Monitora le prenotazioni BigQuery
In qualità di amministratore di BigQuery, puoi monitorare le prenotazioni nel tuo progetto visualizzando l'utilizzo degli slot di progetto e prenotazione, nonché la fattura basata sulla capacità.
Visualizza l'utilizzo degli slot di prenotazione e del progetto
Puoi visualizzare l'utilizzo degli slot di progetto e prenotazione nei seguenti modi:
INFORMATION_SCHEMAvisualizzazioni. Per recuperare le informazioni sull'utilizzo di progetti e prenotazioni, esegui una query sulle visteINFORMATION_SCHEMA.JOBS*.Il campo
reservation_idnelle visteINFORMATION_SCHEMA.JOBS*contiene il nome della prenotazione.ConsoleGoogle Cloud . La console Google Cloud include grafici che mostrano l'utilizzo degli slot. Per saperne di più, consulta Utilizza i grafici delle risorse amministrative.
Esplora job. Puoi utilizzare Explorer job per raggruppare i job per prenotazione nell'intera organizzazione e visualizzare le statistiche di riepilogo, tra cui tempo di slot, job attivi e job in coda.
Audit log. Utilizza gli audit log per visualizzare le metriche sull'utilizzo degli slot.
Il metodo
Jobs. Utilizza il metodo APIJobsper visualizzare le metriche sull'utilizzo degli slot per un job.Cloud Monitoring. Puoi utilizzare Cloud Monitoring per creare dashboard per monitorare gli slot allocati. Con una dashboard di Cloud Monitoring, puoi visualizzare l'utilizzo degli slot per ogni prenotazione e per ogni tipo di job, in tutti i progetti all'interno della prenotazione. Per visualizzare le metriche di utilizzo degli slot per tutti i progetti che utilizzano una prenotazione, devi aggiungere esplicitamente questi progetti consumer all'ambito delle metriche del progetto in cui monitori le metriche. Per saperne di più sulle metriche disponibili per la dashboard di Cloud Monitoring, consulta Metriche disponibili per la visualizzazione.

