Utiliser le réseau kubenet double pile dans Azure Kubernetes Service (AKS)

Les clusters AKS peuvent désormais être déployés en mode double pile grâce à la mise en réseau kubenet et à un réseau virtuel Azure à double pile. Dans cette configuration, les nœuds reçoivent à la fois une adresse IPv4 et une adresse IPv6 du sous-réseau du réseau virtuel Azure. Les pods reçoivent à la fois une adresse IPv4 et une adresse IPv6 du sous-réseau du réseau virtuel Azure des nœuds à partir d’un espace d’adressage logiquement différent. La traduction d’adresses réseau (NAT) est ensuite configurée afin que les pods puissent accéder aux ressources sur le réseau virtuel Azure. L’adresse IP source du trafic est traduite en adresse IP principale du nœud de la même famille (IPv4 vers IPv4 et IPv6 vers IPv6).

Cet article explique comment utiliser la mise en réseau à double pile avec un cluster AKS. Pour plus d’informations sur les options et considérations relatives aux réseaux, consultez Concepts de réseau pour Kubernetes et AKS.

Limites

• Les tables de routage Azure ont une limite stricte de 400 itinéraires par table.
  • Chaque nœud d’un cluster à double pile nécessite deux itinéraires, un pour chaque famille d’adresses IP, les clusters à double pile sont limités à 200 nœuds.
• Dans les pools de nœuds Azure Linux, les objets de service sont pris en charge seulement avec externalTrafficPolicy: Local.
• La mise en réseau à double pile est requise pour le réseau virtuel Azure et le CIDR du pod.
  • IPv6 à pile unique n’est pas pris en charge pour les adresses IP de nœud ou de pod. Les services peuvent être approvisionnés sur IPv4 ou IPv6.
• Les fonctionnalités suivantes ne sont pas prises en charge sur kubenet à double pile :
  • Stratégies réseau Azure
  • Stratégies réseau Calico
  • NAT Gateway
  • le module complémentaire de nœuds virtuels.
  • les pools de nœuds Windows ;

Prérequis

• Toutes les conditions préalables à la configuration de la mise en réseau kubenet s’appliquent.
• Les clusters à double pile AKS nécessitent Kubernetes version 1.21.2 ou ultérieure. La version 1.22.2 ou ultérieure est recommandée.
• Si vous utilisez des modèles Azure Resource Manager, la version de schéma 2021-10-01 est requise.

Vue d’ensemble de la mise en réseau à double pile dans Kubernetes

Kubernetes v1.23 apporte une prise en charge stable en amont des clusters IPv4/IPv6 à double pile, y compris la mise en réseau des pods et des services. Les nœuds et les pods se voient toujours attribuer une adresse IPv4 et une adresse IPv6, tandis que les services peuvent être à double pile ou à pile unique sur l’une ou l’autre famille d’adresses.

AKS configure les services de prise en charge requis pour la mise en réseau à double pile. Cette configuration comprend :

• Si vous utilisez un réseau virtuel managé, une configuration de réseau virtuel double pile.
• Adresses de nœuds et de pods IPv4 et IPv6.
• Règles de trafic sortant pour le trafic IPv4 et IPv6.
• Configuration de l’équilibreur de charge pour les services IPv4 et IPv6.

Remarque

Lorsque vous utilisez Dualstack avec un type sortant de routage défini par l’utilisateur, vous pouvez choisir d’avoir un itinéraire par défaut pour IPv6 selon que vous avez besoin de votre trafic IPv6 pour atteindre Internet ou non. Si vous n’avez pas d’itinéraire par défaut pour IPv6, un avertissement s’affiche lors de la création d’un cluster, mais n’empêche pas la création du cluster.

Déploiement d’un cluster à double pile

Les attributs suivants sont fournis pour prendre en charge les clusters à double pile :

• --ip-families : utilise une liste de familles d’adresses IP séparées par des virgules, à activer sur le cluster.
  • Seuls ipv4 ou ipv4,ipv6 sont pris en charge.
• --pod-cidrs : utilise une liste de plages d’adresses IP en notation CIDR, séparées par des virgules, à partir de laquelle attribuer des adresses IP aux pods.
  • Le nombre et l’ordre des plages dans cette liste doivent correspondre à la valeur fournie à --ip-families.
  • Si aucune valeur n’est fournie, la valeur par défaut 10.244.0.0/16,fd12:3456:789a::/64 est utilisée.
• --service-cidrs : utilise une liste de plages d’adresses IP en notation CIDR, séparées par des virgules, à partir de laquelle attribuer des adresses IP aux services.
  • Le nombre et l’ordre des plages dans cette liste doivent correspondre à la valeur fournie à --ip-families.
  • Si aucune valeur n’est fournie, la valeur par défaut 10.0.0.0/16,fd12:3456:789a:1::/108 est utilisée.
  • Le sous-réseau IPv6 attribué à --service-cidrs ne peut pas être supérieur à /108.

