Créer et configurer un cluster Azure Kubernetes Service (AKS) pour utiliser des nœuds virtuels sur le Portail Azure

Article
08/02/2024

Les nœuds virtuels permettent la communication réseau entre les pods qui s’exécutent dans Azure Container Instances (ACI) et les clusters Azure Kubernetes Service (AKS). Pour que cette communication ait lieu, un sous-réseau de réseau virtuel est créé et des permissions déléguées sont assignées. Les nœuds virtuels ne fonctionnent qu’avec des clusters AKS créés avec un réseau avancé (Azure CNI). Les clusters AKS sont créés à l’aide d’une mise en réseau de base (kubenet) par défaut.

Cet article vous montre comment créer un réseau virtuel et des sous-réseaux, puis comment déployer un cluster AKS qui utilise une mise en réseau avancée à l’aide du portail Azure.

Notes

Pour obtenir une vue d’ensemble de la disponibilité et des limitations des régions de nœuds virtuels, consultez Utiliser des nœuds virtuels dans AKS.

Avant de commencer

Vous avez besoin du fournisseur de services ACI inscrit sur votre abonnement.

Vérifiez l’état de l’inscription du fournisseur ACI à l’aide de la commande az provider list.

az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table

L’exemple de sortie suivant montre que l’état du fournisseur Microsoft.ContainerInstance est Registered :

Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired

Si l’état du fournisseur est NotRegistered, inscrivez-le à l’aide de la commande az provider register.
```
az provider register --namespace Microsoft.ContainerInstance
```

Créer un cluster AKS

Accédez à la page d’accueil du portail Azure.
Sélectionnez Créer une ressource>Conteneurs.
Dans la ressource Azure Kubernetes Service (AKS), sélectionnez Créer.
Sur la page Bases, configurez les options suivantes :
- Détails du projet : sélectionnez un abonnement Azure, puis sélectionnez ou créez un groupe de ressources Azure, tel que myResourceGroup.
- Détails du cluster : Entrez un nom du cluster Kubernetes, tel que myAKSCluster. Sélectionnez une région et une version Kubernetes pour le cluster AKS.
Sélectionnez Suivant : pools de nœuds et cochez *Activer les nœuds virtuels.
Sélectionnez Revoir + créer.
Quand la validation est terminée, sélectionnez Créer.

Par défaut, ce processus crée une identité de cluster managée, qui est utilisée pour la communication et l’intégration du cluster avec d’autres services Azure. Pour plus d’informations, consultez Utiliser des identités managées. Vous pouvez également utiliser un principal de service comme identité de cluster.

Ce processus configure le cluster à des fins de mise en réseau avancée et les nœuds virtuels pour qu’ils utilisent leur propre sous-réseau de réseau virtuel Azure. Ce sous-réseau possède des permissions déléguées pour se connecter à des ressources Azure entre le cluster AKS. Si vous ne disposez pas de sous-réseau délégué, le portail Azure crée et configure un réseau virtuel Azure et un sous-réseau avec les nœuds virtuels.

Se connecter au cluster

Le service Azure Cloud Shell est un interpréteur de commandes interactif et gratuit que vous pouvez utiliser pour exécuter les étapes décrites dans cet article. Il contient des outils Azure courants préinstallés et configurés pour être utilisés avec votre compte. Pour gérer un cluster Kubernetes, utilisez kubectl, le client de ligne de commande Kubernetes. Le client kubectl est préinstallé dans Azure Cloud Shell.

Configurez kubectl afin de vous connecter à votre cluster Kubernetes avec la commande az aks get-credentials. L’exemple suivant obtient les informations d’identification du nom du cluster myAKSCluster dans le groupe de ressources nommé myResourceGroup :
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Vérifiez la connexion à votre cluster à l’aide de kubectl get nodes.

kubectl get nodes

L’exemple de sortie suivant représente le nœud de machine virtuelle unique créé et le nœud virtuel Linux, nommé virtual-node-aci-linux :

NAME                           STATUS    ROLES     AGE       VERSION
virtual-node-aci-linux         Ready     agent     28m       v1.11.2
aks-agentpool-14693408-0       Ready     agent     32m       v1.11.2

Déployer un exemple d’application

Dans Azure Cloud Shell, créez un fichier nommé virtual-node.yaml et copiez-y le code YAML suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aci-helloworld
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aci-helloworld
  template:
    metadata:
      labels:
        app: aci-helloworld
    spec:
      containers:
      - name: aci-helloworld
        image: mcr.microsoft.com/azuredocs/aci-helloworld
        ports:
        - containerPort: 80
      nodeSelector:
        kubernetes.io/role: agent
        beta.kubernetes.io/os: linux
        type: virtual-kubelet
      tolerations:
      - key: virtual-kubelet.io/provider
        operator: Exists

Le YAML définit un nodeSelector et une toleration, ce qui permet de planifier le pod sur le nœud virtuel. Le pod reçoit une adresse IP interne du sous-réseau de réseau virtuel Azure délégué de façon à être utilisé avec des nœuds virtuels.

Exécutez l’application à l’aide de la commande kubectl apply.
```
kubectl apply -f virtual-node.yaml
```

Affichez les pods planifiés sur le nœud à l’aide de la commande kubectl get pods avec l’argument -o wide.

kubectl get pods -o wide

L’exemple de sortie suivant montre le pod virtual-node-helloworld planifié sur le nœud virtual-node-linux.

NAME                                     READY     STATUS    RESTARTS   AGE       IP           NODE
virtual-node-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux

Notes

Si vous utilisez des images stockées dans Azure Container Registry, configurez et utilisez un secret Kubernetes. Compte-tenu de la limitation des nœuds virtuels, vous ne pouvez pas utiliser l’authentification de principal de service Microsoft Entra intégrée. Si vous n'utilisez pas de secret, les pods planifiés sur les nœuds virtuels ne parviennent pas à démarrer et renvoient l'erreur HTTP response status code 400 error code "InaccessibleImage".

Tester le pod de nœud virtuel

Pour tester le pod en cours d’exécution sur le nœud virtuel, accédez à l’application de démonstration avec un client web. Une adresse IP interne est attribuée au pod ; vous pouvez donc facilement tester la connectivité à partir d’un autre pod sur le cluster AKS.

Créez un pod de test et attachez-lui une session de terminal à l’aide de la commande suivante kubectl run.
```
kubectl run -it --rm virtual-node-test --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```
Installez curl dans le pod à l’aide de la commande suivante apt-get.
```
apt-get update && apt-get install -y curl
```
Accédez à l’adresse de votre pod à l’aide de la commande suivante curl et fournissez votre adresse IP interne.
```
curl -L http://10.241.0.4
```
L’exemple de sortie condensée suivant montre l’application de démonstration.
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Fermez la session de terminal de votre pod de test avec exit, ce qui supprime également le pod.
```
exit
```

Étapes suivantes

Dans cet article, vous avez planifié un pod sur le nœud virtuel et affecté une adresse IP interne privée. Si vous le souhaitez, vous pouvez créer un déploiement de service et router le trafic vers votre pod au moyen d’un équilibreur de charge ou d’un contrôleur d’entrée. Pour plus d’informations, consultez Créer un contrôleur d’entrée de base dans AKS.

Les nœuds virtuels constituent l’un des composants d’une solution de mise à l’échelle dans AKS. Pour plus d’informations sur ces solutions, consultez les articles suivants :

Partager via