Einheitliches Data Lakehouse für KI mit Apache Iceberg und Lakehouse erstellen

1. Einführung

In diesem Codelab lernen Sie die Funktionen des Unified Data Lakehouse in Google Cloud kennen. Sie interagieren mit öffentlichen Datasets, die über den Apache Iceberg REST Catalog in Lakehouse bereitgestellt werden, und wenden dann die KI-Funktionen von Google Cloud auf strukturierte und unstrukturierte Daten an.

Sie fragen das klassische NYC Taxi-Dataset mit Apache Iceberg ab, nutzen Time Travel , um Datenänderungen zu prüfen, und verwenden dann BigQuery ML und Gemini , um KI-Modelle auf Ihre Daten anzuwenden.

Aufgaben

  • Verwenden Sie Managed Service for Apache Spark, um öffentliche Apache Iceberg-Datasets abzufragen, die in Lakehouse gehostet werden.
  • Fragen Sie strukturierte Daten im Apache Iceberg-Format ab.
  • Demonstrieren Sie Time Travel in Apache Iceberg.
  • Verwenden Sie BigQuery ML , um ein Vorhersagemodell für strukturierte Daten zu trainieren.
  • Erstellen Sie eine Lakehouse-Objekttabelle (unstrukturierte Daten) und verwenden Sie Gemini , um Bilder zu analysieren.

Voraussetzungen

  • Ein Webbrowser wie Chrome.
  • Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.

Erwartete Kosten und Dauer

  • Dauer: ca. 45 Minuten.
  • Geschätzte Kosten: weniger als 2 $. Wir verwenden öffentliche Datasets und serverlose Abfragen, um die Kosten niedrig zu halten.

2. Einrichtung und Anforderungen

In diesem Schritt bereiten Sie Ihre Umgebung vor und aktivieren die erforderlichen APIs.

Cloud Shell starten

Die meisten Befehle werden in der Google Cloud Shell ausgeführt.

  1. Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren.
  2. Authentifizierung prüfen: 
    gcloud auth list
  3. Bestätigen Sie Ihr Projekt: 
    gcloud config get project
  4. Wenn das Projekt nicht festgelegt ist, legen Sie es mit Ihrer Projekt-ID fest: 
    gcloud config set project <YOUR_PROJECT_ID>

APIs aktivieren

Führen Sie den folgenden Befehl aus, um die erforderlichen APIs für BigQuery, Cloud Resource Manager und Gemini Enterprise Agent Engine zu aktivieren:

gcloud services enable \
  bigquery.googleapis.com \
  aiplatform.googleapis.com \
  cloudresourcemanager.googleapis.com

Umgebung konfigurieren und Bucket für Abhängigkeiten erstellen

  1. Legen Sie die Umgebungsvariablen in Ihrem Terminal fest:
    export PROJECT_ID=$(gcloud config get project)
export REGION=us-central1
export DEPS_BUCKET=$PROJECT_ID-deps-bucket
  2. Erstellen Sie den Cloud Storage-Bucket für Abhängigkeiten. PySpark-Skripts werden hier zum Zeitpunkt der Jobübermittlung hochgeladen:
    gcloud storage buckets create gs://$DEPS_BUCKET --location=$REGION

3. Verbindung zum öffentlichen Apache Iceberg-Katalog herstellen

In diesem Schritt stellen Sie eine Verbindung zu einem aktiven Apache Iceberg-Katalog in Produktionsqualität her, der in Lakehouse von Google Cloud gehostet wird.

Spark SQL mit der Managed Apache Spark Batch CLI ausführen

