Configurar a conexão entre nuvens para o AWS Glue

Uma conexão entre nuvens com um Data Catalog do AWS Glue permite consultar tabelas do Apache Iceberg desse catálogo remoto no Google Cloudsem mover arquivos. Para configurar o acesso, configure um papel do IAM da AWS, crie um catálogo federado somente leitura no Lakehouse sem fronteiras e verifique a conectividade. Também é possível rotear o tráfego pelo Interconexão entre nuvens.

Antes de começar

  1. Consulte a visão geral do Lakehouse para entender como ele gerencia o acesso aos dados.
  2. Leia sobre como acessar dados entre nuvens para entender como isso funciona.
  3. Consulte os catálogos compatíveis para verificar as configurações compatíveis.
  4. Analise o modelo de autorização para consultas entre nuvens para entender como funcionam as permissões e a delegação de identidade entre o Google Cloud e o Data Catalog do AWS Glue.
  5. Opcional: se você planeja rotear leituras de consulta ou atualização de metadados em segundo plano pelo Cross-Cloud Interconnect entre sua rede de nuvem privada virtual (VPC) do Google Cloud e sua VPC da AWS, verifique se você tem uma conta ativa da AWS, provisione uma conexão do Interconexão entre nuvens, estabeleça sessões do BGP com o Cloud Router e verifique se você tem as permissões do IAM necessárias nos dois ambientes de nuvem.
  6. Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloudagora, crie uma conta para avaliar o desempenho dos nossos produtos em situações reais. Clientes novos também recebem US $300 em créditos para executar, testar e implantar cargas de trabalho sem custos financeiros.
  7. Verify that billing is enabled for your Google Cloud project.

  8. Enable the BigLake API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  9. Verify that billing is enabled for your Google Cloud project.

  10. Enable the BigLake API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

Funções exigidas

Para receber as permissões necessárias para configurar o acesso entre nuvens, peça ao administrador para conceder a você os seguintes papéis do IAM 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 usando papéis personalizados ou outros papéis predefinidos.

Limitações e considerações

Nesta seção, listamos as limitações e considerações para acessar dados entre nuvens.

  • VPC Service Controls: se o projeto que contém o endpoint do catálogo federado ou o bucket do Cloud Storage estiver dentro de um perímetro de serviço do VPC Service Controls, será necessário configurar regras de saída ou entrada. Para mais informações, consulte Usar o VPC Service Controls com endpoints de catálogo federado.
  • Provedores de nuvem Interconexão entre nuvens Interconnect: o uso do Cross-Cloud Interconnect para rotear o transporte de consultas, a atualização de metadados em segundo plano ou ambos é compatível com a AWS.
  • Roteamento de rede: se você não configurar o Interconexão entre nuvens para transporte de consultas ou atualização de metadados em segundo plano, o tráfego correspondente será roteado pela Internet pública usando TLS. O roteamento de leituras de consulta pela Internet pública pode resultar em taxas de saída mais altas do provedor de nuvem remoto e em um desempenho menos previsível.
  • Somente leitura: os catálogos federados no Lakehouse são visualizações somente leitura do catálogo remoto. A manipulação de recursos (como criar, atualizar ou excluir recursos) não é compatível e precisa ser realizada diretamente no catálogo remoto.
  • Atualização de dados: a flag --refresh-interval de um catálogo federado determina a frequência com que os metadados são sincronizados. O valor precisa ser 0s (desativado) ou pelo menos 300s (5 minutos). A atualização de metadados em segundo plano de um catálogo pode levar mais tempo quanto mais recursos de namespace e tabela houver. Se a atualização anterior for excedida, a atual será ignorada, e a próxima será programada para o intervalo seguinte. As consultas usam os metadados do catálogo sincronizados mais recentemente. Portanto, as alterações feitas no catálogo remoto, como novas tabelas, atualizações de esquema ou dados recém-confirmados, não ficam visíveis no Lakehouse até que a próxima atualização de metadados em segundo plano seja concluída.
  • Armazenamento em cache do Lakehouse: o armazenamento em cache entre nuvens está desativado por padrão (--cross-cloud-cache=disabled). É possível ativar ou desativar o armazenamento em cache no nível do catálogo federado ou da conexão. As chaves de criptografia gerenciadas pelo cliente (CMEK) não são compatíveis com o armazenamento em cache. Os arquivos armazenados em cache são criptografados usando Google-owned and Google-managed encryption keys. Se a restrição da política da organização constraints/gcp.restrictNonCmekServices for aplicada a uma tabela na consulta, o armazenamento em cache será desativado automaticamente para essa consulta. Para mais informações, consulte Armazenamento em cache inteligente.
  • Residência de dados e compliance: quando você ativa o armazenamento em cache entre nuvens em um catálogo ou conexão federada, o Lakehouse armazena temporariamente os arquivos em cache em repouso na região do Google Cloud em que a consulta é executada. Se os arquivos de nuvem remotos estiverem em uma jurisdição diferente, verifique se o armazenamento em cache entre regiões atende aos requisitos de residência de dados e compliance da sua organização antes de ativá-lo.

