export const components = {

AWSLambda,

AWSContainerRegistry,

AWSCloudWatch,

AWSXRay,

AWSCloudTrail,

AWSS3,

AWSAPIGateway,

AWSSQSQueue,

AWSEventBridge,

AWSCloudDevelopmentKit,

Arrow

};

Introduction

AWS Lambda's container image support represents a significant evolution in serverless computing, allowing developers to package and deploy functions using container images up to 10GB in size. This capability bridges the gap between containerized applications and serverless architecture, offering greater flexibility in dependency management and code deployment.

$1

$1

Before diving in, ensure you have:

$1

$1

$1

1. Consistent Development Experience

- Use familiar Docker workflows

- Same tools across local and cloud

- Better development-production parity

2. Advanced Dependency Management

- Layer caching for faster builds

- Better control over dependencies

- Support for complex requirements

3. Enhanced Security

- Container scanning integration

- Image signing capabilities

- Vulnerability assessments

$1

$1

$1

``json

{

"Version": "2012-10-17",

"Statement": [

{

"Effect": "Allow",

"Action": [

"ecr:GetAuthorizationToken",

"ecr:BatchCheckLayerAvailability",

"ecr:GetDownloadUrlForLayer",

"ecr:BatchGetImage",

"ecr:PutImage",

"ecr:InitiateLayerUpload",

"ecr:UploadLayerPart",

"ecr:CompleteLayerUpload"

],

"Resource": "*"

}

]

}

`

$1

$1

$1

`plaintext

lambda-container/

├── Dockerfile

├── app/

│ ├── __init__.py

│ ├── main.py

│ ├── utils/

│ │ ├── __init__.py

│ │ └── helpers.py

│ └── config/

│ ├── __init__.py

│ └── settings.py

├── tests/

│ ├── __init__.py

│ ├── test_handler.py

│ └── test_utils.py

├── requirements/

│ ├── base.txt

│ ├── dev.txt

│ └── prod.txt

└── scripts/

├── build.sh

└── deploy.sh

`

$1

`python

app/main.py

`

$1

`plaintext

requirements/base.txt

`

$1

`dockerfile

Build stage

`

$1

$1

$1

`yaml

AWSTemplateFormatVersion: '2010-09-09'

Description: 'Lambda Container Function Stack'

Parameters:

Environment:

Type: String

Default: dev

AllowedValues: [dev, staging, prod]

ImageUri:

Type: String

Description: ECR image URI

Resources:

LambdaExecutionRole:

Type: AWS::IAM::Role

Properties:

AssumeRolePolicyDocument:

Version: '2012-10-17'

Statement:

- Effect: Allow

Principal:

Service: lambda.amazonaws.com

Action: sts:AssumeRole

ManagedPolicyArns:

- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

LambdaFunction:

Type: AWS::Lambda::Function

Properties:

FunctionName: !Sub ${AWS::StackName}-${Environment}

PackageType: Image

Code:

ImageUri: !Ref ImageUri

Role: !GetAtt LambdaExecutionRole.Arn

MemorySize: 1024

Timeout: 30

Environment:

Variables:

ENVIRONMENT: !Ref Environment

LOG_LEVEL: INFO

LambdaLogGroup:

Type: AWS::Logs::LogGroup

Properties:

LogGroupName: !Sub /aws/lambda/${LambdaFunction}

RetentionInDays: 30

Outputs:

FunctionName:

Description: Lambda function name

Value: !Ref LambdaFunction

FunctionArn:

Description: Lambda function ARN

Value: !GetAtt LambdaFunction.Arn

`

$1

$1

$1

1. Multi-stage Builds

`dockerfile

Build stage for dependencies

`

2. Layer Optimization

`plaintext

.dockerignore

`

$1

$1

`python

import logging

import watchtower

import boto3

from typing import Optional

def setup_cloudwatch_logging(

log_group: str,

stream_name: Optional[str] = None,

log_level: int = logging.INFO

) -> None:

"""Configure CloudWatch logging with structured formatting"""

logger = logging.getLogger()

logger.setLevel(log_level)

# Remove existing handlers

logger.handlers = []

# Create CloudWatch handler

cloudwatch_handler = watchtower.CloudWatchLogHandler(

log_group=log_group,

stream_name=stream_name or 'lambda-container-logs',

boto3_client=boto3.client('logs')

)

# Create formatter

formatter = logging.Formatter(

'{"timestamp": "%(asctime)s", "level": "%(levelname)s", '

'"function": "%(funcName)s", "line": "%(lineno)d", '

'"message": %(message)s}'

)

cloudwatch_handler.setFormatter(formatter)

# Add handler

logger.addHandler(cloudwatch_handler)

`

$1

| Metric | CloudWatch | X-Ray | Custom |

|--------|------------|-------|--------|

| Invocations | ✓ | ✓ | Optional |

| Errors | ✓ | ✓ | Optional |

| Duration | ✓ | ✓ | Optional |

| Memory | ✓ | ✗ | Optional |

| Cold Starts | ✓ | ✓ | Optional |

| Traces | ✗ | ✓ | Optional |

| Custom Metrics | ✗ | ✗ | ✓ |

$1

$1

$1

`bash

Scan image for vulnerabilities

``

$1

$1

$1

1. Image Size Reduction

- Use multi-stage builds

- Remove unnecessary dependencies

- Implement layer caching

2. Resource Optimization

- Right-size memory allocation

- Optimize code execution time

- Use provisioned concurrency when needed

3. Monitoring and Alerts

- Set up cost alarms

- Monitor usage patterns

- Implement auto-scaling policies

$1

Lambda container images provide a powerful way to deploy complex applications while maintaining the benefits of serverless architecture. By following the best practices and optimization techniques outlined in this guide, you can effectively leverage this feature for your applications.

Key Takeaways:

$1