Wir verwenden Managed Apache Spark, um PySpark-Jobs auszuführen, ohne die Infrastruktur verwalten zu müssen. Wir konfigurieren es so, dass es auf den öffentlichen Lakehouse REST Catalog verweist.

  1. Definieren Sie die Eigenschaften des Lakehouse REST Catalog, um sie nicht wiederholen zu müssen.Diese Konfiguration weist Spark an:
    • Die Bibliotheken iceberg-spark-runtime und iceberg-gcp-bundle zu verwenden.
    • Einen Katalog mit dem Namen my_catalog mit dem Lakehouse REST Catalog-Endpunkt zu konfigurieren.
    • Google Cloud Storage (GCS) zum Lesen von Datendateien anstelle des standardmäßigen lokalen Dateisystems zu verwenden.
    • Diesen Katalog my_catalog als Standard für unsere Sitzung festzulegen.
    • Verwendete Anmeldedaten für erweiterte Sicherheitsfunktionen und vereinfachten Datenzugriff zu verwenden.
    export METASTORE_PROPERTIES="^|^spark.jars.packages=org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:1.10.0,org.apache.iceberg:iceberg-gcp-bundle:1.10.0|\
spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog|\
spark.sql.catalog.my_catalog.type=rest|\
spark.sql.catalog.my_catalog.uri=https://biglake.googleapis.com/iceberg/v1/restcatalog|\
spark.sql.catalog.my_catalog.warehouse=gs://biglake-public-nyc-taxi-iceberg|\
spark.sql.catalog.my_catalog.io-impl=org.apache.iceberg.gcp.gcs.GCSFileIO|\
spark.sql.catalog.my_catalog.header.x-goog-user-project=$PROJECT_ID|\
spark.sql.catalog.my_catalog.header.X-Iceberg-Access-Delegation=vended-credentials|\
spark.sql.catalog.my_catalog.rest.auth.type=org.apache.iceberg.gcp.auth.GoogleAuthManager|\
spark.sql.defaultCatalog=my_catalog|\
spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions|\
spark.log.level=ERROR"
  2. Erstellen Sie eine einfache Testabfragedatei:
    cat <<EOF > test.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

spark.sql("SHOW TABLES IN public_data").show()
EOF
  3. Übermitteln Sie den Batchjob:
    gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  test.py
    Warten Sie einige Minuten, bis der Batchjob abgeschlossen ist.Nach Abschluss des Jobs sollte die Ausgabe in etwa so aussehen:
    +-----------+----------------+-----------+
|  namespace|       tableName|isTemporary|
+-----------+----------------+-----------+
|public_data|     nyc_taxicab|      false|
|public_data|nyc_taxicab_2021|      false|
+-----------+----------------+-----------+

4. Strukturierte Iceberg-Daten abfragen

Nach der Verbindung haben Sie vollständigen SQL-Zugriff auf die Datasets. Wir fragen das NYC Taxi-Dataset ab, das als Iceberg-Tabelle modelliert wurde.

Standardaggregationsabfrage ausführen

Erstellen Sie eine Datei mit dem Namen query.py:

cat <<EOF > query.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

query = """
SELECT
  passenger_count,
  COUNT(1) AS num_trips,
  ROUND(AVG(total_amount), 2) AS avg_fare,
  ROUND(AVG(trip_distance), 2) AS avg_distance
FROM public_data.nyc_taxicab
WHERE data_file_year = 2021 AND passenger_count > 0
GROUP BY passenger_count
ORDER BY num_trips DESC
"""

spark.sql(query).show()
EOF

Übermitteln Sie sie mit Managed Apache Spark:

gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  query.py

Warten Sie einige Minuten, bis der Batchjob abgeschlossen ist.

Nach Abschluss des Jobs sollte die Ausgabe in etwa so aussehen:

+---------------+---------+--------+------------+
|passenger_count|num_trips|avg_fare|avg_distance|
+---------------+---------+--------+------------+
|              1| 21508009|   18.82|        3.03|
|              2|  4424746|   20.22|        3.40|
|              3|  1164846|   19.84|        3.27|
|              5|   718282|   18.88|        3.07|
|              4|   466485|   20.61|        3.44|
|              6|   452467|   18.97|        3.11|
|              7|       78|   65.24|        3.71|
|              8|       49|   57.39|        5.88|
|              9|       35|   73.26|        6.20|
|             96|        1|   17.00|        2.00|
|            112|        1|   15.00|        2.00|
+---------------+---------+--------+------------+

