Tworzenie ujednoliconej architektury data lakehouse na potrzeby AI przy użyciu Apache Iceberg i BigLake

1. Wprowadzenie

W tym ćwiczeniu poznasz możliwości Unified Data Lakehouse w Google Cloud. Będziesz wchodzić w interakcje z publicznymi zbiorami danych udostępnianymi za pomocą katalogu REST Apache Iceberg w BigLake, a następnie stosować funkcje AI Google Cloud do danych uporządkowanych i nieuporządkowanych.

Wykonasz zapytanie dotyczące klasycznego zbioru danych NYC Taxi za pomocą Apache Iceberg, skorzystasz z funkcji Time Travel, aby sprawdzić zmiany w danych, a następnie użyjesz BigQuery ML i Gemini do uruchamiania modeli AI na swoich danych.

Jakie zadania wykonasz

  • Użyj Google Cloud Serverless dla Apache Spark, aby wysyłać zapytania do publicznych zbiorów danych Apache Iceberg hostowanych w BigLake.
  • wykonywać zapytania dotyczące uporządkowanych danych w formacie Apache Iceberg;
  • Zaprezentuj Time Travel w Apache Iceberg.
  • Użyj BigQuery ML, aby wytrenować model prognozujący na podstawie danych strukturalnych.
  • Utwórz tabelę obiektów BigLake (dane nieustrukturyzowane) i użyj Gemini do analizowania obrazów.

Czego potrzebujesz

  • przeglądarka, np. Chrome;
  • Projekt Google Cloud z włączonymi płatnościami.

Spodziewany koszt i czas trwania

  • Czas realizacji: około 45 minut.
  • Szacowany koszt: < 2,00 zł. Korzystamy z publicznych zbiorów danych i zapytań bezserwerowych, aby utrzymać niskie koszty.

2. Konfiguracja i wymagania

W tym kroku przygotujesz środowisko i włączysz niezbędne interfejsy API.

Uruchamianie Cloud Shell

Większość poleceń będziesz uruchamiać w Google Cloud Shell.

  1. Kliknij Aktywuj Cloud Shell u góry konsoli Google Cloud.
  2. Potwierdź uwierzytelnianie: 
    gcloud auth list
  3. Potwierdź projekt: 
    gcloud config get project
  4. Jeśli projekt nie jest ustawiony, ustaw go za pomocą identyfikatora projektu: 
    gcloud config set project <YOUR_PROJECT_ID>

Włącz interfejsy API

Aby włączyć wymagane interfejsy API dla BigQuery, Cloud Resource Manager i Vertex AI, uruchom to polecenie:

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

Konfigurowanie środowiska i tworzenie zasobnika zależności

  1. Ustaw zmienne środowiskowe w terminalu:
    export PROJECT_ID=$(gcloud config get project)
export REGION=us-central1
export DEPS_BUCKET=$PROJECT_ID-deps-bucket
  2. Utwórz zasobnik Cloud Storage zależności. Skrypty PySpark są przesyłane tutaj w momencie przesyłania zadania:
    gcloud storage buckets create gs://$DEPS_BUCKET --location=$REGION

3. Nawiązywanie połączenia z publicznym katalogiem Apache Iceberg

W tym kroku połączysz się z działającym w środowisku produkcyjnym katalogiem Apache Iceberg hostowanym w BigLake od Google Cloud.

Uruchamianie Spark SQL za pomocą interfejsu wiersza poleceń Serverless for Apache Spark Batch

Do uruchamiania zadań PySpark bez konieczności zarządzania infrastrukturą będziemy używać Google Cloud Serverless for Apache Spark. Skonfigurujemy go tak, aby wskazywał publiczny katalog BigLake REST.

  1. Zdefiniuj właściwości katalogu BigLake REST, aby uniknąć ich powtarzania.Ta konfiguracja informuje Sparka:
    • Aby korzystać z bibliotek iceberg-spark-runttime i iceberg-gcp-bundle.
    • Aby skonfigurować katalog o nazwie my_catalog za pomocą punktu końcowego katalogu BigLake REST.
    • Aby używać Google Cloud Storage (GCS) do odczytywania plików danych zamiast domyślnego lokalnego systemu plików.
    • Aby ustawić ten katalog my_catalog jako domyślny w naszej sesji.
    • Aby używać dostarczonych danych logowania w celu zwiększenia bezpieczeństwa i uproszczenia dostępu do danych.
    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. Utwórz prosty plik zapytania testowego:
    cat <<EOF > test.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

