Thread by @tpschmidt_

📚 AWS 1x1 - 𝗟𝗮𝗺𝗯𝗱𝗮 ƛ

The Heart of your Serverless Love Story 🧡

All my learnings & (almost) everything you need to know ↓

𝗧𝗵𝗿𝗲𝗮𝗱 𝗢𝘃𝗲𝗿𝘃𝗶𝗲𝘄

• Introduction
• Cold Starts
• Handler Method
• Runtimes
• Layers
• Security
• Versioning & Aliases
• Provisioned & Reserved Concurrency
• Lambda@Edge
• Pros & Cons
• Observability
• Considerations to make

{ 1/31 }

𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻

AWS released Lambda in late 2014, spreading the buzzword serverless.

With EC2 you didn't have to think about physical servers anymore, but only virtual machines.

With Lambda, there's not even that anymore to maintain.
Just bring your code.

{ 2/31 }

AWS will take care of provisioning the underlying infrastructure and container.

Besides not having to think about operation overhead like you'd have when managing virtual machines or containers, you'll be only billed when your function is actually executed.

{ 3/31 }

What does that mean?

If you're building a spike or an MVP for a business idea that's solely featuring serverless services like Lambda, you won't induce costs when your service is idle.

That's a huge plus in comparison to using ECS or EC2.

{ 4/31 }

What's probably not obvious and I've found that there's often confusion amongst beginners:
A single Lambda instance will only process a single request at a time

If two requests are reaching your Lambda at the exact same time, there's a need for two dedicated instances

{ 5/31 }

Why's that important?

AWS doesn't want to block computation resources for idle functions, so it will regularly de-provision your function.

Even if they are continuously invoked, 𝘁𝗵𝗲𝘆 𝘄𝗶𝗹𝗹 𝗯𝗲 𝗱𝗲-𝗽𝗿𝗼𝘃𝗶𝘀𝗶𝗼𝗻𝗲𝗱 𝗮𝘁 𝘀𝗼𝗺𝗲 𝘁𝗶𝗺𝗲.

{ 6/31 }

This results in having the feared 𝗖𝗼𝗹𝗱 𝗦𝘁𝗮𝗿𝘁𝘀

If your request triggers a new Lambda instance, you'll have a significantly longer delay until your function code is executed.
If you're not using a lightweight framework, the bootstrap will even take more time.

{ 7/31 }

You can work against that by regularly invoking your functions with health checks, but as said, it won't protect you from having cold starts from time to time.

That's why it's important to not run code that needs a lot of spin-up time.

{ 8/31 }

𝗛𝗮𝗻𝗱𝗹𝗲𝗿 𝗠𝗲𝘁𝗵𝗼𝗱

That's always the entry point of your Lambda function.

Everything that's outside this function will be executed first when your function receives a cold start and 𝘄𝗼𝗻'𝘁 𝗱𝗶𝘀𝗮𝗽𝗽𝗲𝗮𝗿 from memory until it's de-provisioned.

{ 9/31 }

Another 𝗴𝗶𝗳𝘁 we receive from AWS:

the execution of the global code outside of your handler method will be executed with high memory & CPU settings and 𝗶𝘀𝗻'𝘁 𝗯𝗶𝗹𝗹𝗲𝗱 for the first 10s.

Make use of this by bootstrapping your core framework outside.

{ 10/31 }

𝗥𝘂𝗻𝘁𝗶𝗺𝗲𝘀

Lambda supports everything you can think of, ranging from Node.js, over Ruby & Python to Java.

Not finding your preference?
You can bring your 𝗼𝘄𝗻 𝗿𝘂𝗻𝘁𝗶𝗺𝗲.

docs.aws.amazon.com/lambda/latest/…

{ 11/31 }

𝗟𝗮𝘆𝗲𝗿𝘀

When your function is executed, all the dependencies it needs have to be bundled into your deployment unit.

If you're using for example Node.js, your node_modules can easily reach 100MB.

You don't want to package & deploy this every time.

{ 12/31 }

This is surely true, as dependencies in comparison to your business logic code rarely change or get updated

With Layers, you can bundle your dependencies separately and then attach them to 𝗼𝗻𝗲 or 𝘀𝗲𝘃𝗲𝗿𝗮𝗹 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀

Next time, only deploy your code!

{ 13/31 }

𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆

As with other services, your function is protected via IAM
By default, there's no ingress traffic possible to your function, but all egress to the internet

You can assign your function to a VPC to access other services there, but you don't have to

{ 14/31 }

𝗩𝗲𝗿𝘀𝗶𝗼𝗻𝗶𝗻𝗴 & 𝗔𝗹𝗶𝗮𝘀𝗲𝘀

You can use aliases when updating your functions, to have your Lambdas versioned.

This enables you to do things like canary deployments by using weighted aliases, e.g. only sending 20% of traffic to your updated function.

{ 15/31 }

𝗣𝗿𝗼𝘃𝗶𝘀𝗶𝗼𝗻𝗲𝗱 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆

Reduce your latency fluctuations by keeping instances provisioned.
This introduces significantly higher pricing though.

Also, deployments of your function will take more time as your version needs publishing.

{ 16/31 }

