CI/CD-Pipeline für Ihren Datenverarbeitungsworkflow einrichten

In dieser Anleitung wird beschrieben, wie Sie mit verwalteten Produkten auf Google Cloud durch Implementierung von Methoden zur kontinuierlichen Integration und kontinuierlichen Bereitstellung (Continuous Integration/Continuous Delivery, CI/CD) eine CI/CD-Pipeline für die Datenverarbeitung einrichten. Data Scientists und Datenanalysten können die Methoden der CI/CD-Verfahren anpassen, um eine hohe Qualität, Wartbarkeit und Anpassungsfähigkeit der Datenprozesse und Workflows sicherzustellen. Sie können folgende Methoden anwenden:

  • Versionskontrolle des Quellcodes.
  • Automatisches Erstellen, Testen und Bereitstellen von Anwendungen.
  • Isolation der Umgebung und Abgrenzung von der Produktion.
  • Replizierbare Verfahren zur Einrichtung der Umgebung.

Diese Anleitung richtet sich an Data Scientists und Datenanalysten, die Datenverarbeitungsjobs zur periodischen Ausführung erstellen, um ihre Forschung und Entwicklung (F&E) so zu strukturieren, dass Arbeitslasten im Rahmen der Datenverarbeitung systematisch und automatisch verwaltet werden.

Bereitstellungsarchitektur

In dieser Anleitung verwenden Sie die folgenden Google Cloud-Produkte:

  • Cloud Build zur Einrichtung einer CI/CD-Pipeline zum Erstellen, Bereitstellen und Testen eines Datenverarbeitungsworkflows sowie der Datenverarbeitung selbst. Cloud Build ist ein verwalteter Dienst, mit dem Ihr Build auf Google Cloud ausgeführt wird. Ein Build setzt sich aus einer Reihe von Build-Schritten zusammen, die jeweils in einem Docker-Container ausgeführt werden.
  • Cloud Composer zum Definieren und Ausführen der Workflowschritte, z. B. Starten der Datenverarbeitung, Testen und Überprüfen der Ergebnisse. Cloud Composer ist ein verwalteter Apache Airflow-Dienst, der eine Umgebung bereitstellt, in der Sie komplexe Workflows erstellen, planen, überwachen und verwalten können, z. B. den Datenverarbeitungsworkflow in dieser Anleitung.
  • Dataflow zum Ausführen des WordCount-Beispiels für Apache Beam zur Veranschaulichung eines Datenprozesses.

CI/CD-Pipeline

Im Großen und Ganzen setzt sich die CI/CD-Pipeline aus den folgenden Schritten zusammen:

  1. Cloud Build verpackt das WordCount-Beispiel mithilfe des Maven-Builders in einer selbstausführenden Java Archive(JAR)-Datei. Der Maven-Builder ist ein Container, in dem Maven installiert ist. Wenn ein Build-Schritt für die Verwendung des Maven-Builders konfiguriert ist, werden die Aufgaben von Maven ausgeführt.
  2. Cloud Build lädt die JAR-Datei in Cloud Storage hoch.
  3. Cloud Build führt für den Code des Datenverarbeitungsworkflows Einheitentests aus und stellt den Workflowcode für Cloud Composer bereit.
  4. Cloud Composer ruft die JAR-Datei ab und führt den Datenverarbeitungsjob in Dataflow aus.

Im folgenden Diagramm sind die Schritte der CI/CD-Pipeline ausführlich dargestellt:

Architekturdiagramm der CI/CD-Pipeline

In dieser Anleitung werden die Bereitstellungen für die Test- und Produktionsumgebung in zwei verschiedene Cloud Build-Pipelines unterteilt – eine Test- und eine Produktionspipeline.

