Estimer et contrôler les coûts

Cette page explique comment estimer les coûts et regroupe les bonnes pratiques de contrôle des coûts dans BigQuery. BigQuery propose deux types de modèles de tarification : à la demande et basée sur la capacité. Pour en savoir plus sur les tarifs, consultez la section Tarifs de BigQuery.

Avec BigQuery, vous pouvez estimer le coût d'exécution d'une requête, calculer les octets traités par diverses requêtes et obtenir une estimation du coût mensuel en fonction de votre utilisation prévue. Pour contrôler les coûts, vous devez également suivre les bonnes pratiques d'optimisation de calcul des requêtes et du stockage BigQuery. Pour connaître les bonnes pratiques sur les coûts, consultez la page Contrôler les coûts des requêtes.

Pour surveiller les coûts des requêtes et l'utilisation de BigQuery, analysez les journaux d'audit BigQuery.

Estimer le coût d'une requête

BigQuery propose les méthodes suivantes pour estimer les coûts :

• Utiliser l'option de test à blanc ("dry run") de requête pour estimer les coûts avant d'exécuter une requête à l'aide du modèle de tarification à la demande.
• Calculer le nombre d'octets traités par les différents types de requêtes.
• Obtenir le coût mensuel en fonction de l'utilisation prévue à l'aide du simulateur de coût Google Cloud.

Calcul de la taille des requêtes à la demande

Pour calculer le nombre d'octets traités par les différents types de requêtes à l'aide du modèle de facturation à la demande, consultez les sections suivantes :

• Instructions LMD
• Instructions LDD
• Tables en cluster

Interroger les formats en colonnes dans Cloud Storage

Si vos données externes sont stockées aux formats de type ORC ou Parquet, le nombre d'octets facturés est limité aux colonnes lues par BigQuery. Les types de données d'une source de données externe étant convertis en types de données BigQuery par la requête, le nombre d'octets lus est calculé en fonction de la taille des types de données BigQuery. Pour en savoir plus sur les conversions de types de données, consultez les pages suivantes :

• Conversions ORC
• Conversions Parquet

Utiliser le simulateur de coût Google Cloud

Le simulateur de coût Google Cloud peut vous aider à créer une estimation globale des coûts mensuels pour BigQuery en fonction de l'utilisation prévue.

Contrôler les coûts des requêtes

Pour optimiser les coûts des requêtes, assurez-vous de disposer d'un stockage optimisé et d'un calcul des requêtes. Pour découvrir d'autres méthodes de contrôle du coût des requêtes, consultez les sections suivantes :

Vérifier le coût des requêtes avant de les exécuter

Bonne pratique : Avant d'exécuter des requêtes, prévisualisez-les pour estimer les coûts.

Les requêtes sont facturées en fonction du nombre d'octets lus. Pour estimer les coûts avant d'exécuter une requête, vous disposez des options suivantes :

• Utilisez le programme de validation des requêtes dans la console Google Cloud.
• Utilisez le simulateur de coût Google Cloud.
• Effectuez un dry run sur les requêtes.

Utiliser l'outil de validation des requêtes

Lorsque vous saisissez une requête dans la console Google Cloud, l'outil de validation des requêtes valide sa syntaxe et fournit une estimation du nombre d'octets lus. Vous pouvez vous servir de cette estimation pour calculer le coût de la requête dans le simulateur de coût.

• Si votre requête n'est pas valide, l'outil de validation des requêtes affiche un message d'erreur. Exemple :

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

• Si votre requête est valide, l'outil de validation des requêtes fournit une estimation du nombre d'octets nécessaires pour traiter la requête. Exemple :

  This query will process 623.1 KiB when run.

Effectuer une simulation

Pour effectuer une simulation, procédez comme suit :

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))

Éviter d'exécuter des requêtes pour explorer les données d'une table

Bonne pratique : N'exécutez pas de requêtes pour explorer ou prévisualiser les données d'une table.

Si vous testez ou explorez vos données, vous pouvez afficher les données gratuitement sans affecter les quotas à l'aide des options d'aperçu de la table.

Vous trouverez ci-dessous les options d'aperçu de données disponibles dans BigQuery :

• Dans la console Google Cloud, sur la page "Détails de la table", cliquez sur l'onglet Aperçu pour échantillonner les données.
• Dans l'outil de ligne de commande bq, exécutez la commande bq head et spécifiez le nombre de lignes à prévisualiser.
• Dans l'API, récupérez les données de la table à partir d'un ensemble de lignes donné à l'aide de tabledata.list.
• Évitez d'utiliser LIMIT dans des tables hors cluster, car cette clause LIMIT ne permet pas de réduire les coûts de calcul.

