How to Set Up an AWS Lambda-Like Environment with Docker

[00:00 - 00:03] Hi folks. Next we've got to set up our local system.

[00:04 - 00:15] The end goal is going to be able to run your Django application in the cloud, specifically on AWS Lambda. And it's best if we simulate that same environment on your local machine.

[00:16 - 00:42] If we develop locally, natively either on Windows or Mac, when we install certain Django applications and modules, they may not be compatible with a runtime environment that AWS Lambda is going to provide. So in order to establish an environment that is most like AWS Lambda, we're going to go ahead and use Docker.

[00:43 - 01:00] If you haven't used Docker before, essentially it creates a virtual container on your system and you can configure that virtual system, however you'd like. Using Docker, we'll be able to simulate as closely as we can in AWS Lambda environment.

[01:01 - 01:19] So when we upload our AWS Django app to the cloud, it's going to be the most compatible we can get and we're going to avoid unnecessary and unpleasant surprises if things don't work in the cloud. So what you're going to need to do is download Docker Desktop.

[01:20 - 01:26] It's a free tool at Docker.com. Go ahead and download it now and install it.

[01:27 - 01:37] When you're done, at least on my Mac, you'll be able to see a little Docker icon when it's running. And if you go to the command line prompt, you can type in Docker-v to get the Docker version.

[01:38 - 01:48] Now this version that you see here may not match the version you have. It'll probably be a later version, but all the versions of Docker are going to work fine.

[01:49 - 02:14] So once you've done that, we are going to go ahead and essentially download a pre-configured Docker image that's going to be very close to AWS Lambda. So there's a GitHub repo called LambCI that have created Docker images that accurately reflect the AWS Lambda environment for various programming languages.

[02:15 - 02:23] Since we use Python, we're going to pull down the Python Docker environment. So what we want to do is type in Docker, pull LambCI.

[02:24 - 02:32] That's the organization that maintains this image. LambBuild, Python, three to eight.

[02:33 - 02:42] So three to eight is the latest version at the time of this writing that is supported in AWS Lambda. So we're going to go ahead and run this command.

[02:43 - 03:03] What this command does is it downloads the image to your local machine so that you can run it without having to re-download it again and again. Now that we've downloaded the Docker image, let's create a folder for our project.

[03:04 - 03:13] I've just calling it serverless-dz-course. You may call it whatever you'd like.

[03:14 - 03:25] And of course this directory is empty. Now what we're going to do is we're going to create a instance of the Docker container that we downloaded.

[03:26 - 03:40] So if we type in this command here, what it's going to do is invoke Docker, tell it to run an image. The dash TI makes it an interactive mode so we can use the terminal to interact with it.

[03:41 - 03:58] -v maps the local directory to the image directory var task and the -rm deletes the container after we're done with this. We specify the Lambda image that we want and we run bash, which is a shell.

[03:59 - 04:17] So once that starts up, you see we're dumped into a shell environment and this shell environment is actually the Docker instance running. So this instance is like a little piece of AWS Lambda running on your local computer.

[04:18 - 04:34] And you can see that we have everything we need to run the Lambda environment. We're going to exit the shell, which causes Docker to kill the instance and we're back to our local machine.

[04:35 - 04:45] Now that we've downloaded the generic image, we're going to customize it for our purposes. Next, we're going to create a custom Docker image.

[04:46 - 04:53] We do this using a Docker file. In your directory, go ahead and create a Docker file.

[04:54 - 05:06] I'm going to use VI, but you can use any editor you'd like or VS code. Make sure that the capital D is the only thing capitalized, the F in file is not capitalized.

[05:07 - 05:22] So I'm cutting and pasting and we're going to go through this. You don't have to understand Docker files for this course, but it's nice to be able to understand what exactly this one's doing in case you want to customize it a little bit.

[05:23 - 05:36] The first line from indicates what is the base image to use for your custom Docker image. And of course, we're using the Lamb CI Python 3.8 image.

[05:37 - 05:48] The next line here is to make the working directory var task. This is the default execution directory used by AWS Lambda.

[05:49 - 06:02] And so all your code is going to be dropped into var task when Lambda runs. The next item here is we exposing port 8000.

[06:03 - 06:17] We do that so that anything running in our container on port 8000 will be accessible to our local machine on port 8000. This lets us browse Django web application if we are running in debug mode.

[06:18 - 06:38] This next line here ensures that the prompt when you log in identifies itself as Zappa shell so that you know when you are running a Docker instance of this container. And then the last command is the command to use when running an interactive mode.

[06:39 - 06:52] Needless to say, you're not going to have to learn the intricacies of Docker files, building it, but here's the steps that we're going to take to do it. I'm going to go ahead and save this.

[06:53 - 07:16] Now that this is created, all we do is run Docker build T Docker image. All right, so Docker build, oops, Docker build is going to tell it to build a custom image and the T tells it, here's the Docker image to use.

[07:17 - 07:27] Here's the name of the Docker image to use. So our new image once it's built is going to be called Zappa Docker image and a period just says, use the current directory to build it.

[07:28 - 07:41] Okay, so that was quick and we only had to do this once. Now we have a Zappa Docker image on our local machine that we can use for all our Zappa tools.

[07:42 - 07:53] Finally, the last thing we want to do is I'm going to create a shortcut. So I don't have to type in that very long command, Docker run so and so, blah, blah, blah, blah.

[07:54 - 08:01] So what I'm going to do is I'm going to create a small script file. If you're on Windows, it's going to be called Zappa shell.bat or batch file.

[08:02 - 08:17] If you're on Linux Mac OS, just call it Zappa shell.sh. So once again, I'm going to paste that command with a couple extra parameters here.

[08:18 - 08:28] So we have Docker run TI for interactive. Then we tell it to map port 8,000 of the instance to the port 8,000 of a local machine so that we can use the browser.

[08:29 - 08:55] We set up some environmental variables so that when we get to the Zappa utility, the AWS profile is selected as the same one we set up in the last lesson. The dash V volume maps the current working directory to var task and as we know, var task is where AWS Lambda runs the custom code from your project.

[08:56 - 09:10] And we're going to map another volume here and it's going to be your .AWS credentials directory in your home directory. It's going to appear in the doc container as /root.ados.

[09:11 - 09:31] This lets all your credentials you set up in the last lesson be exposed within the Docker container. And of course, dash dash RM means delete the instance after the execution was finished and we now replace the Lamb CI Python image with our own Zappa Docker image that we just created.

[09:32 - 09:54] So having said that, go ahead and finish that. And now if we want to go ahead and run our shell file, it's going to start our custom Docker image, create an instance, Docker instance of that image and put us in the shell.

[09:55 - 10:13] And suddenly now we know we are in the shell because this is running within the Docker instance. So this is as if we have an AWS Lambda environment on our local machine.

[10:14 - 10:18] And it's pretty easy to hop into and pretty easy to hop out of just type exit. We're all done.

[10:19 - 10:26] Finally, the last thing we need is a code editor. I recommend VS code.

[10:27 - 10:35] Many people use it, it's very popular, but any code editor will do. Once you are comfortable with that, we can move on to the next lesson.

[10:36 - 10:37] (click)