Impostazione di una pipeline CI/CD per il flusso di lavoro di elaborazione dati

Last reviewed 2023-04-20 UTC

Questo tutorial descrive come configurare una pipeline di integrazione continua/deployment continuo (CI/CD) per l'elaborazione dei dati implementando metodi CI/CD con prodotti gestiti su Google Cloud. I data scientist e gli analisti possono adattare le metodologie dalle pratiche CI/CD per aiutare a garantire alta qualità, manutenibilità e adattabilità dei processi e dei flussi di lavoro dei dati. I metodi che puoi applicare sono i seguenti:

  • Controllo della versione del codice sorgente.
  • Creazione, test e deployment automatici di app.
  • Isolamento dell'ambiente e separazione dalla produzione.
  • Procedure replicabili per la configurazione dell'ambiente.

Questo tutorial è destinato a data scientist e analisti che creano job ricorrenti per l'elaborazione dei dati allo scopo di strutturare la ricerca e lo sviluppo (R&D) in modo sistematico e automatico per la gestione dei carichi di lavoro di elaborazione dati.

Architettura di deployment

In questa guida vengono utilizzati i seguenti prodotti Google Cloud:

  • Cloud Build per creare una pipeline CI/CD per la creazione, il deployment e il test di un flusso di lavoro di elaborazione dati e dell'elaborazione stessa. Cloud Build è un servizio gestito che esegue la tua build su Google Cloud. Una build è una serie di passaggi di build in cui ogni passaggio viene eseguito in un container Docker.
  • Cloud Composer per definire ed eseguire i passaggi del flusso di lavoro, ad esempio avviare l'elaborazione dei dati, testare e verificare i risultati. Cloud Composer è un servizio Apache Airflow gestito che offre un ambiente in cui è possibile creare, pianificare, monitorare e gestire flussi di lavoro complessi, come il flusso di lavoro di elaborazione dati, in questo tutorial.
  • Dataflow per eseguire l'esempio di Apache Beam WordCount come processo di dati di esempio.

La pipeline CI/CD

A livello generale, la pipeline CI/CD prevede i seguenti passaggi:

  1. Cloud Build pacchettizza l'esempio di WordCount in un file Archive (JAR) Java in esecuzione utilizzando il generatore Maven. Il builder Maven è un container in cui è installato Maven. Quando un passaggio di build è configurato per l'utilizzo del builder Maven, Maven esegue le attività.
  2. Cloud Build carica il file JAR su Cloud Storage.
  3. Cloud Build esegue test delle unità sul codice del flusso di lavoro di elaborazione dati ed esegue il deployment del codice del flusso di lavoro in Cloud Composer.
  4. Cloud Composer acquisisce il file JAR ed esegue il job di elaborazione dati su Dataflow.

Il seguente diagramma mostra una visualizzazione dettagliata dei passaggi della pipeline CI/CD.

Diagramma dell'architettura della pipeline CI/CD.

In questo tutorial, i deployment negli ambienti di test e produzione sono separati in due diverse pipeline di Cloud Build, una test e una pipeline di produzione.

Nel diagramma precedente, la pipeline di test è composta dai seguenti passaggi:

  1. Uno sviluppatore esegue il commit delle modifiche al codice in Cloud Source Repositories.
  2. Le modifiche al codice attivano una build di test in Cloud Build.
  3. Cloud Build crea il file JAR che viene eseguito automaticamente e ne esegue il deployment nel bucket JAR di test su Cloud Storage.
  4. Cloud Build esegue il deployment dei file di test nei bucket dei file di test in Cloud Storage.
  5. Cloud Build imposta la variabile in Cloud Composer per fare riferimento al file JAR di cui è stato eseguito il deployment.
  6. Cloud Build testa il flusso di lavoro di elaborazione dati Direct Acycicli Graph (DAG) e ne esegue il deployment nel bucket Cloud Composer su Cloud Storage.
  7. Il deployment del file DAG del flusso di lavoro viene eseguito in Cloud Composer.
  8. Cloud Build attiva l'esecuzione del flusso di lavoro di elaborazione dati di recente deployment.
  9. Una volta superato il test di integrazione del flusso di lavoro di elaborazione dati, viene pubblicato un messaggio in Pub/Sub che contiene un riferimento all'ultima JAR (ottenuta dalle variabili Airflow) nel campo dati del messaggio.

Nel diagramma precedente, la pipeline di produzione è composta dai seguenti passaggi:

  1. La pipeline di deployment in produzione viene attivata quando un messaggio viene pubblicato in un argomento Pub/Sub.
  2. Uno sviluppatore approva manualmente la pipeline di deployment di produzione e viene eseguita la build.
  3. Cloud Build copia l'ultimo file JAR auto-eseguibile dal bucket JAR di test al bucket JAR di produzione su Cloud Storage.
  4. Cloud Build testa il flusso di lavoro di elaborazione dei dati di produzione e ne esegue il deployment nel bucket Cloud Composer su Cloud Storage.
  5. Il deployment del file DAG del flusso di lavoro di produzione viene eseguito in Cloud Composer.

