Configura builds para diferentes lenguajes (Node.js, Python, Java)

Concepto clave

Configurar builds para diferentes lenguajes en GitHub Actions es como tener un taller de mecánica con herramientas especializadas para cada tipo de vehículo. No usarías las mismas llaves para un coche, una moto y un camión. De igual forma, cada lenguaje de programación tiene sus propias dependencias, entornos de ejecución y comandos de construcción específicos.

GitHub Actions permite definir workflows que automatizan estos procesos mediante jobs y steps. La clave está en seleccionar las acciones predefinidas adecuadas y configurar correctamente los entornos. Para Node.js necesitarás gestionar paquetes npm, para Python entornos virtuales, y para Java herramientas como Maven o Gradle. La automatización consistente asegura que cada build se ejecute en las mismas condiciones, eliminando el "en mi máquina funciona".

Cómo funciona en la práctica

Imagina que tienes un proyecto con microservicios en Node.js, Python y Java. Primero, creas un archivo YAML en .github/workflows/. Luego, defines jobs separados para cada lenguaje o usas matrices para ejecutar builds en paralelo. Cada job especifica un runner (como ubuntu-latest) y steps que instalan dependencias, ejecutan tests y generan artefactos.

Paso a paso: 1) Configura el evento trigger (push a main), 2) Define jobs con nombres descriptivos, 3) Usa acciones oficiales como actions/setup-node, 4) Ejecuta comandos específicos del lenguaje, 5) Guarda resultados con actions/upload-artifact. La ventaja es que puedes reutilizar configuraciones y compartir datos entre jobs.

Código en acción

Workflow básico para Node.js y Python en paralelo:

name: Multi-language Build

on:
  push:
    branches: [ main ]

jobs:
  build-node:
    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

  build-python:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Setup Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.10'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run tests
      run: pytest

Refactorización usando matriz para Java con Maven:

name: Java Build Matrix

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        java-version: [11, 17]
    steps:
    - uses: actions/checkout@v4
    - name: Setup Java ${{ matrix.java-version }}
      uses: actions/setup-java@v4
      with:
        java-version: ${{ matrix.java-version }}
        distribution: 'temurin'
    - name: Build with Maven
      run: mvn -B package --file pom.xml
    - name: Upload artifact
      uses: actions/upload-artifact@v4
      with:
        name: java-app-${{ matrix.java-version }}
        path: target/*.jar

Errores comunes

• No especificar versiones exactas: Usar "node" sin versión puede causar inconsistencias. Siempre define versiones específicas como '18.20.0'.
• Olvidar cache de dependencias: Reinstalar todo cada vez ralentiza builds. Usa acciones como actions/cache para npm, pip o Maven.
• Manejo incorrecto de entornos virtuales en Python: No activar el entorno o instalar en el global. Usa python -m venv y activación explícita.
• No limpiar entre jobs: Archivos residuales pueden contaminar builds. Añade steps de limpieza o usa actions/checkout fresco.
• Ignorar fallos en steps no críticos: Tests que fallan pero no detienen el workflow. Usa continue-on-error solo cuando sea apropiado.

Checklist de dominio

1. Puedo configurar un workflow que construya una app Node.js con npm install y test.
2. Sé instalar dependencias Python en un entorno virtual dentro de GitHub Actions.
3. He usado matrices para ejecutar builds de Java con diferentes versiones del JDK.
4. Implementé cache para acelerar la instalación de dependencias en al menos un lenguaje.
5. Puedo explicar la diferencia entre jobs paralelos y secuenciales en un workflow.
6. Configuré la subida de artefactos después de un build exitoso.
7. Sé cómo leer logs de GitHub Actions para depurar fallos en builds.

Configura un workflow multi-lenguaje para un proyecto de ejemplo

Crea un workflow que automatice builds para tres lenguajes diferentes en un solo repositorio. Sigue estos pasos:

1. Crea un repositorio nuevo en GitHub con tres carpetas: /node-app, /python-app, /java-app. En cada una, añade un archivo simple (ej. app.js, app.py, Main.java) y un test básico.
2. En .github/workflows/multi-build.yml, define un workflow que se dispare en push a la rama main.
3. Configura tres jobs separados (build-node, build-python, build-java) que se ejecuten en paralelo.
4. En cada job, usa la acción de setup apropiada (Node.js 18, Python 3.10, Java 17) e instala dependencias.
5. Añade un step para ejecutar tests en cada lenguaje (usa comandos como npm test, pytest, mvn test).
6. Implementa cache para las dependencias de Node.js usando actions/cache con la clave npm-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}.
7. Configura que el workflow falle si algún test no pasa, y sube un artefacto del build de Java.

• Revisa la documentación de actions/setup-node para ver cómo especificar versiones exactas.
• Usa '|' en YAML para comandos multi-línea en Python.
• Asegúrate de que los paths en cache apunten a los directorios correctos de cada lenguaje.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.