Limpia Docker y recupera gigas con prune

Contenido del curso

Optimización Avanzada en Docker

Buenas Prácticas en Docker

Instalación y Configuración en Entornos Multiplataforma

Redes Avanzadas y Balanceo de Carga

Automatización de CI/CD

Orquestación

Develop

34
Dev containers en VS Code con Docker
09:54 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:22

Limpia Docker y recupera gigas con prune

Curso de Docker Avanzado

Clase 13 de 34

Clase 13 / 34

Recursos

Acumular imágenes, contenedores y volúmenes sin uso en Docker es como dejar archivos temporales en tu navegador: ocupan espacio que probablemente nunca vas a recuperar. Con el comando docker prune puedes limpiar todo eso en segundos y recuperar gigas reales de tu disco duro, algo clave si trabajas con múltiples proyectos o imágenes pesadas.

La idea es sencilla: automatizar la limpieza dentro de un script de batch para ejecutarlo de forma periódica y mantener tu instancia de Docker ligera.

¿Qué hace el comando docker prune y por qué deberías usarlo?

Cada vez que creas imágenes, despliegas contenedores o montas volúmenes, Docker guarda artefactos temporales. Muchos quedan huérfanos cuando eliminas la imagen original o detienes un contenedor sin borrarlo. El comando prune se encarga de barrer todo eso de un solo golpe.

¿Qué es docker prune? Es un comando que elimina recursos no utilizados de Docker: imágenes sin tag, contenedores detenidos, volúmenes huérfanos, redes inactivas y caché de construcción. Lo encuentras explicado desde el inicio del video [0:43].

La analogía es directa: tu navegador guarda caché para acelerar tus visitas, pero si nunca lo limpias, se llena. Docker funciona igual.

¿Cómo crear un script de batch para automatizar la limpieza?

En lugar de ejecutar comando por comando, lo práctico es agrupar todo en un archivo .sh. En la clase se crea una carpeta llamada prune dentro de Visual Studio y dentro un archivo borra-todo.sh [2:10].

El script combina cinco comandos que cubren todos los frentes de limpieza:

docker image prune -a: elimina imágenes sin tag o sin contenedor asociado. La bandera -a significa all [2:32].
docker container prune: borra contenedores detenidos o pausados que olvidaste eliminar [2:55].
docker volume prune: limpia volúmenes que quedaron flotando tras cerrar sus imágenes [3:10].
docker system prune: hace lo mismo que los tres anteriores en un solo comando, además de borrar redes no usadas [3:30].
Limpieza del caché de construcción de imágenes, útil cuando reconstruyes seguido [3:50].

Es redundante incluir los cinco, pero garantiza que nada quede atrás.

¿Con qué frecuencia conviene ejecutar el script?

Depende de tu ritmo de trabajo. Si construyes imágenes a diario, una vez por semana es razonable. Equipos como el de Microsoft mencionado en la clase usan este tipo de script de forma rutinaria para mantener limpias sus instancias locales [5:55].

¿Qué resultado real obtienes al ejecutar docker prune?

Al correr el script desde la terminal con bash borra-todo.sh, Docker pide confirmación en cada paso con una Y de yes. Cada bloque te dice exactamente qué va a borrar antes de hacerlo, así que tienes control total.

En la demostración los resultados fueron concretos:

Imágenes sin contenedor asociado eliminadas, recuperando 54 kilobytes iniciales.
Contenedores detenidos borrados por completo.
Volúmenes locales anónimos no utilizados eliminados.
En el paso de system prune, se recuperaron 4 GB de espacio en disco [5:00].
Caché de imágenes limpio, en este caso con 0 bytes porque ya estaba vacío.

¿Cuánto espacio puedo recuperar con docker prune? Depende de cuántas imágenes y volúmenes tengas acumulados. En el ejemplo de la clase se liberaron 4 GB de un solo tirón, pero en máquinas con meses de trabajo sin limpieza es común recuperar mucho más.

Después de ejecutarlo, al volver a Docker Desktop, la sección de Containers queda vacía y solo permanecen las imágenes que aún tienen un contenedor asociado activo. Todo lo demás desaparece.

¿Qué conceptos clave debes dominar antes de hacer prune?

