This document discusses serverless computing on AWS using AWS Lambda and AWS Fargate. It provides an overview of the anatomy of an AWS Lambda function, including the handler function, event and context objects, dependencies and common helper functions. It also describes how to structure serverless applications using Lambda functions and how AWS Lambda layers can be used to share common code between functions. Finally, it outlines the architecture of running serverless containers on AWS Fargate without having to manage servers or clusters.

1. © 2020, Amazon Web Services, Inc. or its affiliates. All rights reserved.
容器技術和 AWS Lambda 讓您專注
「應用優先」
T r a c k 4 | S e s s i o n 2
Bob Yeh
Startup Solutions Architect

2. Agenda
What customers want
Application-first approach
Application-first with AWS Fargate
Application-first with AWS Lambda

3. Customers have lots
of pieces to operate

4. What our customers want
Build applications,
not infrastructure
Scale quickly
and seamlessly
Security and
isolation by design

5. Application should guide infrastructure

6. AWS manages Customer manages
Data source integrations
Physical hardware, software,
networking, and facilities
Provisioning
Application code
Container orchestration, provisioning
Cluster scaling
Physical hardware, host OS/kernel,
networking, and facilities
Application code
Data source integrations
Security config
and updates
Network config
Management tasks
Container orchestration control plane
Physical hardware, software,
networking, and facilities
Application code
Data source integrations
Work clusters
Security config and updates,
network config, firewall, and
management tasks
Physical hardware, software,
networking, and facilities
Application code
Data source integrations
Scaling
Security config and updates
Network config
Management tasks
Provisioning, managing scaling
and patching of servers
Serverless operations with AWS Fargate and Lambda
AWS Lambda
Serverless functions
AWS Fargate
Serverless containers
Amazon ECS/EKS
Container-management
-as-a-service
Amazon EC2
Infrastructure-as-a-service
Less
More
Opinionated

7. Execution isolation boundary
Task
Network
interface
Data
volume
microVM
Application container
Sidecar container
AWS Fargate data plane
Kernel
Credentials
Function
Network
interface
Data
volume
microVM
Application code
Layers
AWS Lambda data plane
Kernel
Credentials

8. © 2020, Amazon Web Services, Inc. or its affiliates. All rights reserved.

10. Security
Ensuring the security of the infrastructure that is underlying customer containers is
our primary tenet
Availability and scalability
This includes maintaining both uptime of running containers and elasticity of the
platform to support rapid scale-out and scale-in of containers with high reliability
Operational efficiency
Maintain high resources utilization of the underlying fleet to reduce operational
costs for the business
AWS Fargate design tenets

11. AWS Fargate data plane
Container runtime
Fargate agent
Physical server
Amazon EC2 instance

12. AWS Fargate control plane
Cluster
tasks
Available &
checked-out
instances
Front-end
service
Cluster manager
subsystem
Capacity manager
subsystem
Entry point
data plane and drives

13. RunTask call flow
Front-end
service
Cluster manager
subsystem
Capacity manager
subsystem
Capacity
reserved
Task
task
console
agent
agent
capacity
Capacity
agent

14. Amazon EKS on AWS Fargate architecture
podagents
pod as
running
capacity
scheduler scheduler
scheduler
name
profile
pod
cluster
server

15. AWS Fargate VPC integration
172.31.0.0/16
Subnet
172.31.1.0/24
Internet
Other entities in VPC
EC2 LB DB etc.
Private IP
172.31.1.164
Launch your Fargate tasks into subnets
Under the hood
• We create an elastic network interface
• The network interface is allocated a
private IP from your subnet
• The network interface is attached to your task
• Your task now has a private IP from your subnet
You can assign public IPs to your tasks
Configure security groups to control inbound and
outbound traffic
Network interface Fargate
taskPublic /
208.57.73.13 /
VPC

16. Cluster
permissions
Application
permissions
Task
housekeeping
permissions
Cluster
Fargate task
Cluster permissions
Control who can launch/describe tasks in your cluster
Application permissions
Allows your application containers to access AWS
resources securely
Housekeeping permissions
Allows us to perform housekeeping activities around
your task
• Amazon ECR image pull
• Amazon CloudWatch Logs pushing
• Network interface creation
• Register/deregister targets into ELB
AWS Fargate IAM permission types

17. © 2020, Amazon Web Services, Inc. or its affiliates. All rights reserved.

18. Anatomy of an AWS Lambda function
Your function
Language runtime
Execution environment
Lambda service
Compute substrate

19. Anatomy of an AWS Lambda function
Your function
Language runtime
Execution environment
Lambda service
Compute substrate

