Docker Crash Course for Beginners

In this lesson, we'll take a simple Go application from a GitHub repository and turn it into a Docker image using a custom Dockerfile.

You'll learn how each instruction works: FROM, WORKDIR, COPY, RUN, ENTRYPOINT and CMD. How they fit together to define a reproducible container image.

By the end, you'll understand how to package any Go app (or other language) into a portable and isolated container ready to run anywhere.

In this lesson, you'll get hands-on with Docker containers.

We'll start by running your first container using docker run, then explore how to list running containers with docker ps, inspect stopped ones with docker ps -a and manage their lifecycle using stop, start and logs. You'll also learn how to expose ports from your container to your host using the -p flag.

By the end of this section, you'll feel comfortable creating, viewing and interacting with containers in your local environment.

In this lesson, we'll break down what the Docker build context really is and why it matters.

You'll learn how everything inside the context (usually .) gets sent to the Docker daemon during a build and how that can slow down builds or expose sensitive data if not handled properly.

We'll show you how to use a .dockerignore file to exclude unnecessary files and folders, making your builds faster, smaller and more secure.

This is a critical step for any real-world Docker workflow.

In this lesson, you'll learn how to create optimized Docker images using multi-stage builds.

We'll start with a traditional image that includes all your build tools (like Go or Node.js) and then show how to split the build and runtime environments to significantly reduce image size and surface area.

You'll understand:

1. Why large images are problematic in production.

2. How each FROM instruction starts a new build stage.

3. How to copy only the final artifacts (like binaries or build folders) into a minimal runtime image (like Alpine in our case).

By the end, you'll be writing clean, secure and production-ready Dockerfiles using best practices.

In this lesson, you’ll learn how to build Go applications for different operating systems and CPU architectures using Docker.

We’ll explore how to define build-time arguments (ARG) in your Dockerfile and how to pass values like GOOS and GOARCH using the --build-arg flag during the build process. You'll understand the difference between ARG and ENV and how to use them together to make your Docker builds portable and platform-aware.

By the end of this video, you’ll be able to compile your Go apps for any target. Whether it’s Linux, ARM64 for Raspberry Pi or amd64 for desktop using a single, reusable Dockerfile.

In this lesson, we'll dive into Docker registries: the place where Docker images are stored and shared.

You'll learn:

1. What a Docker registry is and why it's important.

2. How Docker Hub works (the default public registry).

3. How Docker knows where to pull an image from.

4. How to authenticate to private registries.

5. How to push and pull images from a registry (public or private).

By the end, you'll understand where your images are stored, how they get shared across environments and how to securely work with private registries when needed.

In this section, you'll learn how to interact with running Docker containers using real-world commands you'll use daily.

We'll cover:

• docker run: how to start containers from an image

• --name: assigning human-readable names to your containers

• docker ps: listing active containers

• docker stop, start, rm: controlling and cleaning up containers

• docker logs: reading container output

• docker inspect: digging into metadata and container configuration

By the end of this lesson, you'll be comfortable starting, inspecting, stopping, and cleaning up containers, an essential skill for any Docker-based workflow.

In this section, you'll learn how Docker volumes work and why they're essential for persistent data.

You'll create a volume, attach it to a container, store data, remove the container and then start a new one with the same volume, confirming your data is still there.

This hands-on demo gives you a clear understanding of how to decouple container lifecycles from your data, a critical skill for building real-world Dockerized applications.

In this section, we dive into how Docker handles networking between containers.

You'll learn what Docker networks are, why they matter and how containers communicate with each other across different network types.

We'll explore how to create, inspect and manage Docker networks. See how Docker provides DNS-based service discovery out of the box.

By the end of this chapter, you'll understand:

• The types of Docker networks and when to use each.

• How containers can find and talk to each other.

• How to create custom networks for isolated, secure setups.

• How Docker's internal DNS works and how to troubleshoot common issues.

  
  

This knowledge is essential for working with multi-container applications and services that depend on talking to each other.

In this chapter, you'll learn how Docker handles networking between containers.

We'll use the Docker CLI to inspect existing networks, create new ones and connect or disconnect containers from them. You'll also access a running container to explore how DNS resolution works inside Docker by performing nslookup commands.

By the end of this lesson, you'll have a solid understanding of how containers communicate with each other, how Docker's internal DNS works and how to manage network isolation and connectivity using simple CLI commands.

In this lesson, we introduce Docker Compose and explain why it's such a powerful tool for managing multi-container applications.

You'll learn what Docker Compose is, how it works and why it simplifies your workflow when dealing with complex setups.

We'll build a real-world example by running our own instance of n8n connected to a PostgreSQL database, all orchestrated using docker-compose.yml.

You'll understand the structure of this file, how services relate to each other and how Compose helps you spin up entire environments with a single command.

By the end of this chapter, you'll know how to:

• Define services in a docker-compose.yml.

• Manage environment variables.

• Set up service dependencies.

• Persist data using named volumes.

In this video, we put everything into action using docker compose up and docker compose down.

You'll see how to:

• Spin up a working instance of n8n connected to a PostgreSQL database.

• Use environment variables and volumes to configure your setup.

• Access the n8n UI in your browser.

• Stop and clean up the containers properly.

This is where Docker Compose shows its real value: one command to start your entire stack, and another to shut it down. Fast, consistent, and easy to replicate.

By the end of this lesson, you'll have a fully working local automation platform running with just a few lines of YAML and two simple commands.

This challenge is based on a real-world bug that caused intermittent 502 errors in production. It drove developers crazy for weeks. Sometimes it worked, sometimes it didn't. The cause? Subtle. The fix? Simple, once you see it.

The rules:

• Run the simulation script provided.

• Don't peek inside the file.

• Use only Docker commands — no AI, no search, just your brain.

• Then solve the same problem using an AI assistant and compare the results.

• Log your time for both approaches and see which one wins.

This is not just about fixing a bug. It's about understanding the Docker environment, containers networking and the limitations of tools like Nginx.

Download materials, track your time and share your results in the comments.

Now that you have a solid understanding of Docker fundamentals, it's time to look ahead. In this final section, we'll explore what comes after mastering Docker.

You'll get a high-level introduction to CI/CD pipelines and see how Docker plays a key role in automated builds, testing and deployments. We'll also talk about container orchestration with Kubernetes, what it is, when you need it and how it connects with everything you've learned so far.

To wrap things up, we'll cover essential concepts around monitoring and observability in containerized environments, highlighting why it's crucial to keep an eye on your apps once they're running in production.

Finally, I'll share clear next steps to help you keep growing: what topics to explore, what real-world projects to try and how to keep improving your DevOps and cloud-native skills.

This is where everything starts to come together, from learning Docker to actually using it in modern development workflows.

This bonus lecture is all about what comes next after the course. If you enjoyed learning Docker with me, there's a lot more content waiting for you.