AWS Lambda is a serverless computing platform offered by Amazon Web Services (AWS) that allows developers to run code without having to provision or manage servers.
This is a perfect solution for executing small tasks, as it only requires a minimal amount of administration and is cost-effective as you only pay for what you use.
In this blog post, we will be exploring how to use Python and AWS Lambda to develop and deploy a simple application.
1. Setting up an AWS Account and Boto3.
I’ve already covered this is my previous post, if you haven’t already seen please have a look at:
Using Python with AWS: A Beginner’s Guide
Once you have created your account, you can log in to the AWS Management Console and navigate to the AWS Lambda dashboard.
2. Creating a Python Function
AWS Lambda allows you to run code written in a number of different programming languages, including Python.
To get started, we need to create a Python function that will be executed by AWS Lambda when a specific event occurs.
This function can be as simple or as complex as you need it to be.
For this example, we will create a simple Python function that takes a string as input and returns the string reversed.
The code for this function is as follows:
AWS Lambda and Python: A Beginner’s Guide
def reverse_string(event, context):
return event['input_string'][::-1]
In this example, the function takes two parameters: event and context.
The event parameter contains the data that is passed to the function, and the context parameter contains information about the runtime environment of the function.
The function returns the reversed string.
3. Deploying the Python function to AWS Lambda
Now we’ll deploy this function on AWS Lambda service.
You can create a Lambda function using the AWS Management Console or the AWS CLI.
In this post, we will be using the AWS Management Console to create a Lambda function.
To create a Lambda function using the AWS Management Console:
- Go to the AWS Management Console.
- Click on the Services dropdown menu and select Lambda.
- Click on the Create Function button.
- Choose the Author from Scratch option.
- Give your function a name and choose Python 3.7 as the runtime.
- Choose the Create Function button.
Once we have created our function, we can test it by using the built-in test feature in the AWS Lambda dashboard.
To test our function, we need to create a test event and specify the input_string parameter.
After we have created the test event, we can click the “Test” button to run the function and see the output.
4. Invoking an AWS Lambda Function using Boto3
Once you have created a Lambda function, you can invoke it using Boto3.
To invoke a Lambda function using Boto3, you need to create a client object and call the invoke method.
The following code demonstrates how to invoke an AWS Lambda function using Boto3:
import boto3
client = boto3.client('lambda')
response = client.invoke(
FunctionName='reverse_string',
InvocationType='RequestResponse'
)
print(response)
In the code above, we first create a client object for the Lambda service.
We then call the invoke method on the client object, passing in the name of our Lambda function and the invocation type.
5. Integrating AWS Lambda with Other AWS Services
One of the key benefits of using AWS Lambda is that it can be easily integrated with other AWS services.
For example, we can trigger our AWS Lambda function when a new file is uploaded to Amazon S3, or when a new message is added to an Amazon Kinesis stream.
To integrate our AWS Lambda function with other AWS services, we need to create an event source.
An event source is a configuration that specifies the type of event that will trigger our function and the AWS service that will be providing the data for the event.
In this example, we will be integrating our AWS Lambda function with Amazon S3.
To do this, we will create a new event source in the AWS Lambda dashboard and select Amazon S3 as the event source type.
We will then specify the S3 bucket that will trigger our function and the events that will trigger the function (e.g., object created, object deleted).
import boto3
def lambda_handler(event, context):
# Create an S3 client
s3 = boto3.client("s3")
# Get the bucket name from the event
bucket_name = event["Records"][0]["s3"]["bucket"]["name"]
# Get the file name from the event
file_name = event["Records"][0]["s3"]["object"]["key"]
# Download the file from S3
response = s3.get_object(Bucket=bucket_name, Key=file_name)
# Get the contents of the file
file_content = response["Body"].read().decode("utf-8")
# Do some processing on the file contents
processed_content = process_file(file_content)
# Upload the processed content to a new S3 file
s3.put_object(Bucket=bucket_name, Key="processed/" + file_name, Body=processed_content)
def process_file(file_content):
# Your code for processing the file contents goes here
return processed_content
In this code, we have defined a Lambda function lambda_handler that is triggered when a file is uploaded to an S3 bucket.
The function uses the Boto3 S3 client to download the file from the S3 bucket and get its contents.
The contents of the file are then processed using the process_file function and the processed content is uploaded to a new S3 file in the same bucket with the key processed/[original file name].
This is a simple example of how to integrate an AWS Lambda function with Amazon S3 using the Boto3 library.
The possibilities are endless, and you can do much more complex processing on the file contents using this setup.
Conclusion
In this post, we have explored how to use the Python programming language to interact with AWS Lambda using the AWS management console as well as boto3 library.
We have seen how to install Boto3, set up AWS credentials, create an AWS Lambda function, and invoke an AWS Lambda function using Boto3.
With these basics in hand, you are now ready to start building your own AWS Lambda functions using Python and Boto3 library.
Hope you liked this post and learned something new today 🙂
Do not forget to follow *only* if you are finding any value add with my posts!