Stima e controllo dei costi

Questa pagina descrive come stimare il costo e elenca le best practice per il controllo costi in BigQuery. BigQuery offre due tipi di modelli di prezzi: on demand e in base alla capacità. Per informazioni sui prezzi, consulta la sezione Prezzi di BigQuery.

Con BigQuery puoi stimare il costo di esecuzione di una query, calcolare i byte elaborati da varie query e ottenere una stima mensile dei costi in base all'utilizzo previsto. Per controllare i costi, devi anche seguire le best practice per ottimizzare il calcolo delle query e lo spazio di archiviazione BigQuery. Per le best practice specifiche per i costi, consulta Controllare i costi delle query.

Per monitorare i costi delle query e l'utilizzo di BigQuery, analizza gli audit log di BigQuery.

Stima dei costi delle query

BigQuery fornisce vari metodi per stimare il costo:

• Utilizza l'opzione Esecuzione simulata della query per stimare i costi prima di eseguire una query utilizzando il modello di prezzo on demand.
• Calcolo del numero di byte elaborati da vari tipi di query.
• Ottieni il costo mensile in base all'utilizzo previsto utilizzando il Calcolatore prezzi di Google Cloud.

Calcolo delle dimensioni delle query on demand

Per calcolare il numero di byte elaborati dai vari tipi di query utilizzando il modello di fatturazione on demand, consulta le seguenti sezioni:

• Istruzioni DML
• Istruzioni DDL
• Tabelle in cluster

Esegui query sui formati a colonne su Cloud Storage

Se i tuoi dati esterni sono archiviati in formato ORC o Parquet, il numero di byte addebitati è limitato alle colonne lette da BigQuery. Poiché i tipi di dati di un'origine dati esterna sono convertiti dalla query in tipi di dati BigQuery, il numero di byte letti è calcolato in base alle dimensioni dei tipi di dati BigQuery. Per informazioni sulle conversioni dei tipi di dati, consulta le seguenti pagine:

• Conversioni ORC
• Conversioni Parquet

Utilizzare il Calcolatore prezzi di Google Cloud

Il Calcolatore prezzi di Google Cloud può aiutarti a creare una stima mensile complessiva del costo di BigQuery in base all'utilizzo previsto.

Controllare i costi delle query

Per ottimizzare i costi delle query, assicurati di avere spazio di archiviazione ottimizzato e calcolo delle query. Per altri metodi per controllare il costo delle query, consulta le sezioni seguenti:

Controlla il costo delle query prima di eseguirle

Best practice:prima di eseguire le query, visualizzane l'anteprima per stimare i costi.

Le query vengono fatturate in base al numero di byte letti. Per stimare i costi prima di eseguire una query:

• Utilizza il validatore delle query nella console Google Cloud.
• Utilizza il Calcolatore prezzi di Google Cloud.
• Esegui una prova per le query.

Utilizzare lo strumento di convalida delle query

Quando inserisci una query nella console Google Cloud, il validatore delle query verifica la sintassi della query e fornisce una stima del numero di byte letti. Puoi utilizzare questa stima per calcolare il costo delle query nel Calcolatore prezzi.

• Se la query non è valida, lo strumento di convalida delle query visualizza un messaggio di errore. Ad esempio:

  Not found: Table myProject:myDataset.myTable was not found in location US

• Se la query è valida, lo strumento di convalida fornisce una stima del numero di byte necessari per elaborarla. Ad esempio:

  This query will process 623.1 KiB when run.

Esegui una prova

Per eseguire una simulazione:

bq query \
--use_legacy_sql=false \
--dry_run \
'SELECT
   COUNTRY,
   AIRPORT,
   IATA
 FROM
   `project_id`.dataset.airports
 LIMIT
   1000'
 

