Chainguard Images

Images conteneur minimales zéro-CVE construites sur Wolfi Linux pour des chaînes d’approvisionnement logiciel sécurisées.

Démarrage

Récupération des images

Commande	Description
`docker pull cgr.dev/chainguard/static:latest`	Récupérer l’image de base statique minimale
`docker pull cgr.dev/chainguard/busybox:latest`	Récupérer l’image busybox pour le débogage
`docker pull cgr.dev/chainguard/wolfi-base:latest`	Récupérer l’image de base Wolfi avec shell
`docker pull cgr.dev/chainguard/python:latest`	Récupérer l’image runtime Python
`docker pull cgr.dev/chainguard/node:latest`	Récupérer l’image runtime Node.js
`docker pull cgr.dev/chainguard/go:latest`	Récupérer l’image de build Go
`docker pull cgr.dev/chainguard/nginx:latest`	Récupérer l’image du serveur web nginx
`docker pull cgr.dev/chainguard/git:latest`	Récupérer l’image git minimale
`docker pull cgr.dev/chainguard/jdk:latest`	Récupérer l’image Java JDK
`docker pull cgr.dev/chainguard/rust:latest`	Récupérer l’image de build Rust
`docker pull cgr.dev/chainguard/redis:latest`	Récupérer l’image du serveur Redis
`docker pull cgr.dev/chainguard/postgres:latest`	Récupérer l’image PostgreSQL
`docker pull cgr.dev/chainguard/curl:latest`	Récupérer l’image curl minimale

Tags des images

Commande	Description
Tag `:latest`	Build le plus récent, prêt pour la production
Tag `:latest-dev`	Variante de développement avec shell et gestionnaire de paquets
`:latest` sur les images `-dev`	Inclut apk, shell et outils de débogage
`cgr.dev/chainguard-private/IMAGE`	Registre d’images privées/entreprise
Épinglage par digest `@sha256:abc123...`	Épingler à un build exact pour la reproductibilité

Utilisation des images

Utilisation de base

Commande	Description
`FROM cgr.dev/chainguard/static:latest`	Utiliser l’image statique dans un Dockerfile
`FROM cgr.dev/chainguard/python:latest-dev`	Utiliser la variante dev avec pip et shell
`FROM cgr.dev/chainguard/node:latest AS build`	Utiliser comme étape de build
`FROM cgr.dev/chainguard/go:latest AS builder`	Utiliser l’image Go pour la compilation
`docker run --rm cgr.dev/chainguard/wolfi-base sh`	Exécuter un shell interactif
`docker run --rm -p 8080:8080 cgr.dev/chainguard/nginx`	Exécuter le serveur nginx
`docker run --rm cgr.dev/chainguard/python -- python -c "print('hello')"`	Exécuter un one-liner Python

Build multi-étapes Go

# Étape de build
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

# Étape runtime - distroless, pas de shell, pas de gestionnaire de paquets
FROM cgr.dev/chainguard/static:latest
COPY --from=builder /server /server
EXPOSE 8080
ENTRYPOINT ["/server"]

Build multi-étapes Python

# Étape de build avec pip disponible
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 . .

# Étape runtime - Python minimal, pas de pip, pas de shell
FROM cgr.dev/chainguard/python:latest
COPY --from=builder /install /usr/local
COPY --from=builder /app /app
WORKDIR /app
ENTRYPOINT ["python", "-m", "myapp"]

Build multi-étapes Node.js

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

# Étape runtime
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"]

Build multi-étapes Java

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

# Étape runtime
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"]

Découverte

Opérations Chainctl

Commande	Description
`chainctl auth login`	S’authentifier auprès de Chainguard
`chainctl auth login --headless`	Se connecter dans les environnements headless
`chainctl auth configure-docker`	Configurer Docker pour utiliser le registre Chainguard
`chainctl images list`	Lister les images Chainguard disponibles
`chainctl images repos list --group=GROUP_ID`	Lister les dépôts d’images pour un groupe
`chainctl images diff IMAGE1 IMAGE2`	Comparer deux versions d’image
`chainctl images history cgr.dev/chainguard/python`	Afficher l’historique des versions d’image
Naviguer sur `images.chainguard.dev`	Catalogue web de toutes les images

Inspection des images

Commande	Description
`crane ls cgr.dev/chainguard/python`	Lister les tags disponibles pour une image
`crane manifest cgr.dev/chainguard/python:latest`	Voir le manifeste de l’image
`crane config cgr.dev/chainguard/python:latest`	Voir la configuration de l’image
`docker inspect cgr.dev/chainguard/python:latest`	Inspecter les métadonnées de l’image
`docker history cgr.dev/chainguard/python:latest`	Voir les couches de l’image
`dive cgr.dev/chainguard/python:latest`	Explorer les couches de l’image interactivement

Vérification

Vérification des signatures

Commande	Description
`cosign verify --certificate-oidc-issuer=https://token.actions.githubusercontent.com --certificate-identity-regexp='chainguard' cgr.dev/chainguard/python`	Vérifier la signature de l’image
`cosign verify-attestation --type spdx cgr.dev/chainguard/python`	Vérifier l’attestation SBOM
`cosign verify-attestation --type vuln cgr.dev/chainguard/python`	Vérifier l’attestation de vulnérabilité
`cosign tree cgr.dev/chainguard/python`	Voir les artefacts de la chaîne d’approvisionnement
`cosign verify-attestation --type slsaprovenance cgr.dev/chainguard/python`	Vérifier la provenance SLSA

