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.
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.
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.
- La cartella
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:
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
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.
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.
- Per ID argomento, inserisci
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:
Crea ed esegui il deployment del file JAR con esecuzione automatica di WordCount.
- Controlla il codice sorgente.
- Compila il codice sorgente WordCount Beam in un file JAR a esecuzione automatica.
- Archivia il file JAR su Cloud Storage, dove può essere recuperato da Cloud Composer per eseguire il job di elaborazione WordCount.
Esegui il deployment e configura il flusso di lavoro di elaborazione dati su Cloud Composer.
- Esegui il test delle unità sul codice dell'operatore personalizzato utilizzato dal flusso di lavoro DAG.
- 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.
- Imposta le variabili di Cloud Composer in modo che rimandino al file JAR appena creato.
- Esegui il deployment della definizione del DAG del flusso di lavoro nell'ambiente Cloud Composer.
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.
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.
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.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
.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'argomentointegration-test-complete-topic
Pub/Sub, che verrà utilizzato per attivare la pipeline di build di produzione.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
.Nella console Google Cloud, vai alla pagina Abbonamenti.
Fai clic su integration-test-complete-topic-sub, seleziona la scheda Messaggio e fai clic su Pull
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.- Nella pagina DAG, nella riga
prod_word_count
, fai clic su Attiva DAG.
- Nella pagina DAG, nella riga
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.
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
.
- Nel campo Nome, inserisci
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.
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
.
- Nel campo Nome, inserisci
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.
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.
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.
- Nella console Google Cloud, vai alla pagina 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:
Nella console Google Cloud, vai alla pagina Attivatori.
Accanto agli attivatori che hai creato, fai clic su Altromore_vert 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.