Um den Erfolg und die wachsende Präferenz der Kunden für OSS-Lösungen noch stärker zu berücksichtigen, wird Cloud Composer zu Managed Service for Apache Airflow weiterentwickelt. Durch diese Namensänderung wird das Verständnis der Kunden für unser Portfolio verbessert und gleichzeitig unser Engagement für das offenste Cloud-Ökosystem unterstrichen.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Dataflow-Pipelines mit Managed Airflow starten

Managed Airflow (Gen 3) | Managed Airflow (Gen 2) | Managed Airflow (Legacy Gen 1)

Auf dieser Seite wird beschrieben, wie Sie mit dem DataflowTemplateOperator Dataflow-Pipelines aus Managed Airflow starten. Die Pipeline „Cloud Storage Text für BigQuery“ ist eine Batchpipeline, mit der Sie in Cloud Storage gespeicherte Textdateien hochladen, diese mit einer von Ihnen bereitgestellten benutzerdefinierten JavaScript-Funktion (User Defined Function, UDF) transformieren und die Ergebnisse in BigQuery ausgeben können.

Eine benutzerdefinierte Funktion, eine Eingabedatei und ein JSON-Schema werden in einen Cloud Storage-Bucket hochgeladen. Ein DAG, der auf diese Dateien verweist, startet eine Dataflow-Batchpipeline, die die benutzerdefinierte Funktion und die JSON-Schemadatei auf die Eingabedatei anwendet. Anschließend werden diese Inhalte in eine BigQuery-Tabelle hochgeladen.

Übersicht

Bevor Sie den Workflow starten, erstellen Sie die folgenden Einheiten:
- Eine leere BigQuery-Tabelle aus einem leeren Dataset, die die folgenden Spalten mit Informationen enthält: location, average_temperature, month und optional inches_of_rain, is_current und latest_measurement.
- Eine JSON-Datei, mit der die Daten aus der Datei .txt in das richtige Format für das Schema der BigQuery-Tabelle normalisiert werden. Das JSON-Objekt enthält ein Array von BigQuery Schema. Jedes Objekt enthält einen Spaltennamen, einen Eingabetyp und gibt an, ob es sich um ein Pflichtfeld handelt.
- Eine .txt-Eingabedatei, die die Daten enthält, die per Batch in die BigQuery-Tabelle hochgeladen werden.
- Eine in JavaScript geschriebene benutzerdefinierte Funktion, die jede Zeile der .txt-Datei in die für unsere Tabelle relevanten Variablen umwandelt.
- Eine Airflow-DAG-Datei, die auf den Speicherort dieser Dateien verweist.
Als Nächstes laden Sie die Datei .txt, die UDF-Datei .js und die Schemadatei .json in einen Cloud Storage-Bucket hoch. Sie laden die DAG auch in Ihre Managed Airflow-Umgebung hoch.
Nachdem der DAG hochgeladen wurde, führt Airflow einen Task daraus aus. Bei dieser Aufgabe wird eine Dataflow-Pipeline gestartet, in der die benutzerdefinierte Funktion auf die Datei .txt angewendet und gemäß dem JSON-Schema formatiert wird.
Schließlich werden die Daten in die BigQuery-Tabelle hochgeladen, die Sie zuvor erstellt haben.

Hinweis

Für diesen Leitfaden sind JavaScript-Kenntnisse erforderlich, um die benutzerdefinierte Funktion zu schreiben.
In diesem Leitfaden wird davon ausgegangen, dass Sie bereits eine Managed Airflow-Umgebung haben. Informationen zum Erstellen einer Umgebung finden Sie unter Umgebung erstellen. Sie können mit dieser Anleitung eine beliebige Version von Managed Airflow verwenden.
Aktivieren Sie die APIs für Managed Service for Apache Airflow, Dataflow, Cloud Storage und BigQuery, falls sie noch nicht aktiviert sind.
Rollen, die zum Aktivieren von APIs erforderlich sind
Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen
APIs aktivieren
Prüfen Sie, ob Sie die folgenden Berechtigungen haben:
- Managed Airflow-Rollen: Sie können eine Umgebung erstellen (falls Sie noch keine haben), Objekte im Bucket der Umgebung verwalten, DAGs ausführen und auf die Airflow-UI zugreifen.
- Cloud Storage-Rollen: Erstellen Sie einen Bucket und verwalten Sie Objekte darin.
- BigQuery-Rollen: Dataset und Tabelle erstellen, Daten in der Tabelle ändern, Tabellenschema und ‑metadaten ändern.
- Dataflow-Rollen: Dataflow-Jobs ansehen.
Achten Sie darauf, dass das Dienstkonto Ihrer Umgebung die Berechtigungen zum Erstellen von Dataflow-Jobs, zum Zugriff auf den Cloud Storage-Bucket und zum Lesen und Aktualisieren von Daten für die Tabelle in BigQuery hat.