Die Testpipeline im vorangegangenen Diagramm setzt sich aus den folgenden Schritten zusammen:

  1. Ein Entwickler übergibt Änderungen am Code an Cloud Source Repositories.
  2. Die Änderungen lösen in Cloud Build einen Test-Build aus.
  3. Cloud Build erstellt die selbstausführende JAR-Datei und stellt sie im JAR-Test-Bucket in Cloud Storage bereit.
  4. Cloud Build stellt die Testdateien in den Testdatei-Buckets in Cloud Storage bereit.
  5. Cloud Build stellt die Variable in Cloud Composer so ein, dass sie auf die neu bereitgestellte JAR-Datei verweist.
  6. Cloud Build testet den gerichteten azyklischen Graphen (Directed Acyclic Graph, DAG) für den Datenverarbeitungsworkflow und stellt ihn im Cloud Composer-Bucket in Cloud Storage bereit.
  7. Die Workflow-DAG-Datei wird in Cloud Composer bereitgestellt.
  8. Cloud Build löst den neu bereitgestellten Datenverarbeitungsworkflow aus.

Die Produktionspipeline im vorangegangenen Diagramm setzt sich aus den folgenden Schritten zusammen:

  1. Ein Entwickler führt die Pipeline für die Produktionsbereitstellung manuell in Cloud Build aus.
  2. Cloud Build kopiert die neueste selbstausführende JAR-Datei aus dem JAR-Test-Bucket in den JAR-Produktions-Bucket in Cloud Storage.
  3. Cloud Build testet den Produktionsdatenverarbeitungs-Workflow-DAG und stellt ihn im Cloud Composer-Bucket in Cloud Storage bereit.
  4. Die Produktionsworkflow-DAG-Datei wird in Cloud Composer bereitgestellt.

In dieser Anleitung wird der Produktionsdatenverarbeitungs-Workflow in derselben Cloud Composer-Umgebung wie der Testworkflow bereitgestellt, um eine konsolidierte Ansicht aller Datenverarbeitungsworkflows zu erhalten. Für die Zwecke dieser Anleitung werden die Umgebungen mithilfe verschiedener Cloud Storage-Buckets getrennt, in denen die Eingabe- und Ausgabedaten abgelegt werden.

Zur vollständigen Trennung der Umgebungen müssen in verschiedenen Projekten mehrere Cloud Composer-Umgebungen erstellt werden, die standardmäßig voneinander getrennt sind. Diese Trennung trägt zum Schutz der Produktionsumgebung bei. Dieser Ansatz wird in dieser Anleitung nicht weiter erörtert. Weitere Informationen zum Zugriff auf Ressourcen in mehreren Google Cloud-Projekten finden Sie unter Dienstkontoberechtigungen festlegen.

Datenverarbeitungsworkflow

Die Anleitung zum Ausführen des Datenverarbeitungsworkflows in Cloud Composer ist in einem in Python geschriebenen gerichteten azyklischen Graphen (Directed Acyclic Graph, DAG) definiert. Im DAG werden alle Schritte des Datenverarbeitungsworkflows zusammen mit ihren jeweiligen Abhängigkeiten untereinander definiert.

Die CI/CD-Pipeline stellt die DAG-Definition aus Cloud Source Repositories automatisch in jedem Build in Cloud Composer bereit. Durch diese Vorgehensweise wird dafür gesorgt, dass Cloud Composer immer die neueste Workflowdefinition hat, ohne dass der Nutzer sich darum kümmern muss.

In der DAG-Definition für die Testumgebung ist neben dem Datenverarbeitungsworkflow ein End-to-End-Testschritt festgelegt. Dieser sorgt dafür, dass der Datenverarbeitungsworkflow ordnungsgemäß ausgeführt wird.

Im folgenden Diagramm ist der Datenverarbeitungsworkflow dargestellt.

Datenverarbeitungsworkflow in vier Schritten

