Partager via

Démarrage rapide : Déployer un cluster AKS Azure Linux avec OS Guard (préversion) à l’aide d’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). Après avoir installé les prérequis, vous allez installer l’extension Azure CLI aks-preview, inscrire l’indicateur de fonctionnalité AzureLinuxOSGuardPreview, 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 JSON (JavaScript Object Notation) 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.

Considérations et limitations

Avant de commencer, passez en revue les considérations et limitations suivantes pour Azure Linux avec OS Guard (préversion) :

Prerequisites

  • Si vous n’avez pas de compte Azure, créez un compte gratuit 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 des commandes de référence CLI localement, installez 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 Comment 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 terminer 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 effectuer une mise à niveau vers 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-cli ou 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.

Installer l’extension Azure CLI aks-preview

Important

Les fonctionnalités d’évaluation AKS sont disponibles en libre-service et font l’objet d’un abonnement. Les versions d'essai sont fournies « en l’état » et « selon disponibilité », et elles sont exclues des contrats de niveau de service et de la garantie limitée. Les versions préliminaires AKS sont, dans la mesure du possible, partiellement couvertes par le service clientèle. Par conséquent, ces fonctionnalités ne sont pas destinées à une utilisation en production. Pour plus d’informations, consultez les articles de support suivants :

Exécutez la commande suivante pour installer l’extension aks-preview :

az extension add --name aks-preview

Exécutez la commande suivante pour effectuer la mise à jour vers la dernière version de l’extension publiée :

az extension update --name aks-preview

Inscrire l’indicateur de fonctionnalité AzureLinuxOSGuardPreview

Inscrivez l’indicateur AzureLinuxOSGuardPreview de fonctionnalité à l’aide de la commande [az feature register][az-feature-register] comme indiqué dans l’exemple suivant :

az feature register --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"

Quelques minutes sont nécessaires pour que l’état s’affiche Registered (Inscrit). Vérifiez l’état de l’inscription à l’aide de la commande [az feature show][az-feature-show] :

az feature show --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"

Lorsque l’état reflète Inscrit, actualisez l’inscription du fournisseur de ressources Microsoft.ContainerService à l’aide de la commande [az provider register][az-provider-register] :

az provider register --namespace "Microsoft.ContainerService"

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

  1. Accédez à https://shell.azure.com pour ouvrir Cloud Shell dans votre navigateur.

  2. 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": {
            "defaultValue": "osguardakscluster",
            "type": "String",
            "metadata": {
                "description": "The name of the Managed Cluster resource."
            }
        },
        "location": {
            "defaultValue": "[resourceGroup().location]",
            "type": "String",
            "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."
            }
        },
        "agentCount": {
            "defaultValue": 3,
            "minValue": 1,
            "maxValue": 50,
            "type": "Int",
            "metadata": {
                "description": "The number of nodes for the cluster."
            }
        },
        "agentVMSize": {
            "defaultValue": "Standard_DS2_v2",
            "type": "String",
            "metadata": {
                "description": "The size of the Virtual Machine."
            }
        },
        "osSKU": {
            "defaultValue": "AzureLinuxOSGuard",
            "allowedValues": [
                "AzureLinuxOSGuard",
                "AzureLinux3OSGuard"
            ],
            "type": "String",
            "metadata": {
                "description": "The Linux SKU to use."
            }
        }
    },
    "resources": [
        {
            "type": "Microsoft.ContainerService/managedClusters",
            "apiVersion": "2025-05-01",
            "name": "[parameters('clusterName')]",
            "location": "[parameters('location')]",
            "identity": {
                "type": "SystemAssigned"
            },
            "properties": {
                "dnsPrefix": "[parameters('dnsPrefix')]",
                "agentPoolProfiles": [
                    {
                        "name": "agentpool",
                        "mode": "System",
                        "count": "[parameters('agentCount')]",
                        "vmSize": "[parameters('agentVMSize')]",
                        "osType": "Linux",
                        "osSKU": "[parameters('osSKU')]",
                        "osDiskType": "Managed",
                        "enableFIPS": true,
                        "securityProfile": {
                            "enableSecureBoot": true,
                            "enableVTPM": true
                        },
                    }
                ]
            }
        }
    ],
    "outputs": {
        "controlPlaneFQDN": {
            "type": "String",
            "value": "[reference(parameters('clusterName')).fqdn]"
        }
    }
}

Pour ajouter Azure Linux avec OS Guard à un modèle ARM existant, vous devez ajouter :

  • "osSKU": "AzureLinuxOSGuard"
  • "mode": "System" à agentPoolProfiles
  • "osDiskType": "Managed" à agentPoolProfiles
  • "enableFIPS": true à agentPoolProfiles
  • "securityProfile": {enableSecureBoot: true enableVTPM: true} à agentPoolProfiles
  • définissez apiVersion sur 2025-05-01 ou version ultérieure ("apiVersion": "2025-05-01").

Déployer le modèle

  1. Sélectionnez le bouton suivant pour vous connecter à Azure et ouvrir un modèle.

    Bouton pour déployer le modèle Resource Manager sur Azure.

  2. 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 testAzureLinuxOSGuardResourceGroup, puis choisissez OK.
    • Emplacement : sélectionnez un emplacement, comme USA Est.
    • Nom du cluster : entrez un nom unique pour le cluster AKS, tel que testAzureLinuxOSGuardCluster.
    • Préfixe DNS : entrez un préfixe DNS unique pour votre cluster, tel que myAzureLinuxOSGuardCluster.
    • 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).

  3. Sélectionnez Vérifier + créer.

La création d’Azure Linux avec le cluster OS Guard 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.

  1. Installez kubectl en local avec la commande az aks install-cli :

    az aks install-cli

  2. Configurez kubectl afin de vous connecter à votre cluster Kubernetes avec la commande az 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 testAzureLinuxOSGuardResourceGroup --name testAzureLinuxCluster

  3. Pour vérifier la connexion à votre cluster, exécutez la commande kubectl get. Cette commande renvoie la liste des nœuds de cluster.

    kubectl get nodes

    L’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.

  1. Créez un fichier appelé azure-vote.yaml.

    • Si vous utilisez Azure Cloud Shell, vous pouvez créer ce fichier à l’aide de code, vi ou nano comme si vous travailliez sur un système virtuel ou physique

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

    Pour obtenir une répartition des fichiers manifeste YAML, consultez Déploiements et manifestes YAML.

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

    L’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

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

Capture d’écran de la navigation vers l’exemple d’application Azure Vote.

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 testAzureLinuxOSGuardCluster --yes --no-wait

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez déployé un cluster Azure Linux avec OS Guard. Pour en savoir plus sur Azure Linux avec OS Guard et découvrir un exemple complet de déploiement et de gestion de cluster, passez au didacticiel Azure Linux avec OS Guard.

Didacticiel sur Azure Linux OS Guard

  • Last updated on