O produto descrito nesta documentação, Anthos Clusters na AWS (geração anterior), está em modo de manutenção . Todas as novas instalações devem usar o produto da geração atual, Anthos Clusters na AWS .

Esta página foi traduzida pela API Cloud Translation.

Integração com a infraestrutura existente

Neste tópico, você configura uma AWS Virtual Private Cloud (VPC) existente com sub-redes públicas e privadas e executa anthos-gke para concluir a instalação de um serviço de gerenciamento.

Antes de começar

Para concluir as etapas a seguir, você precisa do seguinte:

Permissões do AWS IAM conforme descrito em Requisitos .
Uma VPC AWS existente com:
- Pelo menos uma sub-rede pública.
- Pelo menos uma sub-rede privada.
- Um gateway de internet com uma rota para a sub-rede pública.
- Um gateway NAT com uma rota para a sub-rede privada.
- Nomes de host DNS habilitados.
- Nenhum valor personalizado de domain-name nos seus conjuntos de opções de DHCP. Para obter mais informações, consulte Solução de problemas . O GKE na AWS não oferece suporte a valores diferentes dos nomes de domínio padrão do EC2 .
Para obter mais informações sobre como configurar sua AWS VPC, consulte VPC com sub-redes públicas e privadas .
Os IDs de sub-rede pública e privada da sua VPC existente. Por exemplo, subnet-1234567890abcdefg .
Para versões de cluster 1.20 ou inferiores, um grupo de segurança da AWS que permite entrada SSH (porta 22) dos grupos de segurança ou intervalos de IP onde você gerenciará sua instalação do GKE na AWS.
Para versões de cluster 1.21 ou superiores, um grupo de segurança da AWS que permite conexões Konnectivity (porta 8132) de saída dos intervalos de IP da VPC que hospedam seus pools de nós do GKE na AWS.

Criando o espaço de trabalho

