Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Gérer les connexions

La gestion des connexions dans BigQuery vous permet de contrôler la façon dont BigQuery se connecte aux sources de données et services externes afin que les analystes puissent interroger des données externes sans les déplacer ni les copier dans BigQuery. Vous pouvez afficher, lister, partager, mettre à jour, supprimer et dépanner les connexions dans vos projets.

Types de connexions compatibles

Vous pouvez créer les types de connexions suivants :

Connexions Amazon S3
Connexions Apache Spark
Connexions à Blob Storage
Connexions aux ressources Cloud pour se connecter aux données Cloud Storage et implémenter des fonctions distantes
Connexions Spanner
Connexions Cloud SQL
Connexions AlloyDB

Pour créer une connexion par défaut pour un projet, consultez la présentation de la connexion par défaut.

Avant de commencer

Assurez-vous que votre connexion fonctionne. Les connexions sont spécifiques au type et dépendent de la source de données externe connectée.
Activez l'API BigQuery Connection.

Activer l'API
Assurez-vous de pouvoir afficher la liste des comptes de service de votre projet. BigQuery crée et utilise un compte de service pour se connecter à votre source de données externe. Lorsque vous créez une connexion, un compte de service IAM (Identity and Access Management) géré parGoogle Cloud est créé en votre nom. Pour afficher le compte de service associé à une connexion particulière, affichez les informations sur la connexion.

Rôles requis

Pour obtenir les autorisations nécessaires pour gérer les connexions, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Afficher les informations sur la connexion : Utilisateur de connexion BigQuery (roles/bigquery.connectionUser) sur votre ensemble de données
Lister toutes les connexions : Utilisateur de connexion BigQuery (roles/bigquery.connectionUser) sur votre ensemble de données
Partager une connexion : Administrateur de connexion BigQuery (roles/bigquery.connectionAdmin) sur votre connexion
Modifier une connexion : Administrateur de connexion BigQuery (roles/bigquery.connectionAdmin) sur votre connexion
Supprimer une connexion : Administrateur de connexion BigQuery (roles/bigquery.connectionAdmin) sur votre connexion

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

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

Pour en savoir plus sur les rôles nécessaires pour créer et utiliser une connexion par défaut, consultez Rôles et autorisations requis.

Ces rôles prédéfinis contiennent les autorisations requises pour effectuer les tâches décrites dans ce document. Pour afficher les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Afficher les informations sur la connexion : bigquery.connections.get
Répertorier toutes les connexions : bigquery.connections.list
Modifier et supprimer une connexion : bigquery.connections.update
Partager une connexion : bigquery.connections.setIamPolicy

Répertorier toutes les connexions

Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery

Les connexions sont répertoriées dans votre projet, dans un groupe appelé Connexions.
Dans le volet de gauche, cliquez sur Explorateur :

Si le volet de gauche ne s'affiche pas, cliquez sur Développer le volet de gauche pour l'ouvrir.
Dans le volet Explorateur, cliquez sur le nom de votre projet, puis sur Connexions pour afficher la liste de toutes les connexions.

bq

Saisissez la commande bq ls, puis spécifiez l'option --connection. Vous pouvez également spécifier les options --project_id et --location pour identifier le projet et l'emplacement des connexions à répertorier.

bq ls --connection --project_id=PROJECT_ID --location=REGION

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
REGION : région de la connexion

API

Utilisez la méthode projects.locations.connections.list dans la documentation de référence de l'API REST.

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.

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 google.api_core.exceptions
from google.cloud import bigquery_connection_v1


def list_connections(project_id: str, location: str):
    """Prints all connections in a given project and location.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the connections (for example, "us", "us-central1").
    """
    client = bigquery_connection_v1.ConnectionServiceClient()

    parent = client.common_location_path(project_id, location)

    request = bigquery_connection_v1.ListConnectionsRequest(
        parent=parent,
        page_size=100,
    )

    print(f"Listing connections in project '{project_id}' and location '{location}':")

    try:
        for connection in client.list_connections(request=request):
            print(f"Connection ID: {connection.name.split('/')[-1]}")
            print(f"Friendly Name: {connection.friendly_name}")
            print(f"Has Credential: {connection.has_credential}")
            print("-" * 20)

        print("Finished listing connections.")

    except google.api_core.exceptions.InvalidArgument as e:
        print(
            f"Could not list connections. Please check that the project ID '{project_id}' "
            f"and location '{location}' are correct. Details: {e}"
        )

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.

