Partager via


Démarrage rapide : déployer un cluster Kubernetes à l’aide d’un modèle Azure Resource Manager

S’applique à : Azure Stack HCI, version 23H2

Ce guide de démarrage rapide montre comment déployer un cluster Kubernetes dans AKS Arc à l’aide d’un modèle Azure Resource Manager. Azure Arc étend les fonctionnalités de gestion Azure aux clusters Kubernetes n’importe où, offrant une approche unifiée de la gestion des différents environnements.

Avant de commencer

Cet article suppose une compréhension élémentaire des concepts liés à Kubernetes.

Pour déployer un modèle Resource Manager, vous avez besoin d’un accès en écriture sur les ressources que vous déployez et d’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.

Prérequis

  • Compte Azure avec un abonnement actif.
  • Un cluster Azure Stack HCI 23H2.
  • Dernière version d’Azure CLI.

Étape 1 : préparer votre compte Azure

  1. Connectez-vous à Azure : ouvrez votre terminal ou invite de commandes et connectez-vous à votre compte Azure à l’aide d’Azure CLI :

    az login
    
  2. Définir votre abonnement : remplacez par <your-subscription-id> votre ID d’abonnement :

    az account set --subscription "<your-subscription-id>"
    

Étape 2 : créer une paire de clés SSH à l’aide d’Azure CLI

az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"

ou, créez une paire de clés SSH à l’aide de ssh-keygen :

ssh-keygen -t rsa -b 4096

Pour déployer le modèle, vous devez fournir la clé publique à partir de la paire SSH. Pour récupérer la clé publique, utilisez la az sshkey show commande :

az sshkey show --name "mySSHKey" --resource-group "myResourceGroup" --query "publicKey"

Par défaut, les fichiers de clé SSH sont créés dans le répertoire ~/.ssh . Exécutez la az sshkey create commande ou ssh-keygen pour remplacer toute paire de clés SSH existante portant le même nom.

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.

Étape 3 : Passer en revue le modèle

Le modèle utilisé dans ce guide de démarrage rapide provient du référentiel Modèles de démarrage rapide Azure :

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
      "provisionedClusterName": {
          "type": "string",
          "defaultValue": "aksarc-armcluster",
          "metadata": {
              "description": "The name of the AKS Arc Cluster resource."
          }
      },
      "location": {
          "type": "string",
          "defaultValue": "eastus",
          "metadata": {
              "description": "The location of the AKS Arc Cluster resource."
          }
      },
      "resourceTags": {
            "type": "object",
            "defaultValue": {}
        },
      "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 '"
          }
      },
       "enableAHUB": {
            "type": "string",
            "defaultValue": "NotApplicable",
            "metadata": {
                "description": "Azure Hybrid Benefit for Windows Server licenses. NotApplicable, True, False."
            }
        },
       "agentName": {
              "type": "string",
              "defaultValue": "nodepool",
              "metadata": {
                  "description": "The name of the node pool."
              }
          },
        "agentVMSize": {
            "type": "string",
            "defaultValue": "Standard_A4_v2",
            "metadata": {
                  "description": "The VM size for node pools."
            }
        },
        "agentCount": {
              "type": "int",
              "defaultValue": 1,
              "minValue": 1,
              "maxValue": 50,
              "metadata": {
                  "description": "The number of nodes for the cluster."
              }
          },
          "agentOsType": {
              "type": "string",
              "defaultValue": "Linux",
              "metadata": {
                  "description": "The OS Type for the agent pool. Values are Linux and Windows."
              }
          },
         "loadBalancerCount": {
            "type": "int",
            "defaultValue": 0,
            "metadata": {
                "description": "The number of load balancers."
            }
        },
          "kubernetesVersion": {
              "type": "string",
              "metadata": {
                  "description": "The version of Kubernetes."
              }
          },
          "controlPlaneNodeCount": {
              "type": "int",
              "defaultValue": 1,
              "minValue": 1,
              "maxValue": 5,
              "metadata": {
                  "description": "The number of control plane nodes for the cluster."
              }
          },
          "controlPlaneIp": {
            "type": "string",
            "defaultValue": "<default_value>",
              "metadata": {
                  "description": "Control plane IP address."
              }
         },
          "controlPlaneVMSize": {
              "type": "string",
              "defaultValue": "Standard_A4_v2",
              "metadata": {
                  "description": "The VM size for control plane."
              }
          },
          "vnetSubnetIds": {
              "type": "array",
              "metadata": {
                  "description": "List of subnet Ids for the AKS cluster."
              }
          },
          "podCidr": {
            "type": "string",
            "defaultValue": "10.244.0.0/16",
            "metadata": {
                  "description": "The VM size for control plane."
              }
          },
          "networkPolicy": {
            "type": "string",
            "defaultValue": "calico",
            "metadata": {
                  "description": "Network policy to use for Kubernetes pods. Only options supported is calico."
              }
          },
          "customLocation": {
            "type": "string",
            "metadata": {
                  "description": "Fully qualified custom location resource Id."
              }
          }
      },
      "resources": [
      {
          "apiVersion": "2024-01-01",
          "type": "Microsoft.Kubernetes/ConnectedClusters",
          "kind": "ProvisionedCluster",
          "location": "[parameters('location')]",
          "name": "[parameters('provisionedClusterName')]",
          "tags": "[parameters('resourceTags')]",
          "identity": {
              "type": "SystemAssigned"
          },
          "properties": {
              "agentPublicKeyCertificate":"" ,
              "aadProfile": {
                  "enableAzureRBAC": false
              }
          }
      },
      {
          "apiVersion": "2024-01-01",
          "type": "microsoft.hybridcontainerservice/provisionedclusterinstances",
          "name": "default",
          "scope": "[concat('Microsoft.Kubernetes/ConnectedClusters', '/', parameters('provisionedClusterName'))]",
          "dependsOn": [
              "[resourceId('Microsoft.Kubernetes/ConnectedClusters', parameters('provisionedClusterName'))]"
          ],
          "properties": {
          "agentPoolProfiles": [
            {
              "count": "[parameters('agentCount')]",
              "name":"[parameters('agentName')]",
              "osType": "[parameters('agentOsType')]",
              "vmSize": "[parameters('agentVMSize')]"
            }
          ],
          "cloudProviderProfile": {
            "infraNetworkProfile": {
                  "vnetSubnetIds": "[parameters('vnetSubnetIds')]"
            }
          },
          "controlPlane": {
            "count": "[parameters('controlPlaneNodeCount')]",
            "controlPlaneEndpoint": {
                        "hostIP": "[parameters('controlPlaneIp')]"
                    },
            "vmSize": "[parameters('controlPlaneVMSize')]"
          },
         "licenseProfile": {
            "azureHybridBenefit": "[parameters('enableAHUB')]"
         },
          "kubernetesVersion": "[parameters('kubernetesVersion')]",
          "linuxProfile": {
            "ssh": {
              "publicKeys": [
                {
                  "keyData": "[parameters('sshRSAPublicKey')]"
                }
              ]
            }
          },
        "networkProfile": {
          "loadBalancerProfile": {
            "count": "[parameters('loadBalancerCount')]"
          },
          "networkPolicy": "[parameters('networkPolicy')]",
          "podCidr": "[parameters('podCidr')]"
        },
        "storageProfile": {
          "nfsCsiDriver": {
            "enabled": false
          },
          "smbCsiDriver": {
            "enabled": false
          }
        }
        },
        "extendedLocation": {
            "name": "[parameters('customLocation')]",
            "type": "CustomLocation"
        }
      }
    ]
  }

