Connessione ad Amazon S3

Una connessione ad Amazon Simple Storage Service (Amazon S3) in BigQuery consente agli analisti di dati di eseguire query sui dati archiviati nei bucket Amazon S3 e di esportare i risultati delle query da BigQuery ad Amazon S3. Puoi creare una connessione in modo che BigQuery Omni possa accedere in modo sicuro ai tuoi dati Amazon S3.

Ogni connessione ha un utente Amazon Web Services (AWS) Identity and Access Management (IAM) univoco. Concedi le autorizzazioni a quell'utente tramite i ruoli AWS IAM, le cui policy determinano a quali dati BigQuery può accedere per ogni connessione.

Prima di iniziare

Assicurati di aver creato le seguenti risorse:

• Un progettoGoogle Cloud con l'API BigQuery Connection abilitata.
• Se utilizzi il modello di prezzi basato sulla capacità, assicurati di aver abilitato l'API BigQuery Reservation per il tuo progetto. Per informazioni sui prezzi, consulta Prezzi di BigQuery Omni.
• Un account AWS con le autorizzazioni per modificare le policy IAM in AWS.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare una connessione per accedere ai dati di Amazon S3, chiedi all'amministratore di concederti il ruolo IAM BigQuery Connection Admin (roles/bigquery.connectionAdmin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Crea un criterio AWS IAM per BigQuery

Assicurati di seguire le best practice per la sicurezza di Amazon S3. Ti consigliamo di procedere come segue:

• Configura una policy AWS che impedisca l'accesso al tuo bucket Amazon S3 tramite HTTP.
• Configura una policy AWS che impedisca l'accesso pubblico al tuo bucket Amazon S3.
• Utilizza la crittografia lato server di Amazon S3.
• Limita le autorizzazioni concesse all'Account Google al minimo richiesto.
• Configura CloudTrail e attiva gli eventi di dati Amazon S3.

Per creare una policy IAM AWS, utilizza la console AWS o Terraform:

Console AWS

1. Vai alla console AWS IAM. Assicurati di aver eseguito l'accesso all'account proprietario del bucket Amazon S3 a cui vuoi accedere.

   Vai alla console AWS IAM

2. Seleziona Policies (Policy) > Create policy (Crea policy) (si apre in una nuova scheda).

3. Fai clic su JSON e incolla quanto segue nell'editor:

   {
    "Version": "2012-10-17",
    "Statement": [
       {
        "Effect": "Allow",
        "Action": [
          "s3:ListBucket"
        ],
        "Resource": [
          "arn:aws:s3:::BUCKET_NAME"
         ]
       },
      {
        "Effect": "Allow",
        "Action": [
          "s3:GetObject",
          EXPORT_PERM
        ],
        "Resource": [
          "arn:aws:s3:::BUCKET_NAME",
           "arn:aws:s3:::BUCKET_NAME/*"
         ]
       }
    ]
   }

   Sostituisci quanto segue:

   • BUCKET_NAME: il bucket Amazon S3 a cui vuoi che BigQuery acceda.
   • EXPORT_PERM (facoltativo): autorizzazione aggiuntiva se vuoi esportare i dati in un bucket Amazon S3. Sostituisci con "s3:PutObject"
     • Per separare controllo dell'accesso per l'esportazione, ti consigliamo di creare un'altra connessione con un ruolo IAM AWS separato e di concedere al ruolo l'accesso in sola scrittura. Per controllo dell'accesso più granulare, puoi anche limitare l'accesso di un ruolo a un percorso specifico del bucket.
   Nota: se ricevi un errore dopo aver incollato il JSON nell'editor, formatta il testo JSON utilizzando un editor JSON.

4. Nel campo Nome, inserisci un nome per la policy, ad esempio bq_omni_read_only.

5. Fai clic su Crea policy.

La policy viene creata con un Amazon Resource Name (ARN) nel seguente formato:

arn:aws:iam::AWS_ACCOUNT_ID:policy/POLICY_NAME

Sostituisci quanto segue:

• AWS_ACCOUNT_ID: il numero ID dell'utente AWS IAM della connessione.
• POLICY_NAME: il nome della policy che hai scelto.

AWS CLI

Per creare una policy IAM AWS, utilizza il comando aws iam create-policy:

  aws iam create-policy \
   --policy-name POLICY_NAME \
   --policy-document '{
     "Version": "2012-10-17",
     "Statement": [
        {
         "Effect": "Allow",
         "Action": [
           "s3:ListBucket"
         ],
         "Resource": [
           "arn:aws:s3:::BUCKET_NAME"
          ]
        },
       {
         "Effect": "Allow",
         "Action": [
           "s3:GetObject",
           EXPORT_PERM
         ],
         "Resource": [
           "arn:aws:s3:::BUCKET_NAME",
            "arn:aws:s3:::BUCKET_NAME/*"
          ]
        }
     ]
    }'