const {ConnectionServiceClient} = require('@google-cloud/bigquery-connection');
const {status} = require('@grpc/grpc-js');

const client = new ConnectionServiceClient();

/**
 * Lists BigQuery connections in a given project and location.
 *
 * @param {string} projectId The Google Cloud project ID. for example, 'example-project-id'
 * @param {string} location The location to list connections for. for example, 'us-central1'
 */
async function listConnections(projectId, location) {
  const parent = client.locationPath(projectId, location);

  const request = {
    parent,
    pageSize: 100,
  };

  try {
    const [connections] = await client.listConnections(request, {
      autoPaginate: false,
    });

    if (connections.length === 0) {
      console.log(
        `No connections found in ${location} for project ${projectId}.`,
      );
      return;
    }

    console.log('Connections:');
    for (const connection of connections) {
      console.log(`  Name: ${connection.name}`);
      console.log(`  Friendly Name: ${connection.friendlyName}`);
    }
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.log(
        `Project '${projectId}' or location '${location}' not found.`,
      );
    } else {
      console.error('Error listing connections:', err);
    }
  }
}

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.api.gax.rpc.ApiException;
import com.google.api.gax.rpc.InvalidArgumentException;
import com.google.cloud.bigquery.connection.v1.Connection;
import com.google.cloud.bigquery.connection.v1.ListConnectionsRequest;
import com.google.cloud.bigquery.connection.v1.LocationName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import java.io.IOException;

public class ListConnections {

  /**
   * Lists all BigQuery connections in a given project and location.
   *
   * @param projectId The Google Cloud project ID (for example, "example-project-id").
   * @param location The geographic location of the connections (for example, "us-central1").
   */
  public static void listConnections(String projectId, String location) {
    LocationName parent = LocationName.of(projectId, location);

    ListConnectionsRequest request =
        ListConnectionsRequest.newBuilder().setParent(parent.toString()).setPageSize(100).build();

    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      System.out.printf(
          "Listing connections in project '%s' and location '%s':%n", projectId, location);

      for (Connection connection : client.listConnections(request).iterateAll()) {
        System.out.printf("Connection Name: %s%n", connection.getName());
        System.out.printf("Friendly Name: %s%n", connection.getFriendlyName());
        System.out.printf("Has Credential: %b%n", connection.getHasCredential());
      }

      System.out.println("Finished listing connections.");
    } catch (InvalidArgumentException err) {
      System.err.printf(
          "error: invalid argument listing connections in location '%s' for project '%s': %s%n",
          location, projectId, err.getMessage());
    } catch (ApiException | IOException err) {
      System.err.printf(
          "error: failed to list connections in location '%s' for project '%s': %s%n",
          location, projectId, err.getMessage());
    }
  }

Afficher les informations sur la connexion

Une fois que vous avez créé une connexion, vous pouvez obtenir des informations sur sa configuration. Celle-ci inclut les valeurs que vous avez fournies lors de la création du transfert.

Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Les connexions sont répertoriées dans votre projet, dans un groupe appelé Connexions.
Dans le volet de gauche, cliquez sur Explorateur :
Dans le volet Explorateur, cliquez sur le nom de votre projet, puis sur Connexions pour afficher la liste de toutes les connexions.
Cliquez sur la connexion pour afficher les détails.

bq

Saisissez la commande bq show, puis spécifiez l'option --connection. Qualifiez éventuellement l'ID de connexion avec l'ID de projet et la région de la connexion.

bq show --connection PROJECT_ID.REGION.CONNECTION_ID

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
REGION : région de la connexion
CONNECTION_ID : ID de connexion

API

Utilisez la méthode projects.locations.connections.get dans la documentation de référence de l'API REST.

Python

import google.api_core.exceptions
from google.cloud import bigquery_connection_v1

client = bigquery_connection_v1.ConnectionServiceClient()


