Conteneurisation : Docker et OCI

Conteneurisation : Docker et OCI

1) Concepts et normes de base du BEC

OCI Image Spec est un format d'image (manifeste, config, calques, index pour multi-arch).
OCI Runtime Spec - Comment démarrer un conteneur (bundle, 'bou. json`); réalisation : runc, ainsi que gVisor, Kata Containers.
OCI Distribution Spec - Interaction avec les registres (push/pull, autorisation).

Docker = UX et l'écosystème autour de l'OCI : Dockerfile/BuildKit/CLI/Composer/Hub. Dans Kubernetes, Docker Engine a été remplacé par containerd/CRI-O, mais le format des images est le même.

2) Images : Calques, balises, métadonnées

Образ = слои (layered filesystem) + config (entrypoint/cmd/env/labels) + manifest.
Tags : n'utilisez pas ': latest' dans la vente ; pinning ': 1. 21. 3 ', git-SHA ou date + SHA.
LABEL : propriétaire, contact, vcs-url, org. opencontainers. (title, description, revision, source).
Multi-arch : Le manifeste-index donne la bonne option pour 'amd64/arm64'.

3) Assemblage : Dockerfile, BuildKit, multi-stage

3. 1 Principes

Réduisez les couches, fixez les versions, nettoyez les cachets des gestionnaires de lots.
Copiez d'abord les fichiers manifeste/lock, puis 'RUN install deps' améliore le cache.
.dockerignore est obligatoire (exclure '.git', artefacts, secrets).
Les échantillons distroless/alpine/base minimale sont préférés.

3. 2 jetons BuildKit

Bilds parallèles, secrets dans l'assemblage ('--secret'), cache mounts, buildx pour multi-arch.

dockerfile syntax=docker/dockerfile:1. 6
RUN --mount=type=cache,target=/root/.cache/pip pip install -r requirements. txt

3. 3 exemples de multi-stage

dockerfile syntax=docker/dockerfile:1. 6
FROM golang:1. 23 AS build
WORKDIR /src
COPY go. mod go. sum./
RUN go mod download
COPY..
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o /app

FROM gcr. io/distroless/static:nonroot
USER 65532:65532
COPY --from=build /app /app
ENTRYPOINT ["/app"]

dockerfile syntax=docker/dockerfile:1. 6
FROM node:22-alpine AS deps
WORKDIR /app
COPY package. json./
RUN npm ci --omit=dev

FROM node:22-alpine AS build
WORKDIR /app
COPY --from=deps /app/node_modules./node_modules
COPY..
RUN npm run build

FROM node:22-alpine
WORKDIR /app
ENV NODE_ENV=production
COPY --from=deps /app/node_modules./node_modules
COPY --from=build /app/dist./dist
USER node
CMD ["node","dist/server. js"]

dockerfile syntax=docker/dockerfile:1. 6
FROM python:3. 12-slim AS base
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
WORKDIR /app

FROM base AS deps
RUN --mount=type=cache,target=/root/.cache/pip pip install --upgrade pip
COPY requirements. txt.
RUN --mount=type=cache,target=/root/.cache/pip pip wheel --wheel-dir=/wheels -r requirements. txt

FROM base
COPY --from=deps /wheels /wheels
RUN pip install --no-index --find-links=/wheels -r /app/requirements. txt && rm -rf /wheels
COPY..
USER 1000:1000
CMD ["python","-m","app"]

dockerfile syntax=docker/dockerfile:1. 6
FROM maven:3. 9-eclipse-temurin-21 AS build
WORKDIR /src
COPY pom. xml./
RUN mvn -q -e -DskipTests dependency:go-offline
COPY..
RUN mvn -q -DskipTests package

FROM eclipse-temurin:21-jre
WORKDIR /app
COPY --from=build /src/target/app. jar /app/app. jar
ENTRYPOINT ["java","-XX:+UseContainerSupport","-jar","/app/app. jar"]

4) Images minimales, PID 1 et signaux

Distroless - Moins de surface d'attaque, pas de shell/gestionnaire de paquets.

dockerfile
ENTRYPOINT ["tini","--","/app"]

« HEALTHCHECK » (fréquence/délai, sans charge excessive).

5) La titrisation des conteneurs

5. 1 Politiques et hardening

Non-root (USER), rootless Docker/containers.
Capabilities : Supprimer le superflu ('--cap-drop = ALL --cap-add = NET _ BIND _ SERVICE', etc.).
seccomp/AppArmor/SELinux : activez les profils par défaut ou stricts.
Read-only FS + `tmpfs` для `/tmp`, no-new-privileges.
Secrets : pas dans les images ; Montez à partir du gestionnaire de secrets (K8s/vault/docker secrets).

5. 2 Supply chain

SBOM (CycloneDX/SPDX) et scan (Trivy/Grype).
Signature (cosign, sigstore) et stratégie sur pull (verify).
Répétitions de mises à jour : les images de base avec des patchs CVE sont régulièrement réécrites.

6) Stockage et pilotes de fichiers

Par défaut, overlay2 (rapide et stable). Les environnements rootless sont souvent fuse-overlayfs.
volumes pour les données et les caches, bind-mount pour le développement.
N'écrivez pas dans '/' - utilisez le chemin de données ('/data '), séparez l'état de l'image.

7) Réseau et DNS

Docker du réseau : bridge (par défaut), host (minimum overhead, conflits de ports), none, macvlan/ipvlan (intégration L2/L3).
DNS resolver Docker prend de l'hôte/daemon. json; pour prod, configurez des resolves cash locaux.
En K8s, le réseau est géré par CNI (Calico/Cilium/Flannel). Pour sidecar/mesh - interceptions (iptables).