Déployer un cluster AKS double pile

Azure CLI

1. Créez un groupe de ressources Azure pour le cluster à l’aide de la commande az group create.

   az group create --location <region> --name <resourceGroupName>
   

2. Créez un cluster AKS à double pile à l’aide de la commande az aks create avec le paramètre --ip-families défini sur ipv4,ipv6.

   az aks create \
       --location <region> \
       --resource-group <resourceGroupName> \
       --name <clusterName> \
       --ip-families ipv4,ipv6 \
       --generate-ssh-keys
   

3. Une fois le cluster créé, obtenez les informations d’identification de l’administrateur du cluster à l’aide de la commande az aks get-credentials.

   az aks get-credentials --resource-group <resourceGroupName> --name <clusterName>
   

Azure Resource Manager

1. Créez le modèle ARM et passez ["IPv4", "IPv6"] au paramètre ipFamilies à l’objet networkProfile.

   {
     "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
     "contentVersion": "1.0.0.0",
     "parameters": {
       "clusterName": {
         "type": "string",
         "defaultValue": "aksdualstack"
       },
       "location": {
         "type": "string",
         "defaultValue": "[resourceGroup().location]"
       },
       "kubernetesVersion": {
         "type": "string",
         "defaultValue": "1.22.2"
       },
       "nodeCount": {
         "type": "int",
         "defaultValue": 3
       },
       "nodeSize": {
         "type": "string",
         "defaultValue": "Standard_B2ms"
       }
     },
     "resources": [
       {
         "type": "Microsoft.ContainerService/managedClusters",
         "apiVersion": "2021-10-01",
         "name": "[parameters('clusterName')]",
         "location": "[parameters('location')]",
         "identity": {
           "type": "SystemAssigned"
         },
         "properties": {
           "agentPoolProfiles": [
             {
               "name": "nodepool1",
               "count": "[parameters('nodeCount')]",
               "mode": "System",
               "vmSize": "[parameters('nodeSize')]"
             }
           ],
           "dnsPrefix": "[parameters('clusterName')]",
           "kubernetesVersion": "[parameters('kubernetesVersion')]",
           "networkProfile": {
             "ipFamilies": [
               "IPv4",
               "IPv6"
             ]
           }
         }
       }
     ]
   }
   

2. Une fois le cluster créé, obtenez les informations d’identification de l’administrateur du cluster à l’aide de la commande az aks get-credentials.

   az aks get-credentials --resource-group <resourceGroupName> --name <clusterName>
   

Notes

Pour plus d’informations sur le déploiement de modèles ARM, consultez la documentation Azure Resource Manager.

Bicep

1. Créez le modèle Bicep et passez ["IPv4", "IPv6"] au paramètre ipFamilies à l’objet networkProfile.

   param clusterName string = 'aksdualstack'
   param location string = resourceGroup().location
   param kubernetesVersion string = '1.22.2'
   param nodeCount int = 3
   param nodeSize string = 'Standard_B2ms'
   
   resource aksCluster 'Microsoft.ContainerService/managedClusters@2021-10-01' = {
     name: clusterName
     location: location
     identity: {
       type: 'SystemAssigned'
     }
     properties: {
       agentPoolProfiles: [
         {
           name: 'nodepool1'
           count: nodeCount
           mode: 'System'
           vmSize: nodeSize
         }
       ]
       dnsPrefix: clusterName
       kubernetesVersion: kubernetesVersion
       networkProfile: {
         ipFamilies: [
           'IPv4'
           'IPv6'
         ]
       }
     }
   }
   

2. Une fois le cluster créé, obtenez les informations d’identification de l’administrateur du cluster à l’aide de la commande az aks get-credentials.

   az aks get-credentials --resource-group <resourceGroupName> --name <clusterName>
   

Notes

Pour plus d’informations sur le déploiement de modèles Bicep, consultez la documentation du modèle Bicep.

Inspecter les nœuds pour voir les deux familles d’adresses IP

• Une fois le cluster approvisionné, confirmez que les nœuds sont approvisionnés avec une mise en réseau à double pile à l’aide de la commande kubectl get nodes.

  kubectl get nodes -o=custom-columns="NAME:.metadata.name,ADDRESSES:.status.addresses[?(@.type=='InternalIP')].address,PODCIDRS:.spec.podCIDRs[*]"
  

  La sortie de la commande kubectl get nodes montre que les nœuds ont des adresses et un espace d’attribution d’adresses IP aux pods à la fois pour IPv4 et IPv6.

  NAME                                ADDRESSES                           PODCIDRS
  aks-nodepool1-14508455-vmss000000   10.240.0.4,2001:1234:5678:9abc::4   10.244.0.0/24,fd12:3456:789a::/80
  aks-nodepool1-14508455-vmss000001   10.240.0.5,2001:1234:5678:9abc::5   10.244.1.0/24,fd12:3456:789a:0:1::/80
  aks-nodepool1-14508455-vmss000002   10.240.0.6,2001:1234:5678:9abc::6   10.244.2.0/24,fd12:3456:789a:0:2::/80
  

