Search learning paths, guides, and videos.

    Browse

    Browse content

    Videos and guides share one catalog. Everything here stands on its own, whether or not it belongs to a learning path.

    Level
    Product
    Topic

    All content

    Guide
    Beginner · 20 min

    How image layers and the build cache work

    Find out why changing one line of code can make docker build reinstall every dependency. See the layers your Dockerfile creates, then reorder it so the build cache skips the slow steps.

    Explore →
    Guide
    Beginner · 20 min

    Keep data with volumes and bind mounts

    A container's files disappear when you remove it. Keep a to-do app's database in a named volume so it survives a new container, bind-mount a directory so you can see the database on your own disk, and learn which one to reach for.

    Explore →
    Guide
    Beginner · 25 min

    Run a multi-container app with Compose

    Connect a to-do app to a MySQL database by hand on a Docker network, feel how many flags that takes, then describe the same app in one compose.yaml and run it with a single command.

    Explore →
    Guide
    Beginner · 20 min

    Run your first container

    Run a real to-do app in a container, reach it from your browser, run a second copy beside it, configure it with an environment variable, look inside it, and see what happens to its data when you remove it.

    Explore →
    Guide
    Beginner · 15 min

    Share your image on Docker Hub

    Name your image for a registry, sign in, and push it to Docker Hub with a version tag and latest, then pull it back and run it the way anyone else would.

    Explore →
    Guide
    Beginner · 20 min

    Shrink your image with multi-stage builds

    Split a Node.js Dockerfile into build stages and a slim final stage, so the image ships the built frontend and production dependencies but leaves the compilers and dev tools behind. Then measure the difference.

    Explore →
    Guide
    Beginner · 12 min

    What is a container?

    Learn what containers and images are, how a container differs from a virtual machine, and where images come from, using registries, repositories, tags, and the trusted content on Docker Hub.

    Explore →
    Guide
    Beginner · 20 min

    Write your first Dockerfile

    Write a Dockerfile for a real Node.js app, build it into an image, run it, and call its API, while learning what each instruction does and what the build context is.

    Explore →
    Guide
    Intermediate · 15 min

    Give sandboxed agents live web access with Firecrawl

    Compose the Firecrawl v3 mixin onto a sandbox workload. The agent gets the Firecrawl Python SDK and a network rule for the Firecrawl API, and the sandbox proxy adds your API key to requests, so the key never enters the sandbox.

    Explore →
    Guide
    Advanced · 30 min

    Build a trusted container delivery pipeline

    Write a GitHub Actions release workflow that builds an image with SBOM and provenance attestations, gates it on Docker Scout policy, signs it by digest with keyless Cosign, and only then publishes the release tag.

    Explore →
    Guide
    Advanced · 35 min

    Enforce your organization's container standards

    Turn your team's image rules into checks that run on every build: a Buildx build policy that refuses unapproved base images before the build starts, and Docker Scout policies that fail an image that doesn't meet the bar.

    Explore →
    Guide
    Intermediate · 25 min

    Find and fix vulnerabilities before you ship

    Scan an image with the Docker Scout CLI, separate the findings you can act on from the ones you can't, fix them by updating dependencies and refreshing the base image, and prove the fix with a side-by-side comparison.

    Explore →
    Guide
    Advanced · 30 min

    Only run trusted images in production

    Install Kyverno and write an admission policy that admits an image to the production namespace only when it is signed by your release workflow and carries a signed SBOM, then watch the cluster refuse everything else.

    Explore →
    Guide
    Intermediate · 20 min

    Add tools and runtimes to a sandbox

    Package a language runtime as a Docker Sandbox kit. Install it at build time with a Dockerfile, then use lifecycle hooks and config files to prepare each sandbox before the agent starts.

    Explore →
    Guide
    Intermediate · 20 min

    Build your first Docker Sandbox kit

    Write a small v3 mixin kit from scratch, validate it with Buildx, run it in a sandbox from a local directory, and see how a kit carries its files, network rules, and agent instructions in one image.

    Explore →
    Guide
    Intermediate · 20 min

    Give your agents reusable skills

    Package your team's workflow as an agent skill in a Docker Sandbox kit, add standing guidance beside it, and see an agent find and use both in a fresh sandbox.

    Explore →
    Guide
    Intermediate · 20 min

    Make your Sandbox kits configurable

    Turn a kit with hardcoded values into one that serves every team and project. Declare arguments with defaults and constraints, template them into network policy and generated files, and supply values from the CLI, an environment file, or a kit set.

    Explore →
    Guide
    Beginner · 12 min

    Customize your sandbox with kits

    Change what's in your sandbox without building anything. Add a published kit to give the agent a browser to test with, then swap the agent itself and keep the browser.

    Explore →
    Guide
    Beginner · 6 min

    What is a sandbox?

    A friendly, picture-first look at how a Docker Sandbox keeps an AI agent helpful and your computer safe — the box, the door guard, the pretend key, and the kits you pack inside.

    Explore →
    Guide
    Advanced · 30 min

    Run Mistral Vibe in a Docker Sandbox

    Build a reusable v3 workload kit for Mistral's Vibe CLI. Vibe runs in an isolated microVM and reaches Mistral through the sandbox proxy, so your API key stays on the host. Verify the setup with a small coding task.

    Explore →
    Guide
    Advanced · 45 min

    Secure a Backstage application with Docker Hardened Images

    Learn how to secure a Backstage developer portal using Docker Hardened Images (DHI), handle native module compilation with better-sqlite3, add Socket Firewall protection during dependency installation, and produce a distroless runtime image using DHI customizations.

    Explore →
    Guide
    Intermediate · 30 min

    Use Docker Hardened Images with Red Hat OpenShift

    Learn how to deploy Docker Hardened Images (DHI) on Red Hat OpenShift, configure Security Context Constraints, handle arbitrary user ID assignment, and set file permissions for both runtime and development image variants.

    Explore →
    Guide
    Intermediate · 10 min

    Using Docker with Zscaler

    Embed Zscaler's root certificate into Docker images, allowing containers to operate securely with Zscaler proxies and avoid SSL errors.

    Explore →

    Nothing matches those filters. Try removing one.