Domande Colloquio Pipeline CI/CD: GitHub Actions, GitLab CI e Jenkins nel 2026

Le domande sui colloqui relativi alle pipeline CI/CD sono tra gli argomenti più comuni nelle selezioni DevOps del 2026. Con GitHub Actions che elabora oltre 71 milioni di job al giorno e ha introdotto l'esecuzione parallela degli step a giugno 2026, GitLab CI alla versione 19 con il Secrets Manager nativo, e Jenkins con un tasso di adozione del 28%, gli intervistatori si aspettano che i candidati dimostrino competenza pratica su tutte e tre le piattaforme.

Struttura e Trigger dei Workflow GitHub Actions

GitHub Actions organizza l'automazione attorno a workflow, job e step. Un workflow è un file YAML memorizzato in .github/workflows/ che definisce quando e come viene eseguita l'automazione. Ogni workflow contiene uno o più job, e ogni job viene eseguito su un runner separato.

Una domanda comune nei colloqui chiede ai candidati di spiegare la relazione tra i trigger on, le dipendenze dei job e la keyword needs.

# .github/workflows/ci.yml
name: CI Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci
      - run: npm run lint

  test:
    needs: lint              # waits for lint to pass
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node: [20, 22]       # runs tests on both versions
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
          cache: npm
      - run: npm ci
      - run: npm test

  deploy:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production  # requires approval
    steps:
      - uses: actions/checkout@v4
      - run: ./deploy.sh

Questo workflow dimostra tre concetti chiave: la keyword needs crea un grafo di dipendenze tra i job, la strategia matrix abilita il testing parallelo su diverse versioni di Node.js, e la keyword environment protegge i deployment con approvazioni manuali.

Step Paralleli di GitHub Actions

GitHub Actions ha introdotto l'esecuzione parallela degli step il 25 giugno 2026, implementando una delle funzionalità più richieste. In precedenza, tutti gli step all'interno di un job venivano eseguiti in sequenza. La nuova funzionalità introduce quattro keyword che abilitano l'esecuzione concorrente all'interno di un singolo job.

# .github/workflows/parallel-steps.yml
name: Build with Parallel Steps

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci

      # Run lint and typecheck in parallel
      - name: lint
        run: npm run lint
        background: true

      - name: typecheck
        run: npm run typecheck
        background: true

      - wait-all:              # wait for both to complete

      # Or use the parallel shorthand
      - parallel:
          - name: build-frontend
            run: npm run build:frontend
          - name: build-backend
            run: npm run build:backend

      - run: npm run deploy

La keyword background: true avvia uno step in modo asincrono e prosegue immediatamente allo step successivo. La keyword wait-all mette in pausa l'esecuzione finché tutti gli step in background precedenti non sono completati. La keyword parallel fornisce una forma abbreviata che esegue più step contemporaneamente e attende che tutti siano completati prima di continuare.

Esistono due keyword aggiuntive: wait prende di mira step in background specifici, e cancel termina con grazia uno step in background quando non è più necessario (utile per interrompere servizi a lunga esecuzione).

Configurazione Pipeline GitLab CI con Stage

GitLab CI utilizza un file .gitlab-ci.yml nella root del repository. A differenza di GitHub Actions dove i job vengono eseguiti indipendentemente per default, GitLab CI organizza i job in stage che vengono eseguiti in sequenza, mentre i job all'interno dello stesso stage vengono eseguiti in parallelo.

Gli intervistatori chiedono frequentemente ai candidati di convertire un workflow GitHub Actions in una pipeline GitLab CI, o viceversa.

# .gitlab-ci.yml
stages:
  - validate
  - test
  - deploy

variables:
  NODE_VERSION: "22"

lint:
  stage: validate
  image: node:${NODE_VERSION}
  cache:
    key: ${CI_COMMIT_REF_SLUG}
    paths:
      - node_modules/
  script:
    - npm ci
    - npm run lint

unit-tests:
  stage: test
  image: node:${NODE_VERSION}
  parallel:
    matrix:
      - NODE_VERSION: ["20", "22"]
  script:
    - npm ci
    - npm test
  artifacts:
    reports:
      junit: coverage/junit.xml
    expire_in: 7 days

deploy-production:
  stage: deploy
  image: alpine:latest
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
      when: manual                   # manual gate
  environment:
    name: production
    url: https://app.example.com
  script:
    - ./deploy.sh

Differenze chiave rispetto a GitHub Actions: gli stage impongono l'ordine di esecuzione globalmente, la keyword parallel:matrix gestisce i matrix build, e artifacts:reports:junit integra i risultati dei test direttamente nelle viste delle merge request.

