Packaging & Reproducibility

The arc of Packaging & Reproducibility: get a Docker image that runs the model, make the build reproducible, make it safe to run anywhere, and make it slim — so the model the earlier modules built runs identically on a machine that has never seen the code.

Write a Dockerfile, build it, run it, and score a record end to end — the working image every later lesson in this module hardens.

Freeze the dependency graph into the image and order the Dockerfile so a one-line code edit does not re-resolve and reinstall every dependency — the difference between an image that builds and one that builds the same.

Harden the reproducible image against what it carries across machines: keep config in the environment, never write a secret into a layer, and decide once what even enters the build context.

Diagnose "works on my machine" as a missing-environment failure, then cut a multi-GB image to a few hundred MB with the same model and the same behaviour.

Turn a score-and-exit container into a long-lived service: a blocking server as PID 1, a published port bound to the right interface, and persistent state in a volume rather than the throwaway writable layer.

Replace a page of docker run flags with one declarative compose.yaml: two services that come up on one command, find each other by service name, and gate the frontend on the backend being ready — not merely started.

A recap of Packaging & Reproducibility: a Docker image that runs the model, a build that reproduces from a clean machine, secrets kept out of the layers, a slim multi-stage artifact, the image run as a long-lived service, and a multi-service stack composed on one command — and where the system goes next.