Containerizare: Docker și OCI

Containerizare: Docker și OCI

1) Concepte și standarde OCI de bază

Specificaţii imagine OCI - format imagine (manifest, config, straturi, index pentru multi-arch).
Specificații OCI Runtime - cum să rulați un container (pachet, "config. json "); implementare: runcul, precum și gVisor, Kata Containers.
Specificații de distribuție OCI - interacțiunea cu registrele (push/pull, autorizare).

Docker = UX și ecosistemul din jurul OCI: Dockerfile/BuildKit/CLI/Compose/Hub. În Kubernetes, Docker Engine este înlocuit de containerd/CRI-O, dar formatul imaginii este același.

2) Apariții: straturi, etichete, metadate

Образ = слои (sistem de fișiere stratificat) + config (entrypoint/cmd/env/labels) + manifest.
Etichete: nu utilizați „: cele mai recente” în prod; pinning ': 1. 21. 3 ', git-SHA sau data + SHA.
ETICHETĂ: proprietar, contact, vcs-url, org. opencontainere. (titlu, descriere, revizuire, sursă).
Multi-arch: Manifestul index oferă opțiunea corectă pentru „amd64/arm64”.

3) Build: Dockerfile, BuildKit, multi-etapă

3. 1 Principii

Minimizați straturile, fixați versiunile, curățați cache-urile managerului de pachete.
Mai întâi copiați fișierele manifest/blocare, apoi "RUN install deps' - îmbunătățește memoria cache.
.dockerignore este necesar (excludeți „.git”, artefacte, secrete).
Sunt preferate exemple de baze distroless/alpine/minime.

3. 2 chips-uri BuildKit

Paralel construiește, secrete în ansamblu („--secret”), suporturi cache, buildx pentru multi-arch.

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

3. 3 Exemple în mai multe etape

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) Imagini minime, PID 1 și semnale

Distroless - suprafață de atac mai mică, fără coajă/manager de pachete.

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

"HEALTHCHECK 'este rezonabil (frecvență/timeout, nici o sarcină inutilă).

5) Securitatea containerelor

5. 1 Politici și întărire

Non-root (USER), fără rădăcini Docker/containere.
Capacități: eliminați inutile ('--cap-drop = ALL --cap-add = NET _ BIND _ SERVICE' etc.).
seccomp/AppArmor/SELinux: Activați profilurile implicite sau stricte.
Read-only FS + 'tmpfs' для '/tmp', nu-new-privilegii.
Secrete: nu în imagini; montați de la managerul secretelor K8s/vault/docker.

5. 2 Lanțul de aprovizionare

SBOM (CycloneDX/SPDX) și scanare (Trivy/Grype).
Semnătură (cosign, sigstore) și politica de tragere (verifică).
Repetiții pentru actualizări: imaginile de bază cu patch-uri CVE sunt reconstruite în mod regulat.

6) drivere de stocare și fișiere

Implicit este suprapunere2 (rapid și stabil). În medii fără rădăcini, de multe ori siguranțe-suprapuneri.
volume pentru date și cache-uri, bind-mount pentru dezvoltare.
Nu scrieți la „/” - utilizați calea de date („/date ”), stare separată de imagine.

7) Rețea și DNS

Rețele Docker: bridge (default), host (minim deasupra capului, conflicte portuare), none, macvlan/ipvlan (integrare L2/L3).
Docker DNS resolver ia/demon de la gazdă. json; pentru prod, configurați cache-ul local resolver.
În K8s, rețeaua este gestionată de CNI (Calico/Cilium/Flannel). Pentru sidecar/plasă - interceptări (iptables).

8) Resurse și QoS (cgroups v2)

Restricții: '--cpus', '--memory', '--pids-limit', '--cpuset-cpus'.
Setați cereri/limite (în K8s) → afectează programarea și QoS.
Monitor OOMKilled, throttling, vârfuri de latență din cauza GC/IO.

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

9) Jurnalele și observabilitatea

Drivere jurnal: 'json-file' (cu rotaţie), 'journal', 'gelf', 'awslogs',' syslog '.

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

Metrici: Docker Engine API, cAdvisor, nod exportatori; urmărirea prin intermediul unui agent într-un container sau ataș.

10) Registre și autentificare

