Optimizar los tiempos de los flujos de trabajo CI/CD impacta directamente en la productividad del desarrollador y reduce los gastos de cómputo. Este artículo te muestra cómo integrar el almacenamiento en caché de dependencias en GitHub Actions, ayudándote a reducir los tiempos de compilación y configuración de paquetes.

Proporcionamos plantillas de flujo de trabajo YAML para Node.js, Python y Rust, junto con mejores prácticas para garantizar aciertos de caché óptimos.

1. ¿Por qué almacenar en caché dependencias en CI/CD?

Cuando un agente CI se inicia sin caché, levanta un contenedor limpio y obtiene cada dependencia de los registros de paquetes. Esto introduce varios inconvenientes:

1. Bucles de desarrollo ineficientes: Los desarrolladores pierden minutos valiosos esperando que se instalen las bibliotecas estándar antes de probar el código.
2. Riesgos de red: Si npm, PyPI o crates.io sufren un tiempo de inactividad menor, tu compilación falla debido a problemas de red externos.
3. Costos de ejecución: En repositorios privados, GitHub te cobra por cada minuto activo. Compilaciones más rápidas reducen directamente los costos operativos.

El almacenamiento en caché permite que el pipeline reutilice los recursos descargados entre ejecuciones, haciendo que las ejecuciones posteriores sean hasta un 80% más rápidas.

2. Plantillas YAML para lenguajes principales

En 2026, las acciones de configuración de lenguaje predeterminadas de GitHub incluyen soporte de caché integrado, haciendo la configuración sencilla.

1) Node.js (npm / pnpm / yarn)

Configura la propiedad cache bajo actions/setup-node:

name: Node.js CI

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Código
        uses: actions/checkout@v4

      - name: Configurar Node
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Instalar Paquetes
        run: npm ci

      - name: Ejecutar Pruebas
        run: npm test

2) Python (pip / poetry)

Para entornos Python, habilita el caché usando la clave cache en actions/setup-python:

name: Ejecutor de pruebas Python

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
          cache: 'pip'
      - name: Instalar Dependencias
        run: pip install -r requirements.txt
      - name: Ejecutar Linter
        run: flake8 .

3) Rust (Cargo)

La compilación de Rust es notoriamente lenta. Para almacenar en caché las dependencias de Cargo y los artefactos de compilación intermedios (el directorio /target), usa el estándar comunitario swatinem/rust-cache:

name: Rust CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Configurar compilador Rust
        uses: actions/setup-rust@v1
      - name: Configurar caché de Cargo
        uses: swatinem/rust-cache@v2
      - name: Ejecutar Pruebas
        run: cargo test

3. Caché personalizado y solución de problemas

Para carpetas no manejadas por las acciones predeterminadas, defínelas manualmente usando actions/cache:

- name: Cachear Archivos Personalizados
  uses: actions/cache@v4
  with:
    path: ~/.my-custom-cache
    key: ${{ runner.os }}-custom-${{ hashFiles('**/lockfile.json') }}
    restore-keys: |
      ${{ runner.os }}-custom-

• key: Identificador único para el caché. La función hashFiles crea un hash de tus lockfiles (package-lock.json, Cargo.lock, etc.). Cuando un lockfile cambia, el caché antiguo se invalida y se construye uno nuevo.
• restore-keys: Una lista ordenada de claves de prefijo para usar como respaldo si no se encuentra una coincidencia exacta de caché.

Previniendo fallos de caché

1. Haz commit de los lockfiles: Asegúrate de que los lockfiles estén rastreados en Git. Sin ellos, los hashes fluctúan, causando fallos frecuentes de caché.
2. Monitorea el tamaño del caché: GitHub limita el almacenamiento de caché a 10GB por repositorio. Una vez que superas este límite, GitHub elimina automáticamente los cachés más antiguos. Excluye artefactos de compilación innecesarios de tus rutas de caché.

4. Resumen

Configurar el almacenamiento en caché de acciones es una de las formas más fáciles de optimizar tus pipelines de software. Implementar estos cambios puede ahorrar horas de tiempo de espera en todo tu equipo cada semana. Verifica tus flujos de trabajo YAML e integra el caché hoy.