The product described by this documentation, Anthos Clusters on AWS (previous generation), is now in maintenance mode. All new installs must use the current generation product, Anthos clusters on AWS.

Como fazer a integração com a infraestrutura atual

Neste tópico, você configura uma Nuvem privada virtual (VPC, na sigla em inglês) da AWS com sub-redes públicas e privadas e executa anthos-gke para concluir a instalação de um serviço de gerenciamento. para criar um anexo da VLAN de monitoramento.

Antes de começar

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

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

Como criar o espaço de trabalho

Crie um arquivo chamado anthos-gke.yaml em um editor de texto. Cole o conteúdo a seguir 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 pela região da AWS para executar o cluster.
- ADMIN_AWS_IAM_ARN pelo nome de recurso da Amazon da chave de IAM da AWS do administrador.
- KMS_KEY_ARN pelo nome do recurso da Amazon da chave KMS da AWS que protege os dados do serviço de gerenciamento quando o serviço de gerenciamento é criado.
- DATABASE_KMS_KEY_ARN pelo nome do recurso da Amazon da chave KMS da AWS que protege seus bancos de dados etcd.
- SECURITY_GROUP_IDS com mais IDs de grupo de segurança que permitem acesso às VMs de serviço de gerenciamento.
- GCP_PROJECT_ID pelo projeto do Google Cloud que hospeda o ambiente do GKE Enterprise.
- MANAGEMENT_KEY_PATH pela localização da chave da conta de serviço de gerenciamento do Google Cloud.
- HUB_KEY_PATH pelo local da chave da conta de serviço do Google Cloud Connect.
- NODE_KEY_PATH pela localização da chave da conta de serviço do nó GKE na AWS.
- VPC_SUBNET_ID pelo ID da sub-rede em que o serviço de gerenciamento é executado.
- SSH_SECURITY_GROUP pela lista de IDs de grupo de segurança que tem acesso SSH em instâncias do serviço de gerenciamento.
Opcional: se você quiser criptografar os volumes de serviços de gerenciamento, substitua os seguintes valores:
- ROOT_VOLUME_SIZE pelo tamanho do volume em gigabytes para o serviço de gerenciamento. Por exemplo, 10.
- ROOT_VOLUME_TYPE pelo tipo de volume EBS. Por exemplo, gp3.
- ROOT_VOLUME_IOPS pela montagem das operações de E/S provisionadas por segundo (IOPS, na sigla em inglês) para o volume. Válido apenas quando volumeType for GP3. Para mais informações, consulte Volumes SSD de uso geral (gp3).
- ROOT_VOLUME_KEY pelo nome de recurso da Amazon da chave do KMS da AWS que criptografa os volumes raiz da instância do serviço gerenciado. Para mais informações, consulte Como usar uma CMK gerenciada pelo cliente para criptografar volumes.
Opcional: se você quiser criar um Bastion Host para acessar o GKE no ambiente da AWS com um túnel SSH, substitua os seguintes valores:
- BASTION_HOST_SUBNET_ID pelo código da sub-rede em que o Bastion Host é executado. Verifique se VPC_SUBNET_ID permite conexões de entrada de BASTION_HOST_SUBNET_ID.
- SSH_CIDR_BLOCK pelo bloco CIDR de que seu Bastion Host permite a conexão SSH de entrada. Por exemplo, 203.0.113.0/24. Se quiser permitir o SSH de qualquer endereço IP, use 0.0.0.0/0.
- BASTION_VOLUME_KEY pelo nome de recurso da Amazon da chave do KMS da AWS que protege o volume raiz Bastion.
Opcional: se você quiser tráfego direto por meio de um proxy HTTP, substitua o seguinte valor:
- PROXY_JSON_FILE pelo caminho relativo do arquivo de configuração de proxy. Se você não estiver usando um proxy, remova essa 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 terminar, o serviço de gerenciamento será executado na AWS.

Marcar as sub-redes com o nome do cluster

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

Para incluir tags nas sub-redes, siga estas etapas:

Mude para o diretório com o GKE na configuração da AWS. Você criou esse diretório ao instalar o serviço de gerenciamento.
```
cd anthos-aws
```
Exporte o ID do 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 o ID de VPC da AWS como a variável de ambiente $VPC_ID. Escolha 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)
```
Receba os IDs da sub-rede particular com a ferramenta CLI aws.
```
  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 as sub-redes tenham private no nome. Se as sub-redes não incluírem esse texto, altere os parâmetros da sinalização --filters. Para mais informações, consulte Como usar o filtro.
Marque as sub-redes com o ID do cluster. Execute o comando a seguir 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.

Como se conectar ao serviço de gerenciamento

Nesta seção, você estabelece uma conexão com o serviço de gerenciamento. É possível encapsular os comandos por meio de um Bastion Host. Se você tiver uma conexão direta com a VPC da AWS, pule para Gerar credenciais e conectar.

Como se conectar com um Bastion Host

Se você usar um Bastion Host para configurar o túnel SSH, primeiro configure o host no anthos-gke.yaml. Em seguida, crie um script para abrir o túnel seguindo estas 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 Bastion Host (~/.ssh/anthos-gke).
Para abrir o túnel, execute o script bastion-tunnel.sh. O túnel encaminha do localhost:8118 para o Bastion Host.

Para abrir um túnel para o Bastion Host, execute o seguinte comando:
```
./bastion-tunnel.sh -N
```
As mensagens do túnel SSH aparecem nessa janela. Quando estiver pronto para fechar a conexão, interrompa o processo usando Control+C ou fechando a janela.
Mude para o diretório com o GKE na configuração da AWS.
```
cd anthos-aws
```

Gerar credenciais e se conectar

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

Gere um kubeconfig para autenticação. Use anthos-gke para anexar credenciais à 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.

A seguir

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