Warum Apache Iceberg?

  • Partitionsbereinigung: Die Abfrage filtert nach data_file_year = 2021. Mit Iceberg kann die Engine das Scannen von Daten aus anderen Jahren vollständig überspringen.
  • Engine-Agilität: Sie können dies in Spark, Trino oder BigQuery ausführen, ohne Daten zu kopieren.

5. Time Travel in Apache Iceberg

Eine der leistungsstärksten Funktionen von Iceberg ist Time Travel. Damit können Sie Daten so abfragen, wie sie in einer früheren Version oder einem früheren Snapshot vorhanden waren.

Tabellenverlauf ansehen

Erstellen Sie eine Datei mit dem Namen history.py:

cat <<EOF > history.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

spark.sql("SELECT * FROM public_data.nyc_taxicab.history").show()
EOF

Übermitteln Sie sie:

gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  history.py

In der Console sollte eine Ausgabe ähnlich der folgenden zu sehen sein:

+--------------------+-------------------+-------------------+-------------------+
|     made_current_at|        snapshot_id|          parent_id|is_current_ancestor|
+--------------------+-------------------+-------------------+-------------------+
|2026-01-07 21:32:...|6333415779680505547|               NULL|               true|
|2026-01-07 21:34:...|1840345522877675925|6333415779680505547|               true|
|2026-01-07 21:36:...|7203554539964460256|1840345522877675925|               true|
|2026-01-07 21:38:...|4573466015237516024|7203554539964460256|               true|
|2026-01-07 21:40:...|3353190952148867790|4573466015237516024|               true|
|2026-01-07 21:42:...|1335547378580631681|3353190952148867790|               true|
|2026-01-07 21:44:...|8203141258229894239|1335547378580631681|               true|
|2026-01-07 21:46:...|1597048231706307813|8203141258229894239|               true|
|2026-01-07 21:48:...|6247811509231462655|1597048231706307813|               true|
|2026-01-07 21:50:...|2527184310045633322|6247811509231462655|               true|
|2026-01-07 21:52:...|2512764101237223642|2527184310045633322|               true|
|2026-01-07 21:52:...|7045957533358062548|2512764101237223642|               true|
|2026-01-07 21:53:...| 531753237516076726|7045957533358062548|               true|
|2026-01-07 21:53:...|4184653573199718274| 531753237516076726|               true|
|2026-01-07 21:54:...|5125223829492177301|4184653573199718274|               true|
|2026-01-07 21:54:...|6844673237417600305|5125223829492177301|               true|
|2026-01-07 21:54:...|6634828203344518093|6844673237417600305|               true|
|2026-01-07 21:55:...|7637728273407236194|6634828203344518093|               true|
|2026-01-07 21:55:...|3424071684958740192|7637728273407236194|               true|
|2026-01-07 21:55:...|1743746294196424254|3424071684958740192|               true|
+--------------------+-------------------+-------------------+-------------------+

Sie sehen Zeilen, die verschiedene Snapshot-IDs und die Zeitpunkte darstellen, zu denen sie übernommen wurden.

Aktuelle mit vorheriger Zeilenanzahl vergleichen

Erstellen Sie eine Datei mit dem Namen timetravel.py:

cat <<EOF > timetravel.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

query = """
SELECT 'Current State' AS version, COUNT(*) AS count FROM public_data.nyc_taxicab
UNION ALL
SELECT 'Past State' AS version, COUNT(*) AS count FROM public_data.nyc_taxicab VERSION AS OF 4573466015237516024
"""

spark.sql(query).show()
EOF

Übermitteln Sie sie:

gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  timetravel.py

In der Console sollte eine Ausgabe ähnlich der folgenden zu sehen sein:

+-------------+----------+
|      version|     count|
+-------------+----------+
|Current State|1293069366|
|   Past State|  72878594|
+-------------+----------+

So können Sie Datenänderungen im Zeitverlauf prüfen.

6. Strukturierte KI mit BigQuery ML

