Accéder à des clusters Google Kubernetes Engine privés à l'aide de 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 dans un projet appartenant à Google et est appairé à votre réseau VPC à l'aide d'une connexion d'appairage. 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 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 dans la même région Google Cloud afin d'obtenir 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

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Activer les API Cloud Build, Google Kubernetes Engine, and Service Networking.
Activer les API
Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

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 d'appairage GKE" dans le schéma ci-dessus) :
```
gcloud compute networks create GKE_PEERING_VPC_NAME \
    --subnet-mode=CUSTOM
```
Remplacez GKE_PEERING_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_PEERING_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_PEERING_VPC_NAME: nom du réseau VPC à appairer avec le 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. Ils sont prêts à être appairés avec 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_PEERING_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_PEERING_VPC_NAME: nom du réseau VPC à appairer avec le 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 le cluster GKE dans Cloud Console, veillez à décocher Accéder au plan de contrôle à l'aide de son adresse IP externe.
Vous avez maintenant créé un cluster GKE privé appairé au réseau VPC de votre propre projet.
Récupérez le nom de l'appairage de réseaux 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_PEERING_VPC_NAME \
    --export-custom-routes \
    --no-export-subnet-routes-with-public-ip
```
Remplacez GKE_PEERING_VPC_NAME par le nom du réseau VPC à appairer avec le plan de contrôle du cluster GKE.

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 du réseau VPC à appairer avec le réseau de 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 du réseau VPC à appairer avec le réseau de 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 du réseau VPC à appairer avec le réseau de pool privé Cloud Build.
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_PEERING_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 Cloud Build à 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:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
    --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 :

Effectuer un nettoyage

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 aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez é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.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

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_PEERING_VPC_NAME :

gcloud compute networks delete \
    PRIVATE_POOL_PEERING_VPC_NAME \
    GKE_PEERING_VPC_NAME

Étapes suivantes

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.