Contrôler la communication avec des adresses IP persistantes sur les pods

Standard

Cette page explique comment implémenter des adresses IP persistantes sur les pods Google Kubernetes Engine (GKE). Vous pouvez contrôler la mise en réseau de vos pods GKE avec un mappage d'adresses IP persistant personnalisé. Pour en savoir plus sur les adresses IP persistantes, leurs cas d'utilisation et leurs avantages, consultez la section À propos des adresses IP persistantes pour les pods GKE.

Conditions requises

GKE version 1.29 ou ultérieure.
Choisissez entre réserver des adresses IP fournies par Google (adresses IP fournies par Google) ou utiliser vos propres adresses IP (BYOIP).
Configurez votre application exécutée dans les pods pour qu'elle reconnaisse et utilise les adresses IP persistantes attribuées.
Les adresses IP persistantes pour les pods GKE nécessitent GKE Dataplane V2 et des clusters avec multiréseau activé.

Limites

Le réseau par défaut n'est pas compatible avec les adresses IP persistantes. Vous devez activer le multiréseau lors de la création du cluster.
Configurez vos applications pour qu'elles utilisent des adresses IP persistantes attribuées. GKE n'ajoute pas automatiquement la configuration de l'adresse IP aux interfaces réseau du pod.
Vous ne pouvez associer chaque adresse IP persistante qu'à un seul pod à la fois. Lorsque plusieurs pods sont disponibles, GKE envoie généralement le trafic au pod le plus récent. Toutefois, GKE ne le fait que si le pod le plus récent est opérationnel, ce qui signifie que l'état de la condition Ready est True par défaut. Vous pouvez configurer et modifier ce comportement à l'aide du paramètre reactionMode sur GKEIPRoute.
GKE n'accepte que les adresses IPv4 comme adresses IP persistantes.
GKE n'est compatible qu'avec les multiréseaux de couche 3 ou de type d'appareil pour les adresses IP persistantes.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Activer GKE Enterprise
En savoir plus sur les adresses IP.
Passez en revue les conditions requises et les limites.

Tarifs

Les fonctionnalités de l'optimiseur de fonction réseau (NFO) suivantes ne sont disponibles que sur les clusters qui se trouvent dans des projets activés avec GKE Enterprise :

Pour connaître les frais qui s'appliquent en cas d'activation de l'édition Enterprise de Google Kubernetes Engine (GKE), consultez les tarifs de GKE Enterprise.

Implémenter des adresses IP persistantes pour les pods GKE

Les adresses IP persistantes dans GKE permettent de donner à vos pods une identité réseau stable, même si les pods eux-mêmes sont mis à jour ou déplacés.

Cette section résume le workflow d'implémentation des adresses IP persistantes pour les pods GKE :

Créer un cluster : créez un cluster sur lequel l'API Gateway, GKE Dataplane V2 et le multiréseau sont activés.
Réserver une adresse IP : décidez si vous avez besoin d'une adresse IP externe (accessible publiquement) ou interne (Google Cloud uniquement) et réservez-la. Choisissez la même région que votre cluster GKE.
Créer une passerelle : configurez l'objet de passerelle Kubernetes qui contient vos adresses IP persistantes réservées et vous permet de créer des règles (GKEIPRoutes) sur les pods de votre cluster qui peuvent utiliser ces adresses IP persistantes.
Créez ou identifiez des charges de travail avec des réseaux supplémentaires pour les adresses IP persistantes : préparez les pods à utiliser des adresses IP persistantes en activant plusieurs interfaces réseau et en définissant le réseau sur lequel se trouvent les adresses IP persistantes.
Créer l'objet GKEIPRoute pour les charges de travail sélectionnées : configurez GKEIPRoute pour attribuer l'adresse IP persistante à un pod spécifique. Vous pouvez utiliser des libellés pour cibler les pods appropriés et éventuellement configurer la manière dont le routage réagit aux modifications apportées aux pods.
Configurer la détection de votre application : configurez votre application dans le pod pour utiliser activement l'adresse IP persistante.
Surveillance : suivez l'état de votre passerelle et de vos objets GKEIPRoute pour vous assurer que tout fonctionne comme prévu.

