Esegui il deployment di una pipeline CI/CD per i flussi di lavoro di elaborazione dati

Last reviewed 2023-05-12 UTC

Questo documento descrive come eseguire il deployment dell'architettura in Utilizzare una pipeline CI/CD per i flussi di lavoro di elaborazione dati.

Questo deployment è destinato a data scientist e analisti che creano job di elaborazione dati in esecuzione ricorrente per strutturare la ricerca e lo sviluppo in modo da gestire sistematicamente e automaticamente i carichi di lavoro di elaborazione dati.

Data scientist e analisti possono adattare le metodologie dalle pratiche CI/CD per contribuire 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 delle app.
Isolamento e separazione dell'ambiente dalla produzione.
Procedure replicabili per la configurazione dell'ambiente.

Architettura

Il seguente diagramma mostra una visualizzazione dettagliata dei passaggi della pipeline CI/CD sia per la pipeline di test che per la pipeline di produzione.

Diagramma dell'architettura della pipeline CI/CD.

Nel diagramma precedente, la pipeline di test inizia quando uno sviluppatore esegue il commit delle modifiche del codice in Cloud Source Repositories e termina quando viene superato il test di integrazione del flusso di lavoro di elaborazione dati. A quel punto, la pipeline pubblica in Pub/Sub un messaggio contenente un riferimento all'ultimo file JAR (Java Archive) a esecuzione automatica (ottenuto dalle variabili Airflow) nel campo dei dati del messaggio.

Nel diagramma precedente, la pipeline di produzione inizia quando viene pubblicato un messaggio in un argomento Pub/Sub e termina quando viene eseguito il deployment del file DAG del flusso di lavoro di produzione in Cloud Composer.

In questa guida al deployment utilizzerai i seguenti prodotti Google Cloud:

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

Obiettivi

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

Ottimizzazione dei costi

In questo documento utilizzerai i seguenti componenti fatturabili di Google Cloud:

Prima di iniziare

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

Nota: se non prevedi di conservare le risorse che crei in questo deployment, crea un progetto anziché selezionarne uno esistente. Dopo aver completato il deployment, puoi eliminare il progetto per rimuovere tutte le risorse associate.

Vai al selettore progetti
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.

Codice di esempio

Il codice campione per questo deployment si trova in 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, deve essere controllato dal codice sorgente e attiva processi automatici di compilazione e test. 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 dei DAG del compositore per i flussi di lavoro di elaborazione dati con i passaggi per progettare, implementare e testare il processo 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.

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

Test di integrazione e unità

Oltre al test di integrazione che verifica il flusso di lavoro di elaborazione dati dall'inizio alla fine, questo deployment prevede due test delle unità. I test delle unità sono test automatici sul codice di elaborazione dati e sul codice del flusso di lavoro di elaborazione dati. Il test sul codice di elaborazione dati è scritto in Java e viene eseguito automaticamente durante il processo di compilazione Maven. Il test sul codice del flusso di lavoro di elaborazione dati è scritto in Python e viene eseguito come passaggio di build indipendente.

configura l'ambiente

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

Nella console Google Cloud, apri Cloud Shell:

Apri Cloud Shell

Clona il repository del codice campione:

git clone https://github.com/GoogleCloudPlatform/ci-cd-for-data-processing-workflow.git

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:
- L'ID del tuo progetto Google Cloud
- La tua regione e la tua 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 una sessione e l'altra, se la sessione di Cloud Shell si arresta o si disconnette durante l'esecuzione di questo deployment, devi reimpostare le variabili di ambiente.

Crea l'ambiente Cloud Composer