Der Datenverarbeitungsworkflow umfasst die folgenden Schritte:

  1. Ausführung des WordCount-Datenprozesses in Dataflow.
  2. Herunterladen der Ausgabedateien aus dem WordCount-Prozess. Der WordCount-Prozess gibt drei Dateien aus:

    • download_result_1
    • download_result_2
    • download_result_3
  3. Herunterladen der Referenzdatei mit dem Namen download_ref_string.

  4. Prüfen des Ergebnisses anhand der Referenzdatei. Bei diesem Integrationstest werden alle drei Ergebnisse zusammengefasst und die zusammengefassten Ergebnisse mit der Referenzdatei verglichen.

Durch die Verwendung eines Frameworks zur Aufgabenorchestrierung wie Cloud Composer zum Verwalten des Datenverarbeitungsworkflows lässt sich der Code für den Workflow vereinfachen.

Tests

Neben dem Integrationstest, mit dem eine End-to-End-Überprüfung des Datenverarbeitungsworkflows vorgenommen wird, werden in dieser Anleitung zwei Einheitentests behandelt. Bei den Einheitentests handelt es sich um automatische Tests des Codes für die Datenverarbeitung und des Codes für den Datenverarbeitungsworkflow. Der Test des Codes für die Datenverarbeitung ist in Java geschrieben und wird automatisch während des Maven-Build-Prozesses ausgeführt. Der Test des Codes für den Datenverarbeitungsworkflow ist in Python geschrieben und wird als eigenständiger Build-Schritt ausgeführt.

Ziele

  • Cloud Composer-Umgebung konfigurieren.
  • Cloud Storage-Buckets für Ihre Daten erstellen.
  • Build-, Test- und Produktionspipelines erstellen.
  • Build-Trigger konfigurieren.

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss dieser Anleitung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Cloud Build, Cloud Source Repositories, Cloud Composer, and Dataflow APIs aktivieren.

    Aktivieren Sie die APIs

Beispielcode

Der Beispielcode befindet sich in zwei Ordnern:

  • Der Ordner env-setup enthält Shell-Skripts für die Ersteinrichtung der Google Cloud-Umgebung.
  • Der Ordner source-code enthält den Code, der im Laufe der Zeit entwickelt wird, von der Quelle gesteuert werden muss und automatische Build- und Testprozesse auslöst. In diesem Ordner gibt es folgende Unterordner:

    • Der Ordner data-processing-code enthält den Apache Beam-Prozessquellcode.
    • Der Ordner workflow-dag enthält die Composer-DAG-Definitionen für die Datenverarbeitungsworkflows mit den Schritten für das Entwerfen, Einbinden und Testen des Dataflow-Prozesses.
    • Der Ordner build-pipeline enthält zwei Cloud Build-Konfigurationen – eine für die Testpipeline und eine für die Produktionspipeline. Er enthält auch ein Supportskript für die Pipelines.

Für die Zwecke dieser Anleitung befinden sich die Quellcodedateien für die Datenverarbeitung und für den DAG-Workflow in verschiedenen Ordnern im selben Quellcode-Repository. In einer Produktionsumgebung befinden sich die Quellcodedateien in der Regel in eigenen Quellcode-Repositories und werden von verschiedenen Teams verwaltet.

Umgebung einrichten

In dieser Anleitung führen Sie alle Befehle in Cloud Shell aus. Cloud Shell wird am unteren Rand der Google Cloud Console als Fenster angezeigt.

  1. Öffnen Sie Cloud Shell in der Cloud Console:

    Zu Cloud Shell

  2. Klonen Sie das Beispielcode-Repository:

    git clone https://github.com/GoogleCloudPlatform/ci-cd-for-data-processing-workflow.git
    
  3. Führen Sie ein Skript aus, um Umgebungsvariablen festzulegen:

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

    Mit dem Skript werden die folgenden Umgebungsvariablen festgelegt:

    • Ihre Google Cloud-Projekt-ID.
    • Ihre Region und Ihre Zone.
    • Der Name Ihrer Cloud Storage-Buckets, die von der Build-Pipeline und dem Datenverarbeitungsworkflow verwendet werden.

    Da Umgebungsvariablen zwischen Sitzungen nicht beibehalten werden, müssen Sie sie zurücksetzen, wenn Ihre Cloud Shell-Sitzung während der Arbeit mit der Anleitung beendet oder getrennt wird.