def get_connection(project_id: str, location: str, connection_id: str):
    """Retrieves connection metadata about a specified BigQuery connection.

    A connection stores metadata about an external data source and credentials to access it.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the connection (for example, "us-central1").
        connection_id: The ID of the connection to retrieve.
    """

    name = client.connection_path(project_id, location, connection_id)

    try:
        connection = client.get_connection(name=name)

        print(f"Successfully retrieved connection: {connection.name}")
        print(f"Friendly name: {connection.friendly_name}")
        print(f"Description: {connection.description}")
        if connection.cloud_sql:
            print(f"Cloud SQL instance ID: {connection.cloud_sql.instance_id}")
    except google.api_core.exceptions.NotFound:
        print(f"Connection '{name}' not found.")

Node.js

const {ConnectionServiceClient} =
  require('@google-cloud/bigquery-connection').v1;
const {status} = require('@grpc/grpc-js');

const client = new ConnectionServiceClient();

/**
 * Retrieves connection metadata about a specified BigQuery connection.
 *
 * A connection stores metadata about an external data source and credentials to access it.
 *
 * @param {string} projectId - Google Cloud project ID. for example, 'example-project-id'
 * @param {string} location - The location of the connection. for example, 'us-central1'
 * @param {string} connectionId - The ID of the connection to retrieve. for example, 'example_connection'
 */
async function getConnection(projectId, location, connectionId) {
  const name = client.connectionPath(projectId, location, connectionId);

  const request = {
    name,
  };

  try {
    const [connection] = await client.getConnection(request);

    console.log(`Successfully retrieved connection: ${connection.name}`);
    console.log(`  Friendly name: ${connection.friendlyName}`);
    console.log(`  Description: ${connection.description}`);
    console.log(`  Has credential: ${connection.hasCredential}`);

    if (connection.cloudSql) {
      console.log(`  Cloud SQL instance ID: ${connection.cloudSql.instanceId}`);
      console.log(`  Cloud SQL database: ${connection.cloudSql.database}`);
      console.log(`  Cloud SQL type: ${connection.cloudSql.type}`);
    }
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.log(`Connection ${name} not found.`);
    } else {
      console.error(`Error getting connection ${name}:`, err);
    }
  }
}

Java

import com.google.api.gax.rpc.ApiException;
import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.bigquery.connection.v1.Connection;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import java.io.IOException;

public class GetConnection {