Fluxo de trabalho geral

Para acessar dados entre nuvens, siga estas etapas gerais:

  • Configurar o Cross-Cloud Interconnect (opcional): configure uma conexão particular entre sua rede VPC do Google Cloud e sua VPC da AWS.
  • Configurar a federação: configure a autenticação criando um papel do IAM com uma política de confiança de marcador de posição na AWS. Em seguida, crie um catálogo federado no Lakehouse e atualize a política de confiança.
  • Verifique a conexão: verifique se o Lakehouse pode se conectar ao catálogo remoto.
  • Consultar dados: execute consultas nos dados federados usando o BigQuery ou o Serviço Gerenciado para Apache Spark com a convenção de nomenclatura PROJECT_ID.CATALOG_NAME.NAMESPACE.TABLE de quatro partes. Se quiser, ative o armazenamento em cache entre nuvens no catálogo federado para ajudar a reduzir os custos de saída entre nuvens e acelerar as consultas subsequentes. Para mais informações, consulte Consultar dados remotos.
  • Configurar permissões e controle de acesso: use o IAM para gerenciar quem pode descobrir e consultar catálogos federados, namespaces e tabelas no Google Cloud. Para mais informações, consulte Gerenciar ACLs de endpoint do catálogo REST do Apache Iceberg.

Configurar o Interconexão entre nuvens (opcional)

Por padrão, as leituras de dados de consulta e a atualização de metadados em segundo plano viajam pela Internet pública usando TLS. Para ajudar a melhorar o isolamento de rede, fornecer latência previsível e reduzir os custos de transferência de dados, é possível configurar o Interconexão entre nuvens entre sua rede VPC doGoogle Cloud e sua rede de nuvem remota (VPC da AWS).

É possível provisionar uma das seguintes opções de implantação do Interconexão entre nuvens:

Estabeleça sessões do BGP entre o Cloud Router em Google Cloud e sua rede de nuvem remota para permitir a troca de rotas.

É possível configurar o roteamento pelo Interconexão entre nuvens para um ou ambos os caminhos de tráfego a seguir, dependendo dos requisitos de segurança e custo:

  • Transporte de consultas (--service-directory-name): encaminha leituras de consulta do BigQuery ou de mecanismos de código aberto para seu armazenamento de objetos remoto (Amazon S3) para ajudar a reduzir as taxas de saída entre nuvens e manter a latência de consulta previsível.
  • Atualização de metadados em segundo plano (--metadata-service-directory-name): encaminha as solicitações de autenticação e atualização de metadados em segundo plano do plano de controle do catálogo do ambiente de execução do Lakehouse para o endpoint privado remoto do AWS Glue Data Catalog. Por exemplo, quando o catálogo remoto restringe o acesso à Internet público.

Se você rotear o transporte de consultas e a atualização de metadados em segundo plano pelo Interconexão entre nuvens, conclua as etapas de endpoint privado, roteamento e serviço do Diretório de Serviços uma vez para o endpoint de armazenamento remoto e uma vez para o endpoint de catálogo remoto. Os dois serviços do Diretório de Serviços precisam residir na mesma região do Google Cloud do catálogo federado e podem compartilhar a mesma sub-rede somente proxy e o mesmo namespace do Diretório de Serviços.

É possível usar um dos dois fluxos de arquitetura para rotear o tráfego do Diretório de Serviços para os endpoints particulares remotos:

  • Roteamento do balanceador de carga: usa um balanceador de carga de rede de proxy interno regional do Google Cloudpara distribuir solicitações entre grupos de endpoints de rede (NEGs) de conectividade híbrida que apontam para os endereços IP de endpoint privado remoto (interfaces de rede elástica da AWS (ENIs)). Esse fluxo é obrigatório para Interconexão entre nuvens por parceiro e recomendado para conexões dedicadas do Interconexão entre nuvens para balanceamento de carga, escalonabilidade e alta disponibilidade.
  • Roteamento de endpoint direto: conecta o Diretório de Serviços diretamente a um único endereço IP de endpoint particular remoto. Esse fluxo funciona apenas com conexões dedicadas Interconexão entre nuvens e não é compatível com o Interconexão entre nuvens por parceiro.

Selecione o fluxo de configuração que corresponde aos requisitos da sua arquitetura:

Balanceador de carga

Para configurar um balanceador de carga de rede de proxy interno regional que distribui solicitações entre os endereços IP do endpoint privado remoto, siga estas etapas:

Configurar endpoints particulares de nuvem remota