Cloud Composer-Umgebung erstellen

In dieser Anleitung richten Sie eine Cloud Composer-Umgebung ein, die aus n1-standard-1-Knoten besteht.

  1. Erstellen Sie in Cloud Shell die Cloud Composer-Umgebung:

    gcloud composer environments create $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --zone $COMPOSER_ZONE_ID \
        --machine-type n1-standard-1 \
        --node-count 3 \
        --disk-size 20 \
        --python-version 2
    
  2. Führen Sie ein Skript aus, um die Variablen in der Cloud Composer-Umgebung festzulegen. Die Variablen werden für die Datenverarbeitungs-DAGs benötigt.

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

    Mit dem Skript werden die folgenden Umgebungsvariablen festgelegt:

    • Ihre Google Cloud-Projekt-ID.
    • Ihre Region und Ihre Zone.
    • Der Name Ihrer Cloud Storage-Buckets, die von der Build-Pipeline und dem Datenverarbeitungsworkflow verwendet werden.

Cloud Composer-Umgebungsattribute extrahieren

Cloud Composer verwendet zum Speichern von DAGs einen Cloud Storage-Bucket. Wenn Sie eine DAG-Definitionsdatei in den Bucket verschieben, werden die Dateien automatisch von Cloud Composer gelesen. Sie haben den Cloud Storage-Bucket für Cloud Composer bei der Erstellung der Cloud Composer-Umgebung erstellt. Beim folgenden Verfahren extrahieren Sie die URL für die Buckets und konfigurieren dann die CI/CD-Pipeline so, dass DAG-Definitionen für den Cloud Storage-Bucket automatisch bereitgestellt werden.

  1. Exportieren Sie in Cloud Shell die URL für den Bucket als Umgebungsvariable:

    export COMPOSER_DAG_BUCKET=$(gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.dagGcsPrefix)")
    
  2. Exportieren Sie den Namen des Dienstkontos, das Cloud Composer verwendet, um Zugriff auf die Cloud Storage-Buckets zu erhalten:

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

Cloud Storage-Buckets erstellen

In diesem Abschnitt erstellen Sie eine Reihe von Cloud Storage-Buckets, um Folgendes zu speichern:

  • Artefakte der Zwischenschritte des Build-Prozesses.
  • Die Ein- und Ausgabedateien für den Datenverarbeitungsworkflow.
  • Den Staging-Speicherort für die Dataflow-Jobs zum Speichern von Binärdateien.

So erstellen Sie Cloud Storage-Buckets:

  • Erstellen Sie in Cloud Shell Cloud Storage-Buckets und erteilen Sie dem Cloud Composer-Dienstkonto die Berechtigung zum Ausführen der Datenverarbeitungsworkflows:

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

Quellcode per Push an Cloud Source Repositories übertragen

In dieser Anleitung haben Sie eine einzelne Quellcodebasis, für die Sie eine Versionskontrolle durchführen müssen. Mit dem folgenden Schritt wird gezeigt, wie eine Codebasis entwickelt wird und sich mit der Zeit verändert. Immer wenn Änderungen per Push an das Repository übertragen werden, wird die Build-, Bereitstellungs- und Testpipeline ausgelöst.

  • Übertragen Sie in Cloud Shell den Ordner source-code per Push 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
    

    Dies sind Standardbefehle zum Initialisieren von Git in einem neuen Verzeichnis und zum Übertragen des Inhalts per Push in ein Remote-Repository.

Cloud Build-Pipelines erstellen

In diesem Abschnitt erstellen Sie die Build-Pipelines, mit denen der Datenverarbeitungsworkflow erstellt, bereitgestellt und getestet wird.

