Forem: awedis

Building and Shipping Apps Faster with Kiro’s Agentic Power - (Let's Build 🏗️ Series)

awedis — Wed, 04 Mar 2026 19:51:28 +0000

What if you could go from a blank screen to a fully deployed serverless API — API Gateway, Lambda, DynamoDB, and all — in under an hour? Kiro, AWS's agentic IDE, makes that possible. You describe what you want in plain English, and Kiro generates the spec, the infrastructure, and the application code.

In this article, I'll walk you through building a complete serverless CRUD API with Kiro and Terraform.

The main parts of this article:
1- About Kiro
2- Building a Serverless REST API with Kiro (API Gateway + Lambda + DynamoDB)
3- Key Takeaways

About

Kiro is an agentic development environment that makes it easy for developers to ship real engineering work with the help of AI agents. Kiro is our answer to the question “what would a development environment look like if it could take full advantage of AI?”

Kiro operates as a standalone IDE (a fork of VS Code), which makes the environment feel very familiar.

After downloading it from their website, I authenticated using my AWS Builder ID — the process was simple and straightforward.

Building a Serverless REST API with Kiro (API Gateway + Lambda + DynamoDB)

Prerequisites

AWS account with credentials configured
Node.js installed
Kiro IDE installed (https://kiro.dev)
Terraform installed (https://developer.hashicorp.com/terraform/install)

Step 1: Create a New Project in Kiro

Open Kiro IDE
Create a new project folder (e.g. kiro-serverless-api)
Open the project in Kiro

Step 2: Write a Spec (Kiro's Spec-Driven Development)

Open Kiro's spec panel
Describe what you want to build in natural language:

"Build a CRUD REST API for managing tasks. Each task has an id, title, description, status, and createdAt. Use API Gateway for HTTP endpoints, Lambda for handlers, and DynamoDB for storage. Use Terraform for infrastructure."

Kiro will generate a spec, design doc, and task list
Review and approve the generated plan

Step 3: Let Kiro Generate the Code

Kiro will create the project structure:

Walk through each task Kiro generates and approve the code

Step 4: Review the Generated Infrastructure (Terraform)

DynamoDB table with partition key (id)
Lambda functions for each CRUD operation (create, get, list, update, delete)
API Gateway REST API with routes mapped to Lambda functions
IAM roles granting Lambda access to DynamoDB

Step 5: Review the Generated Lambda Handlers

Here is an example of a snippet that represents a spec task checklist item within a Spec-Driven Workflow.

- [ ] 4.2 Create API Gateway methods
    - Define POST method on `/tasks` for task creation
    - Define GET method on `/tasks` for listing all tasks
    - Define GET method on `/tasks/{id}` for retrieving specific task
    - Define PUT method on `/tasks/{id}` for updating task
    - Define DELETE method on `/tasks/{id}` for deleting task
    - Set authorization to NONE for all methods
    - _Requirements: 7.1, 7.4_

Step 6: Install Dependencies

npm install

Step 7: Deploy to AWS

cd infra
terraform init
terraform plan (review what will be created)
terraform apply (confirm with "yes")
Note the API Gateway endpoint URL from the output

Step 8: Test the API

Make sure all endpoints are functioning as expected.

Step 9: Cleanup

cd infra && terraform destroy (confirm with "yes")

That’s it — in under one hour, you were able to build a fully functional serverless application by following a spec-driven workflow. This approach gives you the opportunity to review and validate each task individually, while allowing you to refine, adjust, or even change minor details as you go. 😎

Key Takeaways

Kiro's spec-driven approach: describe -> spec -> design -> tasks -> code
Kiro generates Terraform HCL files for AWS infrastructure
Lambda handlers and API routes are generated from the spec
Infrastructure and application code are created together
End result: a fully deployed serverless API with minimal manual coding

Happy coding 👨🏻‍💻

💡 Enjoyed this? Let’s connect and geek out some more on LinkedIn.

Hands-On with AWS Lambda Durable Functions & Callback ⚡⏳🚀 - (Let's Build 🏗️ Series)

awedis — Sun, 21 Dec 2025 10:52:19 +0000

AWS made many new announcements at re:Invent 2025, and one of the highlights is AWS Lambda Durable Functions: New Lambda capability lets you build applications that coordinate multiple steps reliably over extended periods—from seconds to up to one year—without paying for idle compute time when waiting for external events or human decisions.

People who know me are aware that I’m a strong advocate of Step Functions. I love decoupling and building event-driven architectures, so when AWS announced Lambda Durable Functions, I got excited and wanted to try it out 😊

In this article, we’ll create a system to showcase how Durable Functions handle callbacks in real-world workflows.

The main parts of this article:
1- 🧩 Basic concepts
2- 🏗️ Understanding Durable Function Code
3- 🧪 Human-in-the-loop Approvals (Full Example)
4- 📊 Monitoring

🧩 Basic concepts

When creating a new AWS Lambda function, you’ll now see the option to enable Durable Execution.

Now, let’s select Python 3.14 and create our new function. Once it’s created, you’ll see the default code generated by AWS.

from aws_durable_execution_sdk_python.config import Duration
from aws_durable_execution_sdk_python.context import DurableContext, StepContext, durable_step
from aws_durable_execution_sdk_python.execution import durable_execution

@durable_step
def my_step(step_context: StepContext, my_arg: int) -> str:
    step_context.logger.info("Hello from my_step")
    return f"from my_step: {my_arg}"

@durable_execution
def lambda_handler(event, context) -> dict:
    msg: str = context.step(my_step(123))

    context.wait(Duration.from_seconds(10))

    context.logger.info("Waited for 10 seconds without consuming CPU.")

    return {
        "statusCode": 200,
        "body": msg,
    }

Once you’ve created the Durable Lambda function, you’ll notice a new tab labeled “Durable Executions.”

🏗️ Understanding Durable Function Code

The withDurableExecution wrapper
Your durable function is wrapped with withDurableExecution. This wrapper enables durable execution by providing the DurableContext object and managing checkpoint operations.

The DurableContext object
Instead of the standard Lambda context, your function receives a DurableContext. This object provides methods for durable operations like step() and wait() that create checkpoints.

Steps and checkpoints
Each context.step() call creates a checkpoint before and after execution. If your function is interrupted, it resumes from the last completed checkpoint. The function doesn't re-execute completed steps. It uses their stored results instead.

Wait operations
The context.wait() call pauses execution without consuming compute resources. When the wait completes, Lambda invokes your function again and replays the checkpoint log, substituting stored values for completed steps.

Replay mechanism
When your function resumes after a wait or interruption, Lambda runs your code from the beginning. However, completed steps don't re-execute. Lambda replays their results from the checkpoint log. This is why your code must be deterministic.

🧪 Human-in-the-loop Approvals (Full Example)

How the flow works:

┌──────────────────────────┐
│  Event / API / Trigger   │
│  (API Gateway, S3, Cron) │
└─────────────┬────────────┘
              │
              ▼
┌──────────────────────────┐
│  Durable Lambda Function │
│  (Orchestrator)          │
│                          │
│  1. Start execution      │
│  2. Do initial steps     │
│  3. Create callback ID   │
│  4. Send human request   │
│     (email, UI, system)  │
│  5. WAIT (paused)        │
└─────────────┬────────────┘
              │
              │  Callback ID
              │
              ▼
┌──────────────────────────┐
│  Human Interaction Layer │
│                          │
│  • Web UI                │
│  • Internal tool         │
│  • Approval system       │
│                          │
│  User approves / rejects │
└─────────────┬────────────┘
              │
              │ API call with:
              │ - callbackId
              │ - decision
              │
              ▼
┌──────────────────────────┐
│  API Gateway             │
└─────────────┬────────────┘
              │
              ▼
┌──────────────────────────┐
│  Callback Lambda         │
│                          │
│  • Validates request     │
│  • Calls                 │
│    send_durable_execution│
│    _callback_success     │
│    or failure            │
└─────────────┬────────────┘
              │
              ▼
┌──────────────────────────┐
│  Durable Lambda Function │
│  (Resumed)               │
│                          │
│  • Receives callback     │
│  • Continues workflow    │
│  • Approve / Reject path │
│  • Finish execution      │
└──────────────────────────┘

Now, let’s start adding our callback logic, and wait mechanism. The Durable Lambda pauses execution, emits a callback ID, and resumes only when an external system—or a human—explicitly signals completion. This pattern enables human approvals, long-running workflows, and event-driven orchestration without polling or managing state machines.

from aws_durable_execution_sdk_python.context import DurableContext, StepContext, durable_step
from aws_durable_execution_sdk_python.execution import durable_execution
from aws_durable_execution_sdk_python.config import CallbackConfig, Duration
from time import sleep

@durable_step
def _send_approval_request(
    step_context: StepContext,
    documentId: str,
    reviewers: str,
    callbackId: str
) -> str:
    # send API call to third party service
    # notify/validate human interaction here

    return f"_send_approval_request: {documentId} {reviewers} {callbackId}"

@durable_step
def _step(step_context: StepContext, my_arg: int) -> str:
    step_context.logger.info("Hey there from _step")
    sleep(5)
    return f"_step: {my_arg}"

@durable_execution
def lambda_handler(event, context: DurableContext) -> dict:
    document_id = event['documentId']
    reviewers = event['reviewers']

    context.step(lambda _: _step(1)(_), name="prepare-document")

    callback = context.create_callback(
        name="approval_callback",
        config=CallbackConfig(
            timeout=Duration.from_hours(24),  # Maximum wait time
            heartbeat_timeout=Duration.from_hours(2),  # Fail if no heartbeat for 2 hours
        ),
    )

    callback_id = callback.callback_id
    context.step(lambda _: _send_approval_request(document_id, reviewers, callback_id)(_), name="send-document")
    print('callback_id -> ', callback_id)

    # Wait for result - execution suspends here
    result = callback.result()
    print('result -> ', result)

    if result == 'approve':
        return {
            'status': 'approve',
            'documentId': document_id
        }

    return {
        'status': 'rejected',
        'documentId': document_id,
    }

📋 Note: It’s important to publish new versions of your Durable Functions to be able to test them.

Now, let’s create the Lambda function that will call send_durable_execution_callback_success to resume the Durable Lambda execution.

# Message processor side (separate Lambda or service)
import boto3
import json
from botocore.exceptions import ClientError
print(boto3.__version__)

client = boto3.client('lambda')

def lambda_handler(event, context):
    callback_id = event["callback_id"]
    status = event["status"]

    try:
        client.send_durable_execution_callback_success(
            CallbackId=callback_id,
            Result=status
        )
    except ClientError as e:
        # Notify failure
        return {
            "statusCode": 500,
            "body": json.dumps({
                "error": str(e)
            })
        }
    return {
        "statusCode": 200,
        "message": "Callback Sent"
    }

📋 Note: In my case, I needed to install the latest version of boto3 because the default version bundled with Lambda did not include the newer Lambda Durable Functions APIs. This is how my requirements.txt file looks.

boto3==1.42.13
botocore==1.42.13

Once installed, make sure to upload the artifacts to an S3 bucket and reference them from a Lambda layer attached to this function.

I also attached the following permissions to my Lambda function.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:SendDurableExecutionCallbackSuccess",
                "lambda:SendDurableExecutionCallbackFailure"
            ],
            "Resource": "*"
        }
    ]
}

📋 Note: This can be any AWS service (EC2, ECS, etc.). In my case, I’m using a Lambda function, since it can be easily triggered from API Gateway or even tested directly from the AWS console by running a test invocation.

Result:

To test my Durable Function, I need to provide the following input:

{
  "documentId": "a1234",
  "reviewers": "awedis"
}

Perfect! You can see that our Lambda function has executed. By clicking on “Durable Execution Details,” you can even view the individual steps that were run.

Now, let’s copy the Callback ID generated by our Durable Function and pass it to the Notify Lambda function.

{
  "callback_id": "<YOUR_CALLBACK_ID>",
  "status": "approve"
}

Once executed, you can return to the Durable Execution page, where you should see that the Durable Lambda function has resumed and successfully completed the approval_callback.

Lambda Callback Responder

Main Durable Function

Why this example is powerful?

Human-in-the-loop workflows
Long-running processes (hours/days)
No Step Functions needed
No polling
No state machines
Fully serverless

📊 Monitoring

CloudWatch Metrcis

ApproximateRunningDurableExecutions / Number of durable executions in the RUNNING state

ApproximateRunningDurableExecutionsUtilization / Percentage of your account's maximum running durable executions quota currently in use

DurableExecutionDuration / Elapsed wall-clock time in milliseconds that a durable execution remained in the RUNNING state

DurableExecutionStarted / Number of durable executions that started

DurableExecutionStopped / Number of durable executions stopped using the StopDurableExecution API

DurableExecutionSucceeded / Number of durable executions that completed successfully

DurableExecutionFailed / Number of durable executions that completed with a failure

DurableExecutionTimedOut / Number of durable executions that exceeded their configured execution timeout

DurableExecutionOperations / Cumulative number of operations performed within a durable execution (max: 3,000)

DurableExecutionStorageWrittenBytes / Cumulative amount of data in bytes persisted by a durable execution (max: 100 MB)

📝 Conclusion

In my opinion, AWS Lambda Durable Functions are extremely useful and can be applied to many complex serverless, event-driven architectures. When combined with services like SQS, SNS, or AWS Step Functions, they enable you to build powerful, scalable, and elegant workflows.

Happy coding 👨🏻‍💻

Github Source Code: https://github.com/awedis/aws-lambda-durable-functions-callback

💡 Enjoyed this? Let’s connect and geek out some more on LinkedIn.

Why You Should Use AWS ECR Pull-Through Cache

awedis — Tue, 08 Jul 2025 19:45:38 +0000

Let's say your team is growing, and more development, staging, and production environments are being launched. At some point, you might hit limits when pulling images from public repositories. It happens, right? That's where ECR Pull-Through Cache comes in to solve the issue.

When building containerized applications, developers often rely on public Docker images like nginx, node, or python.

These images are pulled from public registries such as Docker Hub. But pulling from external registries comes with challenges; rate limits, availability, and slower downloads sometimes.

That’s where AWS ECR Pull-Through Cache comes in.

What is Pull-Through Cache?
AWS Elastic Container Registry (ECR) Pull-Through Cache allows you to mirror public container images locally in your own private ECR registry. Once an image is pulled, ECR caches it, and future requests pull from the cache.

Benefits of Using Pull-Through Cache

🚀 Faster Image Downloads
Images are stored inside AWS, closer to your workloads, especially in EC2, EKS, or Lambda, resulting in faster pull times.
🔐 Increased Reliability
Avoid outages or throttling from public registries like Docker Hub, especially under CI/CD load or heavy cluster usage.
🛡️ Security & Governance
Keep a local copy of base images to review, scan, and control what goes into your environments.
📊 Reduced External Dependencies
Pulling from your internal ECR avoids relying on internet connectivity or third-party limits (like Docker Hub’s anonymous rate limits).
💰 Cost-Efficient CI/CD
Speeding up builds and avoiding slow external pulls can reduce CI job time and cut down compute cost.

How It Works (In Simple Terms)
You enable a pull-through cache for a public source (e.g. Docker Hub).

AWS ECR creates a mirror repository like:

aws_account_id.dkr.ecr.region.amazonaws.com/docker/library/node

You pull from ECR just like you would from Docker Hub:

docker pull aws_account_id.dkr.ecr.region.amazonaws.com/docker/library/node:18

Example Use Case
Your CI/CD pipeline builds 10 microservices based on node:18. With pull-through caching, the first pull goes to Docker Hub, then ECR caches it, and now all future builds get it instantly from ECR (faster, reliable, and not rate-limited). 😎

Final Thoughts
If you're using Docker images from public registries in AWS environments, enabling ECR Pull-Through Cache is a no-brainer. It speeds up builds, adds reliability, and reduces reliance on third-party services.

Happy coding 👨🏻‍💻

💡 Enjoyed this? Let’s connect and geek out some more on LinkedIn.

Voice-to-Insights with Amazon Bedrock, Comprehend & AWS Lambda - (Let's Build 🏗️ Series)

awedis — Sun, 11 May 2025 18:11:03 +0000

Let’s build an application that processes audio uploads, such as podcast snippets, meeting recordings, or voice notes, by automatically transcribing the audio to text, summarizing the main points, analyzing sentiment and topics, and delivering the results through an API.

The main parts of this article:
1- 💡 Tech Stack (AWS Services)
2- 🎯 Technical Part (Code)
3- 📝 Conclusion

💡 Tech Stack (AWS Services)

We are going to use several AWS services: AWS Lambda, Amazon S3 Bucket, Amazon Bedrock, Amazon Comprehend.

Amazon S3: The bucket that will hold our .mp3 files.

AWS Lambda: Take an uploaded .mp3 or .wav file, call Amazon Transcribe to convert audio to text then it will use Use Claude (via Bedrock) to summarize and highlight key insights. Use Amazon Comprehend to extract sentiment and topics and finally return everything in a beautiful JSON.

Amazon Bedrock: We will use Claude to summarize and highlight key insights.

Amazon Comprehend: Will help us to extract sentiment and topics.

🎯 Technical Part (Code)

import boto3
import json
import time
from urllib.parse import urlparse, unquote_plus

transcribe = boto3.client('transcribe')
s3 = boto3.client('s3')

def lambda_handler(event, context):
    print("Event:", json.dumps(event))

    bucket = event['Records'][0]['s3']['bucket']['name']
    audio_key = unquote_plus(event['Records'][0]['s3']['object']['key'])

    job_name = f"transcription-{int(time.time())}"
    file_uri = f"s3://{bucket}/{audio_key}"

    transcribe.start_transcription_job(
        TranscriptionJobName=job_name,
        Media={'MediaFileUri': file_uri},
        MediaFormat=audio_key.split('.')[-1],
        LanguageCode='en-US',
        OutputBucketName=bucket
    )

    while True:
        status = transcribe.get_transcription_job(TranscriptionJobName=job_name)
        if status['TranscriptionJob']['TranscriptionJobStatus'] in ['COMPLETED', 'FAILED']:
            break
        time.sleep(5)

    if status['TranscriptionJob']['TranscriptionJobStatus'] == 'FAILED':
        raise Exception("Transcription failed")

    transcript_uri = status['TranscriptionJob']['Transcript']['TranscriptFileUri']
    parsed = urlparse(transcript_uri)
    transcript_bucket = parsed.path.split('/')[1]
    transcript_key = '/'.join(parsed.path.split('/')[2:])

    obj = s3.get_object(Bucket=transcript_bucket, Key=transcript_key)
    transcript_data = json.loads(obj['Body'].read())

    transcript_text = transcript_data['results']['transcripts'][0]['transcript']
    print("--> Transcribed Text:\n", transcript_text)

Once we run the start_transcription_job function, it converts the audio to text and saves the files inside the S3 bucket.

Also you can see that the transcribed file is placed inside the same S3 bucket.

Perfect! We've successfully converted our .mp3 files to text, now let's take it further by adding Amazon Comprehend for sentiment and topic analysis, and Amazon Bedrock for intelligent summarization.

comprehend = boto3.client('comprehend')
bedrock = boto3.client('bedrock-runtime')

BEDROCK_MODEL_ID = "anthropic.claude-3-sonnet-20240229-v1:0"

sentiment = comprehend.detect_sentiment(Text=transcript_text[:5000], LanguageCode='en')
summary = summarize_with_claude(transcript_text)

def summarize_with_claude(text):
    prompt = f"""Summarize this meeting or speech in clear bullet points, highlight any action items or topics discussed:\n\n{text[:4000]}"""

    body = {
        "prompt": f"\n\nHuman: {prompt}\n\nAssistant:",
        "max_tokens_to_sample": 500,
        "temperature": 0.7,
        "top_k": 250,
        "top_p": 0.9,
        "stop_sequences": ["\n\nHuman:"]
    }

    response = bedrock.invoke_model(
        modelId=BEDROCK_MODEL_ID,
        body=json.dumps(body),
        contentType="application/json",
        accept="application/json"
    )

    response_body = json.loads(response['body'].read())
    return response_body.get("completion", "No summary generated.")

Also make sure the enable the right Model inside the AWS console.

Now to test the function, input the following json:

{
  "Records": [
    {
      "s3": {
        "bucket": {
          "name": "<YOUR_S3_BUCKET>"
        },
        "object": {
          "key": "AD-CONAF-2019BC-MID-JPWiser-v2.mp3"
        }
      }
    }
  ]
}

Also make sure the Lambda has the required permissions and add the timeout of Lambda function:

{
    "Version": "2012-10-17",
    "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "s3:GetObject",
            "s3:PutObject",
            "transcribe:StartTranscriptionJob",
            "transcribe:GetTranscriptionJob",
            "comprehend:DetectSentiment",
            "bedrock:InvokeModel"
          ],
          "Resource": "*"
        }
    ]
}

