Chainguard Images

Imágenes de contenedor mínimas con cero CVEs construidas sobre Wolfi Linux para cadenas de suministro de software seguras.

Primeros Pasos

Descargar Imágenes

Comando	Descripción
`docker pull cgr.dev/chainguard/static:latest`	Descargar imagen base estática mínima
`docker pull cgr.dev/chainguard/busybox:latest`	Descargar imagen busybox para depuración
`docker pull cgr.dev/chainguard/wolfi-base:latest`	Descargar imagen base Wolfi con shell
`docker pull cgr.dev/chainguard/python:latest`	Descargar imagen de runtime Python
`docker pull cgr.dev/chainguard/node:latest`	Descargar imagen de runtime Node.js
`docker pull cgr.dev/chainguard/go:latest`	Descargar imagen de compilación Go
`docker pull cgr.dev/chainguard/nginx:latest`	Descargar imagen del servidor web nginx
`docker pull cgr.dev/chainguard/git:latest`	Descargar imagen mínima de git
`docker pull cgr.dev/chainguard/jdk:latest`	Descargar imagen de Java JDK
`docker pull cgr.dev/chainguard/rust:latest`	Descargar imagen de compilación Rust
`docker pull cgr.dev/chainguard/redis:latest`	Descargar imagen del servidor Redis
`docker pull cgr.dev/chainguard/postgres:latest`	Descargar imagen de PostgreSQL
`docker pull cgr.dev/chainguard/curl:latest`	Descargar imagen mínima de curl

Etiquetas de Imagen

Comando	Descripción
Etiqueta `:latest`	Compilación más reciente, lista para producción
Etiqueta `:latest-dev`	Variante de desarrollo con shell y gestor de paquetes
`:latest` en imágenes `-dev`	Incluye apk, shell y herramientas de depuración
`cgr.dev/chainguard-private/IMAGE`	Registro de imágenes privado/empresarial
Fijación por digest `@sha256:abc123...`	Fijar a compilación exacta de imagen para reproducibilidad

Uso de Imágenes

Uso Básico

Comando	Descripción
`FROM cgr.dev/chainguard/static:latest`	Usar imagen estática en Dockerfile
`FROM cgr.dev/chainguard/python:latest-dev`	Usar variante dev con pip y shell
`FROM cgr.dev/chainguard/node:latest AS build`	Usar como etapa de compilación
`FROM cgr.dev/chainguard/go:latest AS builder`	Usar imagen Go para compilación
`docker run --rm cgr.dev/chainguard/wolfi-base sh`	Ejecutar shell interactivo
`docker run --rm -p 8080:8080 cgr.dev/chainguard/nginx`	Ejecutar servidor nginx
`docker run --rm cgr.dev/chainguard/python -- python -c "print('hello')"`	Ejecutar una línea de Python

Compilación Multi-Etapa en Go

# Etapa de compilación
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

# Etapa de runtime - distroless, sin shell, sin gestor de paquetes
FROM cgr.dev/chainguard/static:latest
COPY --from=builder /server /server
EXPOSE 8080
ENTRYPOINT ["/server"]

Compilación Multi-Etapa en Python

# Etapa de compilación con 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 . .

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

Compilación Multi-Etapa en Node.js

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

# Etapa de 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"]

Compilación Multi-Etapa en Java

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

# Etapa de 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"]

Descubrimiento

Operaciones de Chainctl

Comando	Descripción
`chainctl auth login`	Autenticarse con Chainguard
`chainctl auth login --headless`	Iniciar sesión en entornos headless
`chainctl auth configure-docker`	Configurar Docker para usar el registro de Chainguard
`chainctl images list`	Listar imágenes disponibles de Chainguard
`chainctl images repos list --group=GROUP_ID`	Listar repositorios de imágenes para un grupo
`chainctl images diff IMAGE1 IMAGE2`	Comparar dos versiones de imagen
`chainctl images history cgr.dev/chainguard/python`	Mostrar historial de versiones de imagen
Navegar a `images.chainguard.dev`	Catálogo web de todas las imágenes

Inspección de Imágenes

Comando	Descripción
`crane ls cgr.dev/chainguard/python`	Listar etiquetas disponibles de una imagen
`crane manifest cgr.dev/chainguard/python:latest`	Ver manifiesto de la imagen
`crane config cgr.dev/chainguard/python:latest`	Ver configuración de la imagen
`docker inspect cgr.dev/chainguard/python:latest`	Inspeccionar metadatos de la imagen
`docker history cgr.dev/chainguard/python:latest`	Ver capas de la imagen
`dive cgr.dev/chainguard/python:latest`	Explorar capas de la imagen interactivamente

Verificación

Verificación de Firmas

Comando	Descripción
`cosign verify --certificate-oidc-issuer=https://token.actions.githubusercontent.com --certificate-identity-regexp='chainguard' cgr.dev/chainguard/python`	Verificar firma de la imagen
`cosign verify-attestation --type spdx cgr.dev/chainguard/python`	Verificar atestación SBOM
`cosign verify-attestation --type vuln cgr.dev/chainguard/python`	Verificar atestación de vulnerabilidades
`cosign tree cgr.dev/chainguard/python`	Ver artefactos de la cadena de suministro
`cosign verify-attestation --type slsaprovenance cgr.dev/chainguard/python`	Verificar procedencia SLSA

