DEV Community: OMAR EL AALLAOUI

“Boosting AWS Lambda Performance with Containerization: A Comprehensive Tutorial”

OMAR EL AALLAOUI — Sat, 25 Mar 2023 13:55:40 +0000

AWS Lambda is a serverless computing service that allows you to run code without the need to provision or manage servers. Lambda is ideal for running small, event-driven functions that execute on demand. However, as your application grows and you start processing more events, you may encounter performance issues. To improve the performance of your Lambda functions, you can use containerization. In this article, we will discuss how containerization can boost AWS Lambda performance and provide a comprehensive tutorial on how to containerize your Lambda functions.

What is Containerization?

Containerization is the process of packaging an application along with its dependencies and libraries into a single container image. The container image can then be deployed to any environment that supports containerization, such as Amazon Elastic Container Service (ECS) or Amazon Elastic Kubernetes Service (EKS).

How Containerization Boosts AWS Lambda Performance?

AWS Lambda functions are limited in the amount of memory and CPU they can use, which can lead to performance issues when processing large volumes of events. By containerizing your Lambda functions, you can increase the amount of memory and CPU available to your functions, which can significantly improve performance.

Containerization also allows you to package your Lambda function along with its dependencies and libraries, reducing the size of your deployment package and improving the cold start time of your functions.

How to Containerize Your AWS Lambda Functions?

To containerize your AWS Lambda functions, follow these steps:

Step 1: Create a Dockerfile The first step in creating a Lambda function using a container image is to create a Dockerfile. The Dockerfile is used to define the image that will be used to run the Lambda function. In the Dockerfile, you need to specify the base image, copy the code and dependencies, and define the command that will be used to run the Lambda function.

Here is an example Dockerfile for a Python-based Lambda function:

FROM public.ecr.aws/lambda/python:3.8

COPY app.py requirements.txt ./

RUN pip install --no-cache-dir -r requirements.txt

CMD ["app.lambda_handler"]

This Dockerfile starts with the public.ecr.aws/lambda/python:3.8 base image, copies the app.py file and the requirements.txt file to the image, installs the dependencies specified in the requirements.txt file using pip, and sets the command to run the lambda_handler function in the app.py file.

Step 2: Build and Push the Container Image to ECR Once you have created the Dockerfile, you need to build and push the container image to Amazon Elastic Container Registry (ECR). ECR is a fully-managed container registry that makes it easy to store, manage, and deploy Docker container images.

To build the container image, run the following command in the directory containing the Dockerfile:

docker build -t my-lambda-image .

This command builds the Docker image using the Dockerfile in the current directory and tags the image with the name my-lambda-image.

To push the container image to ECR, you need to create a repository in the ECR console and follow the instructions to authenticate and push the image. For more information, refer to the ECR documentation.

Step 3: Create a Lambda Function Using the Container Image Once you have built and pushed the container image to ECR, you can create a Lambda function using the container image. To create a Lambda function, go to the Lambda console, select “Create function”, and choose “Container image” as the function type.

In the “Container image” section, enter the name of the ECR repository that contains your container image, select the image tag, and enter the memory allocation and timeout values.

In the “Networking” section, you can configure your Lambda function to connect to a VPC or an Amazon Virtual Private Cloud (VPC).

Finally, in the “Preview” section, you can test your Lambda function by entering the input payload and clicking on “Test”.

Step 4: Deploy and Test the Lambda Function Once you have created the Lambda function, you can deploy and test it. To deploy the Lambda function, click on the “Deploy” button in the Lambda console.

To test the Lambda function, you can use the Test feature in the Lambda console or use the AWS Command Line Interface (CLI) to invoke the function. Here is an example of how to invoke the Lambda function using the AWS CLI:

aws lambda invoke --function-name my-lambda-function --payload '{"name": "Omar"}' response.json

In conclusion, containerizing your AWS Lambda functions can significantly boost their performance, scalability, and cost-effectiveness. By following the steps outlined in this article, you can easily create and deploy container images for your Lambda functions, and optimize them based on your specific requirements. With containerization, you can take full advantage of the benefits of AWS Lambda, and build powerful and efficient serverless applications.

