Skip to main content
Mapagam

42 SECTIONS · 1269 TOPICS

Docker Roadmap

  1. Understanding Docker Architecture

    1. 1. Understanding Containers vs Virtual Machines
    2. Key Differences Summary
    3. 2. Understanding Images vs Containers
    4. Example: Image Creation and Container Launch
    5. 3. Understanding Docker Engine Components
    6. Example: Docker Daemon and Client Interaction
    7. 4. Understanding Docker Daemon vs Docker CLI
    8. Example: CLI command execution flow
    9. Comparison: Daemon vs CLI
    10. 5. Understanding Namespaces and cgroups
    11. Example: Resource Limits with cgroups
    12. 6. Understanding Union File Systems
    13. Example: Layered File System
    14. Key Concepts
    15. 7. Understanding Docker Registry Architecture
    16. Example: Pushing to a Registry
    17. Registry Types
    18. 8. Understanding Container Lifecycle States
    19. Example: Check container state
    20. 9. Understanding Docker Object Hierarchy
    21. Example: Docker Object Hierarchy in Practice
    22. Key Concepts Summary
    23. 10. Understanding Docker Desktop Architecture
    24. Example: Docker Desktop UI Components
    25. Key Features of Docker Desktop Architecture
    26. 11. Understanding OCI Runtime Specification
    27. Example: OCI Runtime Configuration
    28. Key Points
    29. 12. Understanding containerd Integration
    30. Example: Docker using containerd as runtime
    31. Key Concepts

  2. Installing and Configuring Docker

    1. 1. Installing Docker Engine
    2. Example: Post-installation setup on Linux
    3. 2. Installing Docker Desktop
    4. Example: Verify Installation
    5. Installation Summary
    6. 3. Configuring Docker Daemon
    7. Example: Docker Daemon Configuration File
    8. 4. Configuring Storage Drivers
    9. Example: Configure overlay2 storage driver
    10. 5. Configuring Logging Drivers
    11. Example: Setting a logging driver for a container
    12. Example: Setting a logging driver for a service (Docker Swarm)
    13. 6. Configuring Docker Context
    14. Example: Creating a Named Docker Context
    15. 7. Setting Up Proxy Configuration
    16. Example: Docker Daemon Proxy Configuration
    17. 8. Configuring Registry Mirrors
    18. Example: Setting up a Registry Mirror
    19. Example: Using Aliyun Mirror
    20. Steps to Configure Registry Mirrors
    21. 9. Enabling BuildKit
    22. Example: Using BuildKit with Dockerfile
    23. 10. Setting Up Experimental Features
    24. Example: Enabling Experimental Features
    25. Workflow: Enabling Experimental Features
    26. Summary of Experimental Features
    27. 11. Configuring Docker Root Directory
    28. Example: Setting Docker Root Directory
    29. 12. Managing Docker User Groups
    30. Example: Adding a User to the Docker Group

  3. Working with Docker Init

    1. 1. Initializing New Projects
    2. Example: Using docker init
    3. 2. Selecting Application Templates
    4. Example: Using Node.js Express Template
    5. 3. Generating Dockerfile Automatically
    6. Example: Using Docker Init to generate Dockerfile
    7. Summary of Steps
    8. 4. Generating docker-compose.yml
    9. Example: Basic docker-compose.yml
    10. Key Concepts
    11. 5. Generating .dockerignore Files
    12. Example: Basic .dockerignore
    13. 6. Customizing Generated Configuration
    14. Example: Modifying docker-compose.yml
    15. 7. Understanding Template Options
    16. Example: Initializing with a specific template
    17. 8. Configuring Language-Specific Settings
    18. Example: Node.js Configuration
    19. Example: Python Configuration
    20. 9. Using Init with Existing Projects
    21. Example: Initializing Docker in an existing Node.js project
    22. Key Considerations
    23. 10. Modifying Generated Files
    24. Example: Modifying the Dockerfile
    25. Example: Updating docker-compose.yml

  4. Managing Docker System

    1. 1. Viewing System Information
    2. 2. Viewing Version Information
    3. Example: Check Docker version
    4. 3. Checking Disk Usage
    5. Example: Check disk usage
    6. Example: Prune unused objects
    7. 4. Monitoring System Events
    8. Example: View Docker System Events
    9. Example: Filter Events by Container
    10. Example: Format Events with Custom Template
    11. 5. Pruning System Resources
    12. Example: Remove unused Docker objects
    13. Example: Prune with force flag
    14. Example: Prune volumes and images
    15. 6. Cleaning Up Build Cache
    16. Example: Remove unused build cache
    17. Example: Prune with filters
    18. 7. Removing All Stopped Containers
    19. Example: Remove all stopped containers
    20. 8. Removing All Unused Resources
    21. Example: Remove unused Docker resources
    22. Summary of docker system prune
    23. 9. Forcing Removal
    24. Example: Force remove a running container
    25. Example: Force remove an image in use
    26. 10. Filtering Resources for Pruning
    27. Example: Pruning Images by Label
    28. Example: Pruning Containers by Status
    29. Example: Pruning Volumes by Name Pattern
    30. 11. Viewing Live Resource Usage
    31. Example: Monitoring Container Resource Usage
    32. Example: Using Custom Format
    33. 12. Managing Docker Data Directory
    34. Example: Changing Docker Data Directory
    35. Workflow: Migrating Docker Data Directory

  5. Working with Docker Images

    1. 1. Pulling Images
    2. Example: Pulling a specific image tag
    3. 2. Listing Images
    4. 3. Searching Images
    5. Example: Search for official Nginx images
    6. Example: Limit search results to 5
    7. 4. Inspecting Images
    8. Example: Inspecting an Image
    9. Example: Viewing Image History
    10. 5. Viewing Image History
    11. 6. Tagging Images
    12. Example: Tagging an Image
    13. Example: Pushing Tagged Image
    14. 7. Removing Images
    15. Example: Remove a Docker Image
    16. 8. Pruning Unused Images
    17. Example: Remove unused images
    18. Example: Remove images with specific label
    19. Example: Remove all unused images without confirmation
    20. 9. Saving Images to Archive
    21. 10. Loading Images from Archive
    22. Example: Loading a Docker Image Archive
    23. 11. Filtering Images
    24. Example: Filtering by Label
    25. Example: Combining Filters
    26. 12. Displaying Image Digests

  6. Building Images with Dockerfile

    1. 1. Creating Dockerfile
    2. Example: Basic Dockerfile
    3. 2. Setting Working Directory
    4. Example: Setting Working Directory
    5. 3. Using COPY vs ADD Instructions
    6. Example: COPY usage
    7. Example: ADD usage with URL
    8. 4. Defining Environment Variables
    9. Example: Setting Environment Variables
    10. 5. Defining Build Arguments
    11. Example: Using ARG in Dockerfile
    12. 6. Exposing Ports
    13. Example: EXPOSE directive usage
    14. Key Points
    15. 7. Setting User Context
    16. Example: Setting User Context
    17. 8. Adding Labels
    18. Example: Adding Labels in Dockerfile
    19. 9. Using ENTRYPOINT vs CMD
    20. Example: ENTRYPOINT and CMD together
    21. Example: Override CMD with arguments
    22. Example: Override ENTRYPOINT with --entrypoint
    23. Key Differences Summary
    24. 10. Configuring Healthchecks
    25. Example: Basic Healthcheck
    26. Example: Healthcheck with Options
    27. Healthcheck Configuration Options
    28. 11. Handling .dockerignore Files
    29. Example: .dockerignore usage
    30. 12. Building Images
    31. Example: Basic Dockerfile

  7. Implementing Multi-Stage Builds

    1. 1. Creating Multi-Stage Dockerfile
    2. Example: Multi-Stage Dockerfile
    3. 2. Using Named Build Stages
    4. Example: Multi-stage Dockerfile with Named Stages
    5. 3. Copying Artifacts Between Stages
    6. Example: Copying Build Artifacts
    7. 4. Targeting Specific Build Stage
    8. Example: Building a Specific Stage
    9. 5. Optimizing Build Cache Layers
    10. Example: Optimizing RUN Commands
    11. Example: Using .dockerignore
    12. 6. Implementing Build-Time Dependencies
    13. Example: Using Build-Time Args
    14. 7. Reducing Final Image Size
    15. Example: Multi-stage build with size optimization
    16. 8. Sharing Layers Between Stages
    17. Example: Sharing Dependencies
    18. 9. Using External Images in Stages
    19. Example: Using External Images in Multi-Stage Build
    20. Best Practices for External Images
    21. 10. Building Platform-Specific Images
    22. Example: Building for ARM64
    23. 11. Creating Development vs Production Stages
    24. Example: Multi-stage Dockerfile
    25. Key Benefits
    26. 12. Using Scratch Base Image
    27. Example: Go App with Scratch

  8. Optimizing Docker Images

    1. 1. Using Smaller Base Images
    2. Example: Using Alpine as base image
    3. 2. Minimizing Layer Count
    4. Example: Combining RUN commands
    5. Example: Multi-stage build
    6. 3. Combining RUN Commands
    7. Example: Efficient RUN Commands
    8. 4. Ordering Instructions for Cache Efficiency
    9. Example: Efficient Layer Ordering
    10. 5. Leveraging Build Cache Effectively
    11. Example: Optimizing Dockerfile for Cache
    12. Cache Optimization Tips
    13. 6. Using .dockerignore to Exclude Files
    14. Example: Basic .dockerignore
    15. 7. Removing Build Dependencies
    16. Example: Reducing Image Size with Multi-Stage Build
    17. 8. Cleaning Package Manager Cache
    18. Example: Cleaning apt cache in a multi-stage build
    19. 9. Using Specific Image Tags
    20. Example: Pulling an image with a specific digest
    21. 10. Compressing Image Layers
    22. Example: Reducing Layer Size with RUN Commands
    23. 11. Analyzing Image Size
    24. Example: Analyze image size breakdown
    25. 12. Squashing Image Layers
    26. Example: Squashing image layers

  9. Building with BuildKit

    1. 1. Enabling BuildKit
    2. Example: Enable BuildKit in Dockerfile
    3. 2. Using BuildKit Syntax
    4. Example: Multi-stage build with BuildKit features
    5. 3. Using Build Secrets
    6. Example: Using a file-based secret
    7. Example: Using an environment variable as secret
    8. 4. Mounting SSH Agent
    9. Example: Using SSH mount in Docker Build
    10. 5. Implementing Build Mounts
    11. Example: Using bind mount to share source code
    12. Example: Using cache mount for faster builds
    13. 6. Caching Build Layers
    14. Example: Caching RUN Commands
    15. 7. Using Inline Cache
    16. Example: Using inline cache with Dockerfile
    17. Example: Build with inline cache
    18. 8. Configuring Build Output
    19. Example: Save image to local registry
    20. Example: Push to remote registry
    21. 9. Using Build Contexts
    22. Example: Specifying a build context
    23. Key Points
    24. 10. Building for Multiple Platforms
    25. Example: Building for Multiple Platforms
    26. Key Points
    27. 11. Optimizing Layer Caching
    28. Example: Layer Caching Optimization
    29. 12. Debugging Builds with Progress Output
    30. Example: Enable detailed build progress

  10. Working with Docker Buildx

    1. 1. Installing Buildx
    2. Example: Verify Buildx Installation
    3. 2. Creating Builder Instance
    4. Example: Creating a new builder instance
    5. 3. Listing Builders
    6. Example: Listing all Docker Buildx builders
    7. 4. Using Builder
    8. Example: Building for Multiple Platforms
    9. Example: Load Image to Local Cache
    10. 5. Inspecting Builder
    11. Example: Inspecting default builder
    12. Example: Inspecting a named builder
    13. 6. Building Multi-Platform Images
    14. Example: Building multi-platform image
    15. 7. Pushing Multi-Platform Images
    16. Example: Pushing Multi-Platform Image
    17. 8. Building with Cache Export
    18. Example: Exporting and Importing Cache
    19. 9. Building with Cache Import
    20. Example: Importing cache from a registry
    21. Example: Exporting cache to a registry
    22. 10. Using Remote Build Contexts
    23. Example: Building from a Git Repository
    24. 11. Building with OCI Exporter
    25. Example: Exporting an OCI Image
    26. 12. Removing Builder
    27. Example: Remove a Builder

  11. Running and Managing Containers

    1. 1. Running Containers
    2. Example: Running a Web Server Container
    3. Example: Starting a Container with Custom Volume Mounting
    4. 2. Running in Detached Mode
    5. Example: Running a Web Server in Detached Mode
    6. Key Points
    7. 3. Running Interactive Containers
    8. Example: Running an Interactive Bash Shell
    9. Key Points
    10. 4. Naming Containers
    11. Example: Naming a Container
    12. 5. Removing Containers After Exit
    13. Example: Remove a stopped container
    14. Example: Remove all stopped containers
    15. 6. Overriding Container Commands
    16. Example: Override command on container run
    17. Example: Execute command in running container
    18. 7. Running Containers as Different User
    19. Example: Running container as non-root user
    20. Example: Running container with user by name
    21. 8. Mapping Ports
    22. Example: Map a single port
    23. Example: Map multiple ports
    24. Example: Map port with random host port
    25. 9. Setting Environment Variables
    26. Example: Using environment variables in a Node.js app
    27. 10. Mounting Volumes
    28. Example: Mounting a Host Directory
    29. Example: Using Named Volumes
    30. 11. Limiting Container Resources
    31. Example: Limiting Memory and CPU
    32. 12. Restarting Containers Automatically
    33. Example: Setting Restart Policy

  12. Managing Container Lifecycle

    1. 1. Listing Containers
    2. 2. Starting Stopped Containers
    3. Example: Starting a Stopped Container
    4. 3. Stopping Running Containers
    5. Example: Stopping a Container Gracefully
    6. Example: Stopping a Container with Timeout
    7. Example: Killing a Container Immediately
    8. 4. Restarting Containers
    9. Example: Restart policy with on-failure
    10. Example: Always restart container
    11. 5. Pausing Containers
    12. Example: Pausing and Unpausing a Container
    13. 6. Unpausing Containers
    14. Example: Unpause a Container
    15. 7. Killing Containers (docker kill)
    16. Example: Killing a Container
    17. Example: Killing a Container with Custom Signal
    18. 8. Removing Containers (docker rm)
    19. Example: Remove a container by name
    20. Example: Remove a container by ID
    21. Example: Remove multiple containers
    22. Example: Force remove a running container
    23. Example: Remove container and its volumes
    24. 9. Renaming Containers (docker rename)
    25. Example: Rename a Container
    26. 10. Waiting for Container Exit (docker wait)
    27. Example: Waiting for a container to exit
    28. 11. Updating Running Container
    29. Example: Update Memory Limit of a Running Container
    30. 12. Creating Container Without Starting
    31. Example: Creating a Container Without Starting It

  13. Inspecting and Debugging Containers

    1. 1. Viewing Container Logs (docker logs)
    2. Example: Viewing logs from a running container
    3. Example: Following logs in real-time
    4. Example: Viewing logs since a specific time
    5. Example: Viewing last 50 lines of logs
    6. 2. Following Log Output
    7. Example: Following Logs in Real-Time
    8. Example: Filtering Logs by Time
    9. 3. Limiting Log Output (--tail, --since)
    10. Example: Viewing Recent Logs
    11. Example: Filtering Logs by Time
    12. 4. Inspecting Container Details
    13. Example: Inspecting Container Configuration
    14. 5. Viewing Container Processes
    15. Example: Inspecting a container's processes
    16. Example: Running ps inside a container
    17. 6. Monitoring Container Stats
    18. Key Stats Fields
    19. 7. Executing Commands in Container
    20. Example: Running a shell in a container
    21. Example: Running a command in the background
    22. 8. Attaching to Running Container
    23. 9. Copying Files To/From Container
    24. Example: Copying a file from container to host
    25. Example: Copying a directory from host to container
    26. 10. Viewing Container Changes
    27. Example: Using docker diff
    28. 11. Exporting Container Filesystem
    29. Example: Exporting Container Filesystem
    30. 12. Inspecting Container Exit Codes
    31. Example: Exit Code Analysis

  14. Using Docker Debug

    1. 1. Starting Debug Session
    2. Example: Attach debugger to running container
    3. 2. Debugging Running Containers
    4. Example: Inspecting a running container
    5. Example: Viewing logs from a container
    6. Example: Listing processes in a container
    7. 3. Debugging Stopped Containers
    8. Example: Inspecting a Stopped Container
    9. Example: Viewing Logs from a Stopped Container
    10. 4. Debugging Slim Images
    11. Example: Identify Large Layers in Slim Image
    12. Example: Add Debug Tools to Slim Image
    13. 5. Installing Debug Tools Temporarily
    14. Example: Installing strace in a Container
    15. 6. Using Shell in Debug Mode
    16. Example: Accessing Container Shell
    17. 7. Inspecting Filesystem in Debug
    18. Example: Inspecting Files in a Running Container
    19. Example: Copying Files from Container to Host
    20. 8. Debugging Network Issues
    21. Example: Inspecting a network
    22. Example: Testing connectivity from a container
    23. 9. Analyzing Container State
    24. Example: Inspecting Container Configuration
    25. Example: Monitoring Container CPU and Memory
    26. 10. Exiting Debug Sessions Cleanly
    27. Example: Exiting Debug Session

  15. Managing Container Health

    1. 1. Defining Healthchecks in Dockerfile
    2. Example: Defining a Healthcheck in Dockerfile
    3. 2. Configuring Health Intervals
    4. Example: Setting custom health check intervals
    5. 3. Setting Health Timeout
    6. Example: Setting Health Check Timeout
    7. 4. Defining Health Retries
    8. Example: Setting Health Check Retries
    9. 5. Setting Start Period
    10. Example: Using startPeriod in Dockerfile
    11. 6. Using Custom Health Commands
    12. Example: Custom Health Check with HTTP Endpoint
    13. Example: Health Check with Script
    14. 7. Viewing Container Health Status
    15. Example: Inspecting Health Check Details
    16. 8. Monitoring Health Events
    17. Example: Health Check Configuration
    18. Example: Inspecting Health Status
    19. Example: Viewing Health Logs
    20. 9. Disabling Healthchecks
    21. Example: Disabling Healthcheck in Runtime
    22. 10. Implementing Dependency Health Checks
    23. Example: HTTP GET Health Check
    24. Example: TCP Port Health Check
    25. 11. Understanding Health States
    26. Example: Health Check Configuration
    27. 12. Handling Health Failures Gracefully
    28. Example: Health Check Configuration in Dockerfile
    29. Example: Health Check in Compose File
    30. Best Practices for Health Checks

  16. Working with Container Labels

    1. 1. Adding Labels at Build Time
    2. Example: Dockerfile LABEL usage
    3. Example: CLI label during build
    4. 2. Adding Labels at Runtime
    5. 3. Filtering Containers by Label
    6. Example: Using Label Filters in Docker CLI
    7. Example: Combining Multiple Label Filters
    8. 4. Organizing Resources with Labels
    9. Example: Setting Labels During Build
    10. Example: Setting Labels at Runtime
    11. Label Usage Summary
    12. 5. Using Labels for Automation
    13. Example: Applying Labels During Build
    14. Example: Filtering Containers by Labels
    15. 6. Implementing Labeling Standards
    16. Example: Setting Standardized Labels
    17. Workflow: Applying Labels to Existing Images
    18. Comparison: Labeling Approaches
    19. 7. Viewing Container Labels
    20. Example: Inspecting Labels Using docker inspect
    21. Example: Filtering Containers by Label
    22. 8. Updating Container Labels
    23. Example: Setting labels on a running container
    24. Example: Creating a container with labels
    25. 9. Using Labels with Orchestrators
    26. Example: Docker Swarm Label Usage
    27. Example: Kubernetes Label Usage
    28. 10. Implementing Metadata Conventions
    29. Example: Setting Metadata Labels in Dockerfile

  17. Working with Docker Volumes

    1. 1. Creating Named Volumes
    2. Example: Create and Use a Named Volume
    3. 2. Listing Volumes
    4. Example: List all volumes
    5. Example: Inspect a volume
    6. 3. Inspecting Volumes
    7. Example: Inspecting Volume Details
    8. 4. Mounting Volumes
    9. Example: Mounting a Volume with Read-Write Access
    10. Example: Mounting a Volume with Read-Only Access
    11. 5. Using Bind Mounts
    12. Example: Mounting a Host Directory
    13. Example: Mounting a Single File
    14. 6. Creating tmpfs Mounts
    15. Example: Creating a tmpfs mount
    16. 7. Setting Volume Drivers
    17. Example: Using a Custom Volume Driver
    18. 8. Managing Volume Permissions
    19. Example: Setting Read-Only Volume
    20. Example: Using SELinux Labels
    21. 9. Backing Up Volumes
    22. Example: Backup Volume to Host
    23. 10. Restoring Volumes from Backup
    24. Example: Restore volume from backup file
    25. Key Considerations
    26. 11. Removing Volumes
    27. Example: Remove a specific volume
    28. Example: Remove multiple volumes
    29. Example: Remove all unused volumes
    30. 12. Pruning Unused Volumes
    31. Example: Remove unused volumes

  18. Configuring Docker Networks

    1. 1. Creating Networks
    2. Example: Create a custom bridge network
    3. Example: Create an overlay network for swarm mode
    4. 2. Listing Networks
    5. Example: List all networks with custom format
    6. Example: Filter networks by driver
    7. 3. Inspecting Networks
    8. Example: Inspecting a Network
    9. 4. Connecting Containers to Networks
    10. Example: Connecting a Container to a Network
    11. Example: Connecting to Default Bridge Network
    12. 5. Disconnecting Containers from Networks
    13. Example: Disconnecting a Container from a Network
    14. 6. Using Bridge Networks
    15. Example: Creating a Custom Bridge Network
    16. Example: Running Container on Custom Bridge Network
    17. 7. Using Host Network
    18. Example: Run container with host network
    19. 8. Using None Network
    20. Example: Run container with no network
    21. 9. Configuring Network Aliases
    22. Example: Using Network Aliases in Docker Compose
    23. 10. Setting Up DNS Configuration
    24. Example: Custom DNS Servers
    25. Example: Adding Host Entry
    26. 11. Removing Networks
    27. Example: Remove a network by name
    28. Example: Remove a network by ID
    29. Example: Remove all unused networks
    30. 12. Pruning Unused Networks
    31. Example: Prune unused networks with confirmation
    32. Example: Prune networks without confirmation
    33. Example: Prune networks with label filter

  19. Configuring Resource Constraints

    1. 1. Limiting Memory Usage
    2. Example: Setting Memory Limits
    3. 2. Setting Memory Reservation
    4. Example: Setting Memory Reservation
    5. 3. Configuring Swap Limit
    6. Example: Setting Swap Limit for a Container
    7. 4. Limiting CPU Usage
    8. Example: Limiting CPU Usage to 50% of One Core
    9. Example: Setting CPU Period and Quota
    10. 5. Setting CPU Shares
    11. Example: Setting CPU Shares for a Container
    12. Example: Using CPU Quota and Period
    13. 6. Pinning to Specific CPUs
    14. Example: Running a container on specific CPUs
    15. 7. Setting Block I/O Weight
    16. Example: Setting Block I/O Weight
    17. 8. Limiting Device Read/Write
    18. Example: Limiting Device Read/Write
    19. 9. Setting PID Limits
    20. Example: Setting PID Limits
    21. 10. Configuring Restart Policies
    22. Example: Using restart policy in Docker Compose
    23. Example: Using restart policy with Docker CLI
    24. 11. Setting Stop Timeout
    25. Example: Setting Stop Timeout
    26. 12. Configuring OOM Killer Behavior
    27. Example: Setting OOM Score Adjustment

  20. Working with Docker Logging

    1. 1. Viewing Container Logs (docker logs)
    2. Example: Viewing logs with timestamps and limited output
    3. Example: Following logs in real-time
    4. 2. Following Logs in Real-Time
    5. Example: Follow logs with timestamps
    6. Example: Follow logs since a specific time
    7. 3. Limiting Log Output (--tail, --since)
    8. Example: Viewing Recent Logs
    9. Example: Filtering Logs by Time
    10. 4. Configuring Logging Drivers
    11. Example: Setting logging driver for a container
    12. Example: Setting logging driver for a service (Swarm mode)
    13. 5. Using JSON File Driver
    14. Example: Run container with JSON logging
    15. 6. Using Syslog Driver
    16. Example: Configure Docker to use Syslog Driver
    17. 7. Using Journald Driver
    18. Example: Run container with journald logging
    19. 8. Configuring Log Options
    20. Example: Configure JSON log driver with max size and rotation
    21. Example: Use syslog driver with custom facility
    22. Example: Use GELF driver for Graylog
    23. 9. Setting Log Rotation
    24. Example: Configure log rotation for a container
    25. 10. Viewing Logs from Multiple Containers
    26. Example: Viewing logs from multiple containers
    27. Example: Following logs from multiple containers
    28. 11. Filtering Logs by Timestamp
    29. Example: Filtering Logs by Timestamp
    30. 12. Disabling Logging
    31. Example: Disable logging for a container

  21. Working with Docker Registry

    1. 1. Logging into Registry
    2. 2. Logging out from Registry
    3. Example: Logging out from a specific registry
    4. Example: Logging out from the default registry
    5. 3. Tagging for Different Registries
    6. Example: Pushing to a Private Registry
    7. Example: Using Tagging for Multi-Architecture Images
    8. 4. Pushing Images
    9. Example: Pushing to Docker Hub
    10. 5. Pulling from Private Registry
    11. Example: Pulling an Image from a Private Registry
    12. 6. Using Docker Hub Repositories
    13. Example: Pushing an Image to Docker Hub
    14. Example: Pulling an Image from Docker Hub
    15. Key Concepts
    16. 7. Running Local Registry
    17. Example: Start a local registry with Docker
    18. Example: Push image to local registry
    19. 8. Configuring Insecure Registries
    20. Example: Docker Daemon Configuration
    21. 9. Authenticating with Token
    22. Example: Using Token Authentication
    23. 10. Managing Registry Credentials
    24. Example: Logging into a registry
    25. Example: Logging in with credentials
    26. 11. Implementing Registry Webhooks
    27. Example: Setting up a Webhook Endpoint
    28. 12. Configuring Registry Storage Backends
    29. Example: Configuring S3 Storage Backend

  22. Working with Docker Compose

    1. 1. Creating docker-compose.yml File
    2. Example: Basic docker-compose.yml
    3. 2. Defining Services (services:)
    4. Example: Basic service definition
    5. Example: Service with environment and dependencies
    6. 3. Validating Compose File
    7. Example: Validate a Docker Compose file
    8. 4. Building Services
    9. Example: Building a Node.js Service
    10. Example: Multi-stage Build
    11. 5. Starting Services
    12. Example: Starting Services with Docker Compose
    13. Workflow: Starting Services in Docker Compose
    14. 6. Stopping Services
    15. Example: Stop all services
    16. Example: Stop specific service
    17. 7. Viewing Service Logs
    18. Example: View logs for a specific service
    19. Example: Follow logs with timestamps
    20. Example: View last 100 lines of logs
    21. 8. Executing Commands in Services
    22. Example: Executing a shell in a running service
    23. Example: Running a command to check service logs
    24. 9. Scaling Services
    25. Example: Scaling a Service
    26. 10. Using Environment Files
    27. Example: Environment file usage
    28. Example: Using environment variables in Compose
    29. Best Practices for Environment Files
    30. 11. Defining Dependencies
    31. Example: Using depends_on
    32. 12. Overriding Compose Files
    33. Example: Override Compose File
    34. Example: Override Configuration

  23. Configuring Docker Compose Networks and Volumes

    1. 1. Defining Networks in Compose
    2. Example: Defining a Custom Network
    3. 2. Defining Volumes in Compose
    4. Example: Named Volume
    5. Example: Bind Mount
    6. Example: Volume with Options
    7. 3. Creating Named Volumes in Compose
    8. Example: Define a Named Volume in Compose
    9. Example: Use External Volume in Compose
    10. 4. Using Bind Mounts in Compose
    11. Example: Mounting Host Logs to Container
    12. 5. Using External Networks
    13. Example: Using an External Network in docker-compose.yml
    14. 6. Using External Volumes
    15. Example: Using External Volume in Compose File
    16. 7. Configuring Network Drivers
    17. Example: Using bridge driver in docker-compose.yml
    18. Example: Using overlay driver in swarm mode
    19. 8. Setting Volume Driver Options
    20. Example: Using local-persist driver with options
    21. 9. Setting Network Aliases in Services
    22. Example: Defining Network Aliases
    23. 10. Configuring IPAM Settings
    24. Example: IPAM Configuration
    25. 11. Using Network Subnets
    26. Example: Defining a Custom Network with Subnet
    27. 12. Sharing Volumes Between Services
    28. Example: Named Volume for Data Persistence

  24. Using Advanced Docker Compose Features

    1. 1. Using Compose Profiles
    2. Example: Defining Profiles in Compose File
    3. Example: Activating a Profile
    4. 2. Using Watch Mode
    5. Example: Watch Mode in docker-compose.yml
    6. 3. Implementing Health Checks in Compose
    7. Example: Basic HTTP Health Check
    8. Example: Custom Script Health Check
    9. 4. Defining Deploy Configuration
    10. Example: Basic deploy configuration
    11. 5. Using Fragments and Extensions
    12. Example: Using Extensions
    13. 6. Interpolating Environment Variables
    14. Example: Using Environment Variable Interpolation in docker-compose.yml
    15. 7. Using Secrets in Compose
    16. Example: Using Secrets in Docker Compose
    17. 8. Using Configs in Compose
    18. Example: Define and Use a Config
    19. 9. Setting Resource Limits
    20. Example: Setting Memory Limit
    21. Example: Setting CPU Limit
    22. 10. Configuring Restart Policies
    23. Example: Using restart policy in docker-compose.yml
    24. 11. Using Include Directive
    25. Example: Including a Compose File
    26. 12. Implementing Service Dependencies
    27. Example: Using depends_on with service_healthy
    28. Key Points

  25. Managing Docker Contexts

    1. 1. Creating Contexts
    2. Example: Creating a Docker Context
    3. 2. Listing Contexts
    4. Example: Listing Docker contexts
    5. 3. Inspecting Context
    6. Example: Inspecting Default Context
    7. 4. Using Different Context
    8. Example: Switching Contexts
    9. Example: Creating a New Context
    10. 5. Switching Between Contexts
    11. Example: Switching to a context named "mycontext"
    12. 6. Managing Remote Docker Hosts
    13. Example: Setting up a remote Docker context via SSH
    14. 7. Updating Context
    15. Example: Update context description
    16. 8. Exporting Context
    17. Example: Exporting a Docker context to a tar file
    18. 9. Importing Context
    19. Example: Importing a Context from Archive
    20. 10. Removing Context
    21. Example: Removing a Context
    22. 11. Using SSH Contexts
    23. Example: Creating an SSH Context
    24. Example: Using the SSH Context
    25. 12. Configuring TLS for Remote Contexts
    26. Example: Setting up TLS for a remote Docker context

  26. Working with Docker Plugins

    1. 1. Installing Volume Plugins
    2. Example: Installing a Volume Plugin
    3. 2. Listing Plugins
    4. Example: Listing Plugins
    5. Example: Listing Plugins with JSON Format
    6. Example: Filtering Plugins by Name
    7. 3. Inspecting Plugins
    8. Example: Inspecting a Plugin
    9. 4. Enabling Plugins
    10. Example: Enabling a Plugin
    11. 5. Disabling Plugins
    12. Example: Disabling a Plugin
    13. 6. Configuring Plugin Options
    14. Example: Setting Plugin Configuration
    15. Example: Setting Environment Variables
    16. 7. Using Network Plugins
    17. Example: Creating an Overlay Network
    18. Example: Attaching a Service to an Overlay Network
    19. 8. Using Storage Plugins
    20. Example: Configure Storage Driver
    21. 9. Upgrading Plugins
    22. Example: Upgrading a Plugin
    23. 10. Creating Custom Plugins
    24. Example: plugin.json
    25. Workflow: Creating a Custom Plugin
    26. Plugin Types
    27. 11. Managing Plugin Permissions
    28. Example: Installing a Plugin with Specific Permissions
    29. 12. Removing Plugins
    30. Example: Removing a Plugin

  27. Working with Docker Extensions

    1. 1. Installing Docker Extensions
    2. Example: Installing Portainer Extension
    3. 2. Listing Extensions
    4. Example: Listing all Docker Extensions
    5. Example: Listing only enabled extensions
    6. 3. Updating Extensions
    7. Example: Updating Docker Desktop Extension
    8. Update Process Summary
    9. 4. Removing Extensions
    10. Example: Removing a Docker Extension
    11. 5. Using Extensions in Docker Desktop
    12. Example: Installing an Extension via CLI
    13. Workflow: Using Extensions in Docker Desktop
    14. Comparison: Docker Desktop vs Extension Capabilities
    15. 6. Discovering Extensions Marketplace
    16. Example: Accessing Docker Extensions Marketplace
    17. Key Marketplace Features
    18. 7. Managing Extension Permissions
    19. Example: Setting Extension Permissions via CLI
    20. 8. Configuring Extension Settings
    21. Example: Enabling Extension Debug Mode
    22. 9. Using Database Extensions
    23. Example: Connecting to a MySQL Database via Extension
    24. Example: Using PostgreSQL Extension to Create a Table
    25. 10. Using Monitoring Extensions
    26. Example: Setting up Prometheus Exporter
    27. Example: Grafana Dashboard Setup
    28. 11. Using Security Extensions
    29. Example: Scanning an Image with Trivy
    30. 12. Building Custom Extensions
    31. Example: Basic Extension Structure
    32. Example: Extension UI Dashboard
    33. Example: Backend Service

  28. Implementing Docker Security Best Practices

    1. 1. Running Containers as Non-Root
    2. Example: Set Non-Root User in Dockerfile
    3. Example: Run Container with UID/GID
    4. 2. Using Read-Only Filesystems
    5. Example: Run container with read-only root filesystem
    6. 3. Dropping Kernel Capabilities
    7. Example: Dropping Capabilities in a Container
    8. 4. Adding Required Capabilities
    9. 5. Setting Security Options
    10. Example: Running a container with security options
    11. Security Option Summary
    12. 6. Limiting Container Privileges
    13. Example: Running a Container with Limited Privileges
    14. 7. Isolating Containers with User Namespaces
    15. Example: Running a Container with User Namespace
    16. 8. Configuring AppArmor Profiles
    17. Example: Running a Container with AppArmor Profile
    18. 9. Setting Up SELinux Labels
    19. Example: Applying SELinux Labels to Docker Volumes
    20. 10. Using Docker Content Trust
    21. Example: Enable Docker Content Trust
    22. Example: Inspect Signed Image
    23. 11. Implementing Secrets Management
    24. Example: Using Docker Secrets in a Service
    25. 12. Using Official Base Images
    26. Example: Pulling and Running Official Ubuntu Image
    27. Example: Pulling and Running Official Node.js Image

  29. Scanning Images for Vulnerabilities

    1. 1. Scanning with Docker Scout
    2. Example: Scanning an Image for CVEs
    3. 2. Viewing Vulnerability Recommendations
    4. Example: Using Trivy to Scan Image
    5. 3. Comparing Image Vulnerabilities
    6. Comparison Summary
    7. 4. Setting Severity Threshold
    8. Example: Scan with Severity Threshold
    9. 5. Generating SBOM
    10. Example: Generate SBOM with Docker CLI
    11. SBOM Generation Workflow
    12. 6. Using Trivy for Scanning
    13. Example: Scan an image for vulnerabilities
    14. Example: Scan with severity filter
    15. Example: Save scan results to a file
    16. 7. Implementing CI/CD Security Checks
    17. Example: Integrating Docker Scout in GitHub Actions
    18. Security Check Workflow
    19. 8. Managing Scan Results
    20. Example: Viewing scan results in JSON format
    21. Managing Scan Results Summary
    22. 9. Fixing Common Vulnerabilities
    23. Example: Updating Alpine Image to Fix CVEs
    24. 10. Using Docker Bench for Security
    25. Example: Running Docker Bench for Security
    26. Key Checks Performed
    27. 11. Auditing Docker Configurations
    28. Example: Secure Dockerfile Configuration
    29. 12. Implementing Image Signing
    30. Example: Signing an Image
    31. Example: Verifying an Image

  30. Using Docker Content Trust

    1. 1. Enabling Content Trust
    2. Example: Enabling Content Trust for a Repository
    3. 2. Signing Images with Notary
    4. Example: Signing a Docker Image
    5. 3. Managing Signing Keys
    6. Example: Generate a new signing key
    7. Example: List available signing keys
    8. Example: Remove a signing key
    9. 4. Verifying Image Signatures
    10. Example: Verifying an Image Signature
    11. 5. Configuring Trust Policies
    12. Example: Setting Up Content Trust
    13. 6. Rotating Signing Keys
    14. 7. Delegating Signing Authority
    15. Example: Adding a Signer
    16. Key Points
    17. 8. Using Root Keys Securely
    18. Example: Revoking Root Key
    19. 9. Managing Repository Keys
    20. Example: Generate a Signing Key
    21. Example: Inspect Key Details
    22. Workflow: Add a Key to a Repository
    23. 10. Recovering from Key Compromise
    24. Example: Revoking a compromised key
    25. Example: Re-signing an image after key recovery
    26. 11. Integrating with CI/CD Pipelines
    27. Example: Docker Content Trust in GitHub Actions
    28. 12. Troubleshooting Trust Errors
    29. Example: Re-enable Docker Content Trust

  31. Working with Docker Swarm Mode

    1. 1. Initializing Swarm
    2. Example: Initializing a Docker Swarm
    3. 2. Joining Swarm as Worker
    4. Example: Joining a Worker Node
    5. 3. Joining Swarm as Manager
    6. Example: Joining a Manager Node
    7. 4. Listing Swarm Nodes
    8. 5. Inspecting Nodes
    9. Example: Inspecting a Node
    10. 6. Promoting Worker to Manager
    11. Example: Promoting a Worker Node
    12. 7. Demoting Manager to Worker
    13. Example: Demoting a Manager Node
    14. 8. Updating Swarm Configuration
    15. Example: Updating Docker Daemon Configuration
    16. 9. Managing Join Tokens
    17. Example: Generate a new join token for workers
    18. Example: Use a join token to add a worker node
    19. 10. Removing Node from Swarm
    20. Example: Removing a Node
    21. 11. Leaving Swarm
    22. Example: Leaving a Swarm
    23. Example: Force Leaving a Swarm
    24. 12. Configuring Swarm Encryption
    25. Example: Enabling Swarm Encryption

  32. Deploying Services in Swarm

    1. 1. Creating Services
    2. Example: Creating a Web Service
    3. Example: Creating a Service with Environment Variables
    4. 2. Listing Services
    5. Example: Listing all services in a swarm
    6. Example: Listing services with JSON format
    7. 3. Inspecting Services
    8. Example: Inspecting a Service
    9. Example: Formatting Service Inspection Output
    10. 4. Listing Service Tasks
    11. Example: Listing tasks for a service
    12. Example: Filtering tasks by status
    13. Example: Formatting task output as JSON
    14. 5. Viewing Service Logs
    15. Example: View service logs
    16. Example: Follow service logs
    17. Example: View logs since a specific time
    18. Example: View last 100 log lines
    19. 6. Configuring Replicas
    20. Example: Setting Replica Count
    21. Example: Scaling Replicas
    22. 7. Scaling Services
    23. Example: Scaling a Service Up
    24. Example: Scaling Down to Zero
    25. Scaling Service Workflow
    26. 8. Updating Services
    27. Example: Update Service Image
    28. Example: Scale Service Replicas
    29. 9. Setting Update Parallelism
    30. Example: Update Parallelism in Service Deployment
    31. 10. Rolling Back Services
    32. Example: Rolling Back a Service
    33. 11. Configuring Placement Constraints
    34. Example: Deploying Service with Placement Constraints
    35. 12. Removing Services
    36. Example: Remove a Service
    37. Example: Force Remove a Service

  33. Managing Swarm Secrets and Configs

    1. 1. Creating Secrets
    2. Example: Creating a secret from a file
    3. Example: Creating a secret from stdin
    4. 2. Listing Secrets
    5. Example: List all secrets
    6. Example: List secrets with custom format
    7. Example: Filter secrets by name
    8. 3. Inspecting Secrets
    9. Example: Inspecting a Secret
    10. 4. Using Secrets in Services
    11. Example: Using a secret in a service
    12. Example: Using a config in a service
    13. 5. Mounting Secrets at Custom Paths
    14. Example: Mounting a secret at a custom path
    15. 6. Setting Secret Permissions
    16. Example: Assigning Secret Permissions to a Service
    17. 7. Removing Secrets
    18. Example: Remove a secret
    19. 8. Creating Configs
    20. Example: Creating a Config from a File
    21. Example: Creating a Config from Literal Data
    22. 9. Listing Configs
    23. Example: Listing all configs
    24. Example: Filtering configs by name
    25. 10. Inspecting Configs
    26. Example: Inspecting a Config
    27. 11. Using Configs in Services
    28. Example: Attach Config to Service
    29. Key Points
    30. 12. Removing Configs
    31. Example: Remove a config

  34. Configuring Swarm Networks

    1. 1. Creating Overlay Networks
    2. Example: Creating an Overlay Network
    3. 2. Encrypting Overlay Networks
    4. Example: Create encrypted overlay network
    5. 3. Attaching Services to Networks
    6. Example: Attaching a Service to a Network
    7. Example: Attaching Multiple Services to Same Network
    8. 4. Publishing Service Ports
    9. Example: Publishing a Service Port
    10. Example: Publishing with Ingress Mode
    11. 5. Configuring Ingress Network
    12. Example: Create Ingress Network with Custom Subnet
    13. 6. Setting Up Service Discovery
    14. Example: Create an Overlay Network
    15. Example: Attach Service to Network
    16. 7. Using Network Aliases in Services
    17. Example: Defining a Network Alias for a Service
    18. 8. Configuring Load Balancing
    19. Example: Load Balancing Configuration
    20. 9. Managing Routing Mesh
    21. Example: Configure Routing Mesh Subnet
    22. 10. Configuring External Load Balancers
    23. Example: External Load Balancer Setup
    24. 11. Using Attachable Overlay Networks
    25. Example: Creating an Attachable Overlay Network
    26. Example: Attaching a Container to the Network
    27. 12. Troubleshooting Swarm Networking
    28. Common Issues and Solutions
    29. Example: Inspecting Service Network Configuration

  35. Working with Docker Stacks

    1. 1. Creating Stack Compose File
    2. Example: Basic Stack Compose File
    3. 2. Deploying Stacks
    4. Example: Deploy a stack using docker stack deploy
    5. 3. Listing Stacks
    6. Example: List all stacks
    7. Example: List stacks with custom format
    8. 4. Listing Stack Services
    9. Example: Listing services in a stack
    10. 5. Viewing Stack Tasks
    11. Example: View stack tasks using CLI
    12. 6. Configuring Stack Networks
    13. Example: Create an Internal Stack Network
    14. Example: Attach Service to Custom Network
    15. 7. Configuring Stack Volumes
    16. Example: Bind Mount Volume
    17. Example: Named Volume
    18. 8. Using Stack Secrets
    19. Example: Define a secret in a stack compose file
    20. Example: Using a literal secret
    21. 9. Using Stack Configs
    22. Example: Create a Stack Config
    23. Example: Use Config in Stack
    24. 10. Updating Stack Deployments
    25. Example: Update stack deployment
    26. 11. Monitoring Stack Health
    27. Example: Check stack task status
    28. 12. Removing Stacks
    29. Example: Remove a stack

  36. Managing Docker Performance

    1. 1. Monitoring Resource Usage
    2. Example: Monitoring CPU and Memory Usage
    3. Example: Filtering Containers by Name
    4. 2. Optimizing Build Cache
    5. Example: Efficient Dockerfile with Cache Optimization
    6. 3. Using Volume Performance Options
    7. Example: Using
    8. Example: Mounting a volume with performance options
    9. 4. Configuring Storage Driver Settings
    10. Example: Configure overlay2 storage driver
    11. Storage Driver Configuration Tips
    12. 5. Implementing Resource Constraints
    13. Example: Limiting CPU and Memory Usage
    14. Example: Setting Memory Swap Limit
    15. 6. Optimizing Network Performance
    16. Example: Using host network mode for performance
    17. Example: Adding custom host entry
    18. Network Optimization Tips
    19. 7. Using BuildKit for Faster Builds
    20. Example: Enabling BuildKit
    21. Key Benefits of BuildKit
    22. BuildKit Optimization Steps
    23. 8. Parallel Container Execution
    24. Example: Running Multiple Containers Concurrently
    25. Best Practices for Parallel Execution
    26. 9. Minimizing Image Pulls
    27. Example: Pulling image with specific tag
    28. Example: Building image without cache
    29. 10. Using Local Registry for Caching
    30. Example: Setting up a local registry with caching
    31. Workflow: Pushing to local registry
    32. 11. Optimizing Layer Caching Strategy
    33. Example: Layer Caching Optimization
    34. Key Tips for Layer Caching
    35. 12. Profiling Container Performance
    36. Example: Using
    37. Example: Collecting detailed stats using
    38. Key Metrics to Monitor

  37. Debugging Docker Issues

    1. 1. Inspecting Container Exit Codes
    2. Example: Checking Exit Code
    3. Example: Running a Failing Command
    4. 2. Viewing Container Logs for Errors
    5. Example: Viewing recent errors in a container
    6. Example: Following logs in real-time to debug a startup issue
    7. 3. Executing Shell in Container
    8. Example: Executing Shell in Container
    9. 4. Checking Container Resource Usage
    10. Example: Monitoring Resource Usage
    11. 5. Inspecting Network Connectivity
    12. Example: Testing Internal Container Connectivity
    13. 6. Verifying Volume Mounts
    14. Example: Check mounted volumes in a running container
    15. 7. Testing Port Mappings
    16. Example: Verify Port Mapping
    17. 8. Checking Dockerfile Syntax
    18. Example: Validate Dockerfile Syntax
    19. 9. Validating docker-compose.yml
    20. Example: Basic Validation Command
    21. Example: Error Detection
    22. Validation Steps
    23. 10. Using Docker Events for Troubleshooting
    24. Example: Listening to Docker Events
    25. Common Event Types
    26. 11. Analyzing Image Layers
    27. Example: Inspecting Image Layers
    28. 12. Debugging Build Failures
    29. Example: Debugging a build failure with verbose logs
    30. Example: Using .dockerignore to reduce build context

  38. Troubleshooting Common Issues

    1. 1. Resolving Port Already in Use
    2. Example: Stop and Remove Conflicting Container
    3. Example: Map Different Host Port
    4. 2. Fixing Volume Permission Errors
    5. Example: Fixing Volume Permissions
    6. 3. Handling Out of Disk Space
    7. Example: Pruning Docker Resources
    8. Example: Configuring Log Rotation
    9. 4. Resolving Network Connectivity Issues
    10. Example: Inspecting Container Network Configuration
    11. Example: Mapping Ports Correctly
    12. 5. Fixing Container Startup Failures
    13. Example: Debugging Startup Failures
    14. 6. Handling Build Context Too Large
    15. Example: Using .dockerignore to reduce build context
    16. Workflow to reduce build context size
    17. 7. Resolving Image Pull Failures
    18. Example: Logging into Docker Hub
    19. Example: Pulling an Image with Credentials
    20. 8. Fixing DNS Resolution Problems
    21. Example: Using custom DNS server
    22. Example: Adding host entry
    23. 9. Handling Container Memory Issues
    24. Example: Setting Memory Limits
    25. Example: Using Memory Swap
    26. 10. Resolving Docker Daemon Errors
    27. Example: Restarting Docker Service
    28. 11. Fixing Registry Authentication Errors
    29. Example: Logging into a Private Registry
    30. Common Authentication Flow
    31. 12. Handling Compose File Errors
    32. Example: Fixing Invalid YAML

  39. Implementing Production Best Practices

    1. 1. Using Non-Root Users
    2. Example: Creating a Non-Root User
    3. 2. Running One Process Per Container
    4. Example: Correct Usage
    5. Example: Incorrect Usage
    6. 3. Implementing Health Checks
    7. Example: Health Check in Dockerfile
    8. 4. Setting Resource Limits
    9. Example: Limiting CPU and Memory Usage
    10. Example: Setting Memory Swap Limit
    11. 5. Using Named Volumes for Persistence
    12. Example: Creating and Using a Named Volume
    13. Key Benefits of Named Volumes
    14. 6. Externalizing Configuration
    15. Example: Using Environment Variables for DB Config
    16. 7. Implementing Graceful Shutdown
    17. Example: Handling SIGTERM in Node.js
    18. Example: Dockerfile with graceful shutdown
    19. 8. Using Labels for Metadata
    20. Example: Adding Labels to Dockerfile
    21. Example: Adding Labels via Docker Run
    22. 9. Versioning Images with Tags
    23. Example: Tagging Images for Release
    24. 10. Scanning for Vulnerabilities
    25. Example: Running a vulnerability scan with Trivy
    26. Key Points
    27. 11. Documenting Dockerfiles with Comments
    28. Example: Commented Dockerfile
    29. 12. Using Official Base Images
    30. Example: Using Official Base Image in Dockerfile

  40. Managing Docker in Production

    1. 1. Implementing Rolling Updates
    2. Example: Update Service with Rolling Strategy
    3. Rolling Update Best Practices
    4. 2. Configuring Zero-Downtime Deployments
    5. Example: Using Docker Compose for Rolling Updates
    6. Zero-Downtime Deployment Best Practices
    7. 3. Setting Up Health Monitoring
    8. Example: Docker Healthcheck Configuration
    9. Example: Healthcheck with Custom Script
    10. Example: Monitoring with Prometheus
    11. 4. Implementing Log Aggregation
    12. Example: Basic Docker Log Configuration
    13. Example: Using Fluentd for Log Aggregation
    14. Best Practices for Log Aggregation
    15. 5. Using Centralized Logging
    16. Example: Configure Docker to send logs to a central logging service
    17. 6. Configuring Backup Strategies
    18. Example: Docker Volume Backup Script
    19. Backup Best Practices
    20. 7. Implementing Disaster Recovery
    21. Example: Backup and Restore Strategy
    22. Disaster Recovery Best Practices
    23. 8. Managing Secrets Securely
    24. Example: Using Docker Secrets in Swarm
    25. Best Practices for Secret Management
    26. 9. Setting Up Access Control
    27. Example: Creating a Secure User Group
    28. 10. Monitoring Container Metrics
    29. Example: Collecting Container Metrics with Docker Stats
    30. Example: Using Prometheus to Monitor Docker Metrics
    31. 11. Implementing Auto-Scaling
    32. Example: Scaling a Service
    33. Example: Auto-scaling with External Tools
    34. 12. Managing Production Deployments
    35. Example: Docker Compose for Production
    36. Example: Health Checks in Production
    37. Production Deployment Best Practices

  41. Using Docker with CI/CD

    1. 1. Building Images in CI Pipelines
    2. Example: GitLab CI Pipeline Configuration
    3. 2. Tagging Images with Build Numbers
    4. Example: Tagging with Build Number
    5. Example: Tagging with Branch and Commit
    6. 3. Pushing Images to Registry Automatically
    7. Example: GitHub Actions Workflow
    8. 4. Running Tests in Containers
    9. Example: Running Tests in a Node.js Container
    10. Example: Using Docker Compose for Test Execution
    11. 5. Implementing Multi-Stage Builds for CI
    12. Example: Multi-stage Dockerfile for CI
    13. Best Practices for Multi-Stage Builds in CI
    14. 6. Caching Layers in CI/CD
    15. Example: Using Docker BuildKit with Cache
    16. Best Practices for Layer Caching
    17. 7. Using Docker Compose for Testing
    18. Example: Test Service Setup
    19. Best Practices for Testing with Docker Compose
    20. 8. Implementing Security Scans in Pipeline
    21. Example: Docker Security Scan with Trivy
    22. Security Scanning Tools Comparison
    23. 9. Deploying Containers from CI/CD
    24. Example: GitHub Actions Deployment
    25. 10. Using Docker API in Automation
    26. Example: Automate Container Lifecycle
    27. 11. Configuring Docker Daemon for CI
    28. Example: Docker daemon configuration file
    29. 12. Managing CI/CD Secrets with Docker
    30. Example: Using Docker Secrets in a Service
    31. Best Practices for CI/CD Secrets

  42. Docker CLI Tips and Shortcuts

    1. 1. Using Command Aliases
    2. Example: Setting up aliases in .bashrc or .zshrc
    3. 2. Formatting Output
    4. Example: Formatting Docker Container List
    5. Example: Custom JSON Output
    6. 3. Using Filters Effectively
    7. Example: Filtering Containers by Label
    8. Example: Filtering Images by Parent Image
    9. 4. Using Quiet Mode
    10. Example: Using quiet mode to get container IDs
    11. Example: Using quiet mode to get image IDs
    12. 5. Combining Commands with Pipes
    13. Example: Filter containers by status using
    14. Example: Get container IDs of stopped containers
    15. Example: Count running containers
    16. 6. Leveraging Bash Completion
    17. Example: Enabling Bash Completion
    18. Benefits of Bash Completion
    19. 7. Using Latest Container
    20. Example: Run a container with custom port mapping
    21. Example: Run a container with environment variables
    22. 8. Chaining Docker Commands
    23. Example: Run and Remove Container in One Command
    24. Example: Chain Multiple Commands with &&
    25. Example: Use Shell Pipes to Chain Commands
    26. Best Practices for Chaining Commands
    27. 9. Using Shell Variables in Commands
    28. Example: Setting and Using Variables
    29. 10. Exporting Environment Variables
    30. Example: Setting Environment Variables
    31. 11. Using Docker Context Efficiently
    32. Example: Creating a remote context
    33. 12. Cleaning Up All Resources
    34. Example: Remove all stopped containers, unused networks, unused images, and build cache