Crie endpoints particulares na rede remota e nas sub-redes que se conectam à sua rede VPC do Google Cloud pelo Interconexão entre nuvens e anote os endereços IP particulares atribuídos a cada endpoint:

  • Para transporte de consulta particular (repositório de objetos remoto): crie um endpoint de VPC de interface para o Amazon S3 (com.amazonaws.AWS_REGION.s3) na VPC da AWS e anote os endereços IP particulares das ENIs provisionadas.
  • Para atualização de metadados em segundo plano particular (catálogo remoto): crie um endpoint de VPC de interface para o AWS Glue (com.amazonaws.AWS_REGION.glue) na VPC da AWS e anote os endereços IP particulares das ENIs provisionadas.
  • Regras de segurança de entrada: verifique se os grupos de segurança da AWS anexados aos endpoints particulares permitem o tráfego TCP de entrada na porta 443 dos intervalos CIDR da VPC do Google Cloud . Inclua o intervalo CIDR da sub-rede somente proxy do Google Cloud para permitir verificações de integridade e tráfego encaminhado.

Configurar a rede do Google Cloud

Execute os comandos a seguir para configurar o balanceador de carga interno. Se você estiver roteando o transporte de consultas e a atualização de metadados em segundo plano pelo Interconexão entre nuvens, configure um serviço de back-end, um proxy TCP de destino e uma regra de encaminhamento separados para o endpoint de armazenamento e o endpoint de catálogo. Para configurações avançadas, consulte Configurar um balanceador de carga de rede de proxy interno regional com conectividade híbrida.

gcloud compute networks subnets create PROXY_SUBNET_NAME \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=REGION \
    --network=VPC_NETWORK \
    --range=PROXY_SUBNET_RANGE

Substitua:

  • PROXY_SUBNET_NAME: um nome para a sub-rede somente proxy.
  • PROXY_SUBNET_RANGE: um intervalo CIDR não utilizado na rede VPC (por exemplo, 10.129.0.0/23).
  1. Crie uma verificação de integridade TCP regional:

    gcloud compute health-checks create tcp HEALTH_CHECK_NAME \
        --region=REGION \
        --port=443

    Substitua:

    • HEALTH_CHECK_NAME: um nome para a verificação de integridade.
    • REGION: a região do Google Cloud (por exemplo, us-east4).
  2. Crie grupos de endpoints de rede (NEGs) de conectividade híbrida e adicione endpoints:

    Crie um NEG híbrido (NON_GCP_PRIVATE_IP_PORT) para cada zona:

    gcloud compute network-endpoint-groups create NEG_NAME \
        --network-endpoint-type=NON_GCP_PRIVATE_IP_PORT \
        --zone=ZONE \
        --network=VPC_NETWORK

    Adicione o endereço IP particular da ENI do endpoint remoto ao NEG híbrido:

    gcloud compute network-endpoint-groups update NEG_NAME \
        --zone=ZONE \
        --add-endpoint="ip=REMOTE_ENDPOINT_IP,port=443"

    Substitua:

    • NEG_NAME: um nome para o NEG híbrido.
    • ZONE: a zona do Google Cloud (por exemplo, us-east4-a). Essa zona precisa estar na região do anexo da VLAN do Interconexão entre nuvens.
    • VPC_NETWORK: o nome da sua rede VPC.
    • REMOTE_ENDPOINT_IP: o endereço IP particular do armazenamento remoto ou do endpoint particular do catálogo remoto nessa zona.

    Se o endpoint remoto tiver vários endereços IP particulares distribuídos entre zonas, repita esses comandos para criar NEGs híbridos e adicionar endpoints para cada zona.

  3. Crie e configure o serviço de back-end:

    Crie um serviço de back-end regional com balanceamento de carga gerenciado interno:

    gcloud compute backend-services create BACKEND_SERVICE_NAME \
        --load-balancing-scheme=INTERNAL_MANAGED \
        --protocol=TCP \
        --region=REGION \
        --health-checks=HEALTH_CHECK_NAME \
        --health-checks-region=REGION

    Adicione os NEGs híbridos ao serviço de back-end:

    gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
        --region=REGION \
        --network-endpoint-group=NEG_NAME \
        --network-endpoint-group-zone=ZONE \
        --balancing-mode=CONNECTION \
        --max-connections=MAX_CONNECTIONS

    Substitua:

    • BACKEND_SERVICE_NAME: um nome para o serviço de back-end.
    • NEG_NAME: o nome do NEG híbrido que você criou na etapa anterior.
    • ZONE: a zona do Google Cloud (por exemplo, us-east4-a).
    • MAX_CONNECTIONS: o número máximo de conexões simultâneas para o back-end (por exemplo, 100).

    Repita o comando add-backend para cada NEG híbrido que você criou.

  4. Configure o front-end do balanceador de carga:

    Crie um proxy TCP de destino:

    gcloud compute target-tcp-proxies create TARGET_PROXY_NAME \
        --backend-service=BACKEND_SERVICE_NAME \
        --region=REGION

    Crie uma regra de encaminhamento para rotear o tráfego para o proxy de destino:

    gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
        --load-balancing-scheme=INTERNAL_MANAGED \
        --network=VPC_NETWORK \
        --subnet=VPC_SUBNET \
        --ports=443 \
        --region=REGION \
        --target-tcp-proxy=TARGET_PROXY_NAME \
        --target-tcp-proxy-region=REGION \
        --allow-global-access

    Substitua:

    • TARGET_PROXY_NAME: um nome para o proxy de destino.
    • FORWARDING_RULE_NAME: um nome para a regra de encaminhamento.
    • VPC_SUBNET: o nome da sub-rede VPC.