Pour implémenter une adresse IP persistante pour les pods GKE, procédez comme suit :

Étape 1 : Créer un cluster GKE Dataplane V2 et multiréseau activé

Pour activer les fonctionnalités avancées de routage réseau et de gestion des adresses IP nécessaires à la mise en œuvre d'adresses IP persistantes sur les pods GKE, vous devez create un cluster GKE Dataplane V2 et multiréseau activé.

Étape 2 : Réserver des adresses IP persistantes

Pour établir des identités réseau fiables pour vos pods et configurer des adresses IP persistantes, vous devez d'abord acquérir des adresses IP persistantes. Vous pouvez choisir de réserver des adresses IP fournies par Google ou d'utiliser vos propres adresses (BYOIP).

Étape 2a : Réserver les adresses IP fournies par Google

Pour réserver des adresses IP externes, exécutez la commande suivante :

gcloud compute addresses create ADDRESS_NAME \
   --region=REGION

Remplacez les éléments suivants :

ADDRESS_NAME : nom que vous souhaitez associer à cette adresse.
REGION : région dans laquelle vous souhaitez réserver cette adresse. Il doit s'agir de la même région que le pod auquel vous souhaitez associer l'adresse IP.

Remarque : Vous devez spécifier une région lorsque vous réservez une adresse IP, car les règles de transfert, qui gèrent le routage du trafic pour les adresses IP persistantes, sont régionales. Votre adresse IP et votre cluster GKE doivent se trouver dans la même région pour que le routage fonctionne correctement.

Pour réserver des adresses IP internes, exécutez la commande suivante :

gcloud compute addresses create ADDRESS_NAME \
    --region REGION
    --subnet SUBNETWORK \
    --addresses IP_ADDRESS

Remplacez les éléments suivants :

ADDRESS_NAME : nom d'une ou de plusieurs adresses que vous souhaitez réserver. Dans le cas de plusieurs adresses, spécifiez toutes les adresses sous forme de liste, séparées par des espaces. Par exemple : example-address-1 example-address-2 example-address-3
REGION : région de la requête.
SUBNETWORK : sous-réseau de l'adresse IPv4 interne.

Pour que le trafic soit correctement acheminé au sein de votre réseau privé, les adresses IP internes doivent appartenir à un sous-réseau désigné.

Pour en savoir plus sur les adresses IP externes et internes, consultez les pages Réserver une adresse IP externe statique et Réserver une adresse IP interne statique.

Étape 2b : Utilisez vos propres adresses IP (BYOIP)

Vous pouvez utiliser vos propres adresses IP (BYOIP) au lieu de vous fier aux adresses IP fournies par Google. La fonctionnalité BYOIP est utile si vous avez besoin d'adresses IP spécifiques pour vos applications ou si vous transférez des systèmes existants vers Google Cloud. Pour utiliser BYOIP, Google vérifie que vous êtes le propriétaire de la plage d'adresses IP. Une fois les adresses IP importées dans Google Cloud, vous pouvez les attribuer en tant qu'adresses IP persistantes pour les pods GKE. Pour en savoir plus, consultez la section Utiliser vos propres adresses IP.

Étape 3 : Créer des objets Gateway

Les objets Gateway contiennent les adresses IP et définissent les pods pouvant les utiliser. Pour contrôler la manière dont les adresses IP persistantes sont attribuées à vos pods GKE, vous utiliserez des objets Gateway.

Créez un objet Kubernetes Gateway de la classe appropriée :
- gke-persistent-regional-external-managed pour les adresses IP externes (publiques).
- gke-persistent-regional-internal-managed pour les adresses IP internes (Google Cloud uniquement).
Dans la section des adresses de la passerelle, répertoriez les adresses IP persistantes (fournies par Google ou BYOIP) gérées par cette passerelle.
Utilisez la section Listeners pour déterminer quels pods (et les objets GKEIPRoute associés) peuvent utiliser les adresses IP de la passerelle. Listeners agit comme un filtre en fonction de l'espace de noms de GKEIPRoute où un objet GKEIPRoute existe.