Sostituisci quanto segue:

• POLICY_NAME: il nome della policy che stai creando.
• BUCKET_NAME: il bucket Amazon S3 a cui vuoi che BigQuery acceda.
• EXPORT_PERM (facoltativo): autorizzazione aggiuntiva se vuoi esportare i dati in un bucket Amazon S3. Sostituisci con "s3:PutObject"
  • Per separare controllo dell'accesso per l'esportazione, ti consigliamo di creare un'altra connessione con un ruolo IAM AWS separato e di concedere al ruolo l'accesso in sola scrittura. Per controllo dell'accesso più granulare, puoi anche limitare l'accesso di un ruolo a un percorso specifico del bucket.

La policy viene creata con un Amazon Resource Name (ARN) nel seguente formato:

arn:aws:iam::AWS_ACCOUNT_ID:policy/POLICY_NAME

Sostituisci quanto segue:

• AWS_ACCOUNT_ID: il numero ID dell'utente AWS IAM della connessione.
• POLICY_NAME: il nome della policy che hai scelto.

Terraform

Aggiungi quanto segue alla configurazione di Terraform per collegare una policy a una risorsa bucket Amazon S3:

  resource "aws_iam_policy" "bigquery-omni-connection-policy" {
    name = "bigquery-omni-connection-policy"

    policy = <<-EOF
            {
              "Version": "2012-10-17",
              "Statement": [
                  {
                      "Sid": "BucketLevelAccess",
                      "Effect": "Allow",
                      "Action": ["s3:ListBucket"],
                      "Resource": ["arn:aws:s3:::BUCKET_NAME"]
                  },
                  {
                      "Sid": "ObjectLevelAccess",
                      "Effect": "Allow",
                      "Action": ["s3:GetObject",EXPORT_PERM],
                      "Resource": [
                          "arn:aws:s3:::BUCKET_NAME",
                          "arn:aws:s3:::BUCKET_NAME/*"
                          ]
                  }
              ]
            }
            EOF
  }

Sostituisci quanto segue:

• BUCKET_NAME: il bucket Amazon S3 a cui vuoi che BigQuery acceda.
• EXPORT_PERM (facoltativo): autorizzazione aggiuntiva se vuoi esportare i dati in un bucket Amazon S3. Sostituisci con "s3:PutObject"
  • Per separare controllo dell'accesso per l'esportazione, ti consigliamo di creare un'altra connessione con un ruolo AWS IAM separato e di concedere al ruolo l'accesso in sola scrittura. Per un controllo degli accessi più granulare, puoi anche limitare l'accesso di un ruolo a un percorso specifico del bucket.

Crea un ruolo AWS IAM per BigQuery

Successivamente, crea un ruolo che consenta l'accesso al bucket Amazon S3 da BigQuery. Questo ruolo utilizza la policy che hai creato nella sezione precedente.

Per creare un ruolo IAM AWS, utilizza la console AWS o Terraform:

Console AWS

1. Vai alla console AWS IAM. Assicurati di aver eseguito l'accesso all'account proprietario del bucket Amazon S3 a cui vuoi accedere.

   Vai alla console AWS IAM

2. Seleziona Ruoli > Crea ruolo.

3. In Select type of trusted entity (Seleziona il tipo di entità attendibile), seleziona Web Identity (Identità web).

4. In Provider di identità, seleziona Google.

5. In Pubblico, inserisci 00000 come valore segnaposto. Sostituirai il valore in un secondo momento.

6. Fai clic su Avanti: Autorizzazioni.

7. Per concedere al ruolo l'accesso ai tuoi dati Amazon S3, collega una policy IAM al ruolo. Cerca la policy che hai creato nella sezione precedente e fai clic sul pulsante di attivazione/disattivazione.

8. Fai clic su Avanti: Tag.

9. Fai clic su Successivo: esamina. Inserisci un nome per il ruolo, ad esempio BQ_Read_Only.

10. Fai clic su Crea ruolo.

AWS CLI

Utilizza il seguente comando per creare un ruolo IAM e assegnare la policy al ruolo creato:

  aws iam create-role \
   --role-name bigquery-omni-connection \
   --max-session-duration 43200 \
   --assume-role-policy-document '{
     "Version": "2012-10-17",
     "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Federated": "accounts.google.com"
            },
            "Action": "sts:AssumeRoleWithWebIdentity",
            "Condition": {
                "StringEquals": {
                    "accounts.google.com:sub": "00000"
                }
            }
        }
    ]
}'

