Cette page a été traduite par l'API Cloud Translation.

Accéder à des clusters Google Kubernetes Engine privés avec des pools privés Cloud Build

Ce tutoriel explique comment accéder à un cluster privé Google Kubernetes Engine (GKE) à l'aide de pools privés Cloud Build. Cet accès vous permet d'utiliser Cloud Build pour déployer votre application sur un cluster GKE privé. Ce tutoriel est destiné aux administrateurs réseau et s'applique à toutes les situations où les pools privés Cloud Build doivent communiquer avec des services exécutés dans un réseau cloud privé virtuel (VPC) appairé. Par exemple, les travailleurs du pool privé peuvent communiquer avec les services suivants :

Cluster GKE privé
Base de données Cloud SQL
Instance Memorystore
Instance Compute Engine s'exécutant dans un réseau VPC différent de celui appairé avec le pool privé Cloud Build

Les pools privés Cloud Build et les plans de contrôle de cluster GKE s'exécutent tous deux dans des réseaux VPC appartenant à Google. Ces réseaux VPC sont appairés à votre propre réseau VPC sur Google Cloud. Toutefois, l'appairage de réseaux VPC n'est pas compatible avec l'appairage transitif, ce qui peut être une restriction lors de l'utilisation de pools privés Cloud Build. Ce tutoriel présente une solution qui utilise Cloud VPN pour permettre aux nœuds de calcul d'un pool privé Cloud Build d'accéder au plan de contrôle d'un cluster GKE privé.

Dans ce tutoriel, nous partons du principe que vous connaissez Google Kubernetes Engine, Cloud Build, la commande gcloud, l'appairage de réseaux VPC et Cloud VPN.

Présentation de l'architecture

Lorsque vous créez un cluster GKE privé sans accès client au point de terminaison public, les clients ne peuvent accéder au plan de contrôle du cluster GKE qu'à l'aide de son adresse IP privée. Les clients tels que kubectl ne peuvent communiquer avec le plan de contrôle que s'ils s'exécutent sur une instance ayant accès au réseau VPC et se trouvant sur un réseau autorisé.

Si vous souhaitez utiliser Cloud Build pour déployer votre application sur ce cluster GKE privé, vous devez utiliser des pools privés Cloud Build pour accéder aux clusters GKE. Les pools privés sont un ensemble d'instances de nœuds de calcul qui s'exécutent dans un projet Google Cloud appartenant à Google et qui sont appairées à votre réseau VPC à l'aide d'une connexion d'appairage de réseaux VPC. Dans cette configuration, les instances de nœud de calcul sont autorisées à communiquer avec l'adresse IP privée du plan de contrôle du cluster GKE.

Toutefois, le plan de contrôle du cluster GKE s'exécute également du projet appartenant à Google et se connecte à votre réseau VPC via Private Service Connect (PSC) : L'appairage de réseaux VPC n'est pas compatible avec l'appairage transitif. Par conséquent, les paquets ne peuvent pas être acheminés directement entre le pool privé Cloud Build et le plan de contrôle du cluster GKE.

Pour permettre aux instances de nœuds de calcul Cloud Build d'accéder au plan de contrôle des clusters GKE, vous pouvez appairer le pool privé et utiliser PSC pour connecter le plan de contrôle du cluster GKE à deux réseaux VPC que vous possédez, puis connecter ces deux réseaux VPC en utilisant Cloud VPN. Cet appairage et cette connexion permettent à chaque côté du tunnel VPC d'annoncer les pools privés et les réseaux de plans de contrôle du cluster GKE, complétant ainsi la route.

Le schéma d'architecture suivant présente les ressources utilisées dans ce tutoriel :

Tunnel VPN complétant la route entre le pool privé Cloud Build et le plan de contrôle du cluster GKE.

Nous vous recommandons de créer toutes les ressources utilisées dans ce tutoriel région Google Cloud pour une faible latence. Le tunnel VPN peut traverser deux régions différentes si cette communication interrégionale est nécessaire pour votre implémentation. Les deux réseaux VPC que vous possédez peuvent également appartenir à des projets différents.

Objectifs

Créez un cluster GKE privé.
Configurez un pool privé Cloud Build.
Créez une connexion VPN haute disponibilité entre deux réseaux VPC.
Activez le routage des paquets sur deux appairages de réseaux VPC et une connexion VPC.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.
Enable the Cloud Build, Google Kubernetes Engine, and Service Networking APIs.
Enable the APIs
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Créer deux réseaux VPC dans votre propre projet

