Exploración de trabajos

Los trabajos son las piezas fundamentales de los flujos de trabajo de Acciones de GitHub. Cada trabajo es una colección de pasos que se ejecutan secuencialmente en el mismo ejecutor, compartiendo el sistema de archivos y las variables de entorno.

Descripción de la ejecución del trabajo

Características clave de los trabajos

• Pasos secuenciales: los pasos dentro de un trabajo se ejecutan uno después de otro
• Entorno compartido: todos los pasos comparten el mismo ejecutor y sistema de archivos
• Ejecución aislada: cada trabajo obtiene un entorno virtual nuevo
• Registros que se pueden buscar: las salidas del trabajo se capturan y se pueden buscar automáticamente.
• Soporte de artefactos: los trabajos pueden guardar y compartir archivos entre ejecuciones de flujo de trabajo

Estructura de trabajo básica

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

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test

Ejecución en paralelo frente a secuencial

Ejecución en paralelo (valor predeterminado)

De forma predeterminada, varios trabajos se ejecutan simultáneamente para minimizar la duración del flujo de trabajo:

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Run linter
        run: npm run lint

  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Run tests
        run: npm test

  # Both lint and test jobs run simultaneously

Ejecución secuencial con dependencias

Usa la needs palabra clave para crear dependencias de trabajo:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Build application
        run: ./build.sh

  test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Run integration tests
        run: ./test.sh

  deploy:
    needs: [build, test] # Waits for multiple jobs
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to production
        run: ./deploy.sh

Patrones de trabajo avanzados

Estrategia de matriz para varias configuraciones

Ejecutar trabajos en varios entornos simultáneamente:

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node-version: [18, 20, 22]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm test

Ejecución de trabajos condicionales

Ejecute trabajos solo cuando se cumplan condiciones específicas:

jobs:
  deploy:
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to production
        run: echo "Deploying to production"

  notify:
    needs: deploy
    if: failure() # Only runs if deploy job fails
    runs-on: ubuntu-latest
    steps:
      - name: Send failure notification
        run: echo "Deployment failed!"

Control de errores de trabajo

Comportamiento predeterminado

• Si se produce un error en algún paso, se produce un error en todo el trabajo.
• Los trabajos dependientes no se ejecutarán si se producen errores en sus requisitos previos
• El flujo de trabajo se marca como erróneo.

Control del comportamiento de errores

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Run tests (continue on error)
        run: npm test
        continue-on-error: true

      - name: Upload test results
        if: always() # Runs regardless of previous step outcome
        uses: actions/upload-artifact@v4
        with:
          name: test-results
          path: test-results.xml

Procedimientos recomendados para trabajos

• Mantener los trabajos centrados: cada trabajo debe tener una sola responsabilidad
• Usar nombres descriptivos: hacer que los propósitos del trabajo sean claros en la interfaz de usuario del flujo de trabajo
• Optimización de dependencias: cree solo las dependencias cuando sea realmente necesario
• Elección de los ejecutores adecuados: Coincidencia del sistema operativo del ejecutor con las necesidades de la aplicación
• Maneje los fallos de manera elegante: use la ejecución condicional y continúe ante un error estratégicamente
• Compartir datos de manera eficiente: utilice artefactos o resultados para pasar datos entre trabajos

Para obtener opciones completas de configuración de trabajos, consulte Uso de trabajos en un flujo de trabajo.