In questo tutorial, il flusso di lavoro di elaborazione dei dati di produzione viene eseguito nello stesso ambiente Cloud Composer del flusso di lavoro di test, per offrire una vista consolidata di tutti i flussi di lavoro di elaborazione dati. Ai fini di questo tutorial, gli ambienti sono separati utilizzando diversi bucket Cloud Storage per conservare i dati di input e di output.

Per separare completamente gli ambienti, sono necessari più ambienti Cloud Composer creati in progetti diversi, che sono separati per impostazione predefinita dagli altri. Questa separazione aiuta a proteggere l'ambiente di produzione. Questo approccio non rientra nell'ambito di questo tutorial. Per saperne di più su come accedere alle risorse di più progetti Google Cloud, consulta Impostazione delle autorizzazioni degli account di servizio.

Flusso di lavoro di elaborazione dati

Le istruzioni su come Cloud Composer esegue il flusso di lavoro per l'elaborazione dei dati sono definite in un grafico aciclico diretto scritto in Python. Nel DAG, tutti i passaggi del flusso di lavoro di elaborazione dati sono definiti insieme alle dipendenze tra loro.

La pipeline CI/CD esegue automaticamente il deployment della definizione DAG da Cloud Source Repositories a Cloud Composer in ogni build. Questo processo garantisce che Cloud Composer sia sempre aggiornato con la definizione del flusso di lavoro più recente senza alcun intervento umano.

Nella definizione di DAG per l'ambiente di test, viene definito un passaggio di test end-to-end oltre al flusso di lavoro di elaborazione dei dati. Il passaggio di test consente di assicurarsi che il flusso di lavoro di elaborazione dati funzioni correttamente.

Il flusso di lavoro per l'elaborazione dei dati è illustrato nel diagramma seguente.

Il flusso di lavoro di elaborazione dati in quattro fasi.

Il flusso di lavoro per l'elaborazione dei dati è costituito dai seguenti passaggi:

  1. Eseguire il processo per i dati WordCount in Dataflow.
  2. Scarica i file di output dal processo WordCount. Il processo WordCount genera tre file:

    • download_result_1
    • download_result_2
    • download_result_3
  3. Scarica il file di riferimento, chiamato download_ref_string.

  4. Verifica il risultato rispetto al file di riferimento. Questo test di integrazione aggrega tutti e tre i risultati e confronta i risultati aggregati con il file di riferimento.

  5. Pubblicare un messaggio in Pub/Sub una volta superato il test di integrazione.

L'utilizzo di un framework di orchestrazione delle attività come Cloud Composer per gestire il flusso di lavoro di elaborazione dati contribuisce ad alleviare la complessità del codice del flusso di lavoro.

I test

Oltre al test di integrazione che verifica il flusso di lavoro di elaborazione dati da un capo all'altro, in questo tutorial sono disponibili due test delle unità. I test delle unità sono test automatici sul codice per il trattamento dati e sul codice del flusso di lavoro di elaborazione dati. Il test sul codice di elaborazione dati è scritto in Java ed eseguito automaticamente durante il processo di compilazione Maven. Il test sul codice del flusso di lavoro di elaborazione dati è scritto in Python ed eseguito come un passaggio di build indipendente.

Obiettivi

  • Configurare l'ambiente Cloud Composer.
  • Creare bucket Cloud Storage per i tuoi dati.
  • Creare le pipeline di build, test e produzione.
  • Configura il trigger di build.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Abilita le API Cloud Build, Cloud Source Repositories, Cloud Composer, and Dataflow.

    Abilita le API

  5. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  7. Abilita le API Cloud Build, Cloud Source Repositories, Cloud Composer, and Dataflow.

    Abilita le API

Codice di esempio

Il codice campione è costituito da due cartelle:

  • La cartella env-setup contiene script shell per la configurazione iniziale dell'ambiente Google Cloud.
  • La cartella source-code contiene codice sviluppato nel tempo, che deve essere controllato dall'origine e attiva processi di build e test automatici. Questa cartella contiene le seguenti sottocartelle:

    • La cartella data-processing-code contiene il codice sorgente del processo Apache Beam.
    • La cartella workflow-dag contiene le definizioni del DAG del compositore per i flussi di lavoro di elaborazione dati con i passaggi per progettare, implementare e testare il processo di Dataflow.
    • La cartella build-pipeline contiene due configurazioni di Cloud Build, una per la pipeline di test e l'altra per la pipeline di produzione. Questa cartella contiene anche uno script di supporto per le pipeline.

