Diese Seite wurde von der Cloud Translation API übersetzt.

Verbindungen verwalten

In diesem Dokument wird beschrieben, wie Sie eine BigQuery-Verbindung aufrufen, auflisten, freigeben, bearbeiten, löschen und Fehler beheben.

Als BigQuery-Administrator können Sie Verbindungen erstellen und verwalten, die zum Herstellen einer Verbindung zu Diensten und externen Datenquellen verwendet werden. BigQuery-Analysten verwenden diese Verbindungen, um Abfragen für externe Datenquellen zu senden, ohne Daten in BigQuery verschieben oder kopieren zu müssen. Sie können die folgenden Arten von Verbindungen erstellen:

Amazon S3-Verbindungen
Apache Spark-Verbindungen
Blob Storage-Verbindungen
Cloud-Ressourcenverbindungen, um eine Verbindung zu Cloud Storage-Daten herzustellen und Remote-Funktionen zu implementieren
Cloud Spanner-Verbindungen
Cloud SQL-Verbindungen
AlloyDB-Verbindungen

Informationen zum Erstellen einer Standardverbindung für ein Projekt finden Sie unter Standardverbindung – Übersicht.

Hinweise

Stellen Sie sicher, dass eine funktionierende Verbindung besteht. Verbindungen sind typspezifisch und hängen von der verbundenen externen Datenquelle ab.
BigQuery Connection API aktivieren.

API aktivieren
Prüfen Sie, ob Sie eine Liste der Dienstkonten in Ihrem Projekt aufrufen können. BigQuery erstellt und verwendet ein Dienstkonto, um eine Verbindung zu Ihrer externen Datenquelle herzustellen. Wenn Sie eine Verbindung erstellen, wird ein vonGoogle Cloudverwaltetes IAM-Dienstkonto (Identity and Access Management) für Sie erstellt. Rufen Sie die Verbindungsdetails auf, um das Dienstkonto zu sehen, das einer bestimmten Verbindung zugeordnet ist.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zur Verwaltung von Verbindungen benötigen:

Verbindungsdetails ansehen: BigQuery Connection User (roles/bigquery.connectionUser) für Ihr Dataset
Alle Verbindungen auflisten: BigQuery Connection User (roles/bigquery.connectionUser) für Ihr Dataset
Verbindung freigeben: BigQuery-Verbindungsadministrator (roles/bigquery.connectionAdmin) für Ihre Verbindung
Verbindung bearbeiten: BigQuery-Verbindungsadministrator (roles/bigquery.connectionAdmin) für Ihre Verbindung
Verbindung löschen: BigQuery-Verbindungsadministrator (roles/bigquery.connectionAdmin) für Ihre Verbindung

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Informationen zu den Rollen, die zum Erstellen und Verwenden einer Standardverbindung erforderlich sind, finden Sie unter Erforderliche Rollen und Berechtigungen.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Ausführen der Aufgaben in diesem Dokument erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Verbindungsdetails ansehen: bigquery.connections.get
Alle Verbindungen auflisten: bigquery.connections.list
Verbindung bearbeiten oder löschen: bigquery.connections.update
Verbindung teilen: bigquery.connections.setIamPolicy

Alle Verbindungen auflisten

Wählen Sie eine der folgenden Optionen aus:

Console

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Verbindungen werden in Ihrem Projekt in einer Gruppe namens Verbindungen aufgeführt.
Klicken Sie im linken Bereich auf Explorer:

Wenn Sie den linken Bereich nicht sehen, klicken Sie auf Linken Bereich maximieren, um ihn zu öffnen.
Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts und dann auf Verbindungen, um eine Liste aller Verbindungen aufzurufen.

bq

Verwenden Sie den bq ls-Befehl und geben Sie das Flag --connection an. Geben Sie optional die Flags --project_id und --location an, um das Projekt und den Standort der aufzulistenden Verbindungen zu identifizieren.

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

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Google Cloud Projekt-ID
REGION: die Verbindungsregion

API

Verwenden Sie die Methode projects.locations.connections.list im Referenzabschnitt der REST API.

Python

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Python API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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;

// Sample to get list of connections
public class ListConnections {

  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";
    listConnections(projectId, location);
  }

  static void listConnections(String projectId, String location) throws IOException {
    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      LocationName parent = LocationName.of(projectId, location);
      int pageSize = 10;
      ListConnectionsRequest request =
          ListConnectionsRequest.newBuilder()
              .setParent(parent.toString())
              .setPageSize(pageSize)
              .build();
      client
          .listConnections(request)
          .iterateAll()
          .forEach(con -> System.out.println("Connection Id :" + con.getName()));
    }
  }
}