Nachdem Sie nun die Iceberg-Daten untersucht haben, verwenden wir die KI-Funktionen von BigQuery. Da der öffentliche Iceberg-Katalog schreibgeschützt ist, können wir BigQuery verwenden, um ein Modell in unserem Arbeitsbereich zu trainieren, indem wir Daten aus öffentlichen Tabellen lesen.

Lokales Dataset erstellen

Erstellen Sie zuerst mit der bq-CLI ein Dataset in Ihrem Projekt, um das KI-Modell zu speichern:

bq mk --location=$REGION --project_id=$PROJECT_ID iceberg_ai

Lineares Regressionsmodell trainieren

Jetzt trainieren Sie ein lineares Regressionsmodell mit der öffentlichen Lakehouse Iceberg-Tabelle.

Erstellen Sie eine Abfragedatei und trainieren Sie das Modell mit bq query:

cat <<'EOF' > train_model.sql
CREATE OR REPLACE MODEL `iceberg_ai.predict_fare`
OPTIONS(model_type='LINEAR_REG', input_label_cols=['fare_amount']) AS
SELECT fare_amount, passenger_count, CAST(trip_distance AS FLOAT64) AS trip_distance
FROM `bigquery-public-data`.`biglake-public-nyc-taxi-iceberg`.public_data.nyc_taxicab
WHERE fare_amount > 0 AND trip_distance > 0 AND RAND() < 0.01; -- Using 1% of data to downsample
EOF

bq query --location=$REGION --use_legacy_sql=false < train_model.sql

Vorhersagen mit dem Modell

Nachdem das Modell trainiert wurde, können Sie damit Fahrpreise für neue Fahrten mit ML.PREDICT vorhersagen.

Erstellen Sie eine Abfragedatei und führen Sie die Vorhersage mit bq query aus:

cat <<'EOF' > predict_fare.sql
SELECT
  predicted_fare_amount, passenger_count, trip_distance
FROM
  ML.PREDICT(MODEL `iceberg_ai.predict_fare`,
    (
    SELECT 2 AS passenger_count, 5.0 AS trip_distance
    )
  );
EOF

bq query --location=$REGION --use_legacy_sql=false < predict_fare.sql

Die Ausgabe sollte in etwa so aussehen:

+-----------------------+-----------------+---------------+
| predicted_fare_amount | passenger_count | trip_distance |
+-----------------------+-----------------+---------------+
|     14.12252095150709 |               2 |           5.0 |
+-----------------------+-----------------+---------------+

7. Unstrukturierte KI mit Lakehouse

Daten bestehen nicht nur aus Zeilen und Spalten. Unified Data Lakehouses verarbeiten auch unstrukturierte Daten (Bilder, PDFs). Wir verwenden Objekttabellen und Objektreferenzen , um unstrukturierte Daten abzufragen.

Objekttabellen sind schreibgeschützte externe Tabellen in BigQuery, in denen Objekte in einem Cloud Storage-Pfad aufgeführt sind. Jede Zeile stellt eine Datei dar, mit Spalten für Metadaten wie uri, size und einer speziellen Spalte ref mit der ObjectRef.

Objektreferenzen (ObjectRef) verweisen auf die tatsächlichen Daten einer einzelnen Datei. Moderne BigQuery ML-Funktionen wie AI.GENERATE oder AI.AGG verwenden ObjectRef, um Dateiinhalte (Bilder, Audio oder Text) für die Analyse zu lesen, ohne die Bytes in eine Standardtabelle zu laden.

Dataset für unstrukturierte KI erstellen

Erstellen Sie zuerst ein zweites Dataset in Ihrem Projekt, um die Objekttabellen mit der bq-CLI in der Multiregion US zu speichern:

bq mk --location=US --project_id=$PROJECT_ID iceberg_object_ai

Externe Verbindung erstellen

Wenn Sie in Cloud Storage gespeicherte Daten (sowohl Objekttabellen als auch unstrukturierte Daten) aus BigQuery abfragen möchten, müssen Sie eine externe Verbindung erstellen.

Führen Sie in Cloud Shell den folgenden Befehl aus, um eine Cloud-Ressourcenverbindung zu erstellen:

bq mk --connection --project_id=$PROJECT_ID --location=US --connection_type=CLOUD_RESOURCE my-conn

Suchen Sie die Dienstkonto-ID, die für Ihre Verbindung erstellt wurde:

CONNECTION_SA=$(bq show --format=json --project_id=$PROJECT_ID --connection $PROJECT_ID.us.my-conn | jq -r '.serviceAccountId // .cloudResource.serviceAccountId')

Weisen Sie dem Dienstkonto die Rollen Gemini Enterprise Agent Engine User und Storage Object Viewer zu, damit es Gemini-Modelle aufrufen und GCS-Daten lesen kann:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$CONNECTION_SA" \
  --role="roles/aiplatform.user"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$CONNECTION_SA" \
  --role="roles/storage.objectViewer"

Objekttabelle erstellen

Wir verwenden die im vorherigen Abschnitt erstellte externe Verbindung my-conn, um auf unstrukturierte Daten zuzugreifen. Erstellen Sie eine Abfragedatei und erstellen Sie die Objekttabelle mit bq query:

cat <<'EOF' > create_object_table.sql
CREATE EXTERNAL TABLE `iceberg_object_ai.sample_images`
WITH CONNECTION `us.my-conn`
OPTIONS (
  object_metadata = 'SIMPLE',
  uris = ['gs://cloud-samples-data/vision/landmark/*']
);
EOF

bq query --use_legacy_sql=false < create_object_table.sql

Gemini für Objektdaten verwenden

Führen Sie jetzt eine Abfrage mit Gemini aus, um die Bilder zu bewerten, ohne sie herunterzuladen.

Fragen Sie die Bilder mit Standard-SQL über bq query ab:

cat <<EOF > query_images.sql
SELECT
  uri,
  image_analysis.description
FROM (
  SELECT
    uri,
    AI.GENERATE(
      (
        'Identify what is happening in the image.',
        ref
      ),
      connection_id => 'us.my-conn',
      endpoint => 'gemini-2.5-flash-lite',
      output_schema => 'event STRING, severity STRING, description STRING'
    ) AS image_analysis
  FROM
    iceberg_object_ai.sample_images
);
EOF

bq query --use_legacy_sql=false < query_images.sql

Beispielausgabe:

+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                           uri                            |                                                                                                                                                                                                                             description                                                                                                                                                                                                                             |
+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| gs://cloud-samples-data/vision/landmark/eiffel_tower.jpg | The Eiffel Tower stands tall against a cloudy sky, overlooking the Seine River in Paris. Boats are docked along the riverbank, and trees line the opposite shore, with bridges and buildings visible in the distance.                                                                                                                                                                                                                                               |
| gs://cloud-samples-data/vision/landmark/pofa.jpg         | A wide shot shows the Palace of Fine Arts, a monumental structure in San Francisco, California. The building features a large rotunda with a dome, surrounded by colonnades. In front of the rotunda is a lagoon. Several people are walking around the grounds. The sky is blue with a few scattered clouds.                                                                                                                                                       |
| gs://cloud-samples-data/vision/landmark/st_basils.jpeg   | A monument stands in front of Saint Basil's Cathedral in Moscow under a bright blue sky with scattered white clouds. The cathedral features distinctive onion domes in various colors and patterns, including red, blue and white stripes, green and beige stripes, and red and blue diamonds. A large green tree partially obscures the left side of the cathedral. People are visible in the foreground near the base of the monument and the cathedral entrance. |
+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Objektreferenzen direkt untersuchen: Sentimentanalyse

Objekttabellen verwalten Dateireferenzen automatisch. Sie können aber auch direkt mit diesen Objekten interagieren, indem Sie Objektreferenzen von BigQuery verwenden, um Ad-hoc-Analysen für einzelne Dateien auszuführen.

Sie können beispielsweise eine kleine Textdatei verwenden, die in Ihrem eigenen GCS-Bucket gespeichert ist (mit der zuvor erstellten Variablen $DEPS_BUCKET), und sie mit OBJ.MAKE_REF und bq query analysieren.

