Collegarsi ad Amazon S3

In qualità di amministratore di BigQuery, puoi creare una connessione per consentire agli analisti di 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 univoco gestito da Amazon Web Services (AWS) per Identity and Access Management. Puoi concedere le autorizzazioni agli utenti tramite i ruoli AWS IAM. I criteri all'interno dei ruoli AWS IAM determinano i dati a cui BigQuery può accedere per ogni connessione.

Le connessioni sono necessarie per eseguire query su Amazon S3data ed esportare i risultati delle query da BigQuery nel tuo bucket Amazon S3.

Prima di iniziare

Assicurati di aver creato le seguenti risorse:

• Un progetto Google Cloud con l'API BigQuery Connection abilitata.
• Se utilizzi il modello di prezzi a costo fisso, assicurati di aver attivato l'API BigQuery Reservation per il tuo progetto. Per informazioni sui prezzi, vedi Prezzi di BigQuery Omni.
• Un account AWS.
• Autorizzazione per modificare i criteri IAM in AWS.

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 tuo bucket Amazon S3 tramite HTTP.
• Configura un criterio AWS che impedisce l'accesso pubblico al bucket Amazon S3.
• Utilizza la crittografia lato server di Amazon S3.
• Limita le autorizzazioni concesse all'Account Google al minimo necessario.
• Configura CloudTrails e abilita gli eventi dati di Amazon S3.

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

Console AWS

1. Vai alla console di Identity and Access Management (IAM) di AWS. Assicurati di essere nell'account a cui appartiene il 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"
        ],
        "Resource": [
          "arn:aws:s3:::BUCKET_NAME",
           "arn:aws:s3:::BUCKET_NAME/*"
         ]
       }
    ]
   }
   

   Sostituisci quanto segue:

   • BUCKET_NAME: il bucket Amazon S3 a cui vuoi accedere a BigQuery.
   Nota: se ricevi un errore dopo aver incollato il codice 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 risorsa Amazon (ARN) nel seguente formato:

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

Sostituisci quanto segue:

• AWS_ACCOUNT_ID: numero che identifica l'utente IAM di AWS.
• POLICY_NAME: il nome del criterio che hai scelto.

Terraform

Aggiungi quanto segue alla configurazione Terraform per collegare un criterio a una risorsa del 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"],
                      "Resource": [
                          "arn:aws:s3:::BUCKET_NAME",
                          "arn:aws:s3:::BUCKET_NAME/*"
                          ]
                  }
              ]
            }
            EOF
  }

Sostituisci BUCKET_NAME con il bucket Amazon S3 a cui vuoi accedere a BigQuery.

Se devi esportare i dati in un bucket Amazon S3, devi avere anche l'autorizzazione s3:PutObject. Per separare il controllo dell'accesso, ti consigliamo di creare un'altra connessione con un ruolo AWS IAM separato e concedere l'accesso di sola scrittura al ruolo. Per un controllo dell'accesso 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 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 essere nell'account a cui appartiene il bucket Amazon S3 a cui vuoi accedere.
2. Seleziona Ruoli > Crea ruolo.
3. In Seleziona il tipo di entità attendibile, seleziona Identità web.
4. In Identity Provider (Provider di identità), seleziona Google.
5. In Pubblico, inserisci 00000 come valore segnaposto. Dovrai sostituire il valore in un secondo momento.
6. Fai clic su Successivo: autorizzazioni.
7. Per concedere al ruolo l'accesso ai dati di Amazon S3, collega un criterio IAM al ruolo. Cerca il criterio creato nella sezione precedente e fai clic sul pulsante di attivazione/disattivazione.
8. Fai clic su Successivo: 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 Terraform per creare un ruolo IAM e assegnare 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
  }

Sostituisci PLACE_HOLDER_VALUE con 00000 come valore segnaposto. Dovrai sostituire il valore in un secondo momento.

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 tua connessione nel progetto Cloud che contiene l'istanza di Amazon S3 in cui vuoi eseguire la 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:

   • In Tipo di connessione, seleziona BigLake on AWS (tramite BigQuery Omni).
   • In ID connessione, inserisci un identificatore per la risorsa di connessione. Puoi utilizzare lettere, numeri, trattini e trattini bassi.
   • In Località della connessione, seleziona aws-us-east-1.
   • (Facoltativo) In Nome semplice, inserisci un nome intuitivo per la connessione, ad esempio My connection resource. Il nome intuitivo può essere qualsiasi valore che ti aiuta 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 principio di Google specifico per ogni connessione. Esempio:

     BigQuery Google identity: 000000000000000000000
     

bq

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

Sostituisci quanto segue:

• AWS_ACCOUNT_ID: numero che identifica l'utente IAM di AWS.
• ROLE_NAME: il nome del criterio del ruolo scelto.
• AWS_LOCATION: una località AWS in Google Cloud. Deve essere impostato su aws-us-east-1.
• CONNECTION_NAME: il nome che assegni alla risorsa di connessione.

La riga di comando mostra il seguente output:

  Identity: IDENTITY_ID

L'output contiene quanto segue:

• IDENTITY_ID: un'entità Google controllata da Google Cloud specifica per ogni connessione.

Prendi nota del valore di 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 progetto Cloud.

Java

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

Visualizza su GitHub Feedback

import com.google.cloud.bigquery.connection.v1.AwsAccessRole;
import com.google.cloud.bigquery.connection.v1.AwsCrossAccountRole;
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";
    // Note: As of now location only supports 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";
    AwsCrossAccountRole role = AwsCrossAccountRole.newBuilder().setIamRoleId(iamRoleId).build();
    AwsProperties awsProperties = AwsProperties.newBuilder().setCrossAccountRole(role).build();
    Connection connection = Connection.newBuilder().setAws(awsProperties).build();
    createAwsConnection(projectId, location, connectionId, connection);
  }

  public 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 trust al ruolo AWS

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

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

Aggiungere un criterio di attendibilità al ruolo AWS

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

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

Console AWS

1. Vai alla console AWS IAM. Assicurati di essere nell'account a cui appartiene il 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. L'aumento della durata della sessione oltre le 12 ore non consente ulteriori tentativi. Per ulteriori informazioni, consulta la pagina relativa al limite di tempo di esecuzione della query per query/multi-istruzione.

      

   2. Fai clic su Salva modifiche.

5. Seleziona Relazioni di trust e fai clic su Modifica relazione di trust. Sostituisci i contenuti delle norme con i seguenti criteri:

   {
     "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 l'entità Google controllata da Google Cloud specifica per ogni connessione.

6. Fai clic su Aggiorna criterio di attendibilità.

Terraform

Aggiorna la configurazione Terraform esistente con la seguente 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": "IDENTITY_ID"
                  }
                }
              }
            ]
          }
          EOF
    }

Sostituisci IDENTITY_ID con l'entità Google che Google Cloud controlla specifica per ogni connessione.

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, attendi e riprova più tardi per 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. A questo scopo, puoi:

1. Nella console AWS, vai alla pagina IAM.

   Vai a AWS IAM

2. Vai a IAM > Provider di Identity Platform.

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

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

La connessione è ora pronta per l'uso.

Passaggi successivi

• Scopri di più sui diversi tipi di connessione.
• Scopri di più sulla gestione delle connessioni.
• Scopri di più su BigQuery Omni.
• Utilizza il BigQuery Omni con lab 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.