Verbindungsdetails ansehen

Nachdem Sie eine Verbindung erstellt haben, können Sie Informationen zur Konfiguration der Verbindung abrufen. Die Konfiguration enthält die Werte, die Sie bei der Erstellung der Übertragung angegeben haben.

Wählen Sie eine der folgenden Optionen aus:

Console

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen
Verbindungen werden in Ihrem Projekt in einer Gruppe namens Verbindungen aufgeführt.
Klicken Sie im linken Bereich auf Explorer:
Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts und dann auf Verbindungen, um eine Liste aller Verbindungen aufzurufen.
Klicken Sie auf die Verbindung, um die Details aufzurufen.

bq

Verwenden Sie den bq show-Befehl und geben Sie das Flag --connection an. Geben Sie optional die Verbindungs-ID und die Projekt-ID und die Region der Verbindung an.

bq show --connection PROJECT_ID.REGION.CONNECTION_ID

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Google Cloud Projekt-ID
REGION: die Verbindungsregion
CONNECTION_ID: die Verbindungs-ID

API

Verwenden Sie die Methode projects.locations.connections.get im Referenzabschnitt der REST API.

Python

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

import com.google.cloud.bigquery.connection.v1.Connection;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigquery.connection.v1.GetConnectionRequest;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import java.io.IOException;

// Sample to get connection
public class GetConnection {

  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";
    getConnection(projectId, location, connectionId);
  }

  static void getConnection(String projectId, String location, String connectionId)
      throws IOException {
    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      ConnectionName name = ConnectionName.of(projectId, location, connectionId);
      GetConnectionRequest request =
          GetConnectionRequest.newBuilder().setName(name.toString()).build();
      Connection response = client.getConnection(request);
      System.out.println("Connection info retrieved successfully :" + response.getName());
    }
  }
}

IAM-Richtlinie (Identity and Access Management) für eine Verbindung abrufen

So rufen Sie die IAM-Richtlinie für eine Verbindung ab:

Python

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.


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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Sie können die folgenden Rollen zuweisen, damit Nutzer Daten abfragen und Verbindungen verwalten können:

roles/bigquery.connectionUser: Nutzer können Verbindungen nutzen, um sich mit externen Datenquellen zu verbinden und diese abzufragen.
roles/bigquery.connectionAdmin: Nutzer können Verbindungen verwalten.

Weitere Informationen zu IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Vordefinierte Rollen und Berechtigungen.

Wählen Sie eine der folgenden Optionen aus:

Console

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Verbindungen werden in Ihrem Projekt in einer Gruppe namens Verbindungen aufgeführt.
Klicken Sie im linken Bereich auf Explorer:

Wenn Sie den linken Bereich nicht sehen, klicken Sie auf Linken Bereich maximieren, um ihn zu öffnen.
Klicken Sie auf Ihr Projekt, dann auf Connections (Verbindungen) und wählen Sie eine Verbindung aus.
Klicken Sie im Bereich Details auf Freigeben, um eine Verbindung freizugeben. Führen Sie anschließend folgende Schritte aus:
1. Geben Sie im Dialogfeld Verbindungsberechtigungen die Verbindung für andere Hauptkonten frei, indem Sie Hauptkonten hinzufügen oder bearbeiten.
2. Klicken Sie auf Speichern.

bq

Sie können keine Verbindung mit dem bq-Befehlszeilentool freigeben. Verwenden Sie zum Freigeben einer Verbindung die Google Cloud Console oder die Methode der BigQuery Connections API.

API

Verwenden Sie die Methode projects.locations.connections.setIAM in dem Referenzabschnitt zur BigQuery Connections REST API und geben Sie eine Instanz der Ressource policy an.

Java

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Verbindung bearbeiten

Eine Verbindung verwendet die Anmeldedaten des Nutzers, der sie erstellt hat. Wenn Sie den einer Verbindung zugeordneten Nutzer ändern müssen, können Sie die Anmeldedaten des Nutzers aktualisieren. Dies ist hilfreich, wenn der Nutzer, der die Verbindung erstellt hat, der Organisation nicht mehr angehört.

Die folgenden Elemente einer Verbindung können Sie nicht bearbeiten:

Verbindungstyp
Verbindungs-ID
Standort

Wählen Sie eine der folgenden Optionen aus:

Console

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Verbindungen werden in Ihrem Projekt in einer Gruppe namens Verbindungen aufgeführt.
Klicken Sie im linken Bereich auf Explorer:
Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts und dann auf Verbindungen, um eine Liste aller Verbindungen aufzurufen.
Klicken Sie auf die Verbindung, um die Details aufzurufen.
Klicken Sie im Bereich Verbindungsinformationen auf Details bearbeiten. Führen Sie anschließend folgende Schritte aus:
1. Bearbeiten Sie im Dialogfeld Verbindung bearbeiten die Verbindungsdetails, einschließlich der Nutzeranmeldedaten.
2. Klicken Sie auf Verbindung aktualisieren.

bq

Geben Sie den Befehl bq update ein und geben Sie das Verbindungs-Flag --connection an. Die vollständig qualifizierte connection_id ist erforderlich.

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

Dabei gilt:

INSTANCE: die Cloud SQL-Instanz
DATABASE: der Datenbankname
USERNAME: der Nutzername Ihrer Cloud SQL-Datenbank
PASSWORD: das Passwort für Ihre Cloud SQL-Datenbank
PROJECT: die Google Cloud Projekt-ID
REGION: die Verbindungsregion
CONNECTION_ID: die Verbindungs-ID

Mit dem folgenden Befehl wird beispielsweise die Verbindung in einem Projekt mit der ID federation-test und der Verbindungs-ID test-mysql aktualisiert.

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

Sehen Sie sich die Methode projects.locations.connections.patch im Referenzabschnitt der REST API an und geben Sie eine Instanz der Ressource connection an.

Python

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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 com.google.protobuf.util.FieldMaskUtil;
import java.io.IOException;

// Sample to update connection
public class UpdateConnection {

  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";
    String description = "MY_DESCRIPTION";
    Connection connection = Connection.newBuilder().setDescription(description).build();
    updateConnection(projectId, location, connectionId, connection);
  }

  static void updateConnection(
      String projectId, String location, String connectionId, Connection connection)
      throws IOException {
    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      ConnectionName name = ConnectionName.of(projectId, location, connectionId);
      FieldMask updateMask = FieldMaskUtil.fromString("description");
      UpdateConnectionRequest request =
          UpdateConnectionRequest.newBuilder()
              .setName(name.toString())
              .setConnection(connection)
              .setUpdateMask(updateMask)
              .build();
      Connection response = client.updateConnection(request);
      System.out.println("Connection updated successfully :" + response.getDescription());
    }
  }
}

Verbindung löschen

Wählen Sie eine der folgenden Optionen aus:

Console

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Verbindungen werden in Ihrem Projekt in einer Gruppe namens Verbindungen aufgeführt.
Klicken Sie im linken Bereich auf Explorer:
Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts und dann auf Verbindungen, um eine Liste aller Verbindungen aufzurufen.
Klicken Sie auf die Verbindung, um die Details aufzurufen.
Klicken Sie im Detailbereich auf Löschen, um die Verbindung zu löschen.
Geben Sie im Dialogfeld Verbindung löschen? delete ein, um den Löschvorgang zu bestätigen.
Klicken Sie auf Löschen.

bq

Geben Sie den Befehl bq rm ein und geben Sie das Verbindungs-Flag --connection an. Die vollständig qualifizierte connection_id ist erforderlich.

bq rm --connection PROJECT_ID.REGION.CONNECTION_ID

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Google Cloud Projekt-ID
REGION: die Verbindungsregion
CONNECTION_ID: die Verbindungs-ID

API

Weitere Informationen finden Sie unter projects.locations.connections.delete-Methode im Referenzabschnitt der REST API.

Python

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigquery.connection.v1.DeleteConnectionRequest;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import java.io.IOException;

// Sample to delete a connection
public class DeleteConnection {

  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 connectionName = "MY_CONNECTION_NAME";
    deleteConnection(projectId, location, connectionName);
  }

  static void deleteConnection(String projectId, String location, String connectionName)
      throws IOException {
    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      ConnectionName name = ConnectionName.of(projectId, location, connectionName);
      DeleteConnectionRequest request =
          DeleteConnectionRequest.newBuilder().setName(name.toString()).build();
      client.deleteConnection(request);
      System.out.println("Connection deleted successfully");
    }
  }
}

Verbindungen verwalten

Hinweise

Erforderliche Rollen

Erforderliche Berechtigungen

Alle Verbindungen auflisten

Console

bq

API

Python

Node.js

Java

Verbindungsdetails ansehen

Console

bq

API

Python

Node.js

Java

IAM-Richtlinie (Identity and Access Management) für eine Verbindung abrufen

Python

Node.js

Verbindung für Nutzer freigeben

Console

bq

API

Java

Verbindung bearbeiten

Console

bq

API

Python

Node.js

Java

Verbindung löschen

Console

bq

API

Python

Node.js

Java

Nächste Schritte