Ai fini di questo tutorial, i file del codice sorgente per l'elaborazione dei dati e per il flusso di lavoro DAG si trovano in cartelle diverse nello stesso repository di codice sorgente. In un ambiente di produzione, i file del codice sorgente si trovano solitamente nei propri repository di codice sorgente e sono gestiti da team diversi.

Configurazione dell'ambiente

In questo tutorial, eseguirai tutti i comandi in Cloud Shell. Cloud Shell viene visualizzato come finestra nella parte inferiore della console Google Cloud.

  1. Nella console Google Cloud, apri Cloud Shell:

    Apri Cloud Shell

  2. Clona il repository del codice campione:

    git clone https://github.com/GoogleCloudPlatform/ci-cd-for-data-processing-workflow.git
    
  3. Esegui uno script per impostare le variabili di ambiente:

    cd ~/ci-cd-for-data-processing-workflow/env-setup
    source set_env.sh
    

    Lo script imposta le seguenti variabili di ambiente:

    • ID progetto Google Cloud
    • Regione e zona
    • Il nome dei bucket Cloud Storage utilizzati dalla pipeline di build e dal flusso di lavoro di elaborazione dati.

    Poiché le variabili di ambiente non vengono conservate tra le sessioni, se la sessione di Cloud Shell viene arrestata o si disconnette mentre lavori al tutorial, devi reimpostare le variabili di ambiente.

Creazione dell'ambiente Cloud Composer

In questo tutorial, imparerai a configurare un ambiente Cloud Composer.

  1. In Cloud Shell, aggiungi il ruolo Estensione agente di servizio API Cloud Composer v2 (roles/composer.ServiceAgentV2Ext) all'account agente di servizio Cloud Composer:

    gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
        --member serviceAccount:service-$PROJECT_NUMBER@cloudcomposer-accounts.iam.gserviceaccount.com \
        --role roles/composer.ServiceAgentV2Ext
    
  2. In Cloud Shell, crea l'ambiente Cloud Composer:

    gcloud composer environments create $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --image-version composer-2.0.14-airflow-2.2.5
    
  3. Esegui uno script per impostare le variabili nell'ambiente Cloud Composer. Le variabili sono necessarie per i DAG per l'elaborazione dei dati.

    cd ~/ci-cd-for-data-processing-workflow/env-setup
    chmod +x set_composer_variables.sh
    ./set_composer_variables.sh
    

    Lo script imposta le seguenti variabili di ambiente:

    • ID progetto Google Cloud
    • Regione e zona
    • Il nome dei bucket Cloud Storage utilizzati dalla pipeline di build e dal flusso di lavoro di elaborazione dati.

Estrai le proprietà dell'ambiente Cloud Composer

Cloud Composer utilizza un bucket Cloud Storage per archiviare i DAG. Lo spostamento di un file di definizione DAG nel bucket attiva Cloud Composer per la lettura automatica dei file. Hai creato il bucket Cloud Storage per Cloud Composer quando hai creato l'ambiente Cloud Composer. Nella procedura seguente, estrai l'URL per i bucket e quindi configura la pipeline CI/CD per eseguire automaticamente il deployment delle definizioni DAG nel bucket Cloud Storage.

  1. In Cloud Shell, esporta l'URL del bucket come variabile di ambiente:

    export COMPOSER_DAG_BUCKET=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.dagGcsPrefix)")
    
  2. Esporta il nome dell'account di servizio utilizzato da Cloud Composer per avere accesso ai bucket Cloud Storage:

    export COMPOSER_SERVICE_ACCOUNT=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.nodeConfig.serviceAccount)")
    

Creazione dei bucket Cloud Storage

In questa sezione creerai un insieme di bucket Cloud Storage per archiviare i seguenti:

  • Artefatti dei passaggi intermedi del processo di compilazione.
  • I file di input e di output per il flusso di lavoro di elaborazione dati.
  • La posizione temporanea per i job Dataflow per archiviare i file binari.

Per creare i bucket Cloud Storage, completa il seguente passaggio:

  • In Cloud Shell, crea bucket Cloud Storage e concedi all'account di servizio Cloud Composer l'autorizzazione per eseguire i flussi di lavoro di elaborazione dati:

    cd ~/ci-cd-for-data-processing-workflow/env-setup
    chmod +x create_buckets.sh
    ./create_buckets.sh
    

Creazione dell'argomento Pub/Sub