Zugriff auf Cloud Build-Dienstkonto gewähren

Cloud Build stellt Cloud Composer-DAGs bereit und löst Workflows aus, die aktiviert werden, wenn Sie zusätzlich Zugriff auf das Cloud Build-Dienstkonto gewähren. Weitere Informationen zu den verschiedenen verfügbaren Rollen bei der Arbeit mit Cloud Composer finden Sie in der Dokumentation zur Zugriffssteuerung.

  1. Fügen Sie in Cloud Shell dem Cloud Build-Dienstkonto die Rolle composer.admin hinzu, damit der Cloud Build-Job Airflow-Variablen in Cloud Composer festlegen kann:

    gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
        --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
        --role=roles/composer.admin
    
  2. Fügen Sie dem Cloud Build-Dienstkonto die Rolle composer.worker hinzu, damit der Cloud Build-Job den Datenworkflow in Cloud Composer auslösen kann:

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

Build- und Testpipeline erstellen

Die Schritte der Build- und Testpipeline werden in der YAML-Konfigurationsdatei konfiguriert. In dieser Anleitung verwenden Sie vorkonfigurierte Builder-Images für git, maven, gsutil und gcloud, um die Aufgaben in den einzelnen Build-Schritten auszuführen. Sie verwenden Substitutionen für Konfigurationsvariablen, um bei der Erstellung die Umgebungseinstellungen zu definieren. Der Speicherort des Quellcode-Repositorys wird durch Variablensubstitutionen sowie die Speicherorte der Cloud Storage-Buckets definiert. Diese Informationen werden vom Build benötigt, um die JAR-Datei, die Testdateien und die DAG-Definition bereitzustellen.

  • Übermitteln Sie in Cloud Shell die Konfigurationsdatei für die Build-Pipeline, um die Pipeline in Cloud Build zu erstellen:

    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
    

    Mit diesem Befehl wird Cloud Build angewiesen, einen Build mit den folgenden Schritten auszuführen:

    1. Erstellen und Bereitstellen einer selbstausführenden JAR-WordCount-Datei.

      1. Überprüfen des Quellcodes.
      2. Kompilieren des WordCount-Beam-Quellcodes in eine selbstausführende JAR-Datei.
      3. Speichern der JAR-Datei in Cloud Storage, wo sie von Cloud Composer zur Ausführung des WordCount-Verarbeitungsjobs abgerufen werden kann.
    2. Bereitstellen und Einrichten des Datenverarbeitungsworkflows in Cloud Composer.

      1. Ausführen des Einheitentests für den vom Workflow-DAG verwendeten Code mit benutzerdefinierten Operatoren.
      2. Bereitstellen der Testeingabedatei und der Testreferenzdatei in Cloud Storage. Die Testeingabedatei ist die Eingabe für den WordCount-Verarbeitungsjob. Die Testreferenzdatei wird als Referenz verwendet, um die Ausgabe des WordCount-Verarbeitungsjobs zu überprüfen.
      3. Festlegen der Cloud Composer-Variablen, damit sie auf die neu erstellte JAR-Datei verweisen.
      4. Bereitstellen der Workflow-DAG-Definition in der Cloud Composer-Umgebung.
    3. Ausführen des Datenverarbeitungsworkflows in der Testumgebung zum Auslösen des Testverarbeitungsworkflows.

Build- und Testpipeline überprüfen