Depois de criar a regra de encaminhamento para o balanceador de carga, anote o endereço IP interno atribuído a ele. Esta é sua pasta LOAD_BALANCER_IP_ADDRESS.

Configurar o Diretório de Serviços

Registre o endereço IP do balanceador de carga interno no Diretório de Serviços para que o Lakehouse possa descobrir e rotear para ele de forma particular. Se você configurou regras de encaminhamento de balanceador de carga separadas para transporte de consultas e atualização de metadados em segundo plano, crie um serviço e um endpoint separados do Diretório de Serviços para cada endereço IP de regra de encaminhamento.

  1. Crie um namespace para os endpoints particulares remotos:

    gcloud service-directory namespaces create NAMESPACE \
        --project=PROJECT_ID \
        --location=REGION

    Substitua:

    • NAMESPACE: um identificador exclusivo para o namespace.
    • PROJECT_ID: o ID do projeto do Google Cloud .
    • REGION: a região do Google Cloud (por exemplo, us-east4). Ela precisa ser a mesma do catálogo federado.
  2. Crie um serviço no namespace do Diretório de Serviços:

    gcloud service-directory services create SERVICE_NAME \
        --namespace=NAMESPACE \
        --project=PROJECT_ID \
        --location=REGION

    Substitua:

    • SERVICE_NAME: um identificador exclusivo para seu serviço (crie um nome de serviço separado, como METADATA_SERVICE_NAME, ao registrar um endpoint de atualização de metadados em segundo plano).
  3. Crie um endpoint para a regra de encaminhamento do balanceador de carga no serviço:

    gcloud service-directory endpoints create ENDPOINT_NAME \
        --project=PROJECT_ID \
        --namespace=NAMESPACE \
        --service=SERVICE_NAME \
        --location=REGION \
        --network=projects/PROJECT_NUMBER/global/networks/VPC_NETWORK \
        --address=LOAD_BALANCER_IP_ADDRESS \
        --port=443

    Substitua:

    • ENDPOINT_NAME: um identificador exclusivo para o endpoint.
    • PROJECT_NUMBER: o número do projeto do Google Cloud. Use o número do projeto na flag --network.
    • LOAD_BALANCER_IP_ADDRESS: o endereço IP interno da regra de encaminhamento do balanceador de carga.

Endpoint direto

Para configurar o Diretório de Serviços para rotear o tráfego diretamente para um único endereço IP de endpoint privado remoto pelo Interconexão entre nuvens dedicado, siga estas etapas:

  1. Crie o endpoint particular na rede de nuvem remota:

    Anote o endereço IP privado e a porta (443) de cada endpoint e verifique se os grupos de segurança da AWS permitem o tráfego TCP de entrada na porta 443 da sua rede VPC do Google Cloud .

  2. Crie um namespace para os endpoints particulares remotos:

    gcloud service-directory namespaces create NAMESPACE \
        --project=PROJECT_ID \
        --location=REGION

    Substitua:

    • NAMESPACE: um identificador exclusivo para o namespace.
    • PROJECT_ID: o ID do projeto do Google Cloud .
    • REGION: a região do Google Cloud (por exemplo, us-east4). Ela precisa ser a mesma do catálogo federado.
  3. Crie um serviço no namespace do Diretório de Serviços. Se você estiver roteando o transporte de consultas e a atualização de metadados em segundo plano de forma particular, crie um serviço separado para cada endpoint:

    gcloud service-directory services create SERVICE_NAME \
        --namespace=NAMESPACE \
        --project=PROJECT_ID \
        --location=REGION

    Substitua:

    • SERVICE_NAME: um identificador exclusivo para seu serviço (crie um nome de serviço separado, como METADATA_SERVICE_NAME, ao registrar um endpoint de atualização de metadados em segundo plano).
  4. Crie um endpoint no serviço com o endereço IP privado e a porta do endpoint privado remoto:

    gcloud service-directory endpoints create ENDPOINT_NAME \
        --service=SERVICE_NAME \
        --namespace=NAMESPACE \
        --project=PROJECT_ID \
        --location=REGION \
        --address=REMOTE_ENDPOINT_IP \
        --port=REMOTE_ENDPOINT_PORT \
        --network=projects/PROJECT_NUMBER/global/networks/VPC_NETWORK

    Substitua:

    • ENDPOINT_NAME: um identificador exclusivo para o endpoint.
    • REMOTE_ENDPOINT_IP: o endereço IP privado do endpoint privado do armazenamento remoto ou do catálogo remoto (por exemplo, 10.0.1.45).
    • REMOTE_ENDPOINT_PORT: o número da porta do endpoint particular remoto (por exemplo, 443).
    • PROJECT_NUMBER: o número do projeto do Google Cloud. Use o número do projeto na flag --network.
    • VPC_NETWORK: o nome da rede VPC do Google Cloudassociado à sua conexão do Interconexão entre nuvens.