In questo deployment, configurerai un ambiente Cloud Composer.

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

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
```
Nota: il provisioning dell'ambiente Cloud Composer richiede in genere circa 15 minuti, ma in alcuni casi può essere necessaria fino a un'ora. Attendi il completamento del processo prima di continuare.
Esegui uno script per impostare le variabili nell'ambiente Cloud Composer. Le variabili sono necessarie per i DAG di elaborazione 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:
- L'ID del tuo progetto Google Cloud
- La tua regione e la tua 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 a leggere automaticamente i 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, quindi configurerai la pipeline CI/CD per eseguire automaticamente il deployment delle definizioni DAG nel bucket Cloud Storage.

In Cloud Shell, esporta l'URL per il bucket come variabile di ambiente:

export COMPOSER_DAG_BUCKET=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
    --location $COMPOSER_REGION \
    --format="get(config.dagGcsPrefix)")

Esporta il nome dell'account di servizio utilizzato da Cloud Composer per accedere ai bucket Cloud Storage:

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

Crea i bucket Cloud Storage

In questa sezione creerai un insieme di bucket Cloud Storage per archiviare quanto segue:

Artefatti dei passaggi intermedi del processo di compilazione.
I file di input e di output del flusso di lavoro di elaborazione dati.
La posizione temporanea per l'archiviazione dei file binari dei job Dataflow.

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

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
```

Crea l'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 in modo da attivare automaticamente la pipeline di build di produzione.

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

Vai alla pagina Argomenti
Fai clic su Crea argomento.
Per configurare l'argomento, completa i seguenti passaggi:
- Per ID argomento, inserisci integration-test-complete-topic.
- Verifica che l'opzione Aggiungi un abbonamento predefinito sia selezionata.
- Lascia chiare le opzioni rimanenti.
- Per Crittografia, seleziona Chiave di crittografia gestita da Google.
- Fai clic su Crea argomento.

Esegui il push del codice sorgente in Cloud Source Repositories

In questo deployment, hai un codebase sorgente che devi inserire nel controllo della versione. Il passaggio seguente mostra come viene sviluppato un codebase e cambia nel tempo. Ogni volta che viene eseguito il push delle modifiche al 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

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

Crea pipeline di Cloud Build

In questa sezione creerai le pipeline di build che creano, eseguono il deployment e testano il flusso di lavoro di elaborazione dati.

Concedi l'accesso all'account di servizio Cloud Build