Leere BigQuery-Tabelle mit einer Schemadefinition erstellen

Erstellen Sie eine BigQuery-Tabelle mit einer Schemadefinition. Sie verwenden diese Schemadefinition später in diesem Leitfaden. In dieser BigQuery-Tabelle werden die Ergebnisse des Batch-Uploads gespeichert.

So erstellen Sie eine leere Tabelle mit einer Schemadefinition:

Console

Rufen Sie in der Google Cloud Console die Seite „BigQuery“ auf:

BigQuery aufrufen
Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt.
Klicken Sie im Detailbereich auf Dataset erstellen.
Geben Sie auf der Seite „Dataset erstellen“ im Abschnitt Dataset-ID den Namen average_weather für Ihr Dataset ein. Übernehmen Sie für alle anderen Felder die Standardeinstellungen.
Klicken Sie auf Dataset erstellen.
Kehren Sie zum Navigationsbereich zurück und maximieren Sie im Abschnitt Ressourcen Ihr Projekt. Klicken Sie dann auf das Dataset average_weather.
Klicken Sie im Detailfeld auf Tabelle erstellen.
Wählen Sie auf der Seite Tabelle erstellen im Abschnitt Quelle die Option Leere Tabelle aus.
Gehen Sie auf der Seite Create table (Tabelle erstellen) im Abschnitt Destination (Ziel) so vor:
- Wählen Sie für Dataset-Name das Dataset average_weather aus.
- Geben Sie im Feld Tabellenname den Namen average_weather ein.
- Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.

Geben Sie im Abschnitt Schema die Schemadefinition ein. Sie haben dazu folgende Möglichkeiten:

Sie können Schemainformationen manuell eingeben, indem Sie Als Text bearbeiten aktivieren und das Tabellenschema als JSON-Array eingeben. Geben Sie die folgenden Informationen ein:

[
    {
        "name": "location",
        "type": "GEOGRAPHY",
        "mode": "REQUIRED"
    },
    {
        "name": "average_temperature",
        "type": "INTEGER",
        "mode": "REQUIRED"
    },
    {
        "name": "month",
        "type": "STRING",
        "mode": "REQUIRED"
    },
    {
        "name": "inches_of_rain",
        "type": "NUMERIC"
    },
    {
        "name": "is_current",
        "type": "BOOLEAN"
    },
    {
        "name": "latest_measurement",
        "type": "DATE"
    }
]

Geben Sie das Schema mithilfe von Feld hinzufügen manuell ein:

Behalten Sie für Partitions- und Clustereinstellungen den Standardwert No partitioning bei.
Übernehmen Sie im Abschnitt Erweiterte Optionen den Standardwert für Verschlüsselung, und zwar Google-owned and managed key.
Klicken Sie auf Tabelle erstellen.

bq

Verwenden Sie den Befehl bq mk, um ein leeres Dataset und eine Tabelle in diesem Dataset zu erstellen.

Führen Sie den folgenden Befehl aus, um ein Dataset mit dem durchschnittlichen globalen Wetter zu erstellen:

bq --location=LOCATION mk \
    --dataset PROJECT_ID:average_weather

Ersetzen Sie Folgendes:

LOCATION: die Region, in der sich die Umgebung befindet.
PROJECT_ID: Die Projekt-ID.

Führen Sie den folgenden Befehl aus, um eine leere Tabelle in diesem Dataset mit der Schemadefinition zu erstellen:

