Clearing AWS CloudFront Cache: AWS Lambda, Python

Managing cache invalidation is crucial for delivering updated content to users. AWS CloudFront, a popular Content Delivery Network (CDN), allows you to clear cached content by creating an invalidation. This tutorial demonstrates how to create an AWS Lambda function to automate CloudFront cache invalidation using Boto3, the AWS SDK for Python.

Implementation

1. Set Up Environment Variables

First, set up an environment variable DISTRIBUTION_ID which holds the ID of your CloudFront distribution. This can be done in the Lambda console under the "Configuration" tab or through the AWS CLI.

2. Lambda Function code:

import boto3
import json
import os
from datetime import datetime

def lambda_handler(event, context):
    cloudfront = boto3.client('cloudfront'),
    
    distribution_id = os.getenv('DISTRIBUTION_ID')
    
    if not distribution_id:
        return {
            'statusCode': 400,
            'body': json.dumps('Environment variable DISTRIBUTION_ID not set')
        }
    
    try:
        response = cloudfront.create_invalidation(
            DistributionId=distribution_id,
            InvalidationBatch={
                'Paths': {
                    'Quantity': 1,
                    'Items': ['/*']
                },
                'CallerReference': str(context.aws_request_id)
            }
        )
        
        # Convert datetime objects to strings recursively in the response
        def convert_datetime(obj):
            if isinstance(obj, datetime):
                return obj.isoformat()
            elif isinstance(obj, dict):
                return {k: convert_datetime(v) for k, v in obj.items()}
            elif isinstance(obj, list):
                return [convert_datetime(i) for i in obj]
            else:
                return obj

        return {
            'statusCode': 200,
            'body': json.dumps(convert_datetime(response))
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps(str(e))
        }

3. Explanation of the Code

• Environment Variable Check: The function first checks if the DISTRIBUTION_ID environment variable is set. If not, it returns a 400 status code with an error message.
• Creating Invalidation: The cloudfront.create_invalidation method is called to create an invalidation for the specified distribution. The invalidation path is set to /* to clear the entire cache.
• Handling Response: The response from the create_invalidation call contains datetime objects. A helper function convert_datetime is used to recursively convert these datetime objects to strings for JSON serialization.
• Error Handling: If any exception occurs during the process, the function catches it and returns a 500 status code with the error message.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "cloudfront:CreateInvalidation"
            ],
            "Resource": "*"
        }
    ]
}

This policy allows the Lambda function to create invalidations in any CloudFront distribution.

Testing the Function

Invoke the function manually or set up a trigger (e.g., an API Gateway, S3 event, etc.) to test if it invalidates the CloudFront cache as expected.

Conclusion

By following these steps, you have automated the process of invalidating AWS CloudFront cache using a Lambda function. This ensures that your users always get the most up-to-date content. Feel free to extend this function to handle specific paths or integrate it into your deployment pipeline for automatic cache invalidation on updates.

Optimize your content delivery process by implementing this automated CloudFront cache invalidation solution today! Follow the steps in this tutorial to ensure your users always receive the latest content, enhancing their overall experience.