Créer un exemple de charge de travail

Une fois le cluster créé, vous pouvez déployer vos charges de travail. Cet article vous guide à travers un exemple de déploiement de charge de travail d’un serveur web NGINX.

Déployer un serveur web NGINX

kubectl

1. Créez un serveur web NGINX à l’aide de la commande kubectl create deployment nginx.

   kubectl create deployment nginx --image=nginx:latest --replicas=3
   

2. Affichez les ressources du pod à l’aide de la commande kubectl get pods.

   kubectl get pods -o custom-columns="NAME:.metadata.name,IPs:.status.podIPs[*].ip,NODE:.spec.nodeName,READY:.status.conditions[?(@.type=='Ready')].status"
   

   La sortie indique que les pods ont des adresses IPv4 et IPv6. Les pods n’affichent pas d’adresses IP tant qu’ils ne sont pas prêts.

   NAME                     IPs                                NODE                                READY
   nginx-55649fd747-9cr7h   10.244.2.2,fd12:3456:789a:0:2::2   aks-nodepool1-14508455-vmss000002   True
   nginx-55649fd747-p5lr9   10.244.0.7,fd12:3456:789a::7       aks-nodepool1-14508455-vmss000000   True
   nginx-55649fd747-r2rqh   10.244.1.2,fd12:3456:789a:0:1::2   aks-nodepool1-14508455-vmss000001   True
   

YAML

1. Créez un serveur web NGINX à l’aide du manifeste YAML suivant.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       app: nginx
     name: nginx
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - image: nginx:latest
           name: nginx
   

2. Affichez les ressources du pod à l’aide de la commande kubectl get pods.

   kubectl get pods -o custom-columns="NAME:.metadata.name,IPs:.status.podIPs[*].ip,NODE:.spec.nodeName,READY:.status.conditions[?(@.type=='Ready')].status"
   

   La sortie indique que les pods ont des adresses IPv4 et IPv6. Les pods n’affichent pas d’adresses IP tant qu’ils ne sont pas prêts.

   NAME                     IPs                                NODE                                READY
   nginx-55649fd747-9cr7h   10.244.2.2,fd12:3456:789a:0:2::2   aks-nodepool1-14508455-vmss000002   True
   nginx-55649fd747-p5lr9   10.244.0.7,fd12:3456:789a::7       aks-nodepool1-14508455-vmss000000   True
   nginx-55649fd747-r2rqh   10.244.1.2,fd12:3456:789a:0:1::2   aks-nodepool1-14508455-vmss000001   True
   

Exposez la charge de travail via un service de type LoadBalancer

Important

À partir d'AKS v1.27, vous pouvez créer un service LoadBalancer à double pile qui sera provisionné avec 1 IP publique IPv4 et 1 IP publique IPv6. Toutefois, dans les versions antérieures, seule la première adresse IP d’un service est provisionnée sur l’équilibreur de charge. Par conséquent, un service double pile reçoit une IP publique uniquement pour sa première famille d’adresses IP listées. Afin de fournir un service à double pile pour un seul déploiement, créez deux services ciblant le même sélecteur, un pour IPv4 et l’autre pour IPv6.

kubectl

AKS à partir de la version v1.27

1. Exposez le déploiement NGINX à l’aide de la commande kubectl expose deployment nginx.

   kubectl expose deployment nginx --name=nginx --port=80 --type=LoadBalancer --overrides='{"spec":{"ipFamilyPolicy": "PreferDualStack", "ipFamilies": ["IPv4", "IPv6"]}}'
   

   Vous recevez une sortie qui indique que les services ont été exposés.

   service/nginx exposed
   

2. Une fois que le déploiement est exposé et que les services LoadBalancer sont entièrement provisionnés, obtenez les adresses IP des services à l’aide de la commande kubectl get services.

   kubectl get services
   

   NAME         TYPE           CLUSTER-IP               EXTERNAL-IP         PORT(S)        AGE
   nginx        LoadBalancer   10.0.223.73   2603:1030:20c:9::22d,4.156.88.133   80:30664/TCP   2m11s
   

   kubectl get services nginx -ojsonpath='{.spec.clusterIPs}'
   

   ["10.0.223.73","fd17:d93e:db1f:f771::54e"]
   

