BYTE the Cloud

Chris 0:00
Welcome to the deep dive. Today. We're focusing on you cloud engineers out there. Yeah, get ready, because we're going deep into AWS Lambda tax, right? You might think you know it, yeah, but there's always more to learn, especially if you're going for that AWS cert, absolutely,

Kelly 0:16
yeah. We'll be breaking it down, looking at what it's good at, what it's not so good at, right? And how it fits into that whole serverless world.

Chris 0:25
Okay, so let's set the stage. Okay, imagine if you could write code without having to worry about servers, right? That's the magic of Lambda. Upload your code, and Lambda handles everything else, scaling, patching, security. It takes care of it all.

Kelly 0:41
It's pretty amazing. Yeah, it really is. It's like a personal assistant, right? But for your code, for your deployments, yeah, what I find really cool is that it's event driven, okay? So that makes it perfect for those systems that need to react quickly. Give me an example, like resizing images as soon as someone uploads them, Oh, okay. Or triggering, you know, like personalized recommendations when a user does something specific, I see that's where Lambda really shines. So

Chris 1:04
it's not just about convenience then, no, no, it's about building a whole new kind of application. Exactly. Okay, so let's unpack what Lambda is at its core. All right, we know it's serverless, yeah, but what does that actually mean for us cloud engineers? Well, think

Kelly 1:20
of it as a super powerful engine for running code on demand. It supports a bunch of different progRAMming languages, so you can use what you're comfortable with, right? But the real game changer is that you only pay for what you use. Oh, the pay as you go exactly. You only pay for the compute time your code actually uses. That

Chris 1:39
can save a lot of money compared to, oh, absolutely traditional servers, especially, yeah, especially as things are getting more dynamic and everything needs to scale, right? But there's always trade offs, right, always. So what are some of the limitations we should be aware of with Lambda?

Kelly 1:54
Well, for one, each function has a time limit.

Chris 1:58
How long can it run for?

Kelly 1:59
You know, I can't just run forever, right? Which might be a problem for really long tasks.

Chris 2:04
Okay, so for longer running things, we need to think about something else. Yeah, got it.

Kelly 2:07
And then there's something called cold starts. Oh, yeah, I've heard of those. The first time you call a function after it's been idle for a while, there's a little delay, okay? Because it has to set up the execution environment, right? And that can affect performance, especially, especially if your application needs to be really snappy,

Chris 2:26
yeah, instantaneous, right? So knowing these limitations, how does Lambda fit into that bigger picture of AWS?

Kelly 2:33
So Lambda is like the heart of the serverless world in AWS, okay? And it's got a whole network of supporting services around it, right? You can trigger Lambda functions from almost any AWS service. Oh, wow, it's incredibly flexible. Yeah. Think about API gateway for building APIs or S3 for doing stuff when someone uploads a file. Okay, the possibilities are pretty much endless. It sounds like

Chris 2:58
you're almost composing music, in a way, yeah,

Kelly 3:00
but with all these services and orchestra, right? Yeah, all working together, so

Chris 3:04
let's get practical. Okay, let's say I'm prepping for that AWS exam. What kind of questions should I expect about Landa, right? And how do I knock those answers out of the park? Let's say

Kelly 3:16
you get this scenario. Okay, you need to build a system that processes images that users upload to an S3 bucket. Okay, yeah, the system needs to resize the images, add watermarks right, and then store them in a different S3 bucket. Okay. How would you do this using Lambda? That's

Chris 3:37
a pretty classic image processing scenario, and I could see how Lambda fits in. But how do I answer this? To really show that I know my stuff? Well, you want to

Kelly 3:46
show that you understand how Lambda works with other services and how it uses events. So you'd start by saying that you create a Lambda function that gets triggered when a new object is uploaded to that S3 bucket. Then the function would use the AWS SDK right to download the image from S3 process it using something like image magic, okay, or a similar tool, I say, and then upload the processed image to that second bucket.

Chris 4:16
So I'm not just listing the steps, yeah, I'm also mentioning specific AWS services and tools exactly, so it shows I can actually do this. Not just talk about it, right?

Kelly 4:25
You want to prove you can actually build it, got it. And to go even further, you could talk about optimizing the function. Oh, okay, make it run faster and cost less. Like what you could talk about using environment variables for settings, or Lambda layers to manage dependencies, or even caching to avoid doing the same work over and over,

