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:

What helps:

No formal prerequisites. The courses under "Take first" cover what helps.

Take first:

Take next:

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)

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.

Course outline

Start Here

  1. 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.
  2. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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

  1. 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.
  2. 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.
  3. 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

  1. 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.
  2. 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.