Erstellen Sie zuerst eine kleine Textdatei und laden Sie sie in Ihren Bucket hoch:

cat <<'EOF' > review.txt
This product is fantastic! It exceeded my expectations. The quality is top-notch. I highly recommend it to everyone!
EOF

gcloud storage cp review.txt gs://${DEPS_BUCKET}/review.txt

Fragen Sie die Datei jetzt mit OBJ.MAKE_REF in Standard-SQL ab:

cat <<EOF > sentiment_analysis.sql
SELECT
  AI.GENERATE(
    (
      'Analyze the sentiment of this text file. Is it positive, negative, or neutral? Explain why.',
      OBJ.MAKE_REF('gs://${DEPS_BUCKET}/review.txt', 'us.my-conn')
    ),
    connection_id => 'us.my-conn',
    endpoint => 'gemini-2.5-flash-lite'
  ).result AS ml_generate_text_result;
EOF

bq query --use_legacy_sql=false < sentiment_analysis.sql

Beispielausgabe:

+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                 ml_generate_text_result                                                                                  |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| This text file has a **strongly positive** sentiment.                                                                                                                                    |
|                                                                                                                                                                                          |
| Here's why:                                                                                                                                                                              |
|                                                                                                                                                                                          |
| *   **Positive Keywords:** The text is filled with unequivocally positive words and phrases:                                                                                             |
|     *   "fantastic"                                                                                                                                                                      |
|     *   "exceeded my expectations"                                                                                                                                                       |
|     *   "top-notch"                                                                                                                                                                      |
|     *   "highly recommend"                                                                                                                                                               |
|                                                                                                                                                                                          |
| *   **Enthusiastic Language:** The use of exclamation marks ("!") further amplifies the positive tone, indicating excitement and strong approval.                                        |
|                                                                                                                                                                                          |
| *   **Lack of Negative or Neutral Elements:** There are no words, phrases, or implications that suggest any dissatisfaction, criticism, or even indifference.                            |
|                                                                                                                                                                                          |
| In summary, the author's language is enthusiastic and uses multiple strong positive descriptors, leaving no room for doubt that their opinion of the product is overwhelmingly positive. |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

8. Bereinigen

Damit Ihrem Google Cloud-Konto keine laufenden Gebühren entstehen, löschen Sie die in diesem Codelab erstellten Ressourcen.

Dataset und Verbindung löschen

Führen Sie in Cloud Shell den folgenden Befehl aus, um Ihre Datasets und die Verbindung zu löschen:

bq rm -r -f --location=$REGION iceberg_ai
bq rm -r -f --location=US iceberg_object_ai
bq rm --connection $PROJECT_ID.US.my-conn

GCS-Buckets und lokale Dateien löschen

Bereinigen Sie die GCS-Buckets und lokalen Dateien:

# Delete GCS buckets
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud storage rm -r gs://dataproc-temp-${REGION}-${PROJECT_NUMBER}-*
gcloud storage rm -r gs://dataproc-staging-${REGION}-${PROJECT_NUMBER}-*
gcloud storage rm -r gs://${DEPS_BUCKET}

# Delete local files
rm -f train_model.sql predict_fare.sql create_object_table.sql query_images.sql sentiment_analysis.sql test.py query.py history.py timetravel.py review.txt

Wenn Sie das Projekt nur für dieses Lab erstellt haben, können Sie es auch vollständig löschen.

9. Glückwunsch

Glückwunsch! Sie haben ein Unified Data Lakehouse mit Apache Iceberg, Lakehouse und BigQuery AI erstellt.

Das haben Sie gelernt

  • Verbindung zu öffentlichen Apache Iceberg REST-Katalogen herstellen und diese abfragen.
  • Time Travel in Iceberg verwenden, um Dataset-Versionen zu prüfen.
  • BigQuery ML-Modelle für strukturierte Daten trainieren.
  • Unstrukturierte Daten (Bilder) mit Objekttabellen und ObjectRef verbinden.
  • Gemini direkt in BigQuery SQL verwenden, um Bilder zu analysieren.

Referenzdokumente