Prüfen Sie nach dem Senden der Build-Datei die Build-Schritte.

  1. Rufen Sie in der Cloud Console die Seite Build-Verlauf auf, um eine Liste aller bisherigen und aktuell ausgeführten Builds zu sehen.

    Zur Seite "Build-Verlauf"

  2. Klicken Sie auf den Build, der gerade ausgeführt wird.

  3. Prüfen Sie auf der Seite Build-Details, ob die Build-Schritte mit den zuvor beschriebenen Schritten übereinstimmen.

    Einzelheiten zu den Build-Schritten

    Auf der Seite Build-Details wird im Feld Status des Builds Build successful angegeben, wenn der Build fertiggestellt ist.

  4. Prüfen Sie in Cloud Shell, ob die JAR-WordCount-Beispieldatei in den richtigen Bucket kopiert wurde:

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

    Die Ausgabe sieht etwa so aus:

    gs://…-composer-dataflow-source-test/dataflow_deployment_e88be61e-50a6-4aa0-beac-38d75871757e.jar
    
  5. Rufen Sie die URL zur Cloud Composer-Weboberfläche auf. Notieren Sie sich die URL, da sie im nächsten Schritt verwendet wird.

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.airflowUri)"
    
  6. Wechseln Sie mit der URL aus dem vorangegangenen Schritt zur Cloud Composer-UI und überprüfen Sie, ob der DAG erfolgreich ausgeführt wurde. Wenn in der Spalte DAG Runs (DAG-Ausführungen) keine Informationen angezeigt werden, warten Sie einige Minuten und laden Sie die Seite noch einmal.

    1. Halten Sie den Mauszeiger über den hellgrünen Kreis unter DAG-Ausführungen, um zu prüfen, ob der Datenverarbeitungsworkflow-DAG test_word_count bereitgestellt wurde und sich im Ausführungsmodus befindet. In diesem Fall wird Aktiv angezeigt.

      DAG-Verarbeitungsstatus "Aktiv"

    2. Klicken Sie auf den hellgrünen Kreis und anschließend auf der Seite DAG-Ausführungen auf DAG-ID: test_word_count, um sich den ausgeführten Datenverarbeitungsworkflow als Diagramm anzeigen zu lassen.

    3. Laden Sie die Seite Graphansicht noch einmal, um den Status der aktuellen DAG-Ausführung zu aktualisieren. In der Regel dauert es drei bis fünf Minuten, bis der Workflow abgeschlossen ist. Halten Sie den Mauszeiger über die einzelnen Aufgaben, um zu prüfen, ob die DAG-Ausführung erfolgreich abgeschlossen wurde. In diesem Fall wird als Kurzinfo Status: Erfolgreich angegeben. Die letzte Aufgabe mit dem Namen do_comparison ist der Integrationstest, mit dem die Prozessausgabe anhand der Referenzdatei überprüft wird.

Produktionspipeline erstellen

Wenn der Testverarbeitungsworkflow erfolgreich ausgeführt wird, können Sie die aktuelle Version des Workflows zur Produktion hochstufen. Es gibt verschiedene Möglichkeiten, den Workflow für die Produktion bereitzustellen:

  • Manuell.
  • Automatische Auslösung, wenn alle Tests in der Test- oder Staging-Umgebung erfolgreich abgeschlossen wurden.
  • Automatische Auslösung durch einen geplanten Job.

Auf die automatischen Ansätze wird in dieser Anleitung nicht eingegangen. Weitere Informationen finden Sie unter Release-Engineering.

In dieser Anleitung führen Sie eine manuelle Bereitstellung für die Produktion durch, indem Sie den Produktionsbereitstellungs-Build von Cloud Build ausführen. Der Produktionsbereitstellungs-Build umfasst folgende Schritte:

  1. Kopieren der JAR-WordCount-Datei aus dem Test-Bucket in den Produktions-Bucket.
  2. Festlegen der Cloud Composer-Variablen für den Produktionsworkflow, sodass sie auf die neu heraufgestufte JAR-Datei verweisen.
  3. Bereitstellen der DAG-Definition für den Produktionsworkflow in der Cloud Composer-Umgebung und Ausführen des Workflows.