Chris 4:45
I see. So it's all about those extra details that show you really understand it exactly. Okay? That makes sense. It's

Kelly 4:50
like the difference between describing a regular car and knowing all the specs of a high performance sports car,

Chris 4:57
right? Got it.

Kelly 4:58
Now, let's say you get a. Question about security, right? Like, how

Chris 5:01
do you make sure your Lambda functions are secure, yeah, and that they only have the permissions they absolutely

Kelly 5:06
need. Security is super important, especially in the cloud, absolutely crucial. What are the key points I need to hit on for a question like that? You

Chris 5:15
wanted to start with IAM roles. Oh, okay. Lambda functions run within those roles, yeah, and those roles define what the function is allowed to do in your AWS account. You absolutely have to stress that you should only give the function the bare minimum permissions it needs,

Kelly 5:33
right? So no more giving admin access just in case, huh? No way. Gotta lock things down

Chris 5:38
exactly you want to prevent anything from happening that's not supposed to right? And you could give some examples of how you'd actually do this, like, what if your function needs to read data from an S3 bucket? Yeah, you'd create an IAM role that only lets it read from that specific bucket. Okay, nothing else got it. Or if it needs to write data to a dynamedb table, you give it right access only to that table. So that's where those fine grained IAM policies come in,

Kelly 6:05
right? It's like giving each function a very specific key that only unlocks the doors it absolutely needs to Okay?

Chris 6:11
So it's not just about knowing what Lambda is, no, it's about knowing how to use it securely, right and efficiently, exactly within the whole AWS ecosystem. That's

Kelly 6:20
the key. All right,

Chris 6:21
let's try another question, a bit more of a challenge. Okay, hit me. How about this? You have a Lambda function that needs to crunch a huge amount of data, and you're worried about hitting that time limit, okay. How would you handle that?

Kelly 6:35
This question is really testing. If you understand Lambdas limits, right? And if you can think outside the box. Okay. First you acknowledge the problem. Lambda functions have time limits, right? If you go over, it just stops, yeah, then you explain how you'd work around that. So

Chris 6:51
how do we deal with a problem that's too big for one Lambda function? You

Kelly 6:56
could break the task down, okay, into smaller chunks and have separate Lambda functions handle each

Chris 7:03
chunk like a divide and conquer strategy exactly.

Kelly 7:05
You could use something called batch processing, where you split the data up, right, and process each batch separately, okay? Or you could use a service called step functions. I've heard of that. It helps you orchestrate a workflow, okay? With multiple Lambda functions. I see each one doing a specific part of the job, like an assembly line. Exactly, yeah, each function does its part and passes it on to the next.

Chris 7:30
So instead of one function trying to do it all, right, we have a chain of functions working

Kelly 7:34
together exactly. Got it This not only helps you stay within the time limit, but it also makes your solution more robust and scalable, okay?

Chris 7:43
So it's more reliable and can handle more data, right? This is starting to click now. Good. It's not just about knowing the features of Lambda. It's about

Kelly 7:50
the bigger picture. It's about how to use it strategically to solve problems in the real world. And that's exactly what the AWS exam is all about. Okay, let's

Chris 7:59
try one more, one that often trips people up. How about this? You're building an application using API gateway and Lambda, okay, how do you ensure that only authorized users can access your API?

Kelly 8:15
Ah, API security, yeah, very important in the serverless world, especially

Chris 8:20
with everything being so interconnected, exactly what's the best way to approach this?

Kelly 8:25
You want to start by highlighting that API gateway has really strong built in security features. So

Chris 8:31
API gateway is like the security guard for our serverless apps. Exactly. Then

Kelly 8:35
you dive into the specifics of how API gateway secures endpoints. Yeah, you can talk about API keys, which are like tokens that clients use to identify themselves, right? You can set up API gateway to require these keys for certain endpoints so

Chris 8:50
only clients with a valid key can get in. That's the idea. That's a good starting point. But I'm guessing there are more advanced methods too. Oh, absolutely, when we need more control,

Kelly 9:00
right? That's where custom authorizers come in. Okay? They let you write your own authorization logic using Lambda. Using Lambda, exactly. Interesting. You can configure API gateway to trigger a custom authorizer function. Every time a request comes in, I see the authorizer checks who's making the request, what permissions they have right and then decides whether to allow or deny the request. It's like having