bq mk --table \
PROJECT_ID:average_weather.average_weather \
location:GEOGRAPHY,average_temperature:INTEGER,month:STRING,inches_of_rain:NUMERIC,is_current:BOOLEAN,latest_measurement:DATE

Nachdem die Tabelle erstellt wurde, können Sie die Ablaufzeit, die Beschreibung und die Labels der Tabelle aktualisieren. Ebenso können Sie die Schemadefinition ändern.

Python

Speichern Sie diesen Code als dataflowtemplateoperator_create_dataset_and_table_helper.py und aktualisieren Sie die Variablen darin, damit sie Ihr Projekt und Ihren Standort widerspiegeln. Führen Sie ihn dann mit dem folgenden Befehl aus:

python dataflowtemplateoperator_create_dataset_and_table_helper.py

Python

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Managed Airflow zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


# Make sure to follow the quickstart setup instructions beforehand.
# See instructions here:
# https://cloud.google.com/bigquery/docs/quickstarts/quickstart-client-libraries

# Before running the sample, be sure to install the bigquery library
# in your local environment by running pip install google.cloud.bigquery

from google.cloud import bigquery

# TODO(developer): Replace with your values
project = "your-project"  # Your GCP Project
location = "US"  # the location where you want your BigQuery data to reside. For more info on possible locations see https://cloud.google.com/bigquery/docs/locations
dataset_name = "average_weather"


def create_dataset_and_table(project, location, dataset_name):
    # Construct a BigQuery client object.
    client = bigquery.Client(project)

    dataset_id = f"{project}.{dataset_name}"

    # Construct a full Dataset object to send to the API.
    dataset = bigquery.Dataset(dataset_id)

    # Set the location to your desired location for the dataset.
    # For more information, see this link:
    # https://cloud.google.com/bigquery/docs/locations
    dataset.location = location

    # Send the dataset to the API for creation.
    # Raises google.api_core.exceptions.Conflict if the Dataset already
    # exists within the project.
    dataset = client.create_dataset(dataset)  # Make an API request.

    print(f"Created dataset {client.project}.{dataset.dataset_id}")

    # Create a table from this dataset.

    table_id = f"{client.project}.{dataset_name}.average_weather"

    schema = [
        bigquery.SchemaField("location", "GEOGRAPHY", mode="REQUIRED"),
        bigquery.SchemaField("average_temperature", "INTEGER", mode="REQUIRED"),
        bigquery.SchemaField("month", "STRING", mode="REQUIRED"),
        bigquery.SchemaField("inches_of_rain", "NUMERIC", mode="NULLABLE"),
        bigquery.SchemaField("is_current", "BOOLEAN", mode="NULLABLE"),
        bigquery.SchemaField("latest_measurement", "DATE", mode="NULLABLE"),
    ]

    table = bigquery.Table(table_id, schema=schema)
    table = client.create_table(table)  # Make an API request.
    print(f"Created table {table.project}.{table.dataset_id}.{table.table_id}")

Cloud Storage-Bucket erstellen

Erstellen Sie einen Bucket, in dem alle für den Workflow erforderlichen Dateien gespeichert werden. In der DAG, die Sie später in dieser Anleitung erstellen, wird auf die Dateien verwiesen, die Sie in diesen Speicher-Bucket hochladen. So erstellen Sie einen neuen Storage-Bucket:

Console

Öffnen Sie Cloud Storage in der Google Cloud Console.

Cloud Storage aufrufen
Klicken Sie auf Bucket erstellen, um das Formular zum Erstellen eines Buckets zu öffnen.
1. Geben Sie die Bucket-Informationen ein und klicken Sie zum Ausführen der einzelnen Schritte jeweils auf Weiter:
  - Geben Sie einen global eindeutigen Namen für den Bucket an. In diesem Leitfaden wird bucketName als Beispiel verwendet.
  - Wählen Sie Region als Standorttyp aus. Wählen Sie als Nächstes einen Standort für die Bucket-Daten aus.
  - Wählen Sie Standard als Standard-Speicherklasse für Ihre Daten aus.
  - Wählen Sie Einheitliche Zugriffssteuerung für den Zugriff auf Ihre Objekte aus.
2. Klicken Sie auf Fertig.

gcloud

Führen Sie den Befehl gcloud storage buckets create aus:

gcloud storage buckets create gs://bucketName/

Ersetzen Sie Folgendes:

bucketName: Der Name des Buckets, den Sie zuvor in diesem Leitfaden erstellt haben.

Codebeispiele

C#


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class CreateBucketSample
{
    public Bucket CreateBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.CreateBucket(projectId, bucketName);
        Console.WriteLine($"Created {bucketName}.");
        return bucket;
    }
}

Go

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// createBucket creates a new bucket in the project.
func createBucket(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, nil); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v created\n", bucketName)
	return nil
}

Java

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class CreateBucket {
  public static void createBucket(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    Bucket bucket = storage.create(BucketInfo.newBuilder(bucketName).build());

    System.out.println("Created bucket " + bucket.getName());
  }
}

Python

from google.cloud import storage


def create_bucket(bucket_name):
    """Creates a new bucket."""
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.create_bucket(bucket_name)

    print(f"Bucket {bucket.name} created")

Ruby

def create_bucket bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.create_bucket bucket_name

  puts "Created bucket: #{bucket.name}"
end

BigQuery-Schema im JSON-Format für Ihre Ausgabetabelle erstellen

Erstellen Sie eine JSON-formatierte BigQuery-Schemadatei, die der zuvor erstellten Ausgabetabelle entspricht. Die Feldnamen, ‑typen und ‑modi müssen mit denen übereinstimmen, die zuvor in Ihrem BigQuery-Tabellenschema definiert wurden. In dieser Datei werden die Daten aus der Datei .txt in ein Format normalisiert, das mit Ihrem BigQuery-Schema kompatibel ist. Geben Sie dieser Datei den Namen jsonSchema.json.

{
    "BigQuery Schema": [
    {
        "name": "location",
        "type": "GEOGRAPHY",
        "mode": "REQUIRED"
    },
    {
        "name": "average_temperature",
        "type": "INTEGER",
        "mode": "REQUIRED"
    },
    {
        "name": "month",
        "type": "STRING",
        "mode": "REQUIRED"
    },
    {
        "name": "inches_of_rain",
        "type": "NUMERIC"
    },
    {
        "name": "is_current",
        "type": "BOOLEAN"
    },
    {
        "name": "latest_measurement",
        "type": "DATE"
    }]
}

JavaScript-Datei zum Formatieren Ihrer Daten erstellen

In dieser Datei definieren Sie Ihre benutzerdefinierte Funktion (User Defined Function, UDF), die die Logik für die Transformation der Textzeilen in Ihrer Eingabedatei bereitstellt. Beachten Sie, dass diese Funktion jede Textzeile in Ihrer Eingabedatei als eigenes Argument verwendet. Die Funktion wird also einmal für jede Zeile Ihrer Eingabedatei ausgeführt. Geben Sie dieser Datei den Namen transformCSVtoJSON.js.


function transformCSVtoJSON(line) {
  var values = line.split(',');
  var properties = [
    'location',
    'average_temperature',
    'month',
    'inches_of_rain',
    'is_current',
    'latest_measurement',
  ];
  var weatherInCity = {};

  for (var count = 0; count < values.length; count++) {
    if (values[count] !== 'null') {
      weatherInCity[properties[count]] = values[count];
    }
  }

  return JSON.stringify(weatherInCity);
}

Eingabedatei erstellen

Diese Datei enthält die Informationen, die Sie in Ihre BigQuery-Tabelle hochladen möchten. Kopieren Sie diese Datei lokal und nennen Sie sie inputFile.txt.

POINT(40.7128 74.006),45,'July',null,true,2020-02-16
POINT(41.8781 87.6298),23,'October',13,false,2015-02-13
POINT(48.8566 2.3522),80,'December',null,true,null
POINT(6.5244 3.3792),15,'March',14,true,null

Dateien in Ihren Bucket hochladen

Laden Sie die folgenden Dateien in den Cloud Storage-Bucket hoch, den Sie zuvor erstellt haben:

JSON-formatiertes BigQuery-Schema (.json)
Benutzerdefinierte JavaScript-Funktion (transformCSVtoJSON.js)
Die Eingabedatei für den zu verarbeitenden Text (.txt)

