0Pricing
CI/CD with GitHub Actions & DevOps Pipelines · Lección

Workflows y Actions reutilizables

Cree y aproveche workflows reutilizables y Actions personalizadas para modularizar sus canalizaciones y promover la coherencia entre repositorios.

Workflows y Actions reutilizables es una lección gratuita de CI/CD with GitHub Actions & DevOps Pipelines en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de CI/CD with GitHub Actions & DevOps Pipelines, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de CI/CD with GitHub Actions & DevOps Pipelines incluye 4 lecciones en total.

Introducción a la reutilización de flujos de trabajo

En el desarrollo de software moderno, la eficiencia y la coherencia son fundamentales. A medida que crecen sus proyectos, también lo hacen sus necesidades de automatización.

Los flujos de trabajo reutilizables y las acciones personalizadas de GitHub Actions le ayudan a evitar la repetición de código, lo que hace que sus canalizaciones de CI/CD sean más fáciles de mantener y más sólidas.

¿Por qué reutilizar los flujos de trabajo?

Imagine que tiene varias aplicaciones que necesitan los mismos pasos de compilación, prueba o implementación. Copiar y pegar el código del flujo de trabajo provoca:

  • Duplicación: más código que mantener.
  • Incoherencia: es fácil pasar por alto actualizaciones en distintos flujos de trabajo.
  • Problemas de mantenimiento: los cambios requieren actualizar muchos archivos.

¡La reutilización resuelve estos problemas!

Definición de un flujo de trabajo reutilizable

Un flujo de trabajo reutilizable es un flujo de trabajo completo al que pueden llamar otros flujos de trabajo. Se almacena en su repositorio y funciona como una plantilla.

Para hacer que un flujo de trabajo sea reutilizable, se utiliza el evento workflow_call. Esto indica a GitHub Actions que este flujo de trabajo está destinado a recibir llamadas, no a activarse mediante eventos habituales como push o pull_request.

Ejemplo de flujo de trabajo reutilizable

Este es un flujo de trabajo reutilizable sencillo que simula una compilación. Guárdelo en .github/workflows/reusable-build.yml.

Define un output llamado build_id que pueden utilizar los flujos de trabajo que lo llamen.

name: Reusable Build Component

on:
  workflow_call:
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build
        run: echo "Building project with ID ${{ steps.generate_id.outputs.id }}..."

Llamada a un flujo de trabajo reutilizable

Para utilizar un flujo de trabajo reutilizable, otro flujo de trabajo (el «caller») emplea la palabra clave uses, de forma similar a como utilizaría una acción de GitHub.

Especifique la ruta al archivo del flujo de trabajo reutilizable dentro de su repositorio, o incluso desde otro repositorio o una versión específica.

Ejemplo de flujo de trabajo que realiza la llamada

Este flujo de trabajo, guardado como .github/workflows/main-app-ci.yml, llama a nuestro flujo de trabajo reusable-build.yml.

Observe cómo accede al resultado build_id del flujo de trabajo llamado mediante jobs.call-build.outputs.build_id.

name: Main App CI

on: [push]

jobs:
  call-build:
    uses: ./.github/workflows/reusable-build.yml
    outputs:
      build_id: ${{ jobs.call-build.outputs.build_id }}
  
  deploy:
    needs: call-build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy app
        run: echo "Deploying app built with ID ${{ needs.call-build.outputs.build_id }}"

Pasar entradas a flujos de trabajo reutilizables

Los flujos de trabajo reutilizables no son solo plantillas estáticas; pueden aceptar entradas, lo que los hace muy flexibles.

Defina las entradas esperadas en la sección on: workflow_call: inputs: del flujo de trabajo reutilizable, especificando su tipo, si son obligatorias y una descripción. El flujo de trabajo que realiza la llamada pasa estas entradas mediante la palabra clave with:.

Flujo de trabajo reutilizable con entradas

Este es un archivo reusable-build.yml actualizado que acepta una entrada target_env. Esto permite personalizar la misma lógica de compilación para distintos entornos.

name: Reusable Build Component with Input

on:
  workflow_call:
    inputs:
      target_env:
        required: true
        type: string
        description: "The target environment for the build"
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build for ${{ inputs.target_env }}
        run: echo "Building project for ${{ inputs.target_env }} with ID ${{ steps.generate_id.outputs.id }}..."

Ejemplo de llamada con entradas

Ahora, nuestro flujo de trabajo principal de CI puede llamar dos veces al componente de compilación reutilizable, una para 'staging' y otra para 'production', pasando distintos valores de target_env.

name: Main App CI with Input

on: [push]

jobs:
  call-build-staging:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'staging'
    outputs:
      build_id: ${{ jobs.call-build-staging.outputs.build_id }}
  
  call-build-prod:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'production'
    outputs:
      build_id: ${{ jobs.call-build-prod.outputs.build_id }}

Flujos de trabajo reutilizables frente a acciones personalizadas

Aunque ambos fomentan la reutilización, tienen propósitos diferentes:

  • Flujos de trabajo reutilizables: Orquestan una serie de trabajos. Definen una estructura de flujo de trabajo completa (por ejemplo, compilar, probar y desplegar).
  • Acciones personalizadas: Realizan una tarea específica y única dentro de un trabajo (por ejemplo, configurar Node.js o publicar un paquete). Son los bloques de construcción *dentro* de los pasos de un trabajo.

Piense en los flujos de trabajo como recetas y en las acciones como ingredientes o pasos individuales.

Comprobación rápida

¿Cuáles de las siguientes son ventajas clave de utilizar flujos de trabajo reutilizables en GitHub Actions?

Resumen: flujos de trabajo reutilizables y acciones

Hemos visto cómo los flujos de trabajo reutilizables ayudan a modularizar sus pipelines de CI/CD.

  • Se definen mediante workflow_call.
  • Pueden aceptar inputs y proporcionar outputs.
  • Los flujos de trabajo que realizan la llamada utilizan la palabra clave uses.
  • Se diferencian de las acciones personalizadas, que son bloques de construcción de una sola tarea dentro de los trabajos.

Adoptar la reutilización permite lograr una automatización más eficiente, coherente y fácil de mantener en todos sus proyectos.

Preguntas frecuentes

¿La lección «Workflows y Actions reutilizables» es gratis?

Sí — el texto completo de «Workflows y Actions reutilizables» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de CI/CD with GitHub Actions & DevOps Pipelines, actualiza a CoddyKit PRO. El curso de CI/CD with GitHub Actions & DevOps Pipelines incluye 4 lecciones en total.

¿Qué aprenderé en «Workflows y Actions reutilizables»?

Cree y aproveche workflows reutilizables y Actions personalizadas para modularizar sus canalizaciones y promover la coherencia entre repositorios. Practicas CI/CD with GitHub Actions & DevOps Pipelines con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar CI/CD with GitHub Actions & DevOps Pipelines?

No se requiere experiencia previa. CI/CD with GitHub Actions & DevOps Pipelines en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Workflows y Actions reutilizables»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de CI/CD with GitHub Actions & DevOps Pipelines?

Sí. Cada lección de CI/CD with GitHub Actions & DevOps Pipelines incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Compilaciones matriciales para varios entornos
  2. Almacenamiento en caché de dependencias para acelerar la ejecución
  3. Workflows y Actions reutilizables
  4. Ejecución condicional y dependencias entre jobs
← Volver a CI/CD with GitHub Actions & DevOps Pipelines