Chris 9:25
a bouncer at a club. Yeah, good analogy, checking IDs and making sure everyone's on the list exactly. So I'm combining the power of API gateway security with the flexibility of Lambda right to create my own custom authorization flow. That's

Kelly 9:39
the idea. Okay, that's pretty cool. And to really show you know your stuff, yeah, you could mention different ways to implement those custom authorizers. You could talk about using Amazon Cognito for managing users and authentication right, or using JWT tokens for a more set less approach that

Chris 9:59
shows. Because I've actually thought about how I'd implement this in the real world. Exactly. That's the key. Okay, so this is really giving me a clear picture of how Lambda fits into the whole security landscape of AWS. It's not just about the function itself, right? It's about using other services like API gateway and IAM to build a complete security strategy. Absolutely, this has been really helpful, good. I'm glad I feel like I'm really starting to understand the power of Lambda, yeah, and how to build these robust, scalable and secure serverless applications.

Kelly 10:35
That's great to hear.

Chris 10:36
We've covered so much ground. Well, we have, but we've got more to go, right? Oh, yeah, definitely for the next round. Bring

Kelly 10:40
it on. Okay, let's jump back into those exam style questions. Okay, how about this one? You have a Lambda function that needs to access secrets, secrets that are stored in AWS secrets manager, right? How would you implement this securely?

Chris 10:56
Secrets management is so important? Oh, absolutely, especially when you're dealing with sensitive information like database credentials, API keys. We talked about environment variables before, yeah, but is there a better way to handle this in Lambda,

Kelly 11:10
you're on the right track, okay, environment variables can be used, yeah, but they're not really ideal for secrets, especially

Chris 11:17
in production. Exactly. You don't want those secrets just floating around. No, not at all. So what's the best practice? Then AWS

Kelly 11:24
secrets manager, okay, it's a service specifically designed for storing and managing secrets.

Chris 11:31
So instead of hard coding secrets in our code, right, or putting them in environment variables, yeah, we store them in secrets manager, exactly. But how does our Lambda function actually get those secrets then, well, Lambda

Kelly 11:42
has built in integration with secrets manager, okay, so your functions can retrieve secrets when they're running

Chris 11:48
at runtime. Yeah, so it doesn't have to know the secret beforehand Exactly,

Kelly 11:52
yeah. You use the AWS SDK within your function to fetch the secret from Secrets manager, okay? And you use the secrets Arn to do that,

Chris 12:03
so the secret itself never actually appears in my code, right, or in any config files. Nope. That's really good for security. It minimizes

Kelly 12:11
the risk of exposure. Yeah, it's like having a super secure vault, right? Just for your secrets. And

Chris 12:16
Lambda can get in when it needs to exactly, but only when it needs to. And

Kelly 12:20
to make it even more secure. Yeah, you can use IAM to control who has access to those secrets.

Chris 12:26
So it's not just any Lambda function that can grab them, right? It's only those that are authorized, only

Kelly 12:30
authorized roles or users can access specific secrets.

Chris 12:35
So we've got secrets manager for the secure storage. Yeah, I am for controlling access, and the AWS SDK inside our Lambda function to get the secret when we need it. Exactly, that sounds like a pretty solid security setup, it is. And for the exam, it's not just about knowing the individual services, right? It's about showing you can use them together, yeah, to solve a real problem. Exactly,

Kelly 12:59
that's what they're looking for. Okay,

Chris 13:00
let's switch gears a little bit. Okay. What about Lambda layers? Oh, layers

Kelly 13:05
a very powerful feature, but how

Chris 13:07
do they work?

Kelly 13:09
Think of them like reusable components for your Lambda functions, you can package up common code libraries dependencies and share them across multiple

Chris 13:19
functions. So instead of copying and pasting the same code into every function exactly, create a layer, yeah, and then any function that needs it can use it exactly.

Kelly 13:28
It's like a shared library, okay? I see this not only saves you from repeating yourself, right? Less duplication, but it also makes your deployment packages smaller, which means faster deployment, faster deployments, and potentially better cold start performance, right?

Chris 13:42
Because there's less to load exactly, that makes a lot of sense, especially in serverless, where every millisecond counts Absolutely. Can you give me some real world examples of how layers might be used? Sure,