GitLab 19.0 (maggio 2026) ha introdotto il Secrets Manager in open beta, fornendo storage nativo dei secrets senza servizi esterni come HashiCorp Vault. GitLab 19.2 (luglio 2026) ha reso generalmente disponibili le policy di esecuzione programmata delle pipeline, permettendo ai team di applicare scan di compliance o controlli delle dipendenze con una cadenza fissa su più progetti da una singola definizione di policy.

Sintassi della Pipeline Dichiarativa Jenkins

Jenkins utilizza un Jenkinsfile nella root del repository. La sintassi della pipeline dichiarativa, raccomandata come default nel 2026, fornisce gestione strutturata degli errori e un layout chiaro basato su stage.

Una domanda frequente nei colloqui: spiegare la differenza tra pipeline dichiarative e scriptate, e quando usare ciascuna.

// Jenkinsfile
pipeline {
    agent any

    tools {
        nodejs 'node-22'       // configured in Jenkins Global Tool
    }

    environment {
        CI = 'true'
        DEPLOY_ENV = credentials('deploy-env-secret')
    }

    stages {
        stage('Install') {
            steps {
                sh 'npm ci'
            }
        }

        stage('Lint & Test') {
            parallel {             // parallel execution
                stage('Lint') {
                    steps {
                        sh 'npm run lint'
                    }
                }
                stage('Test') {
                    steps {
                        sh 'npm test'
                    }
                    post {
                        always {
                            junit 'coverage/junit.xml'
                        }
                    }
                }
            }
        }

        stage('Deploy') {
            when {
                branch 'main'
            }
            input {
                message 'Deploy to production?'
            }
            steps {
                sh './deploy.sh'
            }
        }
    }

    post {
        failure {
            mail to: 'team@example.com',
                 subject: "Build failed: ${env.JOB_NAME}",
                 body: "Check ${env.BUILD_URL}"
        }
    }
}

Le pipeline dichiarative impongono una struttura attraverso blocchi obbligatori pipeline, agent e stages. La direttiva parallel all'interno di uno stage esegue lint e test simultaneamente. La direttiva input mette in pausa l'esecuzione per l'approvazione manuale, simile agli environment di GitHub Actions e ai gate manuali di GitLab. Jenkins richiede Java 21 da gennaio 2026, quindi gli ambienti delle pipeline devono tenere conto di questa dipendenza runtime.

Gestione dei Secrets sulle Piattaforme CI/CD

Ogni colloquio CI/CD include domande sulla gestione dei secrets. Ogni piattaforma gestisce le credenziali in modo diverso, e comprendere le implicazioni di sicurezza è fondamentale.

GitHub Actions memorizza i secrets a livello di repository, environment o organizzazione. I secrets vengono mascherati automaticamente nei log, ma l'attuale modello di scoping ha limitazioni. La roadmap di sicurezza 2026 introduce gli scoped secrets che vincolano le credenziali a contesti di esecuzione espliciti, affrontando il rischio di accessi troppo ampi.

GitLab CI fornisce variabili CI/CD con regole di protezione. Le variabili protette vengono iniettate solo nelle pipeline che girano su branch o tag protetti. GitLab 19.0 ha introdotto il Secrets Manager, permettendo ai team di memorizzare e referenziare secrets nativamente senza vault esterni. I secrets sono limitati a progetti o gruppi e accessibili solo ai job che li richiedono esplicitamente.

Jenkins utilizza il plugin Credentials con diversi tipi di credenziali (username/password, chiave SSH, testo segreto, certificato). L'helper credentials() nelle pipeline dichiarative vincola i secrets alle variabili d'ambiente, e le credenziali a livello di Folder limitano l'accesso a progetti specifici.

La risposta critica nei colloqui: mai codificare secrets nei file di pipeline, usare sempre la gestione nativa dei secrets della piattaforma, ruotare le credenziali regolarmente e preferire token di breve durata rispetto a chiavi API di lunga durata.

Ottimizzazione delle Pipeline e Strategie di Caching

Le pipeline lente impattano direttamente sulla produttività degli sviluppatori. Gli intervistatori testano se i candidati sono in grado di diagnosticare e correggere i colli di bottiglia delle prestazioni nei sistemi CI/CD.

Tre tecniche di ottimizzazione universali si applicano a tutte e tre le piattaforme:

Caching delle dipendenze evita di riscaricare i pacchetti ad ogni esecuzione. GitHub Actions usa actions/cache o il supporto cache integrato nelle action di setup. GitLab CI usa cache con una strategia di chiavi. Jenkins si affida alla persistenza del workspace o ai comandi stash/unstash.