𝗥𝗲𝘀𝗲𝗿𝘃𝗲𝗱 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆

Assign dedicated reservations of parallel executions for your function.
This means this number will be subtracted from your default account soft limit of 1000 parallel executions (can be increased via the support)

{ 17/31 }

It guarantees that this concurrency level is always possible for your function.

What it also ensures: 𝘁𝗵𝗶𝘀 𝗰𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 𝗹𝗲𝘃𝗲𝗹 𝗰𝗮𝗻'𝘁 𝗯𝗲 𝗲𝘅𝗰𝗲𝗲𝗱𝗲𝗱!

The wording's not the best, as reserved and provisioned concurrency are often confused.

{ 18/31 }

𝗟𝗮𝗺𝗯𝗱𝗮@𝗘𝗱𝗴𝗲

Lambda's not only good for computation workloads or REST backends.
You can also use them with CloudFront.

It enables you to execute code at different times when your CloudFront distribution is called.

{ 19/31 }

By that you can for example easily implement authorization rules or change destinations for your origin.

Generally, you can do a lot as you're also able to use the AWS-SDK and invoke other services.

Another tip: CloudFront functions - the lightweight alternative!

{ 20/31 }

𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 of using Lambda

• reduce operations: package & run your code
• out-of-the-box scalability: ⚡️-fast horizontal scaling
• pay-as-you-go: only pay for what you're using
• agility & development speed: reducing burdens & increasing productivity

{ 21/31 }

𝗗𝗼𝘄𝘀𝗶𝗱𝗲𝘀

• cold-starts
• higher abstraction but lower predictability
• pricing: depending on your workload & traffic, Lambda can be a cost pitfall
• vendor-lock: compared to container-based apps, it's more difficult to migrate to another provider

{ 22/31 }

𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆

Still, a goliath task is having in-depth observability for your lambda-powered architecture.
Mostly, you'll design event-driven, async architectures that involve a lot of other services like SQS.

So there's not just an HTTP 500 to find.

{ 23/31 }

CloudWatch helps you a lot in the first place with Metrics & Alerts.
A lot of them are predefined, like:

• Lambda Errors: your function did not finish with exit code 0
• Throttles: concurrency limit was exceeded

Familiarize yourself with CloudWatch possibilities!

{ 24/31 }

CloudWatch has its limitations and the Console Interface is still painfully to use for certain tasks like log browsing and having a complete solution needs a lot of work.

Third-party tools which are mostly easy to set up are helping a lot.

{ 25/31 }

My biased proposal:

Try out @thedashbird for free - an all-embracing monitoring and debugging tool for serverless applications powered by Lambda.

If you've got questions, feedback or you're missing a feature: send me a DM 📨
We can work something out 🧑‍💻

{ 26/31 }

𝗖𝗼𝗻𝘀𝗶𝗱𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 𝘁𝗼 𝗺𝗮𝗸𝗲

Don't just blindly build a new service with Lambda.
Do an in-depth requirements analysis before and think about your use-cases.

Understand what you want & make sure 𝘁𝗵𝗲 𝘀𝗲𝗿𝘃𝗲𝗿𝗹𝗲𝘀𝘀 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝗳𝗶𝘁𝘀!

{ 27/31 }

Answer these questions:

1. Does the service need to maintain a 𝗰𝗲𝗻𝘁𝗿𝗮𝗹 𝘀𝘁𝗮𝘁𝗲?
2. Does the service need to serve requests 𝘃𝗲𝗿𝘆 𝗳𝗿𝗲𝗾𝘂𝗲𝗻𝘁𝗹𝘆?
3. Is the architecture rather 𝗺𝗼𝗻𝗼𝗹𝗶𝘁𝗵𝗶𝗰 instead built of small, loosely coupled parts?

{ 28/31 }

4. Is it 𝘄𝗲𝗹𝗹 𝗸𝗻𝗼𝘄𝗻 how the service needs to 𝘀𝗰𝗮𝗹𝗲 𝗼𝘂𝘁 on a daily or weekly basis and as well the expected traffic in the future?
5. Are processes mostly revolving around 𝘀𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗼𝘂𝘀 𝗼𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀?

The more 𝗡𝗼𝘀, the better!

{ 29/31 }

If you've answered one or more questions with yes, likely a "classical" containerized approach with ECS can be a better solution.

I love Lambda and taking a serverless approach, but 𝗶𝘁 𝗻𝗲𝗲𝗱𝘀 𝘁𝗼 𝗳𝗶𝘁 𝘆𝗼𝘂𝗿 𝗴𝗼𝗮𝗹𝘀.

{ 30/31 }

Lambda is continuously 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝗱!

Since I've started with Lambda in 2018, AWS introduced among other things:

• AWS Hyperplane for running Lambda smoothly attached to VPCs
• fine-grained billing in 1ms periods
• running Lambda on Gravity ARM processors

{ 31/31 }

𝗙𝗶𝗻𝗮𝗹 𝘁𝗵𝗼𝘂𝗴𝗵𝘁𝘀

There's no way to think about the cloud world without Lambda - it's here to stay
Take time to explore it and start building!

Drop me a message for advice on your cloud journey! ✍️

As Always: Happy about a ♻️ &❤️ of the initial post!

Thank you! 🙌