Kelly 13:54
let's say you have a set of utility functions, okay, that you use in multiple Lambda functions. Instead of copying them into each function, you package them as a layer, okay? Or maybe you need a specific version of a library that's not included in the standard Lambda environment, right? You can bundle that library as a layer and then

Chris 14:15
include it with your functions. Yeah, exactly. So it's not just about sharing code, yeah, it's also about managing dependencies, making our architecture more modular and easier to maintain. That's right. Okay. I'm starting to see how layers can be really useful. They're a great tool, especially as our serverless applications get more complex, especially then, what other hidden gems should we talk about?

Kelly 14:38
How about this? You're worried about the performance of your Lambda function, okay, especially those cold starts. Uh

Chris 14:45
oh, cold starts, yeah, those can be a pain. They can especially when you need low latency, right? What can we do about them? Well, first

Kelly 14:53
you have to accept that cold starts are a part of serverless. There's always going to be that delay one. A function is invoked for the first time, right?

Chris 15:02
Because it has to set up the environment exactly, but we can minimize that delay, right? Absolutely. What are some strategies for that? One approach

Kelly 15:09
is to keep your function warm warm by invoking it periodically,

Chris 15:13
even if there's no real work to do. Even

Kelly 15:16
then, you can do this with scheduled events or by sending dummy requests to

Chris 15:22
the function. So it's like keeping the engine running exactly, just ready to go. Another

Kelly 15:25
approach is to minimize what needs to be loaded during a cold start. Okay, optimize your code. Use smaller libraries, leverage Lambda layers, so

Chris 15:35
we're making our function lighter and faster to load exactly if we have functions that are super critical and can't afford any delay at all,

Kelly 15:44
then you can use provisioned concurrency. Okay? This keeps a certain number of function instances initialized and ready to go, so no

Chris 15:53
cold starts for those instances, right? That's like having a dedicated lane for our VIP functions to get instant service, understanding

Kelly 15:59
cold starts and knowing how to mitigate them. Yeah, is crucial for anyone working with Lambda, especially

Chris 16:05
if performance is a big concern, absolutely. Okay, let's try another exam question. All right. Shoot one that's a bit more complex. Okay, you need to build a serverless application with multiple Lambda functions. How can you orchestrate these functions and manage the flow of data between them. This

Kelly 16:23
is about building those larger serverless applications. Yeah, it's about thinking in terms of workflows and pipelines, like moving

Chris 16:30
from playing a single instrument to conducting an orchestra exactly. I need a conductor to keep everything in sync, and

Kelly 16:36
AWS has a tool for that. What is it? AWS step function. Step functions, okay, it's a serverless workflow orchestration service. What does that mean? Exactly? It lets you define a series of steps, right? Each step could be a Lambda function, and you control how the data flows between those steps. So

Chris 16:54
it's like drawing a flow chart for our serverless application. Yeah, good analogy. Each box is a Lambda function, right and the arrows show how the data moves exactly step functions makes it easy to create and manage these workflows. Yeah, even complex ones.

Kelly 17:09
It can handle branching, parallel execution, error handling, so

Chris 17:13
we can build workflows that can handle different scenarios exactly, like what happens if a function fails right, or if we need to process data in parallel, step functions can handle all of that. Yeah, that's pretty powerful. It is. What else should I know about step functions for the exam?

Kelly 17:30
You could talk about the different types of workflows, standard workflows for longer processes, and express workflows for quick, high performance tasks. So

Chris 17:40
we choose the right type depending on what we need exactly, and don't forget about integration with other AWS services, right, like SNS for notifications, SQS for queues, DynamoDB for storing data. Step functions can work with all of them. This is a whole new level of serverless applications. It

Kelly 17:58
is very cool. Step functions is a key tool for anyone serious about serverless.

Chris 18:04
Okay, let's try one more question, one that's a bit more practical. Okay, you're deploying a Lambda function, and it needs to access resources in a private subnet, okay, within your VPC ice. How would you set this up?

Kelly 18:19
This question gets into networking and security, right? And how Lambda works with VPCs. Okay, by default, Lambda functions run outside of your VPC, so

Chris 18:29
they can't access things in private subnets directly. So if I have a database and a private subnet, yeah, my Lambda function can't connect to it, not

Kelly 18:37
without some configuration. Okay. So what do we do? You need to configure the Lambda function to run inside your VPC? Okay, this is where VPC configuration comes in. Uh huh. You can associate your function with specific subnets within your VTC so