Para aprovechar el comando sin riesgos, conviene tener claros algunos términos que aparecen en el flujo:

Imagen sin tag: una imagen que perdió su etiqueta identificadora, normalmente porque la reconstruiste con el mismo nombre.
Contenedor detenido: un contenedor que ya no está corriendo pero sigue ocupando espacio en el listado.
Volumen huérfano: almacenamiento persistente que sobrevivió a la eliminación de su contenedor.
Caché de build: capas intermedias que Docker guarda para acelerar futuras construcciones de imágenes.
Script de batch: archivo ejecutable que agrupa varios comandos para correrlos en secuencia.

Entender estos elementos te permite decidir qué tan agresiva quieres que sea tu limpieza.

¿Ya tienes tu propio script de mantenimiento para Docker? Cuéntame cómo lo configuraste y qué tan seguido lo corres.

Jose Guerrero

Hace 4 meses•editado

Les comparto un script en Bash para limpiar Docker de forma más segura y visual.

Por defecto corre en modo `dry-run`, así que no borra nada: primero muestra el uso de disco de Docker y el comando que ejecutaría. Para limpiar de verdad se usa `--apply`.

Uso:

chmod +x docker-prune.sh
./docker-prune.sh
./docker-prune.sh --apply

docker-prune.sh:

#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

DRY_RUN=1
PRUNE_ALL=0
PRUNE_VOLUMES=0
VERBOSE=0
USE_COLOR=1

if [[ ! -t 1 || -n "${NO_COLOR:-}" ]]; then
  USE_COLOR=0
fi

if [[ "$USE_COLOR" -eq 1 ]] && command -v tput >/dev/null 2>&1; then
  BOLD="$(tput bold 2>/dev/null || true)"
  DIM="$(tput dim 2>/dev/null || true)"
  RESET="$(tput sgr0 2>/dev/null || true)"
  RED="$(tput setaf 1 2>/dev/null || true)"
  GREEN="$(tput setaf 2 2>/dev/null || true)"
  YELLOW="$(tput setaf 3 2>/dev/null || true)"
  BLUE="$(tput setaf 4 2>/dev/null || true)"
  MAGENTA="$(tput setaf 5 2>/dev/null || true)"
  CYAN="$(tput setaf 6 2>/dev/null || true)"
else
  BOLD=''
  DIM=''
  RESET=''
  RED=''
  GREEN=''
  YELLOW=''
  BLUE=''
  MAGENTA=''
  CYAN=''
fi

paint() {
  local color="$1"
  local text="$2"
  printf '%s%s%s' "$color" "$text" "$RESET"
}

divider() {
  printf '%s\n' "${DIM}------------------------------------------------------------${RESET}"
}

banner() {
  divider
  printf '%s %s\n' "$(paint "$BOLD$CYAN" "docker-prune")" "$(paint "$DIM" "Docker cleanup assistant")"
  divider
}

section() {
  printf '\n%s %s\n' "$(paint "$MAGENTA" "==>")" "$(paint "$BOLD" "$*")"
}

meta() {
  local label="$1"
  local value="$2"
  printf '  %s %-12s %s\n' "$(paint "$BLUE" "::")" "$label" "$value"
}

status_line() {
  local color="$1"
  local status="$2"
  local text="$3"
  printf '  %s %-12s %s\n' "$(paint "$color" "->")" "$(paint "$color" "$status")" "$text"
}

die() {
  printf '%s %s\n' "$(paint "$RED" "Error:")" "$*" >&2
  exit 1
}

is_number() {
  case "${1:-}" in
    ''|*[!0-9]*) return 1 ;;
    *) return 0 ;;
  esac
}

command_exists() {
  command -v "$1" >/dev/null 2>&1
}

usage() {
  cat <<'EOF'
docker-prune - Safe Docker cleanup helper

Usage:
  docker-prune [options]

Default mode is dry-run. It only shows Docker disk usage and the command it would run.

Options:
  --apply        Actually run Docker prune
  --dry-run      Show what would happen (default)
  --all          Remove all unused images, not only dangling images
  --volumes      Also remove anonymous unused volumes
  --verbose      Show detailed Docker disk usage
  --no-color     Disable colored output
  -h, --help     Show this help

Examples:
  docker-prune
  docker-prune --apply
  docker-prune --apply --all
  docker-prune --apply --all --volumes
EOF
}

