Chainguard Images

Minimale Zero-CVE-Container-Images basierend auf Wolfi Linux für sichere Software-Lieferketten.

Erste Schritte

Images abrufen

Befehl	Beschreibung
`docker pull cgr.dev/chainguard/static:latest`	Minimales statisches Base-Image abrufen
`docker pull cgr.dev/chainguard/busybox:latest`	Busybox-Image zum Debuggen abrufen
`docker pull cgr.dev/chainguard/wolfi-base:latest`	Wolfi-Base-Image mit Shell abrufen
`docker pull cgr.dev/chainguard/python:latest`	Python-Runtime-Image abrufen
`docker pull cgr.dev/chainguard/node:latest`	Node.js-Runtime-Image abrufen
`docker pull cgr.dev/chainguard/go:latest`	Go-Build-Image abrufen
`docker pull cgr.dev/chainguard/nginx:latest`	nginx-Webserver-Image abrufen
`docker pull cgr.dev/chainguard/git:latest`	Minimales Git-Image abrufen
`docker pull cgr.dev/chainguard/jdk:latest`	Java-JDK-Image abrufen
`docker pull cgr.dev/chainguard/rust:latest`	Rust-Build-Image abrufen
`docker pull cgr.dev/chainguard/redis:latest`	Redis-Server-Image abrufen
`docker pull cgr.dev/chainguard/postgres:latest`	PostgreSQL-Image abrufen
`docker pull cgr.dev/chainguard/curl:latest`	Minimales curl-Image abrufen

Image-Tags

Befehl	Beschreibung
`:latest`-Tag	Neuester Build, produktionsbereit
`:latest-dev`-Tag	Entwicklungsvariante mit Shell und Paketmanager
`:latest` auf `-dev`-Images	Enthält apk, Shell und Debugging-Tools
`cgr.dev/chainguard-private/IMAGE`	Private/Enterprise-Image-Registry
Digest-Pinning `@sha256:abc123...`	Auf exakten Image-Build für Reproduzierbarkeit festpinnen

Image-Verwendung

Grundlegende Verwendung

Befehl	Beschreibung
`FROM cgr.dev/chainguard/static:latest`	Statisches Image im Dockerfile verwenden
`FROM cgr.dev/chainguard/python:latest-dev`	Dev-Variante mit pip und Shell verwenden
`FROM cgr.dev/chainguard/node:latest AS build`	Als Build-Stage verwenden
`FROM cgr.dev/chainguard/go:latest AS builder`	Go-Image für Kompilierung verwenden
`docker run --rm cgr.dev/chainguard/wolfi-base sh`	Interaktive Shell ausführen
`docker run --rm -p 8080:8080 cgr.dev/chainguard/nginx`	nginx-Server ausführen
`docker run --rm cgr.dev/chainguard/python -- python -c "print('hello')"`	Python-Einzeiler ausführen

Go Multi-Stage Build

# Build-Phase
FROM cgr.dev/chainguard/go:latest AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /server ./cmd/server

# Laufzeit-Phase - distroless, keine Shell, kein Paketmanager
FROM cgr.dev/chainguard/static:latest
COPY --from=builder /server /server
EXPOSE 8080
ENTRYPOINT ["/server"]

Python Multi-Stage Build

# Build-Phase mit verfügbarem pip
FROM cgr.dev/chainguard/python:latest-dev AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
COPY . .

# Laufzeit-Phase - minimales Python, kein pip, keine Shell
FROM cgr.dev/chainguard/python:latest
COPY --from=builder /install /usr/local
COPY --from=builder /app /app
WORKDIR /app
ENTRYPOINT ["python", "-m", "myapp"]

Node.js Multi-Stage Build

# Build-Phase
FROM cgr.dev/chainguard/node:latest-dev AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

# Laufzeit-Phase
FROM cgr.dev/chainguard/node:latest
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
EXPOSE 3000
ENTRYPOINT ["node", "dist/index.js"]

Java Multi-Stage Build

# Build-Phase
FROM cgr.dev/chainguard/jdk:latest-dev AS builder
WORKDIR /app
COPY . .
RUN ./gradlew build --no-daemon -x test

# Laufzeit-Phase
FROM cgr.dev/chainguard/jre:latest
COPY --from=builder /app/build/libs/app.jar /app/app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

Discovery

Chainctl-Operationen

Befehl	Beschreibung
`chainctl auth login`	Bei Chainguard authentifizieren
`chainctl auth login --headless`	In Headless-Umgebungen anmelden
`chainctl auth configure-docker`	Docker für Chainguard-Registry konfigurieren
`chainctl images list`	Verfügbare Chainguard-Images auflisten
`chainctl images repos list --group=GROUP_ID`	Image-Repos für eine Gruppe auflisten
`chainctl images diff IMAGE1 IMAGE2`	Zwei Image-Versionen vergleichen
`chainctl images history cgr.dev/chainguard/python`	Image-Versionsverlauf anzeigen
`images.chainguard.dev` durchsuchen	Web-Katalog aller Images