Dans cette section, vous allez créer deux réseaux VPC et un sous-réseau pour les nœuds de cluster GKE.

Dans Cloud Shell, créez le premier réseau VPC (appelé "Réseau VPC d'appairage de pool privé" dans le schéma précédent). Vous n'avez pas besoin de créer de sous-réseaux dans ce réseau.
```
gcloud compute networks create PRIVATE_POOL_PEERING_VPC_NAME \
    --subnet-mode=CUSTOM
```
Remplacez PRIVATE_POOL_PEERING_VPC_NAME par le nom de votre réseau VPC à appairer au réseau du pool privé Cloud Build.
Créez le deuxième réseau VPC (appelé "Réseau VPC du cluster GKE" dans diagramme précédent):
```
gcloud compute networks create GKE_CLUSTER_VPC_NAME \
    --subnet-mode=CUSTOM
```
Remplacez GKE_CLUSTER_VPC_NAME par le nom de votre réseau VPC à appairer au plan de contrôle du cluster GKE.
Créez un sous-réseau pour les nœuds de cluster GKE :
```
gcloud compute networks subnets create GKE_SUBNET_NAME \
    --network=GKE_CLUSTER_VPC_NAME \
    --range=GKE_SUBNET_RANGE \
    --region=REGION
```
Remplacez les éléments suivants :
- GKE_SUBNET_NAME : nom du sous-réseau destiné à héberger les nœuds du cluster GKE.
- GKE_CLUSTER_VPC_NAME: nom de votre pour vous connecter au réseau VPC plan de contrôle du cluster GKE.
- GKE_SUBNET_RANGE : plage d'adresses IP de GKE_SUBNET_NAME. Pour ce tutoriel, vous pouvez utiliser 10.244.252.0/22.
- REGION : région Google Cloud hébergeant le cluster GKE. Pour ce tutoriel, vous pouvez utiliser us-central1.

Vous avez maintenant configuré deux réseaux VPC dans votre propre projet, et ils sont prêts à être appairés à d'autres services.

Créer un cluster GKE privé

Dans cette section, vous allez créer le cluster GKE privé.

Dans Cloud Shell, créez un cluster GKE sans accès client au point de terminaison public du plan de contrôle.
```
gcloud container clusters create PRIVATE_CLUSTER_NAME \
    --region=REGION \
    --enable-master-authorized-networks \
    --network=GKE_CLUSTER_VPC_NAME \
    --subnetwork=GKE_SUBNET_NAME \
    --enable-private-nodes \
    --enable-private-endpoint \
    --enable-ip-alias \
    --master-ipv4-cidr=CLUSTER_CONTROL_PLANE_CIDR
```
Remplacez les éléments suivants :
- PRIVATE_CLUSTER_NAME : nom du cluster GKE privé.
- REGION : région du cluster GKE. Dans ce tutoriel, utilisez la région us-central1, qui est la même que celle que vous avez utilisée pour les réseaux VPC.
- GKE_CLUSTER_VPC_NAME : nom de votre réseau VPC à connecter au plan de contrôle du cluster GKE.
- GKE_SUBNET_RANGE : plage d'adresses IP de GKE_SUBNET_NAME. Pour ce tutoriel, vous pouvez utiliser 10.244.252.0/22.
- CLUSTER_CONTROL_PLANE_CIDR : plage d'adresses IP du plan de contrôle du cluster GKE. Elle doit comporter le préfixe /28. Pour ce tutoriel, utilisez 172.16.0.32/28.
  
  Remarque : L'option "--enabled-private-endpoint" permet à Cloud Build de se connecter en interne au cluster GKE. Si vous créez cluster GKE dans la console Cloud, pensez à décocher Accédez au plan de contrôle à l'aide de son adresse IP externe.
Vous avez maintenant créé un cluster GKE privé.

Configurer l'appairage de réseaux VPC pour GKE 1.28 et versions antérieures

Si vous utilisez ce tutoriel pour configurer un cluster existant exécutant GKE version 1.28 ou antérieure, votre réseau VPC privé utilise Appairage de réseaux VPC pour se connecter au cluster GKE. Procédez comme suit :

