12.2 Language Docker Workflows

Language Docker workflows are the specific patterns and conventions different programming language ecosystems have developed for containerizing applications written in that language, reflecting each language's particular build process, dependency management approach, and runtime characteristics.

Why Different Languages Warrant Different Specific Patterns

A compiled language's image typically benefits from a multi-stage build separating compilation from the final runtime, while an interpreted language's image might simply need its runtime and dependencies installed directly, without a separate compilation step at all.

FROM golang:1.22 AS build
RUN go build -o app .

FROM alpine
COPY --from=build /app /app

FROM python:3.12-slim
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .

The first reflects a compiled language's typical multi-stage pattern; the second, an interpreted language's more direct approach.

Why Dependency Management Conventions Differ as Well

Each language ecosystem has its own established convention for declaring and installing dependencies, which a Dockerfile needs to specifically accommodate.

COPY package.json package-lock.json ./
RUN npm ci

COPY Gemfile Gemfile.lock ./
RUN bundle install

Why Understanding Language-Specific Conventions Improves Image Quality

Following the established, well-understood patterns for a given language — proper dependency layer caching, appropriate multi-stage build structure, minimal final runtime image — generally produces a more efficient, maintainable Dockerfile than approaching containerization without this language-specific context.

FROM node:20-alpine AS deps
COPY package*.json ./
RUN npm ci

FROM node:20-alpine
COPY --from=deps /app/node_modules ./node_modules
COPY . .

Why Language Docker Workflows Matter

Recognizing that each programming language ecosystem has developed its own specific, well-established containerization patterns — rather than applying one generic approach uniformly — leads to more efficient, idiomatic, and maintainable Dockerfiles tailored to each language's actual build and runtime characteristics.