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

1. 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.

2. Fija imágenes por digest — usa digests @sha256:... en lugar de etiquetas para despliegues en producción para garantizar reproducibilidad.

3. 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.

4. Verifica firmas en CI/CD — siempre verifica las firmas de imágenes Chainguard con cosign antes de compilar o desplegar.

5. 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.

6. 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.

7. Ejecuta como nonroot — las imágenes Chainguard usan usuario nonroot por defecto; mantén esto en tus Dockerfiles sin cambiar a root.

8. Aplica políticas de imagen — usa Kyverno, OPA Gatekeeper o Sigstore Policy Controller para restringir registros de contenedores en tus clústeres.

9. Genera y almacena SBOMs — usa Syft o cosign para descargar SBOMs para cumplimiento y auditoría.

10. Mantén las imágenes actualizadas — Chainguard reconstruye imágenes frecuentemente; actualiza tus digests regularmente para obtener los últimos parches de seguridad.