Docker

Container work breaks down when each engineer installs Docker differently, builds images by habit, and pushes to cloud targets without a shared process. The result is inconsistent images, risky daemon configurations, and deployments only one person understands. This course gives DevOps teams a common baseline, from local setup on Linux, Windows 10, and WSL through image builds, Docker Swarm, and deployment to Kubernetes, Amazon ECS, Amazon EKS with eksctl, AWS CodeBuild, and Azure.

Risk and configuration hygiene: The training flags insecure choices, such as exposing the Docker daemon over an unprotected TCP interface. It shows a safer pattern: reaching remote hosts over SSH with Docker contexts. For EKS work, learners need IAM credentials set up correctly, so pair this course with your internal access policies.

Role fit: This course is built for DevOps engineers, platform engineers, and systems administrators with roughly three to five years of experience. It is not an entry-level primer. Team Leads can assign the cloud modules selectively by deployment target, such as AWS, Azure, or Kubernetes.

Time investment: Plan for about 13 hours per learner, delivered in short Nuggets. That fits a multi-week enablement plan better than a one-day session.

Change management: Instructors note that the demos may not mirror your environment exactly, and that most organizations automate these steps through CI/CD workflows. Before the team starts, agree on your own image tagging, registry, and pipeline standards.

Training Managers can sequence the modules with Playlists alongside those standards. Team Reporting then shows per-learner progress and completion, so you can see who is ready for hands-on container work.

Container work breaks down when every engineer sets up Docker differently and ships images by habit. This training gives DevOps teams a shared, repeatable workflow from the local workstation to production environments, grounded in scenarios engineers will recognize.

• Safer, consistent setup across Linux, Windows, and WSL. Your team configures Docker Desktop and the Linux daemon the same way. They avoid insecure options such as exposing the daemon on an unencrypted TCP interface and manage remote hosts over SSH with Docker contexts.
• Repeatable, versioned images. Engineers learn how the build context and Dockerfile instructions shape an image. They tag images for version control and push them to a central registry that feeds Kubernetes, AWS Fargate, or Azure Container Instances. This cuts "works on my machine" drift between environments.
• Right-sized multi-container apps. The team builds patterns for containers that work together, with each service handling a clear role instead of packing everything into one image. That makes app components easier to update, troubleshoot, and move between environments.
• A path to hands-off delivery. The team deploys to Kubernetes, Amazon ECS, Amazon EKS with eksctl, and Azure, and builds images with AWS CodeBuild. They also automate routine Docker Engine tasks. The result moves your team from manual steps toward a pipeline that can test, build, and deploy containers across clusters, with less repetitive work and fewer one-off deployments.

Knowledge

• How Docker runs Windows and Linux containers, and how to install and configure it on Linux (systemd), Windows Docker Desktop, and WSL, including why exposing the daemon over unsecured TCP is risky and why SSH-based Docker contexts are the safer choice
• How container images work: Dockerfiles, RUN and ENV instructions, the build context, tagging for version control, and pushing to a central registry for distribution
• How Docker Swarm clusters nodes and runs services, and how Docker Compose defines, monitors, and scales multi-container applications with overrides and environment variables
• How containerized workloads deploy to Kubernetes, Amazon EKS with eksctl and IAM credentials, Amazon ECS, AWS CodeBuild, and Azure
• How Python can automate routine tasks against the Docker API

Ability

• Pull versioned images from Docker Hub and run, inspect, and debug interactive containers with the Docker CLI
• Build custom images from a Dockerfile, then tag and push them to a registry for repeatable deployments
• Initialize a Docker Swarm cluster, deploy services to it, and scale individual Docker Compose services to match their workload needs
• Create and manage EKS clusters and node groups with eksctl, and build images with AWS CodeBuild
• Deploy a containerized application to a managed Kubernetes cluster and identify the repeatable operational steps involved
• Automate routine Docker Engine tasks with Python to reduce manual container management