3. Vérifiez les fonctionnalités via une requête web en ligne de commande à partir d’un hôte compatible IPv6. Azure Cloud Shell n’est pas compatible IPv6.

   SERVICE_IP=$(kubectl get services nginx -o jsonpath='{.status.loadBalancer.ingress[1].ip}')
   curl -s "http://[${SERVICE_IP}]" | head -n5
   

   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   <style>
   

Version AKS antérieure à v1.27

1. Exposez le déploiement NGINX à l’aide de la commande kubectl expose deployment nginx.

   kubectl expose deployment nginx --name=nginx-ipv4 --port=80 --type=LoadBalancer'
   kubectl expose deployment nginx --name=nginx-ipv6 --port=80 --type=LoadBalancer --overrides='{"spec":{"ipFamilies": ["IPv6"]}}'
   

   Vous recevez une sortie qui indique que les services ont été exposés.

   service/nginx-ipv4 exposed
   service/nginx-ipv6 exposed
   

2. Une fois que le déploiement est exposé et que les services LoadBalancer sont entièrement provisionnés, obtenez les adresses IP des services à l’aide de la commande kubectl get services.

   kubectl get services
   

   NAME         TYPE           CLUSTER-IP               EXTERNAL-IP         PORT(S)        AGE
   nginx-ipv4   LoadBalancer   10.0.88.78               20.46.24.24         80:30652/TCP   97s
   nginx-ipv6   LoadBalancer   fd12:3456:789a:1::981a   2603:1030:8:5::2d   80:32002/TCP   63s
   

3. Vérifiez les fonctionnalités via une requête web en ligne de commande à partir d’un hôte compatible IPv6. Azure Cloud Shell n’est pas compatible IPv6.

   SERVICE_IP=$(kubectl get services nginx-ipv6 -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
   curl -s "http://[${SERVICE_IP}]" | head -n5
   

   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   <style>
   

YAML

AKS à partir de la version v1.27

1. Exposez le déploiement NGINX à l’aide du manifeste YAML suivant.

   apiVersion: v1
   kind: Service
   metadata:
     labels:
       app: nginx
     name: nginx
   spec:
     externalTrafficPolicy: Cluster
     ipFamilyPolicy: PreferDualStack
     ipFamilies:
     - IPv4
     - IPv6
     ports:
     - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       app: nginx
     type: LoadBalancer
   

2. Une fois que le déploiement est exposé et que les services LoadBalancer sont entièrement provisionnés, obtenez les adresses IP des services à l’aide de la commande kubectl get services.

   kubectl get services
   

   NAME         TYPE           CLUSTER-IP               EXTERNAL-IP         PORT(S)        AGE
   nginx        LoadBalancer   10.0.223.73   2603:1030:20c:9::22d,4.156.88.133   80:30664/TCP   2m11s
   

   kubectl get services nginx -ojsonpath='{.spec.clusterIPs}'
   

   ["10.0.223.73","fd17:d93e:db1f:f771::54e"]
   

3. Vérifiez les fonctionnalités via une requête web en ligne de commande à partir d’un hôte compatible IPv6. Azure Cloud Shell n’est pas compatible IPv6.

   SERVICE_IP=$(kubectl get services nginx -o jsonpath='{.status.loadBalancer.ingress[1].ip}')
   curl -s "http://[${SERVICE_IP}]" | head -n5
   

   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   <style>
   

Version AKS antérieure à v1.27

1. Exposez le déploiement NGINX à l’aide du manifeste YAML suivant.

   ---
   apiVersion: v1
   kind: Service
   metadata:
     labels:
       app: nginx
     name: nginx-ipv4
   spec:
     externalTrafficPolicy: Cluster
     ports:
    - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       app: nginx
     type: LoadBalancer
   ---
   apiVersion: v1
   kind: Service
   metadata:
     labels:
       app: nginx
     name: nginx-ipv6
   spec:
     externalTrafficPolicy: Cluster
     ipFamilies:
    - IPv6
     ports:
    - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       app: nginx
     type: LoadBalancer
   

2. Une fois que le déploiement est exposé et que les services LoadBalancer sont entièrement provisionnés, obtenez les adresses IP des services à l’aide de la commande kubectl get services.

   kubectl get services
   

   NAME         TYPE           CLUSTER-IP               EXTERNAL-IP         PORT(S)        AGE
   nginx-ipv4   LoadBalancer   10.0.88.78               20.46.24.24         80:30652/TCP   97s
   nginx-ipv6   LoadBalancer   fd12:3456:789a:1::981a   2603:1030:8:5::2d   80:32002/TCP   63s
   

3. Vérifiez les fonctionnalités via une requête web en ligne de commande à partir d’un hôte compatible IPv6. Azure Cloud Shell n’est pas compatible IPv6.

   SERVICE_IP=$(kubectl get services nginx-ipv6 -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
   curl -s "http://[${SERVICE_IP}]" | head -n5
   

   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   <style>