Cette page a été traduite par l'API Cloud Translation.

Gérer les jobs

Ce document explique comment gérer des tâches dans BigQuery, y compris comment afficher les détails d'une tâche, répertorier les tâches, annuler une tâche, répéter une tâche et supprimer les métadonnées d'une tâche.

À propos des tâches BigQuery

Chaque fois que vous chargez, exportez, interrogez ou copiez des données, BigQuery crée, planifie et exécute automatiquement une tâche qui suit la progression de la tâche.

Comme les tâches peuvent durer un certain temps, elles s'exécutent de manière asynchrone, et il est possible d'interroger leur état. Les actions plus courtes (telles que la récupération d'une liste de ressources ou l'obtention de métadonnées) ne sont pas gérées en tant que tâches.

Une fois envoyée, une tâche peut être déterminée par l'un des états suivants :

PENDING : la tâche est planifiée et attend d'être exécutée.
RUNNING : la tâche est en cours d'exécution.
DONE : la tâche est terminée. Si la tâche est terminée sans erreur, BigQuery signale cet état comme SUCCESS. Si la tâche se termine avec des erreurs, BigQuery signale cet état comme FAILURE.

Quotas

Pour en savoir plus sur les quotas appliqués aux tâches, consultez la documentation relative aux types de tâches sur la page Quotas et limites:

Tarifs

Chaque tâche est associée à un projet que vous spécifiez. Les coûts d'utilisation liés à une tâche sont facturés sur le compte de facturation associé au projet défini. Si vous partagez l'accès à un projet, tous les coûts liés aux tâches exécutées dans le projet sont facturés sur le compte de facturation.

Par exemple, lors de l'exécution d'une tâche de requête, le coût est facturé au projet qui exécute la tâche. Ainsi, lorsque vous affichez l'ID d'une tâche de requête au format <project_id>:<region>.<job_id>, project_id correspond à l'ID du projet facturé pour la requête.

Pour en savoir plus, reportez-vous à la page Tarifs.

Avant de commencer

Attribuez aux utilisateurs des rôles IAM (Identity and Access Management) incluant les autorisations nécessaires pour effectuer l'ensemble des tâches du présent document.

Rôles requis

Pour obtenir les autorisations nécessaires pour exécuter et gérer des jobs, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet:

Exécuter ou répéter une tâche, lister vos tâches, afficher les détails de vos tâches et les annuler : Utilisateur de tâche BigQuery (roles/bigquery.jobUser) ou Utilisateur BigQuery (roles/bigquery.user)
Lister toutes les tâches d'un projet : administrateur BigQuery (roles/bigquery.admin) ou administrateur de ressources BigQuery (roles/bigquery.resourceAdmin)
Afficher les détails de toutes les tâches d'un projet, annuler une tâche du projet et supprimer les métadonnées de la tâche : Administrateur BigQuery (roles/bigquery.admin)

Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour exécuter et gérer des jobs. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Vous devez disposer des autorisations suivantes pour exécuter et gérer des jobs:

Exécuter ou répéter une tâche, et lister vos tâches : bigquery.jobs.create
Afficher les détails de vos jobs : bigquery.jobs.get
Annulez vos tâches : bigquery.jobs.update
Afficher les détails de toutes les tâches d'un projet :
- bigquery.jobs.get
- bigquery.jobs.listAll
Répertoriez toutes les tâches d'un projet : bigquery.jobs.listAll
Annuler n'importe quelle tâche du projet :
- bigquery.jobs.update
- bigquery.jobs.listAll
Supprimer les métadonnées de tâche :
- bigquery.jobs.delete
- bigquery.jobs.listAll

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Rôles prédéfinis et autorisations.

Afficher les informations sur le job

Vous pouvez afficher les détails du job à l'aide de la console Google Cloud, de l'outil de ligne de commande bq, de l'API ou des bibliothèques clientes. Les détails incluent les données et les métadonnées, telles que le type de job, l'état du job et l'utilisateur qui l'a créée.

Pour afficher les détails d'une tâche, procédez comme suit:

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Développez le volet Historique des jobs.
Sélectionnez le type d'historique des tâches à afficher :
- Pour afficher des informations sur vos tâches récentes, cliquez sur Historique personnel.
- Pour afficher les informations sur les tâches récentes de votre projet, cliquez sur Historique du projet.
Pour afficher les détails d'une tâche, cliquez sur la tâche.