Now let us try to test the code. Go to AWS Lambda Test section, and input the required json and run the script.

Finally here is the full code for our Lambda function:

import boto3
import json
import time
from urllib.parse import urlparse, unquote_plus

transcribe = boto3.client('transcribe')
comprehend = boto3.client('comprehend')
bedrock = boto3.client('bedrock-runtime')
s3 = boto3.client('s3')

BEDROCK_MODEL_ID = "eu.anthropic.claude-3-7-sonnet-20250219-v1:0"

def lambda_handler(event, context):
    print("Event:", json.dumps(event))

    bucket = event['Records'][0]['s3']['bucket']['name']
    audio_key = unquote_plus(event['Records'][0]['s3']['object']['key'])

    job_name = f"transcription-{int(time.time())}"
    file_uri = f"s3://{bucket}/{audio_key}"

    transcribe.start_transcription_job(
        TranscriptionJobName=job_name,
        Media={'MediaFileUri': file_uri},
        MediaFormat=audio_key.split('.')[-1],
        LanguageCode='en-US',
        OutputBucketName=bucket
    )

    while True:
        status = transcribe.get_transcription_job(TranscriptionJobName=job_name)
        if status['TranscriptionJob']['TranscriptionJobStatus'] in ['COMPLETED', 'FAILED']:
            break
        time.sleep(5)

    if status['TranscriptionJob']['TranscriptionJobStatus'] == 'FAILED':
        raise Exception("Transcription failed")

    transcript_uri = status['TranscriptionJob']['Transcript']['TranscriptFileUri']
    parsed = urlparse(transcript_uri)
    transcript_bucket = parsed.path.split('/')[1]
    transcript_key = '/'.join(parsed.path.split('/')[2:])

    obj = s3.get_object(Bucket=transcript_bucket, Key=transcript_key)
    transcript_data = json.loads(obj['Body'].read())

    transcript_text = transcript_data['results']['transcripts'][0]['transcript']
    print("--> Transcribed Text:\n", transcript_text)

    sentiment = comprehend.detect_sentiment(Text=transcript_text[:5000], LanguageCode='en')
    summary = summarize_with_claude(transcript_text)
    return {
        "statusCode": 200,
        "body": {
            "summary": summary,
            "sentiment": sentiment,
            "transcription": transcript_text[:500],
        }
    }