Vous pouvez choisir l'une des options de sélection d'espace de noms Kubernetes suivantes :
- Tous les espaces de noms : tous les GKEIPRoute du cluster.
- Sélecteur : GKEIPRoute dans les espaces de noms de GKEIPRoute correspondant à un libellé spécifique.
- Même espace de noms : uniquement GKEIPRoutes dans l'espace de noms de la même GKEIPRoute que la passerelle.

L'exemple suivant fournit un accès au niveau du cluster aux adresses IP externes persistantes, ce qui permet à n'importe quel pod de les utiliser.

Enregistrez l'exemple de fichier manifeste suivant sous le nom allowed-pod-ips.yaml :

kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  namespace: default
  name: allowed-pod-ips
spec:
  gatewayClassName: gke-persistent-regional-external-managed

  listeners:
    - name: default
      port: 443
      protocol: none
      allowedRoutes:
        namespaces:
          from: All

  addresses:
    - value: "34.123.10.1/32"
      type: "gke.networking.io/cidr"
    - value: "34.123.10.2/32"
      type: "gke.networking.io/cidr"

où :

addresses : répertorie toutes les adresses IP dont les autorisations sont gérées par la passerelle spécifique.
listeners : permet d'identifier les espaces de noms à partir desquels les objets GKEIPRoute peuvent faire référence à cette passerelle.

Appliquez le fichier manifeste au cluster :

kubectl apply -f allowed-pod-ips.yaml

Étape 4 : Créer ou identifier des charges de travail avec des réseaux supplémentaires pour les adresses IP persistantes

Configurez des pods multiréseaux et créez des objets réseau indiquant les réseaux auxquels l'adresse IP persistante appartient.

Étape 5 : Créez l'objet `GKEIPRoute` pour les charges de travail sélectionnées

Pour attribuer une adresse IP persistante à un pod sélectionné, créez un objet GKEIPRoute.

Enregistrez l'exemple de fichier manifeste suivant sous le nom my-ip-route.yaml :

kind: GKEIPRoute
apiVersion: networking.gke.io/v1
metadata:
  namespace: default
  name: my-ip-route
spec:
  parentRefs:
  - name: allowed-pod-ips
    namespace: default
  addresses:
  - value: "34.123.10.1/32"
    type: "gke.networking.io/cidr"
  network: blue-network
  reactionMode: ReadyCondition
  podSelector: # Only one pod is selected.
    matchLabels:
      component: proxy

où :

parentRefs : pointe vers la passerelle à partir de laquelle les adresses IP persistantes sont utilisées. Ce champ est immuable.
addresses : répertorie toutes les adresses IP persistantes acheminées vers le pod identifié avec podSelector. Ce champ est modifiable. Pour IPv4, seules les adresses /32 sont acceptées.
podSelector : spécifie les libellés qui identifient le pod vers lequel les adresses IP persistantes sont acheminées. Ce champ est modifiable et s'applique au même espace de noms dans lequel GKEIPRoute est placé. Si vous sélectionnez plusieurs pods, deux facteurs supplémentaires sont pris en compte : l'heure de création du pod (GKE sélectionne le plus récent) et la définition du champ reactionMode.
reactionMode : spécifie le comportement de cette fonctionnalité lorsqu'un pod spécifique (sélectionné par podSelector) est créé ou supprimé. Ce champ est facultatif et est défini par défaut sur ReadyCondition. Le champ ReadyCondition est immuable. Vous pouvez définir reactionMode pour contrôler le comportement de la fonctionnalité lorsque des pods sont créés, supprimés ou mis à jour.
network : pointe vers l'interface réseau d'un pod vers laquelle les adresses IP persistantes sont routées. Ce champ est immuable.

Appliquez le fichier manifeste au cluster :