Exemple de vérification Cosign

# Vérifier la signature d'une image Chainguard
cosign verify \
  --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp="chainguard" \
  cgr.dev/chainguard/python:latest

# Vérifier l'attestation SBOM et l'afficher
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 .

# Vérifier l'attestation d'analyse de vulnérabilité
cosign verify-attestation \
  --type vuln \
  --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp="chainguard" \
  cgr.dev/chainguard/python:latest

Analyse de vulnérabilités

Commande	Description
`grype cgr.dev/chainguard/python`	Analyser l’image pour les vulnérabilités avec Grype
`grype cgr.dev/chainguard/python --only-fixed`	Afficher uniquement les vulnérabilités corrigibles
`trivy image cgr.dev/chainguard/python`	Analyser avec le scanner Trivy
`trivy image --severity HIGH,CRITICAL cgr.dev/chainguard/python`	Analyser pour les niveaux high/critical uniquement
`docker scout cves cgr.dev/chainguard/python`	Analyser avec Docker Scout
`chainctl images vulns cgr.dev/chainguard/python`	Voir les vulnérabilités connues via chainctl

Gestion des paquets APK Wolfi

Opérations sur les paquets

Commande	Description
`apk update`	Mettre à jour l’index des paquets (dans les images dev)
`apk add curl`	Installer un paquet
`apk add --no-cache python3 py3-pip`	Installer sans mettre en cache l’index
`apk add --virtual .build-deps gcc musl-dev`	Installer des dépendances de build virtuelles
`apk del .build-deps`	Supprimer un groupe de paquets virtuels
`apk del curl`	Supprimer un paquet
`apk list --installed`	Lister les paquets installés
`apk search nginx`	Rechercher les paquets disponibles
`apk info python3`	Afficher les détails d’un paquet
`apk info -L python3`	Lister les fichiers d’un paquet

Construction d’images personnalisées

Construction de paquets Melange

Commande	Description
`melange keygen`	Générer des clés de signature pour les paquets
`melange build recipe.yaml --signing-key melange.rsa`	Construire un paquet APK à partir d’une recette
`melange build recipe.yaml --arch x86_64,aarch64`	Construire pour plusieurs architectures
`melange bump recipe.yaml 1.2.3`	Mettre à jour la version dans la recette

Exemple de recette Melange

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

Construction d’images Apko

Commande	Description
`apko build config.yaml tag output.tar`	Construire une image OCI à partir d’une config YAML
`apko publish config.yaml tag`	Construire et pousser l’image vers un registre
`apko build config.yaml tag output.tar --arch x86_64,aarch64`	Construire une image multi-architectures
`docker load < output.tar`	Charger l’image construite dans Docker

Exemple de configuration Apko

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 et provenance

Artefacts de la chaîne d’approvisionnement

Commande	Description
`cosign download sbom cgr.dev/chainguard/python`	Télécharger le SBOM de l’image
`syft cgr.dev/chainguard/python`	Générer un SBOM avec Syft
`syft cgr.dev/chainguard/python -o spdx-json`	Générer un SBOM au format SPDX
`syft cgr.dev/chainguard/python -o cyclonedx-json`	Générer un SBOM au format CycloneDX
`cosign download attestation cgr.dev/chainguard/python`	Télécharger toutes les attestations
`cosign verify-attestation --type slsaprovenance cgr.dev/chainguard/python`	Vérifier la provenance SLSA
`chainctl images vulns cgr.dev/chainguard/python`	Voir les vulnérabilités connues

Application des politiques

Politique d’admission Kubernetes

# Sigstore Policy Controller - exiger les signatures Chainguard
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

Exemple de politique Kyverno

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/*"

Pipeline de vérification CI/CD

# GitHub Actions - vérifier et analyser avant le déploiement
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

Bonnes pratiques

Utiliser les builds multi-étapes — compilez dans les images -dev (qui ont les compilateurs et gestionnaires de paquets) et copiez uniquement l’artefact final dans l’image runtime minimale.
Épingler les images par digest — utilisez les digests @sha256:... au lieu des tags pour les déploiements en production afin de garantir la reproductibilité.
Choisir la bonne image de base — utilisez static pour les binaires compilés sans dépendances OS, wolfi-base quand vous avez besoin d’un shell, et les images spécifiques au langage pour les langages interprétés.
Vérifier les signatures en CI/CD — vérifiez toujours les signatures des images Chainguard avec cosign avant de compiler ou déployer.
Analyser même les images zéro-CVE — exécutez des analyses de vulnérabilités comme étape de validation ; les images Chainguard devraient retourner zéro résultat, confirmant que votre pipeline utilise des images authentiques.
Utiliser les variantes -dev uniquement dans les étapes de build — n’envoyez jamais les images -dev en production ; elles incluent des outils qui augmentent la surface d’attaque.
Exécuter en tant que nonroot — les images Chainguard utilisent par défaut l’utilisateur nonroot ; maintenez cela dans vos Dockerfiles en ne basculant pas vers root.
Appliquer des politiques d’images — utilisez Kyverno, OPA Gatekeeper ou Sigstore Policy Controller pour restreindre les registres de conteneurs dans vos clusters.
Générer et stocker les SBOMs — utilisez Syft ou cosign pour télécharger les SBOMs pour la conformité et les pistes d’audit.
Garder les images à jour — Chainguard reconstruit les images fréquemment ; mettez à jour vos digests régulièrement pour bénéficier des derniers correctifs de sécurité.