def summarize_with_claude(text):
    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 200,
        "top_k": 250,
        "stop_sequences": [],
        "temperature": 1,
        "top_p": 0.999,
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Summarize this meeting or speech in clear bullet points, "
                            "highlight any action items or topics discussed:\n\n"
                            + text[:4000]
                        )
                    }
                ]
            }
        ]
    }

    response = bedrock.invoke_model(
        modelId=BEDROCK_MODEL_ID,
        body=json.dumps(body),
        contentType="application/json",
        accept="application/json",
    )

    response_body = json.loads(response["body"].read())
    return response_body.get("content", "No summary generated.")

Perfect, we can see our code generated the Sentiment analysis data, and also summarized bullet points of our audio file.

📝 Conclusion

Combining multiple AWS services allows you to build truly innovative systems. In this example, we demonstrated how using a few straightforward services can result in a production-ready application with real-world applications across various industries. I hope you found this article helpful!

Happy coding 👨🏻‍💻

💡 Enjoyed this? Let’s connect and geek out some more on LinkedIn.

Tracking 🔍 Deletion Events with AWS Lambda and CloudTrail - (Let's Build 🏗️ Series)

awedis — Thu, 24 Apr 2025 20:20:20 +0000

Imagine if you can automate an alerting system that whenever a user deletes a resource on the AWS cloud you want to send message to specific people.

Well, we are going to create one using two AWS services, AWS Lambda and CloudTrail.

The main parts of this article:
1- About AWS Services
2- Technical Part (Python code)
3- Conclusion

About AWS Services

1- AWS Lambda: AWS Lambda is a compute service that runs your code in response to events and automatically manages the compute resources, making it the fastest way to turn an idea into a modern, production, serverless applications.

2- AWS CloudTrail: AWS CloudTrail is an AWS service that helps you enable operational and risk auditing, governance, and compliance of your AWS account. Actions taken by a user, role, or an AWS service are recorded as events in CloudTrail. Events include actions taken in the AWS Management Console, AWS Command Line Interface, and AWS SDKs and APIs.

Architecture overview

Before running the Lambda function, make sure CloudTrail logging is enabled. Go to the CloudTrail console, navigate to the Trails section, and create a trail if one doesn't already exist. Ensure that the trail is configured to deliver logs to an S3 bucket, as the Lambda function reads CloudTrail logs directly from S3.

Also make sure the Lambda function has the correct IAM role permissions to interact with S3 bucket.

import json
import boto3
import gzip
import io

def get_deleted_events(records):
    deletion_events = []
    for record in records:
        if record.get("eventName") and "Delete" in record["eventName"]:
            deletion_events.append(record)
    return deletion_events

def lambda_handler(event, context):
    s3_client = boto3.client("s3")

    for record in event["Records"]:
        bucket_name = record["s3"]["bucket"]["name"]
        object_key = record["s3"]["object"]["key"]

        response = s3_client.get_object(Bucket=bucket_name, Key=object_key)

        with gzip.GzipFile(fileobj=io.BytesIO(response["Body"].read()), mode='rb') as file:
            cloudtrail_logs = json.loads(file.read().decode("utf-8"))

        deletion_events = get_deleted_events(cloudtrail_logs.get("Records", []))

        if deletion_events:
            print(f"Found {len(deletion_events)} deletion event(s):")
            for event in deletion_events:
                print(json.dumps(event, indent=2))
        else:
            print("No deletion events found in this log file.")

    return {"statusCode": 200, "body": "Processed CloudTrail logs."}

Now in order to test this we need to input the following object:

{
  "Records": [
    {
      "s3": {
        "bucket": {
          "name": "<Your bucket name>"
        },
        "object": {
          "key": "<the object that ends .json.gz inside the folder>"
        }
      }
    }
  ]
}

Now in order to test, I will delete a Lambda function that I don't need it. And then take the latest Cloudtrail log from S3.

Great, the Lambda function successfully detected the deletion event.
To further enhance this solution, you can update the code to process multiple S3 objects in one run, or consider leveraging AWS-native services like AWS Config, AWS CloudTrail Lake, or AWS Security Hub for more scalable and automated deletion tracking across your environment.

Also if you want to notify specific users, consider integrating with services like Amazon SNS or SES.

Conclusion

This Lambda function provides a lightweight and effective way to track deletion events across your AWS account using CloudTrail logs. By automatically processing logs from S3 and printing relevant deletion actions to CloudWatch Logs, it helps improve visibility, audit ability, and security awareness — without needing any additional alerting or external systems.

Happy coding 👨🏻‍💻

💡 Enjoyed this? Let’s connect and geek out some more on LinkedIn.

Automating Cost Management: Creating AWS Budgets with Terraform ⚙️

awedis — Sun, 26 Jan 2025 11:55:29 +0000

When it comes to monitoring, one of the most important things is to automate alarms, budget passes and always be aware of the price changes.

I will show you how to create a Budget using AWS Billing and Cost Management with Terraform in this article.

The main parts of this article:
1- About AWS Services
2- Architecture overview (Terraform)
3- Conclusion

About AWS Services

1- AWS Billing and Cost Management provides a suite of features to help you set up your billing, retrieve and pay invoices, and analyze, organize, plan, and optimize your costs.

To learn more about AWS Billing and Cost Management: Official Page

Architecture Overview

variable "region" {
  default     = "eu-west-1"
  description = "AWS Region to deploy to"
}

terraform {
  required_version = "1.5.1"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "5.84.0"
    }
  }
}