Récupérez le nom de l'appairage de réseau VPC du cluster GKE. Cet appairage de réseau VPC a été généré automatiquement lors de la création du cluster GKE.
```
export GKE_PEERING_NAME=$(gcloud container clusters describe PRIVATE_CLUSTER_NAME \
    --region=REGION \
    --format='value(privateClusterConfig.peeringName)')
```
Remplacez les éléments suivants :
- PRIVATE_CLUSTER_NAME : nom du cluster GKE privé.
- REGION : région du cluster GKE. Dans ce tutoriel, utilisez la région us-central1, qui est la même que celle que vous avez utilisée pour les réseaux VPC.
Activez l'exportation de routes personnalisées afin d'annoncer le réseau de pool privé au plan de contrôle du cluster GKE :
```
gcloud compute networks peerings update $GKE_PEERING_NAME \
    --network=GKE_CLUSTER_VPC_NAME \
    --export-custom-routes \
    --no-export-subnet-routes-with-public-ip
```
Remplacez GKE_CLUSTER_VPC_NAME par le nom de votre Réseau VPC à se connecter au cluster GKE plan de contrôle.

Pour plus d'informations sur les routes personnalisées, consultez la section Importer et exporter des routes personnalisées.

Créer un pool privé Cloud Build

Dans cette section, vous allez créer le pool privé Cloud Build.

Dans Cloud Shell, allouez une plage d'adresses IP nommée dans le réseau VPC PRIVATE_POOL_PEERING_VPC_NAME pour le pool privé Cloud Build :
```
gcloud compute addresses create RESERVED_RANGE_NAME \
    --global \
    --purpose=VPC_PEERING \
    --addresses=PRIVATE_POOL_NETWORK \
    --prefix-length=PRIVATE_POOL_PREFIX \
    --network=PRIVATE_POOL_PEERING_VPC_NAME
```
Remplacez les éléments suivants :
- RESERVED_RANGE_NAME : nom de la plage d'adresses IP privées qui héberge le pool privé Cloud Build
- PRIVATE_POOL_NETWORK : première adresse IP de RESERVED_RANGE_NAME. Pour ce tutoriel, vous pouvez utiliser 192.168.0.0.
- PRIVATE_POOL_PREFIX : préfixe de RESERVED_RANGE_NAME. Chaque pool privé créé utilisera le paramètre /24 de cette plage. Pour ce tutoriel, vous pouvez utiliser 20, ce qui vous permet de créer jusqu'à 16 pools.
- PRIVATE_POOL_PEERING_VPC_NAME : nom de votre réseau VPC à appairer au réseau du pool privé Cloud Build.
- La plage d'adresses IP est global, car lorsque --purpose est VPC_PEERING, la plage d'adresses IP nommée doit être global.
Créez une connexion privée entre le réseau VPC contenant le pool privé Cloud Build et PRIVATE_POOL_PEERING_VPC_NAME :
```
gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=RESERVED_RANGE_NAME \
    --network=PRIVATE_POOL_PEERING_VPC_NAME
```
Remplacez les éléments suivants :
- RESERVED_RANGE_NAME : nom de la plage d'adresses IP privées qui héberge le pool privé Cloud Build
- PRIVATE_POOL_PEERING_VPC_NAME : nom de votre réseau VPC à appairer au réseau du pool privé Cloud Build.
Activez l'exportation de routes personnalisées afin d'annoncer le réseau du plan de contrôle du cluster GKE au pool privé :
```
gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=PRIVATE_POOL_PEERING_VPC_NAME \
    --export-custom-routes \
    --no-export-subnet-routes-with-public-ip
```
Remplacez PRIVATE_POOL_PEERING_VPC_NAME par le nom de votre réseau VPC à appairer avec Cloud Build réseau de pool privé privé.
Créez un pool privé Cloud Build qui est associé à PRIVATE_POOL_PEERING_VPC_NAME :
```
gcloud builds worker-pools create PRIVATE_POOL_NAME \
   --region=REGION \
   --peered-network=projects/$GOOGLE_CLOUD_PROJECT/global/networks/PRIVATE_POOL_PEERING_VPC_NAME
```
Remplacez les éléments suivants :
- PRIVATE_POOL_NAME : nom du pool privé Cloud Build.
- REGION : région du cluster GKE. Dans ce tutoriel, utilisez la région us-central1, qui est la même que celle que vous avez utilisée pour les réseaux VPC.

Vous avez maintenant créé un pool privé Cloud Build et l'avez appairé au réseau VPC dans votre propre projet.

Créer une connexion Cloud VPN entre deux réseaux VPC

Dans votre propre projet, vous disposez désormais d'un réseau VPC appairé avec le pool privé Cloud Build et d'un deuxième réseau VPC appairé avec le cluster GKE privé.

Dans cette section, vous allez créer une connexion Cloud VPN entre les deux réseaux VPC de votre projet. Cette connexion complète la route et permet aux pools privés Cloud Build d'accéder au cluster GKE.

