Ejecutar tareas mediante programación

Para ejecutar un trabajo de BigQuery de forma programática mediante la API REST o las bibliotecas de cliente, debes hacer lo siguiente:

1. Llama al método jobs.insert.
2. Solicita periódicamente el recurso de trabajo y examina la propiedad de estado para saber cuándo se ha completado el trabajo.
3. Comprueba si el trabajo se ha completado correctamente.

Antes de empezar

Concede roles de gestión de identidades y accesos (IAM) que proporcionen a los usuarios los permisos necesarios para realizar cada tarea de este documento.

Permisos obligatorios

Para ejecutar una tarea de BigQuery, necesitas el permiso de gestión de identidades y accesos bigquery.jobs.create.

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para ejecutar un trabajo:

• roles/bigquery.user
• roles/bigquery.jobUser
• roles/bigquery.admin

Además, cuando creas un trabajo, se te conceden automáticamente los siguientes permisos para ese trabajo:

• bigquery.jobs.get
• bigquery.jobs.update

Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta el artículo sobre funciones y permisos predefinidos.

Tareas en ejecución

Para ejecutar una tarea mediante programación, sigue estos pasos:

1. Inicia el trabajo llamando al método jobs.insert. Cuando llames al método jobs.insert, incluye una representación de recurso de tarea.

2. En la sección configuration del recurso de trabajo, incluye una propiedad secundaria que especifique el tipo de trabajo: load, query, extract o copy.

3. Después de llamar al método jobs.insert, comprueba el estado del trabajo llamando a jobs.get con el ID y la ubicación del trabajo, y consulta el valor de status.state para saber el estado del trabajo. Cuando status.state es DONE, el trabajo ha dejado de ejecutarse. Sin embargo, el estado DONE no significa que el trabajo se haya completado correctamente, sino que ya no se está ejecutando.

4. Comprueba si el trabajo se ha completado correctamente: Si el trabajo tiene una propiedad errorResult, significa que ha fallado. La propiedad status.errorResult contiene información que describe qué ha ido mal en un trabajo fallido. Si no aparece status.errorResult, significa que el trabajo se ha completado correctamente, aunque puede que se hayan producido algunos errores no fatales, como problemas al importar algunas filas en un trabajo de carga. Los errores no críticos se devuelven en la lista status.errors del trabajo.

Ejecutar trabajos con bibliotecas de cliente

Para crear y ejecutar un trabajo con las bibliotecas de cliente de Cloud para BigQuery, sigue estos pasos:

using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;

public class BigQueryCreateJob
{
    public BigQueryJob CreateJob(string projectId = "your-project-id")
    {
        string query = @"
            SELECT country_name from `bigquery-public-data.utility_us.country_code_iso";

        // Initialize client that will be used to send requests.
        BigQueryClient client = BigQueryClient.Create(projectId);

        QueryOptions queryOptions = new QueryOptions
        {
            JobLocation = "us",
            JobIdPrefix = "code_sample_",
            Labels = new Dictionary<string, string>
            {
                ["example-label"] = "example-value"
            },
            MaximumBytesBilled = 1000000
        };

        BigQueryJob queryJob = client.CreateQueryJob(
            sql: query,
            parameters: null,
            options: queryOptions);

        Console.WriteLine($"Started job: {queryJob.Reference.JobId}");
        return queryJob;
    }
}

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 com.google.common.collect.ImmutableMap;
import java.util.UUID;

// Sample to create a job
public class CreateJob {

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

  public static void createJob(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)
              .setLabels(ImmutableMap.of("example-label", "example-value"))
              .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.getJobId().getJob().equals(jobId.getJob())) {
        System.out.print("Job created successfully." + job.getJobId().getJob());
      } else {
        System.out.print("Job was not created");
      }
    } catch (BigQueryException e) {
      System.out.print("Job was not created. \n" + e.toString());
    }
  }
}

from google.cloud import bigquery

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

query_job = client.query(
    "SELECT country_name from `bigquery-public-data.utility_us.country_code_iso`",
    # Explicitly force job execution to be routed to a specific processing
    # location.
    location="US",
    # Specify a job configuration to set optional job resource properties.
    job_config=bigquery.QueryJobConfig(
        labels={"example-label": "example-value"}, maximum_bytes_billed=1000000
    ),
    # The client libraries automatically generate a job ID. Override the
    # generated ID with either the job_id_prefix or job_id parameters.
    job_id_prefix="code_sample_",
)  # Make an API request.

print("Started job: {}".format(query_job.job_id))

Añadir etiquetas de trabajo

Las etiquetas se pueden añadir a los trabajos de consulta a través de la línea de comandos mediante la marca --label de la herramienta de línea de comandos bq. La herramienta bq solo permite añadir etiquetas a los trabajos de consulta.

También puedes añadir una etiqueta a un trabajo cuando se envía a través de la API especificando la propiedad labels en la configuración del trabajo al llamar al método jobs.insert. La API se puede usar para añadir etiquetas a cualquier tipo de trabajo.

No puedes añadir ni actualizar etiquetas en trabajos pendientes, en curso o completados.

Cuando añades una etiqueta a un trabajo, esta se incluye en tus datos de facturación.

Para obtener más información, consulta Añadir etiquetas de trabajo.

Siguientes pasos

• Consulta Ejecutar consultas para ver un ejemplo de código que inicia y sondea una tarea de consulta.
• Para obtener más información sobre cómo crear una representación de recurso Job, consulta la página de descripción general de Jobs en la referencia de la API.