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.

Remarque : Pour contrôler les coûts, vous pouvez également demander à votre propriétaire de projet ou à l'administrateur de quotas de créer des contrôles de coûts personnalisés.

Estimer le coût d'une requête

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

• Utilisez l'option de simulation de requête pour estimer les coûts avant d'exécuter une requête à l'aide du modèle de tarification à la demande.
• Calculez le nombre d'octets traités par différents types de requêtes.
• Obtenez le coût mensuel en fonction de votre 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

Remarque : Le dataset modèle de facturation du stockage des ensembles de données qui a été sélectionné n'a pas d'incidence sur le calcul du coût des requêtes à la demande. BigQuery utilise toujours des octets logiques (non compressés) pour calculer le coût des requêtes à la demande.

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.

À la demande

Pour estimer les coûts dans le simulateur de coût Google Cloud lors de l'utilisation du modèle de tarification à la demande, procédez comme suit :

1. Ouvrez le simulateur de coût Google Cloud.
2. Cliquez sur BigQuery.
3. Cliquez sur l'onglet À la demande.
4. Dans le champ Nom de la table, saisissez le nom de la table. Par exemple, airports.
5. Pour Tarifs de stockage, saisissez la taille estimée de la table dans les champs de stockage. Vous devez seulement estimer le stockage physique ou logique, selon le modèle de facturation du stockage des ensembles de données.
6. Dans le champ Query Pricing (Tarif des requêtes), entrez l'estimation des octets lus, provenant de votre simulation ou de l'outil de validation des requêtes.
7. Cliquez sur Ajouter à l'estimation.
8. L'estimation apparaît à droite. Vous pouvez envoyer l'estimation par e-mail ou l'enregistrer.

Pour en savoir plus, consultez la section Tarification à la demande.

Éditions

Pour estimer les coûts dans le simulateur de coût Google Cloud lors de l'utilisation du modèle de tarification basée sur la capacité avec des éditions BigQuery spécifiques, procédez comme suit :

1. Ouvrez le simulateur de coût Google Cloud.
2. Cliquez sur BigQuery.
3. Cliquez sur l'onglet Éditions.
4. Choisissez la localisation d'utilisation des emplacements.
5. Choisissez votre édition.
6. Définissez le nombre maximal d'emplacements, le nombre d'emplacements de base, l'engagement (facultatif) et l'utilisation estimée de l'autoscaling.
7. Choisissez l'emplacement de stockage des données.
8. Saisissez les estimations de l'utilisation de l'espace de stockage pour le stockage actif, le stockage à long terme, les insertions en flux continu et les lectures en flux continu. Vous devez seulement estimer le stockage physique ou logique, selon le modèle de facturation du stockage des ensembles de données.
9. Cliquez sur Ajouter à l'estimation.

Pour en savoir plus, consultez la section Tarification basée sur la capacité.

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 l'outil de validation des requêtes dans la console Google Cloud.
• Utilisez le simulateur de coût Google Cloud.
• Effectuez une simulation pour 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 de requête fournit une estimation du nombre d'octets nécessaires pour traiter la requête. Exemple :

  This query will process 623.1 KiB when run.

Remarque : Le mégaoctet est la plus petite unité mesurée par le simulateur de coût.

Effectuer une simulation

Pour effectuer une simulation, procédez comme suit :

Console

1. Accédez à la page BigQuery.

   Accéder à BigQuery

2. Saisissez votre requête dans l'Éditeur de requête.

   Si la requête est valide, une coche apparaît automatiquement avec la quantité de données que la requête va traiter. Si la requête n'est pas valide, un point d'exclamation apparaît avec un message d'erreur.

bq

Saisissez une requête semblable à celle-ci à l'aide de l'option --dry_run.

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

Pour une requête valide, la commande génère la réponse suivante :

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

Remarque : Si votre requête traite une petite quantité de données, vous devrez peut-être convertir les Ko en Mo. Le Mo est la plus petite unité de mesure utilisée par le simulateur de coût.

API

Pour effectuer une simulation avec l'API, envoyez une tâche de requête avec la valeur dryRun définie sur true dans le type JobConfiguration.

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Go.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Java.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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());
    }
  }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

// 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);
}

PHP

Avant d'essayer cet exemple, suivez les instructions de configuration pour PHP du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour PHP.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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']);

Python

Définissez la propriété QueryJobConfig.dry_run sur True. La méthode Client.query() renvoie toujours une tâche QueryJob terminée lorsque vous lui transmettez une configuration de requête simulée.

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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.

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 :

Console

1. Dans l'éditeur de requête, cliquez sur Plus > Paramètres de requête > Options avancées.
2. Dans le champ Nombre maximal d'octets facturés, saisissez un nombre entier.
3. Cliquez sur Enregistrer.

bq

Exécutez la commande bq query avec l'option --maximum_bytes_billed.

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

API

Définissez la propriété maximumBytesBilled dans JobConfigurationQuery ou QueryRequest.

Éviter d'utiliser LIMIT dans les 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.
• Apprenez à optimiser la requête.
• 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