  /**
   * Retrieves metadata about a specified BigQuery connection.
   *
   * @param projectId The Google Cloud project ID (for example, "example-project-id").
   * @param location The geographic location of the connection (for example, "us-central1").
   * @param connectionId The ID of the connection to retrieve (for example,
   *     "example-connection-id").
   */
  public static void getConnection(String projectId, String location, String connectionId) {
    ConnectionName name = ConnectionName.of(projectId, location, connectionId);

    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      Connection connection = client.getConnection(name);

      System.out.printf("Successfully retrieved connection: %s%n", connection.getName());
      System.out.printf("Friendly name: %s%n", connection.getFriendlyName());
      System.out.printf("Description: %s%n", connection.getDescription());
      if (connection.hasCloudResource()) {
        System.out.printf(
            "Service Account: %s%n", connection.getCloudResource().getServiceAccountId());
      }
      if (connection.hasCloudSql()) {
        System.out.printf(
            "Cloud SQL instance ID: %s%n", connection.getCloudSql().getInstanceId());
      }
    } catch (NotFoundException err) {
      System.err.printf(
          "error: connection '%s' not found in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    } catch (ApiException | IOException err) {
      System.err.printf(
          "error: failed to get connection '%s' in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    }
  }

Obtenir la stratégie IAM (Identity and Access Management) pour une connexion

Pour obtenir la stratégie IAM d'une connexion, procédez comme suit :

Python


import google.api_core.exceptions
from google.cloud import bigquery_connection_v1

client = bigquery_connection_v1.ConnectionServiceClient()


def get_connection_iam_policy(
    project_id: str,
    location: str,
    connection_id: str,
):
    """Gets the IAM policy of a connection.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the connection (for example, "us").
        connection_id: The ID of the connection.
    """

    resource = client.connection_path(project_id, location, connection_id)

    try:
        policy = client.get_iam_policy(resource=resource)

        print(f"Successfully retrieved IAM policy for connection: {resource}")
        if not policy.bindings:
            print("This policy is empty and has no bindings.")

        for binding in policy.bindings:
            print(f"Role: {binding.role}")
            print("Members:")
            for member in binding.members:
                print(f"    - {member}")

    except google.api_core.exceptions.NotFound:
        print(f"Connection not found: {resource}")

Node.js

const {ConnectionServiceClient} =
  require('@google-cloud/bigquery-connection').v1;
const {status} = require('@grpc/grpc-js');

const client = new ConnectionServiceClient();

/**
 * Gets the IAM policy for a BigQuery connection.
 * @param {string} projectId Google Cloud project ID (for example, 'example-project-id').
 * @param {string} location The location of the connection (for example, 'us').
 * @param {string} connectionId The connection ID (for example, 'example-connection').
 */
async function getIamPolicy(projectId, location, connectionId) {

  const resource = client.connectionPath(projectId, location, connectionId);

  const request = {
    resource,
  };

  try {

    const [policy] = await client.getIamPolicy(request);

    console.log(
      `Successfully retrieved IAM policy for connection: ${connectionId}`,
    );

    if (policy.bindings && policy.bindings.length > 0) {
      console.log('Bindings:');
      policy.bindings.forEach(binding => {
        console.log(`  Role: ${binding.role}`);
        console.log('  Members:');
        binding.members.forEach(member => {
          console.log(`    - ${member}`);
        });
      });
    } else {
      console.log('No policy bindings found.');
    }
  } catch (err) {

    if (err.code === status.NOT_FOUND) {
      console.log(
        `Connection '${connectionId}' not found in project '${projectId}' at location '${location}'.`,
      );
    } else {
      console.error('An error occurred while getting the IAM policy:', err);
    }
  }
}

Java

import com.google.api.gax.rpc.ApiException;
import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import com.google.iam.v1.Binding;
import com.google.iam.v1.GetIamPolicyRequest;
import com.google.iam.v1.Policy;
import java.io.IOException;

public class GetIamPolicy {

  /**
   * Retrieves the IAM policy of a specified BigQuery connection.
   *
   * @param projectId The Google Cloud project ID (for example, "example-project-id").
   * @param location The geographic location of the connection (for example, "us-central1").
   * @param connectionId The ID of the connection (for example, "example-connection-id").
   */
  public static void getIamPolicy(
      String projectId, String location, String connectionId) {
    ConnectionName resource = ConnectionName.of(projectId, location, connectionId);

    GetIamPolicyRequest request =
        GetIamPolicyRequest.newBuilder().setResource(resource.toString()).build();

    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      Policy policy = client.getIamPolicy(request);

      System.out.printf("Successfully retrieved IAM policy for connection: %s%n", resource);
      if (policy.getBindingsList().isEmpty()) {
        System.out.println("Policy is empty and has no bindings.");
      }

      for (Binding binding : policy.getBindingsList()) {
        System.out.printf("Role: %s%n", binding.getRole());
        System.out.println("Members:");
        for (String member : binding.getMembersList()) {
          System.out.printf("  - %s%n", member);
        }
      }
    } catch (NotFoundException err) {
      System.err.printf(
          "error: connection '%s' not found in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    } catch (ApiException | IOException err) {
      System.err.printf(
          "error: failed to get IAM policy for connection '%s' in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    }
  }

Vous pouvez attribuer les rôles suivants pour permettre aux utilisateurs d'interroger des données et de gérer les connexions :

roles/bigquery.connectionUser permet aux utilisateurs de se connecter à des sources de données externes et d'y exécuter des requêtes.
roles/bigquery.connectionAdmin permet aux utilisateurs de gérer les connexions.

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

Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery

Les connexions sont répertoriées dans votre projet, dans un groupe appelé Connexions.
Dans le volet de gauche, cliquez sur Explorateur :

Si le volet de gauche ne s'affiche pas, cliquez sur Développer le volet de gauche pour l'ouvrir.
Cliquez sur votre projet, puis sur Connexions, et sélectionnez une connexion.
Dans le volet Détails, cliquez sur Partager pour partager une connexion. Ensuite, procédez comme suit :
1. Dans la boîte de dialogue Autorisations de connexion, partagez la connexion avec d'autres comptes principaux en ajoutant ou en modifiant des comptes principaux.
2. Cliquez sur Enregistrer.

bq

Vous ne pouvez pas partager de connexion avec l'outil de ligne de commande bq. Pour partager une connexion, utilisez la console Google Cloud ou la méthode de l'API BigQuery Connections permettant le partage de connexion.

API

Utilisez la méthode projects.locations.connections.setIAM dans la documentation de référence de l'API REST BigQuery Connections et fournissez une instance de la ressource policy.

Java

import com.google.api.resourcenames.ResourceName;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import com.google.iam.v1.Binding;
import com.google.iam.v1.Policy;
import com.google.iam.v1.SetIamPolicyRequest;
import java.io.IOException;

// Sample to share connections
public class ShareConnection {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String location = "MY_LOCATION";
    String connectionId = "MY_CONNECTION_ID";
    shareConnection(projectId, location, connectionId);
  }

  static void shareConnection(String projectId, String location, String connectionId)
      throws IOException {
    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      ResourceName resource = ConnectionName.of(projectId, location, connectionId);
      Binding binding =
          Binding.newBuilder()
              .addMembers("group:example-analyst-group@google.com")
              .setRole("roles/bigquery.connectionUser")
              .build();
      Policy policy = Policy.newBuilder().addBindings(binding).build();
      SetIamPolicyRequest request =
          SetIamPolicyRequest.newBuilder()
              .setResource(resource.toString())
              .setPolicy(policy)
              .build();
      client.setIamPolicy(request);
      System.out.println("Connection shared successfully");
    }
  }
}

Modifier une connexion

Une connexion emploie les identifiants de l'utilisateur qui l'a créée. Si vous devez modifier l'utilisateur associé à une connexion, vous pouvez mettre à jour ses identifiants. C'est utile si l'utilisateur qui a créé la connexion ne fait plus partie de votre organisation.

Vous ne pouvez pas modifier les éléments suivants d'une connexion :

Type de connexion
ID de connexion
Emplacement

Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery

Les connexions sont répertoriées dans votre projet, dans un groupe appelé Connexions.
Dans le volet de gauche, cliquez sur Explorateur :
Dans le volet Explorateur, cliquez sur le nom de votre projet, puis sur Connexions pour afficher la liste de toutes les connexions.
Pour afficher les détails, cliquez sur la connexion.
Dans la section Informations sur la connexion, cliquez sur Modifier les détails. Ensuite, procédez comme suit :
1. Dans la boîte de dialogue Modifier la connexion, modifiez les détails de la connexion, y compris les identifiants de l'utilisateur.
2. Cliquez sur Mettre à jour la connexion.

bq

Saisissez la commande bq update, puis indiquez l'option de connexion --connection. L'ID connection_id complet est requis.

  bq update --connection --connection_type='CLOUD_SQL'
      --properties='{"instanceId" : "INSTANCE",
      "database" : "DATABASE", "type" : "MYSQL" }'
      --connection_credential='{"username":"USERNAME", "password":"PASSWORD"}'
      PROJECT.REGION.CONNECTION_ID

Remplacez les éléments suivants :

INSTANCE : instance Cloud SQL
DATABASE : nom de la base de données
USERNAME : nom d'utilisateur de votre base de données Cloud SQL
PASSWORD : mot de passe de votre base de données Cloud SQL
PROJECT : ID du projet Google Cloud
REGION : région de la connexion
CONNECTION_ID : ID de connexion

Par exemple, la commande suivante met à jour la connexion d'un projet avec l'ID federation-test et l'ID de connexion test-mysql.

bq update --connection --connection_type='CLOUD_SQL'
    --properties='{"instanceId" : "federation-test:us-central1:new-mysql",
    "database" : "imdb2", "type" : "MYSQL" }'
    --connection_credential='{"username":"my_username",
    "password":"my_password"}' federation-test.us.test-mysql

API

Reportez-vous à la méthode projects.locations.connections.patch de la section de référence de l'API REST et fournissez une instance de la connection.

Python

import google.api_core.exceptions
from google.cloud import bigquery_connection_v1
from google.protobuf import field_mask_pb2

client = bigquery_connection_v1.ConnectionServiceClient()


def update_connection(project_id: str, location: str, connection_id: str):
    """Updates a BigQuery connection's friendly name and description.

    For security reasons, updating connection properties also resets the
    credential. The `update_mask` specifies which fields of the connection
    to update. This sample only updates metadata fields to avoid resetting
    credentials.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the connection (for example, "us-central1").
        connection_id: The ID of the connection to update.
    """

