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_SCHEMA visualizzazioni. Per recuperare le informazioni sull'utilizzo di progetti e prenotazioni, esegui una query sulle viste INFORMATION_SCHEMA.JOBS*.

    Il campo reservation_id nelle viste INFORMATION_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 API Jobs per 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.

    Monitoraggio delle prenotazioni.

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:

  1. Nella console Google Cloud , vai alla pagina Fatturazione.

    Vai a Fatturazione.

  2. Seleziona il progetto dell'account di fatturazione per cui vuoi visualizzare la fattura.

  3. Vai alla sezione Report e poi, nella sezione Filtri, segui questi passaggi:

    1. Dall'elenco Servizi, seleziona BigQuery e seleziona tutto ciò che è applicabile.
    2. 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.

  1. Nella console Google Cloud , vai alla pagina BigQuery.

    Vai a BigQuery

  2. 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.
  3. 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 $0 di 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_time
  • end_time
  • edition_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
Il seguente script controlla l'utilizzo degli slot coperto dagli impegni per una determinata edizione.

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=true può 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 hanno ignore_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 con ignore_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 50 lent_slots per la prenotazione A e 50 borrowed_slots per 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 con ignore_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