Limiter le nombre d'octets facturés

Bonne pratique : Limitez les coûts des requêtes à l'aide du paramètre "Nombre maximal d'octets facturés".

Vous pouvez limiter le nombre d'octets facturés pour une requête en utilisant le paramètre "Nombre maximal d'octets facturés". Lorsque vous définissez le nombre maximal d'octets facturés, le nombre d'octets lus par la requête est estimé avant l'exécution de la requête. Si le nombre d'octets estimés dépasse la limite, la requête échoue sans engendrer de frais.

Pour les tables en cluster, l'estimation du nombre d'octets facturés pour une requête correspond à la limite supérieure et peut être supérieure au nombre réel d'octets facturés après l'exécution de la requête. Dans certains cas, si vous définissez le nombre maximal d'octets facturés, une requête sur une table en cluster peut échouer, même si le nombre d'octets réellement facturé ne dépasse pas le paramètre d'octets facturés maximal.

Si une requête échoue en raison du paramètre "Nombre maximal d'octets facturés", une erreur est renvoyée sous la forme suivante :

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

Pour définir le nombre maximal d'octets facturés, procédez comme suit :

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

Éviter d'utiliser LIMIT dans des tables hors cluster

Bonne pratique : Pour les tables hors cluster, n'utilisez pas de clause LIMIT comme méthode de contrôle des coûts.

Pour les tables hors cluster, l'application d'une clause LIMIT à une requête n'a aucune incidence sur la quantité de données lues. Vous êtes facturé pour la lecture de tous les octets de la table, comme indiqué par la requête, même si celle-ci ne renvoie qu'un sous-ensemble. Dans un tableau en cluster, une clause LIMIT peut réduire le nombre d'octets analysés, car l'analyse s'arrête lorsque suffisamment de blocs sont analysés pour obtenir le résultat. Seuls les octets analysés vous sont facturés.

Afficher les coûts à l'aide d'un tableau de bord et interroger les journaux d'audit

Bonne pratique : Créez un tableau de bord pour afficher vos données de facturation afin de pouvoir adapter votre utilisation de BigQuery. Pensez également à diffuser vos journaux d'audit vers BigQuery afin d'analyser les modèles d'utilisation.

Vous pouvez exporter vos données de facturation dans BigQuery et les visualiser dans un outil comme Looker Studio. Pour consulter un tutoriel sur la création d'un tableau de bord de facturation, consultez la page Visualiser la facturation Google Cloud à l'aide de BigQuery et Looker Studio.

Vous pouvez également diffuser vos journaux d'audit vers BigQuery et les analyser pour rechercher des motifs d'utilisation, par exemple les coûts des requêtes par utilisateur.

Matérialiser les résultats d'une requête par étapes

Bonne pratique : Matérialisez les résultats de votre requête par étapes, si possible.

Si vous créez une requête volumineuse à plusieurs étapes, BigQuery lit toutes les données requises par la requête chaque fois que vous l'exécutez. Toutes les données lues à chaque exécution de la requête vous sont facturées.

Divisez plutôt votre requête en étapes, où chacune d'elles matérialise les résultats de la requête en les écrivant dans une table de destination. Interroger la plus petite table de destination vous permet de diminuer la quantité de données lues et de réduire les frais. Le coût de stockage des résultats matérialisés est bien inférieur au coût de traitement de grandes quantités de données.

Utiliser l'expiration de la table pour les tables de destination

Bonne pratique : Si vous écrivez les résultats d'une requête volumineuse dans une table de destination, servez-vous du délai d'expiration de la table par défaut pour supprimer les données lorsque vous n'en avez plus besoin.

Conserver de grands ensembles de résultats dans l'espace de stockage BigQuery a un coût. Si vous n'avez pas besoin d'un accès permanent aux résultats, supprimez automatiquement les données selon le délai d'expiration de table défini par défaut.

Pour en savoir plus, consultez les tarifs de stockage.

Étapes suivantes

• Découvrez les tarifs de BigQuery.
• Découvrez comment optimiser les requêtes.
• Découvrez comment optimiser le stockage.

• Pour en savoir plus sur la facturation, les alertes et la visualisation des données, consultez les articles suivants :

  • Créer, modifier ou supprimer des budgets et des alertes de budget
  • Exporter des données Cloud Billing vers BigQuery
  • Visualiser vos coûts avec Looker Studio