Kosten schätzen und kontrollieren

Auf dieser Seite werden Best Practices für die Schätzung und Kontrolle von Kosten in BigQuery beschrieben.

Die primären Kosten in BigQuery sind die Kosten für die Verarbeitung von Abfragen und die Speicherung von Daten in BigQuery. BigQuery bietet zwei Arten von Preismodellen für die Abfrageverarbeitung: On-Demand- und kapazitätsbasierte Preise. Für jedes Modell gibt es unterschiedliche Best Practices zur Kostenkontrolle. Für in BigQuery gespeicherte Daten hängen die Kosten vom Abrechnungsmodell für den Speicher ab, das für jedes Dataset konfiguriert ist.

Preise für BigQuery-Computing

Es gibt geringfügige Unterschiede bei den Compute-Preisen für BigQuery, die sich auf die Kapazitätsplanung und Kostenkontrolle auswirken.

Preismodelle

Für On-Demand-Computing in BigQuery fallen Gebühren pro TiB für BigQuery-Abfragen an.

Alternativ dazu fallen für die Kapazitätsberechnung in BigQuery Gebühren für die Rechenressourcen (Slots) an, die zum Verarbeiten der Abfrage verwendet werden. Wenn Sie dieses Modell verwenden möchten, konfigurieren Sie Reservierungen für Slots.

Reservierungen haben die folgenden Funktionen:

• Sie werden in Slotpools zugewiesen und ermöglichen es Ihnen, die Kapazität zu verwalten und Arbeitslasten auf für Ihre Organisation sinnvolle Weise zu isolieren.
• Sie müssen sich in einem Administrationsprojekt befinden und unterliegen Kontingenten und Limits.

Das Kapazitätsabrechnungsmodell bietet mehrere Versionen, die alle eine Pay-as-you-go-Option enthalten, die in Slot-Stunden abgerechnet wird. In den Enterprise- und Enterprise Plus-Versionen sind auch optionale ein- oder dreijährige Slot-Zusicherungen verfügbar, mit denen Sie im Vergleich zum Pay-as-you-go-Tarif Geld sparen können.

Sie können auch Autoscaling-Reservierungen mit der Option „Pay as you go“ festlegen. Weitere Informationen nachstehend:

• Hier finden Sie einen Vergleich der Preismodelle.
• Weitere Informationen zu den Preisen finden Sie unter On-Demand-Preise für Compute und Preise für die Kapazitätsberechnung.

Kosten für jedes Modell begrenzen

Wenn Sie das On-Demand-Preismodell verwenden, können Sie Kosten nur durch die Konfiguration von Tageskontingenten auf Projekt- oder Nutzerebene begrenzen. Diese Kontingente legen jedoch eine harte Obergrenze fest, die verhindert, dass Nutzer Abfragen über das Kontingentlimit hinaus ausführen. Informationen zum Festlegen von Kontingenten finden Sie unter Benutzerdefinierte Abfragekontingente erstellen.

Wenn Sie das kapazitätsbasierte Preismodell mit Slot-Reservierungen verwenden, geben Sie die maximale Anzahl von Slots an, die für eine Reservierung verfügbar sind. Sie können auch Slot-Zusicherungen erwerben, die für einen bestimmten Zeitraum ermäßigte Preise bieten.

Sie können Editionen vollständig on demand verwenden, indem Sie die Baseline der Reservierung auf 0 und das Maximum auf eine Einstellung festlegen, die Ihren Arbeitslastanforderungen entspricht. BigQuery wird automatisch auf die Anzahl der Slots skaliert, die für Ihre Arbeitslast erforderlich sind. Das von Ihnen festgelegte Maximum wird dabei nie überschritten. Weitere Informationen finden Sie unter Arbeitslastverwaltung mit Reservierungen.

Abfragekosten kontrollieren

Wenn Sie die Kosten einzelner Abfragen kontrollieren möchten, empfehlen wir, zuerst die Best Practices für die Optimierung der Abfrageberechnung und die Optimierung des Speichers zu befolgen.

In den folgenden Abschnitten werden zusätzliche Best Practices beschrieben, mit denen Sie Ihre Abfragekosten weiter kontrollieren können.

Benutzerdefinierte Kontingente für Abfragen erstellen

Best Practice:Verwenden Sie benutzerdefinierte tägliche Abfragekontingente, um die täglich verarbeitete Datenmenge zu begrenzen.

Sie können die Kosten verwalten, indem Sie ein benutzerdefiniertes Kontingent festlegen, das die Menge der pro Tag und Projekt oder pro Tag und Nutzer verarbeiteten Daten begrenzt. Nutzer können keine Abfragen ausführen, sobald das Kontingent erreicht ist.

Zum Festlegen eines benutzerdefinierten Kontingents benötigen Sie bestimmte Rollen oder Berechtigungen. Informationen zu Kontingenten, die festgelegt werden können, finden Sie unter Kontingente und Limits.

Weitere Informationen finden Sie unter Kosten für jedes Preismodell begrenzen.

Geschätzte Kosten vor dem Ausführen einer Abfrage prüfen

Best Practice: Erstellen Sie vor dem Ausführen von Abfragen eine Vorschau, um die Kosten abzuschätzen.

Bei Verwendung des On-Demand-Preismodells werden Abfragen nach der Anzahl der gelesenen Byte abgerechnet. So schätzen Sie die Kosten einer Abfrage vorab:

• Verwenden Sie die Abfragevalidierung in der Google Cloud Console.
• Führen Sie einen Probelauf für Abfragen aus.

Abfragevalidierung verwenden

Wenn Sie eine Abfrage in der Google Cloud Console eingeben, überprüft die Abfragevalidierung die Abfragesyntax und liefert die geschätzte Anzahl der gelesenen Byte. Mit dieser Information können Sie im Preisrechner die Abfragekosten einschätzen.

• Wenn die Abfrage ungültig ist, wird bei der Abfragevalidierung eine Fehlermeldung angezeigt. Beispiel:

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

• Wenn Ihre Abfrage gültig ist, gibt die Abfragevalidierung eine Schätzung der Anzahl an Byte an, die zum Verarbeiten der Abfrage erforderlich ist. Beispiel:

  This query will process 623.1 KiB when run.

Probelauf durchführen

So führen Sie einen Probelauf aus:

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 =