Variablensubstitutionen definieren den Namen der neuesten JAR-Datei, die mit den vom Produktionsverarbeitungsworkflow verwendeten Cloud Storage-Buckets für die Produktion bereitgestellt wird. Führen Sie die folgenden Schritte aus, um die Cloud Build-Pipeline zu erstellen, die den Airflow-Workflow für die Produktion bereitstellt:

  1. Lesen Sie in Cloud Shell den Dateinamen der neuesten JAR-Datei, indem Sie die Cloud Composer-Variable für den JAR-Dateinamen ausgeben lassen:

    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. Verwenden Sie die Konfigurationsdatei für die Build-Pipeline, deploy_prod.yaml,, um die Pipeline in Cloud Build zu erstellen:

    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
    

Von der Produktionspipeline erstellten Datenverarbeitungsworkflow prüfen

  1. Rufen Sie die URL für Ihre Cloud Composer-UI ab:

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION \
        --format="get(config.airflowUri)"
    
  2. Wechseln Sie zu der im vorangegangenen Schritt abgerufenen URL, um zu prüfen, ob der Workflow-DAG zur Produktionsdatenverarbeitung bereitgestellt wurde. In diesem Fall wird in der Liste der DAGs der DAG prod_word_count angezeigt.

    1. Klicken Sie auf der Seite DAGs in der Zeile prod_word_count auf DAG auslösen.

      Wiedergabesymbol zum Auslösen des DAG

    2. Klicken Sie im Dialogfeld Bestätigung auf Bestätigen.

  3. Laden Sie die Seite noch einmal, um den DAG-Ausführungsstatus zu aktualisieren. Halten Sie den Mauszeiger über den hellgrünen Kreis unter DAG Runs (DAG-Ausführungen), um zu prüfen, ob der Datenverarbeitungsworkflow-DAG bereitgestellt wurde und sich im Ausführungsmodus befindet. In diesem Fall wird Aktiv angezeigt.

    DAG-Ausführungsstatus "Aktiv"

  4. Halten Sie den Mauszeiger nach erfolgreicher Ausführung über den dunkelgrünen Kreis unter der Spalte DAG runs (DAG-Ausführungen) und prüfen Sie, ob Erfolgreich angezeigt wird.

    DAG-Ausführungsstatus "Erfolgreich"

  5. Listen Sie in Cloud Shell die Ergebnisdateien im Cloud Storage-Bucket auf:

    gsutil ls gs://$RESULT_BUCKET_PROD
    

    Die Ausgabe sieht etwa so aus:

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

Build-Trigger konfigurieren

Sie richten einen Cloud Build-Trigger ein, der einen neuen Build auslöst, wenn Änderungen per Push an den Master-Branch des Quell-Repositorys übertragen werden.

  1. Führen Sie in Cloud Shell den folgenden Befehl aus, um alle für den Build erforderlichen Substitutionsvariablen abzurufen. Notieren Sie sich diese Werte, da sie in einem späteren Schritt benötigt werden.

    echo "_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}"
    
  2. Rufen Sie in der Cloud Console die Seite Build-Trigger auf.

    Zur Seite "Build-Trigger"

  3. Klicken Sie auf Trigger erstellen.

  4. Klicken Sie auf Cloud Source Repository und dann auf Weiter.

  5. Klicken Sie auf data-pipeline-source und dann auf Weiter.

  6. Führen Sie die folgenden Schritte aus, um die Triggereinstellungen zu konfigurieren:

    • Geben Sie im Feld Name Trigger build in test environment ein.
    • Klicken Sie unter Triggertyp auf Branch.
    • Geben Sie im Feld Branch (regulärer Ausdruck) master ein.
    • Klicken Sie unter Konfiguration auf Cloud Build-Konfigurationsdatei (YAML oder JSON).
    • Geben Sie für den Speicherort der Cloud Build-Konfigurationsdatei build-pipeline/build_deploy_test.yaml ein.
  7. Ersetzen Sie auf der Seite Triggereinstellungen die Variablen durch Werte aus Ihrer Umgebung, die Sie im vorangegangenen Schritt erhalten haben. Fügen Sie nacheinander die folgenden Einträge hinzu und klicken Sie für jedes Name/Wert-Paar auf + Element hinzufügen.

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

      Zuordnung von Name/Wert-Paaren

  8. Klicken Sie auf Trigger erstellen.