Esecuzione parallela distribuisce il lavoro su più runner. GitHub Actions ora supporta sia job paralleli (strategia matrix) che step paralleli (keyword background/parallel). GitLab CI usa parallel:matrix, e Jenkins usa la direttiva parallel. La giusta granularità di suddivisione dipende dal progetto: troppi job paralleli sprecano tempo di avvio dei runner, troppo pochi lasciano capacità inutilizzata.

Esecuzione condizionale salta stage non necessari. Tutte e tre le piattaforme supportano questo: GitHub Actions con espressioni if, GitLab CI con rules, e Jenkins con direttive when. Una pipeline ben progettata salta le fasi di deployment sui branch di feature ed evita che modifiche di solo lint attivino intere suite di test.

Sicurezza delle Pipeline CI/CD e Protezione della Supply Chain

Gli attacchi alla supply chain che prendono di mira i sistemi CI/CD sono aumentati significativamente nel 2025, con incidenti che hanno coinvolto tj-actions/changed-files e altre GitHub Actions popolari. Le domande dei colloqui ora esplorano regolarmente le strategie di hardening.

Fissare le versioni delle action a SHA di commit specifici invece che a tag per prevenire attacchi di tag-hijacking:

# .github/workflows/secure.yml
steps:
  # Vulnerable: tag can be moved to malicious commit
  - uses: actions/checkout@v4

  # Secure: pinned to exact commit SHA
  - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683

GitLab CI affronta le preoccupazioni sulla supply chain attraverso i CI/CD components con attestazione SLSA Level 1 (disponibili da GitLab 18.1), fornendo una provenienza più chiara quando si assemblano pipeline da componenti riutilizzabili. I tag container immutabili (GitLab 18.2) prevengono la sostituzione delle immagini dopo la pubblicazione.

Per Jenkins, il meccanismo Shared Library dovrebbe usare un repository dedicato con branch protection, requisiti di code review e commit firmati. La Commissione Europea ha lanciato un programma Jenkins Bug Bounty attraverso YesWeHack, riflettendo il ruolo critico della piattaforma nelle supply chain enterprise.

Confronto tra Piattaforme per la Preparazione ai Colloqui

Questa tabella di confronto copre le differenze più comunemente testate nei colloqui. La domanda di follow-up tipicamente chiede: "Quale piattaforma sceglieresti per un nuovo progetto, e perché?" La risposta dipende dagli strumenti esistenti, dalla dimensione del team, dai requisiti di compliance, e se l'organizzazione preferisce un'infrastruttura gestita (GitHub/GitLab) o il pieno controllo (Jenkins).

Fonti

• Actions steps can now be run in parallel (GitHub Changelog, giugno 2026)
• Note di rilascio GitLab 19.0 (GitLab Docs, maggio 2026)
• Note di rilascio GitLab 19.2 (GitLab Docs, luglio 2026)
• Jenkins Changelog (Jenkins.io, agosto 2026)
• GitHub Actions 2026 Security Roadmap (GitHub Blog)

La preparazione ai colloqui CI/CD è più efficace con la pratica sui fondamenti CI/CD e sui moduli specifici per GitHub Actions, GitLab CI e Jenkins. La guida completa alle domande essenziali per i colloqui DevOps copre l'intero spettro degli argomenti oltre CI/CD.

Punti Chiave per i Colloqui sulle Pipeline CI/CD

• Gli step paralleli di GitHub Actions (background, wait-all, parallel) sono stati introdotti a giugno 2026, abilitando l'esecuzione concorrente all'interno di un singolo job condividendo runner, checkout e workspace
• GitLab 19.x ha introdotto il Secrets Manager nativo (open beta, maggio 2026) e ha reso generalmente disponibili le policy di esecuzione programmata delle pipeline (luglio 2026), riducendo la dipendenza da strumenti esterni
• Jenkins 2.574+ ha separato plugin core come JUnit e Mailer dal file WAR, richiedendo l'installazione esplicita per le istanze senza accesso all'update center
• La gestione dei secrets è l'argomento di sicurezza più comunemente testato su tutte e tre le piattaforme: dimostrare conoscenza di scoped secrets, variabili protette e strategie di rotazione delle credenziali
• L'ottimizzazione delle pipeline attraverso caching, parallelizzazione ed esecuzione condizionale si applica universalmente e segnala agli intervistatori un'esperienza pratica in produzione
• Preparare almeno una configurazione di pipeline funzionante per piattaforma, concentrandosi su pattern reali piuttosto che su esempi didattici