Dans Cloud Shell, créez deux passerelles VPN haute disponibilité connectées entre elles. Pour créer ces passerelles, suivez les instructions de la section Créer deux passerelles VPN haute disponibilité entièrement configurées qui se connectent l'une à l'autre. La configuration est terminée après la création des sessions BGP. Dans le cadre de ces instructions, utilisez les valeurs suivantes :
- PRIVATE_POOL_PEERING_VPC_NAME pour NETWORK_1
- GKE_CLUSTER_VPC_NAME pour NETWORK_2
- REGION pour REGION_1 et REGION_2

Configurez chacune des quatre sessions BGP que vous avez créées pour annoncer les routes au réseau VPC du pool privé et au réseau VPC du plan de contrôle du cluster GKE :

gcloud compute routers update-bgp-peer ROUTER_NAME_1 \
    --peer-name=PEER_NAME_GW1_IF0 \
    --region=REGION \
    --advertisement-mode=CUSTOM \
    --set-advertisement-ranges=PRIVATE_POOL_NETWORK/PRIVATE_POOL_PREFIX

gcloud compute routers update-bgp-peer ROUTER_NAME_1 \
    --peer-name=PEER_NAME_GW1_IF1 \
    --region=REGION \
    --advertisement-mode=CUSTOM \
    --set-advertisement-ranges=PRIVATE_POOL_NETWORK/PRIVATE_POOL_PREFIX

gcloud compute routers update-bgp-peer ROUTER_NAME_2 \
    --peer-name=PEER_NAME_GW2_IF0 \
    --region=REGION \
    --advertisement-mode=CUSTOM \
    --set-advertisement-ranges=CLUSTER_CONTROL_PLANE_CIDR

gcloud compute routers update-bgp-peer ROUTER_NAME_2 \
    --peer-name=PEER_NAME_GW2_IF1 \
    --region=REGION \
    --advertisement-mode=CUSTOM \
    --set-advertisement-ranges=CLUSTER_CONTROL_PLANE_CIDR

Où les valeurs suivantes sont identiques à celles que vous avez utilisées lors de la création des deux passerelles VPN haute disponibilité :

ROUTER_NAME_1
PEER_NAME_GW1_IF0
PEER_NAME_GW1_IF1
ROUTER_NAME_2
PEER_NAME_GW2_IF0
PEER_NAME_GW2_IF1

Activer l'accès Cloud Build au plan de contrôle du cluster GKE

Maintenant que vous disposez d'une connexion VPN entre les deux réseaux VPC de votre projet, activez l'accès Cloud Build au plan de contrôle des clusters GKE.

Dans Cloud Shell, ajoutez la plage de réseaux du pool privé aux réseaux autorisés du plan de contrôle dans GKE :
```
gcloud container clusters update PRIVATE_CLUSTER_NAME \
    --enable-master-authorized-networks \
    --region=REGION \
    --master-authorized-networks=PRIVATE_POOL_NETWORK/PRIVATE_POOL_PREFIX
```
Remplacez les éléments suivants :
- PRIVATE_CLUSTER_NAME : nom du cluster GKE privé.
- REGION : région du cluster GKE. Dans ce tutoriel, utilisez la région us-central1, qui est la même que celle que vous avez utilisée pour les réseaux VPC.
- PRIVATE_POOL_NETWORK : première adresse IP de RESERVED_RANGE_NAME. Pour ce tutoriel, vous pouvez utiliser 192.168.0.0.
- PRIVATE_POOL_PREFIX : préfixe de RESERVED_RANGE_NAME. Chaque pool privé créé utilisera le paramètre /24 de cette plage. Pour ce tutoriel, vous pouvez utiliser 20, ce qui vous permet de créer jusqu'à 16 pools.

Autorisez le compte de service que vous utilisez pour la compilation à accéder au plan de contrôle du cluster GKE :

export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format 'value(projectNumber)')

gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member=serviceAccount:SERVICE_ACCOUNT \
    --role=roles/container.developer

Les pools privés Cloud Build peuvent désormais accéder au plan de contrôle du cluster GKE.

Valider la solution

Dans cette section, vous allez vérifier que la solution fonctionne en exécutant la commande kubectl get nodes dans une étape de compilation exécutée dans le pool privé.