Console

Wechseln Sie in der Google Cloud Console unter „Cloud Storage“ zur Seite Buckets.

Buckets aufrufen
Klicken Sie in der Liste der Buckets auf Ihren Bucket.
Führen Sie im Tab „Objekte“ für den Bucket einen der folgenden Schritte aus:
- Fügen Sie die gewünschten Dateien per Drag-and-drop von Ihrem Desktop oder Dateimanager in den Hauptbereich der Google Cloud Console ein.
- Klicken Sie auf den Button Dateien hochladen, wählen Sie im angezeigten Dialogfeld die Dateien aus, die Sie hochladen möchten, und klicken Sie auf Öffnen.

gcloud

Führen Sie den Befehl gcloud storage cp aus:

gcloud storage cp OBJECT_LOCATION gs://bucketName

Ersetzen Sie Folgendes:

bucketName: der Name des Buckets, den Sie zuvor in dieser Anleitung erstellt haben.
OBJECT_LOCATION: der lokale Pfad zu Ihrem Objekt. Beispiel: Desktop/transformCSVtoJSON.js

Codebeispiele

Python

from google.cloud import storage


def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The path to your file to upload
    # source_file_name = "local/path/to/file"
    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    # Optional: set a generation-match precondition to avoid potential race conditions
    # and data corruptions. The request to upload is aborted if the object's
    # generation number does not match your precondition. For a destination
    # object that does not yet exist, set the if_generation_match precondition to 0.
    # If the destination object already exists in your bucket, set instead a
    # generation-match precondition using its generation number.
    generation_match_precondition = 0

    blob.upload_from_filename(source_file_name, if_generation_match=generation_match_precondition)

    print(
        f"File {source_file_name} uploaded to {destination_blob_name}."
    )

Ruby

def upload_file bucket_name:, local_file_path:, file_name: nil
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name, skip_lookup: true

  file = bucket.create_file local_file_path, file_name

  puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}"
end

DataflowTemplateOperator konfigurieren

Bevor Sie den DAG ausführen, legen Sie die folgenden Airflow-Variablen fest.

Airflow-Variable	Wert
`project_id`	Die Projekt-ID. Beispiel: `example-project`.
`gce_zone`	Compute Engine-Zone, in der der Dataflow-Cluster erstellt werden muss. Beispiel: `us-central1-a`. Weitere Informationen zu gültigen Zonen finden Sie unter Regionen und Zonen.
`bucket_path`	Der Speicherort des Cloud Storage-Bucket, den Sie zuvor erstellt haben. Beispiel: `gs://example-bucket.`

Nun verweisen Sie auf die Dateien, die Sie zuvor erstellt haben, um einen DAG zu erstellen, mit dem der Dataflow-Workflow gestartet wird. Kopieren Sie diesen DAG und speichern Sie ihn lokal als composer-dataflow-dag.py.



"""Example Airflow DAG that creates a Cloud Dataflow workflow which takes a
text file and adds the rows to a BigQuery table.

This DAG relies on four Airflow variables
https://airflow.apache.org/docs/apache-airflow/stable/concepts/variables.html
* project_id - Google Cloud Project ID to use for the Cloud Dataflow cluster.
* gce_zone - Google Compute Engine zone where Cloud Dataflow cluster should be
  created.
For more info on zones where Dataflow is available see:
https://cloud.google.com/dataflow/docs/resources/locations
* bucket_path - Google Cloud Storage bucket where you've stored the User Defined
Function (.js), the input file (.txt), and the JSON schema (.json).
"""

import datetime

from airflow import models
from airflow.providers.google.cloud.operators.dataflow import (
    DataflowTemplatedJobStartOperator,
)
from airflow.utils.dates import days_ago

bucket_path = "{{var.value.bucket_path}}"
project_id = "{{var.value.project_id}}"
gce_zone = "{{var.value.gce_zone}}"


default_args = {
    # Tell airflow to start one day ago, so that it runs as soon as you upload it
    "start_date": days_ago(1),
    "dataflow_default_options": {
        "project": project_id,
        # Set to your zone
        "zone": gce_zone,
        # This is a subfolder for storing temporary files, like the staged pipeline job.
        "tempLocation": bucket_path + "/tmp/",
    },
}