Build your first CRUD API with AWS ☁️

OMAR EL AALLAOUI — Sat, 25 Mar 2023 13:32:06 +0000

“ The purpose of this tutoriel is to build a very simple CRUD (Create , read, update, delete) API. To acheive this we will be guided through a few steps . From the DynamoDB console to the AWS Lambda console , we’ll learn how to create a DynamoDB table and Lambda function. After that, we’ll use the API Gateway interface to configure an HTTP API , and then we’ll use Postman to test your API ! ”

1.Create A DynamoDB Table

**Amazon DynamoDB **is a fully managed NoSQL database service with seamless scalability and quick and predictable performance. You don’t have to worry about hardware provisioning , setup and configuration, replication, software patching, or cluster scalability with DynamoDB because if offloads the administrative requirements of running and managing a distributed database.

To create a DynamoDB table :

Open the DynamoDB console at **https://console.aws.amazon.com/dynamodb/**
Select Create Table

For Table name, enter crud-http-table , for Primary key , enter id and choose create

Our DynamoDB table becomes available after a few seconds .

2. Create A Lambda Function

AWS Lambda is a compute service that allows you to run programs without the need for server provisioning or management. Lambda automatically scales from a few requests per day to thousands per second , running your code only when it’s needed.

We create Lambda function for the backend of your API. this lambda function creates, reads, updates, and deletes (CRUD) items from DynamoDB. The function uses events from API Gateway to determine how to interact with DynamoDB.

To create a Lambda function

Open The Lambda console at **https://console.aws.amazon.com/lambda**
Select Create function

Fill the function name , I will use “ crud-http-function ” for this example , Runtime Node.js 14.x , Under Permissions choose Change default execution role and select Create a new role from AWS policy templates. For Role name , enter “ crud-http-role” **and choose **Simple microservice permissions form Policy templates , this policy grants the Lambda function permission to interact with DynamoDB.

Scroll down to the console’s Code source editor ,open index.js and replace its contents withe the following code.

https://github.com/omaralaoui1/CRUD_API_NODEJS/blob/main/index.js

Choose Deploy to update your function

3. Create an HTPP API

Amazon API Gateway is a fully managed service that makes publishing, maintaining, monitoring, securing, and operating APIs at any size simple for developers.

You can create RESTful APIs with API Gateway using either HTTP APIs or REST APIs. API Gateway, along with AWS Lambda, is the app-facing component of the AWS serverless infrastructure.

To create an HTTP API

Open the API Gateway console at **https://console.aws.amazon.com/apigateway**
Select Create API and choose build for HTTP API

Fill the API name , I will use ‘ crud-http-api ’ for name , for configure routes choose Next to skip route creation . we’ll create routes later .

4. Create routes

Routes are a way to send incoming API requests to backend resources. Routes consist of two parts: an HTTP method and a resource path, for example, GET /items.

For this example API, we create four routes:

GET /items/{id}
GET /items
PUT /items
DELETE /items/{id}

To create routes:

Open the API Gateway console at **https://console.aws.amazon.com/apigateway**
Select your API ( crud-http-api )
On the left panel choose Routes , and select Create

For Method, choose GET
For the path, enter /itemsand choose create **. Repeat the same thing for **GET /items/{id}, DELETE /items/{id}, and PUT /items.

5. Create an integration

To connect a route to backend resources, you construct an integration. These integrations will be attached to a route at a later time. You establish a single Lambda integration for this sample API, which you use for all routes.

To create an integration:

Open the API Gateway console at **https://console.aws.amazon.com/apigateway**
Select your API ( crud-http-api )
On the left panel choose Integrations , and select Manage integrations and then choose Create

For Integration Type, choose Lambda Function and enter “ crud-http-function ”

Choose Create

6. Attach your integration to routes

All routes in this example API use the same AWS Lambda integration.

To attach integrations to routes:

Open the API Gateway console at **https://console.aws.amazon.com/apigateway**
Select your API ( crud-http-api )
On the left panel choose Integrations , and select a route
Under Choose an existing integration , choose “ crud-http-function”

Choose attach integration , Repeat the same thing for all routes .

All routes show that an AWS Lambda integration is attached.