parse_args() {
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --apply) DRY_RUN=0; shift ;;
      --dry-run) DRY_RUN=1; shift ;;
      --all) PRUNE_ALL=1; shift ;;
      --volumes) PRUNE_VOLUMES=1; shift ;;
      --verbose) VERBOSE=1; shift ;;
      --no-color)
        BOLD=''; DIM=''; RESET=''; RED=''; GREEN=''; YELLOW=''; BLUE=''; MAGENTA=''; CYAN=''
        shift
        ;;
      -h|--help) usage; exit 0 ;;
      *) die "unknown option: $1" ;;
    esac
  done
}

docker_available() {
  command_exists docker || die "Docker CLI is not installed"
  docker info >/dev/null 2>&1 || die "Docker is not running or is not reachable"
}

build_prune_command() {
  PRUNE_CMD=(docker system prune -f)

  if [[ "$PRUNE_ALL" -eq 1 ]]; then
    PRUNE_CMD+=(-a)
  fi

  if [[ "$PRUNE_VOLUMES" -eq 1 ]]; then
    PRUNE_CMD+=(--volumes)
  fi
}

print_command() {
  printf '%q ' "${PRUNE_CMD[@]}"
  printf '\n'
}

show_disk_usage() {
  section "Docker Disk Usage"
  if [[ "$VERBOSE" -eq 1 ]]; then
    docker system df -v
  else
    docker system df
  fi
}

main() {
  parse_args "$@"
  banner

  docker_available
  build_prune_command

  meta "mode" "$([[ "$DRY_RUN" -eq 1 ]] && paint "$YELLOW" "dry-run" || paint "$GREEN" "apply")"
  meta "all" "$PRUNE_ALL"
  meta "volumes" "$PRUNE_VOLUMES"

  show_disk_usage

  section "Prune"
  if [[ "$DRY_RUN" -eq 1 ]]; then
    status_line "$YELLOW" "would run" "$(print_command)"
    status_line "$CYAN" "next" "run: docker-prune --apply"
  else
    status_line "$CYAN" "run" "$(print_command)"
    "${PRUNE_CMD[@]}"
    section "After"
    docker system df
    section "Done"
    status_line "$GREEN" "done" "Docker prune complete"
  fi

  divider
}

main "$@"

Optimización Avanzada en Docker

Optimización avanzada de Docker para cloud native

Docker productivo vs comandos básicos

Multi-stage builds en Docker con ASP.NET

Cómo escanear vulnerabilidades en imágenes Docker

Imágenes distroless: de 840 MB a 52 MB

Imágenes Docker para múltiples arquitecturas

Cómo funciona el caché en Docker builds

De 1.19 GB a 126 MB con Alpine

Qué es el build context en Docker

Docker Hub para compartir imágenes en la nube

Buenas Prácticas en Docker

Cómo reducir capas en Docker

Cómo usar .dockerignore para imágenes más pequeñas

Limpia Docker y recupera gigas con prune

Creando usuarios en Docker sin privilegios root

6 prácticas Docker para imágenes listas para producción

Instalación y Configuración en Entornos Multiplataforma

Publica imágenes Docker en Azure Container Registry

Azure Container Registry hacia Container App

Redes Avanzadas y Balanceo de Carga

Redes en Docker: los 5 modelos explicados

Cómo funcionan los puertos en Docker

Balanceo de carga con NGINX en Docker

Automatización de CI/CD

Optimizar Dockerfile con comandos RUN y scripts

Automatiza Docker con GitHub Actions

Pruebas automáticas de Docker con GitHub Actions

Despliegue automático en Azure con GitHub Actions

Orquestación

Docker Compose: balanceo de cargas automatizado

Estructura y plantilla de Docker Compose YAML

Volúmenes Docker: bind vs nombrados

docker-compose down vs Control C en apagado

Docker Swarm para principiantes paso a paso

Despliegue Docker Swarm con réplicas de Nginx

Costos ocultos de contenedores en la nube

Cómo habilitar Kubernetes en Docker Desktop

Planes y límites de Docker Hub en producción

Develop

Dev containers en VS Code con Docker

Limpia Docker y recupera gigas con prune