Terraform

Aggiungi quanto segue alla configurazione Terraform per creare un ruolo IAM e assegnare la policy al ruolo creato:

  resource "aws_iam_role" "bigquery-omni-connection-role" {
    name                 = "bigquery-omni-connection"
    max_session_duration = 43200

    assume_role_policy = <<-EOF
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": {
            "Federated": "accounts.google.com"
          },
          "Action": "sts:AssumeRoleWithWebIdentity",
          "Condition": {
            "StringEquals": {
              "accounts.google.com:sub": "00000"
            }
          }
        }
      ]
    }
    EOF
  }

  resource "aws_iam_role_policy_attachment" "bigquery-omni-connection-role-attach" {
    role       = aws_iam_role.bigquery-omni-connection-role.name
    policy_arn = aws_iam_policy.bigquery-omni-connection-policy.arn
  }

  output "bigquery_omni_role" {
    value = aws_iam_role.bigquery-omni-connection-role.arn
  }

Quindi, collega la policy al ruolo:

  aws iam attach-role-policy \
    --role-name bigquery-omni-connection \
    --policy-arn arn:aws:iam::AWS_ACCOUNT_ID:policy/POLICY_NAME

Sostituisci quanto segue:

• AWS_ACCOUNT_ID: il numero ID dell'utente AWS IAM della connessione.
• POLICY_NAME: il nome della policy che hai scelto.

Crea connessioni

Per connetterti al tuo bucket Amazon S3, utilizza la consoleGoogle Cloud , lo strumento a riga di comando bq o la libreria client:

Console

Punto chiave: crea la connessione nel progetto Google Cloud che contiene l'istanza Amazon S3 su cui vuoi eseguire query.

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro Explorer, fai clic su Aggiungi dati.

   Si apre la finestra di dialogo Aggiungi dati.

3. Nel riquadro Filtra per, nella sezione Tipo di origine dati, seleziona Storage/Data Lake.

   In alternativa, nel campo Cerca origini dati, puoi inserire aws o Amazon S3.

4. Nella sezione Origini dati in primo piano, fai clic su Amazon S3.

5. Fai clic sulla scheda della soluzione Amazon S3 Omni: BigQuery Federation.

6. Nel riquadro Origine dati esterna, inserisci le seguenti informazioni:

   • In Tipo di connessione, seleziona BigLake su AWS (tramite BigQuery Omni).
   • In ID connessione, inserisci un identificatore per la risorsa di connessione. Puoi utilizzare lettere, numeri, trattini e trattini bassi.
   • In Regione, seleziona la località in cui vuoi creare la connessione.
   • (Facoltativo) In Nome descrittivo, inserisci un nome facile da usare per la connessione, ad esempio My connection resource. Il nome descrittivo può essere qualsiasi valore che ti aiuti a identificare la risorsa di connessione se devi modificarla in un secondo momento.
   • (Facoltativo) In Descrizione, inserisci una descrizione per questa risorsa di connessione.
   • In ID ruolo AWS, inserisci l'ID ruolo IAM completo che hai creato in questo formato:

     arn:aws:iam::AWS_ACCOUNT_ID:role/ROLE_NAME

7. Fai clic su Crea connessione.

8. Fai clic su Vai alla connessione.

9. Nel riquadro Informazioni sulla connessione, copia l'identità Google BigQuery. Si tratta di un'entità Google specifica per ogni connessione. Esempio:

     BigQuery Google identity: IDENTITY_ID
     

Terraform

  resource "google_bigquery_connection" "connection" {
    connection_id = "bigquery-omni-aws-connection"
    friendly_name = "bigquery-omni-aws-connection"
    description   = "Created by Terraform"

    location      = "AWS_LOCATION"
    aws {
      access_role {
        # This must be constructed as a string instead of referencing the
        # AWS resources directly to avoid a resource dependency cycle
        # in Terraform.
        iam_role_id = "arn:aws:iam::AWS_ACCOUNT:role/IAM_ROLE_NAME"
      }
    }
  }

Sostituisci quanto segue:

• AWS_LOCATION: una posizione Amazon S3 in Google Cloud
• AWS_ACCOUNT: l'ID del tuo account AWS.
• IAM_ROLE_NAME: il ruolo che consente l'accesso al bucket Amazon S3 da BigQuery. Utilizza il valore dell'argomento name della risorsa aws_iam_role in Crea un ruolo AWS IAM per BigQuery.

bq

