WEBVTT 00:00.950 --> 00:07.190 All right, so before anything, what I want to do is delete everything from my Docker cache. 00:07.190 --> 00:09.050 So Docker system prune a. 00:09.080 --> 00:14.420 You can also go into your Docker dashboard and press the X button on whatever you need to delete. 00:14.420 --> 00:19.700 Anyways I will remove all stopped containers, all images, all builds that we did so far. 00:19.730 --> 00:22.460 I guess I didn't have anything on my system. 00:22.460 --> 00:30.020 All right, so um, here is the next app that we need to containerize. 00:30.020 --> 00:35.120 Here we have the developer, captain DevOps, telling us there are a couple of ways to get this flask 00:35.150 --> 00:36.710 app up and running. 00:37.520 --> 00:41.720 First we install the dependencies with pip install requirements.txt. 00:41.720 --> 00:45.200 So there's one thing I want to make note of. 00:45.230 --> 00:53.360 Make note of is that this is the first app that we're running that requires dependencies in order to 00:53.360 --> 00:54.080 run. 00:54.410 --> 00:57.260 Uh, the apps before it did not need dependencies. 00:57.260 --> 00:58.670 They were very simple. 00:58.670 --> 01:01.130 Hello World apps. 01:01.130 --> 01:05.450 So this is going to change our Docker workflow just a little bit. 01:06.200 --> 01:13.280 Because what I want to do is create an image that already contains all the dependencies. 01:13.280 --> 01:18.740 So we're going to run this command during the image building phase. 01:18.740 --> 01:26.210 And then after we have an image that includes the source code, the dependencies that the code relies 01:26.210 --> 01:29.900 on in order to compile, and the pre-configured Python environment. 01:29.900 --> 01:32.000 In this case this is a Python application. 01:32.030 --> 01:39.320 Then we're going to provide the container with the commands that it needs to execute the Python application. 01:39.320 --> 01:44.870 So we can provide the container with two separate commands um with two different commands. 01:44.870 --> 01:49.670 One way of running this Python app, according to our dear developer myself in this case. 01:49.670 --> 01:54.470 But let's just pretend I'm captain DevOps or captain DevOps and we're on this DevOps journey. 01:54.470 --> 01:58.180 There are two ways to run this Python app after you've installed the dependencies. 01:58.180 --> 02:07.120 Python app.py or another way of running a flask app is to set a flask app shell environment variable 02:07.120 --> 02:15.250 equal to the entry point of your web application so that when Flask Run is invoked, it knows to start 02:15.250 --> 02:18.820 running the flask app from this file. 02:18.910 --> 02:24.220 Okay, so let's just go ahead and start setting up the Docker file. 02:24.220 --> 02:27.490 It's going to make a lot of sense once we do that. 02:27.490 --> 02:32.110 So from base image is typically the first thing that we run. 02:32.110 --> 02:40.900 Because we need to pull a Python environment that our app relies on in order to compile. 02:40.900 --> 02:47.830 So Python 3.8 slim is the image that I want to pull from Docker Hub. 02:48.610 --> 02:55.120 And then we want to set the directory where we want this application to run once we create a container. 02:55.120 --> 03:01.660 So workdir the application is going to run inside the directory slash app. 03:01.690 --> 03:02.470 All right. 03:02.500 --> 03:06.370 Then we need to copy the project files into the working directory. 03:06.400 --> 03:14.500 What I want to do at first is just say copy the source where it's going to set equal to dot the destination 03:14.500 --> 03:16.090 equal to dot as well. 03:16.090 --> 03:20.650 So dot in the first argument means current directory. 03:21.340 --> 03:25.570 So the directory that the docker file is in is oh five starter code. 03:25.570 --> 03:33.820 So it's just going to copy everything inside of the current directory into the destination which is 03:33.820 --> 03:35.560 another dot the dot. 03:35.560 --> 03:38.290 And the second argument means working directory. 03:38.290 --> 03:45.010 So copy everything in the current directory into the working directory of the container. 03:45.220 --> 03:48.880 All right then we're going to install the dependencies. 03:48.880 --> 03:56.080 So the run command executes a command during the image building phase. 03:56.110 --> 04:00.040 I want to distinguish between the run command and the CMD command. 04:00.040 --> 04:06.580 So the run command executes a command while we're building the image, and any dependencies that we 04:06.580 --> 04:11.050 install in this step will be inside of the image itself. 04:11.140 --> 04:19.210 CMD provides the container with the commands that it needs to run the application. 04:19.750 --> 04:20.230 All right. 04:20.230 --> 04:26.470 So this, uh, this command is executed after we create a container. 04:26.470 --> 04:30.070 This command is executed as we're building the image. 04:30.070 --> 04:36.460 So the dependencies that we install here, using whatever command is given to us by the developer, 04:36.460 --> 04:39.940 they're telling us how they normally install the dependencies on bare metal. 04:39.940 --> 04:42.820 We can just copy it over here. 04:43.180 --> 04:43.840 Okay. 04:43.840 --> 04:50.050 So all the dependencies listed in requirements.txt are going to be installed inside of the image itself. 04:50.050 --> 04:51.760 The image will have the source code. 04:51.760 --> 04:55.770 It's going to have all the dependencies that the code needs in order to run, and it's going to have 04:55.770 --> 04:57.420 the preconfigured Python environment. 04:57.420 --> 05:02.340 All the container has to do is run the application with whatever command we give it. 05:02.370 --> 05:03.090 All right. 05:03.120 --> 05:05.250 Now there's one thing I want to make note of. 05:05.280 --> 05:11.160 We're copying everything in the current directory into the working directory. 05:11.160 --> 05:16.260 So the working directory is going to have the folder flask demo. 05:16.260 --> 05:23.280 And inside of it requirements.txt which means the run command is not going to be able to recognize the 05:23.280 --> 05:24.420 requirements.txt. 05:24.420 --> 05:31.770 Because what it's going to see is flask demo and inside of it is requirements.txt. 05:31.770 --> 05:37.200 So now at this point we need to document and inform the developer that the application will use port 05:37.230 --> 05:38.820 5000 of the container. 05:38.820 --> 05:44.610 So the application itself is going to be serving requests on port 5000. 05:44.610 --> 05:51.210 But because we're going to be running it inside of a container, we need to make sure to tell the developer 05:51.210 --> 05:58.200 that so that they can map the container port to some port on the machine so that it can be accessed 05:58.200 --> 05:59.040 from the outside world. 05:59.040 --> 06:00.900 So don't be confused by this command. 06:00.900 --> 06:08.760 It doesn't actually expose port 5000, it simply documents and informs whoever is creating a container 06:08.790 --> 06:10.500 out of this. 06:10.500 --> 06:18.000 Um, whoever is running this application inside of a container to map the correct port to a host machine 06:18.000 --> 06:18.840 port. 06:18.870 --> 06:19.920 All right. 06:19.920 --> 06:25.020 And now here we can define the command to run when the container starts. 06:25.020 --> 06:32.850 So, um, the command that we're going to give the container for now is Python app.py. 06:36.570 --> 06:37.380 All right. 06:37.380 --> 06:46.050 I want to make note of the fact that we kind of have a command that runs during the image building phase, 06:46.050 --> 06:51.000 and a command that is given to a container after that container is created. 06:51.030 --> 06:52.440 We should be. 06:52.470 --> 06:53.280 Oh, no. 06:53.280 --> 06:54.690 I made a mistake. 06:54.720 --> 07:00.540 So remember that I said that after step two, everything happens inside the working directory. 07:00.540 --> 07:05.880 So when the container runs Python app.py, it's not going to see App.py. 07:05.910 --> 07:11.040 It's going to see flask demo because that's what we copied over into the working directory. 07:14.130 --> 07:18.390 And inside a flask demo is app.py. 07:18.450 --> 07:19.410 Okay. 07:19.920 --> 07:28.140 Now we're going to say docker build dash t I'm going to call the image flask demo. 07:30.390 --> 07:34.980 Oh sorry guys we need to CD into the appropriate directory. 07:34.980 --> 07:42.030 So CD oh five starter code clear. 07:42.960 --> 07:48.200 Then I'm going to docker build t Tea flask demo. 07:48.860 --> 07:51.860 That's what we're that's what we're going to name our image. 07:51.860 --> 07:57.560 And we're going to build an image out of the Docker file inside the current directory. 07:57.590 --> 08:00.170 Oh five starter code. 08:00.500 --> 08:01.400 Okay. 08:01.430 --> 08:04.370 Fingers crossed everything works smoothly. 08:07.730 --> 08:08.300 All right. 08:08.300 --> 08:12.020 So here we have the first layer of our application pulling. 08:12.080 --> 08:13.100 Let me just wait till it's done. 08:13.130 --> 08:13.520 All right. 08:13.520 --> 08:19.820 So here we have the first layer of of our application pulling the Python environment from Docker Hub. 08:19.820 --> 08:25.460 So our overall image includes the base image Python 3.8 slim. 08:25.460 --> 08:30.680 Which means we now have access to a Python environment that we can use to run the app, while the container 08:30.680 --> 08:32.330 will have access to a Python environment. 08:32.360 --> 08:35.270 Now then we have work dir app. 08:35.270 --> 08:39.830 Here we're just setting up the working directory, the working directory where all the magic is going 08:39.860 --> 08:40.520 to happen. 08:40.520 --> 08:46.700 Then we copy literally everything inside the current directory that the Docker file is in. 08:46.730 --> 08:48.650 Into the working directory. 08:48.650 --> 08:54.350 So the working directory is going to actually include the docker file and the flask demo project. 08:54.380 --> 08:55.520 I know what you're thinking. 08:55.520 --> 09:00.350 We should have a docker ignore so that the docker file doesn't go into it, but whatever. 09:01.280 --> 09:03.230 Then the fourth step. 09:03.260 --> 09:06.530 Remember, everything here is happening during the image building phase. 09:06.530 --> 09:09.470 We haven't actually created any containers yet. 09:09.470 --> 09:12.530 The fourth step happens while we're building the image. 09:12.530 --> 09:21.260 So that is going to install all the dependencies inside of requirements.txt into the image itself. 09:21.260 --> 09:26.540 So when the container runs the application, it's going to have access to all the dependencies that 09:26.540 --> 09:28.490 the application needs in order to compile. 09:28.490 --> 09:34.400 It's going to have access to the preconfigured Python environment, and it's going to be able to successfully 09:34.400 --> 09:37.220 run the app using the command that we give it. 09:37.220 --> 09:46.310 So now if I do docker build, not docker build docker run to create a Docker container out of the image 09:46.310 --> 09:52.100 that we just created, the image that includes the source code, the environment and the dependencies. 09:52.100 --> 10:00.950 Everything should work smoothly, but as always, we're going to name the container flask demo container. 10:01.040 --> 10:06.650 And what we're going to do is set it to automatically remove when we're done with it. 10:06.650 --> 10:08.390 And there's one more thing. 10:08.540 --> 10:17.540 So looking at the expose command, this tells me that the application, without looking at the code 10:17.540 --> 10:24.260 itself, me, the person running the container, I can tell the app is using port 5000 of the container 10:24.260 --> 10:30.410 to serve requests, while the containers network is completely isolated from my host machine's network. 10:30.410 --> 10:33.860 So if I say localhost 5000, it's not going to work. 10:33.860 --> 10:36.110 So what I need to do is map. 10:36.200 --> 10:37.760 We're going to do a port mapping. 10:37.760 --> 10:43.490 So I usually like to do this right after a docker run we're going to say dash P for port mapping. 10:43.490 --> 10:50.480 We're going to map the container port that the application is serving requests on to a host machine 10:50.480 --> 10:51.140 port. 10:51.170 --> 10:54.440 In the interest of, I don't know, messing around. 10:54.440 --> 10:56.660 We'll make it port 8080. 10:57.320 --> 11:05.390 So when I say localhost 8080, it's going to map to the container port 5000 where the where the application 11:05.390 --> 11:07.160 is going to be serving requests. 11:07.370 --> 11:08.330 All right. 11:08.360 --> 11:09.620 Let's do it. 11:10.100 --> 11:13.730 Now let me go to localhost 8080. 11:13.730 --> 11:19.850 And I might have been playing around with this before the demo started, but everything works beautifully. 11:19.880 --> 11:20.900 Okay. 11:22.100 --> 11:29.300 Now, um, before we continue, let's start up an interactive shell. 11:30.170 --> 11:31.340 So over here. 11:31.370 --> 11:31.970 Sorry. 11:32.000 --> 11:32.750 We'll. 11:35.210 --> 11:43.960 After the port mapping, we'll say dash it And then we're going to start up an interactive shell. 11:43.960 --> 11:46.540 So slash bin slash shell. 11:47.320 --> 11:48.880 Beautiful LZ. 11:48.910 --> 11:52.270 Here we see the Docker file and flask demo. 11:52.300 --> 11:53.710 Now I know what you're thinking. 11:53.710 --> 12:03.400 We could have a docker ignore that removes the docker file, or it ignores the docker file when copying 12:03.400 --> 12:05.530 the project files into the working directory. 12:05.530 --> 12:07.870 But I want to do something else. 12:08.560 --> 12:16.270 What I want to do is instead of copying everything into the working directory, I want to copy what's 12:16.270 --> 12:19.630 inside a flask demo into the working directory. 12:19.630 --> 12:22.600 So, um, let's exit. 12:23.890 --> 12:28.510 So I want to copy what's inside of flask demo. 12:28.540 --> 12:34.000 I don't want to include the flask demo folder inside of the work. 12:34.000 --> 12:34.240 Dir. 12:34.270 --> 12:41.620 Just what's inside of the flask demo folder into the working directory, which means the working directory 12:41.620 --> 12:47.110 is only going to see app routes, dot pi, app dot pi and requirements.txt. 12:47.110 --> 12:55.150 So inside the working directory the run command is not going to see flask demo, it's going to see requirements.txt, 12:55.270 --> 13:04.360 which means when the container is running the application inside the working directory it's going to 13:04.390 --> 13:05.920 straight up see app dot pi. 13:05.950 --> 13:08.170 There is no flask demo folder anymore. 13:08.200 --> 13:13.450 Before I let the container run the app on its own, let me start up an oh well, we need to rebuild 13:13.450 --> 13:17.110 the image because we changed the docker file. 13:17.410 --> 13:20.200 Now we have a whole new image. 13:20.230 --> 13:21.640 Okay. 13:21.670 --> 13:27.490 And then I'm going to say then we're going to start up an interactive shell LZ. 13:28.870 --> 13:34.030 Now in the working directory we just straight up have the files themselves. 13:34.360 --> 13:38.500 Um, if the container were to run Python app.py. 13:39.580 --> 13:41.590 It would work beautifully. 13:41.620 --> 13:44.860 We're going to let the container run the command on its own. 13:44.860 --> 13:48.610 So I used control C to exit from this runtime. 13:48.610 --> 13:51.940 And then I can press exit to exit the interactive shell. 13:53.170 --> 13:55.570 And now uh do do do do. 13:55.600 --> 13:59.020 I'm just going to let the container run the app on its own. 14:01.120 --> 14:03.910 Without us having to do it for it. 14:07.630 --> 14:08.140 All right. 14:08.140 --> 14:08.890 Beautiful. 14:08.920 --> 14:11.530 Um, let's just test it out. 14:11.560 --> 14:14.800 You can never be too safe. 14:15.220 --> 14:16.180 All right. 14:16.630 --> 14:17.980 What else did I want to teach you? 14:18.010 --> 14:20.830 Let me just check my clipboard real quick. 14:20.860 --> 14:25.330 Do do do do are really important. 14:26.230 --> 14:34.180 So, um, I want to change up our workflow a little bit just to get you more comfortable. 14:34.320 --> 14:39.270 So here's what I want to do first. 14:40.080 --> 14:40.500 Okay. 14:40.500 --> 14:42.210 Here's the diagram we're going to use. 14:42.210 --> 14:42.720 First. 14:42.720 --> 14:48.870 The only thing I want to copy into the working directory is just the requirements.txt. 14:48.900 --> 14:49.860 Okay. 14:50.100 --> 14:57.810 Then we're going to use the run command to install all the dependencies inside of requirements.txt. 14:57.840 --> 15:05.310 After the dependencies have been installed, they're going to be inside of the Docker image itself. 15:05.400 --> 15:15.450 Then we're going to copy over the remaining source code into the working directory and and do the same 15:15.450 --> 15:15.840 thing. 15:15.930 --> 15:18.300 Document that it's using port 5000. 15:18.330 --> 15:21.180 That's the port that needs to be exposed by the container. 15:21.180 --> 15:24.270 And then provide the container with the commands that it needs to run the app. 15:24.270 --> 15:30.570 So so it's actually good practice to be more purposeful with what you copy over step by step. 15:30.570 --> 15:38.550 That way you have more fine grained control over the image building process and can therefore modify 15:38.550 --> 15:40.380 it as you see fit. 15:41.220 --> 15:45.720 Um, and so once we have that all set up, we're going to create a container. 15:45.750 --> 15:51.990 A container is going to use the command that it was provided to run the application itself, located 15:51.990 --> 15:54.030 inside the Docker image. 15:54.030 --> 15:56.340 So the Docker image has got the application. 15:56.340 --> 15:57.420 It's got the dependencies. 15:57.420 --> 15:59.640 It's got the Python environment. 15:59.640 --> 16:03.180 All the container has to do is say Python app.py. 16:03.690 --> 16:04.650 All right. 16:04.770 --> 16:09.030 It doesn't actually need to say Python app app dot pi, but whatever. 16:09.030 --> 16:11.070 We'll just keep it there for reference. 16:11.160 --> 16:11.700 Okay. 16:11.700 --> 16:13.470 So let's change it up a little bit. 16:13.530 --> 16:20.370 Um, we're just going to copy the requirements.txt file first into the working directory. 16:20.430 --> 16:21.240 Okay. 16:22.140 --> 16:26.550 So flask demo slash requirements.txt. 16:28.020 --> 16:36.450 Then we install The dependencies inside requirements.txt inside the image itself. 16:36.570 --> 16:45.270 Then we're going to copy the remaining project files into the working directory. 16:45.870 --> 16:53.280 Now if you prefer the the the approach of just copying everything over all at once, uh, instead of 16:53.280 --> 16:57.150 splitting it up into different steps, that's fine. 16:57.150 --> 17:00.240 But it's good to be familiar with more than one way of doing something. 17:00.240 --> 17:01.710 So copy. 17:02.970 --> 17:10.590 Uh, then we're just going to copy over everything else into the working directory, and that's it. 17:12.150 --> 17:19.650 We shouldn't see much of a change except from how the image itself is being constructed. 17:20.220 --> 17:25.830 But when you're able to do things like this, it's a testament to how comfortable you are with building 17:25.830 --> 17:26.610 images. 17:26.640 --> 17:27.270 Right. 17:27.270 --> 17:31.070 So now we're pulling the Python image. 17:31.070 --> 17:33.710 We have it local, so it takes zero seconds. 17:33.710 --> 17:36.020 We don't have to pull it from Docker Hub anymore. 17:36.530 --> 17:43.220 Uh, we're setting up the working directory slash app copying over first. 17:43.220 --> 17:47.240 We're only copying over the requirements.txt file at this point. 17:47.600 --> 17:51.800 Um, the image does not know anything about app.py or app routes. 17:51.800 --> 17:52.340 Dot py. 17:52.340 --> 17:54.740 It only has the requirements.txt file. 17:54.770 --> 18:02.810 It installs all the dependencies inside the requirements.txt file, and then it copies over the remaining 18:02.840 --> 18:07.430 files into the working directory only after the dependencies have been installed. 18:07.430 --> 18:13.400 So after the dependencies that the application relies on have been installed, then it copies over the 18:13.400 --> 18:14.270 application. 18:14.270 --> 18:18.200 It's much better practice to do it that way, in my honest opinion. 18:18.200 --> 18:19.760 But some people don't really care. 18:19.760 --> 18:22.550 They just dump everything in there all at once. 18:24.050 --> 18:26.240 And it's totally valid to to be honest. 18:26.240 --> 18:28.430 And then we can just say Docker run. 18:29.330 --> 18:34.820 And, uh, let me just use the container from before. 18:35.450 --> 18:37.190 And everything works beautifully. 18:37.220 --> 18:39.920 Is there anything else I wanted to. 18:39.950 --> 18:42.080 Yes there is. 18:42.680 --> 18:50.150 So our dear developer myself, uh, told us there are two ways to run the app after dependencies have 18:50.150 --> 18:50.870 been installed. 18:50.870 --> 18:56.900 So we can provide the container with this command or with this command flask run. 18:56.900 --> 19:07.040 But this command relies on a an environment shell variable being set first the environment the flask 19:07.040 --> 19:08.150 run command. 19:08.150 --> 19:14.870 When it sees the environment shell variable, it understands what the entry point of the application 19:14.870 --> 19:19.430 is and therefore knows where to start when to run the app. 19:19.430 --> 19:28.070 So different applications that you dockerize quote unquote will have different environment shell variables 19:28.070 --> 19:31.910 that you can actually set directly in your Docker file. 19:32.630 --> 19:35.960 So if I want to set an environment shell variable. 19:35.960 --> 19:38.510 So this was one way to do things. 19:39.500 --> 19:46.010 Let me fix up the numbering 1234567. 19:46.400 --> 19:49.850 So this was one way of doing things. 19:50.420 --> 19:57.920 Another way of running the application is to set an environment shell variable. 19:58.130 --> 20:06.800 So on bare metal you would just say for your terminal you would have just said export flask app equals 20:06.830 --> 20:07.700 app dot pi. 20:07.700 --> 20:14.210 And then when you say flask run it's going to use that shell variable to know how to run the application. 20:14.690 --> 20:21.140 Uh, in this case we can provide the environment shell variable over here. 20:21.140 --> 20:22.520 So we say env. 20:23.240 --> 20:28.270 The key is going to be flask app. 20:31.870 --> 20:33.880 And the value app dot Pi. 20:33.910 --> 20:41.980 So anything that you do bare metal Docker typically provides the flexibility to do inside of its ecosystem 20:41.980 --> 20:43.090 as well. 20:43.120 --> 20:48.190 So we can set the environment variable, the environment shell variable as. 20:48.190 --> 20:54.610 So then we can provide the container with the commands that it needs to run the application. 20:54.640 --> 20:58.180 So now the command is going to be flask run. 20:59.080 --> 21:05.170 The container is going to successfully execute this command upon us giving it the environment shell 21:05.200 --> 21:06.730 variable as well. 21:06.910 --> 21:07.540 All right. 21:07.540 --> 21:15.100 So um, you know how you and I, we would run export flask app within our terminal itself? 21:15.130 --> 21:21.460 Well, now we're providing the container with the means of it doing that itself and then calling flask 21:21.460 --> 21:22.000 run. 21:22.000 --> 21:24.280 Pretty cool if you ask me. 21:24.910 --> 21:27.310 Let me go ahead and rebuild the image. 21:29.020 --> 21:30.550 All right. 21:31.030 --> 21:32.410 Docker run. 21:33.490 --> 21:34.720 Beautiful. 21:34.750 --> 21:36.790 Never hurts to test. 21:42.100 --> 21:43.630 That's super weird. 21:43.690 --> 21:47.410 Um, let me try something out. 21:51.910 --> 21:52.870 All right. 21:53.500 --> 21:55.240 Rebuild the image. 22:03.550 --> 22:04.750 All right. 22:05.290 --> 22:07.270 I suspected as much. 22:07.360 --> 22:11.170 This has more to do with how flask runs its applications. 22:11.170 --> 22:17.860 When you run an application using Flask Run, it automatically binds the server to local host. 22:17.890 --> 22:23.830 If you think about the flask application running inside of a Docker container. 22:23.860 --> 22:31.090 Local host in this case is what it's local to the container itself, which means it's unable to access 22:31.090 --> 22:34.660 anything outside the container even if we do the port mapping. 22:34.720 --> 22:44.500 If we say dash dash host 0.0.0.0, it basically allows the application to be able to accept requests 22:44.500 --> 22:49.480 from any available network interface, in this case from any IP address. 22:49.480 --> 22:57.250 We're trying to access it from the IP address of our local machine, which is why adding this allows 22:57.280 --> 23:02.140 us to bypass the restriction imposed upon us by flask itself. 23:02.140 --> 23:08.110 So under this caveat, I would have preferred to just run it using Python app.py. 23:08.140 --> 23:16.810 But um, just know that this is a typical command that is used to run flask applications. 23:16.810 --> 23:23.580 In this case, we need it to provide the container with a command that allows us to run the application 23:23.580 --> 23:25.050 with unrestricted access. 23:25.050 --> 23:29.430 Now, these little caveats can vary from one application to another. 23:29.430 --> 23:35.610 With a little research and troubleshooting, you should be able to understand what's going on and move 23:35.610 --> 23:36.180 from there. 23:36.180 --> 23:41.970 And it's only through bugs and errors that we are able to grow as developers. 23:41.970 --> 23:45.420 So it's good to explore many different ways of doing something. 23:45.420 --> 23:52.650 In the interest of keeping things simple, I'm going to resort to Python App.py doesn't need an environment 23:52.650 --> 23:56.130 shell variable after we have the dependencies in our image. 23:56.130 --> 23:58.500 After we have the Python environment. 23:58.500 --> 24:03.060 Simply running app.py is a lot simpler in my opinion. 24:03.630 --> 24:06.750 All right, that's it for this lesson. 24:07.560 --> 24:12.780 Uh, now we're going to look into Dockerizing, a spring boot application. 24:13.200 --> 24:18.300 This is another application, but this time running in a maven Java environment.