Connettiti ad Amazon S3

In qualità di amministratore BigQuery, puoi creare una connessione per consentire agli analisti dei dati di accedere ai dati archiviati nei bucket Amazon Simple Storage Service (Amazon S3).

BigQuery Omni accede ai dati di Amazon S3 tramite connessioni. Ogni connessione ha un proprio utente Identity and Access Management (IAM) di Amazon Web Services (AWS) univoco. Concedi le autorizzazioni agli utenti tramite i ruoli AWS IAM. I criteri all'interno dei ruoli AWS IAM determinano a quali dati può accedere BigQuery per ogni connessione.

Le connessioni sono necessarie per eseguire query sui dati di Amazon S3 e esportare i risultati delle query da BigQuery al tuo bucket Amazon S3.

Prima di iniziare

Assicurati di aver creato le seguenti risorse:

• Un progetto Google Cloud con l'API BigQuery Connection attivata.
• Se utilizzi il modello di determinazione dei prezzi in base alla capacità, assicurati di aver attivato l'API BigQuery Reservation per il tuo progetto. Per informazioni sui prezzi, consulta la pagina Prezzi di BigQuery Omni.
• Un account AWS con le autorizzazioni per modificare i criteri 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 Amministratore connessione BigQuery (roles/bigquery.connectionAdmin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire 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 un criterio AWS che impedisca l'accesso al bucket Amazon S3 tramite HTTP.
• Configura un criterio 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 di Amazon S3.

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

Console AWS

1. Vai alla console AWS Identity and Access Management (IAM). Assicurati di accedere all'account proprietario del bucket Amazon S3 a cui vuoi accedere.
2. Seleziona Criteri > Crea criterio (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 dell'accesso all'esportazione, ti consigliamo di creare un altro collegamento con un ruolo IAM AWS separato e di concedere al ruolo l'accesso di 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 il criterio, ad esempio bq_omni_read_only.

5. Fai clic su Crea criterio.

Il criterio viene creato con un nome della risorsa Amazon (ARN) nel seguente formato:

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

Sostituisci quanto segue:

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

Terraform

Aggiungi quanto segue alla configurazione Terraform per associare un criterio 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 dell'accesso all'esportazione, ti consigliamo di creare un altro collegamento con un ruolo IAM AWS separato e di concedere al ruolo l'accesso di sola scrittura. Per controllo dell'accesso più granulare, puoi anche limitare l'accesso di un ruolo a un percorso specifico del bucket.

Creare un ruolo AWS IAM per BigQuery

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

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

Console AWS

1. Vai alla console AWS IAM. Assicurati di accedere all'account proprietario del bucket Amazon S3 a cui vuoi accedere.
2. Seleziona Ruoli > Crea ruolo.
3. Per Seleziona il tipo di entità attendibile, seleziona Identità web.
4. In Provider di identità, seleziona Google.
5. In Segmento di pubblico, inserisci 00000 come valore segnaposto. Sostituirai il valore in un secondo momento.
6. Fai clic su Successivo: autorizzazioni.
7. Per concedere al ruolo l'accesso ai dati di Amazon S3, associa un criterio IAM al ruolo. Cerca il criterio che hai creato nella sezione precedente e fai clic sull'opzione per attivare/disattivare.
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.

Terraform

Aggiungi quanto segue alla configurazione di Terraform per creare un ruolo IAM e assegna il criterio 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
  }

Creare connessioni

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

Console

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

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel menu Aggiungi dati, seleziona Origine dati esterna.

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

   • Per 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.
   • Seleziona la posizione in cui vuoi creare la connessione.
   • (Facoltativo) In Nome visualizzato, inserisci un nome intuitivo per la connessione, ad esempio My connection resource. Il nome visualizzato 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.

4. Fai clic su Crea connessione.

5. Fai clic su Vai alla connessione.

6. Nel riquadro Informazioni sulla connessione, copia l'identità Google BigQuery. Si tratta di un principale Google specifico per ogni collegamento. Esempio:

     BigQuery Google identity: 000000000000000000000
     

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: il tuo ID 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 Creare 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 IAM AWS della connessione
• ROLE_NAME: il nome del criterio del ruolo scelto
• AWS_LOCATION: una posizione Amazon S3 in Google Cloud
• CONNECTION_ID: l'ID assegnato a questa risorsa di connessione.

La riga di comando mostra il seguente output:

  Identity: IDENTITY_ID

L'output contiene quanto segue:

• IDENTITY_ID: un principale Google controllato da Google Cloud specifico per ogni connessione.

Prendi nota del valore IDENTITY_ID.

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

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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());
    }
  }
}

Aggiungere una relazione di attendibilità al ruolo AWS

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

• Aggiungi il criterio di attendibilità al ruolo AWS.
• Configura un provider di identità AWS personalizzato.

Aggiungi un criterio di attendibilità al ruolo AWS

La relazione di attendibilità consente alla connessione di assumere il ruolo e di accedere ai dati di Amazon S3 come specificato nel criterio dei ruoli.

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

Console AWS

1. Vai alla console AWS IAM. Assicurati di accedere all'account proprietario del bucket Amazon S3 a cui vuoi accedere.
2. Seleziona Ruoli.
3. Seleziona il ROLE_NAME che hai creato.

4. Fai clic su Modifica e 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 ulteriore tentativo. Se aumenti la durata della sessione oltre le 12 ore, non potrai effettuare ulteriori tentativi. Per ulteriori informazioni, consulta il limite di tempo di esecuzione delle query/query con più istruzioni.

      

   2. Fai clic su Salva modifiche.

5. Seleziona Relazioni di attendibilità e fai clic su Modifica relazione di attendibilità. Sostituisci i contenuti delle norme 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 pagina della console AWS per la connessione che hai creato.

6. Fai clic su Aggiorna criterio attendibilità.

Terraform

Aggiorna la risorsa aws_iam_role nella configurazione Terraform per aggiungere un rapporto di attendibilità:

    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 dell'assegnazione dei ruoli in AWS. Se ricevi un errore di questo tipo quando utilizzi una nuova connessione, attendere e riprovare in un secondo momento potrebbe risolvere il problema.

La connessione è ora pronta per l'uso.

Configurare 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 segmento di pubblico al provider. Per farlo:

1. Nella console AWS, vai alla pagina IAM.

   Vai ad AWS IAM

2. Vai a IAM > Identity Providers (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.

Condividere 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 collegarsi a origini dati esterne ed eseguire query su di esse.

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

Per ulteriori informazioni 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 esterne.

2. Nel riquadro Explorer, fai clic sul nome del progetto > Connessioni esterne > Connessione.

3. 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.

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 Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 di una query in un bucket Amazon S3.