7. Test your API

To make sure that our API is working , we use Postman , an API Platform for building and using APIs.

To get the URL to invoke your API:

Open the API Gateway console at **https://console.aws.amazon.com/apigateway/**
Choose your API , and Note your API’s invoke URL

Copy your API’s invoke URL .

To create an item with PUT Method :

Open Postman and add your API’s URL
Choose PUT Method to send your data to Dynamodb Table through API Gateway and Lambda Function.
Add a request body with item’s ID, first_name , last_name and age .

To get all items :

To delete an item:

Next Steps ….

You can automate the creation of AWS resources by using **AWS CloudFormation *.*
If you enjoyed this article, share it with your friends and colleagues! 😃s

"Docker and WebAssembly: A Love Story ❤️ of Two Technologies Destined to be Together "

OMAR EL AALLAOUI — Sat, 11 Mar 2023 22:28:42 +0000

🚀 “Say goodbye to the old ways of deploying web apps and hello to the dynamic duo of Docker and WebAssembly! Faster, more secure, and endlessly portable. ”

In recent years, both Docker and WebAssembly (WASM) have gained significant popularity in the tech community. Docker provides a way to package applications and their dependencies into lightweight containers that can be deployed and run consistently across different environments. Meanwhile, WebAssembly is a new kind of bytecode that allows developers to run compiled code in the browser at near-native speeds, opening up new possibilities for high-performance web applications. When combined, these two technologies can provide a powerful platform for building and deploying modern web applications that are portable, scalable, and secure.

So, how do Docker and WebAssembly work together? One way is by using Docker to package and deploy WebAssembly applications. Because WebAssembly can be compiled from a variety of languages, it’s possible to build complex applications that run entirely in the browser, without the need for a traditional server-side backend.

Integration between Docker and WebAssembly has been made possible through the use of a tool called WASI (WebAssembly System Interface). WASI provides a standardized interface between WebAssembly modules and the host operating system, allowing developers to write code that can be executed both in the browser and in the Docker container. This makes it possible to build applications that can be deployed in a variety of environments, from desktops and servers to mobile devices and even IoT devices.

One of the main benefits of using Docker and WebAssembly together is portability. Docker containers are designed to be lightweight and easily transportable, making it easy to move an application from one environment to another without having to worry about dependencies or compatibility issues. Meanwhile, WebAssembly modules can be written in a variety of languages, including C, C++, Rust, and even Python, which opens up new possibilities for building web applications that are not limited to JavaScript.

Another benefit of using Docker and WebAssembly together is performance. WebAssembly modules can be compiled to run at near-native speeds, which makes it possible to build high-performance web applications that can compete with native desktop applications. Docker containers provide a way to isolate and optimize the execution environment for a specific application, which can further improve performance and scalability.

To demonstrate the power of Docker and WebAssembly integration, let’s walk through a simple example.

1. Write a C program that prints "Hello, world!" to the console.

#include <stdio.h>

int main() {
    printf("Hello, world!\n");
    return 0;
}

2. Compile the program to WebAssembly using Emscripten.

emcc hello.c -o hello.wasm

3. Create a Dockerfile that defines the container environment and copies the WebAssembly module into the container.

FROM ubuntu:latest

WORKDIR /app

COPY hello.wasm .

CMD ["wasmtime", "hello.wasm"]

4. Build the Docker container using the Docker build command.

docker build -t wasm-demo .

5. Run the Docker container using the Docker run command.

docker run wasm-demo

6. Verify that the "Hello, world!" message is printed to the console.

In this demo, we've created a simple C program that prints "Hello, world!" to the console, and compiled it to WebAssembly using the Emscripten toolchain. We've also created a Dockerfile that defines the container environment and copies the WebAssembly module into the container. Finally, we've built and run the Docker container to execute the WebAssembly module and print the "Hello, world!" message to the console.

The impact of using Docker and WebAssembly together in web development is significant. By enabling high-performance web applications that can be deployed anywhere, developers can build more powerful and scalable web applications than ever before. With the ability to package applications into lightweight and portable containers, deployment and scaling become much simpler, allowing developers to focus on building great applications instead of worrying about infrastructure.

