Conecte-se ao Amazon S3

Como administrador do BigQuery, é possível criar uma conexão para permitir que analistas de dados acessem dados armazenados em buckets do Amazon Simple Storage Service (Amazon S3).

O BigQuery Omni acessa os dados do Amazon S3 por meio de conexões. Cada conexão tem um usuário único do Identity and Access Management (IAM) da Amazon Web Services (AWS). Você concede permissões aos usuários por meio de papéis do IAM da AWS. As políticas nos papéis do IAM da AWS determinam quais dados o BigQuery pode acessar para cada conexão.

As conexões são necessárias para consultar o Amazon S3data e exportar os resultados da consulta do BigQuery para o bucket do Amazon S3.

Antes de começar

Certifique-se criar os seguintes recursos:

• Um projeto do Google Cloud com a API BigQuery Connection ativada.
• Se você estiver no modelo de preços baseados em capacidade, verifique se ativou a API BigQuery Reservation no projeto. Para informações sobre preços, consulte Preços do BigQuery Omni.
• Uma conta da AWS com permissões para modificar as políticas do IAM na AWS.

Funções exigidas

Para conseguir as permissões necessárias para criar uma conexão e acessar os dados do Amazon S3, peça ao administrador para conceder a você o papel do IAM de Administrador de conexão do BigQuery (roles/bigquery.connectionAdmin) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias por meio de papéis personalizados ou de outros papéis predefinidos.

Criar uma política de IAM da AWS para o BigQuery

Siga as práticas recomendadas de segurança para o Amazon S3. Portanto, recomendamos que você faça o seguinte:

• Configure uma política da AWS que impeça o acesso ao bucket do Amazon S3 por HTTP.
• Configure uma política da AWS que impeça o acesso público ao bucket do Amazon S3.
• Usar a criptografia do lado do servidor no Amazon S3.
• Limite o mínimo de permissões concedidas à Conta do Google.
• Configure o CloudTrails e ative eventos de dados do Amazon S3.

Para criar uma política de IAM da AWS, use o Console da AWS ou o Terraform:

Console da AWS

1. Acesse o console do Identity and Access Management (IAM) da AWS. Verifique se você está na conta proprietária do bucket do Amazon S3 que você quer acessar.
2. Selecione Políticas > Criar política (será aberto em uma nova guia).