Configurar a federação

Para consultar seus dados, configure um catálogo federado do Lakehouse que se conecte ao Data Catalog remoto do AWS Glue.

Modelo de autorização

O acesso a dados entre nuvens para o AWS Glue Data Catalog é compatível apenas com o modo de identidade de serviço para fornecer autorização no nível do serviço. Ao conceder aos usuários acesso para consultar tabelas federadas, considere os seguintes comportamentos de autorização:

  • Execução de identidade de serviço: quando você consulta uma tabela federada do AWS Glue Data Catalog no BigQuery ou no Serviço Gerenciado para Apache Spark, o Lakehouse faz a autenticação usando a conta de serviço do Google provisionada do catálogo. Essa conta de serviço assume o papel do IAM da AWS configurado usando sts:AssumeRoleWithWebIdentity, e todas as cargas de trabalho são executadas com esse papel.
  • Aplicação de permissões da AWS: a AWS determina o acesso a bancos de dados, tabelas e buckets do Amazon S3 ou buckets de tabela do AWS Glue com base estritamente nas políticas anexadas ao papel do IAM da AWS configurado. Se você usa o AWS Lake Formation, o acesso também depende das permissões do Lake Formation concedidas a esse papel. As permissões individuais no nível do usuário na AWS não se aplicam a consultas do Google Cloud.

No Google Cloud, as tabelas de catálogo federado não são compatíveis com o controle de acesso refinado (FGAC, na sigla em inglês), como a segurança no nível da linha, da coluna ou o mascaramento de dados do BigQuery. Em vez disso, restrinja o acesso concedendo políticas do IAM no nível do catálogo, do namespace ou da tabela, como o papel de Leitor do BigLake (roles/biglake.viewer). Também é possível filtrar namespaces federados com a flag --namespace-filters ou criar catálogos federados separados com papéis do IAM da AWS distintos para escopos de dados isolados.

Crie o papel do IAM da AWS com uma política de confiança de marcador de posição

O Lakehouse provisiona um ID de conta de serviço do Google após a criação do catálogo. Crie o papel do IAM da AWS com uma política de confiança de marcador de posição.

  1. Crie um arquivo chamado trust_policy.json:

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": {
            "Federated": "accounts.google.com"
          },
          "Action": "sts:AssumeRoleWithWebIdentity",
          "Condition": {
            "StringEquals": {
              "accounts.google.com:aud": [
                "PLACEHOLDER_VALUE"
              ],
              "accounts.google.com:sub": [
                "PLACEHOLDER_VALUE"
              ]
            }
          }
        }
      ]
    }
  2. Execute o comando da CLI da AWS para criar o papel com a política de confiança de marcador de posição. Recomendamos definir a duração máxima da sessão como 12 horas (43200 segundos) para evitar que as credenciais expirem durante jobs de longa duração:

    aws iam create-role \
      --role-name AWS_ROLE_NAME \
      --assume-role-policy-document file://trust_policy.json \
      --max-session-duration 43200

    Substitua:

    • AWS_ROLE_NAME: um nome para o papel do IAM da AWS. Por exemplo, lakehouse_glue_federation_role.

Anexar uma política de permissões