In conclusion, integrating Docker and WebAssembly can provide significant benefits in terms of portability, performance, security, productivity, and collaboration. By leveraging the strengths of these two technologies, developers can create high-performance, secure, and portable web applications that can run anywhere. Whether you are building a new web application from scratch or optimizing an existing one, it is worth considering the potential benefits of integrating Docker and WebAssembly.

Manage AWS services directly from Kubernetes ☸️

OMAR EL AALLAOUI — Sat, 11 Mar 2023 20:40:30 +0000

Manage AWS services directly from Kubernetes ☸️

Using Kubernetes in production often requires integration with various AWS services such as S3, RDS, SQS, etc. Developers or Kubernetes cluster admins have had to manage the containerized application and the associated AWS services separately.

To solve this complexity, the AWS team has released the ACK project, which allows users to control both the application and AWS services from a single location using the Kubernetes CLI.

*AWS Controllers for Kubernetes (ACK) *⤵️

AWS Controllers for Kubernetes (ACK) is an open-source project which defines a framework to build custom controllers (or Kubernetes Operators) for AWS services. Developers or cluster admins can define, create, deploy, control, update, delete, and manage Amazon services directly from within Kubernetes clusters using these custom controllers.

ACK controllers now allow centralized management through the Kubernetes CLI. You can now manage both Kubernetes-native applications and the associated AWS services, using the same Kubernetes API.

🚀 Demo : Creating S3 Bucket From Kubernetes

🚀 Install the ACK service controller for S3 with helm

Before installing a Helm chart, you must first make the Helm chart available on the deployment host. To do so, use the helm pull command and then extract the chart:

export HELM_EXPERIMENTAL_OCI=1

export HELM_EXPERIMENTAL_OCI=1 
export SERVICE=s3 
export RELEASE_VERSION=`curl -sL https://api.github.com/repos/aws-controllers-k8s/s3-controller/releases/latest | grep '"tag_name":' | cut -d'"' -f4` 
export CHART_EXPORT_PATH=/tmp/chart 
export CHART_REF=$SERVICE-chart 
export CHART_REPO=public.ecr.aws/aws-controllers-k8s/$CHART_REF export CHART_PACKAGE=$CHART_REF-$RELEASE_VERSION.tgz  
mkdir -p $CHART_EXPORT_PATH  
helm pull oci://$CHART_REPO --version $RELEASE_VERSION -d $CHART_EXPORT_PATH 
tar xvf $CHART_EXPORT_PATH/$CHART_PACKAGE -C $CHART_EXPORT_PATH

Once the Helm chart is downloaded and exported, you can install a particular ACK service controller using the helm install command:

export ACK_SYSTEM_NAMESPACE=ack-system 
export AWS_REGION=us-west-2  
helm install --create-namespace --namespace $ACK_SYSTEM_NAMESPACE ack-$SERVICE-controller \     
--set aws.region="$AWS_REGION" \     
$CHART_EXPORT_PATH/$SERVICE-chart

The commands above set the target service region of the S3 controller to us-west-2. Be sure to specify your target service region in the AWS_REGION variable. This will be the default AWS region in which resources will be created by the ACK service controller.

🚀 Configuring credentials

There are multiple ways in which you can configure an ACK service controller to use a particular set of AWS credentials:

Web identity token file (recommended) #
Shared credentials file
Access key and secret access key environment variables

in our case, we will use the third method.

Use access key and secret access key environment variables

you set manually the AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY environment variables on the ACK service controller’s Pod:

kubectl -n ack-system set env deployment/ack-s3-controller-s3-chart
\     
AWS_ACCESS_KEY_ID="$AWS_ACCESS_KEY_ID" \     AWS_SECRET_ACCESS_KEY="$AWS_SECRET_ACCESS_KEY"

🚀 Create an ACK Resource

⚡️ Create a S3 Bucket

Create and apply the manifest ⤵️

✔️ Check created S3Bucket

Conclusion

➡️ Using ACK to create AWS resources is a huge plus for those who love managing AWS resources via k8s manifests within the Kubernetes Cluster.

— — — — — — — — — — — — — — — — — — — — — — — — — — — — OMAR