Query successfully validated. Assuming the tables are not modified,
running this query will process 10918 bytes of data.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// queryDryRun demonstrates issuing a dry run query to validate query structure and
// provide an estimate of the bytes scanned.
func queryDryRun(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query(`
	SELECT
		name,
		COUNT(*) as name_count
	FROM ` + "`bigquery-public-data.usa_names.usa_1910_2013`" + `
	WHERE state = 'WA'
	GROUP BY name`)
	q.DryRun = true
	// Location must match that of the dataset(s) referenced in the query.
	q.Location = "US"

	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	// Dry run is not asynchronous, so get the latest status and statistics.
	status := job.LastStatus()
	if err := status.Err(); err != nil {
		return err
	}
	fmt.Fprintf(w, "This query will process %d bytes\n", status.Statistics.TotalBytesProcessed)
	return nil
}

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobStatistics;
import com.google.cloud.bigquery.QueryJobConfiguration;

// Sample to run dry query on the table
public class QueryDryRun {

  public static void runQueryDryRun() {
    String query =
        "SELECT name, COUNT(*) as name_count "
            + "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
            + "WHERE state = 'WA' "
            + "GROUP BY name";
    queryDryRun(query);
  }

  public static void queryDryRun(String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDryRun(true).setUseQueryCache(false).build();

      Job job = bigquery.create(JobInfo.of(queryConfig));
      JobStatistics.QueryStatistics statistics = job.getStatistics();

      System.out.println(
          "Query dry run performed successfully." + statistics.getTotalBytesProcessed());
    } catch (BigQueryException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function queryDryRun() {
  // Runs a dry query of the U.S. given names dataset for the state of Texas.

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/query
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    dryRun: true,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  // Print the status and statistics
  console.log('Status:');
  console.log(job.metadata.status);
  console.log('\nJob Statistics:');
  console.log(job.metadata.statistics);
}

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

// Construct a BigQuery client object.
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);

// Set job configs
$jobConfig = $bigQuery->query($query);
$jobConfig->useQueryCache(false);
$jobConfig->dryRun(true);

// Extract query results
$queryJob = $bigQuery->startJob($jobConfig);
$info = $queryJob->info();

printf('This query will process %s bytes' . PHP_EOL, $info['statistics']['totalBytesProcessed']);

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

job_config = bigquery.QueryJobConfig(dry_run=True, use_query_cache=False)

# Start the query, passing in the extra configuration.
query_job = client.query(
    (
        "SELECT name, COUNT(*) as name_count "
        "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
        "WHERE state = 'WA' "
        "GROUP BY name"
    ),
    job_config=job_config,
)  # Make an API request.

# A dry run query completes immediately.
print("This query will process {} bytes.".format(query_job.total_bytes_processed))

Evita di eseguire query per esplorare i dati della tabella

Best practice:non eseguire query per esplorare o visualizzare l'anteprima dei dati della tabella.

Se stai conducendo esperimenti o esplorando i tuoi dati, puoi utilizzare le opzioni di anteprima della tabella per visualizzare i dati gratuitamente e senza influire sulle quote.

BigQuery supporta le seguenti opzioni di anteprima dei dati:

• Nella console Google Cloud, nella pagina dei dettagli della tabella, fai clic sulla scheda Anteprima per campionare i dati.
• Nello strumento a riga di comando bq, utilizza il comando bq head e specifica il numero di righe da visualizzare in anteprima.
• Nell'API, utilizza tabledata.list per recuperare i dati della tabella da un insieme specificato di righe.
• Evita di utilizzare LIMIT nelle tabelle non cluster. Per le tabelle non clusterizzate, una clausola LIMIT non riduce i costi di calcolo.

Limitare il numero di byte fatturati

Best practice:utilizza l'impostazione dei byte massimi fatturati per limitare i costi delle query.

Puoi limitare il numero di byte fatturati per una query utilizzando l'impostazione dei byte massimi fatturati. Quando imposti il numero massimo di byte fatturati, il numero di byte letti dalla query viene stimato prima dell'esecuzione. Se il numero di byte stimati supera il limite, la query non riesce senza comportare addebiti.

Per le tabelle cluster, la stima del numero di byte fatturati per una query è un limite superiore e può essere superiore al numero effettivo di byte fatturati dopo l'esecuzione della query. Pertanto, in alcuni casi, se imposti il numero massimo di byte fatturati, una query su una tabella clusterizzata può non riuscire, anche se i byte fatturati effettivi non superano l'impostazione del numero massimo di byte fatturati.

Se una query non va a buon fine a causa dell'impostazione del numero massimo di byte fatturati, viene restituito un errore simile al seguente:

Error: Query exceeded limit for bytes billed: 1000000. 10485760 or higher required.

Per impostare il numero massimo di byte fatturati:

  bq query --maximum_bytes_billed=1000000 \
  --use_legacy_sql=false \
  'SELECT
     word
   FROM
     `bigquery-public-data`.samples.shakespeare'

Evita di utilizzare LIMIT nelle tabelle non cluster

Best practice:per le tabelle non in cluster, non utilizzare una clausola LIMIT come metodo di controllo dei costi.

Per le tabelle non cluster, l'applicazione di una clausola LIMIT a una query non influisce sulla quantità di dati letti. Ti viene addebitato il costo della lettura di tutti i byte dell'intera tabella come indicato dalla query, anche se la query restituisce solo un sottoinsieme. Con una tabella in cluster, una clausola LIMIT può ridurre il numero di byte esaminati, perché la scansione si interrompe quando vengono analizzati blocchi sufficienti per ottenere il risultato. Ti vengono addebitati solo i byte sottoposti a scansione.

Visualizzare i costi utilizzando una dashboard ed eseguire query sui log di controllo

Best practice:crea una dashboard per visualizzare i dati di fatturazione in modo da poter apportare aggiustamenti all'utilizzo di BigQuery. Valuta anche la possibilità di eseguire lo streaming degli audit log in BigQuery per analizzare i pattern di utilizzo.

Puoi esportare i dati di fatturazione in BigQuery e visualizzarli in uno strumento come Looker Studio. Per un tutorial sulla creazione di una dashboard di fatturazione, consulta Visualizzare la fatturazione di Google Cloud utilizzando BigQuery e Looker Studio.

Puoi anche trasmettere in streaming i tuoi audit log in BigQuery e analizzare i log per rilevare modelli di utilizzo, ad esempio i costi delle query per utente.

Materializzare i risultati delle query in fasi

Best practice:se possibile, materializza i risultati della query in più fasi.

Se crei una query di grandi dimensioni in più fasi, ogni volta che la esegui, BigQuery legge tutti i dati richiesti dalla query. Ti viene addebitato il costo di tutti i dati letti ogni volta che viene eseguita la query.

Suddividi invece la query in fasi in cui ogni fase materializza i risultati della query scrivendoli in una tabella di destinazione. L'esecuzione di query sulla tabella di destinazione più piccola riduce la quantità di dati letti e abbassa i costi. Il costo di archiviazione dei risultati materializzati è molto inferiore al costo di elaborazione di grandi quantità di dati.

Utilizzare la scadenza della tabella per le tabelle di destinazione

Best practice:se scrivi risultati di query di grandi dimensioni in una tabella di destinazione, utilizza la data e l'ora di scadenza predefinite della tabella per rimuovere i dati quando non sono più necessari.

Mantenere set di risultati di grandi dimensioni nello spazio di archiviazione BigQuery ha un costo. Se non hai bisogno di accedere in modo permanente ai risultati, utilizza la scadenza predefinita della tabella per eliminare automaticamente i dati.

Per ulteriori informazioni, consulta la sezione Prezzi dello spazio di archiviazione.

Passaggi successivi

• Ulteriori informazioni sui prezzi di BigQuery.
• Scopri come ottimizzare la query.
• Scopri come ottimizzare lo spazio di archiviazione.

• Per informazioni su fatturazione, avvisi e visualizzazione dei dati, consulta i seguenti argomenti:

  • Creare, modificare o eliminare budget e avvisi relativi ai budget
  • Esportare i dati di fatturazione Cloud in BigQuery
  • Visualizzazione dei costi con Looker Studio