# Define a DAG (directed acyclic graph) of tasks.
# Any task you create within the context manager is automatically added to the
# DAG object.
with models.DAG(
    # The id you will see in the DAG airflow page
    "composer_dataflow_dag",
    default_args=default_args,
    # The interval with which to schedule the DAG
    schedule_interval=datetime.timedelta(days=1),  # Override to match your needs
) as dag:
    start_template_job = DataflowTemplatedJobStartOperator(
        # The task id of your job
        task_id="dataflow_operator_transform_csv_to_bq",
        # The name of the template that you're using.
        # Below is a list of all the templates you can use.
        # For versions in non-production environments, use the subfolder 'latest'
        # https://cloud.google.com/dataflow/docs/guides/templates/provided-batch#gcstexttobigquery
        template="gs://dataflow-templates/latest/GCS_Text_to_BigQuery",
        # Use the link above to specify the correct parameters for your template.
        parameters={
            "javascriptTextTransformFunctionName": "transformCSVtoJSON",
            "JSONPath": bucket_path + "/jsonSchema.json",
            "javascriptTextTransformGcsPath": bucket_path + "/transformCSVtoJSON.js",
            "inputFilePattern": bucket_path + "/inputFile.txt",
            "outputTable": project_id + ":average_weather.average_weather",
            "bigQueryLoadingTemporaryDirectory": bucket_path + "/tmp/",
        },
    )

DAG in Cloud Storage hochladen

Laden Sie Ihren DAG in den Ordner /dags im Bucket Ihrer Umgebung hoch. Sobald der Upload erfolgreich abgeschlossen wurde, können Sie ihn in der Managed Airflow-Umgebung auf den Link DAGs-Ordner sehen.

Der Ordner „DAGs“ in Ihrer Umgebung enthält Ihren DAG.

Status der Aufgabe ansehen

Rufen Sie die Airflow-Weboberfläche auf.
Klicken Sie auf der Seite „DAGs“ auf den DAG-Namen, z. B. composerDataflowDAG.
Klicken Sie auf der DAGs-Detailseite auf Grafikansicht.
Prüfen Sie den Status:
- Failed: Die Aufgabe ist rot umrandet. Sie können auch den Mauszeiger über die Aufgabe halten und nach State: Failed suchen.
- Success: Die Aufgabe ist von einem grünen Kästchen umgeben. Sie können auch den Mauszeiger über die Aufgabe bewegen und nach Status: Erfolgreich suchen.

Nach einigen Minuten können Sie die Ergebnisse in Dataflow und BigQuery prüfen.

Job in Dataflow ansehen

Rufen Sie in der Google Cloud Console die Seite Dataflow auf.

Zu Dataflow
Ihr Job heißt dataflow_operator_transform_csv_to_bq. Am Ende des Namens ist mit einem Bindestrich eine eindeutige ID angehängt, z. B.:
Klicken Sie auf den Namen, um die Jobdetails aufzurufen.

Ergebnisse in BigQuery anzeigen

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen
Sie können Abfragen mit Standard-SQL senden. Verwenden Sie die folgende Abfrage, um die Zeilen anzuzeigen, die Ihrer Tabelle hinzugefügt wurden:
```
SELECT * FROM projectId.average_weather.average_weather
```

Dataflow-Pipelines mit Managed Airflow starten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Übersicht

Hinweis

Leere BigQuery-Tabelle mit einer Schemadefinition erstellen

Console

bq

Python

Python

Cloud Storage-Bucket erstellen

Console

gcloud

Codebeispiele

C#

Go

Java

Python

Ruby

BigQuery-Schema im JSON-Format für Ihre Ausgabetabelle erstellen

JavaScript-Datei zum Formatieren Ihrer Daten erstellen

Eingabedatei erstellen

Dateien in Ihren Bucket hochladen

Console

gcloud

Codebeispiele

Python

Ruby

DataflowTemplateOperator konfigurieren

DAG in Cloud Storage hochladen

Status der Aufgabe ansehen

Job in Dataflow ansehen

Ergebnisse in BigQuery anzeigen

Nächste Schritte

Dataflow-Pipelines mit Managed Airflow starten