spark.sql("SHOW TABLES IN public_data").show()
EOF
  3. Prześlij zadanie wsadowe:
    gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  test.py
    Powinny pojawić się dane wyjściowe podobne do tych:
    +-----------+----------------+-----------+
|  namespace|       tableName|isTemporary|
+-----------+----------------+-----------+
|public_data|     nyc_taxicab|      false|
|public_data|nyc_taxicab_2021|      false|
+-----------+----------------+-----------+

4. Wykonywanie zapytań o uporządkowane dane Iceberg

Po połączeniu uzyskasz pełny dostęp do zbiorów danych za pomocą SQL. Wyślemy zapytanie do zbioru danych NYC Taxi modelowanego jako tabela Iceberg.

Uruchamianie standardowego zapytania o agregację

Utwórz plik o nazwie 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

Następnie prześlij go za pomocą usługi 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

W konsoli powinny pojawić się dane wyjściowe podobne do tych:

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

Dlaczego warto używać Apache Iceberg?

  • Przycinanie partycji: zapytanie filtruje dane w kolumnie data_file_year = 2021. Iceberg umożliwia silnikowi całkowite pominięcie skanowania danych z innych lat.
  • Elastyczność silnika: możesz uruchomić tę funkcję w Sparku, Trino lub BigQuery bez kopiowania danych.

5. Podróż w czasie w Apache Iceberg

Jedną z najpotężniejszych funkcji Iceberg jest Time Travel. Umożliwia wysyłanie zapytań dotyczących danych w wersji lub migawce z przeszłości.

Wyświetlanie historii tabeli

Utwórz plik o nazwie 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

i prześlij:

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

W konsoli powinny pojawić się dane wyjściowe podobne do tych poniżej:

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

Zobaczysz wiersze reprezentujące różne identyfikatory migawek i daty ich zatwierdzenia.

Porównywanie bieżącej liczby wierszy z liczbą wierszy z przeszłości

Utwórz plik o nazwie 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

i prześlij:

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

W konsoli powinny pojawić się dane wyjściowe podobne do tych poniżej:

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

Dzięki temu możesz sprawdzać zmiany danych w czasie.

6. Ustrukturyzowana AI z BigQuery ML

Teraz, gdy już znasz dane Iceberg, skorzystajmy z funkcji AI w BigQuery. Publiczny katalog Iceberg jest dostępny tylko do odczytu, więc możemy użyć BigQuery do wytrenowania modelu w naszym obszarze roboczym, odczytując dane z tabel publicznych.

Tworzenie lokalnego zbioru danych

Najpierw utwórz w projekcie zbiór danych do przechowywania modelu AI za pomocą interfejsu wiersza poleceń bq:

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

Trenowanie modelu regresji liniowej

Teraz wytrenujesz model regresji liniowej przy użyciu publicznej tabeli BigLake Iceberg.

Utwórz plik zapytania i wytrenuj model za pomocą 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

Prognozowanie z użyciem modelu

Po wytrenowaniu modelu możesz użyć go do prognozowania opłat za nowe przejazdy za pomocą funkcji ML.PREDICT.

Utwórz plik zapytania i uruchom prognozę za pomocą bq query:

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

Zostaną wyświetlone dane wyjściowe podobne do tych:

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

7. Nieustrukturyzowana AI z BigLake

Dane to nie tylko wiersze i kolumny. Ujednolicone architektury lakehouse obsługują też dane nieuporządkowane (obrazy, pliki PDF). Użyjmy tabel obiektów i odwołań do obiektów, aby wysyłać zapytania o dane nieustrukturyzowane.

Tabele obiektów to tabele zewnętrzne tylko do odczytu w BigQuery, które zawierają listę obiektów w ścieżce Cloud Storage. Każdy wiersz reprezentuje plik, a kolumny zawierają metadane, takie jak uri, size i specjalna kolumna ref zawierająca ObjectRef.

