Esta documentação é referente à versão atual do GKE na AWS, lançada em novembro de 2021. Consulte as Notas de lançamento para mais informações.

Criar uma VPC da AWS

O GKE na AWS é executado em uma nuvem privada virtual (VPC) da AWS. Nesta página, explicamos como configurar uma nova VPC para o cluster.

O GKE na AWS cria e gerencia recursos dentro da VPC especificada por você. Também é necessário criar várias sub-redes dentro da VPC:

Até três sub-redes para os nós do plano de controle
Uma sub-rede para o pool de nós
Sub-redes para balanceadores de carga de serviço do Kubernetes

Exemplo de VPC

Siga estas etapas para configurar a VPC ilustrada abaixo. Para seus próprios casos de uso de produção, escolha diferentes intervalos de IP, zonas de disponibilidade, sub-redes e listas de controle de acesso à rede adequadas às suas cargas de trabalho.

O diagrama a seguir mostra a VPC de amostra que você criou seguindo estas etapas:

Exemplo de VPC

Este exemplo usa três zonas de disponibilidade: Zona de disponibilidade 1, Zona de disponibilidade 2, Zona de disponibilidade 3. Por exemplo, para criar uma VPC na região us-east-1, elas podem ser definidas como us-east-1a, us-east-1b, us-east-1c.
Em cada uma das três zonas de disponibilidade, há uma sub-rede pública e uma sub-rede particular.
As réplicas do plano de controle e os endpoints do balanceador de carga, bem como os pools de nós, são criados nas sub-redes particulares.
As sub-redes públicas fornecem acesso de Internet de sub-redes particulares e endpoints de balanceador de carga públicos.
Todas essas sub-redes são marcadas para descoberta automática de sub-redes. Os balanceadores de carga internos serão provisionados nas sub-redes públicas e balanceadores de carga voltados para a Internet nas sub-redes públicas.

Criar a VPC

Escolha um prefixo e edite a variável AMC_PREFIX da página no comando abaixo para defini-lo como o prefixo escolhido. Os comandos de amostra abaixo vão anexar esse prefixo automaticamente a todas as referências à VPC e aos recursos dela.
Crie uma nuvem privada virtual (VPC) da AWS:
```
aws --region AWS_REGION ec2 create-vpc \
    --cidr-block 10.0.0.0/16 \
    --tag-specifications 'ResourceType=vpc, Tags=[{Key=Name,Value=AMC_PREFIXVPC}]'
```
Substitua:
- AWS_REGION: o nome da região compatível com a AWS para criar a VPC.
- AMC_PREFIX: o prefixo do nome da VPC escolhido para a VPC e os recursos dela

Salve o ID da VPC em uma variável de ambiente e ative o suporte ao DNS fornecido pela AWS para a VPC:

VPC_ID=$(aws ec2 describe-vpcs \
  --filters 'Name=tag:Name,Values=AMC_PREFIXVPC' \
  --query "Vpcs[].VpcId" --output text)
aws ec2 modify-vpc-attribute --enable-dns-hostnames --vpc-id $VPC_ID
aws ec2 modify-vpc-attribute --enable-dns-support --vpc-id $VPC_ID

Também é possível usar configurações de DNS diferentes na VPC. Para mais informações, consulte DNS VPC da AWS.

Sub-redes do plano de controle

É possível configurar até três sub-redes para réplicas do plano de controle. Se você especificar menos de três sub-redes, o GKE na AWS criará três réplicas de plano de controle e as distribuirá entre as sub-redes especificadas.

Os clusters são particulares para sua VPC. O acesso direto de entrada aos clusters da Internet não é permitido. O GKE na AWS requer acesso limitado à Internet de saída para criar e gerenciar clusters. Este exemplo usa um gateway de Internet para acesso de saída.

Requisitos de sub-rede

As sub-redes precisam

Resolver endereços DNS
Estabelecer conexões TCP de saída na porta 443 para endereços IP roteáveis
Ser capaz de se conectar aos seguintes endpoints:

Endpoint	Finalidade
storage.googleapis.com	Para fazer o download no Cloud Storage durante a instalação
*.gcr.io	Para fazer o download no Container Registry durante a instalação
gkeconnect.googleapis.com	Como se conectar ao serviço de gerenciamento
oauth2.googleapis.com	Para autenticação de cluster.
sts.googleapis.com	Para autenticação de cluster.
logging.googleapis.com	Para enviar registros ao Cloud Logging
monitoring.googleapis.com	Para enviar métricas ao Cloud Monitoring
opsconfigmonitoring.googleapis.com`	Para enviar metadados de recursos para o Cloud Monitoring.
servicecontrol.googleapis.com	Para o Cloud Audit Logging

Se você não tiver sub-redes para as instâncias do plano de controle, use os seguintes comandos para criá-las.

Criar sub-redes particulares

Crie três sub-redes particulares nas zonas de disponibilidade correspondentes:

   aws ec2 create-subnet \
     --availability-zone AWS_ZONE_1 \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.1.0/24 \
     --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPrivateSubnet1}]'
   aws ec2 create-subnet \
     --availability-zone AWS_ZONE_2 \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.2.0/24 \
     --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPrivateSubnet2}]'
   aws ec2 create-subnet \
     --availability-zone AWS_ZONE_3 \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.3.0/24 \
     --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPrivateSubnet3}]'

Substitua:

AWS_ZONE_1: Zona de disponibilidade 1
AWS_ZONE_2: Zona de disponibilidade 2
AWS_ZONE_3: Zona de disponibilidade 3

Criar sub-redes públicas

Crie três sub-redes públicas. Eles serão usados para fornecer acesso de saída à Internet para as sub-redes particulares.

aws ec2 create-subnet \
  --availability-zone AWS_ZONE_1 \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.101.0/24 \
  --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPublicSubnet1}]'
aws ec2 create-subnet \
  --availability-zone AWS_ZONE_2 \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.102.0/24 \
  --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPublicSubnet2}]'
aws ec2 create-subnet \
  --availability-zone AWS_ZONE_3 \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.103.0/24 \
  --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPublicSubnet3}]'

Substitua:

AWS_ZONE_1
AWS_ZONE_2
AWS_ZONE_3

Marque as sub-redes como públicas:

PUBLIC_SUBNET_ID_1=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPublicSubnet1' \
  --query "Subnets[].SubnetId" --output text)
PUBLIC_SUBNET_ID_2=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPublicSubnet2' \
  --query "Subnets[].SubnetId" --output text)
PUBLIC_SUBNET_ID_3=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPublicSubnet3' \
  --query "Subnets[].SubnetId" --output text)
aws ec2 modify-subnet-attribute \
  --map-public-ip-on-launch \
  --subnet-id $PUBLIC_SUBNET_ID_1
aws ec2 modify-subnet-attribute \
  --map-public-ip-on-launch \
  --subnet-id $PUBLIC_SUBNET_ID_2
aws ec2 modify-subnet-attribute \
  --map-public-ip-on-launch \
  --subnet-id $PUBLIC_SUBNET_ID_3

Criar um gateway da Internet

Crie um gateway de Internet para que as sub-redes públicas tenham acesso à Internet:

aws --region AWS_REGION  ec2 create-internet-gateway \
  --tag-specifications 'ResourceType=internet-gateway, Tags=[{Key=Name,Value=AMC_PREFIXInternetGateway}]'

Substitua AWS_REGION: o nome da região da AWS em que sua VPC foi criada.

Anexe o gateway da Internet à VPC:

INTERNET_GW_ID=$(aws ec2 describe-internet-gateways \
  --filters 'Name=tag:Name,Values=AMC_PREFIXInternetGateway' \
  --query "InternetGateways[].InternetGatewayId" --output text)
aws ec2 attach-internet-gateway \
  --internet-gateway-id $INTERNET_GW_ID \
  --vpc-id $VPC_ID

Configure as tabelas de roteamento para sub-redes públicas

Crie uma tabela de rotas para cada uma das sub-redes públicas.

aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPublicRouteTbl1}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPublicRouteTbl2}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPublicRouteTbl3}]'

Associe as tabelas de rota pública às sub-redes públicas:

PUBLIC_ROUTE_TABLE_ID_1=$(aws ec2 describe-route-tables \
    --filters 'Name=tag:Name,Values=AMC_PREFIXPublicRouteTbl1' \
    --query "RouteTables[].RouteTableId" --output text)
PUBLIC_ROUTE_TABLE_ID_2=$(aws ec2 describe-route-tables \
    --filters 'Name=tag:Name,Values=AMC_PREFIXPublicRouteTbl2' \
    --query "RouteTables[].RouteTableId" --output text)
PUBLIC_ROUTE_TABLE_ID_3=$(aws ec2 describe-route-tables \
    --filters 'Name=tag:Name,Values=AMC_PREFIXPublicRouteTbl3' \
    --query "RouteTables[].RouteTableId" --output text)
aws ec2 associate-route-table \
  --route-table-id $PUBLIC_ROUTE_TABLE_ID_1 \
  --subnet-id $PUBLIC_SUBNET_ID_1
aws ec2 associate-route-table \
  --route-table-id $PUBLIC_ROUTE_TABLE_ID_2 \
  --subnet-id $PUBLIC_SUBNET_ID_2
aws ec2 associate-route-table \
  --route-table-id $PUBLIC_ROUTE_TABLE_ID_3 \
  --subnet-id $PUBLIC_SUBNET_ID_3

Crie rotas padrão para o gateway da Internet:

aws ec2 create-route --route-table-id $PUBLIC_ROUTE_TABLE_ID_1 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $INTERNET_GW_ID
aws ec2 create-route --route-table-id $PUBLIC_ROUTE_TABLE_ID_2 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $INTERNET_GW_ID
aws ec2 create-route --route-table-id $PUBLIC_ROUTE_TABLE_ID_3 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $INTERNET_GW_ID

Aloque um endereço IP elástico (EIP) para cada gateway NAT:

aws ec2 allocate-address \
  --tag-specifications 'ResourceType=elastic-ip, Tags=[{Key=Name,Value=AMC_PREFIXNatEip1}]'
aws ec2 allocate-address \
  --tag-specifications 'ResourceType=elastic-ip, Tags=[{Key=Name,Value=AMC_PREFIXNatEip2}]'
aws ec2 allocate-address \
  --tag-specifications 'ResourceType=elastic-ip, Tags=[{Key=Name,Value=AMC_PREFIXNatEip3}]'

Criar gateways NAT

Crie um gateway NAT em cada uma das três sub-redes públicas:

   NAT_EIP_ALLOCATION_ID_1=$(aws ec2 describe-addresses \
     --filters 'Name=tag:Name,Values=AMC_PREFIXNatEip1' \
     --query "Addresses[].AllocationId" --output text)
   NAT_EIP_ALLOCATION_ID_2=$(aws ec2 describe-addresses \
     --filters 'Name=tag:Name,Values=AMC_PREFIXNatEip2' \
     --query "Addresses[].AllocationId" --output text)
   NAT_EIP_ALLOCATION_ID_3=$(aws ec2 describe-addresses \
     --filters 'Name=tag:Name,Values=AMC_PREFIXNatEip3' \
     --query "Addresses[].AllocationId" --output text)
   aws ec2 create-nat-gateway \
     --allocation-id $NAT_EIP_ALLOCATION_ID_1 \
     --subnet-id $PUBLIC_SUBNET_ID_1 \
     --tag-specifications 'ResourceType=natgateway, Tags=[{Key=Name,Value=AMC_PREFIXNatGateway1}]'
   aws ec2 create-nat-gateway \
     --allocation-id $NAT_EIP_ALLOCATION_ID_2 \
     --subnet-id $PUBLIC_SUBNET_ID_2 \
     --tag-specifications 'ResourceType=natgateway, Tags=[{Key=Name,Value=AMC_PREFIXNatGateway2}]'
   aws ec2 create-nat-gateway \
     --allocation-id $NAT_EIP_ALLOCATION_ID_3 \
     --subnet-id $PUBLIC_SUBNET_ID_3 \
     --tag-specifications 'ResourceType=natgateway, Tags=[{Key=Name,Value=AMC_PREFIXNatGateway3}]'

Configurar as tabelas de roteamento para sub-redes particulares

Crie uma tabela de rota para cada sub-rede particular:

aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPrivateRouteTbl1}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPrivateRouteTbl2}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPrivateRouteTbl3}]'

Associe as tabelas de rota privadas às sub-redes particulares:

PRIVATE_SUBNET_ID_1=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateSubnet1' \
  --query "Subnets[].SubnetId" --output text)
PRIVATE_SUBNET_ID_2=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateSubnet2' \
  --query "Subnets[].SubnetId" --output text)
PRIVATE_SUBNET_ID_3=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateSubnet3' \
  --query "Subnets[].SubnetId" --output text)
PRIVATE_ROUTE_TABLE_ID_1=$(aws ec2 describe-route-tables \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateRouteTbl1' \
  --query "RouteTables[].RouteTableId" --output text)
PRIVATE_ROUTE_TABLE_ID_2=$(aws ec2 describe-route-tables \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateRouteTbl2' \
  --query "RouteTables[].RouteTableId" --output text)
PRIVATE_ROUTE_TABLE_ID_3=$(aws ec2 describe-route-tables \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateRouteTbl3' \
  --query "RouteTables[].RouteTableId" --output text)
aws ec2 associate-route-table --route-table-id $PRIVATE_ROUTE_TABLE_ID_1 \
  --subnet-id $PRIVATE_SUBNET_ID_1
aws ec2 associate-route-table --route-table-id $PRIVATE_ROUTE_TABLE_ID_2 \
  --subnet-id $PRIVATE_SUBNET_ID_2
aws ec2 associate-route-table --route-table-id $PRIVATE_ROUTE_TABLE_ID_3 \
  --subnet-id $PRIVATE_SUBNET_ID_3

Crie as rotas padrão para gateways NAT:

NAT_GW_ID_1=$(aws ec2 describe-nat-gateways \
 --filter 'Name=tag:Name,Values=AMC_PREFIXNatGateway1' \
 --query "NatGateways[].NatGatewayId" --output text)
NAT_GW_ID_2=$(aws ec2 describe-nat-gateways \
 --filter 'Name=tag:Name,Values=AMC_PREFIXNatGateway2' \
 --query "NatGateways[].NatGatewayId" --output text)
NAT_GW_ID_3=$(aws ec2 describe-nat-gateways \
 --filter 'Name=tag:Name,Values=AMC_PREFIXNatGateway3' \
 --query "NatGateways[].NatGatewayId" --output text)
aws ec2 create-route --route-table-id $PRIVATE_ROUTE_TABLE_ID_1  \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $NAT_GW_ID_1
aws ec2 create-route --route-table-id $PRIVATE_ROUTE_TABLE_ID_2  \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $NAT_GW_ID_2
aws ec2 create-route --route-table-id $PRIVATE_ROUTE_TABLE_ID_3 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $NAT_GW_ID_3

Sub-redes de pool de nós

Cada pool de nós é colocado em uma única sub-rede. É possível colocar vários pools de nós em uma sub-rede. O número de nós e pools de nós que é possível criar é limitado pelo intervalo de endereços IP disponível na sub-rede.

Cada sub-rede do pool de nós precisa:

Cumpra os mesmos requisitos de acesso à Internet de saída das sub-redes do plano de controle
Ter espaço de endereço IP suficiente para cobrir o tamanho do pool de nós
Não ative a opção "Atribuir IPs públicos automaticamente"

As sub-redes particulares criadas anteriormente atendem aos requisitos das sub-redes do plano de controle e do pool de nós.

Sub-redes do balanceador de carga de serviço

Se você estiver criando balanceadores de carga de rede ou balanceadores de carga HTTP, sub-redes do balanceador de carga de tag para descoberta automática.

Marque as sub-redes públicas com kubernetes.io/role/elb:

aws ec2 create-tags \
  --resources $PUBLIC_SUBNET_ID_1 \
  --tags Key=kubernetes.io/role/elb,Value=1
aws ec2 create-tags \
  --resources $PUBLIC_SUBNET_ID_2 \
  --tags Key=kubernetes.io/role/elb,Value=1
aws ec2 create-tags \
  --resources $PUBLIC_SUBNET_ID_3 \
  --tags Key=kubernetes.io/role/elb,Value=1

Marque as sub-redes particulares com kubernetes.io/role/internal-elb:

aws ec2 create-tags \
  --resources $PRIVATE_SUBNET_ID_1 \
  --tags Key=kubernetes.io/role/internal-elb,Value=1
aws ec2 create-tags \
  --resources $PRIVATE_SUBNET_ID_2 \
  --tags Key=kubernetes.io/role/internal-elb,Value=1
aws ec2 create-tags \
  --resources $PRIVATE_SUBNET_ID_3 \
  --tags Key=kubernetes.io/role/internal-elb,Value=1

A seguir

Crie chaves KMS da AWS.