Ejemplo de Verificación con Cosign

# Verificar la firma de una imagen Chainguard
cosign verify \
  --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp="chainguard" \
  cgr.dev/chainguard/python:latest

# Verificar atestación SBOM y mostrarla
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 .

# Verificar atestación de escaneo de vulnerabilidades
cosign verify-attestation \
  --type vuln \
  --certificate-oidc-issuer="https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp="chainguard" \
  cgr.dev/chainguard/python:latest

Escaneo de Vulnerabilidades

Comando	Descripción
`grype cgr.dev/chainguard/python`	Escanear imagen en busca de vulnerabilidades con Grype
`grype cgr.dev/chainguard/python --only-fixed`	Mostrar solo vulnerabilidades corregibles
`trivy image cgr.dev/chainguard/python`	Escanear con escáner Trivy
`trivy image --severity HIGH,CRITICAL cgr.dev/chainguard/python`	Escanear solo alta/crítica
`docker scout cves cgr.dev/chainguard/python`	Escanear con Docker Scout
`chainctl images vulns cgr.dev/chainguard/python`	Ver vulnerabilidades conocidas vía chainctl

Gestión de APK de Wolfi

Operaciones de Paquetes

Comando	Descripción
`apk update`	Actualizar índice de paquetes (en imágenes dev)
`apk add curl`	Instalar un paquete
`apk add --no-cache python3 py3-pip`	Instalar sin cachear índice
`apk add --virtual .build-deps gcc musl-dev`	Instalar dependencias de compilación virtuales
`apk del .build-deps`	Eliminar grupo de paquetes virtuales
`apk del curl`	Eliminar un paquete
`apk list --installed`	Listar paquetes instalados
`apk search nginx`	Buscar paquetes disponibles
`apk info python3`	Mostrar detalles del paquete
`apk info -L python3`	Listar archivos de un paquete

Construcción de Imágenes Personalizadas

Construcción de Paquetes con Melange

Comando	Descripción
`melange keygen`	Generar claves de firma para paquetes
`melange build recipe.yaml --signing-key melange.rsa`	Compilar paquete APK desde receta
`melange build recipe.yaml --arch x86_64,aarch64`	Compilar para múltiples arquitecturas
`melange bump recipe.yaml 1.2.3`	Actualizar versión en la receta

Ejemplo de Receta 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

Construcción de Imágenes con Apko

Comando	Descripción
`apko build config.yaml tag output.tar`	Compilar imagen OCI desde configuración YAML
`apko publish config.yaml tag`	Compilar y publicar imagen en registro
`apko build config.yaml tag output.tar --arch x86_64,aarch64`	Compilar imagen multi-arquitectura
`docker load < output.tar`	Cargar imagen compilada en Docker

Ejemplo de Configuración 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 y Procedencia

Artefactos de la Cadena de Suministro

Comando	Descripción
`cosign download sbom cgr.dev/chainguard/python`	Descargar SBOM de la imagen
`syft cgr.dev/chainguard/python`	Generar SBOM con Syft
`syft cgr.dev/chainguard/python -o spdx-json`	Generar SBOM en formato SPDX
`syft cgr.dev/chainguard/python -o cyclonedx-json`	Generar SBOM en formato CycloneDX
`cosign download attestation cgr.dev/chainguard/python`	Descargar todas las atestaciones
`cosign verify-attestation --type slsaprovenance cgr.dev/chainguard/python`	Verificar procedencia SLSA
`chainctl images vulns cgr.dev/chainguard/python`	Ver vulnerabilidades conocidas

Aplicación de Políticas

Política de Admisión de Kubernetes

# Sigstore Policy Controller - requerir firmas de 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

Ejemplo de Política 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 Verificación CI/CD

# GitHub Actions - verificar y escanear antes del despliegue
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

Mejores Prácticas

Usa compilaciones multi-etapa — compila en imágenes -dev (que tienen compiladores y gestores de paquetes) y copia solo el artefacto final a la imagen de runtime mínima.
Fija imágenes por digest — usa digests @sha256:... en lugar de etiquetas para despliegues en producción para garantizar reproducibilidad.
Elige la imagen base correcta — usa static para binarios compilados sin dependencias del SO, wolfi-base cuando necesites shell, e imágenes específicas del lenguaje para lenguajes interpretados.
Verifica firmas en CI/CD — siempre verifica las firmas de imágenes Chainguard con cosign antes de compilar o desplegar.
Escanea incluso imágenes con cero CVEs — ejecuta escaneos de vulnerabilidades como paso de validación; las imágenes Chainguard deberían devolver cero hallazgos, confirmando que tu pipeline usa imágenes genuinas.
Usa variantes -dev solo en etapas de compilación — nunca envíes imágenes -dev a producción; incluyen herramientas que aumentan la superficie de ataque.
Ejecuta como nonroot — las imágenes Chainguard usan usuario nonroot por defecto; mantén esto en tus Dockerfiles sin cambiar a root.
Aplica políticas de imagen — usa Kyverno, OPA Gatekeeper o Sigstore Policy Controller para restringir registros de contenedores en tus clústeres.
Genera y almacena SBOMs — usa Syft o cosign para descargar SBOMs para cumplimiento y auditoría.
Mantén las imágenes actualizadas — Chainguard reconstruye imágenes frecuentemente; actualiza tus digests regularmente para obtener los últimos parches de seguridad.