Anexe uma política de permissões ao seu papel do IAM que permita que o Lakehouse acesse o Glue Data Catalog e os buckets do S3 da região da AWS. Essa política também concede acesso a buckets de tabela do S3 se você usar a integração de tabelas do S3 do AWS Lake Formation. Se você tiver feito upgrade das permissões de dados padrão do AWS Glue para o modelo do AWS Lake Formation, talvez seja necessário conceder outras permissões no Lake Formation.

  1. Crie um arquivo chamado permissions_policy.json com a seguinte configuração de política.

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "GlueRead",
          "Effect": "Allow",
          "Action": [
            "glue:GetCatalog",
            "glue:GetDatabase",
            "glue:GetDatabases",
            "glue:GetTable",
            "glue:GetTables"
          ],
          "Resource": "arn:aws:glue:AWS_REGION:AWS_ACCOUNT_ID:*"
        },
        {
          "Sid": "S3Read",
          "Effect": "Allow",
          "Action": [
            "s3:ListBucket",
            "s3:GetObject"
          ],
          "Resource": [
            "arn:aws:s3:::*"
          ]
        },
        {
          "Sid": "S3TablesRead",
          "Effect": "Allow",
          "Action": [
            "s3tables:GetTableBucket",
            "s3tables:ListNamespaces",
            "s3tables:GetNamespace",
            "s3tables:ListTables",
            "s3tables:GetTable",
            "s3tables:GetTableMetadataLocation",
            "s3tables:GetTableData"
          ],
          "Resource": [
            "arn:aws:s3tables:AWS_REGION:AWS_ACCOUNT_ID:*"
          ]
        }
      ]
    }

    Se você estiver usando chaves gerenciadas pelo cliente hospedadas no AWS Key Management Service (KMS) para criptografar recursos do AWS Glue, do Amazon S3 ou do Amazon S3 Tables, adicione uma instrução que conceda acesso à chave do KMS para descriptografar os recursos:

    # ...
    {
      "Sid": "GlueS3S3TablesKmsDecrypt",
      "Effect": "Allow",
      "Action": [
          "kms:Decrypt"
      ],
      "Resource": [
          "arn:aws:kms:AWS_REGION:AWS_ACCOUNT_ID:key/key_id_for_glue",
          "arn:aws:kms:AWS_REGION:AWS_ACCOUNT_ID:key/key_id_for_s3",
          "arn:aws:kms:AWS_REGION:AWS_ACCOUNT_ID:key/key_id_for_s3_tables"
      ]
    }
    # ...
  2. Anexe esta política de permissões ao seu papel do IAM:

    aws iam put-role-policy \
      --role-name AWS_ROLE_NAME \
      --policy-name AWS_POLICY_NAME \
      --policy-document file://permissions_policy.json

    Substitua:

    • AWS_ROLE_NAME: o nome do papel do IAM da AWS. Por exemplo, lakehouse_glue_federation_role.
    • AWS_POLICY_NAME: um nome para a política de permissões. Por exemplo, lakehouse_glue_federation_policy.
    • AWS_REGION: a região da AWS em que o catálogo do Glue ou as tabelas do S3 estão. Por exemplo, us-east-1.
    • AWS_ACCOUNT_ID: a string de ID da conta da AWS com 12 dígitos. Por exemplo, 123456789012.

Criar um catálogo federado

Crie o catálogo federado usando o console do Google Cloud ou a Google Cloud CLI.

Para evitar falhas prematuras na atualização de metadados em segundo plano enquanto as relações de confiança da AWS estão sendo propagadas, inicialize o catálogo sem especificar uma programação de atualização (que, por padrão, é 0s).

Console

Para criar um catálogo federado:

  1. No console do Google Cloud , acesse Lakehouse.

    Acessar o Lakehouse

  2. Clique em Criar catálogo.

  3. Clique em Catálogo federado.

    A seção Configuração do catálogo é exibida.

  4. Em Origem do catálogo federado, selecione AWS Glue.

  5. Em Local dos dados, selecione a região do Lakehouse em que você quer criar o catálogo federado. Por exemplo, us-east4. Para minimizar a latência (mesmo na Internet pública), selecione a Google Cloud região mais próxima da sua região da AWS.

  6. Clique em Continuar.

    A seção Detalhes da conexão é exibida.

  7. Na seção Detalhes do catálogo remoto, no campo Warehouse da AWS, insira o ID da sua conta da AWS ou o catálogo de buckets de tabelas do S3. Por exemplo: 123456789012 ou 123456789012:s3tablescatalog/my-table-bucket.

  8. No campo Região da AWS, insira sua região da AWS. Por exemplo: us-east-1.

  9. No campo ARN do papel da AWS, insira o ARN do papel da AWS. Use o seguinte formato: arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME.

  10. Em Camada de transporte, selecione Internet pública (padrão) ou Interconexão dedicada particular. Se você selecionar Interconexão privada dedicada, configure os seguintes campos:

    • No campo Nome do diretório de serviços, insira o caminho para o serviço de transporte do serviço do diretório no formato projects/PROJECT_ID/locations/REGION/namespaces/SERVICE_DIRECTORY_NAMESPACE/services/SERVICE_NAME.
    • Opcional: para sincronizar metadados de catálogo pelo Interconexão entre nuvens, no campo Nome do diretório de serviços de metadados, insira o caminho para o serviço do Diretório de Serviços de metadados no formato projects/PROJECT_ID/locations/REGION/namespaces/METADATA_SERVICE_DIRECTORY_NAMESPACE/services/METADATA_SERVICE_NAME.
  11. Clique em Criar.

Para atualizar a Camada de transporte, o Nome do diretório de serviços ou o Nome do diretório de serviços de metadados em um catálogo federado, abra o catálogo no Lakehouse, clique em Editar catálogo, modifique os campos e clique em Salvar.