20. Anatomy of an AWS Lambda function
Handler() function
Function to be executed
upon invocation
Event object
Data sent during Lambda
function invocation
Context object
Methods available to
interact with runtime
information (request ID,
log group, more)
import json
def lambda_handler(event, context):
# TODO implement
return {
'statusCode': 200,
'body': json.dumps('Hello World!')
}

21. Serverless applications
Event source Function
Node.js
Python
Java
C#
Go
Ruby
Runtime API
Changes in
data state
Requests to
endpoints
Changes in
resource state

22. Anatomy of an AWS Lambda function
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Your handler

23. Anatomy of a Lambda functionImport sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Your handler

24. Anatomy of a Lambda functionImport sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Your handler
Dependencies, configuration information,
common helper functions

25. Pre-handler code, dependencies, variables
• Import only what you need
• Where possible, trim down SDKs and other
libraries to the specific bits required
• Pre-handler code is great for
establishing connections, but be
prepared to then handle
reconnections in further executions
• Remember – execution
environments are reused
• Lazily load variables in the global scope
• Don’t load it if you don’t need it – cold starts
are affected
• Clear out used variables so you don’t run into
leftover state
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event,
context) {
....

26. Anatomy of a Lambda functionImport sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Your handler
Dependencies, configuration information,
common helper functions

27. Anatomy of a Lambda functionImport sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionB(thing){
## logic here
}
Business logic sub-functions
Your handler
Dependencies, configuration information,
common helper functions
Common helper functions

28. Anatomy of a serverless application
/orders
/forums
/search
/lists
/user
/...
Amazon API
Gateway
AWS Secrets
Manager /
Parameter Store
Amazon
DynamoDB
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler

29. Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Pre-handler-secret-getter() {
}
Function Pre-handler-db-connect(){
}
Function subFunctionA(thing){
## logic here
}
Function subFunctionA(thing){
## logic here
}
Dependencies, configuration
information, common helper functions
Common helper functions
Business logic sub-functions
Your handler
AWS Secrets
Manager /
Parameter Store
Amazon
DynamoDB
Anatomy of a serverless application
Amazon API
Gateway
/orders
/forums
/search
/lists
/user
/...
There could be a lot of
duplicated code here!

30. AWS Lambda layers
Lets functions easily share code: Upload layer
once, reference within any function
Layer can be anything: Dependencies, training
data, configuration files, etc.
Promotes separation of responsibilities, lets
developers iterate faster on writing business logic
Built-in support for secure sharing by ecosystem

31. Using AWS Lambda layers
• Put common components in a ZIP
file and upload it as a Lambda layer
• Layers are immutable and can be
versioned to manage updates
• When a version is deleted or
permissions to use it are revoked,
functions that used it previously
will continue to work, but you
won’t be able to create new ones
• You can reference up to five layers,
one of which can optionally be a
custom runtime
Lambda
layers
arn:aws:lambda:region:accountId:layer:shared-lib :1
Lambda
layers
arn:aws:lambda:region:accountId:layer:shared-lib:2
Lambda
layers
arn:aws:lambda:region:accountId:layer:shared-lib:3

32. AWS Secrets
Manager /
Parameter Store
Amazon
DynamoDB
Anatomy of a serverless application
/orders
/forums
/search
/lists
/user
/...
Amazon API
Gateway
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Dependencies, configuration information,
common helper functions
Common helper functions
Business logic sub-functions
Your handler
Your handler
Your handler
Your handler
Your handler
Your handler

33. AWS Secrets
Manager /
Parameter Store
Amazon
DynamoDB
Anatomy of a serverless application
/orders
/forums
/search
/lists
/user
/...
Amazon API
Gateway
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Import sdk
Import http-lib
Import ham-sandwich
Pre-handler-secret-getter()
Pre-handler-db-connect()
Function myhandler(event, context) {
<Event handling logic> {
result = SubfunctionA()
}else {
result = SubfunctionB()
return result;
}
Function
Dependencies, configuration information,
common helper functions
Common helper functions
Business logic sub-functions
Your handler
Your handler
Your handler
Your handler
Your handler
Your handler

34. Learn to build modern applications on AWS
Enable rapid innovation by developing your skills in designing,
building, and managing modern applications
Resources created by the experts at AWS to help you build and validate developer skills
Validate expertise with the AWS Certified DevOps –
Professional or AWS Certified Developer – Associate exams
Learn to modernize your applications with free digital training and
classroom offerings, including Architecting on AWS, Developing on
AWS, and DevOps Engineering on AWS
Visit the developer learning path at aws.amazon.com/training/path-developing

35. Thank you!
© 2020, Amazon Web Services, Inc. or its affiliates. All rights reserved.