Crie uma VPC da AWS

O GKE on AWS é executado numa nuvem virtual privada (VPC) da AWS. Esta página explica como configurar uma nova VPC para o cluster.

O GKE on AWS cria e gere recursos na VPC que especificar. Também tem de criar várias sub-redes na VPC:

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

Esta página destina-se a especialistas de redes que pretendam instalar, configurar e prestar apoio técnico a equipamentos de rede. Para saber mais sobre as funções comuns e as tarefas de exemplo a que fazemos referência no Google Cloud conteúdo, consulte Funções e tarefas comuns de utilizadores do GKE.

VPC de exemplo

Siga estes passos para configurar a VPC ilustrada abaixo. Para os seus próprios exemplos de utilização de produção, pode escolher diferentes intervalos de IP, zonas de disponibilidade, sub-redes e listas de controlo de acesso à rede adequadas às suas cargas de trabalho.

O diagrama seguinte mostra a VPC de exemplo que cria quando segue estes passos:

• Este exemplo usa três zonas de disponibilidade: Zona de disponibilidade 1, Zona de disponibilidade 2 e Zona de disponibilidade 3. Por exemplo, para criar uma VPC na região us-east-1, estes podem ser definidos como us-east-1a, us-east-1b e us-east-1c.

• Em cada uma das três zonas de disponibilidade, existe uma sub-rede pública e uma sub-rede privada.

• As réplicas do plano de controlo e os pontos finais do balanceador de carga, bem como os node pools, são criados nas sub-redes privadas.

• As sub-redes públicas oferecem acesso à Internet de saída para as sub-redes privadas e os pontos finais do balanceador de carga público.

• Todas estas sub-redes são etiquetadas para a deteção automática de sub-redes. Os balanceadores de carga internos são aprovisionados nas sub-redes privadas e os balanceadores de carga virados para a Internet nas sub-redes públicas.

Crie a sua VPC

1. Escolha um prefixo e edite a variável de página AMC_PREFIX no comando abaixo para a definir como o prefixo que escolheu. Os comandos de exemplo abaixo anexam automaticamente este prefixo a todas as referências à sua VPC e aos respetivos recursos.

2. Crie uma nuvem virtual privada (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 o seguinte:

   • AWS_REGION: o nome da região da AWS suportada para criar a VPC
   • AMC_PREFIX: o prefixo do nome da VPC que escolheu para a sua VPC e os respetivos recursos

3. Guarde o ID da VPC numa variável de ambiente e ative o suporte de 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 pode usar diferentes definições de DNS para a sua VPC. Para mais informações, consulte o artigo DNS da VPC da AWS.

Sub-redes do plano de controlo

Pode configurar até três sub-redes para réplicas do plano de controlo. Se especificar menos de três sub-redes, o GKE no AWS cria três réplicas do plano de controlo e distribui-as pelas sub-redes especificadas.

Os clusters são privados para a sua VPC. Não é permitido o acesso direto de entrada a clusters a partir da Internet. O GKE na AWS requer acesso limitado à Internet de saída para criar e gerir clusters. Este exemplo usa um gateway de Internet para acesso de saída.

Requisitos de sub-rede

As sub-redes têm de

• Conseguir resolver endereços DNS
• Ser capaz de estabelecer ligações TCP de saída na porta 443 a endereços IP encaminháveis
• Conseguir estabelecer ligação aos seguintes pontos finais:

Ponto final	Finalidade
storage.googleapis.com	Para transferir a partir do Cloud Storage durante a instalação
*.gcr.io	Para transferir a partir do Container Registry durante a instalação
gkeconnect.googleapis.com	Para estabelecer ligação ao serviço de gestão
oauth2.googleapis.com	Para a autenticação de clusters
sts.googleapis.com	Para a autenticação de clusters
logging.googleapis.com	Para enviar registos para o Cloud Logging
monitoring.googleapis.com	Para enviar métricas para o Cloud Monitoring
opsconfigmonitoring.googleapis.com`	Para enviar metadados de recursos para o Cloud Monitoring
servicecontrol.googleapis.com	Para o Cloud Audit Logging

Se não tiver sub-redes para as instâncias do plano de controlo, use os seguintes comandos para as criar.

Crie sub-redes privadas

Crie três sub-redes privadas nas respetivas zonas de disponibilidade:

   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 o seguinte:

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

Crie sub-redes públicas

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

   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 o seguinte:

   • AWS_ZONE_1
   • AWS_ZONE_2
   • AWS_ZONE_3

2. 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
   

Crie um gateway de Internet

1. 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 pelo nome da região da AWS onde a sua VPC foi criada.

2. Associe o gateway de Internet à sua 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 encaminhamento para sub-redes públicas

1. 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}]'
   

2. Associe as tabelas de rotas públicas à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
   

3. Crie rotas predefinidas 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
   

4. Atribua um endereço IP elástico (EIP) a cada gateway de 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}]'
   

Crie gateways de NAT

Crie um gateway de 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}]'

Configure as tabelas de encaminhamento para sub-redes privadas

1. Crie uma tabela de rotas para cada sub-rede privada:

   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}]'
   

2. Associe as tabelas de rotas privadas às sub-redes privadas:

   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
   

3. Crie as rotas predefinidas para gateways de 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 do node pool

Cada conjunto de nós é colocado numa única sub-rede. Pode colocar vários conjuntos de nós numa sub-rede. O número de nós e node pools que pode criar é limitado pelo intervalo de endereços IP disponível na sub-rede.

Cada sub-rede do conjunto de nós tem de:

• Satisfazer os mesmos requisitos de acesso à Internet de saída que as suas sub-redes do plano de controlo
• Ter espaço de endereço IP suficiente para abranger a dimensão do conjunto de nós
• Não ter a opção "Atribuir automaticamente IPs públicos" ativada

As sub-redes privadas criadas anteriormente satisfazem os requisitos das sub-redes do plano de controlo e das sub-redes do conjunto de nós.

Sub-redes do balanceador de carga de serviço

Se estiver a criar balanceadores de carga de rede ou balanceadores de carga de HTTP, etiquete as sub-redes do balanceador de carga para a deteção automática.

Etiquete 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

Etiquete as sub-redes privadas 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

O que se segue?

Crie chaves do AWS KMS.