BigQuery-Reservierungen überwachen
Als BigQuery-Administrator können Sie Reservierungen in Ihrem Projekt überwachen. Sehen Sie sich dazu die Nutzung von Projekt- und Reservierungs-Slots an und rufen Sie Ihre kapazitätsbasierte Abrechnung auf.
Nutzung von Projekt- und Reservierungs-Slots ansehen
Sie können die Nutzung von Projekt- und Reservierungs-Slots so aufrufen:
INFORMATION_SCHEMAAufrufe. Fragen Sie dieINFORMATION_SCHEMA.JOBS*-Ansichten ab, um Informationen zur Projekt- und Reservierungsnutzung abzurufen.Das Feld
reservation_idin denINFORMATION_SCHEMA.JOBS*-Ansichten enthält den Reservierungsnamen.Google Cloud Console. Die Google Cloud Console enthält Diagramme zur Anzeige der Slot-Nutzung. Weitere Informationen finden Sie unter Diagramme zu administrativen Ressourcen verwenden.
Job-Explorer. Mit dem Job-Explorer können Sie Jobs nach Reservierung in Ihrer Organisation gruppieren und zusammenfassende Statistiken aufrufen, einschließlich Slot-Zeit, aktiver Jobs und Jobs in der Warteschlange.
Audit-Logs Verwenden Sie Audit-Logs, um Messwerte zur Slot-Nutzung anzuzeigen.
Die Methode
Jobs. Verwenden Sie die API-MethodeJobs, um Messwerte zur Slot-Nutzung für einen Job aufzurufen.Cloud Monitoring Mit Cloud Monitoring können Sie Dashboards erstellen, um Ihre zugewiesenen Slots zu überwachen. Mit einem Cloud Monitoring-Dashboard können Sie die Slot-Nutzung für jede Reservierung und jeden Jobtyp für alle Projekte innerhalb der Reservierung aufrufen. Wenn Sie Slot-Nutzungsmesswerte für alle Projekte aufrufen möchten, die eine Reservierung nutzen, müssen Sie diese nutzenden Projekte explizit dem Messwertbereich des Projekts hinzufügen, in dem Sie die Messwerte überwachen. Weitere Informationen zu den für das Cloud Monitoring-Dashboard verfügbaren Messwerten finden Sie unter Für die Visualisierung verfügbare Messwerte.

