Créer un VPC AWS

GKE sur AWS s'exécute dans un cloud privé virtuel (VPC) AWS. Cette page explique comment configurer un nouveau VPC pour votre cluster.

GKE sur AWS crée et gère les ressources dans le VPC que vous spécifiez. Vous devez également créer plusieurs sous-réseaux à l'intérieur du VPC :

• Jusqu'à trois sous-réseaux pour les nœuds du plan de contrôle
• Un sous-réseau pour le pool de nœuds
• Sous-réseaux pour les équilibreurs de charge du Service Kubernetes

Exemple de VPC

Suivez les étapes ci-dessous pour configurer le VPC illustré ci-dessous. Pour vos propres cas d'utilisation en production, vous pouvez choisir différentes plages d'adresses IP, zones de disponibilité, sous-réseaux et listes de contrôle d'accès au réseau adaptées à vos charges de travail.

Le schéma suivant illustre l'exemple de VPC que vous créez en procédant comme suit :

• Cet exemple utilise trois zones de disponibilité : Zone de disponibilité 1, Zone de disponibilité 2, Zone de disponibilité 3. Par exemple, pour créer un VPC dans la région us-east-1, ceux-ci peuvent être définis sur us-east-1a, us-east-1b, us-east-1c.

• Dans chacune des trois zones de disponibilité, il existe un sous-réseau public et un sous-réseau privé.

• Les instances dupliquées du plan de contrôle et les points de terminaison de l'équilibreur de charge, ainsi que les pools de nœuds, sont créés dans les sous-réseaux privés.

• Les sous-réseaux publics fournissent un accès Internet sortant aux sous-réseaux privés et aux points de terminaison d'équilibreur de charge public.

• Tous ces sous-réseaux sont marqués pour la détection automatique de sous-réseau. Les équilibreurs de charge internes sont provisionnés dans les sous-réseaux privés et les équilibreurs de charge Web dans les sous-réseaux publics.

Créer votre VPC

1. Choisissez un préfixe et modifiez la variable de page AMC_PREFIX dans la commande ci-dessous pour la définir sur le préfixe que vous avez choisi. Les exemples de commandes ci-dessous associent ensuite automatiquement ce préfixe à toutes les références à votre VPC et à ses ressources.

2. Créez un cloud privé virtuel (VPC) 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}]'
   

   Remplacez les éléments suivants :

   • AWS_REGION : nom de la région AWS compatible dans laquelle créer le VPC.
   • AMC_PREFIX : préfixe du nom du VPC que vous avez choisi pour le VPC et ses ressources.

3. Enregistrez votre ID de VPC dans une variable d'environnement et activez la compatibilité DNS fournie par AWS pour le 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
   

   Vous pouvez également utiliser des paramètres DNS différents pour votre VPC. Pour en savoir plus, consultez la page sur le DNS du VPC AWS.

Sous-réseaux du plan de contrôle

Vous pouvez configurer jusqu'à trois sous-réseaux pour les instances dupliquées du plan de contrôle. Si vous spécifiez moins de trois sous-réseaux, GKE sur AWS crée trois instances dupliquées du plan de contrôle et les distribue entre les sous-réseaux spécifiés.

Les clusters sont privés à votre VPC. L'accès entrant direct aux clusters depuis Internet n'est pas autorisé. GKE sur AWS nécessite un accès Internet limité pour créer et gérer des clusters. Cet exemple utilise une passerelle Internet pour un accès sortant.

Exigences de sous-réseau

Les sous-réseaux doivent respecter les conditions suivantes :

• Être en mesure de résoudre les adresses DNS
• Pouvoir établir des connexions TCP sortantes sur le port 443 vers des adresses IP routables
• Être en mesure de se connecter aux points de terminaison suivants :

Point de terminaison	Usage
storage.googleapis.com	Télécharger des données depuis Cloud Storage lors de l'installation
*.gcr.io	Télécharger des données depuis Container Registry pendant l'installation
gkeconnect.googleapis.com	Se connecter au service de gestion
oauth2.googleapis.com	Pour l'authentification de cluster
sts.googleapis.com	Pour l'authentification de cluster
logging.googleapis.com	Pour envoyer des journaux à Cloud Logging.
monitoring.googleapis.com	Pour envoyer des métriques à Cloud Monitoring.
opsconfigmonitoring.googleapis.com`	Pour envoyer des métadonnées de ressources à Cloud Monitoring
servicecontrol.googleapis.com	Pour Cloud Audit Logging

Si vous ne disposez pas de sous-réseaux pour vos instances de plan de contrôle, utilisez les commandes suivantes pour les créer.

Créer des sous-réseaux privés

Créez trois sous-réseaux privés dans les zones de disponibilité correspondantes :

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

Remplacez les éléments suivants :

• AWS_ZONE_1 : Zone de disponibilité 1
• AWS_ZONE_2 : Zone de disponibilité 2
• AWS_ZONE_3 : Zone de disponibilité 3

Créer des sous-réseaux publics

1. Créez trois sous-réseaux publics. Ils serviront à fournir un accès Internet sortant aux sous-réseaux privés.

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

   Remplacez les éléments suivants :

   • AWS_ZONE_1
   • AWS_ZONE_2
   • AWS_ZONE_3

2. Marquez les sous-réseaux comme publics :

   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
   

Créer une passerelle Internet

1. Créez une passerelle Internet afin que les sous-réseaux publics aient accès à Internet :

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

   Remplacez AWS_REGION : nom de la région AWS dans laquelle votre VPC a été créé.

2. Associez la passerelle Internet à votre 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
   

Configurer les tables de routage pour les sous-réseaux publics

1. Créez une table de routage pour chacun des sous-réseaux publics.

   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. Associez les tables de routage publiques aux sous-réseaux publics :

   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. Créez des routes par défaut vers la passerelle 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. Allouez une adresse IP Elastic (EIP) pour chaque passerelle 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}]'
   

Créer des passerelles NAT

Créez une passerelle NAT dans chacun des trois sous-réseaux publics :

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

Configurer les tables de routage pour les sous-réseaux privés

1. Créez une table de routage pour chaque sous-réseau privé :

   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. Associez les tables de routage privées aux sous-réseaux privés :

   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. Créez les routes par défaut vers les passerelles 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
   

Sous-réseaux de pool de nœuds

Chaque pool de nœuds est placé dans un seul sous-réseau. Vous pouvez placer plusieurs pools de nœuds dans un sous-réseau. Le nombre de nœuds et de pools de nœuds que vous pouvez créer est limité par la plage d'adresses IP disponible dans le sous-réseau.

Chaque sous-réseau de pool de nœuds doit respecter les conditions suivantes :

• Répondre aux mêmes exigences d'accès Internet sortant que vos sous-réseaux de plan de contrôle
• Disposer d'un espace d'adresses IP suffisant pour couvrir la taille du pool de nœuds
• L'option "Attribuer automatiquement des adresses IP publiques" n'est pas activée

Les sous-réseaux privés créés précédemment répondent aux exigences des sous-réseaux du plan de contrôle et des pools de nœuds

Sous-réseaux d'équilibreur de charge du Service

Si vous créez des équilibreurs de charge réseau ou des équilibreurs de charge HTTP, ajoutez un tag aux sous-réseaux d'équilibreur de charge pour la détection automatique.

Ajoutez un tag kubernetes.io/role/elb aux sous-réseaux publics :

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

Ajoutez un tag kubernetes.io/role/internal-elb aux sous-réseaux privés :

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

Étape suivante

Créer des clés KMS AWS