kubectl apply -f my-ip-route.yaml

Attribuer des adresses IP persistantes aux pods StatefulSet

Pour attribuer une adresse IP persistante à un pod spécifique d'un StatefulSet, utilisez le nom d'hôte prévisible du pod et l'ajout automatique de libellés de Kubernetes, comme illustré dans l'exemple suivant :

Enregistrez l'exemple de fichier manifeste suivant sous le nom my-pod-ips.yaml :

kind: GKEIPRoute
apiVersion: networking.gke.io/v1
metadata:
  namespace: proxy-ss-ns
  name: my-pod-ips
spec:
  parentRefs:
  - name: allowed-pod-ips
    namespace: default
  addresses:
  - value: "34.123.10.1/32"
    type: "gke.networking.io/cidr"
  - value: "34.123.10.2/32"
    type: "gke.networking.io/cidr"
  network: blue-network
  reactionMode: ReadyCondition
  podSelector:
    matchLabels:
      statefulset.kubernetes.io/pod-name: proxy-ss-1
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  namespace: proxy-ss-ns
  name: proxy-ss
spec:
  selector:
    matchLabels:
      component: proxy
  serviceName: "proxy"
  replicas: 3
  template:
    metadata:
      annotations:
        networking.gke.io/default-interface: 'eth0'
        networking.gke.io/interfaces: '[{"interfaceName":"eth0","network":"default"}, {"interfaceName":"eth1","network":"blue-network"}]'
      labels:
        component: proxy
    spec:
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

