Démarrage rapide : Déployer un cluster hôte de conteneur Azure Linux pour AKS en utilisant un modèle ARM
Pour commencer, vous allez déployer un cluster hôte de conteneur Azure Linux en utilisant un modèle Azure Resource Manager (ARM). Une fois les prérequis installés, vous devez créer une paire de clés SSH, passer en revue le modèle, déployer le modèle et le valider, puis déployer une application.
Un modèle Azure Resource Manager est un fichier JavaScript Object Notation (JSON) qui définit l'infrastructure et la configuration de votre projet. Le modèle utilise la syntaxe déclarative. Vous décrivez votre déploiement prévu sans écrire la séquence de commandes de programmation pour créer le déploiement.
Prérequis
-
Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.
Utilisez l’environnement Bash dans Azure Cloud Shell. Pour plus d’informations, consultez Démarrage rapide d’Azure Cloud Shell - Bash.
Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour connaître les autres options de connexion, consultez Se connecter avec Azure CLI.
Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser des extensions avec Azure CLI.
Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour passer à la dernière version, exécutez az upgrade.
Si vous n’avez pas encore installé kubectl, installez-le via Azure CLI à l’aide de
az aks install-cliou suivez les instructions en amont.Pour créer un cluster AKS à l’aide d’un modèle Resource Manager, vous fournissez une clé publique SSH. Si vous avez besoin de cette ressource, consultez la section suivante ; sinon, passez à la section Vérifier le modèle.
L’identité que vous utilisez pour créer votre cluster dispose des autorisations minimales appropriées. Pour plus d’informations sur l’accès et l’identité pour AKS, consultez Options d’accès et d’identité pour Kubernetes Azure Service (AKS).
Pour déployer un fichier Bicep ou un modèle ARM, vous devez disposer d’un accès en écriture aux ressources que vous déployez et un accès à toutes les opérations sur le type de ressource Microsoft.Resources/deployments. Par exemple, pour déployer une machine virtuelle, vous avez besoin des autorisations Microsoft.Compute/virtualMachines/write et Microsoft.Resources/deployments/*. Pour obtenir la liste des rôles et autorisations, consultez Rôles intégrés Azure.
Création d’une paire de clés SSH
Pour accéder aux nœuds AKS, vous vous connectez à l’aide d’une paire de clés SSH (publique et privée), que vous générez à l’aide de la commande ssh-keygen. Par défaut, ces fichiers sont créés dans le répertoire ~/.ssh. L’exécution de la commande ssh-keygen remplace toute paire de clés SSH portant le même nom qui existe déjà dans l’emplacement donné.
Accédez à https://shell.azure.com pour ouvrir Cloud Shell dans votre navigateur.
Exécutez la commande
ssh-keygen. L’exemple suivant crée une paire de clés SSH à l’aide du chiffrement RSA avec une longueur de 4096 bits :ssh-keygen -t rsa -b 4096
Pour plus d’informations sur la création de clés SSH, consultez Créer et gérer les clés SSH pour l’authentification dans Azure.
Vérifier le modèle
Le déploiement suivant utilise un modèle ARM à partir des modèles de démarrage rapide Azure.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.1",
"parameters": {
"clusterName": {
"type": "string",
"defaultValue": "azurelinuxakscluster",
"metadata": {
"description": "The name of the Managed Cluster resource."
}
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]",
"metadata": {
"description": "The location of the Managed Cluster resource."
}
},
"dnsPrefix": {
"type": "string",
"metadata": {
"description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
}
},
"osDiskSizeGB": {
"type": "int",
"defaultValue": 0,
"minValue": 0,
"maxValue": 1023,
"metadata": {
"description": "Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize."
}
},
"agentCount": {
"type": "int",
"defaultValue": 3,
"minValue": 1,
"maxValue": 50,
"metadata": {
"description": "The number of nodes for the cluster."
}
},
"agentVMSize": {
"type": "string",
"defaultValue": "Standard_DS2_v2",
"metadata": {
"description": "The size of the Virtual Machine."
}
},
"linuxAdminUsername": {
"type": "string",
"metadata": {
"description": "User name for the Linux Virtual Machines."
}
},
"sshRSAPublicKey": {
"type": "string",
"metadata": {
"description": "Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example 'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm'"
}
},
"osType": {
"type": "string",
"defaultValue": "Linux",
"allowedValues": [
"Linux"
],
"metadata": {
"description": "The type of operating system."
}
},
"osSKU": {
"type": "string",
"defaultValue": "AzureLinux",
"allowedValues": [
"AzureLinux",
"Ubuntu"
],
"metadata": {
"description": "The Linux SKU to use."
}
}
},
"resources": [
{
"type": "Microsoft.ContainerService/managedClusters",
"apiVersion": "2021-03-01",
"name": "[parameters('clusterName')]",
"location": "[parameters('location')]",
"properties": {
"dnsPrefix": "[parameters('dnsPrefix')]",
"agentPoolProfiles": [
{
"name": "agentpool",
"mode": "System",
"osDiskSizeGB": "[parameters('osDiskSizeGB')]",
"count": "[parameters('agentCount')]",
"vmSize": "[parameters('agentVMSize')]",
"osType": "[parameters('osType')]",
"osSKU": "[parameters('osSKU')]",
"storageProfile": "ManagedDisks"
}
],
"linuxProfile": {
"adminUsername": "[parameters('linuxAdminUsername')]",
"ssh": {
"publicKeys": [
{
"keyData": "[parameters('sshRSAPublicKey')]"
}
]
}
}
},
"identity": {
"type": "SystemAssigned"
}
}
],
"outputs": {
"controlPlaneFQDN": {
"type": "string",
"value": "[reference(parameters('clusterName')).fqdn]"
}
}
}
Pour ajouter Azure Linux à un modèle ARM existant, vous devez ajouter "osSKU": "AzureLinux" et "mode": "System" à agentPoolProfiles et définir la version d’API sur 2021-03-01 ou ultérieure ("apiVersion": "2021-03-01").
Déployer le modèle
Sélectionnez le bouton suivant pour vous connecter à Azure et ouvrir un modèle.
Sélectionnez ou entrez les valeurs suivantes.
Pour ce guide de démarrage rapide, conservez les valeurs par défaut pour Taille du disque du système d’exploitation en Go, Nombre d’agents, Taille de machine virtuelle de l’agent, Type de système d’exploitation et Version de Kubernetes. Fournissez vos propres valeurs pour les paramètres de modèle suivants :
- Abonnement: Sélectionnez un abonnement Azure.
- Groupe de ressources : Sélectionnez Créer nouveau. Entrez un nom unique pour le groupe de ressources, tel que testAzureLinuxResourceGroup, puis choisissez OK.
- Emplacement : sélectionnez un emplacement, comme USA Est.
- Nom du cluster : entrez un nom unique pour le cluster AKS, par exemple testAzureLinuxCluster.
- Préfixe DNS : entrez un préfixe DNS unique pour votre cluster, par exemple myAzureLinuxCluster.
- Nom d’utilisateur de l’administrateur Linux : entrez un nom d’utilisateur pour vous connecter avec SSH, par exemple azureUser.
- Clé publique RSA SSH : copiez et collez la partie publique de votre paire de clés SSH (par défaut, le contenu de ~/.ssh/id_rsa.pub).
Sélectionnez Vérifier + créer.
La création du cluster hôte de conteneur Azure Linux prend quelques minutes. Attendez que le cluster soit déployé avec succès avant de passer à l’étape suivante.
Valider le déploiement
Se connecter au cluster
Pour gérer un cluster Kubernetes, utilisez kubectl, le client de ligne de commande Kubernetes.
Installez
kubectlen local avec la commandeaz aks install-cli:az aks install-cliConfigurez
kubectlafin de vous connecter à votre cluster Kubernetes avec la commandeaz aks get-credentials. Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser.az aks get-credentials --resource-group testAzureLinuxResourceGroup --name testAzureLinuxClusterPour vérifier la connexion à votre cluster, exécutez la commande
kubectl get. Cette commande renvoie la liste des nœuds de cluster.kubectl get nodesL’exemple de sortie suivant montre les trois nœuds créés au cours des étapes précédentes. Assurez-vous que l’état du nœud est Prêt :
NAME STATUS ROLES AGE VERSION aks-agentpool-41324942-0 Ready agent 6m44s v1.12.6 aks-agentpool-41324942-1 Ready agent 6m46s v1.12.6 aks-agentpool-41324942-2 Ready agent 6m45s v1.12.6
Déployer l’application
Un fichier manifeste Kubernetes définit un état souhaité d’un cluster, notamment les images conteneur à exécuter.
Dans le cadre de ce guide de démarrage rapide, vous allez utiliser un manifeste pour créer tous les objets nécessaires à l’exécution de l’application Vote Azure. Ce manifeste comprend deux déploiements Kubernetes :
- Exemples d’applications Python pour Azure Vote.
- Une instance Redis.
Deux services Kubernetes sont également créés :
- Un service interne pour l’instance Redis.
- Un service externe pour accéder à l’application Azure vote à partir d’Internet.
Créez un fichier appelé
azure-vote.yaml.- Si vous utilisez Azure Cloud Shell, vous pouvez créer ce fichier à l’aide de
code,viounanocomme si vous travailliez sur un système virtuel ou physique
- Si vous utilisez Azure Cloud Shell, vous pouvez créer ce fichier à l’aide de
Copiez-y la définition YAML suivante :
apiVersion: apps/v1 kind: Deployment metadata: name: azure-vote-back spec: replicas: 1 selector: matchLabels: app: azure-vote-back template: metadata: labels: app: azure-vote-back spec: nodeSelector: "kubernetes.io/os": linux containers: - name: azure-vote-back image: mcr.microsoft.com/oss/bitnami/redis:6.0.8 env: - name: ALLOW_EMPTY_PASSWORD value: "yes" resources: requests: cpu: 100m memory: 128Mi limits: cpu: 250m memory: 256Mi ports: - containerPort: 6379 name: redis --- apiVersion: v1 kind: Service metadata: name: azure-vote-back spec: ports: - port: 6379 selector: app: azure-vote-back --- apiVersion: apps/v1 kind: Deployment metadata: name: azure-vote-front spec: replicas: 1 selector: matchLabels: app: azure-vote-front template: metadata: labels: app: azure-vote-front spec: nodeSelector: "kubernetes.io/os": linux containers: - name: azure-vote-front image: mcr.microsoft.com/azuredocs/azure-vote-front:v1 resources: requests: cpu: 100m memory: 128Mi limits: cpu: 250m memory: 256Mi ports: - containerPort: 80 env: - name: REDIS value: "azure-vote-back" --- apiVersion: v1 kind: Service metadata: name: azure-vote-front spec: type: LoadBalancer ports: - port: 80 selector: app: azure-vote-frontPour obtenir une répartition des fichiers manifeste YAML, consultez Déploiements et manifestes YAML.
Déployez l’application à l’aide de la commande kubectl apply et spécifiez le nom de votre manifeste YAML :
kubectl apply -f azure-vote.yamlL’exemple suivant ressemble à la sortie montrant les déploiements et services créés avec succès :
deployment "azure-vote-back" created service "azure-vote-back" created deployment "azure-vote-front" created service "azure-vote-front" created
Test de l’application
Quand l’application s’exécute, un service Kubernetes expose le front-end de l’application sur Internet. L’exécution de ce processus peut prendre plusieurs minutes.
Surveillez la progression avec la commande kubectl get service et l’argument --watch.
kubectl get service azure-vote-front --watch
La sortie EXTERNAL-IP pour le service azure-vote-front affiche initialement En attente.
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
azure-vote-front LoadBalancer 10.0.37.27 <pending> 80:30572/TCP 6s
Quand l’adresse EXTERNAL-IP passe de l’état pending à une adresse IP publique réelle, utilisez CTRL-C pour arrêter le processus de surveillance kubectl. L’exemple de sortie suivant montre une adresse IP publique valide affectée au service :
azure-vote-front LoadBalancer 10.0.37.27 52.179.23.131 80:30572/TCP 2m
Pour voir l’application Azure Vote en action, ouvrez un navigateur web en utilisant l’adresse IP externe de votre service.
Supprimer le cluster
Si vous n’envisagez pas de suivre les tutoriels suivants, nettoyez toutes les ressources inutiles pour éviter les frais Azure. Utilisez la commande az group delete pour supprimer le groupe de ressources et toutes les ressources associées.
az group delete --name testAzureLinuxCluster --yes --no-wait
Étapes suivantes
Dans ce guide de démarrage rapide, vous avez déployé un cluster hôte de conteneur Azure Linux. Pour en savoir plus sur l’hôte de conteneur Azure Linux et suivre pas à pas un exemple complet illustrant le déploiement et la gestion d’un cluster, passez au tutoriel sur l’hôte de conteneur Azure Linux.