gcloud

Internet pública

Se você não configurar o Interconexão entre nuvens, as conexões vão passar pela Internet pública usando TLS.

gcloud biglake iceberg catalogs create FEDERATED_CATALOG_NAME \
    --project="PROJECT_ID" \
    --primary-location="REGION" \
    --catalog-type="federated" \
    --federated-catalog-type="glue" \
    --glue-warehouse="GLUE_OR_S3_TABLE_BUCKET_WAREHOUSE" \
    --glue-aws-region="AWS_REGION" \
    --glue-aws-role-arn="arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME" \
    --namespace-filters="NAMESPACE_FILTERS" \
    --cross-cloud-cache="CROSS_CLOUD_CACHE_MODE"

Cross-Cloud Interconnect

Se você configurou o Interconexão entre nuvens, forneça a referência de serviço do Diretório de Serviços para o transporte de consulta particular (--service-directory-name), a atualização de metadados em segundo plano particular (--metadata-service-directory-name) ou ambos. Também é possível adicionar ou atualizar qualquer uma das flags em um catálogo atual executando gcloud biglake iceberg catalogs update.

gcloud biglake iceberg catalogs create FEDERATED_CATALOG_NAME \
    --project="PROJECT_ID" \
    --primary-location="REGION" \
    --catalog-type="federated" \
    --federated-catalog-type="glue" \
    --glue-warehouse="GLUE_OR_S3_TABLE_BUCKET_WAREHOUSE" \
    --glue-aws-region="AWS_REGION" \
    --glue-aws-role-arn="arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME" \
    --namespace-filters="NAMESPACE_FILTERS" \
    --cross-cloud-cache="CROSS_CLOUD_CACHE_MODE" \
    --service-directory-name="projects/PROJECT_ID/locations/REGION/namespaces/SERVICE_DIRECTORY_NAMESPACE/services/SERVICE_NAME" \
    --metadata-service-directory-name="projects/PROJECT_ID/locations/REGION/namespaces/METADATA_SERVICE_DIRECTORY_NAMESPACE/services/METADATA_SERVICE_NAME"

Substitua:

  • FEDERATED_CATALOG_NAME: um nome para o catálogo federado.
  • PROJECT_ID: o ID do projeto Google Cloud .
  • REGION: a região do Lakehouse em que o catálogo federado é criado. Precisa ser a mesma região do namespace do Diretório de Serviços e do secret regional.
  • GLUE_OR_S3_TABLE_BUCKET_WAREHOUSE: o identificador do catálogo do warehouse de destino. Para um Glue Data Catalog de uma região da AWS, insira a string de ID da conta da AWS com 12 dígitos. Por exemplo, 123456789012. Para usar um bucket de tabela do S3 na região, insira AWS_ACCOUNT_ID:s3tablescatalog/S3_TABLE_BUCKET. Por exemplo, 123456789012:s3tablescatalog/my-table-bucket.
  • AWS_ACCOUNT_ID: a string de ID da conta da AWS com 12 dígitos. Por exemplo, 123456789012.
  • AWS_REGION: a região da AWS em que o catálogo do Glue ou o bucket de tabela do S3 está localizado. Por exemplo, us-east-1.
  • AWS_ROLE_NAME: o nome do papel do IAM da AWS. Por exemplo, lakehouse_glue_federation_role.
  • NAMESPACE_FILTERS: opcional: uma lista separada por vírgulas de namespaces para federar. Por exemplo, ns1,ns2. Se omitido, o Lakehouse inclui todos os namespaces.
  • CROSS_CLOUD_CACHE_MODE: opcional: se o armazenamento em cache entre nuvens deve ser ativado no catálogo federado (enabled ou disabled). O padrão é disabled. Quando definida como enabled, o Lakehouse armazena em cache os arquivos remotos na região Google Cloud do catálogo. Para mais informações, consulte Armazenamento em cache inteligente.
  • Se você estiver usando o Interconexão entre nuvens, especifique uma ou ambas as seguintes referências do Diretório de serviços (omita qualquer uma das flags se você não estiver roteando essa camada de tráfego pelo Interconexão entre nuvens):
    • SERVICE_DIRECTORY_NAMESPACE e SERVICE_NAME: o namespace do Diretório de serviços e o nome do serviço que você criou para o transporte de consultas particulares para o repositório de objetos remoto.
    • METADATA_SERVICE_DIRECTORY_NAMESPACE e METADATA_SERVICE_NAME: o namespace do Diretório de Serviços e o nome do serviço que você criou para a atualização de metadados em segundo plano particular.

Atualizar a política de confiança

