Reproducibility + Docker

Outcome: Pass cold-clone -> build check Curated video (The Coding Sloth): The Only Docker Tutorial You Need To Get Started — https://www.youtube.com/watch?v=DQdB7wFEygo (verified live via yt-dlp 2026-09-24). Pointer: lambda/face-analysis/Dockerfile pattern; shell: courses/video-scripts/mlops-cloud-deploy/01.md.

12 minutesVideo LessonPDF notes

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Ready to continue?

Mark this lesson as complete when you're ready to proceed.

Key moments

Developer's Law — The problem of code working on one machine but failing on others necessitates a solution for reproducibility.
What Docker Does — Docker packages code, dependencies, and environment settings into lightweight containers, ensuring portability.
Image vs Container — The Image is the recipe containing instructions, while the Container is the runnable instance created from that recipe.
The Dockerfile — The Dockerfile is where the image build instructions are written, starting with a base image using the FROM command.
Optimizing with Caching — Dependencies are installed early in the Dockerfile to utilize layer caching, which speeds up subsequent builds significantly.
RUN vs CMD — RUN executes commands during the image build process, whereas CMD defines the command that starts the container.
Build and Run — The `docker build` command creates the image, and `docker run` starts the container, requiring port forwarding using the -p flag.
Docker Compose Intro — Docker Compose is used to manage multi-container applications by defining how separate services work together.
Compose File Structure — The `compose.yaml` file defines services, specifying build context, images, ports, and environment variables for each container.
Volumes for Persistence — Docker Volumes are necessary to persist data outside the container lifecycle and allow data sharing between services.

PDF notes

Bottom line: You will learn how Docker solves the "works on my machine" problem by packaging applications into portable containers. You will be able to write a basic Dockerfile, build an image, run a container, and use Docker Compose to manage multi-container applications. This ensures your code runs consistently across all environments.

This lesson on Reproducibility + Docker is hands-on and example-driven. You will learn how Docker solves the "works on my machine" problem by packaging applications into portable containers. You will be able to write a basic Dockerfile, build an image, run a container, and use Docker Compose to manage multi-container applications. This ensures your code runs consistently across all environments.

What You'll Be Able To Do

Define the roles of Docker images and containers in application deployment.
Write a Dockerfile to containerize a simple application using best practices like layer caching.
Execute commands to build a Docker image and run a container instance with port forwarding.
Differentiate between the Dockerfile instructions RUN and CMD.
Utilize Docker Compose to define and manage multi-service applications (e.g., web app + database).

Topics Covered in Reproducibility + Docker

Developer's Law (0:00 - 0:45) — The problem of code working on one machine but failing on others necessitates a solution for reproducibility.
What Docker Does (0:45 - 1:50) — Docker packages code, dependencies, and environment settings into lightweight containers, ensuring portability.
Image vs Container (1:50 - 2:55) — The Image is the recipe containing instructions, while the Container is the runnable instance created from that recipe.
The Dockerfile (3:50 - 4:50) — The Dockerfile is where the image build instructions are written, starting with a base image using the FROM command.
Optimizing with Caching (5:00 - 6:30) — Dependencies are installed early in the Dockerfile to utilize layer caching, which speeds up subsequent builds significantly.
RUN vs CMD (6:30 - 7:30) — RUN executes commands during the image build process, whereas CMD defines the command that starts the container.
Build and Run (7:30 - 8:30) — The docker build command creates the image, and docker run starts the container, requiring port forwarding using the -p flag.
Docker Compose Intro (9:30 - 10:30) — Docker Compose is used to manage multi-container applications by defining how separate services work together.
Compose File Structure (10:30 - 11:30) — The compose.yaml file defines services, specifying build context, images, ports, and environment variables for each container.
Volumes for Persistence (11:30 - 12:30) — Docker Volumes are necessary to persist data outside the container lifecycle and allow data sharing between services.

SQL Cheat Sheet