In questa sezione, creerai un argomento Pub/Sub per ricevere i messaggi inviati dal test di integrazione del flusso di lavoro di elaborazione dati per attivare automaticamente la pipeline di build della produzione.

  1. Nella console Google Cloud, vai alla pagina Argomenti Pub/Sub.

    Vai alla pagina Argomenti

  2. Fai clic su Crea argomento.

  3. Per configurare l'argomento:

    • In ID argomento, inserisci integration-test-complete-topic.
    • Verifica che l'opzione Aggiungi un abbonamento predefinito sia selezionata.
    • Lascia deselezionate le altre opzioni.
    • In Crittografia, seleziona Chiave di crittografia gestita da Google.
    • Fai clic su Crea argomento.

    Creare un argomento Pub/Sub.

Esegui il push del codice sorgente in Cloud Source Repositories

In questo tutorial hai un codebase che devi inserire nel controllo della versione. Il seguente passaggio mostra come viene sviluppato un codebase e come cambia nel tempo. Ogni volta che viene eseguito il push delle modifiche nel repository, viene attivata la pipeline per la creazione, il deployment e il test.

  • In Cloud Shell, esegui il push della cartella source-code in Cloud Source Repositories:

    gcloud source repos create $SOURCE_CODE_REPO
    cp -r ~/ci-cd-for-data-processing-workflow/source-code ~/$SOURCE_CODE_REPO
    cd ~/$SOURCE_CODE_REPO
    git init
    git remote add google \
        https://source.developers.google.com/p/$GCP_PROJECT_ID/r/$SOURCE_CODE_REPO
    git add .
    git commit -m 'initial commit'
    git push google master
    

    Si tratta di comandi standard per inizializzare Git in una nuova directory ed eseguire il push dei contenuti a un repository remoto.

Creazione di pipeline Cloud Build

In questa sezione, creerai le pipeline di build che creeranno, eseguiranno il deployment e testeranno il flusso di lavoro di elaborazione dei dati.

Concedi l'accesso all'account di servizio Cloud Build

Cloud Build esegue il deployment dei DAG e dei flussi di lavoro di Cloud Composer che vengono attivati quando aggiungi ulteriore accesso all'account di servizio Cloud Build. Per ulteriori informazioni sui diversi ruoli disponibili quando si lavora con Cloud Composer, consulta la documentazione sul controllo dell'accesso.

  1. In Cloud Shell, aggiungi il ruolo composer.admin all'account di servizio Cloud Build in modo che il job Cloud Build possa impostare le variabili Airflow in Cloud Composer:

    gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
        --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
        --role=roles/composer.admin
    
  2. Aggiungi il ruolo composer.worker all'account di servizio Cloud Build in modo che il job Cloud Build possa attivare il flusso di lavoro dei dati in Cloud Composer:

    gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
        --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
        --role=roles/composer.worker
    

Crea la pipeline di build e test

I passaggi della pipeline di build e test sono configurati nel file di configurazione YAML. In questo tutorial, utilizzi le immagini del builder predefinite per git, maven, gsutil e gcloud per eseguire le attività in ogni passaggio della build. Puoi utilizzare le sostituzioni delle variabili di configurazione per definire le impostazioni dell'ambiente al momento della creazione. La località del repository di codice sorgente è definita dalle sostituzioni di variabili e dalle località dei bucket Cloud Storage. La build ha bisogno di queste informazioni per eseguire il deployment del file JAR, dei file di test e della definizione di DAG.

  • In Cloud Shell, invia il file di configurazione della pipeline per creare la pipeline in Cloud Build:

    cd ~/ci-cd-for-data-processing-workflow/source-code/build-pipeline
    gcloud builds submit --config=build_deploy_test.yaml --substitutions=\
    REPO_NAME=$SOURCE_CODE_REPO,\
    _DATAFLOW_JAR_BUCKET=$DATAFLOW_JAR_BUCKET_TEST,\
    _COMPOSER_INPUT_BUCKET=$INPUT_BUCKET_TEST,\
    _COMPOSER_REF_BUCKET=$REF_BUCKET_TEST,\
    _COMPOSER_DAG_BUCKET=$COMPOSER_DAG_BUCKET,\
    _COMPOSER_ENV_NAME=$COMPOSER_ENV_NAME,\
    _COMPOSER_REGION=$COMPOSER_REGION,\
    _COMPOSER_DAG_NAME_TEST=$COMPOSER_DAG_NAME_TEST
    

    Questo comando indica a Cloud Build di eseguire una build con i seguenti passaggi:

    1. Crea ed esegui il deployment del file JAR auto-eseguito di WordCount.

      1. Controlla il codice sorgente.
      2. Compila il codice sorgente Beam di WordCount in un file JAR con esecuzione automatica.
      3. Archiviare il file JAR su Cloud Storage in cui può essere ritirato da Cloud Composer per eseguire il job di elaborazione WordCount.
    2. Eseguire il deployment e configurare il flusso di lavoro di elaborazione dati in Cloud Composer.

      1. Eseguire il test delle unità sul codice dell'operatore personalizzato utilizzato dal flusso di lavoro DAG.
      2. Esegui il deployment del file di input di test e del file di riferimento di test su Cloud Storage. Il file di input di test è l'input per il job di elaborazione di WordCount. Il file di riferimento per il test viene utilizzato come riferimento per verificare l'output del job di elaborazione di WordCount.
      3. Imposta le variabili di Cloud Composer in modo che rimandino al file JAR appena creato.
      4. Eseguire il deployment della definizione del DAG del flusso di lavoro nell'ambiente Cloud Composer.
    3. Esegui il flusso di lavoro di elaborazione dati nell'ambiente di test per attivare il flusso di lavoro di elaborazione dei test.