Odwołania do obiektów (ObjectRef) wskazują rzeczywiste dane pojedynczego pliku. Nowoczesne funkcje BigQuery ML (np. AI.GENERATE lub AI.AGG) wykorzystują ObjectRef do odczytywania zawartości plików (obrazów, dźwięku lub tekstu) na potrzeby analizy bez wczytywania bajtów do standardowej tabeli.

Tworzenie zbioru danych dla nieuporządkowanej AI

Najpierw utwórz w projekcie drugi zbiór danych do przechowywania tabel obiektów za pomocą interfejsu wiersza poleceń bq w US regionie obejmującym wiele regionów:

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

Tworzenie połączenia zewnętrznego

Aby wykonywać zapytania na danych przechowywanych w Cloud Storage (zarówno w tabelach obiektów, jak i w danych nieustrukturyzowanych) z poziomu BigQuery, musisz utworzyć zewnętrzne połączenie.

Aby utworzyć połączenie z zasobem Cloud, uruchom w Cloud Shell to polecenie:

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

Znajdź identyfikator konta usługi utworzonego na potrzeby połączenia:

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

Przypisz do konta usługi role użytkownika Vertex AI i wyświetlającego obiekty Cloud Storage, aby mogło wywoływać modele Gemini i odczytywać dane GCS:

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"

Tworzenie tabeli obiektów

Aby uzyskać dostęp do danych nieustrukturyzowanych, użyjemy połączenia zewnętrznego my-conn utworzonego w poprzedniej sekcji. Utwórz plik zapytania i tabelę obiektów za pomocą tego kodu: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

Korzystanie z Gemini na danych o obiektach

Teraz możesz uruchomić zapytanie za pomocą Gemini, aby ocenić obrazy bez ich pobierania.

Wysyłaj zapytania dotyczące obrazów za pomocą standardowej wersji SQL w bq query:

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

Przykładowe dane wyjściowe:

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

Bezpośrednie eksplorowanie obiektów ObjectRef: analiza nastrojów

Tabele obiektów automatycznie zarządzają odwołaniami do plików, ale możesz wchodzić w interakcje z tymi obiektami bezpośrednio za pomocą odwołań do obiektów w BigQuery, aby przeprowadzać analizy pojedynczych plików na bieżąco.

Możesz na przykład użyć małego pliku tekstowego zapisanego we własnym zasobniku GCS (za pomocą utworzonej wcześniej zmiennej $DEPS_BUCKET) i przeanalizować go za pomocą OBJ.MAKE_REF z bq query.

Najpierw utwórz mały plik tekstowy i prześlij go do zasobnika:

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

Teraz wyślij zapytanie do pliku za pomocą znaku OBJ.MAKE_REF w standardowej wersji SQL:

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

Przykładowe dane wyjściowe:

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

Aby uniknąć obciążenia konta Google Cloud bieżącymi opłatami, usuń zasoby utworzone podczas tego ćwiczenia.

Usuwanie zbioru danych i połączenia

Aby usunąć zbiory danych i połączenie, uruchom w Cloud Shell to polecenie:

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

Usuwanie zasobników GCS i plików lokalnych

Zwolnij miejsce w zasobnikach GCS i plikach lokalnych:

# 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

Jeśli projekt został utworzony tylko na potrzeby tego modułu, możesz go usunąć.

9. Gratulacje

Gratulacje! Udało Ci się utworzyć ujednoliconą architekturę data lakehouse przy użyciu Apache Iceberg, BigLake i BigQuery AI.

Czego się dowiedziałeś(-aś)

  • Dowiedz się, jak łączyć się z publicznymi katalogami REST Apache Iceberg i wysyłać do nich zapytania.
  • Korzystanie z funkcji Time Travel w Icebergu do kontrolowania wersji zbioru danych.
  • trenowanie modeli BigQuery ML na danych strukturalnych,
  • Łączenie nieuporządkowanych danych (obrazów) za pomocą tabel obiektów i elementu ObjectRef.
  • Używanie Gemini bezpośrednio w SQL BigQuery do analizowania obrazów.

Dokumentacja