8) Ressources et QoS (cgroups v2)

Restrictions : '--cpus', '---memory', '--pids-limit', '--cpuset-cpus'.
Définissez les demandes/limites (en K8s) → affectent la planification et la QoS.
Surveillez OOMKilled, throttling, latinity spikes à cause de GC/IO.

bash docker run --cpus=1. 5 --memory=512m --pids-limit=256 --read-only --tmpfs /tmp:rw,size=64m...

9) Logs et observabilité

Pilotes de logs : 'json-file' (avec rotation), 'journald', 'gelf', 'awslogs', 'syslog'.

json
{ "log-driver":"json-file","log-opts":{"max-size":"10m","max-file":"5"} }

Métriques : API Docker Engine, cAdvisor, node-exportateurs ; la trace à travers l'agent dans le conteneur ou sidecar.

10) Registres et authentification

Registres privés : ECR/GCR/ACR/Harbor/GitHub Container Registry.
Rate-limits Docker Hub; utilisez des miroirs/caches (registry-cache).
Stratégie de retrait/tags immuables, réplication entre les régions.
'docker login' ne sont pas stockés dans les scripts ; utilisez les secrets CI et la fédération OIDC.

11) docker-compose vs orchestrateurs

Composez - développement local/stand d'intégration.
Прод: Kubernetes (Deployment/StatefulSet/DaemonSet, Ingress, Secrets, PVC) с containerd/CRI-O; politiques de sécurité et stratégies rollout.
Swarm est obsolète pour les grandes ventes, bon pour les clusters simples.

yaml version: "3. 9"
services:
api:
build:.
ports: ["8080:8080"]
environment: ["DB_URL=postgres://pg/DB"]
depends_on: ["pg"]
pg:
image: postgres:16-alpine volumes: ["pgdata:/var/lib/postgresql/data"]
volumes: { pgdata: {} }

12) Healthcheck, départ/stop, graceful shutdown

Utilisez 'HEALTHCHECK' avec les délais et les restrictions de 'retries'.
Graceful correct : Attrapez SIGTERM, terminez l'entrée, fermez les connexions, puis sortez.
В K8s: `preStop` hook + `terminationGracePeriodSeconds`, readiness перед liveness.

13) Meilleures pratiques par langue/piles (résumé)

Node : 'npm ci', 'NODE _ BOU = production', désactiver dev-deps dans runtime, '-heapsnapshot' off, 'uWS/GZip' pour le proxy L7.
Python : wheels, 'gunicorn --graceful-timeout', 'GTHREADS'/' UVICorn' par CPU, ne pas stocker venv à l'intérieur de la couche commune sans besoin.
Go : CGO off (si possible),' -ldflags = » -s -w «, distroless/static, 'GOMAXPROCS'par cgroups.
Java : slot JAR, '-XX : MaxRAMPercentage', CDS/Layered JAR pour cache.

14) Chaîne d'approvisionnement et politique d'images

Génère SBOM sur CI, garder à côté de l'artefact.
Scannez les images sur chaque poil ; gate sur les CVE critiques.
Signez les images (cosign), insérez policy controller (à K8s - Kyverno/Conftest/Gatekeeper).
Séparez les comptes/réseaux build et run ; mettez en cache les dépendances dans le registre privé.

15) Anti-modèles

': latest' en vente ; l'absence d'étiquettes immuables.
Assemblage « à l'intérieur de l'hôte » sans isolation ; garder des secrets dans Dockerfile.
Démarrer sous root, '--privileged', capabilities larges.
Images épaisses (> 1-2 Go), absence. dockerignore.
La logique init dans ENTRYPOINT via la forme shell → les problèmes de signaux.
Écrire des données persistantes dans la couche conteneur au lieu de volume.
Healthcheck, qui fait des demandes coûteuses à la prod-DB.

16) Chèque de mise en œuvre (0-45 jours)

0-10 jours

Normaliser Dockerfile (multi-stage, .dockerignore, LABEL, base pinned).
Activer BuildKit/buildx, les monts cache pour les gestionnaires de paquets.
Accéder aux profils non-root et « seccomp »/AppArmor/SELinux par défaut.

11-25 jours

Minimiser les images runtime (alpine/distroless), mettre de l'ordre avec les logs (rotation).
Configurer les limites de ressources, healthchecks, PID 1/tini correct.
Soulevez le registre privé/cache, connectez le scanner CVE et la génération SBOM.

26-45 jours

Entrez une signature d'image et une stratégie d'admission dans le cluster.
Organiser multi-arch (amd64/arm64) pour les bons services.
Documenter le runbook d'assemblage/version, le rapport taille/vulnérabilités/temps d'assemblage.

17) Métriques de maturité

Balises immuables et assemblages reproductibles pour ≥ 95 % des services.
Taille moyenne de l'image runtime <200-300 Mo (par pile).
Les conteneurs 100 % prod sont non root, avec capabilities limitées et read-only FS.
SBOM et balayage CVE sur chaque push ; les CVE critiques sont → bloqués.
Signature des images et policy-enforcement dans les environnements.
Temps de démarrage à froid du conteneur ≤ SLO cible (par exemple, 2-5 secondes), correctement graceful shutdown.

18) Conclusion

Conteneurisation adulte sont les normes OCI + discipline d'assemblage + sécurité par défaut + observation et politique d'approvisionnement. Utilisez multi-stage et BuildKit, réduisez au minimum les images runtime, exécutez non-root sous des profils rigoureux, fixez des balises, numérisez et signez, gardez les logs/ressources/réseau sous contrôle. Ainsi, les conteneurs deviendront la base prévisible et gérable de votre plate-forme - du développement à la production.