Optimiza tiempos de ejecución con caching y matrices

Concepto clave

En el mundo de la automatizacion de CI/CD, el tiempo es un recurso critico. Imagina que cada vez que construyes tu aplicacion, tienes que descargar todas las dependencias desde cero, como si tuvieras que ir al supermercado a comprar ingredientes para cada comida, incluso cuando ya tienes muchos en tu despensa. El caching en GitHub Actions es como tener una despensa inteligente que guarda los ingredientes ya descargados, reduciendo significativamente el tiempo de preparacion.

Por otro lado, las matrices son como tener multiples cocinas trabajando en paralelo para preparar diferentes versiones de un plato simultaneamente. En lugar de ejecutar tu pipeline una vez para cada combinacion de sistema operativo, version de Node.js, o configuracion de prueba, las matrices te permiten definir estas variantes y ejecutarlas en paralelo, optimizando el tiempo total de ejecucion.

Como funciona en la practica

El caching en GitHub Actions utiliza la accion actions/cache para guardar y restaurar directorios especificos entre ejecuciones de workflows. Funciona en tres pasos clave: primero, intenta restaurar una cache existente usando una clave unica; segundo, si no encuentra cache, ejecuta el proceso normal; tercero, al finalizar, guarda los resultados en cache para futuras ejecuciones.

Las matrices se definen en la seccion strategy.matrix de un job y permiten crear multiples ejecuciones basadas en combinaciones de variables. Por ejemplo, puedes probar tu aplicacion en Ubuntu, Windows y macOS simultaneamente, o con diferentes versiones de Python, todo en un solo job definido.

Codigo en accion

Veamos un ejemplo de workflow sin optimizaciones:

name: Build and Test

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test

Ahora, el mismo workflow optimizado con caching y matrices:

name: Optimized Build and Test

on: [push]

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node-version: ['18', '20', '22']
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      
      - name: Cache node modules
        uses: actions/cache@v4
        with:
          path: ~/.npm
          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-node-
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test

Errores comunes

• Claves de cache no unicas: Usar claves genericas como "node-cache" puede causar que multiples proyectos compartan cache incorrectamente. Siempre incluye identificadores especificos del proyecto.
• Matrices demasiado grandes: Definir matrices con muchas combinaciones puede agotar los minutos de GitHub Actions rapidamente. Limita las combinaciones a las realmente necesarias.
• No limpiar cache antigua: GitHub Actions tiene limites de almacenamiento de cache. Configura politicas de retencion o usa restore-keys para manejar versiones.
• Ignorar fallos en matrices: Cuando una combinacion en la matriz falla, el job completo puede fallar. Usa fail-fast: false para permitir que otras combinaciones continúen.
• Caching de archivos temporales Guardar directorios como node_modules directamente en lugar de ~/.npm puede ser menos eficiente y causar problemas de permisos.

Checklist de dominio

1. Puedo configurar caching para dependencias de npm, pip, o maven en un workflow
2. Se crear matrices para probar multiples versiones de lenguajes o sistemas operativos
3. Entiendo como usar restore-keys para fallback en caching
4. Puedo calcular el ahorro de tiempo comparando workflows con y sin optimizaciones
5. Se configurar fail-fast en estrategias de matriz
6. Puedo identificar cuando el caching esta causando problemas y solucionarlos
7. Entiendo los limites de almacenamiento y retencion de cache en GitHub Actions

Optimiza un workflow existente con caching y matrices

En este ejercicio, vas a tomar un workflow de GitHub Actions existente y optimizarlo aplicando caching y matrices. Sigue estos pasos:

1. Clona un repositorio existente que tenga un workflow basico de CI/CD (puedes usar uno propio o este ejemplo: https://github.com/example/node-app)
2. Identifica las etapas que mas tiempo consumen, tipicamente la instalacion de dependencias
3. Agrega caching para las dependencias usando la accion actions/cache@v4. Asegurate de usar una clave unica que incluya el sistema operativo y un hash de los archivos de dependencias
4. Implementa una matriz para probar al menos 2 versiones diferentes del lenguaje principal (ej: Node.js 18 y 20) y 2 sistemas operativos (ej: ubuntu-latest y windows-latest)
5. Ejecuta el workflow optimizado y compara los tiempos de ejecucion con la version original
6. Documenta el ahorro de tiempo porcentual en un archivo README o comentario

• Recuerda que la clave del cache debe cambiar cuando cambian las dependencias, usa hashFiles para esto
• Puedes usar variables de contexto como runner.os en las claves de cache
• Considera usar continue-on-error para jobs de matriz que no son criticos

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.