Esta página se ha traducido con Cloud Translation API.

Gestionar conexiones

En este documento se describe cómo ver, enumerar, compartir, editar, eliminar y solucionar problemas de una conexión de BigQuery.

Como administrador de BigQuery, puedes crear y gestionar conexiones que se usan para conectarse a servicios y fuentes de datos externas. Los analistas de BigQuery usan estas conexiones para enviar consultas a fuentes de datos externas sin mover ni copiar datos en BigQuery. Puede crear los siguientes tipos de conexiones:

Conexiones de Amazon S3
Conexiones de Apache Spark
Conexiones de almacenamiento de blobs
Conexiones de recursos de Cloud para conectarse a datos de Cloud Storage e implementar funciones remotas
Conexiones de Spanner
Conexiones de Cloud SQL
Conexiones de AlloyDB

Para crear una conexión predeterminada para un proyecto, consulta la descripción general de las conexiones predeterminadas.

Antes de empezar

Asegúrate de que tienes una conexión activa. Las conexiones son específicas de cada tipo y dependen de la fuente de datos externa conectada.
Habilita la API de conexión de BigQuery.

Activar la API
Asegúrate de que puedes ver una lista de cuentas de servicio en tu proyecto. BigQuery crea y usa una cuenta de servicio para conectarse a tu fuente de datos externa. Cuando creas una conexión, se crea una cuenta de servicio de gestión de identidades y accesos (IAM) gestionada porGoogle Cloud en tu nombre. Para ver la cuenta de servicio asociada a una conexión concreta, consulta los detalles de la conexión.

Roles obligatorios

Para obtener los permisos que necesitas para gestionar las conexiones, pide a tu administrador que te conceda los siguientes roles de IAM:

Ver los detalles de la conexión: Usuario de conexión de BigQuery (roles/bigquery.connectionUser) en tu conjunto de datos
Lista de todas las conexiones: Usuario de conexión de BigQuery (roles/bigquery.connectionUser) en tu conjunto de datos
Compartir una conexión: Administrador de conexión de BigQuery (roles/bigquery.connectionAdmin) en tu conexión
Editar una conexión: Administrador de conexión de BigQuery (roles/bigquery.connectionAdmin) en tu conexión
Eliminar una conexión: Administrador de conexión de BigQuery (roles/bigquery.connectionAdmin) en tu conexión

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Para obtener información sobre los roles necesarios para crear y usar una conexión predeterminada, consulta Roles y permisos necesarios.

Estos roles predefinidos contienen los permisos necesarios para realizar las tareas descritas en este documento. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Ver los detalles de la conexión: bigquery.connections.get
Mostrar todas las conexiones: bigquery.connections.list
Editar y eliminar una conexión: bigquery.connections.update
Compartir una conexión: bigquery.connections.setIamPolicy

Mostrar todas las conexiones

Selecciona una de las opciones siguientes:

Consola

Ve a la página BigQuery.

Ir a BigQuery

Las conexiones se muestran en tu proyecto, en un grupo llamado Conexiones.
En el panel de la izquierda, haz clic en Explorador:

Si no ves el panel de la izquierda, haz clic en Ampliar panel de la izquierda para abrirlo.
En el panel Explorador, haz clic en el nombre de tu proyecto y, a continuación, en Conexiones para ver una lista de todas las conexiones.

bq

Introduce el comando bq ls y especifica la marca --connection. De forma opcional, especifica las marcas --project_id y --location para identificar el proyecto y la ubicación de las conexiones que se van a enumerar.

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

Haz los cambios siguientes:

PROJECT_ID: tu ID de proyecto Google Cloud
REGION: la región de conexión

API

Usa el método projects.locations.connections.list de la sección de referencia de la API REST.

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

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

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

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

Ver detalles de conexión

Una vez que hayas creado una conexión, podrás obtener información sobre su configuración. La configuración incluye los valores que proporcionaste al crear la transferencia.

Selecciona una de las opciones siguientes:

Consola

Ve a la página BigQuery.

Ir a BigQuery
Las conexiones se muestran en tu proyecto, en un grupo llamado Conexiones.
En el panel de la izquierda, haz clic en Explorador:
En el panel Explorador, haz clic en el nombre de tu proyecto y, a continuación, en Conexiones para ver una lista de todas las conexiones.
Haz clic en la conexión para ver los detalles.

bq

Introduce el comando bq show y especifica la marca --connection. Opcionalmente, puede calificar el ID de conexión con el ID de proyecto y la región de la conexión.

bq show --connection PROJECT_ID.REGION.CONNECTION_ID

Haz los cambios siguientes:

PROJECT_ID: tu ID de proyecto Google Cloud
REGION: la región de conexión
CONNECTION_ID: el ID de conexión

API

Utilice el método projects.locations.connections.get de la sección de referencia de la 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.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());
    }
  }
}

Obtener la política de gestión de identidades y accesos (IAM) de una conexión

Sigue estos pasos para obtener la política de gestión de identidades y accesos de una conexión:

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