Image-Inspektion

Befehl	Beschreibung
`crane ls cgr.dev/chainguard/python`	Verfügbare Tags für ein Image auflisten
`crane manifest cgr.dev/chainguard/python:latest`	Image-Manifest anzeigen
`crane config cgr.dev/chainguard/python:latest`	Image-Konfiguration anzeigen
`docker inspect cgr.dev/chainguard/python:latest`	Image-Metadaten inspizieren
`docker history cgr.dev/chainguard/python:latest`	Image-Layer anzeigen
`dive cgr.dev/chainguard/python:latest`	Image-Layer interaktiv erkunden

Verifizierung

Signaturverifizierung

Befehl	Beschreibung
`cosign verify --certificate-oidc-issuer=https://token.actions.githubusercontent.com --certificate-identity-regexp='chainguard' cgr.dev/chainguard/python`	Image-Signatur verifizieren
`cosign verify-attestation --type spdx cgr.dev/chainguard/python`	SBOM-Attestation verifizieren
`cosign verify-attestation --type vuln cgr.dev/chainguard/python`	Vulnerability-Attestation verifizieren
`cosign tree cgr.dev/chainguard/python`	Supply-Chain-Artefakte anzeigen
`cosign verify-attestation --type slsaprovenance cgr.dev/chainguard/python`	SLSA-Provenance verifizieren

Cosign-Verifizierungsbeispiel

# Signatur eines Chainguard-Images verifizieren
cosign verify \
  --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp="chainguard" \
  cgr.dev/chainguard/python:latest

# SBOM-Attestation verifizieren und ausgeben
cosign verify-attestation \
  --type spdx \
  --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp="chainguard" \
  cgr.dev/chainguard/python:latest | jq -r '.payload' | base64 -d | jq .

# Vulnerability-Scan-Attestation verifizieren
cosign verify-attestation \
  --type vuln \
  --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp="chainguard" \
  cgr.dev/chainguard/python:latest

Schwachstellenscanning

Befehl	Beschreibung
`grype cgr.dev/chainguard/python`	Image auf Schwachstellen mit Grype scannen
`grype cgr.dev/chainguard/python --only-fixed`	Nur behebbare Schwachstellen anzeigen
`trivy image cgr.dev/chainguard/python`	Mit Trivy-Scanner scannen
`trivy image --severity HIGH,CRITICAL cgr.dev/chainguard/python`	Nur hohe/kritische Schwachstellen scannen
`docker scout cves cgr.dev/chainguard/python`	Mit Docker Scout scannen
`chainctl images vulns cgr.dev/chainguard/python`	Bekannte Schwachstellen über chainctl anzeigen

Wolfi APK-Verwaltung

Paketoperationen

Befehl	Beschreibung
`apk update`	Paketindex aktualisieren (in Dev-Images)
`apk add curl`	Paket installieren
`apk add --no-cache python3 py3-pip`	Ohne Cache-Index installieren
`apk add --virtual .build-deps gcc musl-dev`	Virtuelle Build-Abhängigkeiten installieren
`apk del .build-deps`	Virtuelle Paketgruppe entfernen
`apk del curl`	Paket entfernen
`apk list --installed`	Installierte Pakete auflisten
`apk search nginx`	Verfügbare Pakete suchen
`apk info python3`	Paketdetails anzeigen
`apk info -L python3`	Dateien in einem Paket auflisten

Benutzerdefinierte Images erstellen

Melange-Paketbau

Befehl	Beschreibung
`melange keygen`	Signaturschlüssel für Pakete generieren
`melange build recipe.yaml --signing-key melange.rsa`	APK-Paket aus Rezept bauen
`melange build recipe.yaml --arch x86_64,aarch64`	Für mehrere Architekturen bauen
`melange bump recipe.yaml 1.2.3`	Version im Rezept aktualisieren

Melange-Rezept-Beispiel

package:
  name: myapp
  version: 1.0.0
  epoch: 0
  description: My custom application
  copyright:
    - license: Apache-2.0

environment:
  contents:
    packages:
      - build-base
      - go
      - ca-certificates-bundle

pipeline:
  - uses: git-checkout
    with:
      repository: https://github.com/org/myapp
      tag: v${{package.version}}

  - uses: go/build
    with:
      packages: ./cmd/myapp
      output: myapp
      ldflags: -s -w

  - uses: strip

Apko-Image-Bau

Befehl	Beschreibung
`apko build config.yaml tag output.tar`	OCI-Image aus YAML-Konfiguration bauen
`apko publish config.yaml tag`	Image bauen und in Registry pushen
`apko build config.yaml tag output.tar --arch x86_64,aarch64`	Multi-Arch-Image bauen
`docker load < output.tar`	Gebautes Image in Docker laden