Chris 18:51
it can access resources in those subnets Exactly. It's like giving my Lambda function a special pass, yeah, like a backstage pass to get into the VIP area of my VPC. But there are security implications, right? Oh, absolutely. We can't just let anyone in. No,

Kelly 19:04
you need to manage your network access controls, okay, your nacls and security groups, right to restrict traffic and make sure only authorized connections are allowed.

Chris 19:14
So we're not just opening the door wide open. Nope. We're being very specific about who can come in and out. Exactly. What else should I mention for the exam?

Kelly 19:24
You could talk about the performance impact of enabling VPC access. Oh, right. It can add some latency because

Chris 19:31
of the network traffic, right? So it's a trade off between security and performance. Exactly. We have to decide what's more important for our application.

Kelly 19:38
Understanding how to configure Lambda to work with VPCs is crucial, yeah, especially if you need to access private resources.

Chris 19:46
Okay, this has been a great overview of Lambda. It has. We've covered so much from

Kelly 19:50
the basics to some more advanced stuff, and those

Chris 19:52
exam questions have been really helpful. Good. I feel like I have a much better understanding of Lambda. Now, I'm glad to hear that, but there's always more to learn. Yeah, right. Oh, definitely, the world of serverless is constantly evolving. It is. What else should we explore? Let's

Kelly 20:05
talk about monitoring and troubleshooting. Okay, knowing how to monitor your Lambda functions, identify issues, troubleshoot problems, right? That's essential for making sure your serverless applications are reliable and perform it.

Chris 20:19
So even though we're not managing servers directly, we still need to keep an eye on things absolutely and be prepared to fix problems when they arise exactly. Okay, let's dive into that then, all right, okay, let's get into those monitoring and troubleshooting questions. Let's say this comes up on the exam. You deployed a Lambda function, okay, but it's not working the way you expected. How would you go about troubleshooting

Kelly 20:46
it? Troubleshooting serverless applications, especially Lambda functions, it requires a bit of a different way of thinking. Okay, since we don't have access to the underlying infrastructure, we need to use different tools and techniques to figure out what's going wrong.

Chris 21:02
So it's like being a detective, but instead of fingerprints and clues, we have logs and metrics.

Kelly 21:07
Exactly. I like that. The first step is to gather evidence. Okay, start by checking the Lambda functions logs in CloudWatch. Logs. CloudWatch got it. Lambda automatically sends those logs to CloudWatch, and they give you really valuable information about how your function is running, what errors are happening, and the nitty gritty details of each execution. Cloud

Chris 21:28
watch is our go to for understanding what's going on inside our Lambda functions. Absolutely, it's like a black box for serverless applications, exactly. So we check the logs. What next?

Kelly 21:37
Next you want to look at the functions metrics in CloudWatch. Okay, metrics got it. Lambda gives you all sorts of metrics, how many times it's been invoked, how long it takes to run, how often it throws errors, if it's being throttled.

Chris 21:51
So if I see a lot of errors happening, or my function suddenly taking way longer to run, that's a bad sign. We're looking for patterns in anything that seems out of place. Exactly. Okay. So logs and metrics, those are our bread and butter for troubleshooting Lambda. They are anything else we should

Kelly 22:05
be aware of if you really want to impress the examiners. Okay, I like impressing examiners. You can talk about using x ray. X ray, what's that? It's a tracing tool, and it helps you visualize the execution path of your Lambda function, see where the bottlenecks are.

Chris 22:19
So it's like actually seeing inside the function, like an x ray image. You

Kelly 22:22
got it. That's cool. It can be really helpful. And another important thing to remember, yes, good coding practices and defensive progRAMming, right? That's always important, things like adding error handling and logging to your functions that can make troubleshooting so much easier later on. It's

Chris 22:38
like leaving breadcrumbs for yourself so you can retrace your steps if something goes wrong. Exactly. Okay, let's get into another scenario, specific one.

Unknown Speaker 22:46
All right, give me one.

Chris 22:47
You've got a Lambda function that's processing messages from an SQS queue, but the messages aren't

Speaker 1 22:53
being processed as quickly as you expected. Uh huh, a common problem,

Chris 22:56
what steps would you take to figure out what's going on?

