Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
The Complete Podman/Docker Course
Rating: 4.2 out of 5(22 ratings)
161 students

The Complete Podman/Docker Course

A hands-on developer course covering images, Containerfiles, Compose, networking, volumes, multi-stage builds and local
Created byMehdi Haghgoo
Last updated 8/2026
English
English [Auto],

What you'll learn

  • Linux containers
  • How containers work
  • Containerizing applications
  • Work with Docker CLI
  • Work with Podman container engine

Course content

9 sections41 lectures3h 57m total length
  • What Is A Container?1:27

    Discover what a container is and how containerisation packages an application's code, libraries, and dependencies to run the same on any computer, enabling quick deployment and scalable systems using Docker.

  • How Containers Work2:58

    Understand how containers isolate environments while sharing an OS for efficient CPU and RAM use, compared with VMs. Explore Docker Engine, OCI standards, and Docker tools like CLI and Compose.

  • Install Docker4:06

    Install Docker Desktop on macOS or Windows, following platform-specific steps, prerequisites, and enabling auto-start. On Linux, install Docker Engine from repositories and add your user to the Docker group.

Requirements

  • A Linux, Mac or Windows computer with Internet access is required
  • Familiarity with UNIX shell is recommended
  • VS Code or another source code editor (IDE) of your choice

Description

earn how to use containers to build, run, and manage real-world applications with Podman.

This is a practical, developer-focused course designed to take you beyond simply learning container commands. Instead of spending hours on theory, you'll learn how containers fit into the development workflow by working with real applications and different technology stacks.

You'll start with the fundamentals of containers, images, registries, and container engines, then gradually move into building your own container images, running applications, connecting services together, managing persistent data, and creating complete multi-container development environments.

Throughout the course, we'll use Podman as our primary container engine while also understanding its compatibility with the Docker ecosystem. If you're already familiar with Docker, you'll find many of the concepts and commands immediately familiar.

You'll work with several types of applications, including PHP, Node.js, Python, and modern frontend applications such as React and Next.js. You'll see that the same container concepts can be applied across completely different technology stacks.

We'll cover practical topics such as:

  • Understanding containers and how they differ from virtual machines

  • Working with container images and registries

  • Running and managing containers with Podman

  • Building images with Containerfiles

  • Containerizing existing applications

  • Mapping ports and configuring environment variables

  • Working with bind mounts and persistent volumes

  • Connecting containers through networks

  • Running applications alongside databases and other services

  • Creating multi-container development environments

  • Using Compose-based workflows with Podman

  • Containerizing PHP applications

  • Containerizing Node.js applications

  • Containerizing Python applications

  • Containerizing React and Next.js applications

  • Understanding development vs. production containers

  • Using multi-stage builds

  • Troubleshooting containers, networking, permissions, and application connectivity

  • Improving container images and development workflows

  • Understanding rootless containers and the practical advantages of Podman

The course will also explore an increasingly important use case for containers: local AI.

You'll learn how containers can be used to run AI workloads locally, including running an application that communicates with a locally hosted large language model (LLM). This gives you a practical introduction to using containers not only for traditional web applications, but also for modern AI-powered applications.

The goal isn't to turn you into a Kubernetes administrator or make you memorize every feature of Podman. Instead, the focus is on the skills developers actually need when they want to take an application they are working on and put it into a reliable, reproducible containerized environment.

By the end of the course, you won't just know what containers are—you'll be able to take a real application, containerize it, connect it to a database and other services, run the whole development environment locally, and even run an AI application using a local LLM.

Whether you're a PHP, Node.js, Python, React, or full-stack developer, this course will give you a practical foundation for incorporating containers into your everyday development workflow.

Who this course is for:

  • Web application developers that seek to run their applications inside containers
  • Python developers that want to ship their applications as containers for portability
  • AI scientists and researchers that need to run and configure containerized tools
  • Server administrators and cloud engineers
  • CI/CD engineers that want to integrate containers (automatic build and push) to their workflows
  • Back-end developers that need to deploy back-end services needed by web applications
  • Everyone interested in or curious about Linux containers and micro-services