Apko-Konfigurations-Beispiel

contents:
  packages:
    - ca-certificates-bundle
    - wolfi-baselayout
    - myapp
  repositories:
    - https://packages.wolfi.dev/os
    - /path/to/local/packages

accounts:
  groups:
    - groupname: nonroot
      gid: 65532
  users:
    - username: nonroot
      uid: 65532
      gid: 65532
  run-as: 65532

entrypoint:
  command: /usr/bin/myapp

archs:
  - x86_64
  - aarch64

environment:
  APP_ENV: production
  PORT: "8080"

SBOM & Provenance

Supply-Chain-Artefakte

Befehl	Beschreibung
`cosign download sbom cgr.dev/chainguard/python`	Image-SBOM herunterladen
`syft cgr.dev/chainguard/python`	SBOM mit Syft generieren
`syft cgr.dev/chainguard/python -o spdx-json`	SPDX-SBOM generieren
`syft cgr.dev/chainguard/python -o cyclonedx-json`	CycloneDX-SBOM generieren
`cosign download attestation cgr.dev/chainguard/python`	Alle Attestations herunterladen
`cosign verify-attestation --type slsaprovenance cgr.dev/chainguard/python`	SLSA-Provenance verifizieren
`chainctl images vulns cgr.dev/chainguard/python`	Bekannte Schwachstellen anzeigen

Richtliniendurchsetzung

Kubernetes-Admission-Policy

# Sigstore Policy Controller - Chainguard-Signaturen erfordern
apiVersion: policy.sigstore.dev/v1beta1
kind: ClusterImagePolicy
metadata:
  name: require-chainguard-signatures
spec:
  images:
    - glob: "cgr.dev/chainguard/**"
    - glob: "cgr.dev/chainguard-private/**"
  authorities:
    - keyless:
        url: https://fulcio.sigstore.dev
        identities:
          - issuerRegExp: ".*"
            subjectRegExp: ".*chainguard.*"
        ctlog:
          url: https://rekor.sigstore.dev

Kyverno-Richtlinien-Beispiel

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: require-chainguard-images
spec:
  validationFailureAction: Enforce
  background: true
  rules:
    - name: check-image-registry
      match:
        any:
          - resources:
              kinds:
                - Pod
      validate:
        message: "Only Chainguard images from cgr.dev are allowed."
        pattern:
          spec:
            containers:
              - image: "cgr.dev/chainguard/*"
            initContainers:
              - image: "cgr.dev/chainguard/*"

CI/CD-Verifizierungs-Pipeline

# GitHub Actions - vor Deployment verifizieren und scannen
name: Image Verification
on:
  push:
    branches: [main]

jobs:
  verify:
    runs-on: ubuntu-latest
    steps:
      - name: Install cosign
        uses: sigstore/cosign-installer@v3

      - name: Verify image signature
        run: |
          cosign verify \
            --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
            --certificate-identity-regexp="chainguard" \
            cgr.dev/chainguard/python:latest

      - name: Scan for vulnerabilities
        uses: anchore/grype-action@v0
        with:
          image: cgr.dev/chainguard/python:latest
          fail-on: high

Best Practices

Multi-Stage-Builds verwenden — In -dev-Images bauen (die Compiler und Paketmanager haben) und nur das finale Artefakt in das minimale Laufzeit-Image kopieren.
Images per Digest festpinnen — @sha256:...-Digests statt Tags für Produktions-Deployments verwenden, um Reproduzierbarkeit zu garantieren.
Das richtige Base-Image wählen — static für kompilierte Binaries ohne OS-Abhängigkeiten, wolfi-base wenn eine Shell benötigt wird, und sprachspezifische Images für interpretierte Sprachen verwenden.
Signaturen in CI/CD verifizieren — Chainguard-Image-Signaturen vor dem Bauen oder Deployen immer mit cosign verifizieren.
Auch Zero-CVE-Images scannen — Schwachstellenscans als Validierungsschritt durchführen; Chainguard-Images sollten null Ergebnisse liefern, was bestätigt, dass die Pipeline echte Images verwendet.
-dev-Varianten nur in Build-Phasen verwenden — Niemals -dev-Images in Produktion ausliefern; sie enthalten Tools, die die Angriffsfläche vergrößern.
Als nonroot ausführen — Chainguard-Images verwenden standardmäßig den nonroot-Benutzer; dies in Dockerfiles beibehalten, indem nicht zu root gewechselt wird.
Image-Richtlinien durchsetzen — Kyverno, OPA Gatekeeper oder Sigstore Policy Controller verwenden, um Container-Registries in Clustern einzuschränken.
SBOMs generieren und speichern — Syft oder cosign verwenden, um SBOMs für Compliance und Audit-Trails herunterzuladen.
Images aktuell halten — Chainguard baut Images häufig neu; Digests regelmäßig aktualisieren, um die neuesten Sicherheitspatches zu erhalten.