Verifica la pipeline di build e test

Dopo aver inviato il file della build, verifica i passaggi di build.

  1. Nella console Google Cloud, vai alla pagina Cronologia build per visualizzare un elenco di tutte le build passate e attualmente in esecuzione.

    Vai alla pagina Cronologia build

  2. Fai clic sulla build attualmente in esecuzione.

  3. Nella pagina Dettagli build, verifica che i passaggi della build corrispondano ai passaggi descritti in precedenza.

    Dettagli dei passaggi di creazione.

    Nella pagina Dettagli build, il campo Stato della build riporta Build successful al termine della build.

  4. In Cloud Shell, verifica che il file JAR di esempio di WordCount sia stato copiato nel bucket corretto:

    gsutil ls gs://$DATAFLOW_JAR_BUCKET_TEST/dataflow_deployment*.jar
    

    L'output è simile al seguente:

    gs://…-composer-dataflow-source-test/dataflow_deployment_e88be61e-50a6-4aa0-beac-38d75871757e.jar
    
  5. Ottieni l'URL dell'interfaccia web di Cloud Composer. Prendi nota dell'URL perché viene utilizzato nel passaggio successivo.

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.airflowUri)"
    
  6. Utilizza l'URL del passaggio precedente per andare all'interfaccia utente di Cloud Composer per verificare che l'esecuzione del DAG sia riuscita. Se la colonna Esecuzioni non mostra alcuna informazione, attendi qualche minuto e ricarica la pagina.

    1. Per verificare che il flusso di lavoro per l'elaborazione dei dati DAG test_word_count sia stato eseguito in deployment e che sia in modalità di esecuzione, tieni il puntatore sul cerchio verde chiaro sotto Esegui e verifica che indichi che È in esecuzione.

      Stato di elaborazione DAG in esecuzione.

    2. Per visualizzare il grafico del flusso di lavoro di elaborazione dati in esecuzione, fai clic sul cerchio verde chiaro, poi sulla pagina Esecuzioni di esecuzione, fai clic su ID Dag: test_word_count.

    3. Ricarica la pagina Visualizzazione grafico per aggiornare lo stato dell'esecuzione DAG corrente. Generalmente, il completamento del flusso di lavoro richiede dai tre ai cinque minuti. Per verificare che l'esecuzione del DAG venga completata correttamente, tieni premuto il puntatore del mouse su ogni attività per verificare che la descrizione comando indichi Stato: riuscito. L'ultima attività, denominata do_comparison, è il test di integrazione che verifica l'output del processo rispetto al file di riferimento.

  7. Una volta completato il test di integrazione, l'ultima attività, denominata publish_test_complete, pubblica un messaggio nell'argomento Pub/Sub integration-test-complete-topic, che verrà utilizzato per attivare la pipeline di build della produzione.

    1. Per verificare che il messaggio pubblicato contenga il riferimento corretto all'ultimo file JAR, possiamo estrarre il messaggio dalla sottoscrizione Pub/Sub predefinita per integration-test-complete-topic-sub.

    2. Nella console Google Cloud, vai alla pagina Abbonamenti.

      Vai alla pagina Abbonamenti

    3. Fai clic su integration-test-complete-topic-sub, seleziona la scheda Messaggio e fai clic su Pull

    4. L'output dovrebbe essere simile al seguente:

      Messaggio di prova completato.

Crea la pipeline di produzione

Una volta eseguito correttamente il flusso di lavoro di elaborazione del test, puoi promuovere la versione attuale del flusso di lavoro in produzione. Esistono diversi modi per eseguire il deployment del flusso di lavoro in produzione:

  • Manualmente.
  • Si attiva automaticamente quando tutti i test vengono superati negli ambienti di test o di gestione temporanea.
  • Attivata automaticamente da un job programmato.

In questo tutorial, imparerai ad attivare automaticamente la build di produzione quando tutti i test vengono superati nell'ambiente di test. Per ulteriori informazioni sugli approcci automatici, consulta Release Engineering.

