DCA course and practice exam: Docker Certified Associate
This DCA course has 32 video lessons and 65 graded labs, and its DCA practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
Orchestration, images, installation, networking, security and storage
Prepares you for the Docker Certified Associate exam: orchestration, images and registries, installation and configuration, networking, security, and storage and volumes.
Intermediate · 3 hours · 32 lessons · 66 labs
DCA exam guide
The DCA exam (Docker Certified Associate, by Mirantis (Docker Enterprise Platform Business)): 90 minutes; questions: 55; cost: USD 199 / EUR 200 per attempt; a retake waits 14 days.
- Format: 13 multiple-choice and 42 Discrete Option Multiple Choice (DOMC) questions
- Duration: 90 minutes
- Questions: 55
- Pass mark: Not published
- Cost: USD 199 / EUR 200 per attempt; a retake waits 14 days
- Valid for: 2 years
- Delivery: Online proctored (remote)
- Prerequisites: Minimum 6–12 months of Docker experience recommended
Exam domains and weights
- Orchestration: 25%
- Image Creation, Management, and Registry: 20%
- Installation and Configuration: 15%
- Networking: 15%
- Security: 15%
- Storage and Volumes: 10%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 DCA sample questions with answers: free to read, no account needed.
Common questions
How long is the DCA exam?
The DCA exam lasts 90 minutes.
How many questions are on the DCA exam?
55.
How much does the DCA exam cost?
USD 199 / EUR 200 per attempt; a retake waits 14 days.
Is there a free DCA practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: Docker Certification page (Mirantis Training) (Mirantis (Docker Enterprise Platform Business)), checked 2026-10-03.
Who it is for
Intermediate level.
For engineers and administrators who already use Docker and want the Docker Certified Associate certificate: swarm, images, registries, networking, security and storage.
What you don't need yet:
- No Docker install or swarm: labs replay real recorded sessions
- No Kubernetes experience: the exam's Kubernetes part is taught
- No Python or other programming language
What helps:
- Docker basics: images, containers and docker run
- Comfort reading commands at a Linux command line
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
- Docker Architecture & Production Containers — Intermediate
- Linux Fundamentals & Systems Administration — Beginner
Take next:
- Kubernetes: Production-Grade Container Orchestration — Advanced
- Certified Kubernetes Administrator (CKA) Exam Prep — Intermediate
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
The DCA is a multiple-choice exam, partly in DOMC form: passing shows you know Docker and its orchestration. It doesn't test hands-on skill or replace running containers in production; our graded labs replay real recorded sessions.
Exam objectives this course teaches
Docker Certified Associate (DCA)
- Orchestration (25% of the exam): Complete the setup of a swarm mode cluster, with managers and worker nodes; Describe and demonstrate how to extend the instructions to run individual containers into running services under swarm; Describe the importance of quorum in a swarm cluster; Describe the difference between running a container and running a service; Interpret the output of "docker inspect" commands; Convert an application deployment into a stack file using a YAML compose file with "docker stack deploy"; Manipulate a running stack of services; Describe and demonstrate orchestration activities (increase replicas; add networks, publish ports; mount volumes); Describe and demonstrate how to run replicated and global services; Apply node labels to demonstrate placement of tasks; Describe and demonstrate how to use templates with "docker service create"; Identify the steps needed to troubleshoot a service not deploying; Describe how a Dockerized application communicates with legacy systems; Describe how to deploy containerized workloads as Kubernetes pods and deployments; Describe how to provide configuration to Kubernetes pods using configMaps and secrets
- Image Creation, Management, and Registry (20% of the exam): Describe the use of Dockerfile; Describe Dockerfile options such as add, copy, volumes, expose, entry point; Identify and display the main parts of a Dockerfile; Describe and demonstrate how to create an efficient image via a Dockerfile; Describe and demonstrate how to use CLI commands to manage images (list, delete, prune, rmi); Describe and demonstrate how to inspect images and report specific attributes using filter and format; Describe and demonstrate how to tag an image; Describe and demonstrate how to apply a file to create a Docker image; Describe and demonstrate how to display layers of a Docker image; Describe and demonstrate how to modify an image to a single layer; Describe and demonstrate registry functions: deploy, log in, search, push, sign, pull, and delete images
- Installation and Configuration (15% of the exam): Describe sizing requirements for installation; Describe and demonstrate configuration of logging drivers (splunk, journald, etc.); Describe and demonstrate how to create and manage users and teams; Describe and demonstrate how to configure the Docker daemon to start on boot; Describe the use of namespaces, cgroups, and certificate configuration; Describe and demonstrate how to configure backups for UCP and DTR; Describe and demonstrate the setup of repo, selection of a storage driver, and installation of the Docker engine on multiple platforms; Describe and demonstrate how to set up swarm, configure managers, add nodes, and set up the backup schedule; Describe and demonstrate how to use certificate-based client-server authentication to ensure a Docker daemon has the rights to access images on a registry; Describe and interpret errors to troubleshoot installation issues without assistance; Describe and demonstrate the steps to deploy Docker engine, UCP, and DTR on AWS and on-premises in an HA configuration
- Networking (15% of the exam): Describe the Container Network Model and how it interfaces with the Docker engine and network and IPAM drivers; Describe the different types and use cases for the built-in network drivers; Describe and demonstrate how to create a Docker bridge network for developers to use for their containers; Describe and demonstrate how to publish a port so that an application is accessible externally; Identify which IP and port a container is externally accessible on; Compare and contrast "host" and "ingress" publishing modes; Describe and demonstrate how to configure Docker to use external DNS; Describe and demonstrate how to deploy a service on a Docker overlay network; Describe and demonstrate how to troubleshoot container and engine logs to resolve connectivity issues between containers; Describe the Kubernetes container network model; Describe and demonstrate how to use Docker to load balance HTTP/HTTPS traffic to an application (L7 load balancing with Docker EE); Understand and describe the types of traffic that flow between the Docker engine, registry, and UCP controllers; Describe how to route traffic to Kubernetes pods using ClusterIP and NodePort services
- Security (15% of the exam): Describe security administration and tasks; Describe the process of signing an image; Describe default engine security; Describe swarm default security; Describe MTLS; Describe identity roles; Compare and contrast UCP workers and managers; Describe the process to use external certificates with UCP and DTR; Describe and demonstrate that an image passes a security scan; Describe and demonstrate how to enable Docker Content Trust; Describe and demonstrate how to configure RBAC with UCP; Describe and demonstrate how to integrate UCP with LDAP/AD; Describe and demonstrate how to create UCP client bundles
- Storage and Volumes (10% of the exam): Identify the correct graph drivers to use with various operating systems; Describe and demonstrate how to configure devicemapper; Compare and contrast object and block storage and when they should be used; Describe how an application is composed of layers and where these layers reside on the filesystem; Describe the use of volumes with Docker for persistent storage; Identify the steps to take to clean up unused images on a filesystem and DTR; Describe and demonstrate how storage can be used across cluster nodes; Describe how to provision persistent storage to a Kubernetes pod using persistentVolumes; Describe the relationship between container storage interface drivers, storageClass, persistentVolumeClaim and volume objects in Kubernetes
Labs
66 labs, 65 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- Two Managers Down: The Night The Swarm Froze (2 labs): You can explain why a three-manager swarm survives one lost manager but not two, read the recorded errors that prove it, say what keeps running without a leader, and recover with force-new-cluster.
- One Option At A Time: How DOMC Changes The Exam (2 labs): You can explain how a discrete option item is delivered and scored, avoid the two habits that lose DOMC marks, and pace fifty-five items in ninety minutes with a budget per domain.
Orchestration
- Five Nodes Before Lunch: Building A Swarm (2 labs): You can initialise a swarm, join managers and workers with the right tokens, promote and demote nodes, spread managers over failure zones and schedule a swarm backup the way Docker documents it.
- From docker run To docker service: Replicas, Global Mode And Updates (3 labs): You can turn a docker run command into a docker service create command, explain how a service differs from a container, scale replicated services, run a global service on every node, and read an update that rolled itself back.
- One File, Five Services: Stacks From Compose Files (2 labs): You can turn a compose file into a stack with docker stack deploy, say which compose keys a swarm ignores or rejects, check a stack file before deploying it, and change a running stack by redeploying it.
- Where Do The Tasks Land? Labels, Constraints And Templates (2 labs): You can label nodes, keep tasks on matching nodes with constraints, spread them over label values with placement preferences, predict where tasks land, explain a Pending task, and name tasks with service templates.
- Stuck In Pending: Troubleshooting Services And Reading docker inspect (2 labs): You can follow a fixed order of checks for a service that will not deploy, read the fields of docker inspect output with --format and jq, and explain how a swarm service reaches a legacy system outside the cluster.
- The Same Shop On Kubernetes: Pods, Services And Storage For The DCA (2 labs): You can describe a Kubernetes Deployment, its pods, ConfigMaps and Secrets, ClusterIP and NodePort Services, and persistent storage through PersistentVolumeClaims and StorageClasses, and validate the manifests against the Kubernetes schemas.
- Orchestration Sprint: Eight Calls In Eight Minutes (2 labs): You can answer mixed orchestration questions at exam speed: quorum, placement, global and replicated services, stack files, templates, troubleshooting and Kubernetes objects.
Images And Registry
- Twelve Lines, Ten Warnings: Dockerfile Instructions And hadolint (2 labs): You can name the parts of a Dockerfile, explain what FROM, RUN, COPY, ADD, WORKDIR, ENV, EXPOSE, VOLUME, USER, CMD and ENTRYPOINT each do, build an image from a chosen file, and fix what hadolint reports.
- One Edited File, Six Rebuilt Steps: Layers, Cache And Flat Images (2 labs): You can predict which Dockerfile steps the build cache reuses, order a Dockerfile so edits rebuild little, keep images small with combined RUN steps and multi-stage builds, list an image's layers, and flatten an image to a single layer.
- Three Names, One Image: Listing, Formatting, Tagging And Pruning (3 labs): You can list and filter images, print exactly the attributes you need with --format, tag one image under several names, and predict what docker rmi, docker image prune and prune -a will remove.
- Our Own Registry: Deploy, Push, Pull, Search And Delete (2 labs): You can run a private registry, tag and push images to it, read its catalog and tags through the HTTP API, pull by tag and by digest, log in, say what docker search can and cannot search, and delete images and reclaim their space.
- Images Sprint: Eight Questions On Builds, Tags And Registries (2 labs): You can answer mixed image and registry questions at exam speed: Dockerfile instructions, the build cache, multi-stage builds, layers, filters and formats, tags, pruning and registry operations.
Installation And Configuration
- One Comma, No Engine: Installing And Configuring Docker Engine (2 labs): You can install Docker Engine from Docker's repository, enable it to start on boot, write a daemon.json that the engine accepts, validate it with dockerd --validate, and read the errors that stop an engine from starting.
- Forty Gigabytes Of One Log: Logging Drivers And Their Options (2 labs): You can set a default logging driver and options in daemon.json, override them per container or service, choose between json-file, local, journald, syslog, splunk and gelf, predict when docker logs still works, and size log rotation.
- Port 2375, Open To The Office: Engine TLS And Registry Certificates (2 labs): You can protect the Docker API with mutual TLS, build a CA, server and client certificates with openssl, configure the engine and the client to use them, and set up /etc/docker/certs.d so an engine trusts a registry and authenticates to it.
- Two Of Everything: Deploying, Sizing And Backing Up UCP And DTR (2 labs): You can compare UCP (now MKE) managers and workers, plan a highly available MKE and MSR deployment on AWS or on premises, size its nodes, install it with your own certificates, and say what the swarm, MKE and MSR backups each contain.
- Installation Sprint: Eight Configuration Calls (2 labs): You can answer mixed installation and configuration questions at exam speed: daemon.json keys and conflicts, start on boot, logging drivers, TLS and registry certificates, UCP and DTR high availability and backups.
Networking
- One Name That Fails: The Container Network Model, Drivers And DNS (2 labs): You can describe the Container Network Model and its network and IPAM drivers, choose between bridge, host, none, overlay and macvlan, create a user-defined bridge network for developers, and configure containers and engines to use external DNS.
- It Works On The Host: Publishing Ports And Tracing Connections (2 labs): You can publish container ports with -p and -P, work out which IP address and port reach a container from the host, the network and other containers, and troubleshoot connectivity between containers from their errors and logs.
- Any Node, Any Task: Overlay Networks, The Routing Mesh And Layer 7 (2 labs): You can deploy services on an overlay network, compare ingress and host publishing, predict which node answers a request, describe layer 7 load balancing with Interlock, and list the traffic that flows between engines, the registry and UCP controllers.
- Networking Sprint: Eight Questions On Bridges, Meshes And Ports (2 labs): You can answer mixed networking questions at exam speed: network drivers, DNS, port publishing, ingress and host modes, overlay networks and their ports, stack networks and Kubernetes service types.
Security
- Root, But Not That Root: Default Engine Security And Image Scanning (2 labs): You can describe how namespaces, cgroups, capabilities and seccomp confine a container by default, harden a container with users, dropped capabilities, read-only filesystems and limits, and show whether an image passes a vulnerability scan.
- Four Questions From The Auditor: Swarm Security, Autolock And Content Trust (2 labs): You can describe swarm mode's default security, read a node's certificate to show how mutual TLS identifies nodes, rotate certificates and the CA, lock managers with autolock, and explain how Docker Content Trust signs images and why current Docker no longer has it.
- Who Let Femi In? UCP Roles, Grants, LDAP And Client Bundles (2 labs): You can create and manage UCP users, teams and organizations, choose between UCP's built-in roles, configure RBAC with grants on collections, integrate UCP with LDAP or Active Directory, and create and use client bundles.
- Security Sprint: Eight Questions On Defaults, Trust And Access (2 labs): You can answer mixed security questions at exam speed: default engine and swarm security, capabilities, autolock, Content Trust, vulnerability scans, UCP roles and grants, LDAP and client bundles.
Storage And Volumes
- Two Containers, How Much Disk? Storage Drivers, Layers And devicemapper (2 labs): You can explain how image and container layers sit on disk with copy-on-write, choose the right storage driver for an operating system, read a container's overlay2 directories and sizes, and describe how devicemapper was configured in loop-lvm and direct-lvm modes and why Engine 25 and later cannot use it.
- Orders That Vanished: Volumes, Shared Storage And Cleanup (2 labs): You can use named volumes, bind mounts and tmpfs for persistent and temporary data, explain how storage is shared across cluster nodes, compare object and block storage, and clean up unused images, volumes and DTR content.
- Storage Sprint: Eight Questions On Layers, Drivers And Volumes (2 labs): You can answer mixed storage questions at exam speed: layer sharing, storage drivers per platform, devicemapper modes, volumes across nodes, object and block storage, cleanup, and Kubernetes storage classes and claims.
Mock And Review
- Friday, Nine In The Morning: The Mock Exam And Its Report (2 labs): You can sit a full timed DCA mock of 55 items in 90 minutes, pace it with checkpoints, answer DOMC items under time pressure, and read a score report by domain to plan the last days before the exam.
- The Night Before: Final Review And Exam Day (2 labs): You can map the exam's UCP, DTR and Docker EE names to MKE, MSR and MCR, answer for features current Docker has removed, recall the rules and numbers each domain tests, judge DOMC statements quickly, and prepare for the proctored exam and a possible retake.