GSP1087
Übersicht
AlloyDB for PostgreSQL ist ein vollständig verwalteter PostgreSQL-kompatibler Datenbankdienst für die anspruchsvollsten Datenbankarbeitslasten Ihres Unternehmens. AlloyDB kombiniert das Beste von Google mit einer der beliebtesten Open-Source-Datenbank-Engines, PostgreSQL. Das sorgt für hervorragende Leistung, Skalierbarkeit und Verfügbarkeit.
Die spaltenbasierte Engine kann die Verarbeitung von SQL-Scans, Joins und Aggregaten in AlloyDB erheblich beschleunigen. Sie bietet die folgenden Funktionen: 1) einen Spaltenspeicher, der Tabellendaten für ausgewählte Spalten enthält, die in ein spaltenorientiertes Format umstrukturiert wurden, und 2) einen spaltenbasierten Abfrageplaner und eine spaltenbasierte Ausführungs-Engine zur Unterstützung des Spaltenspeichers in Abfragen.
In diesem Lab lernen Sie Funktionen der spaltenbasierten Engine von AlloyDB kennen.
Aufgaben
Aufgaben in diesem Lab:
- Referenz-Dataset zum Testen der spaltenbasierten Engine erstellen
- Referenztest ausführen
- Datenbank-Flag für die spaltenbasierte Engine überprüfen
- Datenbankerweiterung für die spaltenbasierte Engine festlegen oder überprüfen
- Spaltenbasierte Engine testen
Einrichtung und Anforderungen
Vor dem Klick auf „Start Lab“ (Lab starten)
Lesen Sie diese Anleitung. Labs sind zeitlich begrenzt und können nicht pausiert werden. Der Timer beginnt zu laufen, wenn Sie auf Lab starten klicken, und zeigt Ihnen, wie lange Google Cloud-Ressourcen für das Lab verfügbar sind.
In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung durchführen – nicht in einer Simulations- oder Demo-Umgebung. Dazu erhalten Sie neue, temporäre Anmeldedaten, mit denen Sie für die Dauer des Labs auf Google Cloud zugreifen können.
Für dieses Lab benötigen Sie Folgendes:
- Einen Standardbrowser (empfohlen wird Chrome)
Hinweis: Nutzen Sie den privaten oder Inkognitomodus (empfohlen), um dieses Lab durchzuführen. So wird verhindert, dass es zu Konflikten zwischen Ihrem persönlichen Konto und dem Teilnehmerkonto kommt und zusätzliche Gebühren für Ihr persönliches Konto erhoben werden.
- Zeit für die Durchführung des Labs – denken Sie daran, dass Sie ein begonnenes Lab nicht unterbrechen können.
Hinweis: Verwenden Sie für dieses Lab nur das Teilnehmerkonto. Wenn Sie ein anderes Google Cloud-Konto verwenden, fallen dafür möglicherweise Kosten an.
Lab starten und bei der Google Cloud Console anmelden
-
Klicken Sie auf Lab starten. Wenn Sie für das Lab bezahlen müssen, wird ein Dialogfeld geöffnet, in dem Sie Ihre Zahlungsmethode auswählen können.
Auf der linken Seite befindet sich der Bereich „Details zum Lab“ mit diesen Informationen:
- Schaltfläche „Google Cloud Console öffnen“
- Restzeit
- Temporäre Anmeldedaten für das Lab
- Ggf. weitere Informationen für dieses Lab
-
Klicken Sie auf Google Cloud Console öffnen (oder klicken Sie mit der rechten Maustaste und wählen Sie Link in Inkognitofenster öffnen aus, wenn Sie Chrome verwenden).
Im Lab werden Ressourcen aktiviert. Anschließend wird ein weiterer Tab mit der Seite „Anmelden“ geöffnet.
Tipp: Ordnen Sie die Tabs nebeneinander in separaten Fenstern an.
Hinweis: Wird das Dialogfeld Konto auswählen angezeigt, klicken Sie auf Anderes Konto verwenden.
-
Kopieren Sie bei Bedarf den folgenden Nutzernamen und fügen Sie ihn in das Dialogfeld Anmelden ein.
{{{user_0.username | "Username"}}}
Sie finden den Nutzernamen auch im Bereich „Details zum Lab“.
-
Klicken Sie auf Weiter.
-
Kopieren Sie das folgende Passwort und fügen Sie es in das Dialogfeld Willkommen ein.
{{{user_0.password | "Password"}}}
Sie finden das Passwort auch im Bereich „Details zum Lab“.
-
Klicken Sie auf Weiter.
Wichtig: Sie müssen die für das Lab bereitgestellten Anmeldedaten verwenden. Nutzen Sie nicht die Anmeldedaten Ihres Google Cloud-Kontos.
Hinweis: Wenn Sie Ihr eigenes Google Cloud-Konto für dieses Lab nutzen, können zusätzliche Kosten anfallen.
-
Klicken Sie sich durch die nachfolgenden Seiten:
- Akzeptieren Sie die Nutzungsbedingungen.
- Fügen Sie keine Wiederherstellungsoptionen oder Zwei-Faktor-Authentifizierung hinzu (da dies nur ein temporäres Konto ist).
- Melden Sie sich nicht für kostenlose Testversionen an.
Nach wenigen Augenblicken wird die Google Cloud Console in diesem Tab geöffnet.
Hinweis: Wenn Sie auf Google Cloud-Produkte und ‑Dienste zugreifen möchten, klicken Sie auf das Navigationsmenü oder geben Sie den Namen des Produkts oder Dienstes in das Feld Suchen ein.
Cloud Shell aktivieren
Cloud Shell ist eine virtuelle Maschine, auf der Entwicklertools installiert sind. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud. Mit Cloud Shell erhalten Sie Befehlszeilenzugriff auf Ihre Google Cloud-Ressourcen.
-
Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren 
.
-
Klicken Sie sich durch die folgenden Fenster:
- Fahren Sie mit dem Informationsfenster zu Cloud Shell fort.
- Autorisieren Sie Cloud Shell, Ihre Anmeldedaten für Google Cloud API-Aufrufe zu verwenden.
Wenn eine Verbindung besteht, sind Sie bereits authentifiziert und das Projekt ist auf Project_ID, eingestellt. Die Ausgabe enthält eine Zeile, in der die Project_ID für diese Sitzung angegeben ist:
Ihr Cloud-Projekt in dieser Sitzung ist festgelegt als {{{project_0.project_id | "PROJECT_ID"}}}
gcloud ist das Befehlszeilentool für Google Cloud. Das Tool ist in Cloud Shell vorinstalliert und unterstützt die Tab-Vervollständigung.
- (Optional) Sie können den aktiven Kontonamen mit diesem Befehl auflisten:
gcloud auth list
- Klicken Sie auf Autorisieren.
Ausgabe:
ACTIVE: *
ACCOUNT: {{{user_0.username | "ACCOUNT"}}}
Um das aktive Konto festzulegen, führen Sie diesen Befehl aus:
$ gcloud config set account `ACCOUNT`
- (Optional) Sie können die Projekt-ID mit diesem Befehl auflisten:
gcloud config list project
Ausgabe:
[core]
project = {{{project_0.project_id | "PROJECT_ID"}}}
Hinweis: Die vollständige Dokumentation für gcloud finden Sie in Google Cloud in der Übersicht zur gcloud CLI.
Aufgabe 1: Referenz-Dataset zum Testen der spaltenbasierten Engine erstellen
In dieser Lab-Umgebung werden ein AlloyDB-Cluster und eine AlloyDB-Instanz bereitgestellt, wenn Sie das Lab starten.
- Klicken Sie in der Google Cloud Console auf das Navigationsmenü (
) und dann auf Alle Produkte ansehen. Wählen Sie anschließend unter Datenbanken die Option AlloyDB for PostgreSQL aus.
Auf der AlloyDB-Seite werden ein Cluster namens lab-cluster und eine Instanz namens lab-instance angezeigt. Es dauert einige Minuten, bis die Instanz vollständig erstellt und initialisiert ist.
Warten Sie, bis in der Spalte Ressourcenname neben der Instanz lab-instance ein grünes Häkchen (Status Bereit) angezeigt wird, bevor Sie mit dem nächsten Schritt fortfahren.
- Kopieren Sie in der Zeile für die Instanz lab-instance unter Private IP-Adresse die private IP-Adresse (z. B.
10.100.0.2) in eine Textdatei, sodass Sie den Wert in einem späteren Schritt einfügen können. Lassen Sie den Doppelpunkt und die Portnummer (:5432) weg.
Zum Bewerten der Funktionen der spaltenbasierten Engine benötigen Sie ein Dataset von beträchtlicher Größe, anhand dessen Sie die Leistung messen können. In den nächsten Schritten verwenden Sie das PostgreSQL-Tool pgbench, um ein synthetisches Dataset zum Bewerten der spaltenbasierten Engine zu generieren.
-
Klicken Sie im Navigationsmenü (
) unter Compute Engine auf VM-Instanzen.
-
Klicken Sie für die Instanz alloydb-client in der Spalte Verbinden auf SSH, um ein Terminalfenster zu öffnen.
-
Legen Sie die folgende Umgebungsvariable fest und ersetzen Sie ALLOYDB_ADDRESS durch die private IP-Adresse der AlloyDB-Instanz.
export ALLOYDB=ALLOYDB_ADDRESS
- Führen Sie den folgenden Befehl aus, um die private IP-Adresse der AlloyDB-Instanz auf der AlloyDB-Client-VM zu speichern, damit sie während des gesamten Labs erhalten bleibt.
echo $ALLOYDB > alloydbip.txt
- Der erste Schritt in pgbench besteht darin, Beispieltabellen zu erstellen und mit Daten zu füllen. Führen Sie den folgenden Befehl aus, um vier Tabellen zu erstellen. Sie werden aufgefordert, das Passwort für das postgres-Nutzungskonto einzugeben. Das Passwort lautet Change3Me.
Die größte Tabelle pgbench_accounts wird mit 50 Millionen Zeilen geladen. Der Vorgang dauert einige Minuten.
pgbench -h $ALLOYDB -U postgres -i -s 500 -F 90 -n postgres
dropping old tables...
NOTICE: table "pgbench_accounts" does not exist, skipping
NOTICE: table "pgbench_branches" does not exist, skipping
NOTICE: table "pgbench_history" does not exist, skipping
NOTICE: table "pgbench_tellers" does not exist, skipping
creating tables...
generating data (client-side)...
50000000 of 50000000 tuples (100%) done (elapsed 91.26 s, remaining 0.00 s)
creating primary keys...
done in 167.61 s (drop tables 0.00 s, create tables 0.01 s, client-side generate 93.16 s, primary keys 74.43 s).
- Stellen Sie eine Verbindung zum psql-Client her. Führen Sie dann die folgende Abfrage aus, um die Anzahl der Zeilen in der Tabelle pgbench_accounts zu überprüfen. Sie werden aufgefordert, das Passwort für das postgres-Nutzungskonto einzugeben. Das Passwort lautet Change3Me.
psql -h $ALLOYDB -U postgres
select count (*) from pgbench_accounts;
count
----------
50000000
(1 row)
Klicken Sie auf Fortschritt prüfen.
Referenz-Dataset erstellen
Aufgabe 2: Referenztest ausführen
Zu Bewertungszwecken können Sie mit einer sehr einfachen Abfrage sequenzielle Scans ausführen und dann vor und nach dem Hinzufügen der Testtabelle zur spaltenbasierten Engine Abfragepläne zur Erklärung dieser Abfrage verwenden.
- Kehren Sie zur alloydb-client-Shell zurück. Der psql-Client müsste noch aktiv sein. Falls nicht, stellen Sie die Verbindung anhand der Anleitung in Aufgabe 1 wieder her. Führen Sie die folgende Abfrage aus, um Zeitangaben für alle Abfragevorgänge zu aktivieren.
\timing on
- Führen Sie dann die folgende Abfrage aus, um die Ausführungszeit zu bewerten. Diese Abfrage führt sequenzielle Scans der gesamten Tabelle pgbench_accounts aus.
Hinweis: Da diese Beispielabfrage nur zu Demonstrationszwecken dient, ist sie auf 20 zurückgegebene Zeilen begrenzt.
SELECT aid, bid, abalance FROM pgbench_accounts WHERE bid < 189 OR abalance > 100 LIMIT 20;
aid | bid | abalance
-----+-----+----------
1 | 1 | 0
2 | 1 | 0
3 | 1 | 0
4 | 1 | 0
5 | 1 | 0
6 | 1 | 0
7 | 1 | 0
8 | 1 | 0
9 | 1 | 0
10 | 1 | 0
11 | 1 | 0
12 | 1 | 0
13 | 1 | 0
14 | 1 | 0
15 | 1 | 0
16 | 1 | 0
17 | 1 | 0
18 | 1 | 0
19 | 1 | 0
20 | 1 | 0
(20 rows)
- Führen Sie die folgende Abfrage aus, um einen Plan zur Erklärung einer uneingeschränkten Abfrage zu generieren. Ihre Werte sollten denen in der Beispielausgabe ähneln, können jedoch aufgrund der Zufälligkeit der Datengenerierung variieren.
Hinweis: Möglicherweise müssen Sie die Leertaste drücken, um den Plan zur Erklärung der Abfrage durchzugehen.
EXPLAIN (ANALYZE,COSTS,SETTINGS,BUFFERS,TIMING,SUMMARY,WAL,VERBOSE)
SELECT count(*) FROM pgbench_accounts WHERE bid < 189 OR abalance > 100;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------
---------------------------------------------------
Finalize Aggregate (cost=1242226.53..1242226.54 rows=1 width=8) (actual time=11010.409..11014.083 rows=1 loop
s=1)
Output: count(*)
Buffers: shared hit=20921 read=888170
I/O Timings: read=19536.769
-> Gather (cost=1242226.32..1242226.53 rows=2 width=8) (actual time=11010.398..11014.075 rows=3 loops=1)
Output: (PARTIAL count(*))
Workers Planned: 2
Workers Launched: 2
Buffers: shared hit=20921 read=888170
I/O Timings: read=19536.769
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!! Section removed for pasting !!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Filter: ((pgbench_accounts.bid < 189) OR (pgbench_accounts.abalance > 100))
Rows Removed by Filter: 10400000
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!! Section removed for pasting !!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Buffers: shared hit=6
Planning Time: 0.117 ms
Execution Time: 11014.169 ms
(38 rows)
-
Achten Sie in den Ergebnissen besonders auf die Werte von Planning Time und Execution Time. In der Beispielausgabe beträgt der Wert von Planning Time 0,117 Millisekunden und der Wert von Execution Time 11.014,169 Millisekunden oder 11,014 Sekunden. Ihre Werte sollten denen in der Beispielausgabe ähneln, können jedoch aufgrund der Zufälligkeit der Datengenerierung variieren.
-
Kopieren Sie die Werte von Planning Time und Execution Time aus Ihrer Ausführung in eine Textdatei, sodass Sie sie später nach Aktivierung der spaltenbasierten Engine mit den Ergebnissen vergleichen können. Sie können auch die gesamten Ergebnisse des Abfrageplans in eine Textdatei kopieren.
-
Drücken Sie die Taste Q, um den Abfrageplan zu schließen.
Aufgabe 3: Datenbank-Flag für die spaltenbasierte Engine überprüfen
In dieser Aufgabe sehen Sie sich das Datenbank-Flag für die spaltenbasierte Engine in der Instanz an.
-
Klicken Sie in der Google Cloud Console auf das Navigationsmenü () und dann auf Alle Produkte ansehen. Wählen Sie anschließend unter Datenbanken die Option AlloyDB for PostgreSQL aus.
-
Klicken Sie in der Zeile für die Instanz lab-instance auf Aktionen (Symbol für Dreipunktmenü) und dann auf Bearbeiten.
-
Maximieren Sie den Bereich Erweiterte Konfigurationsoptionen.
-
Klicken Sie unter Flags auf Datenbank-Flag hinzufügen.
-
Klicken Sie auf Flag auswählen, um die Liste der verfügbaren Flags durchzugehen und sich ein Bild von den unterstützten Optionen zu machen.
Sie sehen, dass das Flag google_columnar_engine.enabled bereits aktiviert ist (Status An). In diesem Lab werden Sie kein zusätzliches Flag hinzufügen.
- Klicken Sie auf Abbrechen, um die Seite Bearbeiten für die Instanz zu verlassen.
Aufgabe 4: Datenbankerweiterung für die spaltenbasierte Engine festlegen oder überprüfen
Anknüpfend an den vorherigen Abschnitt richten Sie in dieser Aufgabe eine Datenbankerweiterung ein, um die spaltenbasierte Engine für den AlloyDB-Cluster vollständig zu aktivieren.
Zum Aktivieren einer Datenbankerweiterung müssen Sie, anders als beim Konfigurieren eines Flags, über den psql-Client eine Verbindung zur Instanz herstellen.
-
Kehren Sie zur alloydb-client-Shell zurück. Der psql-Client müsste noch aktiv sein. Falls nicht, stellen Sie die Verbindung anhand der Anleitung in Aufgabe 1 wieder her.
-
Prüfen Sie, ob Sie mit der Datenbank postgres verbunden sind, indem Sie die folgende Abfrage ausführen.
\c postgres
- Führen Sie die folgende Systemabfrage aus, um Details zu den in der Datenbank aktivierten Erweiterungen zu sehen.
Hinweis: Ihre Liste der Erweiterungen kann abweichen.
\dx
List of installed extensions
Name | Version | Schema | Description
------------------------+---------+------------+---------------------------------------
google_columnar_engine | 1.0 | public | Google extension for columnar engine
google_db_advisor | 1.0 | public | Google extension for Database Advisor
hypopg | 1.3.2 | public | Hypothetical indexes for PostgreSQL
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
(4 rows)
- Wenn google_columnar_engine in der Liste angezeigt wird, fahren Sie mit der nächsten Aufgabe (Aufgabe 5) fort. Ist google_columnar_engine nicht in der Liste enthalten, führen Sie den folgenden Befehl aus.
CREATE EXTENSION IF NOT EXISTS google_columnar_engine;
- Führen Sie die Erweiterungsabfrage noch einmal aus, um zu bestätigen, dass die Erweiterung google_columnar_engine aktiviert ist.
\dx
Aufgabe 5: Spaltenbasierte Engine testen
Da Ihre Haupttabelle (pgbench_accounts) relativ klein ist, können Sie sie zur Bewertung direkt in die spaltenbasierte Engine einfügen. In einer realen Bereitstellung würden Sie das Empfehlungsframework der spaltenbasierten Engine nutzen, um automatisch diejenigen Spalten in allen Tabellen zu identifizieren, die am häufigsten verwendet werden und von der Verwaltung durch die Engine am meisten profitieren würden.
- Kehren Sie zur alloydb-client-Shell zurück. Führen Sie die folgende Abfrage aus, um pgbench_accounts in die spaltenbasierte Engine einzufügen. Die Abfrage kann einige Minuten dauern.
SELECT google_columnar_engine_add('pgbench_accounts');
- Führen Sie als Nächstes denselben Plan zur Erklärung der Abfrage wie zuvor aus, um die Auswirkungen der spaltenbasierten Engine zu sehen. Ihre Werte sollten denen in der Beispielausgabe ähneln, können jedoch aufgrund der Zufälligkeit der Datengenerierung variieren.
EXPLAIN (ANALYZE,COSTS,SETTINGS,BUFFERS,TIMING,SUMMARY,WAL,VERBOSE)
SELECT count(*) FROM pgbench_accounts WHERE bid < 189 OR abalance > 100;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Finalize Aggregate (cost=142400.72..142400.73 rows=1 width=8) (actual time=75.948..78.680 rows=1 loops=1)
Output: count(*)
-> Gather (cost=142400.51..142400.72 rows=2 width=8) (actual time=71.555..78.667 rows=3 loops=1)
Output: (PARTIAL count(*))
Workers Planned: 2
Workers Launched: 2
-> Partial Aggregate (cost=141400.51..141400.52 rows=1 width=8) (actual time=45.768..45.771 rows=1 loops=3)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Section removed for pasting
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Rows Removed by Columnar Filter: 10400000
Rows Aggregated by Columnar Scan: 4505600
Columnar cache search mode: native
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Section removed for pasting
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Buffers: shared hit=22 read=3 dirtied=1
I/O Timings: read=0.560
Planning Time: 2.022 ms
Execution Time: 78.804 ms
(29 rows)
-
Achten Sie in den Ergebnissen besonders auf die Werte von Planning Time und Execution Time. Im Beispiel nach Aktivierung der spaltenbasierten Engine beträgt der Wert von Planning Time 2,022 Millisekunden und der Wert von Execution Time 78,804 Millisekunden. Ihre Werte sollten denen in der Beispielausgabe ähneln, können jedoch aufgrund der Zufälligkeit der Datengenerierung variieren.
-
Anhand der bereitgestellten Beispiele lässt sich der Unterschied zwischen dem Wert von „Execution Time“ vor und nach Aktivierung der spaltenbasierten Engine mit 10.935,365 ms oder 10,9 Sekunden beziffern. Dies entspricht einer Reduzierung um den Faktor 141. Im Beispiel nach Aktivierung der spaltenbasierten Engine sehen Sie auch, dass über 4,5 Millionen Zeilen mit einem spaltenbasierten Scan statt der Haupt-Datenbank-Engine aggregiert wurden.
Klicken Sie auf Fortschritt prüfen.
Spaltenbasierte Engine testen
Hinweis: Wenn Ihre Punktzahl nach Abschluss aller Aufgaben nicht vollständig aktualisiert wird, maximieren Sie das Feld Prüfpunkte (die gelbe Seitenleiste rechts auf der Seite) und klicken Sie für jede Aufgabe auf Fortschritt prüfen. So wird die Punktzahl aktualisiert.
Das wars! Sie haben das Lab erfolgreich abgeschlossen.
Sie haben nun leistungsstarke Funktionen der spaltenbasierten Engine von AlloyDB kennengelernt.
Google Cloud-Schulungen und -Zertifizierungen
In unseren Schulungen erfahren Sie alles zum optimalen Einsatz unserer Google Cloud-Technologien und können sich entsprechend zertifizieren lassen. Unsere Kurse vermitteln technische Fähigkeiten und Best Practices, damit Sie möglichst schnell mit Google Cloud loslegen und Ihr Wissen fortlaufend erweitern können. Wir bieten On-Demand-, Präsenz- und virtuelle Schulungen für Anfänger wie Fortgeschrittene an, die Sie individuell in Ihrem eigenen Zeitplan absolvieren können. Mit unseren Zertifizierungen weisen Sie nach, dass Sie Experte im Bereich Google Cloud-Technologien sind.
Anleitung zuletzt am 16. Januar 2025 aktualisiert
Lab zuletzt am 15. Dezember 2025 getestet
© 2026 Google LLC. Alle Rechte vorbehalten. Google und das Google-Logo sind Marken von Google LLC. Alle anderen Unternehmens- und Produktnamen können Marken der jeweils mit ihnen verbundenen Unternehmen sein.
