Criar uma VPC AWS

O GKE na AWS é executado em uma Nuvem Privada Virtual (VPC) da AWS. Esta página explica como configurar uma nova VPC para o seu cluster.

O GKE na AWS cria e gerencia recursos dentro da VPC que você especificar. Você também precisa 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 do Kubernetes Service

Esta página é para especialistas em redes que desejam instalar, configurar e oferecer suporte a equipamentos de rede. Para saber mais sobre funções comuns e exemplos de tarefas que mencionamos em Google Cloud conteúdo, consulte Funções e tarefas comuns do usuário do GKE Enterprise .

Exemplo de VPC

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

O diagrama a seguir mostra o exemplo de VPC que você cria ao seguir estas etapas:

Exemplo de VPC

  • 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 , elas podem ser definidas como us-east-1a , us-east-1b e us-east-1c .

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

  • Réplicas do plano de controle e pontos de extremidade do balanceador de carga, bem como pools de nós, são criados nas sub-redes privadas.

  • Sub-redes públicas fornecem acesso de saída à Internet para sub-redes privadas e pontos de extremidade do balanceador de carga público.

  • Todas essas sub-redes são marcadas para descoberta automática de sub-redes . Balanceadores de carga internos serão provisionados nas sub-redes privadas e balanceadores de carga voltados para a Internet nas sub-redes públicas.

Crie sua VPC

  1. Escolha um prefixo e edite a variável de página AMC_PREFIX no comando abaixo para defini-la com o prefixo escolhido. Os comandos de exemplo abaixo anexarão automaticamente esse prefixo a todas as referências à sua VPC e seus recursos.

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

    • AWS_REGION : o nome da região AWS com suporte para criar a VPC
    • AMC_PREFIX : o prefixo do nome da VPC que você escolheu para sua VPC e seus recursos

  3. Salve seu ID da VPC em uma variável de ambiente e ative o suporte 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

    Você também pode usar configurações de DNS diferentes para sua VPC. Para mais informações, consulte DNS da VPC da AWS .

Sub-redes do plano de controle

Você pode 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 do plano de controle e as distribuirá entre as sub-redes especificadas.

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

Requisitos de sub-rede

As sub-redes devem

  • Ser capaz de resolver endereços DNS
  • Ser capaz de estabelecer conexões TCP de saída na porta 443 para endereços IP roteáveis
  • Ser capaz de se conectar aos seguintes endpoints:
Ponto final Propósito
storage.googleapis.com Para baixar do Cloud Storage durante a instalação
*.gcr.io Para baixar do Container Registry durante a instalação
gkeconnect.googleapis.com Para conectar-se 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 logs para o Cloud Logging
monitoramento.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 registro de auditoria em nuvem

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

Criar sub-redes privadas

Crie três sub-redes privadas em suas 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 o seguinte:

Criar sub-redes públicas

  1. Crie três sub-redes públicas. Elas serão usadas para fornecer acesso de saída à internet 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

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

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

Configurar as tabelas de roteamento 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 padrão para o gateway de 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. 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 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 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 do pool de nós

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

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

  • Atenda aos mesmos requisitos de acesso de saída à Internet que suas sub-redes do plano de controle
  • Tenha espaço de endereço IP suficiente para cobrir o tamanho do pool de nós
  • Não ter a opção "Atribuição automática de IPs públicos" habilitada

As sub-redes privadas criadas anteriormente atendem aos requisitos para sub-redes do plano de controle e sub-redes 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 , marque as sub-redes do balanceador de carga 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 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 vem a seguir

Crie chaves do AWS KMS .