FREE DOCKER CONTAINERS LEARNING PATH

WikiFree original practice workbook

The container dock

CASE STATUS: fictional/synthetic teaching material. Do not present the example as real research, employment experience or measured business performance.

OUTCOME
Containerize a tiny local web service, run it with an explicit port mapping and document image, container, configuration and data-lifecycle behavior.

BEFORE YOU START
Basic terminal commands and the Node.js API path or equivalent simple server knowledge. Access to an appropriate Docker installation.

CASE
The fictional Juniper Status service returns a fixed JSON health response. It has no database, secrets or external API. The learning container binds a local host port for review; the project does not deploy to the public internet.

INPUTS
Concept,Practice artifact
Image,Built from a Dockerfile
Container,A running instance of the image
Port mapping,Local host port to application port
Configuration,An explicit nonsecret environment value
Persistence,No persistent application data in this example


ENTRY CHECK

Question: Is an image the same as a running container?

Self-check: No.

Question: Does deleting a container automatically preserve its writable data?

Self-check: Do not assume it does; use deliberate persistence design when needed.

Question: Should secrets be baked into an image?

Self-check: No.

STAGE 1: Explain image and container boundaries

Prerequisite: Basic terminal commands and the Node.js API path or equivalent simple server knowledge. Access to an appropriate Docker installation.

Instruction: An image packages a filesystem and configuration used to create containers. A container is an instance with runtime state. This distinction explains why rebuilding an image and restarting a container are different actions. Our tiny service deliberately avoids persistence so the first experiment focuses on packaging and execution rather than database operations.

Practice task: Draw the relationship between source files, Dockerfile, image and running container. Label what changes during a rebuild.

Deliverable: A container lifecycle map.

Acceptance check: The map distinguishes immutable image content from a running instance and its writable state.

If stuck: Do not describe a container as a complete independent physical machine.

Record your work, decisions and evidence:




Record your result against the acceptance check:



STAGE 2: Create a small build context

Prerequisite: Bring your previous output: A container lifecycle map.

Instruction: The build context is the set of files available to the build. Keep it narrow and exclude unrelated files with a .dockerignore. Use a documented official base image and a nonroot application user where practical. The supplied service uses built-in Node modules, so the image does not need a large dependency install for this exercise.

Practice task: Review the service, Dockerfile and ignore file. Build an image in the dedicated project folder and record the selected base tag.

Deliverable: A small documented image build.

Acceptance check: Only intended source files enter the context and no credentials or personal files are copied.

If stuck: Do not build from a broad home directory just because the command runs there.

Record your work, decisions and evidence:




Record your result against the acceptance check:



STAGE 3: Run and inspect the service

Prerequisite: Bring your previous output: A small documented image build.

Instruction: A port mapping connects a host port to the application listening port inside the container. For local practice, bind the host side to loopback. Inspect container status and logs, then request the health endpoint. A running process does not prove the expected response works, so test the user-visible behavior after starting it.

Practice task: Run the container with the documented local mapping and request its JSON health response. Record status and logs.

Deliverable: A running local container and response check.

Acceptance check: The health response matches the contract and the host mapping is limited to localhost.

If stuck: If the endpoint fails, compare application listen address, container port and host mapping before rebuilding.

Record your work, decisions and evidence:




Record your result against the acceptance check:



STAGE 4: Separate configuration and lifecycle

Prerequisite: Bring your previous output: A running local container and response check.

Instruction: Runtime configuration can vary without copying a new secret into the image. Use a harmless environment value such as APP_LABEL in this exercise. Stop and recreate the container to observe the difference between image contents and runtime settings. Compose can describe the same local setup declaratively; current command syntax may differ from older video demonstrations.

Practice task: Run two instances sequentially with different APP_LABEL values, then express the setup in the supplied Compose file.

Deliverable: A configuration and lifecycle demonstration.

Acceptance check: The label changes at runtime without editing source, and no claim of durable data storage is made.

If stuck: Do not treat a container writable layer as a backup strategy.

Record your work, decisions and evidence:




Record your result against the acceptance check:



STAGE 5: Document a reproducible handover

Prerequisite: Bring your previous output: A configuration and lifecycle demonstration.