Étape 4 : déployer le modèle

Pour déployer le modèle, exécutez la commande suivante pour déployer le cluster Kubernetes :

az deployment group create \
--name "<deployment-name>" \
--resource-group "<resource-group-name>" \
--template-uri "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/quickstarts/microsoft.kubernetes/aks-arc/azuredeploy.json" \
--parameters provisionedClusterName="<cluster-name> location="eastus" sshRSApublicKey="" etc..."

La création du cluster ne prend que quelques minutes. Attendez que le cluster soit déployé avec succès avant de passer à l’étape suivante.

Étape 5 : Vérifier le déploiement

Une fois le déploiement terminé, utilisez la commande suivante pour vérifier que votre cluster Kubernetes est opérationnel :

az aksarc show --resource-group "<resource-group-name>" --name "<cluster-name>" --output table

Étape 6 : Se connecter au cluster

  1. Pour vous connecter au cluster, exécutez la az connectedk8s proxy commande . La commande télécharge et exécute un fichier binaire proxy sur l’ordinateur client, puis extrait un fichier kubeconfig associé au cluster :

    az connectedk8s proxy --name <cluster name> -g <resource group>
    

    Vous pouvez également utiliser le client de ligne de commande Kubernetes, kubectl. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé. Pour installer et exécuter kubectl localement, exécutez la az aksarc install-cli commande .

    Configurez kubectl pour vous connecter à votre cluster Kubernetes à l’aide de la az aksarc get-credentials commande . Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser :

    az aksarc get-credentials --resource-group "<resource-group-name>" --name "<cluster-name>"
    
  2. Pour vérifier la connexion à votre cluster, exécutez la commande kubectl get. Cette commande retourne une liste des nœuds de cluster :

    kubectl get nodes -A --kubeconfig .\<path to kubecofig> 
    

    L’exemple de sortie suivant montre les trois nœuds créés aux étapes précédentes. Assurez-vous que l’état du nœud est Prêt :

    NAME                                STATUS   ROLES   AGE   VERSION
    aks-agentpool-27442051-vmss000000   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000001   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000002   Ready    agent   11m   v1.27.7
    

Ressources de modèle

connectedClusters

Nom Description Valeur
type Type de ressource. Microsoft.Kubernetes/ConnectedClusters
apiVersion Version de l’API de ressource. 2024-01-01
name Nom de la ressource. Chaîne (obligatoire)
Limite de caractères : 1-63
Caractères valides : alphanumériques, traits de soulignement et traits d’union.
Doit commencer et se terminer par un caractère alphanumérique.
location Emplacement géographique dans lequel réside la ressource. Chaîne (obligatoire).
tags Balises de ressource. Dictionnaire de noms et de valeurs d’étiquettes. Consultez Balises dans les modèles.
extendedLocation Emplacement étendu de la machine virtuelle. ExtendedLocation
identity Identité du cluster connecté, s’il est configuré.
properties Propriétés d’un cluster connecté.

ProvisionedClusterInstances

Nom Description Valeur
type Type de ressource microsoft.hybridcontainerservice/provisionedclusterinstances
apiVersion Version de l’API de ressource 2024-01-01
name Nom de la ressource Chaîne (obligatoire). Ne changez pas cette valeur par défaut.
properties Propriétés d’un cluster connecté.
extendedLocation Emplacement étendu du cluster. ExtendedLocation

ExtendedLocation

Nom Description Valeur
name ID de l’emplacement étendu. string
type Type de l’emplacement étendu. CustomLocation

Étapes suivantes

Vue d’ensemble d’AKS Arc