Cloud Build esegue il deployment dei DAG di Cloud Composer e attiva flussi di lavoro, 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 di controllo dell'accesso.

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
```

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 creazione e test sono configurati nel file di configurazione YAML. In questo deployment, utilizzerai immagini del builder predefinite per git, maven, gsutil e gcloud per eseguire le attività in ogni passaggio di build. Puoi utilizzare le sostituzioni delle variabili di configurazione per definire le impostazioni dell'ambiente in fase di creazione. La località del repository del codice sorgente è definita dalle sostituzioni delle 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 del DAG.

In Cloud Shell, invia il file di configurazione della pipeline di compilazione 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 con esecuzione automatica di WordCount.
  1. Controlla il codice sorgente.
  2. Compila il codice sorgente WordCount Beam in un file JAR a esecuzione automatica.
  3. Archivia il file JAR su Cloud Storage, dove può essere recuperato da Cloud Composer per eseguire il job di elaborazione WordCount.
2. Esegui il deployment e configura il flusso di lavoro di elaborazione dati su Cloud Composer.
  1. Esegui 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 del test in Cloud Storage. Il file di input di test è l'input del job di elaborazione di WordPress. Il file di riferimento di test viene utilizzato come riferimento per verificare l'output del job di elaborazione del conteggio di parole.
  3. Imposta le variabili di Cloud Composer in modo che rimandino al file JAR appena creato.
  4. Esegui il deployment della definizione del DAG del flusso di lavoro nell'ambiente Cloud Composer.
3. Per attivare il flusso di lavoro di elaborazione dei test, eseguilo nell'ambiente di test.

Verifica la pipeline di build e test

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

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
Fai clic sulla build in esecuzione.
Nella pagina Dettagli build, verifica che i passaggi di build corrispondano a quelli descritti in precedenza.

Nella pagina Dettagli build, al termine della build viene indicato il valore Build successful nel campo Stato.

In Cloud Shell, verifica che il file JAR di esempio 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

Recupera l'URL dell'interfaccia web di Cloud Composer. Prendi nota dell'URL perché verrà utilizzato nel passaggio successivo.

gcloud composer environments describe $COMPOSER_ENV_NAME \
    --location $COMPOSER_REGION \
    --format="get(config.airflowUri)"

Utilizza l'URL del passaggio precedente per accedere all'interfaccia utente di Cloud Composer e verificare un'esecuzione di DAG riuscita. Se la colonna Esecuzioni non mostra informazioni, attendi qualche minuto e ricarica la pagina.
1. Per verificare che sia stato eseguito il deployment del DAG del flusso di lavoro di elaborazione dati test_word_count e che sia in modalità di esecuzione, tieni il puntatore sul cerchio verde chiaro accanto a Esegui e verifica che il messaggio sia In esecuzione.
2. Per visualizzare il flusso di lavoro di elaborazione dati in esecuzione sotto forma di grafico, fai clic sul cerchio verde chiaro, quindi nella pagina Esecuzioni Dag fai clic su ID dati: test_word_count.
3. Ricarica la pagina Visualizzazione grafico per aggiornare lo stato dell'esecuzione del DAG corrente. Il completamento del flusso di lavoro richiede in genere da 3 a 5 minuti. Per verificare che l'esecuzione di DAG sia terminata correttamente, tieni il puntatore sopra ogni attività per verificare che la descrizione comando riporti Stato: operazione riuscita. La penultima attività, denominata do_comparison, è il test di integrazione che verifica l'output del processo rispetto al file di riferimento.
Una volta completato il test di integrazione, l'ultima attività denominata publish_test_complete pubblica un messaggio nell'argomento integration-test-complete-topic Pub/Sub, che verrà utilizzato per attivare la pipeline di build di produzione.
1. Per verificare che il messaggio pubblicato contenga il riferimento corretto all'ultimo file JAR, possiamo eseguire il pull del messaggio dalla sottoscrizione predefinita Pub/Sub 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:

Crea la pipeline di produzione

Quando il flusso di lavoro di elaborazione dei test viene eseguito correttamente, puoi promuovere la versione corrente 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.
Attivato automaticamente da un job pianificato.

In questo deployment, attivi automaticamente la build di produzione quando tutti i test vengono superati nell'ambiente di test. Per ulteriori informazioni sugli approcci automatizzati, consulta la pagina Progettazione del rilascio.

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

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

Le sostituzioni delle 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 di Cloud Build che esegue il deployment del flusso di lavoro airflow di produzione, completa i seguenti passaggi:

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')

Utilizza il file di configurazione della pipeline di compilazione, 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

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

Ottieni l'URL della tua UI di Cloud Composer:

gcloud composer environments describe $COMPOSER_ENV_NAME \
    --location $COMPOSER_REGION \
    --format="get(config.airflowUri)"

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.
Per aggiornare lo stato dell'esecuzione del DAG, fai clic sul logo Airflow o ricarica la pagina. Un cerchio verde chiaro nella colonna Esecuzioni indica che il DAG è in esecuzione.
Al termine dell'esecuzione, tieni il puntatore sul cerchio verde scuro vicino alla colonna Esecuzioni DAG e verifica che l'indicazione sia Operazione riuscita.

In Cloud Shell, elenca i file dei 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

crea trigger di Cloud Build

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

Configura il trigger della pipeline di build di test

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

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

Vai alla pagina Trigger di build
Fai clic su Crea trigger.
Per configurare le impostazioni dell'attivatore, completa i seguenti passaggi:
- Nel campo Nome, inserisci trigger-build-in-test-environment.
- Nel menu a discesa Regione, seleziona globale (non a livello di regione).
- Per Evento, fai clic su Push a un ramo.
- In Origine, seleziona data-pipeline-source.
- Nel campo Nome ramo, inserisci master.
- In Configurazione, fai clic su File di configurazione di Cloud Build (yaml o json).
- In Posizione, fai clic su Repository.
- Nel campo Posizione file di configurazione di Cloud Build, inserisci build-pipeline/build_deploy_test.yaml.

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

Nella pagina Impostazioni attivatore, in Avanzate, Variabili di sostituzione, sostituisci le variabili con i valori del tuo ambiente ottenuti nel passaggio precedente. Aggiungi il seguente elemento alla volta e fai clic su + Aggiungi elemento per ogni coppia nome-valore.
- _COMPOSER_DAG_BUCKET
- _COMPOSER_DAG_NAME_TEST
- _COMPOSER_ENV_NAME
- _COMPOSER_INPUT_BUCKET
- _COMPOSER_REF_BUCKET
- _COMPOSER_REGION
- _DATAFLOW_JAR_BUCKET
Fai clic su Crea.

Configura il trigger della pipeline di build di produzione

Puoi configurare 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 una fase di approvazione in cui la build deve essere approvata manualmente prima dell'esecuzione della pipeline di produzione.

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

Vai alla pagina Trigger di build
Fai clic su Crea trigger.
Per configurare le impostazioni dell'attivatore, completa i seguenti passaggi:
- Nel campo Nome, inserisci trigger-build-in-prod-environment.
- Nel menu a discesa Regione, seleziona globale (non a livello di regione).
- In Evento, fai clic su Messaggio Pub/Sub.
- In Abbonamento, seleziona integration-test-complete-topic.
- In Origine, seleziona data-pipeline-source.
- In Revisione, seleziona Ramo.
- Nel campo Nome ramo, inserisci master.
- In Configurazione, fai clic su File di configurazione di Cloud Build (yaml o json).
- In Posizione, fai clic su Repository.
- Nel campo Posizione file di configurazione di Cloud Build, inserisci build-pipeline/deploy_prod.yaml.

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

Nella pagina Impostazioni attivatore, in Avanzate, Variabili di sostituzione, sostituisci le variabili con i valori del tuo ambiente ottenuti nel passaggio precedente. Aggiungi il seguente elemento alla volta e fai clic su + Aggiungi elemento per ogni 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)
In Approvazione, seleziona Richiedi approvazione prima dell'esecuzione della build.
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 del test. Puoi verificare che la pipeline di build venga attivata da un push del commit in Cloud Source Repositories e che il flusso di lavoro di elaborazione dati venga eseguito correttamente con i file di test aggiornati.

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

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

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

Nella console Google Cloud, vai alla pagina Cronologia.

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

In Cloud Shell, recupera l'URL dell'interfaccia web di Cloud Composer:

gcloud composer environments describe $COMPOSER_ENV_NAME \
    --location $COMPOSER_REGION --format="get(config.airflowUri)"

Al termine della build, vai all'URL del comando precedente per verificare che il DAG test_word_count sia in esecuzione.

Attendi il termine dell'esecuzione dei DAG, a indicare quando il cerchio verde chiaro nella colonna Esecuzioni DAG scompare. Il completamento del processo richiede in genere 3-5 minuti.

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

mkdir ~/result-download
cd ~/result-download
gsutil cp gs://$RESULT_BUCKET_TEST/output* .

Verifica che la parola appena aggiunta sia presente in uno dei file dei risultati:
```
grep testword output*
```
L'output è simile al seguente:
```
output-00000-of-00003:testword: 1
```
Nella console Google Cloud, vai alla pagina Cronologia.

Vai alla pagina Cronologia
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.
Per eseguire la pipeline di build di produzione, seleziona la casella di controllo accanto alla build, fai clic su Approva, quindi su Approva nella casella di conferma.
Al termine della build, vai all'URL del comando precedente e attiva manualmente il DAG prod_word_count per eseguire la pipeline di produzione.

Esegui la pulizia

Le sezioni seguenti spiegano come evitare addebiti futuri per il progetto Google Cloud e per le risorse Apache Hive e Dataproc che hai utilizzato in questo deployment.

Elimina il progetto Google Cloud

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo deployment, puoi eliminare il progetto Google Cloud.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le singole risorse

Se vuoi mantenere il progetto utilizzato per questo deployment, esegui i passaggi seguenti per eliminare le risorse che hai creato.

Per eliminare il trigger di Cloud Build, completa i seguenti passaggi:
1. Nella console Google Cloud, vai alla pagina Attivatori.
  
  Vai alla pagina Attivatori
2. Accanto agli attivatori che hai creato, fai clic su Altro e poi su Elimina.

In Cloud Shell, elimina l'ambiente Cloud Composer:

gcloud -q composer environments delete $COMPOSER_ENV_NAME \
    --location $COMPOSER_REGION

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

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

Elimina il repository:

gcloud -q source repos delete $SOURCE_CODE_REPO

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

Scopri di più sulla distribuzione continua in stile GitOps con Cloud Build.
Scopri come utilizzare una pipeline CI/CD per i flussi di lavoro di elaborazione dati.
Scopri di più sui pattern di casi d'uso comuni di Dataflow.
Scopri di più sulla Progettazione del rilascio.
Per ulteriori architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.