Slot-Messwerte verstehen
Wenn Sie die BigQuery-Rechenkapazität effektiv überwachen und verwalten möchten, müssen Sie zwischen zugewiesenen Slots und genutzten Slots unterscheiden:
- Zugewiesene Slots
- Die Kapazität, die Ihrem Projekt über Baseline-Slots und aktive Kapazitätszusicherungen zugewiesen ist. Zugewiesene Slots wirken sich auf Ihr Kontingent und Ihre Abrechnung aus.
- Genutzte Slots
- Die Kapazität, die während der Abfrageausführung aktiv von laufenden Jobs verbraucht wird. Genutzte Slots werden in den Diagrammen zur Ressourcennutzung angezeigt.
Da Baseline-Slots dedizierte Ressourcen sind, werden sie vom Kontingentsystem als „verwendet“ gemeldet, auch wenn keine Abfragen aktiv ausgeführt werden. Daher kann die auf der Seite Kontingente und Systemlimits gemeldete Kontingentnutzung höher sein als die tatsächliche Slot-Nutzung, die auf der Seite Monitoring angezeigt wird.
Vergleich von Slot-Messwerten
In der folgenden Tabelle wird verglichen, wie Slot-Messwerte in der Google Cloud Console berechnet und angezeigt werden:
| Google Cloud Console-Seite | Angezeigter Messwert | Was gezählt wird | Quelle der Abweichung |
|---|---|---|---|
| Kontingente und Systemlimits | Verwendetes Kontingent (Gesamtzahl der Slots; siehe Diagramme zur Kontingentnutzung) | Zugewiesene Slots: Referenzslots für Reservierungen und aktive Zusicherungen. | Umfasst inaktive Referenzslots und inaktive Failover-Reservierungen in sekundären Regionen. Autoscaling-Slots werden nicht gezählt. |
| Monitoring | Slot-Nutzung (Diagramme zur Ressourcennutzung) | Genutzte Slots: Recheneinheiten, die von laufenden Jobs aktiv genutzt werden. | Umfasst Autoscaling-Bursts, die aktiv Jobs verarbeiten. Ausgenommen sind inaktive Referenzslots und inaktive Failover-Reservierungen. |
Häufige Ursachen für Abweichungen bei der Slot-Nutzung
Wenn Sie Slot-Messwerte zwischen der Seite Kontingente und Systemlimits und der Seite Monitoring abgleichen, sollten Sie die folgenden häufigen Ursachen für Abweichungen berücksichtigen:
- Inaktive Referenz-Slots: Sie haben Referenz-Slots reserviert, auf denen keine Abfragen aktiv ausgeführt werden. Da Baseline-Slots dedizierte Kapazität sind, werden sie vom Kontingentsystem als verwendet behandelt. In Auslastungsdiagrammen werden jedoch nur die Slots angezeigt, die aktiv Arbeitslasten ausführen.
- Failover-Reservierungen: Wenn Sie die verwaltete Notfallwiederherstellung konfigurieren, werden die Baseline-Slots für eine Failover-Reservierung in der sekundären Region zugewiesen. Diese Slots werden in der sekundären Region als genutztes Kontingent angezeigt, auch wenn die Reservierung inaktiv ist und kein Failover stattgefunden hat. Weitere Informationen finden Sie unter Kontingentüberlegungen für Failover-Reservierungen.
- Autoscaling-Bursts: Die Diagramme zur Ressourcennutzung enthalten Autoscaling-Slots, die aktiv Jobs verarbeiten. Auf der Seite Kontingente und Systemlimits wird dagegen nur die statisch zugewiesene Kapazität (Baseline und Zusicherungen) angezeigt. Slots für das Autoscaling werden nicht berücksichtigt.
Kapazitätsbasierte Abrechnung anzeigen
So rufen Sie Ihre kapazitätsbasierte Abrechnung in Echtzeit auf:
Rufen Sie in der Google Cloud Console die Seite Abrechnung auf.
Wählen Sie das Rechnungskonto aus, für das Sie die Rechnung aufrufen möchten.
Wechseln Sie zum Abschnitt Berichte und gehen Sie im Abschnitt Filter so vor:
- Wählen Sie in der Liste Dienste die Option BigQuery und alle zutreffenden Antworten aus.
- Wählen Sie in der Liste SKUs die Option Alle Artikelnummern aus.
Compute-Kosten einzelnen Projekten zuordnen
Standardmäßig werden bei der kapazitätsbasierten Preisgestaltung für BigQuery-Versionen alle Rechengebühren dem zentralen Verwaltungsprojekt in Rechnung gestellt, das Reservierungen und Kapazitätszusicherungen verwaltet.
Damit Sie Budgets auf Projektebene schätzen und interne Rückbuchungen durchführen können, bietet BigQuery zwei Möglichkeiten, den Ressourcenverbrauch in den einzelnen Abfrageprojekten zu verfolgen, die die Reservierung verwenden:
- Informative Slot-Zuordnung (Standard): Eine informative Position in Ihrem Abrechnungsbericht, die die pro Projekt verwendeten Slot-Stunden zeigt. Die tatsächlichen Rechengebühren werden weiterhin dem Administrationsprojekt in Rechnung gestellt.
- Zuordnung der in Rechnung gestellten Kosten (Vorschau): Eine optionale Funktion, mit der die tatsächlich in Rechnung gestellten Computing-Gebühren basierend auf der Slot-Nutzung vom Verwaltungsprojekt direkt auf die einzelnen Abfrageprojekte übertragen werden.
Attribution von Informationsflächen
Standardmäßig wird für die Abfrageprojekte, in denen SQL-Jobs ausgeführt werden, $0 für die Computing-Ausgaben angezeigt. Alle BigQuery Reservations API-Kunden haben jedoch in ihren Cloud Billing-Daten eine Position Analysis Slots Attribution. Diese Position ist auf der Seite Abrechnung in der Google Cloud Console und im Cloud Billing-Export enthalten.
In dieser Position werden die pro Projekt verwendeten Slotstunden angezeigt. Es fallen keine Kosten an und die Rechnungsbeträge werden nicht beeinflusst.
Zuordnung der in Rechnung gestellten Kosten
Bei der Zuordnung der abgerechneten Rechenkosten werden die tatsächlichen Rechenkosten vom Verwaltungsprojekt direkt auf die einzelnen Abfrageprojekte (auch als Verbrauchsprojekte bezeichnet) übertragen, basierend auf den von Abfragen verbrauchten Slot-Stunden. Mit der Zuordnung der abgerechneten Computing-Kosten können Sie Folgendes tun:
- Kosten auf Projektebene verfolgen: Sie können den Verbrauch auf Projektebene direkt in Cloud Billing-Berichten und -Datenexporten einsehen (
BigQuery-Dienst >All SKUs). - Interne Rückbuchungen durchführen: Verarbeiten Sie interne Rückbuchungen über Abteilungen und Teams hinweg, ohne benutzerdefinierte Data-Engineering-Pipelines erstellen zu müssen.
- Autoscaler-Nutzung zuordnen: Die Autoscaler-Gebühren werden den einzelnen Projekten proportional zu ihrem Autoscaler-Slot-Verbrauch zugeordnet.
Erforderliche IAM-Rollen
Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle BigQuery-Administrator (roles/bigquery.admin) für das Verwaltungsprojekt zuzuweisen, um die Berechtigung zu erhalten, die Sie zum Aktivieren der Zuordnung von Rechenkosten benötigen.
Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.
Diese vordefinierte Rolle enthält die Berechtigung bigquery.reservations.update, die zum Aktivieren der Zuordnung von Rechenkosten erforderlich ist.
Sie können diese Berechtigung auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.
Zuordnung von Rechenkosten aktivieren
Wenn Sie die Zuordnung von Rechenkosten für Ihre Abfrageprojekte aktivieren möchten, führen Sie die DDL-Anweisung (Datendefinitionssprache) ALTER PROJECT SET OPTIONS mit der Option reservation_attribution_mode aus.
Rufen Sie in der Google Cloud Console die Seite BigQuery auf.
Geben Sie im Abfrageeditor die folgende Anweisung ein:
ALTER PROJECT `ADMIN_PROJECT_ID` SET OPTIONS ( `region-LOCATION.reservation_attribution_mode` = 'RESERVATION_ATTRIBUTION_MODE_PROJECT_LEVEL' );Ersetzen Sie Folgendes:
ADMIN_PROJECT_ID: die Projekt-ID Ihres Administrationsprojekts.LOCATION: Der Standort Ihrer Reservierung.
Klicken Sie auf Ausführen.
Nachdem Sie die Zuordnung von Rechenkosten aktiviert haben, werden Änderungen bei der Kostenzuordnung am nächsten Abrechnungstag in den einzelnen Abfrageprojekten angezeigt. Abrechnungstage beginnen um 00:00 Uhr in der Zeitzone America/Los_Angeles. Die Änderungen werden auch innerhalb von etwa einem Tag in den täglichen Cloud-Abrechnungsberichten berücksichtigt.
Attributionsregeln und -verhalten
Wenn die Zuordnung von Rechenkosten aktiv ist, gilt für die Kostenverteilung Folgendes:
- Autoscaling-Zuweisung: Autoscaling-Slot-Gebühren werden ausschließlich den Abfrageprojekten zugerechnet, die während dieses Zeitfensters die automatisch skalierte Kapazität ausgelöst und verbraucht haben. Für Projekte, in denen Abfragen ausgeführt werden, die nur inaktive Slots oder Slots mit Basiszusicherung verbrauchen, fallen
$0an Autoscaling-Gebühren an. - Aufbewahrung im Verwaltungsprojekt: Gebühren für ungenutzte Baseline-Kapazität, nicht zugewiesene Kapazitätszusicherungen und ungenutzte Autoscaling-Slots (aus 50-Slot-Skalierungsschritten und dem einminütigen Cool-down-Fenster) werden weiterhin dem Verwaltungsprojekt zugerechnet.
- Anforderung für ein einzelnes Rechnungskonto: Für die Zuordnung von Rechenkosten müssen sowohl das Verwaltungsprojekt als auch die Abfrageprojekte zum selben Cloud-Rechnungskonto gehören. Wenn ein Abfrageprojekt mit einem separaten Rechnungskonto verknüpft ist, werden die Rechenkosten nicht zwischen Rechnungskonten verschoben und verbleiben im Verwaltungsprojekt.
- Speicherkosten: Speicherkosten werden weiterhin direkt den einzelnen Projekten in Rechnung gestellt, in denen sich die Datasets befinden.
Audit-Logs
Das Erstellen, Löschen und Aktualisieren von Ressourcen im Zusammenhang mit BigQuery-Reservierungen wird in den Audit-Logs des Projektinhabers aufgezeichnet. Weitere Informationen finden Sie unter Audit-Log.
Autoscaling mit Informationsschema überwachen
Mit den folgenden SQL-Skripts können Sie die abgerechneten Slotsekunden für eine bestimmte Version prüfen. Sie müssen diese Skripts in demselben Projekt ausführen, in dem die Reservierungen erstellt wurden. Das erste Skript zeigt abgerechnete Slotsekunden, die von commitment_plan abgedeckt werden, während das zweite Skript abgerechnete Slotsekunden anzeigt, die nicht von einer Zusicherung abgedeckt sind.
Sie müssen nur den Wert von drei Variablen festlegen, um diese Skripts auszuführen:
start_timeend_timeedition_to_check
Diese Skripts unterliegen den folgenden Einschränkungen:
Gelöschte Reservierungen und Kapazitätszusicherungen werden am Ende der Datenaufbewahrungsdauer aus den Informationsschemaansichten entfernt. Geben Sie ein aktuelles Zeitfenster an, das keine gelöschten Reservierungen und Zusicherungen für korrekte Ergebnisse enthält.
Das Ergebnis der Skripts stimmt aufgrund kleiner Rundungsfehler möglicherweise nicht genau mit der Rechnung überein.
Mit dem folgenden Script werden Autoscaling-Slots pro Version aggregiert.
Maximieren, um das Skript zum Berechnen der Slot-Sekunden für das Autoscaling pro Version aufzurufen.
SELECT edition, SUM(s.autoscale_current_slots) AS autoscale_slot_seconds FROM `region-us.INFORMATION_SCHEMA.RESERVATIONS_TIMELINE` m JOIN m.per_second_details s WHERE period_start BETWEEN '2025-09-28' AND '2025-09-29' GROUP BY edition ORDER BY edition
Das folgende Script aggregiert Autoscaling-Slots pro Reservierung.
Maximieren, um das Skript zum Berechnen der Slot-Sekunden für das Autoscaling pro Reservierung aufzurufen.
select reservation_id, sum(s.autoscale_current_slots) as autoscale_slot_seconds from `region-us.INFORMATION_SCHEMA.RESERVATIONS_TIMELINE` m LEFT JOIN m.per_second_details s WHERE period_start between '2025-09-28' and '2025-09-29' group by reservation_id order by reservation_id
Maximieren, um das Skript zur Berechnung von Slotsekunden aus Zusicherungen aufzurufen.
DECLARE start_time,end_time TIMESTAMP; DECLARE edition_to_check STRING; /* Google uses Pacific Time to calculate the billing period for all customers, regardless of their time zone. Use the following format if you want to match the billing report. Change the start_time and end_time values to match the desired window. */ /* The following three variables (start_time, end_time, and edition_to_check) are the only variables that you need to set in the script. During daylight savings time, the start_time and end_time variables should follow this format: 2024-02-20 00:00:00-08. */ SET start_time = "2023-07-20 00:00:00-07"; SET end_time = "2023-07-28 00:00:00-07"; SET edition_to_check = 'ENTERPRISE'; /* The following function returns the slot seconds for the time window between two capacity changes. For example, if there are 100 slots between (2023-06-01 10:00:00, 2023-06-01 11:00:00), then during that window the total slot seconds will be 100 * 3600. This script calculates a specific window (based on the preceding variables), which is why the following script includes script_start_timestamp_unix_millis and script_end_timestamp_unix_millis. */ CREATE TEMP FUNCTION GetSlotSecondsBetweenChanges( slots FLOAT64, range_begin_timestamp_unix_millis FLOAT64, range_end_timestamp_unix_millis FLOAT64, script_start_timestamp_unix_millis FLOAT64, script_end_timestamp_unix_millis FLOAT64) RETURNS INT64 LANGUAGE js AS r""" if (script_end_timestamp_unix_millis < range_begin_timestamp_unix_millis || script_start_timestamp_unix_millis > range_end_timestamp_unix_millis) { return 0; } var begin = Math.max(script_start_timestamp_unix_millis, range_begin_timestamp_unix_millis) var end = Math.min(script_end_timestamp_unix_millis, range_end_timestamp_unix_millis) return slots * Math.ceil((end - begin) / 1000.0) """; /* Sample CAPACITY_COMMITMENT_CHANGES data (unrelated columns ignored): +---------------------+------------------------+-----------------+--------+------------+--------+ | change_timestamp | capacity_commitment_id | commitment_plan | state | slot_count | action | +---------------------+------------------------+-----------------+--------+------------+--------+ | 2023-07-20 19:30:27 | 12954109101902401697 | ANNUAL | ACTIVE | 100 | CREATE | | 2023-07-27 22:29:21 | 11445583810276646822 | FLEX | ACTIVE | 100 | CREATE | | 2023-07-27 23:10:06 | 7341455530498381779 | MONTHLY | ACTIVE | 100 | CREATE | | 2023-07-27 23:11:06 | 7341455530498381779 | FLEX | ACTIVE | 100 | UPDATE | The last row indicates a special change from MONTHLY to FLEX, which happens because of commercial migration. */ WITH /* Information containing which commitment might have plan updated (e.g. renewal or commercial migration). For example: +------------------------+------------------+--------------------+--------+------------+--------+-----------+----------------------------+ | change_timestamp | capacity_commitment_id | commitment_plan | state | slot_count | action | next_plan | next_plan_change_timestamp | +---------------------+------------------------+-----------------+--------+------------+--------+-----------+----------------------------+ | 2023-07-20 19:30:27 | 12954109101902401697 | ANNUAL | ACTIVE | 100 | CREATE | ANNUAL | 2023-07-20 19:30:27 | | 2023-07-27 22:29:21 | 11445583810276646822 | FLEX | ACTIVE | 100 | CREATE | FLEX | 2023-07-27 22:29:21 | | 2023-07-27 23:10:06 | 7341455530498381779 | MONTHLY | ACTIVE | 100 | CREATE | FLEX | 2023-07-27 23:11:06 | | 2023-07-27 23:11:06 | 7341455530498381779 | FLEX | ACTIVE | 100 | UPDATE | FLEX | 2023-07-27 23:11:06 | */ commitments_with_next_plan AS ( SELECT *, IFNULL( LEAD(commitment_plan) OVER ( PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC ), commitment_plan) next_plan, IFNULL( LEAD(change_timestamp) OVER ( PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC ), change_timestamp) next_plan_change_timestamp FROM `region-us.INFORMATION_SCHEMA.CAPACITY_COMMITMENT_CHANGES_BY_PROJECT` ), /* Insert a 'DELETE' action for those with updated plans. The FLEX commitment '7341455530498381779' is has no 'CREATE' action, and is instead labeled as an 'UPDATE' action. For example: +---------------------+------------------------+-----------------+--------+------------+--------+ | change_timestamp | capacity_commitment_id | commitment_plan | state | slot_count | action | +---------------------+------------------------+-----------------+--------+------------+--------+ | 2023-07-20 19:30:27 | 12954109101902401697 | ANNUAL | ACTIVE | 100 | CREATE | | 2023-07-27 22:29:21 | 11445583810276646822 | FLEX | ACTIVE | 100 | CREATE | | 2023-07-27 23:10:06 | 7341455530498381779 | MONTHLY | ACTIVE | 100 | CREATE | | 2023-07-27 23:11:06 | 7341455530498381779 | FLEX | ACTIVE | 100 | UPDATE | | 2023-07-27 23:11:06 | 7341455530498381779 | MONTHLY | ACTIVE | 100 | DELETE | */ capacity_changes_with_additional_deleted_event_for_changed_plan AS ( SELECT next_plan_change_timestamp AS change_timestamp, project_id, project_number, capacity_commitment_id, commitment_plan, state, slot_count, 'DELETE' AS action, commitment_start_time, commitment_end_time, failure_status, renewal_plan, user_email, edition, is_flat_rate, FROM commitments_with_next_plan WHERE commitment_plan <> next_plan UNION ALL SELECT * FROM `region-us.INFORMATION_SCHEMA.CAPACITY_COMMITMENT_CHANGES_BY_PROJECT` ), /* The committed_slots change the history. For example: +---------------------+------------------------+------------------+-----------------+ | change_timestamp | capacity_commitment_id | slot_count_delta | commitment_plan | +---------------------+------------------------+------------------+-----------------+ | 2023-07-20 19:30:27 | 12954109101902401697 | 100 | ANNUAL | | 2023-07-27 22:29:21 | 11445583810276646822 | 100 | FLEX | | 2023-07-27 23:10:06 | 7341455530498381779 | 100 | MONTHLY | | 2023-07-27 23:11:06 | 7341455530498381779 | -100 | MONTHLY | | 2023-07-27 23:11:06 | 7341455530498381779 | 100 | FLEX | */ capacity_commitment_slot_data AS ( SELECT change_timestamp, capacity_commitment_id, CASE WHEN action = "CREATE" OR action = "UPDATE" THEN IFNULL( IF( LAG(action) OVER ( PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC, action ASC ) IN UNNEST(['CREATE', 'UPDATE']), slot_count - LAG(slot_count) OVER ( PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC, action ASC ), slot_count), slot_count) ELSE IF( LAG(action) OVER (PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC, action ASC) IN UNNEST(['CREATE', 'UPDATE']), -1 * slot_count, 0) END AS slot_count_delta, commitment_plan FROM capacity_changes_with_additional_deleted_event_for_changed_plan WHERE state = "ACTIVE" AND edition = edition_to_check AND change_timestamp <= end_time ), /* The total_committed_slots history for each plan. For example: +---------------------+---------------+-----------------+ | change_timestamp | capacity_slot | commitment_plan | +---------------------+---------------+-----------------+ | 2023-07-20 19:30:27 | 100 | ANNUAL | | 2023-07-27 22:29:21 | 100 | FLEX | | 2023-07-27 23:10:06 | 100 | MONTHLY | | 2023-07-27 23:11:06 | 0 | MONTHLY | | 2023-07-27 23:11:06 | 200 | FLEX | */ running_capacity_commitment_slot_data AS ( SELECT change_timestamp, SUM(slot_count_delta) OVER ( PARTITION BY commitment_plan ORDER BY change_timestamp RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ) AS capacity_slot, commitment_plan, FROM capacity_commitment_slot_data ), /* The slot_seconds between each changes, partitioned by each plan. For example: +---------------------+--------------+-----------------+ | change_timestamp | slot_seconds | commitment_plan | +---------------------+--------------+-----------------+ | 2023-07-20 19:30:27 | 64617300 | ANNUAL | | 2023-07-27 22:29:21 | 250500 | FLEX | | 2023-07-27 23:10:06 | 6000 | MONTHLY | | 2023-07-27 23:11:06 | 0 | MONTHLY | | 2023-07-27 23:11:06 | 5626800 | FLEX | */ slot_seconds_data AS ( SELECT change_timestamp, GetSlotSecondsBetweenChanges( capacity_slot, UNIX_MILLIS(change_timestamp), UNIX_MILLIS( IFNULL( LEAD(change_timestamp) OVER (PARTITION BY commitment_plan ORDER BY change_timestamp ASC), CURRENT_TIMESTAMP())), UNIX_MILLIS(start_time), UNIX_MILLIS(end_time)) AS slot_seconds, commitment_plan, FROM running_capacity_commitment_slot_data WHERE change_timestamp <= end_time ) /* The final result is similar to the following: +-----------------+--------------------+ | commitment_plan | total_slot_seconds | +-----------------+--------------------+ | ANNUAL | 64617300 | | MONTHLY | 6000 | | FLEX | 5877300 | */ SELECT commitment_plan, SUM(slot_seconds) AS total_slot_seconds FROM slot_seconds_data GROUP BY commitment_plan
Das folgende Skript prüft die Slot-Nutzung, die nicht durch Zusicherungen für eine bestimmte Version abgedeckt ist. Diese Nutzung enthält zwei Arten von Slots: skalierte Slots und Baseline-Slots, die nicht durch Zusicherungen abgedeckt sind.
Maximieren, um das Skript zur Berechnung von Slotsekunden aufzurufen, die nicht durch Zusicherungen abgedeckt sind
/* This script has several parts: 1. Calculate the baseline and scaled slots for reservations 2. Calculate the committed slots 3. Join the two preceding results to calculate the baseline not covered by committed slots 4. Aggregate the number */ -- variables DECLARE start_time, end_time TIMESTAMP; DECLARE edition_to_check STRING; /* Google uses Pacific Time to calculate the billing period for all customers, regardless of their time zone. Use the following format if you want to match the billing report. Change the start_time and end_time values to match the desired window. */ /* The following three variables (start_time, end_time, and edition_to_check) are the only variables that you need to set in the script. During daylight savings time, the start_time and end_time variables should follow this format: 2024-02-20 00:00:00-08. */ SET start_time = "2023-07-20 00:00:00-07"; SET end_time = "2023-07-28 00:00:00-07"; SET edition_to_check = 'ENTERPRISE'; /* The following function returns the slot seconds for the time window between two capacity changes. For example, if there are 100 slots between (2023-06-01 10:00:00, 2023-06-01 11:00:00), then during that window the total slot seconds will be 100 * 3600. This script calculates a specific window (based on the preceding variables), which is why the following script includes script_start_timestamp_unix_millis and script_end_timestamp_unix_millis. */ CREATE TEMP FUNCTION GetSlotSecondsBetweenChanges( slots FLOAT64, range_begin_timestamp_unix_millis FLOAT64, range_end_timestamp_unix_millis FLOAT64, script_start_timestamp_unix_millis FLOAT64, script_end_timestamp_unix_millis FLOAT64) RETURNS INT64 LANGUAGE js AS r""" if (script_end_timestamp_unix_millis < range_begin_timestamp_unix_millis || script_start_timestamp_unix_millis > range_end_timestamp_unix_millis) { return 0; } var begin = Math.max(script_start_timestamp_unix_millis, range_begin_timestamp_unix_millis) var end = Math.min(script_end_timestamp_unix_millis, range_end_timestamp_unix_millis) return slots * Math.ceil((end - begin) / 1000.0) """; /* Sample RESERVATION_CHANGES data (unrelated columns ignored): +---------------------+------------------+--------+---------------+---------------+ | change_timestamp | reservation_name | action | slot_capacity | current_slots | +---------------------+------------------+--------+---------------+---------------+ | 2023-07-27 22:24:15 | res1 | CREATE | 300 | 0 | | 2023-07-27 22:25:21 | res1 | UPDATE | 300 | 180 | | 2023-07-27 22:39:14 | res1 | UPDATE | 300 | 100 | | 2023-07-27 22:40:20 | res2 | CREATE | 300 | 0 | | 2023-07-27 22:54:18 | res2 | UPDATE | 300 | 120 | | 2023-07-27 22:55:23 | res1 | UPDATE | 300 | 0 | Sample CAPACITY_COMMITMENT_CHANGES data (unrelated columns ignored): +---------------------+------------------------+-----------------+--------+------------+--------+ | change_timestamp | capacity_commitment_id | commitment_plan | state | slot_count | action | +---------------------+------------------------+-----------------+--------+------------+--------+ | 2023-07-20 19:30:27 | 12954109101902401697 | ANNUAL | ACTIVE | 100 | CREATE | | 2023-07-27 22:29:21 | 11445583810276646822 | FLEX | ACTIVE | 100 | CREATE | | 2023-07-27 23:10:06 | 7341455530498381779 | MONTHLY | ACTIVE | 100 | CREATE | */ WITH /* The scaled_slots & baseline change history: +---------------------+------------------+------------------------------+---------------------+ | change_timestamp | reservation_name | autoscale_current_slot_delta | baseline_slot_delta | +---------------------+------------------+------------------------------+---------------------+ | 2023-07-27 22:24:15 | res1 | 0 | 300 | | 2023-07-27 22:25:21 | res1 | 180 | 0 | | 2023-07-27 22:39:14 | res1 | -80 | 0 | | 2023-07-27 22:40:20 | res2 | 0 | 300 | | 2023-07-27 22:54:18 | res2 | 120 | 0 | | 2023-07-27 22:55:23 | res1 | -100 | 0 | */ reservation_slot_data AS ( SELECT change_timestamp, reservation_name, CASE action WHEN "CREATE" THEN autoscale.current_slots WHEN "UPDATE" THEN IFNULL( autoscale.current_slots - LAG(autoscale.current_slots) OVER ( PARTITION BY project_id, reservation_name ORDER BY change_timestamp ASC, action ASC ), IFNULL( autoscale.current_slots, IFNULL( -1 * LAG(autoscale.current_slots) OVER ( PARTITION BY project_id, reservation_name ORDER BY change_timestamp ASC, action ASC ), 0))) WHEN "DELETE" THEN IF( LAG(action) OVER ( PARTITION BY project_id, reservation_name ORDER BY change_timestamp ASC, action ASC ) IN UNNEST(['CREATE', 'UPDATE']), -1 * autoscale.current_slots, 0) END AS autoscale_current_slot_delta, CASE action WHEN "CREATE" THEN slot_capacity WHEN "UPDATE" THEN IFNULL( slot_capacity - LAG(slot_capacity) OVER ( PARTITION BY project_id, reservation_name ORDER BY change_timestamp ASC, action ASC ), IFNULL( slot_capacity, IFNULL( -1 * LAG(slot_capacity) OVER ( PARTITION BY project_id, reservation_name ORDER BY change_timestamp ASC, action ASC ), 0))) WHEN "DELETE" THEN IF( LAG(action) OVER ( PARTITION BY project_id, reservation_name ORDER BY change_timestamp ASC, action ASC ) IN UNNEST(['CREATE', 'UPDATE']), -1 * slot_capacity, 0) END AS baseline_slot_delta, FROM `region-us.INFORMATION_SCHEMA.RESERVATION_CHANGES` WHERE edition = edition_to_check AND change_timestamp <= end_time ), -- Convert the preceding data to a running total /* +---------------------+-------------------------+----------------+ | change_timestamp | autoscale_current_slots | baseline_slots | +---------------------+-------------------------+----------------+ | 2023-07-27 22:24:15 | 0 | 300 | | 2023-07-27 22:25:21 | 180 | 300 | | 2023-07-27 22:39:14 | 100 | 300 | | 2023-07-27 22:40:20 | 100 | 600 | | 2023-07-27 22:54:18 | 220 | 600 | | 2023-07-27 22:55:23 | 120 | 600 | */ running_reservation_slot_data AS ( SELECT change_timestamp, SUM(autoscale_current_slot_delta) OVER (ORDER BY change_timestamp RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS autoscale_current_slots, SUM(baseline_slot_delta) OVER (ORDER BY change_timestamp RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS baseline_slots, FROM reservation_slot_data ), /* The committed_slots change history. For example: +---------------------+------------------------+------------------+ | change_timestamp | capacity_commitment_id | slot_count_delta | +---------------------+------------------------+------------------+ | 2023-07-20 19:30:27 | 12954109101902401697 | 100 | | 2023-07-27 22:29:21 | 11445583810276646822 | 100 | | 2023-07-27 23:10:06 | 7341455530498381779 | 100 | */ capacity_commitment_slot_data AS ( SELECT change_timestamp, capacity_commitment_id, CASE WHEN action = "CREATE" OR action = "UPDATE" THEN IFNULL( IF( LAG(action) OVER ( PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC, action ASC ) IN UNNEST(['CREATE', 'UPDATE']), slot_count - LAG(slot_count) OVER ( PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC, action ASC ), slot_count), slot_count) ELSE IF( LAG(action) OVER (PARTITION BY capacity_commitment_id ORDER BY change_timestamp ASC, action ASC) IN UNNEST(['CREATE', 'UPDATE']), -1 * slot_count, 0) END AS slot_count_delta FROM `region-us.INFORMATION_SCHEMA.CAPACITY_COMMITMENT_CHANGES_BY_PROJECT` WHERE state = "ACTIVE" AND edition = edition_to_check AND change_timestamp <= end_time ), /* The total_committed_slots history. For example: +---------------------+---------------+ | change_timestamp | capacity_slot | +---------------------+---------------+ | 2023-07-20 19:30:27 | 100 | | 2023-07-27 22:29:21 | 200 | | 2023-07-27 23:10:06 | 300 | */ running_capacity_commitment_slot_data AS ( SELECT change_timestamp, SUM(slot_count_delta) OVER (ORDER BY change_timestamp RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS capacity_slot FROM capacity_commitment_slot_data ), /* Add next_change_timestamp to the preceding data, which will be used when joining with reservation data. For example: +---------------------+-----------------------+---------------+ | change_timestamp | next_change_timestamp | capacity_slot | +---------------------+-----------------------+---------------+ | 2023-07-20 19:30:27 | 2023-07-27 22:29:21 | 100 | | 2023-07-27 22:29:21 | 2023-07-27 23:10:06 | 200 | | 2023-07-27 23:10:06 | 2023-07-31 00:14:37 | 300 | */ running_capacity_commitment_slot_data_with_next_change AS ( SELECT change_timestamp, IFNULL(LEAD(change_timestamp) OVER (ORDER BY change_timestamp ASC), CURRENT_TIMESTAMP()) AS next_change_timestamp, capacity_slot FROM running_capacity_commitment_slot_data ), /* Whenever we have a change in reservations or commitments, the scaled_slots_and_baseline_not_covered_by_commitments will be changed. Hence we get a collection of all the change_timestamp from both tables. +---------------------+ | change_timestamp | +---------------------+ | 2023-07-20 19:30:27 | | 2023-07-27 22:24:15 | | 2023-07-27 22:25:21 | | 2023-07-27 22:29:21 | | 2023-07-27 22:39:14 | | 2023-07-27 22:40:20 | | 2023-07-27 22:54:18 | | 2023-07-27 22:55:23 | | 2023-07-27 23:10:06 | */ merged_timestamp AS ( SELECT change_timestamp FROM running_reservation_slot_data UNION DISTINCT SELECT change_timestamp FROM running_capacity_commitment_slot_data ), /* Change running reservation-slots and make sure we have one row when commitment changes. +---------------------+-------------------------+----------------+ | change_timestamp | autoscale_current_slots | baseline_slots | +---------------------+-------------------------+----------------+ | 2023-07-20 19:30:27 | 0 | 0 | | 2023-07-27 22:24:15 | 0 | 300 | | 2023-07-27 22:25:21 | 180 | 300 | | 2023-07-27 22:29:21 | 180 | 300 | | 2023-07-27 22:39:14 | 100 | 300 | | 2023-07-27 22:40:20 | 100 | 600 | | 2023-07-27 22:54:18 | 220 | 600 | | 2023-07-27 22:55:23 | 120 | 600 | | 2023-07-27 23:10:06 | 120 | 600 | */ running_reservation_slot_data_with_merged_timestamp AS ( SELECT change_timestamp, IFNULL( autoscale_current_slots, IFNULL( LAST_VALUE(autoscale_current_slots IGNORE NULLS) OVER (ORDER BY change_timestamp ASC), 0)) AS autoscale_current_slots, IFNULL( baseline_slots, IFNULL(LAST_VALUE(baseline_slots IGNORE NULLS) OVER (ORDER BY change_timestamp ASC), 0)) AS baseline_slots FROM running_reservation_slot_data RIGHT JOIN merged_timestamp USING (change_timestamp) ), /* Join the preceding data to determine the baseline not covered by commitments. +---------------------+-----------------------+-------------------------+------------------------------------+ | change_timestamp | next_change_timestamp | autoscale_current_slots | baseline_not_covered_by_commitment | +---------------------+-----------------------+-------------------------+------------------------------------+ | 2023-07-20 19:30:27 | 2023-07-27 22:24:15 | 0 | 0 | | 2023-07-27 22:24:15 | 2023-07-27 22:25:21 | 0 | 200 | | 2023-07-27 22:25:21 | 2023-07-27 22:29:21 | 180 | 200 | | 2023-07-27 22:29:21 | 2023-07-27 22:39:14 | 180 | 100 | | 2023-07-27 22:39:14 | 2023-07-27 22:40:20 | 100 | 100 | | 2023-07-27 22:40:20 | 2023-07-27 22:54:18 | 100 | 400 | | 2023-07-27 22:54:18 | 2023-07-27 22:55:23 | 220 | 400 | | 2023-07-27 22:55:23 | 2023-07-27 23:10:06 | 120 | 400 | | 2023-07-27 23:10:06 | 2023-07-31 00:16:07 | 120 | 300 | */ scaled_slots_and_baseline_not_covered_by_commitments AS ( SELECT r.change_timestamp, IFNULL(LEAD(r.change_timestamp) OVER (ORDER BY r.change_timestamp ASC), CURRENT_TIMESTAMP()) AS next_change_timestamp, r.autoscale_current_slots, IF( r.baseline_slots - IFNULL(c.capacity_slot, 0) > 0, r.baseline_slots - IFNULL(c.capacity_slot, 0), 0) AS baseline_not_covered_by_commitment FROM running_reservation_slot_data_with_merged_timestamp r LEFT JOIN running_capacity_commitment_slot_data_with_next_change c ON r.change_timestamp >= c.change_timestamp AND r.change_timestamp < c.next_change_timestamp ), /* The slot_seconds between each changes. For example: +---------------------+--------------------+ | change_timestamp | slot_seconds | +---------------------+--------------+ | 2023-07-20 19:30:27 | 0 | | 2023-07-27 22:24:15 | 13400 | | 2023-07-27 22:25:21 | 91580 | | 2023-07-27 22:29:21 | 166320 | | 2023-07-27 22:39:14 | 13200 | | 2023-07-27 22:40:20 | 419500 | | 2023-07-27 22:54:18 | 40920 | | 2023-07-27 22:55:23 | 459160 | | 2023-07-27 23:10:06 | 11841480 | */ slot_seconds_data AS ( SELECT change_timestamp, GetSlotSecondsBetweenChanges( autoscale_current_slots + baseline_not_covered_by_commitment, UNIX_MILLIS(change_timestamp), UNIX_MILLIS(next_change_timestamp), UNIX_MILLIS(start_time), UNIX_MILLIS(end_time)) AS slot_seconds FROM scaled_slots_and_baseline_not_covered_by_commitments WHERE change_timestamp <= end_time AND next_change_timestamp > start_time ) /* Final result for this example: +--------------------+ | total_slot_seconds | +--------------------+ | 13045560 | */ SELECT SUM(slot_seconds) AS total_slot_seconds FROM slot_seconds_data
Fehlerbehebung für das Monitoring von Reservierungen
In den folgenden Abschnitten wird beschrieben, wie Sie häufige Probleme beim Monitoring von BigQuery-Reservierungen und der Slot-Nutzung beheben können.
Messwerte zur Slot-Nutzung stimmen nicht mit INFORMATION_SCHEMA überein
Wenn Sie Abweichungen zwischen den Slot-Nutzungsmesswerten in Ressourcendiagrammen und INFORMATION_SCHEMA-Daten feststellen, versuchen Sie Folgendes:
- Detaillierungsgrad reduzieren: Ändern Sie die Diagrammgranularität in 1-Sekunden-Intervalle statt in 1-Stunden-Intervalle.
- Ausrichtungsaggregation Achten Sie darauf, dass Sie Aggregationsmethoden verwenden, die zwischen Ressourcendiagrammen und
INFORMATION_SCHEMA-Daten übereinstimmen. Wenn Sie beispielsweise die Spitzennutzung in Ressourcendiagrammen besser darstellen möchten, ändern Sie die Messwertaggregation einheitlich in p99 oder p90.
Ausgeliehene Slots werden angezeigt, wenn inaktive Slots deaktiviert sind.
In Ihren Monitoring-Diagrammen wird möglicherweise ein Wert ungleich null für borrowed_slots angezeigt, auch wenn ignore_idle_slots=true für eine oder mehrere Reservierungen festgelegt ist. Diese Einstellung verhindert, dass eine Reservierung inaktive Slots ausleiht, aber nicht, dass sie ihre ungenutzten Slots an andere Reservierungen verleiht.
Diese geliehenen Slots werden in den folgenden Fällen angezeigt:
An andere Reservierungen verleihen. Eine Reservierung mit
ignore_idle_slots=truekann ihre nicht verwendeten Referenz-Slots an andere Reservierungen im selben Administrationsprojekt, in derselben Region und in derselben Version verleihen, die das Ausleihen inaktiver Slots (ignore_idle_slots=false) zulassen. Wenn alle Reservierungen in einem Administrationsprojekt, in einer Region und in einer Versionignore_idle_slots=truehaben, werden inaktive Slots nicht zwischen ihnen geteilt.Angenommen, Reservierung A hat 100 Slots, 0 Nutzung und ist mit
ignore_idle_slots=truekonfiguriert. Reservierung B befindet sich im selben Verwaltungsprojekt, in derselben Region und in derselben Version, hat 100 Slots, benötigt 150 Slots für ihre Arbeitslast und ist mitignore_idle_slots=falsekonfiguriert. Reservierung B kann 50 inaktive Slots von Reservierung A ausleihen, um ihren Bedarf zu decken. In diesem Fall werden in den Monitoring-Diagrammen 50lent_slotsfür Reservierung A und 50borrowed_slotsfür Reservierung B angezeigt.Nutzung, die die Kapazität überschreitet. Wenn die Slotnutzung einer Reservierung vorübergehend die Kapazität (Referenz + Autoscaling-Slots) überschreitet, wird diese Differenz in Monitoring-Diagrammen als
borrowed_slotsangezeigt. Dieses Verhalten kann auch bei Reservierungen mitignore_idle_slots=trueauftreten.
Die Slot-Nutzung kann gelegentlich die Summe Ihrer Referenz plus der skalierten Slots überschreiten. Ihnen wird keine Slot-Nutzung in Rechnung gestellt, die über Ihrer Referenz liegt, plus die skalierten Slots.
Ausgeliehene Slots werden angezeigt, bevor eine Reservierung vollständig genutzt wird
Monitoring-Dashboards verwenden Stichprobendaten, die die genaue zeitliche Slot-Nutzung innerhalb eines Stichprobenintervalls möglicherweise nicht genau widerspiegeln.
Wenn Sie eine genauere Analyse der Slot-Nutzung wünschen, fragen Sie Spalten ab, die sich auf inaktive Slots beziehen, z. B. die Spalten borrowed_slots und lent_slots in der Ansicht INFORMATION_SCHEMA.RESERVATIONS_TIMELINE.
Nächste Schritte
- Weitere Informationen zu Kapazitätszusicherungsplänen.
- Weitere Informationen zur Verwendung von Admin-Ressourcendiagrammen
- Informationen zu BigQuery-Preisen