Contrôler la communication avec des adresses IP persistantes

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 votre pod GKE avec un mappage d'adresses IP persistantes 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.31 ou ultérieure.
  • Vous pouvez réserver des 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 des clusters GKE Dataplane V2 et avec l'API Gateway activée.

Limites

  • Vous devez configurer 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 pouvez associer chaque adresse IP persistante à un seul pod à la fois. Lorsque plusieurs pods sont disponibles, GKE envoie généralement le trafic au pod le plus récent correspondant. 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.
  • La prise en charge de la haute disponibilité (HA) à l'aide d'adresses IP persistantes n'est pas disponible pour les cas d'utilisation autres que DPDK.
  • Vous pouvez spécifier jusqu'à 16 adresses IP sur un seul GKEIPRoute. Pour configurer d'autres adresses, vous pouvez créer plusieurs objets GKEIPRoute.

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.

Implémenter des adresses IP persistantes pour les pods GKE

Les adresses IP persistantes dans GKE permettent d'attribuer une identité réseau stable à vos pods, 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:

  1. Créer un cluster: créez un cluster avec l'API Gateway et GKE Dataplane V2.
  2. 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.
  3. 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.
  4. Créez ou identifiez des charges de travail pour les adresses IP persistantes: si vous utilisez des adresses IP persistantes sur un réseau supplémentaire, 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.
  5. 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 le ou les bons pods, et vous pouvez éventuellement configurer la façon dont le routage réagit aux modifications de pod.
  6. Configurer la détection de votre application : configurez votre application dans le pod pour utiliser activement l'adresse IP persistante.
  7. 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 avec l'API Gateway et GKE Dataplane V2 activés

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 créer un cluster GKE Dataplane V2 comme suit:

gcloud container clusters create CLUSTER_NAME \
    --cluster-version=CLUSTER_VERSION \
    --enable-dataplane-v2 \
    --enable-ip-alias \
    --gateway-api=standard

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom du cluster.
  • CLUSTER_VERSION : version du cluster.

Étape 2: Configurer 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 vous assurer que le trafic est correctement acheminé dans votre réseau privé, les adresses IP internes doivent appartenir au sous-réseau par défaut du cluster ou au sous-réseau réseau supplémentaire.

Pour en savoir plus sur les adresses IP externes et internes, ou pour découvrir comment réserver des adresses à l'aide de la console, 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. 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 passerelle contiennent les adresses IP et définissent les pods éligibles à leur utilisation. Pour contrôler la manière dont les adresses IP persistantes sont attribuées à vos pods GKE, vous utiliserez des objets Gateway.

  1. Créez un objet passerelle Kubernetes 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 Clouduniquement).
  2. 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.

  3. Utilisez la section Listeners pour déterminer quels pods (et leurs objets GKEIPRoute associés) peuvent potentiellement 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: (Facultatif) Créer ou identifier des charges de travail avec des réseaux supplémentaires pour les adresses IP persistantes

Si vous prévoyez d'utiliser vos adresses IP persistantes avec des pods qui nécessitent une connectivité à plusieurs réseaux, vous pouvez configurer des pods multiréseaux et créer des objets réseau indiquant les réseaux auxquels l'adresse IP persistante appartient.

Étape 5: Créer 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: default
  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 la valeur par défaut est 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 acheminé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 multiréseau 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 # point to the right network if you intend to use persistent-ip on additional networks
  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:  <- Remove these lines if the pods are not multi-nic pods
      #   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 :

kubectl apply -f my-ip-route.yaml

Assurez-vous que vous disposez d'un réseau nommé "blue-network" si vous utilisez des réseaux supplémentaires.

É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é).

Étape 7: Activez l'ARP pour les adresses IP persistantes (réseau par défaut uniquement)

Pour générer des requêtes et des réponses ARP (Address Resolution Protocol) valides, et pour établir une nouvelle connexion à un pod à l'aide d'une adresse IP persistante sur le réseau par défaut, vous devez configurer la variable ARP_ANNOUNCE.

Pour définir la variable ARP_ANNOUNCE, exécutez la commande suivante sur votre pod:

echo "2" > /proc/sys/net/ipv4/conf/eth0/ARP_ANNOUNCE

où la variable ARP_ANNOUNCE contrôle la gestion des annonces ARP. Si vous définissez cette valeur sur "2", des annonces ARP sont émises pour l'adresse IP persistante, ce qui permet aux autres appareils du réseau de connaître la nouvelle association.

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

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'il détecte une mise à jour, il réattribue automatiquement l'adresse IP persistante à un pod approprié en fonction de l'reactionMode que vous avez choisie.

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 en termes de rapidité d'attribution de l'adresse IP par rapport aux exigences strictes de préparation.
  • 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'est 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 est possible qu'aucun pod ne s'exécutant 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

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

  3. 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.

  4. 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 de l'adresse IP persistante est en cours

Symptôme

L'état GKEIPRoute affiche "Mutated" (Muté), ce qui indique que la configuration de l'adresse IP persistante d'un pod correspondant est en cours.

Cause possible :

L'état "Mutated" (Modifié) s'affiche pendant la configuration, car le système configure le chemin de données GKE et les ressources Google Cloud pour l'adresse IP persistante.

Solution :

  1. Attendez et réessayez:dans la plupart des cas, le processus de configuration se termine automatiquement en peu de temps. Vérifiez l'état après avoir attendu. Il passe à Ready en cas de réussite.
  2. Examiner plus en détail (si nécessaire) : si l'état "Muté" persiste pendant une longue période, cela peut indiquer une erreur de configuration. Examinez les autres conditions d'état de votre GKEIPRoute :
    • Accepté: indique si votre configuration GKEIPRoute est valide.
    • DPV2Ready : indique si le chemin de données du nœud est correctement programmé.
    • GCPReady: indique si les ressources sont configurées comme prévu. Google Cloud

Recherchez les messages d'erreur correspondant à ces conditions pour résoudre le problème.

Étape suivante