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

1. Einführung

In diesem Codelab lernen Sie die Funktionen des Unified Data Lakehouse in Google Cloud kennen. Sie arbeiten mit öffentlichen Datasets, die über den Apache Iceberg REST Catalog in BigLake 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, sehen sich Zeitreisen an, um Datenänderungen zu prüfen, und verwenden dann BigQuery ML und Gemini, um KI-Modelle für Ihre Daten auszuführen.

Aufgaben

  • Mit Google Cloud Serverless for Apache Spark können Sie öffentliche Apache Iceberg-Datasets abfragen, die in BigLake gehostet werden.
  • Strukturierte Daten im Apache Iceberg-Format abfragen.
  • Time Travel in Apache Iceberg demonstrieren
  • Mit BigQuery ML können Sie ein Vorhersagemodell für strukturierte Daten trainieren.
  • Erstellen Sie eine BigLake-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

  • Zeitaufwand: ca. 45 Minuten.
  • Geschätzte Kosten: unter 2,00 $. 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 über die Google Cloud Shell ausgeführt.

  1. Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren.
  2. Authentifizierung überprü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 Vertex AI 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-Scripts werden beim Senden des Jobs hier 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 BigLake von Google Cloud gehostet wird.

Spark SQL mit der Batch-CLI für Serverless for Apache Spark ausführen

Wir verwenden Google Cloud Serverless for Apache Spark, um PySpark-Jobs auszuführen, ohne die Infrastruktur verwalten zu müssen. Wir konfigurieren ihn so, dass er auf den öffentlichen BigLake REST-Katalog verweist.

  1. Definieren Sie die BigLake REST-Katalogattribute, um sie nicht wiederholen zu müssen.Diese Konfiguration weist Spark an:
    • Um die Bibliotheken iceberg-spark-runttime und iceberg-gcp-bundle zu verwenden.
    • So konfigurieren Sie einen Katalog mit dem Namen my_catalog mit dem BigLake REST Catalog-Endpunkt:
    • Google Cloud Storage (GCS) zum Lesen von Datendateien anstelle des standardmäßigen lokalen Dateisystems verwenden.
    • Um diesen my_catalog-Katalog als Standard für unsere Sitzung festzulegen,
    • Um bereitgestellte Anmeldedaten für mehr Sicherheit und einen einfacheren 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. Senden 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
    Die Ausgabe sollte in etwa so aussehen:
    +-----------+----------------+-----------+
|  namespace|       tableName|isTemporary|
+-----------+----------------+-----------+
|public_data|     nyc_taxicab|      false|
|public_data|nyc_taxicab_2021|      false|
+-----------+----------------+-----------+

4. Strukturierte Iceberg-Daten abfragen

Sobald die Verbindung hergestellt ist, haben Sie vollen 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

Senden Sie ihn mit Serverless for 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

In der Konsole sollte eine ähnliche Ausgabe angezeigt werden:

+---------------+---------+--------+------------+
|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 verwenden?

  • Partition Pruning: Die Abfrage wird nach data_file_year = 2021 gefiltert. Mit Iceberg kann die Engine das Scannen von Daten aus anderen Jahren vollständig überspringen.
  • Engine Agility: Sie können diese Funktion 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. So können Sie Daten 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

Senden Sie es:

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 Konsole sollte eine Ausgabe ähnlich der folgenden angezeigt werden:

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

Es werden Zeilen mit verschiedenen Snapshot-IDs und dem Zeitpunkt angezeigt, zu dem sie übernommen wurden.

Aktuelle Zeilenanzahl mit der vorherigen 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

Senden Sie es:

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 Konsole sollte eine Ausgabe ähnlich der folgenden angezeigt werden:

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

So können Sie Datenänderungen im Zeitverlauf nachvollziehen.

6. Strukturierte KI mit BigQuery ML

Nachdem Sie sich die Iceberg-Daten angesehen haben, wollen wir nun die KI-Funktionen von BigQuery nutzen. 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 ein Dataset in Ihrem Projekt, um das KI-Modell mit der bq CLI zu speichern:

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

Lineares Regressionsmodell trainieren

Jetzt trainieren Sie ein lineares Regressionsmodell mit der öffentlichen BigLake 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 treffen

Nachdem das Modell trainiert wurde, können Sie es verwenden, um Fahrpreise für neue Fahrten mit ML.PREDICT vorherzusagen.

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. Unstructured AI mit BigLake

Daten bestehen nicht nur aus Zeilen und Spalten. Unified Data Lakehouses können auch unstrukturierte Daten (Bilder, PDFs) verarbeiten. 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 steht für eine Datei mit Spalten für Metadaten wie uri, size und einer speziellen ref-Spalte mit dem ObjectRef.

Objektreferenzen (ObjectRef) verweisen auf die tatsächlichen Daten einer einzelnen Datei. Moderne BigQuery ML-Funktionen wie AI.GENERATE oder AI.AGG verarbeiten ObjectRef, um Dateiinhalte (Bilder, Audio oder Text) für die Analyse zu lesen, ohne die Byte 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-Befehlszeile in der multiregionalen US-Region zu speichern:

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

Externe Verbindung erstellen

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

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

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

So finden 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 Vertex AI 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

Jetzt können Sie mit Gemini eine Anfrage ausführen, um die Bilder zu bewerten, ohne sie herunterzuladen.

Bilder mit Standard-SQL über bq query abfragen:

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. |
+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

ObjectRefs direkt untersuchen: Sentimentanalyse

Während Dateireferenzen in Objekttabellen automatisch verwaltet werden, können Sie mit diesen Objekten direkt interagieren, indem Sie Objektreferenzen in BigQuery verwenden, um 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 Variable $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 nun 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

Löschen Sie die in diesem Codelab erstellten Ressourcen, um laufende Gebühren für Ihr Google Cloud-Konto zu vermeiden.

Dataset und Verbindung löschen

Führen Sie in Cloud Shell Folgendes 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

GCS-Buckets und lokale Dateien bereinigen:

# 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 erfolgreich ein Unified Data Lakehouse mit Apache Iceberg, BigLake und BigQuery AI erstellt.

Das haben Sie gelernt

  • Öffentliche Apache Iceberg-REST-Kataloge verbinden und abfragen
  • Zeitreise in Iceberg verwenden, um Dataset-Versionen zu prüfen.
  • Trainieren von BigQuery ML-Modellen mit strukturierten Daten.
  • Unstrukturierte Daten (Bilder) mithilfe von Objekttabellen und ObjectRef verbinden.
  • Gemini direkt in BigQuery SQL zum Analysieren von Bildern verwenden.

Referenzdokumente