bq mk --connection --connection_type='AWS' \
--iam_role_id=arn:aws:iam::AWS_ACCOUNT_ID:role/ROLE_NAME \
--location=AWS_LOCATION \
CONNECTION_ID

Sostituisci quanto segue:

• AWS_ACCOUNT_ID: il numero ID dell'utente AWS IAM della connessione
• ROLE_NAME: il nome della policy del ruolo che hai scelto
• AWS_LOCATION: una posizione Amazon S3 in Google Cloud
• CONNECTION_ID: l'ID che assegni a questa risorsa di connessione.

La riga di comando mostra il seguente output:

  Identity: IDENTITY_ID

L'output contiene quanto segue:

• IDENTITY_ID: un'entità Google che Google Cloud controlla l'accesso specifico per ogni connessione.

Prendi nota del valore IDENTITY_ID.

Nota: per eseguire l'override del progetto predefinito, utilizza il parametro --project_id=PROJECT_ID. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.cloud.bigquery.connection.v1.AwsAccessRole;
import com.google.cloud.bigquery.connection.v1.AwsProperties;
import com.google.cloud.bigquery.connection.v1.Connection;
import com.google.cloud.bigquery.connection.v1.CreateConnectionRequest;
import com.google.cloud.bigquery.connection.v1.LocationName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import java.io.IOException;

// Sample to create aws connection
public class CreateAwsConnection {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    // Example of location: aws-us-east-1
    String location = "MY_LOCATION";
    String connectionId = "MY_CONNECTION_ID";
    // Example of role id: arn:aws:iam::accountId:role/myrole
    String iamRoleId = "MY_AWS_ROLE_ID";
    AwsAccessRole role = AwsAccessRole.newBuilder().setIamRoleId(iamRoleId).build();
    AwsProperties awsProperties = AwsProperties.newBuilder().setAccessRole(role).build();
    Connection connection = Connection.newBuilder().setAws(awsProperties).build();
    createAwsConnection(projectId, location, connectionId, connection);
  }

  static void createAwsConnection(
      String projectId, String location, String connectionId, Connection connection)
      throws IOException {
    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      LocationName parent = LocationName.of(projectId, location);
      CreateConnectionRequest request =
          CreateConnectionRequest.newBuilder()
              .setParent(parent.toString())
              .setConnection(connection)
              .setConnectionId(connectionId)
              .build();
      Connection response = client.createConnection(request);
      AwsAccessRole role = response.getAws().getAccessRole();
      System.out.println(
          "Aws connection created successfully : Aws userId :"
              + role.getIamRoleId()
              + " Aws externalId :"
              + role.getIdentity());
    }
  }
}

Aggiungi una relazione di fiducia con il ruolo AWS

BigQuery Omni offre due metodi per accedere in modo sicuro ai dati da Amazon S3. Puoi concedere all'account di servizio Google Cloud l'accesso al tuo ruolo AWS o, se il tuo account AWS ha un provider di identità personalizzato per accounts.google.com, devi aggiungere l'account di servizio Google Cloud come segmento di pubblico al provider:

• Aggiungi la policy di attendibilità al ruolo AWS.
• Configura un provider di identità AWS personalizzato.

Aggiungi una policy di attendibilità al ruolo AWS

La relazione di trust consente alla connessione di assumere il ruolo e accedere ai dati Amazon S3 come specificato nella policy del ruolo.

Per aggiungere una relazione di trust, utilizza la console AWS o Terraform:

Console AWS

1. Vai alla console AWS IAM. Assicurati di aver eseguito l'accesso all'account proprietario del bucket Amazon S3 a cui vuoi accedere.

   Vai alla console AWS IAM

2. Seleziona Ruoli.

3. Seleziona la ROLE_NAME che hai creato.

4. Fai clic su Modifica e poi segui questi passaggi:

   1. Imposta Durata massima della sessione su 12 ore. Poiché ogni query può essere eseguita per un massimo di sei ore, questa durata consente un nuovo tentativo aggiuntivo. L'aumento della durata della sessione oltre le 12 ore non consentirà ulteriori tentativi. Per saperne di più, consulta il limite di tempo di esecuzione delle query/query con più istruzioni.

      

   2. Fai clic su Salva modifiche.

5. Seleziona Relazioni di trust e fai clic su Modifica relazione di trust. Sostituisci i contenuti della policy con quanto segue:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "accounts.google.com"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "accounts.google.com:sub": "IDENTITY_ID"
           }
         }
       }
     ]
   }

   Sostituisci IDENTITY_ID con il valore dell'identità Google BigQuery, che puoi trovare nella console Google Cloud per la connessione che hai creato.

6. Fai clic su Aggiorna policy di attendibilità.