provider "aws" {
  region = var.region
}

resource "aws_budgets_budget" "ec2" {
  name              = "MonthlyBudget"
  budget_type       = "COST"
  limit_amount      = "10"
  limit_unit        = "USD"
  time_unit         = "MONTHLY"

  notification {
    comparison_operator        = "GREATER_THAN"
    threshold                  = 80
    threshold_type             = "PERCENTAGE"
    notification_type          = "FORECASTED"
    subscriber_email_addresses = ["<YOUR_EMAIL_ADDRESS>"]
  }

  tags = {
    Name = "MonthlyBudget"
  }
}

Now let's say you want to add a budget only for certain resources, you can add the following terraform code inside aws_budgets_budget.

cost_filter {
  name = "Service"
  values = [
    "Amazon Elastic Compute Cloud - Compute",
  ]
}

Conclusion

Automating cost management and budget alerting is essential, especially as your team grows, activity on your account increases, and you scale up rapidly. Creating and maintaining budgets to stay on top of your costs is crucial. I hope this article was helpful and informative!

Happy coding 👨🏻‍💻

If you'd like more content like this, please connect with me on LinkedIn.

Build a Smart Chatbot with AWS Lambda, Lex, and Enhanced Sentiment Analysis - (Let's Build 🏗️ Series)

awedis — Sat, 28 Dec 2024 12:19:04 +0000

Let's say you run a company with a customer assistance call center or a website where clients give feedback about your services. After operating for a while your company starts to scale up, more traffic, hence more users sharing their feedback. So it's the right time to begin implementing chatbots and even integrating them with AI.

Alright without further let's jump in. In this article, I will show you how you can create such smart Chatbots using AWS services. Our chatbot will be smart to receive messages from clients, then it will process the user tone, and based (on positive, negative, or neutral) it will categorize the messages using Amazon Comprehend for sentiment analysis.

The main parts of this article:
1- About AWS Services
2- Architecture overview (Terraform)
3- Technical Part (GO code)
4- Result
5- Conclusion

About AWS Services

1- Amazon Lex to handle the chatbot interactions.

To learn more about Amazon Lex: Official Page

2- Amazon Comprehend for sentiment analysis.

To learn more about Amazon Comprehend: Official Page

3- AWS Lambda will coordinate the process by taking input, querying Lex, analyzing the sentiment with Comprehend, and categorizing the message.

To learn more about AWS Lambda: Official Page

Architecture Overview

Our architecture will be serverless, mainly everything will be done event-driven however you can implement something similar using containers.

terraform {
  required_version = "1.5.1"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "5.70.0"
    }
  }
}