Kelly 22:59
This is a classic question that tests how well you understand how Lambda works with other services, right? In this case, SQS so we have a Lambda function that's triggered by messages coming into an SQS queue. But there's a bottleneck somewhere,

Chris 23:13
right? The messages are piling up. Where do we start looking? Start with the SQS queue

Kelly 23:17
itself. Okay, check its metrics in CloudWatch, things like how many messages are in the queue, how old the oldest messages, how many have been sent and received?

Chris 23:27
So if we see a ton of messages just sitting in the queue, that's a red flag,

Unknown Speaker 23:30
definitely okay. We

Chris 23:31
check the queue. Then what? Then

Kelly 23:33
move on to the Lambda function, right? Check its logs in CloudWatch logs. Look for error messages, exceptions got it also check the functions concurrency settings, make sure it has enough capacity to handle all those messages.

Chris 23:47
So we need to make sure our function has enough power to keep up with the flow of messages

Kelly 23:52
Exactly. But what if the function itself seems to be running fine, but the messages are still backing up? Hmm,

Chris 23:59
that's tricky. What could be going on there?

Kelly 24:02
That's when you need to really understand your SQS configuration, all right, check the queues, visibility timeout setting.

Chris 24:09
Visibility timeout, what's that

Kelly 24:11
This setting controls how long a message is hidden from other consumers after a Lambda function picks it up, okay? If the timeout is too short, the function might not have enough time to finish processing the message before it becomes visible again. So

Chris 24:26
another function might grab the same message and try to process it exactly. That would create a mess. It would so we need to make sure the visibility timeout is long enough for the function to do its job right.

Kelly 24:36
And to really show your SQS expertise, you can talk about different message processing, models like batch processing, batch processing, yeah, where the Lambda function receives a bunch of messages at once instead of one at a time. So

Chris 24:49
it's more efficient, less overhead. Okay, so troubleshooting Lambda with SQS, it's all about understanding both sides of the equation, exactly,

Kelly 24:56
the queues, configuration and the function. Behavior, right? Makes

Chris 25:00
sense? Okay, last question, let's focus on performance optimization. Right? Let's say the exam throws this at you. You have a Lambda function that's running slow, and you think it's because of too many cold starts. What can you do to make it run faster?

Kelly 25:15
Ah, cold starts, everyone's favorite. We've talked about them before, but they're worth revisiting,

Chris 25:21
right? That initial delay when a function hasn't been used in a while.

Kelly 25:24
So how do we tackle those pesky cold starts? Yeah, give me the secrets. One way is to keep the function warm, warm like preheating an oven. Kind of you invoke the function regularly, even if it doesn't have to do anything, so it's always ready to go exactly. You can use scheduled events or send dummy requests smart. What else can we do minimize the amount of code and dependencies that need to be loaded during a cold start

Chris 25:49
so like streamlining our code, making it as lightweight as possible,

Kelly 25:54
right, optimize the code. Use smaller libraries, leverage Lambda layers, layers. We talked about those, right? Yep, they can help separate common dependencies from the core function code.

Chris 26:05
So it's all about making the function as lean and mean as possible. Exactly what about for those super important functions, the ones that can't afford any delay at

Kelly 26:15
all. For those, you can use provisioned concurrency. Provisioned concurrency, right? It keeps a set number of function instances initialized and ready to handle requests. No cold starts for those instances, so

Chris 26:27
they're always on standby, like a SWAT team ready to deploy Exactly. Okay? So we have a lot of weapons in our arsenal to fight those cold starts.

Kelly 26:33
We do and remember, Performance Optimization is an ongoing battle,

Chris 26:37
right? We have to keep monitoring and tweaking things exactly. Monitor your

Kelly 26:41
functions, identify bottlenecks, experiment with different techniques. This has been

Chris 26:46
an amazing deep dive into AWS Lambda. I feel like I've learned so much me too.

Kelly 26:50
Yeah, it's been fun exploring all the different facets of Lambda.

Chris 26:54
And to all of our listeners out there, we hope you've learned a lot too, especially if you're gearing up for that AWS exam. Absolutely

Kelly 27:00
and remember, the learning doesn't stop here. Serverless computing is constantly evolving. So keep exploring, keep experimenting, and keep pushing the boundaries.

Chris 27:11
That's great advice until next time, everyone, keep building awesome things in the cloud and good luck

Kelly 27:16
with that exam. You.