Remarque : La durée d'un job est calculée en soustrayant l'heure de début (plutôt que l'heure de création) de l'heure de fin.

bq

Exécutez la commande bq show avec l'option --job=true et un ID de tâche.

Lorsque vous fournissez l'ID de la tâche, vous pouvez l'utiliser sous sa forme complète ou abrégée. Par exemple, les ID de tâches répertoriés dans la console Google Cloud sont complets. En d'autres termes, ils incluent le projet et l'emplacement:

my-project-1234:US.bquijob_123x456_123y123z123c

Les ID de tâches dans l'outil de ligne de commande sont répertoriés sous forme abrégée. L'ID et l'emplacement du projet ne sont pas inclus :

bquijob_123x456_123y123z123c

Pour spécifier l'emplacement de la tâche, définissez l'option --location sur la valeur correspondant à votre emplacement. Cette option est facultative si vous utilisez l'ID de tâche complet. Si vous incluez l'option --location et que vous utilisez l'ID de tâche complet, l'option --location est ignorée.

La commande suivante demande des informations sur une tâche :

bq --location=LOCATION show --job=true JOB_ID

Remplacez les éléments suivants :

LOCATION : nom de l'emplacement dans lequel la tâche est exécutée Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement à l'aide du fichier .bigqueryrc. Si l'emplacement n'est pas spécifié dans l'ID de la tâche ou à l'aide de l'option --location, l'emplacement par défaut est utilisé.
JOB_ID : ID de la tâche

Exemples

La commande suivante permet d'obtenir des informations récapitulatives sur la tâche US.bquijob_123x456_123y123z123c exécutée dans myproject :

bq show --job=true myproject:US.bquijob_123x456_123y123z123c

Le résultat ressemble à ce qui suit :

 Job Type    State      Start Time      Duration      User Email       Bytes Processed   Bytes Billed   Billing Tier   Labels
 ---------- --------- ----------------- ---------- ------------------- ----------------- -------------- -------------- --------
 extract    SUCCESS   06 Jul 11:32:10   0:01:41    user@example.com

Pour afficher tous les détails de la tâche, renseignez les éléments suivants :

bq show --format=prettyjson --job=true myproject:US.bquijob_123x456_789y123z456c

Le résultat ressemble à ce qui suit :

{
  "configuration": {
    "extract": {
      "compression": "NONE",
      "destinationUri": "[URI removed]",
      "destinationUris": [
        "[URI removed]"
      ],
      "sourceTable": {
        "datasetId": "github_repos",
        "projectId": "bigquery-public-data",
        "tableId": "commits"
      }
    }
  },
  "etag": "\"[etag removed]\"",
  "id": "myproject:bquijob_123x456_789y123z456c",
  "jobReference": {
    "jobId": "bquijob_123x456_789y123z456c",
    "projectId": "[Project ID removed]"
  },
  "kind": "bigquery#job",
  "selfLink": "https://bigquery.googleapis.com/bigquery/v2/projects/federated-testing/jobs/bquijob_123x456_789y123z456c",
  "statistics": {
    "creationTime": "1499365894527",
    "endTime": "1499365894702",
    "startTime": "1499365894702"
  },
  "status": {
    "errorResult": {
      "debugInfo": "[Information removed for readability]",
      "message": "Operation cannot be performed on a nested schema. Field: author",
      "reason": "invalid"
    },
    "errors": [
      {
        "message": "Operation cannot be performed on a nested schema. Field: author",
        "reason": "invalid"
      }
    ],
    "state": "DONE"
  },
  "user_email": "user@example.com"
}

API

Appelez jobs.get, puis indiquez les paramètres jobId et projectId. (Facultatif) Fournissez le paramètre location et définissez la valeur sur l'emplacement dans lequel la tâche est exécutée. Ce paramètre est facultatif si vous utilisez l'ID de tâche complet qui inclut l'emplacement, par exemple my-project-1234:US.bquijob_123x456_123y123z123c.

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

// getJobInfo demonstrates retrieval of a job, which can be used to monitor
// completion or print metadata about the job.
func getJobInfo(w io.Writer, projectID, jobID string) error {
	// projectID := "my-project-id"
	// jobID := "my-job-id"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	job, err := client.JobFromID(ctx, jobID)
	if err != nil {
		return err
	}

	status := job.LastStatus()
	state := "Unknown"
	switch status.State {
	case bigquery.Pending:
		state = "Pending"
	case bigquery.Running:
		state = "Running"
	case bigquery.Done:
		state = "Done"
	}
	fmt.Fprintf(w, "Job %s was created %v and is in state %s\n",
		jobID, status.Statistics.CreationTime, state)
	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.

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.JobId;

// Sample to get a job
public class GetJob {

  public static void runGetJob() {
    // TODO(developer): Replace these variables before running the sample.
    String jobName = "MY_JOB_NAME";
    getJob(jobName);
  }

  public static void getJob(String jobName) {
    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();

      JobId jobId = JobId.of(jobName);
      Job job = bigquery.getJob(jobId);
      System.out.println("Job retrieved successfully");
    } catch (BigQueryException e) {
      System.out.println("Job not retrieved. \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.

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

async function getJob() {
  // Get job properties.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const jobId = "existing-job-id";

  // Create a job reference
  const job = bigquery.job(jobId);

  // Retrieve job
  const [jobResult] = await job.get();

  console.log(jobResult.metadata.jobReference);
}

Python

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.

from google.cloud import bigquery


def get_job(
    client: bigquery.Client,
    location: str = "us",
    job_id: str = "abcd-efgh-ijkl-mnop",
) -> None:
    job = client.get_job(job_id, location=location)

    # All job classes have "location" and "job_id" string properties.
    # Use these properties for job operations such as "cancel_job" and
    # "delete_job".
    print(f"{job.location}:{job.job_id}")
    print(f"Type: {job.job_type}")
    print(f"State: {job.state}")
    print(f"Created: {job.created.isoformat()}")

Si vous avez besoin d'informations supplémentaires pour résoudre des problèmes liés à une tâche, consultez les vues INFORMATION_SCHEMA.JOBS* et les journaux.

Répertorier des tâches

BigQuery enregistre un historique de tâche de six mois pour toutes les tâches d'un projet, pour tous les emplacements. L'historique des tâches comprend les tâches à l'état RUNNING et DONE (indiqué par le signalement de l'état SUCCESS ou FAILURE).

Pour répertorier les tâches dans un projet, procédez comme suit:

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Développez le volet Historique des jobs.
Pour répertorier toutes les tâches d'un projet, cliquez sur Historique du projet. Si vous n'êtes pas le propriétaire du projet, vous ne disposez peut-être pas de l'autorisation nécessaire pour en afficher toutes les tâches. Les tâches les plus récentes sont répertoriées en premier.
Pour répertorier vos tâches, cliquez sur Historique personnel.

bq

Exécutez la commande bq ls avec l'une des options suivantes :

--jobs=true ou -j : identifie les jobs sous la forme du type de ressource à répertorier.
--all=true ou -a : répertorie les jobs de tous les utilisateurs. Pour afficher les détails complets (non masqués) de toutes les tâches, vous devez disposer des autorisations bigquery.jobs.listAll.
--min_creation_time : répertorie les jobs intervenant après une valeur d'horodatage fournie. Cette valeur est représentée par un horodatage Unix en millisecondes.
--max_creation_time : répertorie les jobs intervenant avant une valeur d'horodatage fournie. Cette valeur est représentée par un horodatage Unix en millisecondes.
Les options --max_results ou -n limitent les résultats. La valeur par défaut est 50 résultats.

bq ls --jobs=true --all=true \
    --min_creation_time=MIN_TIME \
    --max_creation_time=MAX_TIME \
    --max_results=MAX_RESULTS \
    PROJECT_ID

Remplacez les éléments suivants :

MIN_TIME : entier représentant un horodatage d'époque Unix en millisecondes.
MAX_TIME : entier représentant un horodatage d'époque Unix en millisecondes.
MAX_RESULTS : entier indiquant le nombre de jobs renvoyés.
PROJECT_ID : l'ID du projet contenant les tâches que vous répertoriez Si vous définissez un projet par défaut, vous n'avez pas besoin de spécifier le paramètre PROJECT_ID.

Exemples

La commande suivante répertorie toutes les tâches pour l'utilisateur actuel. L'exécution de cette commande nécessite les autorisations bigquery.jobs.list.

bq ls --jobs=true myproject

La commande suivante répertorie toutes les tâches pour tous les utilisateurs. L'exécution de cette commande nécessite les autorisations bigquery.jobs.listAll.

bq ls --jobs=true --all=true myproject

La commande suivante répertorie les 10 tâches les plus récentes dans myproject :

bq ls --jobs=true --all=true --max_results=10 myproject

La commande suivante répertorie toutes les tâches soumises avant le 3 mars 2032 à 4:04:00. Cet horodatage (en millisecondes) est équivalent à la valeur entière suivante : 1961899440000.

bq ls --jobs=true --max_creation_time=1961899440000

API

Appelez jobs.list et spécifiez le paramètre projectId. Pour répertorier les tâches pour tous les utilisateurs, définissez le paramètre allUsers sur true. Pour définir allUsers sur true, vous devez disposer des autorisations bigquery.jobs.listAll.

Go

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// listJobs demonstrates iterating through the BigQuery jobs collection.
func listJobs(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	// jobID := "my-job-id"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	it := client.Jobs(ctx)
	// List up to 10 jobs to demonstrate iteration.
	for i := 0; i < 10; i++ {
		j, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		state := "Unknown"
		switch j.LastStatus().State {
		case bigquery.Pending:
			state = "Pending"
		case bigquery.Running:
			state = "Running"
		case bigquery.Done:
			state = "Done"
		}
		fmt.Fprintf(w, "Job %s in state %s\n", j.ID(), state)
	}
	return nil
}

Java

import com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;

// Sample to get list of jobs
public class ListJobs {

  public static void runListJobs() {
    listJobs();
  }

  public static void listJobs() {
    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();

      Page<Job> jobs = bigquery.listJobs(BigQuery.JobListOption.pageSize(10));
      if (jobs == null) {
        System.out.println("Dataset does not contain any jobs.");
        return;
      }
      jobs.getValues().forEach(job -> System.out.printf("Success! Job ID: %s", job.getJobId()));
    } catch (BigQueryException e) {
      System.out.println("Jobs not listed in dataset due to error: \n" + e.toString());
    }
  }
}

Node.js

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

async function listJobs() {
  // Lists all jobs in current GCP project.

  // List the 10 most recent jobs in reverse chronological order.
  //  Omit the max_results parameter to list jobs from the past 6 months.
  const options = {maxResults: 10};
  const [jobs] = await bigquery.getJobs(options);

  console.log('Jobs:');
  jobs.forEach(job => console.log(job.id));
}

Python


from google.cloud import bigquery

import datetime

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

# List the 10 most recent jobs in reverse chronological order.
# Omit the max_results parameter to list jobs from the past 6 months.
print("Last 10 jobs:")
for job in client.list_jobs(max_results=10):  # API request(s)
    print("{}".format(job.job_id))

# The following are examples of additional optional parameters:

# Use min_creation_time and/or max_creation_time to specify a time window.
print("Jobs from the last ten minutes:")
ten_mins_ago = datetime.datetime.utcnow() - datetime.timedelta(minutes=10)
for job in client.list_jobs(min_creation_time=ten_mins_ago):
    print("{}".format(job.job_id))

# Use all_users to include jobs run by all users in the project.
print("Last 10 jobs run by all users:")
for job in client.list_jobs(max_results=10, all_users=True):
    print("{} run by user: {}".format(job.job_id, job.user_email))

# Use state_filter to filter by job state.
print("Last 10 jobs done:")
for job in client.list_jobs(max_results=10, state_filter="DONE"):
    print("{}".format(job.job_id))

Annuler une mission

Vous pouvez annuler une tâche RUNNING ou PENDING. Il faut généralement moins d'une minute pour annuler une tâche.

Même si la tâche peut être annulée, le succès de l'opération n'est pas garanti. La tâche peut se terminer au moment de l'envoi de la demande d'annulation ou se trouver dans une étape ne permettant pas son annulation.

Pour annuler une tâche, procédez comme suit:

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Cliquez sur Saisir une nouvelle requête et saisissez une requête.
Pour exécuter la requête, cliquez sur Run (Exécuter).
Pour annuler une tâche, cliquez sur Cancel (Annuler).

SQL

Utilisez la procédure système BQ.JOBS.CANCEL :

  CALL BQ.JOBS.CANCEL('JOB_ID');

Remplacez JOB_ID par l'ID de la tâche à annuler.

Si vous vous trouvez dans un projet différent, mais dans la même région que la tâche que vous souhaitez annuler, vous devez également inclure l'ID du projet :

  CALL BQ.JOBS.CANCEL('PROJECT_ID.JOB_ID');

Remplacez les éléments suivants :

PROJECT_ID : l'ID du projet contenant la tâche à annuler
JOB_ID : l'ID de la tâche à annuler

La procédure s'affiche immédiatement, et BigQuery annule la tâche peu de temps après. Si la tâche a déjà réussi ou échoué, la procédure n'a aucun effet.

bq

Exécutez la commande bq cancel avec l'argument JOB_ID. Vous pouvez demander une annulation et afficher immédiatement le résultat à l'aide de l'option --nosync=true. Par défaut, les demandes d'annulation attendent la fin de l'opération.

Lorsque vous fournissez l'argument JOB_ID, vous pouvez utiliser l'ID complet ou la forme abrégée. Par exemple, les ID de tâches répertoriés dans la console Google Cloud sont complets. En d'autres termes, ils incluent le projet et l'emplacement :

my-project-1234:US.bquijob_123x456_123y123z123c

Les ID de tâches dans l'outil de ligne de commande bq sont répertoriés sous forme abrégée. L'ID et l'emplacement du projet ne sont pas inclus :

bquijob_123x456_123y123z123c

La commande suivante demande l'annulation de la tâche et attend la fin de l'opération. Si l'ID de tâche complet est fourni, l'option --location est ignorée :

bq --location=LOCATION cancel JOB_ID

La commande suivante demande l'annulation de la tâche et l'affiche immédiatement. Si l'ID de tâche complet est fourni, l'option --location est ignorée :

bq --location=LOCATION --nosync cancel JOB_ID

Remplacez les éléments suivants :

LOCATION (facultatif) : le nom de la zone dans laquelle la tâche est exécutée Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement à l'aide du fichier .bigqueryrc.
JOB_ID : l'ID du job à annuler Si vous copiez l'ID du job à partir de la console Google Cloud, l'ID et l'emplacement du projet sont inclus dans l'ID du job. Exemple : my-project-1234:US.bquijob_123x456_123y123z123c.

Exemples

La commande suivante annule la tâche my-project-1234:US.bquijob_123x456_123y123z123c exécutée dans l'emplacement multirégional US dans le projet my-project-1234 et attend la fin de l'opération. Comme l'ID de tâche complet est utilisé, l'option d'emplacement n'est pas fournie.

bq cancel my-project-1234:US.bquijob_123x456_123y123z123c

La commande suivante annule la tâche bquijob_123x456_123y123z123c exécutée dans l'emplacement multirégional US dans le projet my-project-1234 et attend la fin de l'opération. Comme la forme abrégée de l'ID de tâche est utilisée, l'option --location est fournie.

bq --location=US cancel bquijob_123x456_123y123z123c

La commande suivante annule la tâche bquijob_123x456_123y123z123c exécutée dans l'emplacement multirégion US dans le projet my-project-1234 et affiche immédiatement le résultat. Comme l'ID de tâche complet est utilisé, l'option --location n'est pas fournie.

bq --nosync cancel my-project-1234:US.bquijob_123x456_123y123z123c

API

Appelez jobs.cancel, puis indiquez les paramètres jobId et projectId. Fournissez le paramètre location et définissez la valeur sur l'emplacement dans lequel la tâche est exécutée.

Go

import (
	"context"
	"fmt"

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

// cancelJob demonstrates how a job cancellation request can be issued for a specific
// BigQuery job.
func cancelJob(projectID, jobID string) error {
	// projectID := "my-project-id"
	// jobID := "my-job-id"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	job, err := client.JobFromID(ctx, jobID)
	if err != nil {
		return nil
	}
	return job.Cancel(ctx)
}

Java

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.JobId;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.QueryJobConfiguration;
import java.util.UUID;

// Sample to cancel a job
public class CancelJob {

  public static void runCancelJob() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT country_name from `bigquery-public-data.utility_us.country_code_iso`";
    cancelJob(query);
  }

  public static void cancelJob(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();

      // Specify a job configuration to set optional job resource properties.
      QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();

      // The location and job name are optional,
      // if both are not specified then client will auto-create.
      String jobName = "jobId_" + UUID.randomUUID().toString();
      JobId jobId = JobId.newBuilder().setLocation("us").setJob(jobName).build();

      // Create a job with job ID
      bigquery.create(JobInfo.of(jobId, queryConfig));

      // Get a job that was just created
      Job job = bigquery.getJob(jobId);
      if (job.cancel()) {
        System.out.println("Job canceled successfully");
      } else {
        System.out.println("Job was not canceled");
      }
    } catch (BigQueryException e) {
      System.out.println("Job was not canceled.\n" + e.toString());
    }
  }
}

Node.js

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

async function cancelJob() {
  // Attempts to cancel a job.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const jobId = "existing-job-id";

  // Create a job reference
  const job = bigquery.job(jobId);

  // Attempt to cancel job
  const [apiResult] = await job.cancel();

  console.log(apiResult.job.status);
}

Python

from google.cloud import bigquery


def cancel_job(
    client: bigquery.Client,
    location: str = "us",
    job_id: str = "abcd-efgh-ijkl-mnop",
) -> None:
    job = client.cancel_job(job_id, location=location)
    print(f"{job.location}:{job.job_id} cancelled")

Supprimer les métadonnées de tâche

Vous pouvez supprimer les métadonnées d'un job spécifique à l'aide de l'outil de ligne de commande bq et de la bibliothèque cliente Python. BigQuery conserve un historique des jobs exécutés au cours des six derniers mois. Cette méthode vous permet de supprimer les informations sensibles éventuellement présentes dans les instructions de requête. Les métadonnées d'une tâche ne peuvent être supprimées qu'une fois la tâche terminée. Si une tâche a créé des tâches enfants, elles sont également supprimées. Il n'est pas possible de supprimer des tâches enfants. Seules les tâches parentes ou de niveau supérieur peuvent être supprimées.

Pour supprimer les métadonnées d'un job, procédez comme suit:

bq

Exécutez la commande bq rm avec l'option -j et un ID de tâche.

my-project-1234:US.bquijob_123x456_123y123z123c

Les ID de jobs dans l'outil de ligne de commande bq sont répertoriés sous forme abrégée. L'ID et l'emplacement du projet ne sont pas inclus :

bquijob_123x456_123y123z123c

La commande suivante supprime une tâche:

bq --location=location \
    --project_id=project_id \
    rm -j job_id

Python

from google.api_core import exceptions
from google.cloud import bigquery

# TODO(developer): Set the job ID to the ID of the job whose metadata you
#                  wish to delete.
job_id = "abcd-efgh-ijkl-mnop"

# TODO(developer): Set the location to the region or multi-region
#                  containing the job.
location = "us-east1"

client = bigquery.Client()

client.delete_job_metadata(job_id, location=location)

try:
    client.get_job(job_id, location=location)
except exceptions.NotFound:
    print(f"Job metadata for job {location}:{job_id} was deleted.")

Répéter des tâches

Il n'est pas possible de répéter une tâche en utilisant le même ID. À la place, vous devez créer un job avec la même configuration. Lorsque vous envoyez la nouvelle tâche dans la console Google Cloud ou dans l'outil de ligne de commande bq, un nouvel ID de tâche est attribué. Lorsque vous envoyez la tâche via l'API ou les bibliothèques clientes, vous devez générer un nouvel ID de tâche.

Pour répéter une tâche, procédez comme suit:

Console

Pour répéter une tâche de requête, procédez comme suit:

Accédez à la page BigQuery.

Accéder à BigQuery
Développez le volet Historique des jobs.
Pour répertorier toutes vos tâches, cliquez sur Historique personnel. Pour répertorier toutes les tâches d'un projet, cliquez sur Historique du projet.
Cliquez sur une tâche de requête pour en afficher les détails.
Pour répéter une requête, cliquez sur Ouvrir en tant que nouvelle requête.
Cliquez sur Exécuter.

Pour répéter une tâche de chargement, procédez comme suit :

Accédez à la page BigQuery.

Accéder à BigQuery
Développez le volet Historique des jobs.
Pour répertorier toutes vos tâches, cliquez sur Historique personnel. Pour répertorier toutes les tâches d'un projet, cliquez sur Historique du projet.
Cliquez sur une tâche de chargement pour en afficher les détails.
Pour répéter un job, cliquez sur Répéter le job de chargement.

bq

Relancez votre commande pour que BigQuery génère automatiquement une tâche avec un nouvel ID de tâche.

API

Il n'existe pas de méthode d'appel unique pour répéter une tâche. Pour répéter une tâche spécifique, vous devez procéder comme suit :

Appelez jobs.get pour récupérer la ressource de la tâche à répéter.
Supprimez les champs id, status et statistics. Remplacez le champ jobId par une nouvelle valeur générée par votre code client. Modifiez les autres champs si nécessaire.
Appelez jobs.insert avec la ressource modifiée et le nouvel ID de tâche pour démarrer la nouvelle tâche.

Étape suivante

Apprenez à exécuter des tâches de manière automatisée.