provider "aws" {
  region = var.region
}

resource "aws_iam_role" "lambda_execution_role" {
  name = "lets-build-lambda-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17",
    Statement = [
      {
        Action = "sts:AssumeRole",
        Effect = "Allow",
        Principal = {
          Service = "lambda.amazonaws.com"
        }
      }
    ]
  })
}

resource "aws_iam_policy" "lambda_lex_comprehend_policy" {
  name = "lambda_lex_comprehend_policy"
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = [
          "lex:PostText",
          "comprehend:DetectSentiment",
          "logs:*"
        ]
        Resource = "*"
        Effect   = "Allow"
      }
    ]
  })
}

resource "aws_iam_role_policy_attachment" "lambda_policy_attachment" {
  role       = aws_iam_role.lambda_execution_role.name
  policy_arn = aws_iam_policy.lambda_lex_comprehend_policy.arn
}

resource "aws_lambda_function" "chatbot_function" {
  filename         = "./bootstrap.zip"
  function_name    = "lets-build-function"
  handler          = "main"
  role             = aws_iam_role.lambda_execution_role.arn
  memory_size      = "128"
  timeout          = "3"
  source_code_hash = filebase64sha256("./bootstrap.zip")
  runtime          = "provided.al2"
  architectures    = ["arm64"]

  environment {
    variables = {
      LEX_BOT_NAME = "Chatbot"
      LEX_BOT_ALIAS = "Prod"
      REGION = "${var.region}"
    }
  }
}

