Computer science students in Tunisia often meet Docker in a lecture slide and Kubernetes in a job posting—without ever having run a container locally. This guide is a practical first week: images, containers, registries, and why orchestration exists, written for labs on modest laptops and university networks.
DarDevLab uses this curriculum shape in workshops at ENSI, ESPRIT, and similar programs before students touch client infrastructure.
Day 1 — What a container actually is
A container is a process with isolated filesystem and network namespace—not a mini-VM. Compare docker run hello-world to running python on the host: same CPU, different filesystem view. Students should draw the host kernel shared by all containers.
- Image: immutable template (layers)
- Container: running instance of an image
- Dockerfile: recipe to build an image
- Registry: store and share images (Docker Hub, GHCR)
Day 2 — Build and run your first app
- Simple HTTP server
Flask or Express in 20 lines; Dockerfile with EXPOSE and CMD.
- docker build and run
Map port -p 8080:8080; verify curl from another terminal.
- Environment variables
Pass CONFIG=dev without rebuilding—config belongs outside image.
- Logs
docker logs; discuss why printf debugging in prod fails.
Day 3 — Compose for multi-container apps
Introduce docker-compose.yml with web + Postgres. Students learn service names as DNS, volume for DB persistence, and why depends_on is not readiness. Tear down with volumes once to show data loss—memorable lesson.
Day 4 — Why Kubernetes appears in job posts
When you have ten services, rolling updates, and multiple replicas, Compose on one machine breaks down. Explain Deployment, Pod, Service at whiteboard level—students install minikube or kind for one kubectl get pods success moment.
Day 5 — Lab assignment ideas
- Containerize a class project with multi-stage build
- Document image size before/after slim base
- Write HEALTHCHECK that fails when DB unreachable
- Present: what breaks if you run container as root
Career context in Tunisia
Local startups and offshore centers hire for Docker familiarity before deep K8s. TTN integrators and hosting shops run containerized stacks on VPS. Students who can debug a failed pull or port conflict stand out in internships.
DarDevLab cohorts continue to GitLab CI and cluster deploy paths—see related guides when you outgrow single-host Compose.
Debugging exercises students should practice
Give deliberate failure scenarios: wrong EXPOSE port, missing env var, volume not mounted, image pull rate limit. Grading should reward documented fix steps, not first-try luck. These mirror internship tickets at Tunis startups.
Introduce docker system df and image layer inspection so students see why slim images matter on slow dorm Wi-Fi. A 1.2 GB dev image teaches more about COPY order than any slide.
Security basics from day one
- Do not commit.env files—use.env.example
- Run app process as non-root in Dockerfile USER directive
- Scan images with trivy or docker scout in extra credit
- Understand why mounting docker.sock into containers is dangerous
University lab machines often share one Docker daemon—discuss tenancy and why production uses orchestrators with RBAC.
Connecting to DarDevLab paths
Students who complete this week can join DarDevLab modules on GitLab CI and VPS deploy scripts—the same tools DarDev engineers use on dardev-vps. Portfolio projects containerized here become credible interview demos.
Faculty can reuse this outline under CC-style attribution; DarDev offers guest workshops on request for ENSI-style programs.
Avoid skipping Compose because Kubernetes is trendy—employers still ask candidates to docker run a service and explain port mapping in technical screens.
Assessment rubric suggestion
Grade on reproducibility: another student clones repo and runs with only README steps. Penalize hard-coded paths and missing.env.example entries. Bonus for image size under two hundred MB on final project.
Oral exam question that separates memorization from understanding: what happens to container filesystem when the process exits but you did not use a volume?
Link curriculum to local internship boards—STB, Telnet, and startup labs increasingly list Docker in requirements even for backend junior roles.
Week two extension: push images to GitHub Container Registry and deploy on a free-tier VPS—students see the full path from laptop to URL.
Container literacy reduces fear when internships assign Kubernetes homework—students already know what a Pod wraps.
Faculty should budget lab hours for image pulls—first session often burns time on registry login and VPN issues at university networks.
Pair students for debugging: one reads Dockerfile, one runs commands—mirrors on-call pairing at DarDev client sites.
Encourage students to write a one-page postmortem when their container fails—communication skill matters as much as syntax for Tunis job market.
DarDevLab publishes cohort dates on dardev.net when enrollment opens for the next container and CI module.
Save lab VM snapshots only after students understand layers—snapshots hide rebuild practice they need for production debugging.
Celebrate first green health check in class—that moment anchors the rest of the cloud-native curriculum.
Docker Desktop license?
Free for education and small orgs; verify current Docker terms for your institution.
Linux VM required?
WSL2 or native Linux preferred; macOS works for learning.
Replace VM course?
Complement—not replace. Understand VMs for legacy; containers for cloud-native paths.
Arabic resources?
DarDevLab sessions mix French and English; official docs remain English-first.
Next after this week?
GitLab CI pipeline guide and cloud-native 90-day learning path on news.dardev.net.