Instruction: A handover needs the source, Dockerfile, runtime command, tested image tag and observed response. Record the actual engine and Compose versions if used. Clean up only the named practice container and image when finished, preserving unrelated work. Production use would need additional security, update, monitoring and persistence decisions beyond this local demonstration.

Practice task: Write the README, rerun from the project files and document a missing-port-mapping failure and its correction.

Deliverable: A containerized service package and troubleshooting note.

Acceptance check: A reviewer can rebuild and run the service using the documented commands and understand the limits.

If stuck: Do not claim production readiness or cross-platform testing from one successful local run.

Record your work, decisions and evidence:




Record your result against the acceptance check:



WORKED CASE
The image contains the service code; APP_LABEL is supplied at run time. The application listens inside the container, while an explicit loopback port mapping exposes it only for local review. A successful health response verifies more than container status alone.

FINAL PROJECT
Deliver the service, Dockerfile, ignore file, Compose file, README and observed run evidence. Rebuild after a harmless response change and explain why an existing container does not automatically adopt the new image.

REQUIRED CRITICAL CHECK
The build context excludes unrelated files and secrets, and the demonstrated service remains a clearly scoped local exercise.

SCORING
Score each of the five stage acceptance checks from 0–16 (0 missing/incorrect; 8 partially supported; 16 complete and evidenced). Score the final integrated project from 0–20 (0 missing; 10 incomplete handover; 20 complete, reproducible and consistent with the case). Target: at least 80/100 AND the critical check must pass. A total score never overrides a failed critical check.

SCOPE LIMIT
This is an introductory packaging project, not Kubernetes, swarm administration, production deployment or persistent database design.

SOURCES AND ACCESS
Videos are free. Docker Engine provides a local Linux route; Docker Desktop use depends on its current terms and the learner organization. Check official installation and licensing guidance for your environment. No paid hosting is required.

Free Simplilearn Course: Docker Containers, Compose and Deployment
WikiFree: https://wikifree.com/courses/free-simplilearn-docker-containers-compose-and-deployment/
Official source: https://www.youtube.com/playlist?list=PLEiEAq2VkUULWjtlQxn8Wq9sPdxg-N-T0
Why selected: Selected public Docker lessons cover concepts, basic operation, containers, Compose and packaging an application; long overlapping compilation videos are excluded.

Stage 1 selected lessons:

1. What Is Docker? — What Is Docker And How It Works? — Docker Tutorial For Beginners (15:52)
https://www.youtube.com/watch?v=rOTqprHv1YE&list=PLEiEAq2VkUULWjtlQxn8Wq9sPdxg-N-T0&index=1

Stage 2 selected lessons:

2. Docker Tutorial For Beginners — What Is Docker And How It Works? — Docker Tutorial (30:07)
https://www.youtube.com/watch?v=o5af1LBgAFw&list=PLEiEAq2VkUULWjtlQxn8Wq9sPdxg-N-T0&index=2

Stage 3 selected lessons:

5. What Is A Docker Container? — Docker Container Tutorial For Beginners — Docker Container (21:19)
https://www.youtube.com/watch?v=xnuXKYsZv2Y&list=PLEiEAq2VkUULWjtlQxn8Wq9sPdxg-N-T0&index=5

Stage 4 selected lessons:

7. Docker Compose — Docker Compose Tutorial — Docker Tutorial For Beginners — Docker in 2026 (17:42)
https://www.youtube.com/watch?v=DX1T-PKHKhg&list=PLEiEAq2VkUULWjtlQxn8Wq9sPdxg-N-T0&index=7

Stage 5 selected lessons:

8. Dockerizing An Application — Docker Tutorial For Beginners — DevOps Tutorial Video (21:10)
https://www.youtube.com/watch?v=rNsQGvt9v4k&list=PLEiEAq2VkUULWjtlQxn8Wq9sPdxg-N-T0&index=8

Docker overview
https://docs.docker.com/get-started/docker-overview/

Docker Engine installation
https://docs.docker.com/engine/install/

REUSE
Original WikiFree teaching text and synthetic fixtures are supplied for personal learning and adaptation with attribution. Provider lessons remain on their original sites and retain their own terms. No provider certificate is included.