resource "aws_lambda_permission" "lex_lambda_invocation" {
  statement_id  = "AllowLexInvocation"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.chatbot_function.arn
  principal     = "lex.amazonaws.com"
}

resource "aws_lex_bot" "chatbot" {
  name                      = "Chatbot"
  child_directed            = false
  process_behavior          = "BUILD"
  enable_model_improvements = true
  detect_sentiment          = true

  intent {
    intent_name    = aws_lex_intent.customer_intent.name
    intent_version = aws_lex_intent.customer_intent.version
  }

  abort_statement {
    message {
      content_type = "PlainText"
      content      = "Sorry, I am not able to assist you at this time"
    }
  }
}

resource "aws_lex_intent" "customer_intent" {
  name    = "ExampleIntent"

  sample_utterances = [
    "I need help",
    "Something is not working",
    "Please assist me",
  ]

  fulfillment_activity {
    type = "ReturnIntent"
  }
}

resource "aws_lex_bot_alias" "prod" {
  name    = "Prod"
  bot_name = aws_lex_bot.chatbot.name
  bot_version = aws_lex_bot.chatbot.version
}

output "lex_bot_arn" {
  value = aws_lex_bot.chatbot.arn
}

Technical Part (GO code)

package main

import (
    "context"
    "log"
    "strings"

    "github.com/aws/aws-lambda-go/lambda"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/comprehend"
    "github.com/aws/aws-sdk-go/service/lexruntimeservice"
)

type ChatInput struct {
    Message string `json:"message"`
    UserID  string `json:"user_id"`
}

type ChatOutput struct {
    ResponseMessage string `json:"response_message"`
    Category        string `json:"category"`
}

var lexClient *lexruntimeservice.LexRuntimeService
var comprehendClient *comprehend.Comprehend

func handler(ctx context.Context, chatInput ChatInput) (ChatOutput, error) {
    log.Printf("-- hello --")

    sess := session.Must(session.NewSession())
    lexClient = lexruntimeservice.New(sess)
    comprehendClient = comprehend.New(sess)

    lexResp, err := lexClient.PostText(&lexruntimeservice.PostTextInput{
        BotName:    aws.String("Chatbot"),
        BotAlias:   aws.String("Prod"),
        UserId:     aws.String(chatInput.UserID),
        InputText:  aws.String(chatInput.Message),
    })
    if err != nil {
        log.Printf("Error communicating with Lex: %v", err)
        return ChatOutput{}, err
    }

    responseMessage := aws.StringValue(lexResp.Message)

    compResp, err := comprehendClient.DetectSentiment(&comprehend.DetectSentimentInput{
        Text:     aws.String(chatInput.Message),
        LanguageCode: aws.String("en"),
    })
    if err != nil {
        log.Printf("Error detecting sentiment with Comprehend: %v", err)
        return ChatOutput{}, err
    }

    category := categorizeBySentiment(*compResp.Sentiment)

    return ChatOutput{
        ResponseMessage: responseMessage,
        Category:        category,
    }, nil
}

func categorizeBySentiment(sentiment string) string {
    switch strings.ToLower(sentiment) {
    case "positive":
        return "Positive Feedback"
    case "negative":
        return "Critical Feedback"
    case "neutral":
        return "General Inquiry"
    case "mixed":
        return "Mixed Feedback"
    default:
        return "Uncategorized"
    }
}

func main() {
    lambda.Start(handler)
}

Result

Now let's test by triggering our Lambda function. I will input two different JSONs, one for good feedback and one for bad, and we should be able to detect them.

{
  "user_id": "1234",
  "message": "Something is not working, I need help please"
}

As we can see Amazon Comprehend was able to detect the tone.

responseMessage := aws.StringValue(lexResp.Message)

Since in this section I am returning the response directly from the Lex it returned an empty string, but you can add a response there or even edit the Lambda code to return content.

{
  "user_id": "12345",
  "message": "Thank you, it worked as expected"
}

Here again, it was able to detect that it was positive, but since we had an abort statement as a fallback it returned that content.

Conclusion

In today's world data is everything, and you always need to collect this data (feedback) from your clients, which will lead to the success of your corporation. I hope my article helped you to achieve something or even added some motivation to your to-do tasks.

Happy coding 👨🏻‍💻

If you'd like more content like this, please connect with me on LinkedIn.