Docker Image — The recipe containing instructions and dependencies for the code
Docker Container — A runnable instance created from an image; the isolated environment
- In practice: docker run -p 8080:3000 my-app
Dockerfile — Text file containing sequential instructions to build a Docker image
```
FROM node:22
WORKDIR /app
```
docker build -t <name> . — Command to build an image from the Dockerfile in the current directory
- In practice: docker build -t web-server .
CMD ["<command>"] — Defines the default command executed when the container starts
- In practice: CMD ["npm", "start"]
Layer Caching — Docker reuses unchanged layers to significantly speed up image builds
- In practice: COPY package*.json . RUN npm install
docker compose up — Reads the YAML file and starts all defined multi-container services
- In practice: docker compose up -d
Docker Volume — A folder on the host machine used to persist container data
- In practice: volumes:
- postgres_data:

Comparison Table

Concept	Purpose	Execution Timing
Docker Image	Blueprint for the application environment.	Built once, stored, and shared.
Docker Container	Running instance of the application.	Created from image, runs code, stopped.
RUN	Execute commands during image creation.	During `docker build` (creates new layer).
CMD	Define startup command for the service.	When `docker run` starts the container.

Common Pitfalls

Mistake: Using RUN npm start in the Dockerfile. Avoid: Use CMD ["npm", "start"] to start the container instance.
Mistake: Installing dependencies after copying all code. Avoid: Copy package files first to leverage Docker's layer caching.
Mistake: Copying large files like node_modules. Avoid: Use a .dockerignore file to exclude unnecessary files and folders.
Mistake: Forgetting to map ports when running the container. Avoid: Use the -p flag (e.g., -p 8080:3000) with docker run.
Mistake: Combining multiple services into one container. Avoid: Separate services (like DB/backend) using Docker Compose.

FAQs

What is the difference between an Image and a Container? The Image is the static recipe containing all instructions and dependencies. The Container is the dynamic, running instance created from that recipe.
Why should I install dependencies before copying the rest of my code? This optimizes layer caching. If only your application code changes, Docker skips reinstalling dependencies, resulting in much faster builds.
What is the purpose of the .dockerignore file? It lists files and folders (like node_modules) that should be excluded from the image build context. This keeps images small and build times fast.
How do I debug a running container? You can use Docker Desktop to view logs and execute terminal commands, or use the command line tool docker exec.
What happens to my database data when I stop a container? Data is lost unless you use Docker Volumes. Volumes persist data on the host machine, allowing containers to save and share state.

Common pitfalls

Mistake: Using `RUN npm start` in the Dockerfile. Avoid: Use `CMD ["npm", "start"]` to start the container instance.
Mistake: Installing dependencies after copying all code. Avoid: Copy package files first to leverage Docker's layer caching.
Mistake: Copying large files like `node_modules`. Avoid: Use a `.dockerignore` file to exclude unnecessary files and folders.
Mistake: Forgetting to map ports when running the container. Avoid: Use the `-p` flag (e.g., `-p 8080:3000`) with `docker run`.
Mistake: Combining multiple services into one container. Avoid: Separate services (like DB/backend) using Docker Compose.