Informazioni sulle metriche degli slot
Per monitorare e gestire in modo efficace la capacità di calcolo di BigQuery, devi distinguere tra slot allocati e slot utilizzati:
- Slot allocati
- La capacità dedicata al tuo progetto tramite slot di riferimento e impegni di capacità attivi. Gli slot allocati influiscono sulla quota e sulla fatturazione.
- Slot utilizzati
- La capacità consumata attivamente dai job in esecuzione durante l'esecuzione delle query. Gli slot utilizzati vengono visualizzati nei grafici di utilizzo delle risorse.
Poiché gli slot di base sono risorse dedicate, vengono segnalati come "utilizzati" dal sistema di quote anche quando non sono in esecuzione query attive. Di conseguenza, l'utilizzo della quota riportato nella pagina Quote e limiti di sistema può essere superiore all'utilizzo effettivo degli slot mostrato nella pagina Monitoraggio.
Confronto delle metriche degli slot
La tabella seguente mette a confronto il modo in cui le metriche degli slot vengono calcolate e visualizzate nella console Google Cloud :
| Pagina della consoleGoogle Cloud | Metrica mostrata | Che cosa conteggia | Origine della discrepanza |
|---|---|---|---|
| Quote e limiti di sistema | Quota utilizzata (numero totale di slot; consulta i grafici di utilizzo della quota) | Slot allocati: slot di riferimento della prenotazione e impegni attivi. | Include gli slot di riferimento inattivi e le prenotazioni di failover inattive nelle regioni secondarie. Non conteggia gli slot con scalabilità automatica. |
| Monitoraggio | Utilizzo slot (Grafici di utilizzo delle risorse) | Slot utilizzati: unità di calcolo consumate attivamente dai job in esecuzione. | Include i burst di scalabilità automatica che elaborano attivamente i job. Sono esclusi gli slot di riferimento inattivi e le prenotazioni di failover inattive. |
Cause comuni delle discrepanze nell'utilizzo degli slot
Quando riconcili le metriche degli slot tra la pagina Quote e limiti di sistema e la pagina Monitoring, tieni presente le seguenti cause comuni di discrepanze:
- Slot di riferimento inattivi: hai prenotato slot di riferimento che non eseguono attivamente query. Poiché gli slot di base sono capacità dedicata, il sistema di quote li considera come utilizzati, ma i grafici di utilizzo mostrano solo gli slot che eseguono attivamente i workload.
- Prenotazioni di failover: se configuri il ripristino di emergenza gestito, gli slot di riferimento per una prenotazione di failover vengono allocati nella regione secondaria. Questi slot vengono visualizzati come quota utilizzata nella regione secondaria anche quando la prenotazione è inattiva e non si è verificato alcun failover. Per saperne di più, consulta Considerazioni sulle quote per le prenotazioni di failover.
- Burst di scalabilità automatica: i grafici di utilizzo delle risorse includono gli slot di scalabilità automatica che elaborano attivamente i job. Al contrario, la pagina Quote e limiti di sistema riflette solo la capacità allocata statica (base di riferimento e impegni) e non conteggia gli slot di scalabilità automatica.
Visualizza la fattura basata sulla capacità
Per visualizzare la fattura basata sulla capacità in tempo reale, segui questi passaggi:
Nella console Google Cloud , vai alla pagina Fatturazione.
Seleziona il progetto dell'account di fatturazione per cui vuoi visualizzare la fattura.
Vai alla sezione Report e poi, nella sezione Filtri, segui questi passaggi:
- Dall'elenco Servizi, seleziona BigQuery e seleziona tutto ciò che è applicabile.
- Seleziona Tutti gli SKU dall'elenco SKU.
Attribuisci i costi di computing ai singoli progetti
Per impostazione predefinita, nei prezzi basati sulla capacità delle versioni di BigQuery, tutti gli addebiti per il computing vengono fatturati al progetto di amministrazione centrale che gestisce le prenotazioni e gli impegni di capacità.
Per aiutarti a stimare i budget a livello di progetto ed eseguire storni di addebito interni, BigQuery offre due modi per monitorare il consumo di risorse nei singoli progetti di query che utilizzano la prenotazione:
- Attribuzione slot informativa (predefinita): una voce informativa nel report sulla fatturazione che mostra le ore slot utilizzate per progetto. Le tariffe di computing effettive continuano a essere addebitate al progetto di amministrazione.
- Attribuzione del costo fatturato (anteprima): una funzionalità di attivazione che trasferisce gli addebiti di calcolo effettivi fatturati dal progetto di amministrazione direttamente ai singoli progetti di query in base all'utilizzo degli slot.
Attribuzione degli slot informativi
Per impostazione predefinita, i progetti di query in cui vengono eseguiti i job SQL mostrano $0 per la spesa di computing. Tuttavia, tutti i clienti dell'API BigQuery Reservations hanno una voce Analysis Slots Attribution nei dati di fatturazione Cloud. Questa voce è inclusa nella pagina Fatturazione della console Google Cloud e nell'esportazione della fatturazione Cloud.
Questa voce mostra le ore slot utilizzate per progetto. Non comporta costi e non influisce sui totali delle fatture.
Attribuzione del costo fatturato
L'attribuzione dei costi di computing fatturati trasferisce gli addebiti di computing effettivi dal progetto di amministrazione direttamente ai singoli progetti di query (noti anche come progetti di consumo) in base alle ore slot consumate dalle query. Puoi utilizzare l'attribuzione dei costi di calcolo fatturati per:
- Monitora i costi a livello di progetto: visualizza il consumo a livello di progetto direttamente nei report sulla fatturazione Cloud e nelle esportazioni dei dati (servizio
BigQuery>All SKUs). - Esegui storni di addebito interni: elabora storni di addebito interni tra reparti e team senza creare pipeline di data engineering personalizzate.
- Attribuzione dell'utilizzo del gestore della scalabilità automatica: attribuisci gli addebiti del gestore della scalabilità automatica ai progetti specifici in modo proporzionale in base al consumo di slot del gestore della scalabilità automatica.
Ruoli IAM richiesti
Per ottenere l'autorizzazione necessaria per abilitare l'attribuzione dei costi di computing, chiedi all'amministratore di concederti il ruolo IAM BigQuery Administrator (roles/bigquery.admin) nel progetto di amministrazione.
Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.
Questo ruolo predefinito contiene l'autorizzazione bigquery.reservations.update, necessaria per attivare l'attribuzione dei costi di computing.
Potresti anche ottenere questa autorizzazione con ruoli personalizzati o altri ruoli predefiniti.
Abilita l'attribuzione dei costi di computing
Per attivare l'attribuzione dei costi di calcolo nei progetti di query, esegui l'istruzione DDL (Data Definition Language) ALTER PROJECT SET OPTIONS con l'opzione reservation_attribution_mode.
Nella console Google Cloud , vai alla pagina BigQuery.
Nell'editor di query, inserisci la seguente istruzione:
ALTER PROJECT `ADMIN_PROJECT_ID` SET OPTIONS ( `region-LOCATION.reservation_attribution_mode` = 'RESERVATION_ATTRIBUTION_MODE_PROJECT_LEVEL' );Sostituisci quanto segue:
ADMIN_PROJECT_ID: l'ID progetto del tuo progetto di amministrazione.LOCATION: la località della prenotazione.
Fai clic su Esegui.
Dopo aver attivato l'attribuzione dei costi di calcolo, le variazioni nell'allocazione dei costi iniziano a essere visualizzate nei singoli progetti di query il giorno di fatturazione successivo (i giorni di fatturazione iniziano alle 00:00 nel fuso orario America/Los_Angeles). Le modifiche si riflettono anche nei report sulla fatturazione Cloud giornalieri entro circa un giorno.
Regole e comportamento di attribuzione
Quando l'attribuzione dei costi di computing è attiva, la distribuzione dei costi segue queste regole:
- Allocazione del gestore della scalabilità automatica: gli addebiti per gli slot del gestore della scalabilità automatica vengono attribuiti rigorosamente ai progetti di query che hanno attivato e utilizzato la capacità con scalabilità automatica durante quel periodo di tempo. I progetti che eseguono query che utilizzano solo slot inattivi o slot di impegno di base maturano
$0di addebiti del gestore della scalabilità automatica. - Conservazione del progetto di amministrazione: i costi della capacità di riferimento inutilizzata, degli impegni di capacità non assegnati e degli slot con scalabilità automatica inutilizzati (dagli incrementi di scalabilità di 50 slot e dalla finestra di attesa di un minuto) rimangono attribuiti al progetto di amministrazione.
- Requisito di un singolo account di fatturazione: l'attribuzione dei costi di calcolo richiede che sia il progetto di amministrazione sia i progetti di query appartengano esattamente allo stesso account di fatturazione Cloud. Se un progetto di query è collegato a un account di fatturazione separato, i relativi costi di calcolo non vengono spostati tra gli account di fatturazione e rimangono nel progetto di amministrazione.
- Costi di archiviazione: i costi di archiviazione continuano a essere fatturati direttamente ai singoli progetti in cui risiedono i set di dati.
Audit log
La creazione, l'eliminazione e l'aggiornamento delle risorse relative alle prenotazioni BigQuery vengono registrati negli audit log del Project Owner. Per saperne di più, consulta Audit log.
Monitora la scalabilità automatica con lo schema di informazioni
Puoi utilizzare i seguenti script SQL per controllare i secondi slot fatturati per una determinata versione. Devi eseguire questi script nello stesso progetto in cui sono state create le prenotazioni. Il primo script mostra gli slot-secondi fatturati coperti da commitment_plan, mentre il secondo script mostra gli slot-secondi fatturati non coperti da un impegno.
Per eseguire questi script, devi solo impostare il valore di tre variabili:
start_timeend_timeedition_to_check
Questi script sono soggetti alle seguenti limitazioni:
Le prenotazioni e gli impegni di capacità eliminati vengono rimossi dalle visualizzazioni INFORMATION_SCHEMA al termine del periodo di conservazione dei dati. Per ottenere risultati corretti, specifica un intervallo di tempo recente che non contenga prenotazioni e impegni eliminati.
Il risultato degli script potrebbe non corrispondere esattamente alla fattura a causa di piccoli errori di arrotondamento.
Il seguente script aggrega gli slot con scalabilità automatica per versione.
Espandi per visualizzare lo script per calcolare i secondi slot con scalabilità automatica per edizione.
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
Il seguente script aggrega gli slot di scalabilità automatica per prenotazione.
Espandi per visualizzare lo script per calcolare i secondi slot con scalabilità automatica per prenotazione.
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
Espandi per visualizzare lo script per calcolare gli slot-secondi dagli impegni.
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
Il seguente script controlla l'utilizzo degli slot non coperto dagli impegni per una determinata versione. Questo utilizzo contiene due tipi di slot: slot scalati e slot di base non coperti da impegni.
Espandi per visualizzare lo script per calcolare gli slot-secondi non coperti dagli impegni
/* 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
Risolvi i problemi relativi al monitoraggio delle prenotazioni
Le sezioni seguenti descrivono come risolvere i problemi comuni durante il monitoraggio delle prenotazioni e dell'utilizzo degli slot di BigQuery.
Le metriche di utilizzo degli slot non corrispondono a INFORMATION_SCHEMA
Se riscontri discrepanze tra le metriche di utilizzo degli slot nei grafici delle risorse e i dati di INFORMATION_SCHEMA, prova quanto segue:
- Riduci la granularità. Modifica la granularità del grafico in intervalli di 1 secondo anziché di 1 ora.
- Aggregazione di allineamento. Assicurati di utilizzare metodi di aggregazione che siano allineati tra i grafici delle risorse e i dati di
INFORMATION_SCHEMA. Ad esempio, per riflettere meglio l'utilizzo di picco nei grafici delle risorse, modifica l'aggregazione delle metriche in p99 o p90 in modo coerente.
Gli slot presi in prestito vengono visualizzati quando gli slot inattivi sono disabilitati
I grafici di monitoraggio potrebbero mostrare un valore diverso da zero per borrowed_slots anche se ignore_idle_slots=true è impostato per una o più prenotazioni. Questa impostazione impedisce a una prenotazione di prendere in prestito slot inattivi, ma non le impedisce di prestare i propri slot inutilizzati ad altre prenotazioni.
Questi slot presi in prestito vengono visualizzati nei seguenti casi:
Prestito ad altre prenotazioni. Una prenotazione con
ignore_idle_slots=truepuò prestare i propri slot di riferimento inutilizzati ad altre prenotazioni nello stesso progetto di amministrazione, nella stessa regione e nella stessa edizione che consentono il prestito di slot inattivi (ignore_idle_slots=false). Se tutte le prenotazioni in un progetto di amministrazione, una regione e un'edizione hannoignore_idle_slots=true, gli slot inattivi non vengono condivisi tra loro.Ad esempio, supponiamo che la prenotazione A abbia 100 slot, un utilizzo pari a 0 e sia configurata con
ignore_idle_slots=true. La prenotazione B si trova nello stesso progetto di amministrazione, nella stessa regione e nella stessa edizione, ha 100 slot, richiede 150 slot per il suo workload ed è configurata conignore_idle_slots=false. La prenotazione B può prendere in prestito 50 slot inattivi dalla prenotazione A per soddisfare le sue esigenze. In questo caso, i grafici di monitoraggio indicano 50lent_slotsper la prenotazione A e 50borrowed_slotsper la prenotazione B.Utilizzo superiore alla capacità. Se l'utilizzo degli slot di una prenotazione supera temporaneamente la sua capacità (slot di base + slot con scalabilità automatica), i grafici di monitoraggio mostrano questa differenza come
borrowed_slots. Questo comportamento può verificarsi anche per le prenotazioni conignore_idle_slots=true.
L'utilizzo degli slot può occasionalmente superare la somma degli slot di riferimento e di quelli scalati. Non ti verrà addebitato l'utilizzo di slot superiore alla somma degli slot di base e di quelli scalati.
Gli slot presi in prestito vengono visualizzati prima che una prenotazione venga utilizzata completamente
Le dashboard di monitoraggio utilizzano dati campionati, che potrebbero non riflettere con precisione la tempistica esatta dell'utilizzo degli slot all'interno di un intervallo di campionamento.
Per un'analisi più accurata dell'utilizzo degli slot, esegui query sulle colonne relative agli slot inattivi, ad esempio le colonne borrowed_slots e lent_slots nella vista INFORMATION_SCHEMA.RESERVATIONS_TIMELINE.
Passaggi successivi
- Scopri di più sui piani di impegno di capacità.
- Scopri come utilizzare i grafici delle risorse amministrative.
- Scopri di più sui prezzi di BigQuery.