Prima di implementare l'approccio automatizzato, devi verificare la build del deployment di produzione eseguendo un deployment manuale in produzione. La build di deployment di produzione segue questi passaggi:

  1. Copia il file JAR di WordCount dal bucket di test al bucket di produzione.
  2. Imposta le variabili Cloud Composer per il flusso di lavoro di produzione in modo che rimandino al file JAR appena promosso.
  3. Eseguire il deployment della definizione del DAG del flusso di lavoro di produzione nell'ambiente Cloud Composer ed eseguire il flusso di lavoro.

Le sostituzioni di variabili definiscono il nome dell'ultimo file JAR di cui viene eseguito il deployment in produzione con i bucket Cloud Storage utilizzati dal flusso di lavoro di elaborazione della produzione. Per creare la pipeline Cloud Build che esegue il deployment del flusso di lavoro del flusso d'aria in produzione, completa i seguenti passaggi:

  1. In Cloud Shell, leggi il nome del file JAR più recente stampando la variabile Cloud Composer per il nome file JAR:

    export DATAFLOW_JAR_FILE_LATEST=$(gcloud composer environments run $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION variables get -- \
        dataflow_jar_file_test 2>&1 | grep -i '.jar')
    
  2. Utilizza il file di configurazione della pipeline di build deploy_prod.yaml, per creare la pipeline in Cloud Build:

    cd ~/ci-cd-for-data-processing-workflow/source-code/build-pipeline
    gcloud builds submit --config=deploy_prod.yaml --substitutions=\
    REPO_NAME=$SOURCE_CODE_REPO,\
    _DATAFLOW_JAR_BUCKET_TEST=$DATAFLOW_JAR_BUCKET_TEST,\
    _DATAFLOW_JAR_FILE_LATEST=$DATAFLOW_JAR_FILE_LATEST,\
    _DATAFLOW_JAR_BUCKET_PROD=$DATAFLOW_JAR_BUCKET_PROD,\
    _COMPOSER_INPUT_BUCKET=$INPUT_BUCKET_PROD,\
    _COMPOSER_ENV_NAME=$COMPOSER_ENV_NAME,\
    _COMPOSER_REGION=$COMPOSER_REGION,\
    _COMPOSER_DAG_BUCKET=$COMPOSER_DAG_BUCKET,\
    _COMPOSER_DAG_NAME_PROD=$COMPOSER_DAG_NAME_PROD
    

Verifica il flusso di lavoro di elaborazione dati creato dalla pipeline di produzione

  1. Ottieni l'URL per la tua UI di Cloud Composer:

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.airflowUri)"
    
  2. Per verificare che sia stato eseguito il deployment del DAG del flusso di lavoro di elaborazione dei dati di produzione, vai all'URL recuperato nel passaggio precedente e verifica che il DAG prod_word_count sia nell'elenco dei DAG.

    1. Nella pagina DAG, nella riga prod_word_count, fai clic su Attiva DAG.

      Icona Riproduci per attivare il DAG.

  3. Fai clic sul logo Airflow o ricarica la pagina per aggiornare lo stato di esecuzione di DAG. Un cerchio verde chiaro nella colonna Esecuzioni indica che il DAG è attualmente in esecuzione. Tieni il puntatore sul cerchio per vedere la descrizione comando "In esecuzione".

    Il DAG esegue lo stato dell'esecuzione.

  4. Una volta completata l'esecuzione, tieni il puntatore sul cerchio verde scuro sotto la colonna DAG run e verifica che sia visualizzato Success.

    Stato di esecuzione di DAG riuscito.

  5. In Cloud Shell, elenca i file di risultati nel bucket Cloud Storage:

    gsutil ls gs://$RESULT_BUCKET_PROD
    

    L'output è simile al seguente:

    gs://…-composer-result-prod/output-00000-of-00003
    gs://…-composer-result-prod/output-00001-of-00003
    gs://…-composer-result-prod/output-00002-of-00003
    

Creazione di trigger di Cloud Build

In questa sezione creerai i trigger di Cloud Build che collegano le modifiche al codice sorgente al processo di compilazione del test e tra la pipeline di test e la pipeline di build della produzione.

Configura il trigger della pipeline di build di test