Hi, so you're a developer? Well, you think you're a developer. Nice. Building apps is pretty cool, except when it's not. Let's say you're building a web app. The web app works perfectly. Hey, it's not working. What? Yeah, it's not working, but it works on my machine. This has happened since the beginning of technology. Let me show you. Hey, it's not working. It works on my machine. Now, this has happened, or will happen to every programmer. We call this developer's law. Any code that works perfectly on your machine will inevitably fail on everyone else's. I made that up by the way. But what if I told you there's a way to prevent this? This is Docker. Docker? I hardly know her. So what's Docker? Well, it's the sponsor of today's video. Oh, no wonder. Docker is the number one most used developer tool, based off a Stack Overflow survey, that helps you develop, ship, and run applications within lightweight containers. What? Okay, so Docker is actually pretty simple and something you should know. Sloth, why should I know Docker? You should know Docker because a lot of tech companies use it, because it makes development and deployment easier. Yeah, that makes sense. Plus, it's a skill that's in a lot of job postings, which means learning Docker will make you money. Yeah, that makes sense. What makes Docker so good? Docker essentially allows us to package up our code. Imagine Docker like a Lunchable. The Lunchable has your trash code, dependencies like Node.js or Python, environment settings, and everything else needed to run your trash code. You can bring that Lunchable anywhere and give it to anyone, at school, at work. You can let your friend have it. I like my cheese drippy, bro. No matter where or who uses it, it works. So basically, Docker makes it easier to run your code on any computer because it has everything you need to run the code. No need to install anything. Docker does it all for you. Yeah, that makes sense. Now, how does Docker do that? Docker does this with two important concepts that you have to know, images and containers. Everything revolves around these two concepts, so don't forget them. You can think of images as the recipe. It contains all the ingredients and instructions. This means a Docker image contains the technology we need, runtime, and any system tools we need to run the specific code. Now we need something to actually run the code, which is where containers come in. A container is like the actual meal. It's what gets made from the recipe. Now the cool part about containers is with one image, we can create multiple container instances. What? Now, what does this mean? It means as long as you have the Docker image, you can create a container and run the code. You want proof? Here's me running a Docker image that contains Doom. Yeah, the entire game of Doom. To be fair, you can run Doom on almost anything, but this is what makes Docker amazing. It allows us to simplify the process of sharing code. You no longer have to do a tedious process like installing all these tools and making these configurations to run some code. All you need to do is run one Docker command and it does the rest for you. Yeah, that makes sense. I simplified this explanation a lot, because a lot of you have a shorter attention span than a goldfish. So if you're a nerd and you actually want to learn more about Docker, I'm going to have links in the description if you want to do your own research. Or you can check out my free newsletter called Sloth Bytes where I give you free programming information every week to make you a better programmer. And did I mention it's free? Now that you understand why Docker's important and how it works, kinda, let me show you how to actually use it. Step one, download Docker. Obviously, go to docker.com or click the link in the description and download Docker Desktop. It'll download Docker for you and it comes with a nice little GUI to manage your images and containers. But if you're feeling like a grown up, it also comes with the Docker CLI so you can do everything in the terminal. Step two, check if you have Docker. Open up your terminal and type Docker --version. If you see this, you have Docker installed. If you don't, then uh, good luck, little bro. Figure it out. Step three, set up Docker on your IDE of choice. I'm doing VS Code because I hate myself. Make sure to download the Docker extension on your IDE because it'll have language support and other goodies that'll make your life so much easier. Step four, the Dockerfile. This is pretty important. Now what's a Dockerfile? Remember our recipe analogy? This is literally where we write our recipe. Let's write one together. Here, we have a simple node server. Yeah, you heard me, Node. JavaScript. First, we're going to create the Dockerfile. And inside this file, we're going to write the steps and instructions to run the server. Now, in order to write the steps, you need to know the steps, so you need to understand how to run the server. But since we're using JavaScript, it's pretty easy. First, you get your code, then you go into the file or directory, download your dependencies, and then you run the server with the npm start command. Bodda-bing, bodda-boom. Easy peasy. Now that you understand how to run the server, all we have to do is write all that in our Dockerfile. What? So at the top of your Dockerfile, you're going to write from. And if you downloaded that Docker extension I told you to get like the good boy you are, if you hover over it, you're going to get some nice documentation. Every Dockerfile starts with this command. Now we have to select a base image. And a base image is basically just our starting point. We can use the officially supported Node.js base image that comes with everything we need. So in our Dockerfile, we're going to write from node:22. All we have to do now is write the instructions to start the server. So underneath the from command, you're going to type workdir /app. Workdir stands for working directory. And this is basically us telling Docker, "Hey, start at this point. This is where our code's going to be." The next step is a very important step. So you better listen to this step. Usually in a node project, we get our code and then download our dependency. We could do that in Docker, but that's not the best way. Instead, what we'll actually do is we're going to download our dependencies first and then get our code. So we're going to write these commands. This first command copies our package files, and the second command, well, it should be pretty obvious. It installs our dependencies. Now, why are we doing this? Unlike you and me, Docker is actually pretty smart. It has this thing called layer caching. You can basically imagine every step that we write as a layer. And Docker looks at every layer individually. So for layer caching, it goes like this. Layer change? Do it again. Layer did not change? Use cache. That's it. So the reason we do this for our dependencies is every time we change our code, it's not going to download the dependencies again. It's just going to use the cache. So it basically skips this step, which makes our builds way faster. Our next step now is to copy the code into the image. We do that with this command. Wow. Now, this command copies everything, all our files and our folders into the Docker image. But this is a problem. Since we're copying everything, that also means we're copying our node modules. That's not good, because this file is big, but not as big as your mom. We need a way to ignore that file. We can do that with a .dockerignore file. And inside that file, we're going to add the node_modules folder and any other files you don't want in there. On to the next step. In our code, we have this PORT environment variable. We need to add this into our Dockerfile. We can do that with the ENV command. Now, since this environment variable is a port, we're also going to need this command. This basically tells Docker, "Hey, we're going to need this port." Now it's time for the last step, running the server. We do that with this command. Whoa, whoa, whoa, whoa. Why'd you do it like that? And why didn't you just use RUN npm start like you did for install? Good question, actually. The reason is because the RUN keyword happens when we're building the image, while the CMD keyword is what Docker uses to actually start the container. If we use the RUN keyword for this step, the container would never start. Anyways, enough yapp. Our Dockerfile is complete. Step five, building the image. We're going to have to be grown-ups here and use our terminal. To build your image, we use the Docker build command. So inside your terminal, you're going to type Docker build -t. T stands for tag, and it basically means give your image a name tag. Understand? So give your Docker image a name. You can name it whatever you want. The last thing we're going to add is the path to our Dockerfile, which in our case is the current working directory, so all we have to do is type a period. Run this command, and you're going to see Docker running all the steps we wrote in our Dockerfile. Step six, running the container. We can do that with the Docker run command. Make sure you write the name you gave your image. Hey, what's that -p? This -p is for port forwarding. You can do your own research for that, but for now, think of it as a bridge between our computer and our container. The number on the left is the port for our computer, and the number on the right is the port for the container. If you don't add this part, it's not going to work. Go ahead, try it. I dare you. Run the command, and you're going to see that your Node server is now running. Congratulations, buddy. You know the basics of Docker. I'm proud of you. Step seven, debugging. Even though Docker makes it easier for us to share code, it doesn't stop us from building our containers wrong or from writing trash code. Luckily, debugging and checking any logs is pretty easy with Docker Desktop. So, open up Docker Desktop and look at the container that's running. It should have a little green dot. Click the container, and you can view any logs, you can execute any terminal commands, and you can see how the container is doing. Pretty simple. Now, if you think you're too good for a GUI, you can also do this in the terminal with the Docker exec command. Step eight, Docker Scout. Now, if you notice, when you ran the Docker run command, Docker gave you a recommendation to run this command, Docker Scout quickview. Now, what's Docker Scout? It's a tool created by Docker that looks inside your Docker image, and it generates a detailed report of all the packages that's inside your image. And it's looking for any vulnerabilities inside those packages. If it detects any vulnerabilities, it'll give you suggestions on how to handle them. Using Docker Scout is pretty simple. You can do it with the terminal or with Docker Desktop. I personally recommend Docker Desktop. It's really easy. Let me show you how to use it. All you have to do is go to your images, click on the image that's running, and once you're there, you're going to see this vulnerabilities tab with a button that says start analysis. Click the button, and you're done. It's that simple. Step number nine, Docker Compose and Docker Volumes. Let's be honest here. This Node example was really simple. Nowadays, babies in the womb could do this example. What if we wanted to add a database? What if we wanted to add a front-end? How do we add that with Docker? Now, you could combine all of them into one giant container, but I don't recommend that. A lot of people don't recommend that. Please don't do that. It's pretty stupid. Now, the way people usually do this is they separate each of these services and put them in their own containers. And this is called a multi-container application. What an obvious name, right? But this creates a brand new problem. Now that you have multiple containers, you have to run those containers separately, and you have to find a way to connect them all together and manage them. This is a lot of work and a lot of areas could go wrong trying to manage these containers. Lucky for us, a lot of programmers are lazy, just like me, which is why we have this tool called Docker Compose. Docker Compose is pretty easy to understand. It basically tells all your containers how to work together to create the full application. Let me show you a quick example on how to use it. Let's pretend we added a database to our Node server. So the first thing we're going to do is create a compose.yaml file. And inside that file, we're going to create an object called services. And inside that service object, we're going to be writing down keys that represent the containers we want to run, so in our case, our back-end and our database. Since our back-end is using a Dockerfile we created, we're going to use the build key, and the value is going to be the location of our Dockerfile, which in our case is the current working directory, so it's going to be a period. And remember, our back-end needs port forwarding, so we're going to add that in our configuration, too. And now, moving on to our brand new database container. What we're going to put inside of this one is the image key, because we're not using a Dockerfile for this database. Instead, what we're going to do is use a base image of the database we want to use, which for this example, I'll go with PostgreSQL. Now, our database also has some environment variables we have to add, so we can do that with the environment key, and underneath that, we just add all the information. Okay, we're almost done, I swear. I pinky promise. We just need to add one more thing, and that's a volume. Whenever we close our containers, we lose all the state and data, and our containers right now don't share data between each other. So we need to add a volume. What is that? All right. A volume is basically just a folder on our computer that Docker can access to save any data from our containers and to share that data with other containers. And it's pretty easy to create. Inside your Docker Compose file, you're going to copy down this stuff. And this line right here says, "Hey, Docker, create a volume called postgres_data." And the other one tells Docker, "Hey, we have this volume here. This is how you connect to it." Our Docker Compose file is now complete. All we have to do now is run this command in our terminal. Docker compose up. And Docker will find this configuration file and run all the containers together. And if you want to shut down your containers, then run this command, Docker compose down. And that's all you need to know about Docker Compose, because I'm too lazy to teach you anything else. Step 10, Docker Build Cloud. If you've noticed, building our containers takes a bit of time, even for the simple Node server. Now, imagine how long these containers take for a complex application. Apparently, based on this 2022 survey from Incredibuild, the average developer loses an hour just waiting on their Docker build. Docker realized this problem and recently created something to help reduce build times. They created Docker Build Cloud. And the main difference is, it builds your containers using the cloud. Yeah, it's in the name. Now, in Docker's words, using the cloud allows your builds to be up to 39 times faster. Plus, if you're working with a team, you can share the same cache with them. So one person can build the image, and now everybody can use that same cache, which speeds everything up for everybody. So if you have a more complex project or have a Docker project that takes forever to build, you should probably check out Docker Build Cloud. I'm not going to show you how to do it, because I don't have a complex project. Ah, check. You always you way. Okay, so I'm not going to lie to you all. I kind of wasted your time. You could have just done Docker an it in your terminal, and Docker would have created everything for you. So, uh, thanks for letting me waste your time. Bye.

Frequently asked questions

What is the difference between an Image and a Container?

The Image is the static recipe containing all instructions and dependencies. The Container is the dynamic, running instance created from that recipe.

Why should I install dependencies before copying the rest of my code?

This optimizes layer caching. If only your application code changes, Docker skips reinstalling dependencies, resulting in much faster builds.

What is the purpose of the .dockerignore file?

It lists files and folders (like `node_modules`) that should be excluded from the image build context. This keeps images small and build times fast.

How do I debug a running container?

You can use Docker Desktop to view logs and execute terminal commands, or use the command line tool `docker exec`.

What happens to my database data when I stop a container?

Data is lost unless you use Docker Volumes. Volumes persist data on the host machine, allowing containers to save and share state.