3. Clique em JSON e cole o seguinte no 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/*"
         ]
       }
    ]
   }

   Substitua:

   • BUCKET_NAME: o bucket do Amazon S3 que você quer que o BigQuery acesse.
   Observação: se você receber um erro depois de colar o JSON no editor, formate o texto JSON usando um editor de JSON.
   .

4. No campo Nome, digite um nome de política, como bq_omni_read_only.

5. Clique em Criar política.

A política será criada com um Amazon Resource Name (ARN) no seguinte formato:

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

Substitua:

• AWS_ACCOUNT_ID: o número do ID do usuário do IAM da AWS da conexão.
• POLICY_NAME: o nome da política que você escolheu.

Terraform

Adicione o seguinte à configuração do Terraform para anexar uma política a um recurso do 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
  }

Substitua BUCKET_NAME pelo bucket do Amazon S3 que você quer que o BigQuery acesse.

Caso precise exportar dados para um bucket do Amazon S3, também precisará da permissão s3:PutObject. Para separar o controle de acesso, recomendamos que você crie outra conexão com um papel do IAM da AWS e conceda o acesso somente de gravação. Para um controle de acesso mais granular, também é possível limitar o acesso de um papel a um caminho específico do bucket.

Criar um papel do IAM da AWS para o BigQuery

Em seguida, crie um papel que permita o acesso ao bucket da Amazon S3 no BigQuery. Esse papel usa a política criada na seção anterior.

Para criar um papel do IAM da AWS, use o Console da AWS ou o Terraform:

Console da AWS

1. Acesse o console do IAM da AWS. Verifique se você está na conta proprietária do bucket do Amazon S3 que você quer acessar.
2. Selecione Papéis > Criar papel.
3. Em Selecionar tipo de entidade confiável, escolha Identidade da Web.
4. Em Identity Provider, selecione Google.
5. Em Público, insira 00000 como um valor do marcador. Você substituirá o valor posteriormente.
6. Clique em Next: Permissions.
7. Para conceder o papel do acesso aos dados da Amazon S3, anexe uma política do IAM ao papel. Pesquise a política criada na seção anterior e clique no botão de alternância.
8. Clique em Avançar: tags.
9. Clique em PRÓXIMO: REVISAR. Digite um nome para o papel, como BQ_Read_Only.
10. Clique em Criar papel.

Terraform

Adicione abaixo à configuração do Terraform para criar um papel do IAM e atribuir a política ao papel criado:

  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
  }

Criar conexões

Para se conectar ao seu bucket do Amazon S3, use o console do Google Cloud, a ferramenta de linha de comando bq ou a biblioteca de cliente:

Console

Importante: crie sua conexão no projeto do Google Cloud que contém a instância da Amazon S3 que você quer consultar.

1. Acessar a página do BigQuery.

   Ir para o BigQuery

2. No menu Adicionar dados, selecione Fonte de dados externa.

3. No painel Fonte de dados externa, insira as seguintes informações:

   • Em Tipo de conexão, selecione BigLake on AWS (via BigQuery Omni).
   • Em ID da conexão, insira um identificador para o recurso de conexão. Você pode usar letras, números, traços e sublinhados.
   • Selecione o local em que você quer criar a conexão.
   • (Opcional) Em Nome amigável, insira um nome fácil de usar para a conexão, como My connection resource. O nome intuitivo pode ser qualquer valor que ajude você a identificar o recurso de conexão se precisar modificá-lo mais tarde.
   • (Opcional) Em Descrição, insira uma descrição para este recurso de conexão.
   • Em ID do papel da AWS, insira o ID completo do papel do IAM que você criou neste formato: arn:aws:iam::AWS_ACCOUNT_ID:role/ROLE_NAME.

4. Clique em Criar conexão.

5. Clique em Ir para conexão.

6. No painel Informações de conexão, copie a identidade do Google do BigQuery. Esse é um princípio do Google específico para cada conexão. Exemplo:

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

Substitua:

• AWS_LOCATION: um local do Amazon S3 no Google Cloud
• AWS_ACCOUNT: seu ID da conta da AWS.
• IAM_ROLE_NAME: o papel que permite o acesso ao bucket do Amazon S3 no BigQuery. Use o valor do argumento name do recurso aws_iam_role em Criar um papel do IAM da AWS para o 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

Substitua:

• AWS_ACCOUNT_ID: o número do ID do usuário do IAM da AWS da conexão
• ROLE_NAME: o nome da política de papéis que você escolheu
• AWS_LOCATION: um local do Amazon S3 no Google Cloud
• CONNECTION_ID: o ID que você fornece a esse recurso de conexão.

A linha de comando mostra a seguinte saída:

  Identity: IDENTITY_ID

A saída contém o seguinte:

• IDENTITY_ID: uma principal do Google que o Google Cloud controla que é específica para cada conexão.

Anote o valor de IDENTITY_ID.

Observação: para modificar o projeto padrão, use o parâmetro --project_id=PROJECT_ID. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

Adicionar um relacionamento de confiança ao papel da AWS

O BigQuery Omni oferece dois métodos para acessar os dados com segurança do Amazon S3. Conceda à conta de serviço do Google Cloud acesso ao papel da AWS ou, se a conta da AWS tiver um provedor de identidade personalizado para accounts.google.com, adicione a conta de serviço do Google Cloud como um público-alvo para o provedor:

• Adicione a política de confiança ao papel da AWS.
• Configure um provedor de identidade personalizado da AWS.

Adicionar uma política de confiança ao papel da AWS

A relação de confiança permite que a conexão assuma o papel e acesse os dados do Amazon S3, conforme especificado na política de papéis.

Para adicionar uma relação de confiança, use o Console da AWS ou o Terraform:

Console da AWS

1. Acesse o console do IAM da AWS. Verifique se você está na conta proprietária do bucket do Amazon S3 que você quer acessar.
2. Selecione Papéis.
3. Selecione o ROLE_NAME que você criou.

4. Clique em Editar e faça o seguinte:

   1. Defina a Duração máxima da sessão como 12 horas. Como cada consulta pode ser executada por até seis horas, essa duração permite uma nova tentativa adicional. Aumentar a duração da sessão para além de 12 horas não permitirá novas tentativas adicionais. Para mais informações, consulte o limite de tempo de execução de consulta de várias instruções.

      

   2. Clique em Salvar.

5. Selecione Relacionamentos de confiança e clique em Editar relação de confiança. Substitua o conteúdo da política pelo seguinte:

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

   Substitua IDENTITY_ID pelo valor da identidade do Google BigQuery, que pode ser encontrado na página do console da AWS para a conexão criada.

6. Clique em Atualizar política de confiança.

Terraform

Atualize o recurso aws_iam_role na configuração do Terraform para adicionar uma relação de confiança:

    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
    }

Observação: pode haver um atraso na propagação da atribuição de papéis no AWS. Se você receber um erro desse tipo ao usar uma nova conexão, aguardar e tentar novamente mais tarde pode resolver o problema.

A conexão está pronta para ser usada.

Configurar um provedor de identidade personalizado da AWS

Caso sua conta da AWS tenha um provedor de identidade personalizado para accounts.google.com, adicione o IDENTITY_ID como um público-alvo para o fornecedor. Para isso, você pode fazer o seguinte:

1. No console da AWS, acesse a página IAM.

   Acessar o IAM da AWS

2. Acesse IAM > Provedores de identidade.

3. Selecione o provedor de identidade de accounts.google.com.

4. Clique em Adicionar público e adicione IDENTITY_ID como público.

A conexão está pronta para ser usada.

Compartilhar conexões com os usuários

Você pode conceder os seguintes papéis para permitir que os usuários consultem dados e gerenciem conexões:

• roles/bigquery.connectionUser: permite aos usuários usar conexões para se conectar a fontes de dados externas e executar consultas nelas.

• roles/bigquery.connectionAdmin: permite que os usuários gerenciem conexões.

Para mais informações sobre os papéis e as permissões do IAM no BigQuery, consulte Papéis e permissões predefinidos.

Selecione uma das seguintes opções:

Console

1. Acessar a página do BigQuery.

   Ir para o BigQuery

   As conexões são listadas no projeto, em um grupo chamado Conexões externas.

2. No painel Explorer, clique no nome do seu projeto > Conexões externas > conexão.

3. No painel Detalhes, clique em Compartilhar para compartilhar uma conexão. Em seguida, siga estas etapas:

   1. Na caixa de diálogo Permissões de conexão, compartilhe a conexão com outros principais adicionando ou editando principais.

   2. Clique em Salvar.

bq

Não é possível compartilhar uma conexão com a ferramenta de linha de comando bq. Para compartilhar um recurso de conexão, use o console do Google Cloud ou o método da API BigQuery Connections para compartilhar uma conexão.

API

Consulte o método projects.locations.connections.setIAM na seção de referência da API REST BigQuery Connections e forneça uma instância do recurso policy.

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

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

A seguir

• Saiba sobre diferentes tipos de conexão.
• Saiba mais sobre como gerenciar conexões.
• Saiba mais sobre o BigQuery Omni.
• Use o laboratório do BigQuery Omni com a AWS
• Saiba mais sobre as tabelas BigLake.
• Saiba como consultar dados do Amazon S3.
• Saiba como exportar os resultados da consulta para um bucket do Amazon S3.