Configura un trigger Cloud Build che attiva una nuova build quando viene eseguito il push delle modifiche nel ramo master del repository di origine.

  1. Nella console Google Cloud, vai alla pagina Trigger di build.

    Vai alla pagina Trigger di build.

  2. Fai clic su Crea trigger.

  3. Per configurare le impostazioni di attivazione, procedi nel seguente modo:

    • Nel campo Nome, inserisci trigger-build-in-test-environment.
    • Nel menu a discesa Regione, seleziona globale (non a livello di regione).
    • In Evento, fai clic su Push al ramo.
    • In Origine, seleziona data-pipeline-source.
    • Nel campo Nome filiale, inserisci master.
    • In Configurazione, fai clic su File di configurazione Cloud Build (yaml o json).
    • In Località, fai clic su Repository.
    • Nel campo Posizione file di configurazione Cloud Build, inserisci build-pipeline/build_deploy_test.yaml.
  4. In Cloud Shell, esegui questo comando per ottenere tutte le variabili di sostituzione necessarie per la build. Prendi nota di questi valori perché sono necessari in un passaggio successivo.

    echo "_COMPOSER_DAG_BUCKET : ${COMPOSER_DAG_BUCKET}
    _COMPOSER_DAG_NAME_TEST : ${COMPOSER_DAG_NAME_TEST}
    _COMPOSER_ENV_NAME : ${COMPOSER_ENV_NAME}
    _COMPOSER_INPUT_BUCKET : ${INPUT_BUCKET_TEST}
    _COMPOSER_REF_BUCKET : ${REF_BUCKET_TEST}
    _COMPOSER_REGION : ${COMPOSER_REGION}
    _DATAFLOW_JAR_BUCKET : ${DATAFLOW_JAR_BUCKET_TEST}"
    

    Nota: la coppia nome/valore di output viene utilizzata per il passaggio successivo

  5. Nella pagina Impostazioni trigger, in Avanzate, Variabili di sostituzione, sostituisci le variabili con valori dell'ambiente ottenuti dal passaggio precedente. Aggiungi quello seguente alla volta e fai clic su + Aggiungi elemento per ciascuna coppia nome-valore.

    • _COMPOSER_DAG_BUCKET
    • _COMPOSER_DAG_NAME_TEST
    • _COMPOSER_ENV_NAME
    • _COMPOSER_INPUT_BUCKET
    • _COMPOSER_REF_BUCKET
    • _COMPOSER_REGION
    • _DATAFLOW_JAR_BUCKET

      Mappatura delle coppie nome-valore.

  6. Fai clic su Crea.

Configurazione del trigger della pipeline di build di produzione

Configura un trigger di Cloud Build che attiva una build di produzione quando i test sono stati superati nell'ambiente di test e viene pubblicato un messaggio nell'argomento Pub/Sub tests-complete. Questo trigger include un passaggio di approvazione in cui la build deve essere approvata manualmente prima dell'esecuzione della pipeline di produzione.

  1. Nella console Google Cloud, vai alla pagina Trigger di build.

    Vai alla pagina Trigger di build.

  2. Fai clic su Crea trigger.

  3. Per configurare le impostazioni di attivazione, procedi nel seguente modo:

    • Nel campo Nome, inserisci trigger-build-in-prod-environment.
    • Nel menu a discesa Regione, seleziona globale (non a livello di regione).
    • Per Evento, fai clic su Messaggio Pub/Sub.
    • Per Abbonamento, seleziona integration-test-complete-topic.
    • In Origine, seleziona data-pipeline-source.
    • In Revisione, seleziona Ramo.
    • Nel campo Nome filiale, inserisci master.
    • In Configurazione, fai clic su File di configurazione Cloud Build (yaml o json).
    • In Località, fai clic su Repository.
    • Nel campo Posizione file di configurazione Cloud Build, inserisci build-pipeline/deploy_prod.yaml.
  4. In Cloud Shell, esegui questo comando per ottenere tutte le variabili di sostituzione necessarie per la build. Prendi nota di questi valori perché sono necessari in un passaggio successivo.

    echo "_COMPOSER_DAG_BUCKET : ${COMPOSER_DAG_BUCKET}
    _COMPOSER_DAG_NAME_PROD : ${COMPOSER_DAG_NAME_PROD}
    _COMPOSER_ENV_NAME : ${COMPOSER_ENV_NAME}
    _COMPOSER_INPUT_BUCKET : ${INPUT_BUCKET_PROD}
    _COMPOSER_REGION : ${COMPOSER_REGION}
    _DATAFLOW_JAR_BUCKET_PROD : ${DATAFLOW_JAR_BUCKET_PROD}
    _DATAFLOW_JAR_BUCKET_TEST : ${DATAFLOW_JAR_BUCKET_TEST}"
    

    Nota: la coppia nome/valore di output viene utilizzata per il passaggio successivo

  5. Nella pagina Impostazioni trigger, in Avanzate, Variabili di sostituzione, sostituisci le variabili con valori dell'ambiente ottenuti dal passaggio precedente. Aggiungi quello seguente alla volta e fai clic su + Aggiungi elemento per ciascuna coppia nome-valore.

    • _COMPOSER_DAG_BUCKET
    • _COMPOSER_DAG_NAME_PROD
    • _COMPOSER_ENV_NAME
    • _COMPOSER_INPUT_BUCKET
    • _COMPOSER_REGION
    • _DATAFLOW_JAR_BUCKET_PROD
    • _DATAFLOW_JAR_BUCKET_TEST
    • _DATAFLOW_JAR_FILE_LATEST = $(body.message.data)

      Mappatura delle coppie nome-valore.

  6. In Approvazione, seleziona Richiedi approvazione prima dell'esecuzione della build.

  7. Fai clic su Crea.