    connection_name = client.connection_path(project_id, location, connection_id)

    connection = bigquery_connection_v1.Connection(
        friendly_name="Example Updated BigQuery Connection",
        description="This is an updated description for the connection.",
    )

    update_mask = field_mask_pb2.FieldMask(paths=["friendly_name", "description"])

    try:
        response = client.update_connection(
            name=connection_name,
            connection=connection,
            update_mask=update_mask,
        )

        print(f"Connection '{response.name}' updated successfully.")
        print(f"Friendly Name: {response.friendly_name}")
        print(f"Description: {response.description}")

    except google.api_core.exceptions.NotFound:
        print(f"Connection '{connection_name}' not found. Please create it first.")

Node.js

const {ConnectionServiceClient} =
  require('@google-cloud/bigquery-connection').v1;
const {status} = require('@grpc/grpc-js');

const connectionClient = new ConnectionServiceClient();

/**
 * Updates a BigQuery connection, demonstrating how to update the friendly name and description.
 *
 * @param {string} projectId The Google Cloud project ID. for example, 'example-project-id'
 * @param {string} location The location of the connection. for example, 'us-central1'
 * @param {string} connectionId The ID of the connection to update. for example, 'example-connection-id'
 */
async function updateConnection(projectId, location, connectionId) {
  const name = connectionClient.connectionPath(
    projectId,
    location,
    connectionId,
  );

  const connection = {
    friendlyName: 'Example Updated Connection',
    description: 'A new description for the connection',
  };

  const updateMask = {
    paths: ['friendly_name', 'description'],
  };

  const request = {
    name,
    connection,
    updateMask,
  };

  try {
    const [response] = await connectionClient.updateConnection(request);

    console.log(`Connection updated: ${response.name}`);
    console.log(`  Friendly name: ${response.friendlyName}`);
    console.log(`  Description: ${response.description}`);
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.log(`Connection not found: ${name}`);
    } else {
      console.error(`Error updating connection ${name}:`, err);
    }
  }
}