Puede conceder los siguientes roles para permitir que los usuarios consulten datos y gestionen conexiones:

roles/bigquery.connectionUser: permite a los usuarios usar conexiones para conectarse con fuentes de datos externas y ejecutar consultas en ellas.
roles/bigquery.connectionAdmin: permite a los usuarios gestionar las conexiones.

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

Selecciona una de las opciones siguientes:

Consola

Ve a la página BigQuery.

Ir a BigQuery

Las conexiones se muestran en tu proyecto, en un grupo llamado Conexiones.
En el panel de la izquierda, haz clic en Explorador:

Si no ves el panel de la izquierda, haz clic en Ampliar panel de la izquierda para abrirlo.
Haga clic en su proyecto, en Conexiones y, a continuación, seleccione una conexión.
En el panel Detalles, haz clic en Compartir para compartir una conexión. A continuación, sigue estas instrucciones:
1. En el cuadro de diálogo Permisos de conexión, comparte la conexión con otras entidades principales añadiendo o editando entidades principales.
2. Haz clic en Guardar.

bq

No puedes compartir una conexión con la herramienta de línea de comandos bq. Para compartir una conexión, usa la Google Cloud consola o el método de la API Connections de BigQuery.

API

Usa el método projects.locations.connections.setIAM de la sección de referencia de la API REST Connections de BigQuery y proporciona una instancia del recurso 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");
    }
  }
}

Editar una conexión

Una conexión usa las credenciales del usuario que la creó. Si necesitas cambiar el usuario asociado a una conexión, puedes actualizar sus credenciales. Esta opción es útil si el usuario que creó la conexión ya no trabaja en tu organización.

No puedes editar los siguientes elementos de una conexión:

Tipo de conexión
ID de conexión
Ubicación

Selecciona una de las opciones siguientes:

Consola

Ve a la página BigQuery.

Ir a BigQuery

Las conexiones se muestran en tu proyecto, en un grupo llamado Conexiones.
En el panel de la izquierda, haz clic en Explorador:
En el panel Explorador, haz clic en el nombre de tu proyecto y, a continuación, en Conexiones para ver una lista de todas las conexiones.
Para ver los detalles, haz clic en la conexión.
En la sección Información de conexión, haz clic en Editar detalles. A continuación, sigue estas instrucciones:
1. En el cuadro de diálogo Editar conexión, edita los detalles de la conexión, incluidas las credenciales del usuario.
2. Haz clic en Actualizar conexión.

bq

Introduce el comando bq update y proporciona la marca de conexión: --connection. Es obligatorio indicar el connection_id completo.

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

Haz los cambios siguientes:

INSTANCE: la instancia de Cloud SQL
DATABASE: el nombre de la base de datos
USERNAME: el nombre de usuario de tu base de datos de Cloud SQL
PASSWORD: la contraseña de tu base de datos de Cloud SQL
PROJECT: el ID del proyecto Google Cloud
REGION: la región de conexión
CONNECTION_ID: el ID de conexión

Por ejemplo, el siguiente comando actualiza la conexión de un proyecto con el ID federation-test y el ID de conexión 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

Consulta el método projects.locations.connections.patch en la sección de referencia de la API REST y proporciona una instancia de 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.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());
    }
  }
}

Eliminar una conexión

Selecciona una de las opciones siguientes:

Consola

Ve a la página BigQuery.

Ir a BigQuery

Las conexiones se muestran en tu proyecto, en un grupo llamado Conexiones.
En el panel de la izquierda, haz clic en Explorador:
En el panel Explorador, haz clic en el nombre de tu proyecto y, a continuación, en Conexiones para ver una lista de todas las conexiones.
Haz clic en la conexión para ver los detalles.
En el panel de detalles, haga clic en Eliminar para eliminar la conexión.
En el cuadro de diálogo ¿Eliminar conexión?, introduce delete para confirmar la eliminación.
Haz clic en Eliminar.

bq

Introduce el comando bq rm y proporciona la marca de conexión: --connection. Es obligatorio indicar el connection_id completo.

bq rm --connection PROJECT_ID.REGION.CONNECTION_ID

Haz los cambios siguientes:

PROJECT_ID: tu ID de proyecto Google Cloud
REGION: la región de conexión
CONNECTION_ID: el ID de conexión

API

Consulta el método projects.locations.connections.delete en la sección de referencia de la 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.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");
    }
  }
}

Siguientes pasos

Consulta cómo usar las funciones del mando a distancia.
Consulta cómo usar procedimientos almacenados en Spark.

Gestionar conexiones

Antes de empezar

Roles obligatorios

Permisos obligatorios

Mostrar todas las conexiones

Consola

bq

API

Python

Node.js

Java

Ver detalles de conexión

Consola

bq

API

Python

Node.js

Java

Obtener la política de gestión de identidades y accesos (IAM) de una conexión

Python

Node.js

Compartir una conexión con usuarios

Consola

bq

API

Java

Editar una conexión

Consola

bq

API

Python

Node.js

Java

Eliminar una conexión

Consola

bq

API

Python

Node.js

Java

Siguientes pasos