Testa gli attivatori

Per testare il trigger, aggiungi una nuova parola al file di input di test e apporta la modifica corrispondente al file di riferimento per il test. Verifica che la pipeline di build venga attivata da un commit di Cloud Source Repositories e che il flusso di lavoro di elaborazione dei dati venga eseguito correttamente con i file di test aggiornati.

  1. In Cloud Shell, aggiungi una parola di test alla fine del file di test:

    echo "testword" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/input.txt
    
  2. Aggiorna il file di riferimento dei risultati del test, ref.txt, in modo che corrisponda alle modifiche apportate nel file di input di test:

    echo "testword: 1" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/ref.txt
    
  3. Esegui il commit e il push delle modifiche in Cloud Source Repositories:

    cd ~/$SOURCE_CODE_REPO
    git add .
    git commit -m 'change in test files'
    git push google master
    
  4. Nella console Google Cloud, vai alla pagina Cronologia.

    VAI ALLA PAGINA CRONOLOGIA

  5. Per verificare che una nuova build di test venga attivata dal push al ramo master precedente, nella build in esecuzione, la colonna Ref indica master.

  6. In Cloud Shell, recupera l'URL per la tua interfaccia web di Cloud Composer:

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION --format="get(config.airflowUri)"
    
  7. Al termine della build, vai all'URL del comando precedente per verificare che il DAG test_word_count sia in esecuzione.

    Attendi il completamento dell'esecuzione del DAG, che viene indicata quando il cerchio verde chiaro nella colonna Esecuzione di DAG scompare. Di solito, il processo richiede dai tre ai cinque minuti.

  8. In Cloud Shell, scarica i file dei risultati del test:

    mkdir ~/result-download
    cd ~/result-download
    gsutil cp gs://$RESULT_BUCKET_TEST/output* .
    
  9. Verifica che la parola appena aggiunta sia in uno dei file dei risultati:

    grep testword output*
    

    L'output è simile al seguente:

    output-00000-of-00003:testword: 1
    
  10. Nella console Google Cloud, vai alla pagina Cronologia.

    Vai alla pagina Cronologia

  11. Verifica che una nuova build di produzione sia stata attivata dal completamento del test di integrazione e che la build sia in attesa di approvazione.

    Build di produzione attivata.

  12. Seleziona la casella accanto alla build, fai clic su Approva e fai clic su Approva nella casella di conferma per eseguire la pipeline di produzione.

  13. Al termine della build, vai all'URL del comando precedente e attiva manualmente il DAG prod_word_count per eseguire la pipeline di produzione.

    Icona Riproduci per attivare il DAG.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminare le singole risorse

Se vuoi mantenere il progetto utilizzato per questo tutorial, esegui questi passaggi per eliminare le risorse che hai creato in questo tutorial.

  1. Per eliminare il trigger di Cloud Build, completa questi passaggi:

    1. Nella console Google Cloud, vai alla pagina Trigger.

      Vai alla pagina Attivatori

    2. Accanto agli attivatori che hai creato, fai clic su Altro e poi su Elimina.

  2. In Cloud Shell, elimina l'ambiente Cloud Composer:

    gcloud -q composer environments delete $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION
    
  3. Elimina i bucket Cloud Storage e i relativi file:

    gsutil -m rm -r gs://$DATAFLOW_JAR_BUCKET_TEST \
        gs://$INPUT_BUCKET_TEST \
        gs://$REF_BUCKET_TEST \
        gs://$RESULT_BUCKET_TEST \
        gs://$DATAFLOW_STAGING_BUCKET_TEST \
        gs://$DATAFLOW_JAR_BUCKET_PROD \
        gs://$INPUT_BUCKET_PROD \
        gs://$RESULT_BUCKET_PROD \
        gs://$DATAFLOW_STAGING_BUCKET_PROD
    
  4. Per eliminare l'argomento Pub/Sub e la sottoscrizione predefinita, esegui questi comandi in Cloud Shell:

    gcloud pubsub topics delete integration-test-complete-topic
    gcloud pubsub subscriptions delete integration-test-complete-topic-sub
    
  5. Elimina il repository:

    gcloud -q source repos delete $SOURCE_CODE_REPO
    
  6. Elimina i file e la cartella che hai creato:

    rm -rf ~/ci-cd-for-data-processing-workflow
    rm -rf ~/$SOURCE_CODE_REPO
    rm -rf ~/result-download
    

Passaggi successivi