CI/CD with GitHub Actions & DevOps Pipelines · Lezione

Workflow e Actions riutilizzabili

Crei e utilizzi workflow riutilizzabili e Actions personalizzate per rendere modulari le pipeline e promuovere la coerenza tra i repository.

Workflow e Actions riutilizzabili è una lezione CI/CD with GitHub Actions & DevOps Pipelines gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento CI/CD with GitHub Actions & DevOps Pipelines, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso CI/CD with GitHub Actions & DevOps Pipelines include 4 lezioni in totale.

Introduzione al riutilizzo dei workflow

Nello sviluppo software moderno, efficienza e coerenza sono fondamentali. Con la crescita dei progetti aumentano anche le esigenze di automazione.

I workflow riutilizzabili e le action personalizzate di GitHub Actions aiutano a evitare le ripetizioni, rendendo le pipeline CI/CD più facili da mantenere e più solide.

Perché riutilizzare i workflow?

Immagini di avere più applicazioni che richiedono tutte gli stessi passaggi di build, test o distribuzione. Copiare e incollare il codice dei workflow comporta:

Duplicazione: più codice da mantenere.
Incoerenza: è facile non applicare gli aggiornamenti a tutti i workflow.
Difficoltà di manutenzione: le modifiche richiedono l'aggiornamento di molti file.

Il riutilizzo risolve questi problemi!

Definire un workflow riutilizzabile

Un workflow riutilizzabile è un workflow completo che può essere chiamato da altri workflow. Viene archiviato nel repository e funziona come un modello.

Per rendere riutilizzabile un workflow, si usa l'evento workflow_call. In questo modo si comunica a GitHub Actions che il workflow deve essere chiamato e non attivato da eventi comuni come push o pull_request.

Esempio di workflow riutilizzabile

Ecco un semplice workflow riutilizzabile che simula una build. Lo salvi in .github/workflows/reusable-build.yml.

Definisce un output chiamato build_id che i workflow chiamanti possono usare.

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 }}..."

Chiamare un workflow riutilizzabile

Per usare un workflow riutilizzabile, un altro workflow, detto "chiamante", usa la parola chiave uses, in modo simile a come si usa un'action di GitHub.

Si specifica il percorso del file del workflow riutilizzabile all'interno del repository, oppure quello di un altro repository o di una versione specifica.

Esempio di workflow chiamante

Questo workflow, salvato come .github/workflows/main-app-ci.yml, chiama il workflow reusable-build.yml.

Si noti come acceda all'output build_id del workflow chiamato usando 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 }}"

Passare input ai workflow riutilizzabili

I workflow riutilizzabili non sono semplici template statici: possono accettare degli input, il che li rende estremamente flessibili.

Gli input previsti si definiscono nella sezione on: workflow_call: inputs: del workflow riutilizzabile, specificandone il tipo, indicando se sono obbligatori e fornendo una descrizione. Il workflow chiamante passa questi input usando la parola chiave with:.

Workflow riutilizzabile con input

Ecco una versione aggiornata di reusable-build.yml che accetta un input target_env. In questo modo è possibile personalizzare la stessa logica di build per ambienti diversi.

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 }}..."

Esempio di chiamata con input

Ora il workflow CI principale può chiamare due volte il componente di build riutilizzabile, una volta per 'staging' e una volta per 'production', passando valori diversi per 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 }}

Workflow riutilizzabili e azioni personalizzate

Sebbene entrambi favoriscano la riusabilità, hanno scopi diversi:

Workflow riutilizzabili: orchestrano una serie di job. Definiscono la struttura completa di un workflow, ad esempio build, test e deploy.
Azioni personalizzate: eseguono una singola attività specifica all'interno di un job, ad esempio configurare Node.js o pubblicare un pacchetto. Sono i blocchi costitutivi *all'interno* dei passaggi di un job.

Consideri i workflow come ricette e le azioni come singoli ingredienti o passaggi.

Controllo rapido

Quali dei seguenti sono vantaggi fondamentali dell'uso dei workflow riutilizzabili in GitHub Actions?

Riepilogo: workflow riutilizzabili e azioni

Abbiamo visto come i workflow riutilizzabili aiutino a rendere modulari le pipeline CI/CD.

Vengono definiti usando workflow_call.
Possono accettare inputs e fornire outputs.
I workflow chiamanti usano la parola chiave uses.
Si distinguono dalle azioni personalizzate, che sono blocchi costitutivi per singole attività all'interno dei job.

Adottare la riusabilità porta a un'automazione più efficiente, coerente e facile da gestire nei diversi progetti.

Domande Frequenti

La lezione «Workflow e Actions riutilizzabili» è gratuita?

Sì — il testo completo di «Workflow e Actions riutilizzabili» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso CI/CD with GitHub Actions & DevOps Pipelines, passa a CoddyKit PRO. Il corso CI/CD with GitHub Actions & DevOps Pipelines include 4 lezioni in totale.

Cosa imparerò in «Workflow e Actions riutilizzabili»?

Crei e utilizzi workflow riutilizzabili e Actions personalizzate per rendere modulari le pipeline e promuovere la coerenza tra i repository. Eserciti CI/CD with GitHub Actions & DevOps Pipelines con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare CI/CD with GitHub Actions & DevOps Pipelines?

Non è richiesta alcuna esperienza precedente. CI/CD with GitHub Actions & DevOps Pipelines su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Workflow e Actions riutilizzabili»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione CI/CD with GitHub Actions & DevOps Pipelines?

Sì. Ogni lezione CI/CD with GitHub Actions & DevOps Pipelines include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Build a matrice per più ambienti
Memorizzare nella cache le dipendenze per aumentare la velocità
Workflow e Actions riutilizzabili
Esecuzione condizionale e dipendenze tra job

← Torna a CI/CD with GitHub Actions & DevOps Pipelines