Quando o catálogo é criado, o Lakehouse provisiona uma conta de serviço exclusiva para ele, que é retornada como o campo biglake-service-account-id na resposta de criação do catálogo. Você usa essa conta de serviço para estabelecer a relação de confiança.

  1. Execute o comando a seguir para extrair o valor biglake-service-account-id em uma variável bash ativa:

    LAKEHOUSE_SA_ID=$(gcloud biglake iceberg catalogs describe FEDERATED_CATALOG_NAME \
      --project="PROJECT_ID" \
      --format="value(biglake-service-account-id)")
  2. Atualize a política de confiança do papel do IAM da AWS para substituir o marcador de posição pelo ID verificado do agente de serviço do Google. O bloco de condição valida a correspondência de sub e aud. Grave a política em um arquivo chamado trust_policy_comprehensive.json:

    cat > trust_policy_comprehensive.json << EOF
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": {
            "Federated": "accounts.google.com"
          },
          "Action": "sts:AssumeRoleWithWebIdentity",
          "Condition": {
            "StringEquals": {
              "accounts.google.com:aud": [
                "$LAKEHOUSE_SA_ID"
              ],
              "accounts.google.com:sub": [
                "$LAKEHOUSE_SA_ID"
              ]
            }
          }
        }
      ]
    }
    EOF
  3. Aplique a política finalizada ao seu papel da AWS:

    aws iam update-assume-role-policy \
      --role-name AWS_ROLE_NAME \
      --policy-document file://trust_policy_comprehensive.json

Ativar a atualização de metadados em segundo plano

Agora que as relações de confiança seguras foram estabelecidas nas duas plataformas, atualize seu catálogo para ativar a atualização de metadados em segundo plano (a cada 5 minutos ou 300s, ou mais).

gcloud

gcloud biglake iceberg catalogs update FEDERATED_CATALOG_NAME \
  --project="PROJECT_ID" \
  --refresh-interval="300s"

REST

curl -s -X PATCH \
  -H "x-goog-user-project: PROJECT_ID" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://biglake.googleapis.com/iceberg/v1/restcatalog/extensions/projects/PROJECT_ID/catalogs/FEDERATED_CATALOG_NAME?updateMask=federated_catalog_options.refresh_options.refresh_schedule" \
  -d '{
    "federated_catalog_options": {
      "refresh_options": {
        "refresh_schedule": {
          "refresh_interval": "300s"
        }
      }
    }
  }'

Concluir a configuração do Interconexão entre nuvens

Se você rotear o transporte de consultas, a atualização de metadados em segundo plano ou ambos pelo Interconexão entre nuvens, conceda permissões à conta de serviço do catálogo do Lakehouse para descobrir e autorizar conexões pelo Diretório de Serviços. Se o serviço de transporte do Diretório de Serviços e o serviço de metadados do Diretório de Serviços estiverem hospedados em projetos Google Cloud diferentes, conceda esses papéis em cada projeto que hospeda um serviço do Diretório de Serviços.

Console

  1. No console do Google Cloud , acesse a página IAM.

    Acessar IAM

  2. Clique em Conceder acesso (ou Adicionar).

  3. No campo Novos principais, insira o endereço de e-mail da conta de serviço do catálogo do Lakehouse. Para recuperar esse endereço de e-mail, descreva o catálogo (consulte a guia gcloud).

  4. No menu Papel, selecione Leitor do Diretório de Serviços (roles/servicedirectory.viewer).

  5. Clique em Adicionar outro papel e selecione Serviço autorizado do PSC do Diretório de serviços (roles/servicedirectory.pscAuthorizedService).

  6. Clique em Salvar.

gcloud

Conceda os papéis necessários à conta de serviço do catálogo no projeto que hospeda os serviços do Diretório de Serviços:

# Grant Service Directory Viewer
gcloud projects add-iam-policy-binding PROJECT_ID \
--member="serviceAccount:$(gcloud biglake iceberg catalogs describe FEDERATED_CATALOG_NAME \
    --project="PROJECT_ID" \
    --format='value(biglake-service-account)')" \
--role="roles/servicedirectory.viewer"

# Grant Service Directory PSC Authorized Service
gcloud projects add-iam-policy-binding PROJECT_ID \
--member="serviceAccount:$(gcloud biglake iceberg catalogs describe FEDERATED_CATALOG_NAME \
    --project="PROJECT_ID" \
    --format='value(biglake-service-account)')" \
--role="roles/servicedirectory.pscAuthorizedService"

Verifique a conexão

Verifique se o ciclo de atualização de metadados em segundo plano do catálogo foi concluído e se os namespaces estão sincronizados.

  1. Verifique se o status de atualização indica sucesso:

    gcloud biglake iceberg catalogs describe FEDERATED_CATALOG_NAME \
      --project="PROJECT_ID"
  2. Confirme se os namespaces estão sincronizados:

    gcloud biglake iceberg namespaces list \
      --project="PROJECT_ID" \
      --catalog="FEDERATED_CATALOG_NAME"

A seguir