Dans Cloud Shell, créez un dossier temporaire avec un fichier de configuration Cloud Build qui exécute la commande kubectl get nodes :
```
mkdir private-pool-test && cd private-pool-test

cat > cloudbuild.yaml <<EOF
steps:
- name: "gcr.io/cloud-builders/kubectl"
  args: ['get', 'nodes']
  env:
  - 'CLOUDSDK_COMPUTE_REGION=REGION'
  - 'CLOUDSDK_CONTAINER_CLUSTER=PRIVATE_CLUSTER_NAME'
options:
  workerPool:
    'projects/$GOOGLE_CLOUD_PROJECT/locations/REGION/workerPools/PRIVATE_POOL_NAME'
EOF
```
Remplacez les éléments suivants :
- REGION : région du cluster GKE. Dans ce tutoriel, utilisez la région us-central1, qui est la même que celle que vous avez utilisée pour les réseaux VPC.
- PRIVATE_CLUSTER_NAME : nom du cluster GKE privé.
- PRIVATE_POOL_NAME : nom du pool privé Cloud Build.

Démarrez la tâche de compilation :

gcloud builds submit --config=cloudbuild.yaml

Vérifiez que la sortie correspond à la liste des nœuds du cluster GKE. Le journal de compilation affiché dans la console inclut un tableau semblable à celui-ci :

NAME                                     STATUS   ROLES    AGE   VERSION
gke-private-default-pool-3ec34262-7lq9   Ready    <none>   9d    v1.19.9-gke.1900
gke-private-default-pool-4c517758-zfqt   Ready    <none>   9d    v1.19.9-gke.1900
gke-private-default-pool-d1a885ae-4s9c   Ready    <none>   9d    v1.19.9-gke.1900

Vous avez maintenant vérifié que les nœuds de calcul du pool privé peuvent accéder au cluster GKE. Cet accès vous permet d'utiliser Cloud Build pour déployer votre application sur ce cluster GKE privé.

Dépannage

Si vous rencontrez des problèmes avec ce tutoriel, consultez les documents suivants :

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Supprimer les ressources individuelles

Dans Cloud Shell, supprimez le cluster GKE :
```
gcloud container clusters delete PRIVATE_CLUSTER_NAME \
    --region=REGION \
    --async
```
Lorsque vous exécutez cette commande, l'appairage de réseaux VPC est automatiquement supprimé.

Supprimez le pool privé Cloud Build :

gcloud builds worker-pools delete PRIVATE_POOL_NAME \
    --region=REGION

Supprimez la connexion privée entre le réseau VPC du producteur de services et PRIVATE_POOL_PEERING_VPC_NAME :
```
gcloud services vpc-peerings delete \
   --network=PRIVATE_POOL_PEERING_VPC_NAME \
   --async
```

Supprimez la plage d'adresses IP nommée utilisée pour le pool privé :

gcloud compute addresses delete RESERVED_RANGE_NAME \
    --global

Supprimez les quatre tunnels VPN. Utilisez les noms que vous avez spécifiés dans Créer des tunnels VPN.

gcloud compute vpn-tunnels delete \
    TUNNEL_NAME_GW1_IF0 \
    TUNNEL_NAME_GW1_IF1 \
    TUNNEL_NAME_GW2_IF0 \
    TUNNEL_NAME_GW2_IF1 \
    --region=REGION

Supprimez les deux routeurs cloud. Utilisez les noms que vous avez spécifiés dans Créer des routeurs cloud.

gcloud compute routers delete \
    ROUTER_NAME_1 \
    ROUTER_NAME_2 \
    --region=REGION

Supprimez les deux passerelles VPN. Utilisez les noms que vous avez spécifiés dans Créer des passerelles VPN haute disponibilité.
```
gcloud compute vpn-gateways delete \
    GW_NAME_1 \
    GW_NAME_2 \
    --region=REGION
```
Supprimez GKE_SUBNET_NAME, qui est le sous-réseau qui héberge les nœuds du cluster GKE :
```
gcloud compute networks subnets delete GKE_SUBNET_NAME \
    --region=REGION
```

Supprimez les deux réseaux VPC PRIVATE_POOL_PEERING_VPC_NAME et GKE_CLUSTER_VPC_NAME :

gcloud compute networks delete \
    PRIVATE_POOL_PEERING_VPC_NAME \
    GKE_CLUSTER_VPC_NAME

Étape suivante

Découvrez comment exécuter des compilations dans un pool privé.
Exécutez un proxy dans le cluster GKE privé qui a accès au plan de contrôle.
Découvrez comment déployer sur GKE à partir de Cloud Build.
Testez d'autres fonctionnalités de Google Cloud. Découvrez nos tutoriels.