Registre private: ECR/GCR/ACR/Harbor/GitHub Container Registry.
Limite de tarif Docker Hub; utilizați oglinzi/cache-uri (registry-cache).
Politica de păstrare/etichete imuabile, replicarea între regiuni.
„autentificare” nu este stocată în scripturi; utilizați secretele CI și federația OIDC.

11) docker-compune vs orchestratori

Compune - standuri de dezvoltare/integrare locală.
Прод: Kubernetes (Implementare/StatefulSet/DaemonSet, Ingress, Secrets, PVC) с containerd/CRI-O; politici de securitate și strategii de extindere.
Roiul este depășit pentru vânzări mari, potrivite pentru clustere simple.

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, start/stop, închidere grațioasă

Utilizați „HEALTHCHECK” cu timeout-uri și restricții de „reîncărcare”.
Corect grațios: prinde SIGTERM, termina intrare, închideți conexiunile, apoi ieșiți.
В K8s: 'preStop' cârlig + 'terminareGracePeriodSeconds', pregătire перед viață.

13) Cele mai bune practici de limbă/stivă (rezumat)

Nod: 'npm ci', 'NODE _ ENV = producție', dezactivați dev-deps în timpul rulării, '--heapsnapshot' off, 'uWS/GZip' în spatele proxy L7.
Python: roți, 'gunicorn --grațios-timeout', 'GTHREADS'/' UVICorn' de CPU, nu stocați inutil venv în interiorul unui strat comun.
Du-te: CGO off (dacă este posibil),' -ldsteaguri =” -s -w „', distroless/static, 'GOMAXPROCS' de cgroups.
Java: JAR stratificat, '-XX: MaxRAMPercentage', CDS/JAR stratificat pentru memoria cache.

14) Politica lanțului de aprovizionare și a imaginii

Generați SBOM pe CI, salvați lângă artefact.
Scanați imagini pe fiecare pooch; poarta către CVE-urile critice.
Semnați imagini (cosign), activați controlerul de politici (în K8s - Kyverno/Conftest/Gatekeeper).
Construiți și rulați conturi/rețele separate; Dependențe cache în registrul privat.

15) Anti-modele

„: cele mai recente” în prod; lipsa etichetelor imuabile.
Adunarea „în interiorul gazdei de producție” fără izolare; stocarea secretelor în Dockerfile.
Rularea ca rădăcină, „--privilegiat”, capacități largi.
Imagini groase (> 1-2 GB), niciuna. docherignore.
Logica init în ENTRYPOINT prin forma shell → probleme de semnal.
Scrieţi date persistente în stratul containerului în loc de volum.
Healthcheck, care face cereri scumpe la prod-DB.

16) Lista de verificare a implementării (0-45 zile)

0-10 zile

Standardizați Dockerfile (multi-stage, .dockerignore, LABEL, bază fixată).
Includeți BuildKit/buildx, suporturi cache pentru managerii de pachete.
Treceți la profilurile implicite non-root și 'seccomp '/AppArmor/SELinux.

11-25 zile

Minimizați imaginile de rulare (alpine/distroless), puneți lucrurile în ordine cu jurnalele (rotație).
Configurați limite de resurse, verificări de sănătate, corectați PID 1/tini.
Ridicați registrul privat/memoria cache, conectați scanerul CVE și generarea SBOM.

26-45 zile

Introduceți semnătura imaginii și politica de admitere a clusterului.
Organizați multi-arch (amd64/arm64) pentru serviciile necesare.
Document build/release runbook, build size/vulnerability/time report.

17) Valorile maturității

Etichete imuabile și ansambluri reproductibile pentru ≥ 95% din servicii.
Dimensiunea medie a imaginii runtime este <200-300 MB (stivuite).
100% din containerele prod sunt non-rădăcină, cu capacități limitate și FS read-only.
Scanare SBOM și CVE pe împingere; CVE-urile critice sunt → blocate.
Semnarea imaginilor și aplicarea politicilor în medii.
Ora de pornire la rece a containerului ≤ SLO țintă (de ex. 2-5 secunde), închiderea corectă grațioasă.

18) Concluzie

Containerizarea adulților este standardele OCI + construi disciplina + securitate implicită + observabilitate și politica de livrare. Utilizați multi-stage și BuildKit, minimizați imaginile de rulare, rulați non-root sub profile stricte, fixați tag-uri, scanați și semnați, țineți jurnalele/resursele/rețeaua sub control. Astfel, containerele vor deveni fundamentul previzibil și ușor de gestionat al platformei dvs. - de la dezvoltare la producție.