AWS CLI

Per creare una relazione di trust con la connessione BigQuery, utilizza il comando aws iam update-assume-role-policy:

  aws iam update-assume-role-policy \
    --role-name bigquery-omni-connection \
    --policy-document '{
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": {
            "Federated": "accounts.google.com"
          },
          "Action": "sts:AssumeRoleWithWebIdentity",
          "Condition": {
            "StringEquals": {
              "accounts.google.com:sub": "IDENTITY_ID"
            }
          }
        }
      ]
    }'
  aws iam update-assume-role-policy \
    --role-name bigquery-omni-connection \
    --policy-document '{
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": {
            "Federated": "accounts.google.com"
          },
          "Action": "sts:AssumeRoleWithWebIdentity",
          "Condition": {
            "StringEquals": {
              "accounts.google.com:sub": "IDENTITY_ID"
            }
          }
        }
      ]
    }'

Sostituisci quanto segue:

• IDENTITY_ID: il valore dell'identità Google BigQuery, che puoi trovare nella console Google Cloud per la connessione che hai creato.

Terraform

Aggiorna la risorsa aws_iam_role nella configurazione Terraform per aggiungere una relazione di trust:

    resource "aws_iam_role" "bigquery-omni-connection-role" {
      name                 = "bigquery-omni-connection"
      max_session_duration = 43200

      assume_role_policy = <<-EOF
          {
            "Version": "2012-10-17",
            "Statement": [
              {
                "Effect": "Allow",
                "Principal": {
                  "Federated": "accounts.google.com"
                },
                "Action": "sts:AssumeRoleWithWebIdentity",
                "Condition": {
                  "StringEquals": {
                    "accounts.google.com:sub": "${google_bigquery_connection.connection.aws[0].access_role[0].identity}"
                  }
                }`
              }
            ]
          }
          EOF
    }

Nota: potrebbe verificarsi un ritardo nella propagazione per l'assegnazione dei ruoli in AWS. Se ricevi un errore di questo tipo quando utilizzi una nuova connessione, attendere e riprovare più tardi potrebbe risolvere il problema.

La connessione è ora pronta per l'uso.

Configura un provider di identità AWS personalizzato

Se il tuo account AWS ha un provider di identità personalizzato per accounts.google.com, dovrai aggiungere IDENTITY_ID come pubblico al provider. Per farlo:

1. Vai alla console AWS IAM. Assicurati di aver eseguito l'accesso all'account proprietario del bucket Amazon S3 a cui vuoi accedere.

   Vai alla console AWS IAM

2. Vai a IAM > Provider di identità.

3. Seleziona il provider di identità per accounts.google.com.

4. Fai clic su Aggiungi segmento di pubblico e aggiungi IDENTITY_ID come segmento di pubblico.

La connessione è ora pronta per l'uso.

Condividi le connessioni con gli utenti

Puoi concedere i seguenti ruoli per consentire agli utenti di eseguire query sui dati e gestire le connessioni:

• roles/bigquery.connectionUser: consente agli utenti di utilizzare le connessioni per connettersi a origini dati esterne ed eseguire query su di esse.

• roles/bigquery.connectionAdmin: consente agli utenti di gestire le connessioni.

Per saperne di più sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Ruoli e autorizzazioni predefiniti.

Seleziona una delle seguenti opzioni:

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

   Le connessioni sono elencate nel progetto, in un gruppo denominato Connessioni.

2. Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

   

   Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro sinistro per aprirlo.

3. Fai clic sul progetto, poi su Connessioni e seleziona una connessione.

4. Nel riquadro Dettagli, fai clic su Condividi per condividere una connessione. Quindi:

   1. Nella finestra di dialogo Autorizzazioni di connessione, condividi la connessione con altre entità aggiungendole o modificandole.

   2. Fai clic su Salva.

bq

Non puoi condividere una connessione con lo strumento a riga di comando bq. Per condividere una connessione, utilizza la console Google Cloud o il metodo dell'API BigQuery Connections per condividere una connessione.

API

Utilizza il metodo projects.locations.connections.setIAM nella sezione di riferimento dell'API REST BigQuery Connections e fornisci un'istanza della risorsa policy.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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:[e-mail]")
              .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");
    }
  }
}

Passaggi successivi

• Scopri i diversi tipi di connessione.
• Scopri di più sulla gestione delle connessioni.
• Scopri di più su BigQuery Omni.
• Utilizza il lab BigQuery Omni con AWS.
• Scopri di più sulle tabelle BigLake.
• Scopri come eseguire query sui dati di Amazon S3.
• Scopri come esportare i risultati delle query in un bucket Amazon S3.