Crie um arquivo chamado anthos-gke.yaml em um editor de texto. Cole o seguinte conteúdo no arquivo.
```
 apiVersion: multicloud.cluster.gke.io/v1
 kind: AWSManagementService
 metadata:
   name: management
 spec:
   version: aws-1.14.1-gke.0
   region: AWS_REGION
   authentication:
     awsIAM:
       adminIdentityARNs:
       - ADMIN_AWS_IAM_ARN
   kmsKeyARN: KMS_KEY_ARN
   databaseEncryption:
     kmsKeyARN: DATABASE_KMS_KEY_ARN
   securityGroupIDs:
   - SECURITY_GROUP_IDS
   googleCloud:
     projectID: GCP_PROJECT_ID
     serviceAccountKeys:
       managementService: MANAGEMENT_KEY_PATH
       connectAgent: HUB_KEY_PATH
       node: NODE_KEY_PATH
   existingVPC:
     subnetID: VPC_SUBNET_ID
     allowedSSHSecurityGroupIDs:
     - SSH_SECURITY_GROUP
   # Optional fields
   rootVolume:
     sizeGiB: ROOT_VOLUME_SIZE
     volumeType: ROOT_VOLUME_TYPE
     iops: ROOT_VOLUME_IOPS
     kmsKeyARN: ROOT_VOLUME_KEY
   bastionHost:
     subnetID: BASTION_HOST_SUBNET_ID
     allowedSSHCIDRBlocks:
     - SSH_CIDR_BLOCK
     rootVolume: # Optional
       kmsKeyARN: BASTION_VOLUME_KEY
   proxy: PROXY_JSON_FILE
```
Substitua os seguintes valores:
- AWS_REGION com a região da AWS para executar seu cluster.
- ADMIN_AWS_IAM_ARN com o nome do recurso da Amazon da chave do AWS IAM do administrador.
- KMS_KEY_ARN com o nome do recurso da Amazon da chave KMS da AWS que protege os dados do seu serviço de gerenciamento quando o serviço de gerenciamento é criado.
- DATABASE_KMS_KEY_ARN com o nome do recurso da Amazon da chave AWS KMS que protege seus bancos de dados etcd .
- SECURITY_GROUP_IDS com IDs de grupo de segurança adicionais permitiram acesso às VMs do seu serviço de gerenciamento.
- GCP_PROJECT_ID com o Google Cloud projeto que hospeda seu ambiente GKE Enterprise.
- MANAGEMENT_KEY_PATH com a localização do seu Google Cloudchave da conta do serviço de gerenciamento.
- HUB_KEY_PATH com a localização do seu Google CloudConecte a chave da conta de serviço .
- NODE_KEY_PATH com o local da sua chave de conta de serviço do nó do GKE na AWS.
- VPC_SUBNET_ID com o ID da sub-rede onde o serviço de gerenciamento é executado.
- SSH_SECURITY_GROUP com a lista de IDs de grupos de segurança que permitem acesso SSH dentro das instâncias do serviço de gerenciamento.
Opcional: se você quiser criptografar os volumes do serviço de gerenciamento, substitua os seguintes valores:
- ROOT_VOLUME_SIZE com o tamanho do volume em gigabytes para o serviço de gerenciamento. Por exemplo, 10 .
- ROOT_VOLUME_TYPE com o tipo de volume do EBS . Por exemplo, gp3 .
- ROOT_VOLUME_IOPS com a quantidade de operações de E/S provisionadas por segundo (IOPS) para o volume. Válido somente quando volumeType for GP3 . Para obter mais informações, consulte Volumes SSD de uso geral (gp3) .
- ROOT_VOLUME_KEY com o nome de recurso da Amazon da chave do AWS KMS que criptografa os volumes raiz da sua instância do serviço de gerenciamento. Para obter mais informações, consulte Como usar uma CMK gerenciada pelo cliente para criptografar volumes .
Opcional: se você quiser criar um bastion host para acessar seu ambiente GKE na AWS com um túnel SSH, substitua os seguintes valores:
- BASTION_HOST_SUBNET_ID com o ID da sub-rede onde o Bastion Host é executado. Certifique-se de que VPC_SUBNET_ID permita conexões de entrada de BASTION_HOST_SUBNET_ID .
- SSH_CIDR_BLOCK com o bloco CIDR do qual seu bastion host permite conexão SSH de entrada. Por exemplo, 203.0.113.0/24 . Se quiser permitir SSH de qualquer endereço IP, use 0.0.0.0/0 .
- BASTION_VOLUME_KEY com o nome do recurso da Amazon da chave do AWS KMS que protege seu volume raiz do bastion.
Opcional: se você quiser direcionar o tráfego por meio de um proxy HTTP , substitua o seguinte valor:
- PROXY_JSON_FILE com o caminho relativo do arquivo de configuração do proxy . Se você não estiver usando um proxy, remova esta linha.
Execute anthos-gke aws management init para criar arquivos de configuração:
```
anthos-gke aws management init
```
Execute anthos-gke aws management apply para criar o cluster.
```
anthos-gke aws management apply
```
O comando anthos-gke aws management apply pode levar até dez minutos para ser concluído. Quando anthos-gke for concluído, seu serviço de gerenciamento será executado na AWS.

Marque suas sub-redes com o nome do seu cluster

Se você estiver usando sub-redes da AWS existentes com o GKE na AWS e quiser criar balanceadores de carga, precisará marcar sua VPC e sub-redes com o nome do seu serviço de gerenciamento. Se você criou sua VPC com anthos-gke ou já marcou suas sub-redes, pule esta etapa.

Para marcar suas sub-redes, execute as seguintes etapas:

Acesse o diretório com a configuração do GKE na AWS. Você criou este diretório ao instalar o serviço de gerenciamento .
```
cd anthos-aws
```
Exporte o ID do seu cluster como a variável de ambiente $CLUSTER-ID . Escolha sua versão do Terraform e execute os seguintes comandos:
Terraform 0,12, 0,13
```
export CLUSTER_ID=$(terraform output cluster_id)
```
Terraform 0.14.3+
```
export CLUSTER_ID=$(terraform output -raw cluster_id)
```
Exporte seu ID de VPC da AWS como a variável de ambiente $VPC_ID . Selecione sua versão do Terraform e execute os seguintes comandos:
Terraform 0,12, 0,13
```
export VPC_ID=$(terraform output vpc_id)
```
Terraform 0.14.3+
```
export VPC_ID=$(terraform output -raw vpc_id)
```
Obtenha seus IDs de sub-rede privados com a ferramenta aws CLI.
```
  aws ec2 describe-subnets \
      --filters "Name=vpc-id,Values=$VPC_ID" "Name=tag:Name,Values=*private*" \
      --query "Subnets[*].SubnetId" \
      --output text
```
Observação: este comando pressupõe que suas sub-redes tenham private no nome. Se suas sub-redes não incluírem esse texto, altere os parâmetros do sinalizador --filters . Para obter mais informações, consulte Usando filtragem .
Marque suas sub-redes com o ID do seu cluster. Execute o seguinte comando para cada uma das suas sub-redes.
```
  aws ec2 create-tags \
      --resources SUBNET_IDS \
      --tags Key=gke:multicloud:cluster-id,Value=$CLUSTER_ID
```
Substitua SUBNET_IDS pela lista de IDs de sub-rede, separados por espaços. Por exemplo, subnet-012345678abcdef subnet-abcdef123456789 subnet-123456789abcdef .

Conectando-se ao serviço de gerenciamento

Nesta seção, você estabelece uma conexão com seu serviço de gerenciamento. Você pode encapsular seus comandos por meio de um bastion host . Se você tiver uma conexão direta com sua VPC da AWS, pule para Gerar credenciais e conectar .

Conectando-se com um host bastião

Se você usar um host bastion para configurar o túnel SSH, primeiro configure o host em anthos-gke.yaml . Em seguida, crie um script para abrir o túnel executando as seguintes etapas:

Use terraform para gerar um script que abre um túnel SSH para o bastion host.
```
terraform output bastion_tunnel > bastion-tunnel.sh
chmod 755 bastion-tunnel.sh
```
O Terraform cria o script bastion-tunnel.sh que usa a chave SSH do host bastion ( ~/.ssh/anthos-gke ).
Para abrir o túnel, execute o script bastion-tunnel.sh . O túnel encaminha de localhost:8118 para o host bastion.
Para abrir um túnel para o host bastião, execute o seguinte comando:
```
./bastion-tunnel.sh -N
```
As mensagens do túnel SSH aparecem nesta janela. Quando estiver pronto para encerrar a conexão, interrompa o processo usando Control+C ou fechando a janela.
Mude para o diretório com sua configuração do GKE na AWS.
```
cd anthos-aws
```

Gerar credenciais e conectar

A documentação do GKE na AWS pressupõe que você use um túnel SSH na porta 8118 localhost para acessar seu cluster. Se você usar outro tipo de conexão com sua VPC, como uma interconexão direta, VPN ou outro método, poderá remover a linha env HTTP_PROXY=http://localhost:8118 dos comandos.

Gere um kubeconfig para autenticação. Use anthos-gke para anexar credenciais à sua configuração armazenada em ~/.kube/config .
```
anthos-gke aws management get-credentials
```
Verifique se você consegue se conectar ao serviço de gerenciamento com kubectl .
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl cluster-info
```
kubectl imprime o status do cluster.

O que vem a seguir

Crie um cluster de usuários .
Use um proxy com o GKE na AWS.
Altere sua configuração kubectl para se conectar ao GKE na AWS com menos opções de linha de comando.
Veja os grupos de segurança mínimos necessários para seu serviço de gerenciamento e clusters de usuários do GKE na AWS.