Appliquez le fichier manifeste au cluster (assurez-vous que vous disposez d'un réseau nommé "blue-network") :

kubectl apply -f my-pod-ips.yaml

Attribuer des adresses IP persistantes aux pods de déploiement

Pour attribuer une adresse IP persistante au pod le plus récent d'un déploiement, appliquez un GKEIPRoute avec la configuration suivante :

Enregistrez l'exemple de fichier manifeste suivant sous le nom my-pod-ips.yaml :

kind: GKEIPRoute
apiVersion: networking.gke.io/v1
metadata:
  namespace: proxy-deploy-ns
  name: my-pod-ips
spec:
  parentRefs:
  - name: allowed-pod-ips
    namespace: default
  addresses:
  - value: "34.123.10.1/32"
    type: "gke.networking.io/cidr"
  - value: "34.123.10.2/32"
    type: "gke.networking.io/cidr"
  network: blue-network
  reactionMode: ReadyCondition
  podSelector:
    matchLabels:
      component: proxy
---
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: proxy-deploy-ns
  name: proxy-deploy
spec:
  selector:
    matchLabels:
      component: proxy
  replicas: 4 # Latest Pod is used
  template:
    metadata:
      annotations:
        networking.gke.io/default-interface: 'eth0'
        networking.gke.io/interfaces: '[{"interfaceName":"eth0","network":"default"}, {"interfaceName":"eth1","network":"blue-network"}]'
      labels:
        component: proxy
    spec:
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

Appliquez le fichier manifeste au cluster (assurez-vous que vous disposez d'un réseau nommé "blue-network") :

kubectl apply -f my-ip-route.yaml

Étape 6 : Utiliser des adresses IP persistantes dans le pod

L'attribution d'une adresse IP persistante à un pod GKE à l'aide d'un GKEIPRoute ne rend pas automatiquement les adresses IP utilisables par votre application. Les adresses IP persistantes sont gérées au niveau du routage réseau, mais la configuration par défaut de votre pod n'en est pas consciente. Vous devez configurer la configuration de votre application pour qu'elle reconnaisse et utilise l'adresse dans le pod. Pour ce faire, votre pod aura besoin d'autorisations privilégiées.

Pour configurer votre application, envisagez les options suivantes :

net.ipv4.ip_nonlocal_bind : modifiez un paramètre système pour permettre à votre application d'utiliser des adresses IP qui ne sont pas directement attribuées à son interface.
ip address add : utilisez cette commande dans la logique de votre application pour ajouter manuellement l'adresse IP persistante à une interface.
Sockets bruts : pour un contrôle encore plus précis, votre application peut interagir directement avec la pile réseau (option avancée).
Pile d'adresses IP de l'espace utilisateur : dans des cas spécialisés, une application distincte peut s'exécuter dans le pod pour gérer l'adresse IP (très avancé).

Personnaliser le comportement des adresses IP persistantes lors des modifications de pods

Cette section décrit le comportement de l'adresse IP persistante du pod GKE lorsque le pod ciblé est créé ou supprimé. Le contrôleur GKE surveille vos pods et la configuration GKEIPRoute. Lorsqu'une mise à jour est détectée, il réattribue automatiquement l'adresse IP persistante à un pod approprié en fonction de l'élément reactionMode choisi.

Découvrez comment la fonctionnalité d'adresse IP persistante gère automatiquement les modifications des pods et les options de configuration à votre disposition :

Choisissez entre ReadyCondition ou Exists dans le champ reactionMode de votre configuration GKEIPRoute. Tenez compte des besoins de votre application concernant la rapidité d'attribution de l'adresse IP par rapport aux exigences de préparation strictes.
Si vous utilisez ReadyCondition pour vérifier l'aptitude, assurez-vous que vos pods ont correctement implémenté les vérifications d'aptitude Kubernetes. Sinon, l'adresse IP persistante risque de ne pas fonctionner comme prévu.
Nous vous recommandons de surveiller l'état de vos pods et le champ Conditions de l'objet GKEIPRoute pour vous assurer que le système fonctionne correctement. L'état true de la condition Ready indique que le système fonctionne correctement.

Résoudre les problèmes de communication avec des adresses IP persistantes pour les pods

Cette section explique comment résoudre les problèmes liés aux adresses IP persistantes pour les pods.

`NoPodsFound` lorsqu'aucun pod correspondant n'a été trouvé

Symptôme

L'objet GKEIPRoute spécifie un podSelector (un ensemble de libellés) pour identifier les pods associés à l'adresse IP persistante. L'état NoPodsFound indique qu'aucun pod des espaces de noms GKEIPRoute's ciblés ne porte les libellés correspondants.

Causes probables

Libellés incorrects : le pod avec lequel vous souhaitez utiliser l'adresse IP persistante peut présenter des libellés incorrects, voire aucun libellé.
Aucun pod n'existe : si reactionMode == Exists, vérifiez si le pod est attribué à un nœud en consultant le champ pod.Spec.nodeName. Il se peut qu'aucun pod en cours d'exécution dans l'espace de noms GKEIPRoute's ne corresponde au sélecteur.
Pod not Ready (Pod non prêt) : si la valeur est reactionMode == ReadyCondition, vérifiez si l'état du pod est READY. Même si un pod correspondant existe, s'il n'est pas à l'état Ready, il ne peut pas gérer le trafic et n'est donc pas sélectionné.

Solution

Vérifier vos étiquettes : assurez-vous que les étiquettes de votre podSelector GKEIPRoute's correspondent à celles que vous avez appliquées au pod prévu.
Vérifier l'existence du pod : assurez-vous qu'un pod avec les libellés appropriés existe réellement dans les espaces de noms GKEIPRoute's spécifiés par le Listeners de votre passerelle. Si l'état est reactionMode == Exists, vérifiez si le pod est attribué à un nœud en consultant le champ pod.Spec.nodeName.
Confirmer la disponibilité du pod : si la valeur est reactionMode == ReadyCondition, vérifiez si l'état du pod est READY. Assurez-vous que le pod est à l'état Ready à l'aide de la commande suivante :
```
kubectl get pods -n <namespace>
```
Les pods dans d'autres états (par exemple, "En attente", "Erreur") ne sont pas sélectionnés.
Configurez vos pods pour qu'ils répondent sur l'adresse IP persistante attribuée.

`Mutated` lorsqu'un pod correspondant a été trouvé et que la programmation d'adresse IP persistante est en cours