Java

import com.google.api.gax.rpc.ApiException;
import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.bigquery.connection.v1.Connection;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigquery.connection.v1.UpdateConnectionRequest;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class UpdateConnection {

  /**
   * Updates a BigQuery connection's friendly name and description.
   *
   * @param projectId The Google Cloud project ID (for example, "example-project-id").
   * @param location The geographic location of the connection (for example, "us-central1").
   * @param connectionId The ID of the connection to update (for example, "example-connection-id").
   */
  public static void updateConnection(String projectId, String location, String connectionId) {
    ConnectionName name = ConnectionName.of(projectId, location, connectionId);

    Connection connection =
        Connection.newBuilder()
            .setFriendlyName("Example Updated BigQuery Connection")
            .setDescription("Updated description for the connection.")
            .build();

    // Specify only metadata fields in the FieldMask so existing credentials are not reset.
    FieldMask updateMask =
        FieldMask.newBuilder().addPaths("friendly_name").addPaths("description").build();

    UpdateConnectionRequest request =
        UpdateConnectionRequest.newBuilder()
            .setName(name.toString())
            .setConnection(connection)
            .setUpdateMask(updateMask)
            .build();

    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      Connection response = client.updateConnection(request);

      System.out.printf("Connection '%s' updated successfully.%n", response.getName());
      System.out.printf("Friendly Name: %s%n", response.getFriendlyName());
      System.out.printf("Description: %s%n", response.getDescription());
    } catch (NotFoundException err) {
      System.err.printf(
          "error: connection '%s' not found in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    } catch (ApiException | IOException err) {
      System.err.printf(
          "error: failed to update connection '%s' in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    }
  }

Supprimer une connexion

Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery

Les connexions sont répertoriées dans votre projet, dans un groupe appelé Connexions.
Dans le volet de gauche, cliquez sur Explorateur :
Dans le volet Explorateur, cliquez sur le nom de votre projet, puis sur Connexions pour afficher la liste de toutes les connexions.
Cliquez sur la connexion pour afficher les détails.
Dans le volet Détails, cliquez sur Supprimer pour supprimer la connexion.
Dans la boîte de dialogue Delete connection? (Supprimer la connexion ?), saisissez delete pour confirmer la suppression.
Cliquez sur Supprimer.

bq

Saisissez la commande bq rm, puis indiquez l'option de connexion --connection. L'ID connection_id complet est requis.

bq rm --connection PROJECT_ID.REGION.CONNECTION_ID

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
REGION : région de la connexion
CONNECTION_ID : ID de connexion

API

Reportez-vous à la méthode projects.locations.connections.delete dans la documentation de référence de l'API REST.

Python

import google.api_core.exceptions
from google.cloud import bigquery_connection_v1

client = bigquery_connection_v1.ConnectionServiceClient()


def delete_connection(project_id: str, location: str, connection_id: str):
    """Deletes a BigQuery connection.

    Args:
        project_id: The Google Cloud project ID.
        location: Location of the connection (for example, "us-central1").
        connection_id: ID of the connection to delete.
    """
    name = client.connection_path(project_id, location, connection_id)

    try:
        client.delete_connection(name=name)
        print(f"Connection '{connection_id}' was deleted.")
    except google.api_core.exceptions.NotFound:
        print(f"Connection '{connection_id}' not found.")

Node.js

const {ConnectionServiceClient} =
  require('@google-cloud/bigquery-connection').v1;
const {status} = require('@grpc/grpc-js');

const client = new ConnectionServiceClient();

/**
 * Deletes a connection and its associated credentials.
 *
 * @param {string} projectId Google Cloud project ID (for example, 'example-project-id').
 * @param {string} location The location where the connection resides (for example, 'us-central1').
 * @param {string} connectionId The ID of the connection to delete (for example, 'example-connection').
 */
async function deleteConnection(projectId, location, connectionId) {
  const request = {
    name: client.connectionPath(projectId, location, connectionId),
  };

  try {
    await client.deleteConnection(request);
    console.log(`Connection ${connectionId} deleted successfully.`);
  } catch (error) {
    if (error.code === status.NOT_FOUND) {
      console.log(
        `Connection ${connectionId} does not exist in location ${location} of project ${projectId}.`,
      );
    } else {
      console.error(`Error deleting connection ${connectionId}:`, error);
    }
  }
}

Java

import com.google.api.gax.rpc.ApiException;
import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import java.io.IOException;

public class DeleteConnection {

  /**
   * Deletes a specified BigQuery connection.
   *
   * @param projectId The Google Cloud project ID (for example, "example-project-id").
   * @param location The geographic location of the connection (for example, "us-central1").
   * @param connectionId The ID of the connection to delete (for example, "example-connection-id").
   */
  public static void deleteConnection(String projectId, String location, String connectionId) {
    ConnectionName name = ConnectionName.of(projectId, location, connectionId);

    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      client.deleteConnection(name);
      System.out.printf("Connection '%s' was deleted.%n", connectionId);
    } catch (NotFoundException err) {
      System.err.printf(
          "error: connection '%s' not found in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    } catch (ApiException | IOException err) {
      System.err.printf(
          "error: failed to delete connection '%s' in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    }
  }

Étapes suivantes

Découvrez comment utiliser des fonctions distantes.
Découvrez comment utiliser des procédures stockées pour Spark.

Gérer les connexions

Types de connexions compatibles

Avant de commencer

Rôles requis

Autorisations requises

Répertorier toutes les connexions

Console

bq

API

Python

Node.js

Java

Afficher les informations sur la connexion

Console

bq

API

Python

Node.js

Java

Obtenir la stratégie IAM (Identity and Access Management) pour une connexion

Python

Node.js

Java

Partager une connexion avec les utilisateurs

Console

bq

API

Java

Modifier une connexion

Console

bq

API

Python

Node.js

Java

Supprimer une connexion

Console

bq

API

Python

Node.js

Java

Étapes suivantes