Smart File Organizer Using AWS Lambda & S3 - (Let's Build 🏗️ Series)

awedis — Mon, 04 Nov 2024 14:25:58 +0000

Let's say every time a user uploads files to an S3 bucket, you want to move and organize those files in a certain way, meaning if they upload .js I put it inside the /javascript folder, if .txt to the txt folder and so forth.

Is this the use case that you want to build? then this article should be the right one. Alright without further ado let's start with our example.

The main parts of this article:
1- Architecture overview (Terraform)
2- About AWS Services
3- Technical Part (GO code)
4- Result
5- Conclusion

Architecture Overview

In our architecture, we need to make sure that our Lambda function has the right permissions to read and move objects inside the S3 bucket.

📋 Note: If you want to read how to trigger a Lambda function when a new file is uploaded to an S3 bucket, read the following article

Your Lambda function should have the following IAM permissions in order to be able to finish the job successfully.

{
  Version = "2012-10-17",
  Statement = [
  {
    Effect = "Allow",
    Action = [
      "s3:GetObject",
      "s3:PutObject",
      "s3:DeleteObject"
    ],
    Resource = "${aws_s3_bucket.image_bucket.arn}/*"
  }
  ]
}

This is our Terraform Lambda resource section to be able to deploy our function.

resource "aws_lambda_function" "file_organizer_lambda" {
  filename         = "./bootstrap.zip"
  function_name    = "lets-build-function"
  handler          = "main"
  runtime          = "provided.al2"
  role             = aws_iam_role.lambda_execution_role.arn
  memory_size      = "128"
  timeout          = "3"
  source_code_hash = filebase64sha256("./bootstrap.zip")
  environment {
    variables = {
      REGION = "${var.region}"
    }
  }
}

About AWS Services

Amazon S3 will be the service that will store all our files and folders.
AWS Lambda where we will put our simple/smart peace of GO code to the needed job.

Technical Part (GO code)

Alright before writing our fancy code, let's build the idea in our mind first.

So every time the user uploads a new file, we need to trigger a Lambda function, which will check the file extension and based on that it will copy to a certain folder using AWS SDK.

Here is a simple flow diagram to understand better our functionality.

package main

import (
    "context"
    "fmt"
    "path/filepath"
    "strings"

    "github.com/aws/aws-lambda-go/lambda"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

var (
    svc      = s3.New(session.Must(session.NewSession()))
    bucket   = "YOUR_BUCKET_NAME"
)

func generateTargetKey(record map[string]interface{}) (string, string, string) {
    s3Info := record["s3"].(map[string]interface{})
    bucketName := s3Info["bucket"].(map[string]interface{})["name"].(string)
    objectKey := s3Info["object"].(map[string]interface{})["key"].(string)

    ext := strings.ToLower(filepath.Ext(objectKey))

    var folder string
    switch ext {
    case ".js":
        folder = "javascript/"
    case ".txt":
        folder = "txt/"
    default:
        folder = "others/"
    }

    targetKey := folder + filepath.Base(objectKey)
    return bucketName, objectKey, targetKey
}

func handler(ctx context.Context, event map[string]interface{}) (string, error) {
    records := event["Records"].([]interface{})
    for _, record := range records {
        bucketName, objectKey, targetKey := generateTargetKey(record.(map[string]interface{}))

        if objectKey == targetKey {
            fmt.Printf("Skipping copy for %s as it's already in the correct folder.\n", objectKey)
            continue
        }

        _, err := svc.CopyObject(&s3.CopyObjectInput{
            Bucket:     aws.String(bucketName),
            CopySource: aws.String(bucketName + "/" + objectKey),
            Key:        aws.String(targetKey),
        })
        if err != nil {
            return "", fmt.Errorf("failed to copy object: %v", err)
        }

        _, err = svc.DeleteObject(&s3.DeleteObjectInput{
            Bucket: aws.String(bucketName),
            Key:    aws.String(objectKey),
        })
        if err != nil {
            return "", fmt.Errorf("failed to delete original object: %v", err)
        }

        fmt.Printf("File %s moved to %s\n", objectKey, targetKey)
    }
    return "Files processed successfully", nil
}

func main() {
    lambda.Start(handler)
}

📋 Note: Make sure to save the params in your terminal by running the following, set GOARCH=arm64 & set GOOS=linux and to be sure if things are good you can print the value using this cmd echo %GOARCH%

And run the following cmd:

go build -o bootstrap main.go

For Go functions that use the provided.al2 or provided.al2023 runtime in a .zip deployment package, the executable file that contains your function code must be named bootstrap. If you're deploying the function with a .zip file, the bootstrap file must be at the root of the .zip file.

Result

That's it. Let's upload a couple of files to our S3 bucket and see if they are organized as we want.

After uploading we can see the file was moved to the right folder.

Conclusion

You can use such automation in many interesting features and useful applications for your daily tasks. I hope this was a good and beneficial one for you.

Happy coding.

If you'd like more content like this, please connect with me on LinkedIn.

Amazon S3 Object Expiration - (Let's Build 🏗️ Series)

awedis — Thu, 17 Oct 2024 19:07:16 +0000

If you're working with a large amount of data on an AWS S3 bucket, then you need to learn about this S3 feature.

Let's say you wanted to remove objects from the S3 bucket on some conditions, the first thing you could think of is to write a script (eg. in Go) to retrieve the list of files and delete ones older than a certain date. While that's doable, however, it's not the best approach.

The easiest method is to define the Managing lifecycle on the Amazon S3 bucket.

The main parts of this article:
1- About AWS Services (Info)
2- Technical Part (Code)
3- Result
4- Conclusion

About AWS Services (Info)

Let's see how we can manage the lifecycle of objects in our S3 bucket.

You can specify that objects older than a certain number of days should be expired (deleted). The best part is that this happens automatically regularly and you don't need to run your script.

There are two types of actions:

Transition actions - Let you transition objects between different storage classes.
Expiration actions - Let you define expiration time for objects.

📋 Note: If you want to read more about AWS S3 Managing the lifecycle of objects, check out this link

Technical Part (Code)

AWS S3 bucket with Terraform that automatically expires objects older than one day

resource "aws_s3_bucket" "example_bucket" {
  bucket = var.s3_bucket_name

  lifecycle_rule {
    id      = "expire-1-day-old-objects"
    enabled = true
    prefix  = "temporary/"

    expiration {
      days = 1
    }
  }
}

Result

We can see when we uploaded an image inside the /temporary folder, it was removed after 1 day. Here is a picture of what we can see from the AWS console.

Here we can see the "Expiration date" inside the s3 object

Conclusion

In many cases, you need to enable lifecycle policies or expire rules on your object, especially if you are working with a large volume of data. In some cases, you store files on S3 for a temporary reason, or let's say you storing some logs, and we know that logs should be deleted after a certain period (for eg. after 2 months), so bucket lifecycle configuration will be very helpful and easy way to implement it.

Here is the Github Link

If you did like my content, and want to see more, feel free to connect with me on ➡️ LinkedIn, happy to guide or help with anything that needs clarification 😊💁

Trigger Lambda Function From Amazon SQS - (Let's Build 🏗️ Series)

awedis — Wed, 09 Oct 2024 22:57:48 +0000

Let's build a simple architecture where a Lambda function is triggered from Amazon SQS.

The main parts of this article:
1- Architecture Overview (Terraform)
2- About AWS Services (Info)
3- Technical Part (Code)
4- Result
5- Conclusion

Architecture Overview (Terraform)

aws_sqs_queue:

resource "aws_sqs_queue" "my_queue" {
  name = "my_sqs_queue"

  redrive_policy = jsonencode({
    deadLetterTargetArn = aws_sqs_queue.dlq_queue.arn
    maxReceiveCount     = 10
  })
}

aws_lambda_event_source_mapping

resource "aws_lambda_event_source_mapping" "sqs_trigger" {
  event_source_arn = aws_sqs_queue.my_queue.arn
  function_name    = aws_lambda_function.my_lambda.arn
  enabled          = true
  batch_size       = 5
}

The whole project is available on my Github here

About AWS Services (Info)

1- AWS Lambda: To trigger our function and execute the code.
2- Amazon SQS: Amazon Simple Queue Service (Amazon SQS) offers a secure, durable, and available hosted queue to integrate and decouple distributed software systems and components.

Technical Part (Code)

exports.handler = async (event) => {
  try {
    event.Records.forEach(record => {
      const messageBody = record.body;
      console.log("Received message:", messageBody);
    });

    return {
      statusCode: 200,
      body: JSON.stringify({ message: 'Message processed successfully!' })
    };
  } catch (error) {
    console.error("Error processing SQS message:", error);
    return {
      statusCode: 500,
      body: JSON.stringify({ message: 'Error processing message' })
    };
  }
};

Result

Once we apply we can see our Lambda function has been created, and notice that the SQS service has been connected as a trigger.

Now let us test and send a message from the queue and see if the Lambda will be triggered.

To check if my Lambda function was executed successfully, I can check the logs through CloudWatch.

Conclusion

In many cases, you need to build distributed systems with queues, especially when you are processing big traffic and you don't want to lose any data.

Thank you for reading my article.

👉 Follow me for more 👾
LinkedIn
X

How One Code Update ⚡ Supercharged My Python Performance 🚀!

awedis — Tue, 24 Sep 2024 17:59:21 +0000

Hello Pythoners! 🐍

I was experimenting something lately with python code and was able to conduct small experiment that thought would be nice to share it here with you.

Let's say you are doing API calls from python and you are using for loop for example, but that loop will take some time to finish all the requests, and return the responses in a synchronous way. However you can use Async http calls using this library called Aiohttp.

Aiohttp library in Python is an asynchronous HTTP client and server framework that is built on top of the asynchronous I/O library asyncio in Python. Using this library, we can build web applications and RESTful APIs, and also we can handle synchronous HTTP requests in the application.

Here is a simple code example that I tried it, and the performance improvement is shown in the below picture (AWS EC2 Monitoring section).

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = []
        for url in urls:
            tasks.append(fetch_url(url, session))
        await asyncio.gather(*tasks)

In the above picture we can see how much the cpu and network utilization was optimized by this simple code improvement.

Another example: Let’s say you’re processing a large amount of images for resizing. Instead of resizing them one by one, you can use asynchronous programming to handle them concurrently.

Voilà! 🥹 my code now runs much faster.

Conclusion, always remember code optimization is sooo.. important specially when we are living in an era where big amount of resources can be provided by just a click of button. That small peace of code that you are writing right now, one day might actually handle millions of traffic, and hence optimization is so important.

Thank you for reading my article, let's stay connected via the links below

👉 Follow me for more 👾
LinkedIn
X

Why You Should Use AWS Lambda Layers 📦

awedis — Mon, 26 Aug 2024 22:29:30 +0000

If you have worked with AWS Lambda functions, then this article will be beneficial for you.

From my experience, many developers face challenges with code size and dependencies, especially when working with AWS Lambdas. This article offers a straightforward solution that might help you. 🤘

Multiple reasons why you might consider using layers: 🎯

To reduce the size of your deployment packages.
To separate core function logic from dependencies.
To share dependencies across multiple functions.
To use the Lambda console code editor.

So let's dive deep. We are going to create two small applications, the first one without using layers, and the second example with layers. To keep the stack simple I will use AWS SAM (Serverless Application Model)

If you are new to SAM, here is a short description of it; it's an open-source framework for building serverless applications. It provides shorthand syntax to express functions, APIs, databases, and event source mappings.

Stacks

Example 1️⃣

template.yaml (SAM code, where it creates our AWS Lambda function)

AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Description: 'Lambda Function with SAM'

Resources:
  HelloWorldFunctionPython:
    Type: 'AWS::Serverless::Function'
    Properties:
      Handler: 'app.handler'
      Runtime: 'python3.9'
      CodeUri: ./lambda-package.zip

requirements.txt

numpy

main.py (Simple Python code to just return a response)

import json
import random

def handler(event, context):
    random_number = random.randint(1, 10)

    return {
        'statusCode': 200,
        'body': json.dumps(f'Hello from Python! Random: {random_number}')
    }

We need to place the dependencies and the code inside the folder called lambda-package, we run the following cmd to install the dependencies. And later we zip all the files inside that folder into lambda-package.zip file.

 pip install -r requirements.txt -t ./lambda-package --platform manylinux2014_x86_64 --no-deps

“To package and deploy, run the following commands:

sam package --template-file template.yaml --output-template-file packaged.yaml --s3-bucket lets-build-1

s3-bucket -> The name of the Amazon S3 bucket where this command uploads your AWS CloudFormation template

sam deploy --template-file packaged.yaml --stack-name hello-world-lambda --capabilities CAPABILITY_IAM

capabilities -> A list of capabilities that you must specify to allow AWS CloudFormation to create certain stacks.

However, we are unable to view our code inside the editor.

What if the dependencies get larger? How we can tackle this? So using the Layers, let's continue with example 2 where I will start using Lambda Layers.

Example 2️⃣

Here we go, the biggest change will be in our SAM code, so below I want to split the code into two parts, the first one where I create the layer and the second part where I create my Lambda function using the layers.

AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Description: 'Lambda Function with SAM'

Resources:
  NumPyLayer:
    Type: 'AWS::Serverless::LayerVersion'
    Properties:
      LayerName: 'NumPyLayer'
      Description: 'NumPy layer for Lambda functions'
      ContentUri:
        Bucket: 'lets-build-1'
        Key: 'python.zip'
      CompatibleRuntimes:
        - 'python3.9'

  HelloWorldFunctionPython:
    Type: 'AWS::Serverless::Function'
    Properties:
      Handler: 'app.handler'
      Runtime: 'python3.9'
      CodeUri: ./app.py
      Layers:
        - !Ref NumPyLayer

Outputs:
  HelloWorldFunctionPythonArn:
    Description: 'Python Lambda Function ARN'
    Value: !GetAtt HelloWorldFunctionPython.Arn

Now make sure to place the python dependencies in the right path:

python/
    └── lib/
        └── python3.9/
            └── site-packages/
                └── numpy/
                └── <other dependencies>

Once you place them you can upload the python.zip to your S3 bucket.
Also important when you are installing the dependencies use the following cmd:

pip install -r requirements.txt -t ./python/lib/python3.9/site-packages/ --platform manylinux2014_x86_64 --no-deps

Let's do a quick test for our lambda function using AWS cli:

aws lambda invoke --function-name hello-world-lambda-HelloWorldFunction-CKOzfRY55eaj output.txt

You should see the output ('Hello, World!') inside the output.txt file. Additionally, because we are using Layers, we can edit our code directly from the console.

Conclusion:

AWS Lambda Layers are crucial, especially when dealing with numerous dependencies in your code. I hope this article was helpful. For more content, follow me through the links listed below. 😊

👉 Follow me for more 👾
LinkedIn
X