Connettersi ad Amazon S3

Console AWS

1. Vai alla console AWS IAM. Assicurati di trovarti nell'account proprietario del bucket Amazon S3 a cui vuoi accedere.

   Vai alla console AWS IAM

2. Seleziona Norme > Crea norma (si apre in una nuova scheda).

3. Fai clic su JSON e incolla il seguente codice 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 all'esportazione, ti consigliamo di creare un'altra connessione con un ruolo IAM AWS separato e 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.

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

Interfaccia a riga di comando AWS

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 all'esportazione, ti consigliamo di creare un'altra connessione con un ruolo IAM AWS separato e 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.

Il criterio viene creato 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 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 all'esportazione, ti consigliamo di creare un'altra connessione con un ruolo AWS IAM separato e concedere al ruolo l'accesso di sola scrittura. Per un controllo più granulare dell'accesso, puoi anche limitare l'accesso di un ruolo a un percorso specifico del bucket.

Console AWS

1. Vai alla console AWS IAM. Assicurati di trovarti nell'account proprietario del bucket Amazon S3 a cui vuoi accedere.

   Vai alla console AWS IAM

2. Seleziona Ruoli > Crea ruolo.

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

4. Per 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 Avanti: autorizzazioni.

7. Per concedere al ruolo l'accesso ai dati Amazon S3, associa una policy IAM al ruolo. Cerca il criterio 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.

Interfaccia a riga di comando AWS

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.

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

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

   Si apre la finestra di dialogo Aggiungi dati.

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

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

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

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

6. Nella finestra di dialogo Crea tabella, nel campo ID connessione, seleziona Crea una nuova connessione S3.

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

   • Per Tipo di connessione, seleziona BigLake su AWS (tramite BigQuery Omni).
   • In Connection ID (ID connessione), inserisci un identificatore per la risorsa di connessione. Puoi utilizzare lettere, numeri, trattini e trattini bassi.
   • Per Regione, seleziona la località in cui vuoi creare la connessione.
   • (Facoltativo) In Nome descrittivo, inserisci un nome intuitivo 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.
   • Per ID ruolo AWS, inserisci l'ID ruolo IAM completo che hai creato in questo formato:

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

8. Fai clic su Crea connessione.

9. Fai clic su Vai alla connessione.

10. Nel riquadro Informazioni sulla connessione, copia l'identità Google BigQuery. Si tratta di un principal Google specifico 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 Trusted Cloud by S3NS
• 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 AWS IAM della connessione
• ROLE_NAME: il nome della policy del ruolo che hai scelto
• AWS_LOCATION: una posizione Amazon S3 in Trusted Cloud by S3NS
• 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 Trusted Cloud by S3NS controlla che sia specifica per ogni connessione.

Prendi nota del valore di IDENTITY_ID.

Java

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

Console AWS

1. Vai alla console AWS IAM. Assicurati di trovarti nell'account proprietario del bucket Amazon S3 a cui vuoi accedere.

   Vai alla console AWS IAM

2. Seleziona Ruoli.

3. Seleziona il ROLE_NAME che hai creato.

4. Fai clic su Modifica e poi procedi nel seguente modo:

   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 consentirà ulteriori tentativi. Per ulteriori informazioni, consulta il limite di tempo di esecuzione di query/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:

   {
     "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 Identità Google BigQuery, che puoi trovare nella console Trusted Cloud by S3NS per la connessione che hai creato.

6. Fai clic su Aggiorna criteri di attendibilità.

Interfaccia a riga di comando AWS

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 di identità Google BigQuery, che puoi trovare nella console Trusted Cloud by S3NS 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
    }

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

   Le connessioni sono elencate nel tuo progetto, in un gruppo chiamato 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à aggiungendo o modificando le entità.

   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 Trusted 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

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