Trigger testen

Fügen Sie ein neues Wort zur Testeingabedatei hinzu und nehmen Sie die entsprechende Anpassung an der Testreferenzdatei vor, um den Trigger zu testen. Überprüfen Sie, ob die Build-Pipeline per Commit und Push an Cloud Source Repositories ausgelöst wird und der Datenverarbeitungsworkflow mit den aktualisierten Testdateien ordnungsgemäß ausgeführt wird.

  1. Fügen Sie in Cloud Shell am Ende der Testdatei ein Testwort hinzu:

    echo "testword" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/input.txt
    
  2. Aktualisieren Sie die Referenzdatei für Testergebnisse, ref.txt, um sie mit den Änderungen in der Testeingabedatei abzugleichen:

    echo "testword: 1" >>  ~/$SOURCE_CODE_REPO/workflow-dag/support-files/ref.txt
    
  3. Führen Sie für die Änderungen einen Commit und Push an Cloud Source Repositories durch:

    cd ~/$SOURCE_CODE_REPO
    git add .
    git commit -m 'change in test files'
    git push google master
    
  4. Rufen Sie in der Cloud Console die Seite Verlauf auf.

    ZUR SEITE "VERLAUF"

  5. Überprüfen Sie, ob für den derzeit aktiven Build in der Spalte Trigger der Eintrag Push zu Master-Branch zu sehen ist. Ist das der Fall, wird durch den vorangegangenen Push zum Master-Branch ein neuer Build ausgelöst.

  6. Rufen Sie in Cloud Shell die URL für die Cloud Composer-Weboberfläche ab:

    gcloud composer environments describe $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION --format="get(config.airflowUri)"
    
  7. Wechseln Sie nach Fertigstellung des Builds zur URL aus dem vorangegangenen Befehl, um zu prüfen, ob der DAG test_word_count ausgeführt wird.

    Warten Sie, bis die DAG-Ausführung beendet ist. Dies ist daran zu erkennen, dass der hellgrüne Kreis in der Spalte DAG Runs (DAG-Ausführungen) nicht mehr sichtbar ist. In der Regel dauert es drei bis fünf Minuten, bis der Vorgang abgeschlossen ist.

  8. Laden Sie in Cloud Shell die Testergebnisdateien herunter:

    mkdir ~/result-download
    cd ~/result-download
    gsutil cp gs://$RESULT_BUCKET_TEST/output* .
    
  9. Überprüfen Sie, ob das neu hinzugefügte Wort in einer der Ergebnisdateien enthalten ist:

    grep testword output*
    

    Die Ausgabe sieht etwa so aus:

    output-00000-of-00003:testword: 1
    

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Einzelne Ressourcen löschen

Wenn Sie das für diese Anleitung verwendete Projekt behalten möchten, führen Sie die folgenden Schritte aus, um die in dieser Anleitung erstellten Ressourcen zu löschen.

  1. Führen Sie die folgenden Schritte aus, um den Cloud Build-Trigger zu löschen:

    1. Rufen Sie in der Cloud Console die Seite Trigger auf.

      Zur Seite "Trigger"

    2. Klicken Sie neben dem erstellten Trigger auf das Dreipunkt-Menü  und anschließend auf Löschen.

  2. Löschen Sie in Cloud Shell die Cloud Composer-Umgebung:

    gcloud -q composer environments delete $COMPOSER_ENV_NAME \
        --location $COMPOSER_REGION
    
  3. Löschen Sie die Cloud Storage-Buckets und die zugehörigen Dateien:

    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. Löschen Sie das Repository:

    gcloud -q source repos delete $SOURCE_CODE_REPO
    
  5. Löschen Sie die von Ihnen erstellten Dateien und Ordner:

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

Weitere Informationen