Partager via

Tutoriel : Déployer une application web ASP.NET à l’aide d’Azure Cosmos DB for NoSQL, d’une identité managée et d’AKS via Bicep

  • Article

S’APPLIQUE À : NoSQL

Dans ce tutoriel, vous allez déployer une application web ASP.NET de référence sur un cluster Azure Kubernetes Service (AKS) qui se connecte à Azure Cosmos DB for NoSQL.

Azure Cosmos DB est une plateforme de base de données distribuée complètement managée pour le développement d’applications modernes avec des bases de données NoSQL ou relationnelles.

AKS est un service Kubernetes managé qui vous aide à déployer et gérer rapidement des clusters.

Important

  • Cet article nécessite la dernière version de la ligne de commande Azure. Pour plus d’informations, consultez la rubrique Installation de l’interface de ligne de commande Azure (CLI). Si vous utilisez Azure Cloud Shell, sachez que la version la plus récente est déjà installée.
  • Cet article requiert également la dernière version de l’interface CLI Bicep au sein de l’interface de ligne de commande Azure. Pour plus d'informations, consultez Installer les outils Bicep.
  • Si vous exécutez les commandes de ce tutoriel localement et non pas dans Azure Cloud Shell, assurez-vous d’utiliser un compte administrateur.

Prérequis

Les outils suivants sont nécessaires pour compiler l’application web ASP.NET et créer son image conteneur :

Vue d'ensemble

Ce tutoriel utilise une approche Infrastructure as Code (IaC) pour déployer les ressources sur Azure. Vous utilisez Bicep, qui est un nouveau langage déclaratif qui offre les mêmes fonctionnalités que les modèles Azure Resource Manager. Toutefois, Bicep inclut une syntaxe plus concise et plus facile d’utilisation.

Les modules Bicep déploient les ressources Azure suivantes dans l’étendue de l’abonnement ciblé :

Ce tutoriel utilise les meilleures pratiques de sécurité suivantes pour Azure Cosmos DB :

Conseil

Les étapes de ce tutoriel utilisent Azure Cosmos DB for NoSQL. Toutefois, vous pouvez appliquer les mêmes concepts à Azure Cosmos DB for MongoDB.

Télécharger les modules Bicep

Téléchargez ou clonez les modules Bicep à partir du dossier Bicep du référentiel GitHub azure-samples/cosmos-aks-samples :

git clone https://github.com/Azure-Samples/cosmos-aks-samples.git

cd Bicep/

Connectez-vous à un abonnement Azure

Utilisez la commande az sign in pour vous connecter à votre abonnement Azure par défaut :

az login

Si vous le souhaitez, utilisez la commande az account set avec le nom ou l’ID d’un abonnement spécifique pour définir l’abonnement actif si vous avez plusieurs abonnements :

az account set \
  --subscription <subscription-id>

Initialiser les paramètres de déploiement

Créez un fichier param.json à l’aide du fichier JSON dans l’exemple suivant. Remplacez les espaces réservés {resource group name}, {Azure Cosmos DB account name} et {Azure Container Registry instance name} par vos valeurs.

Important

Tous les noms de ressources que vous utilisez dans le code suivant doivent respecter les règles de nommage et les restrictions pour les ressources Azure. Assurez-vous également que les valeurs d’espace réservé sont remplacées de manière cohérente et qu’elles correspondent aux valeurs dans param.json.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "rgName": {
      "value": "{resource group name}"
    },    
    "cosmosName" :{
      "value": "{Azure Cosmos DB account name}"
    },
    "acrName" :{
      "value": "{Azure Container Registry instance name}"
    }
  }
}

Créer un déploiement Bicep

Définissez des variables d’interpréteur de commandes à l’aide des commandes suivantes. Remplacez les espaces réservés {deployment name} et {location} par vos valeurs.

deploymentName='{deployment name}'  # Name of the deployment
location='{location}' # Location for deploying the resources

Dans le dossier Bicep, utilisez la commande az deployment sub create pour déployer le modèle dans l’étendue actuelle de l’abonnement :

az deployment sub create \
  --name $deploymentName \
  --location $location \
  --template-file main.bicep \
  --parameters @param.json

Pendant le déploiement, la console génère un message indiquant que le déploiement est toujours en cours d’exécution :

 / Running ..

Le déploiement peut prendre 20 à 30 minutes. Une fois l’approvisionnement terminé, la console génère JSON avec Succeeded comme état d’approvisionnement :

      }
    ],
    "provisioningState": "Succeeded",
    "templateHash": "0000000000000000",
    "templateLink": null,
    "timestamp": "2022-01-01T00:00:00.000000+00:00",
    "validatedResources": null
  },
  "tags": null,
  "type": "Microsoft.Resources/deployments"
}

Vous pouvez également voir l’état du déploiement dans le groupe de ressources :

Capture d’écran de l’état du déploiement du groupe de ressources dans le Portail Azure.

Notes

Lors de la création d’un cluster AKS, un deuxième groupe de ressources est automatiquement créé pour stocker les ressources AKS. Pour plus d’informations, consultez Pourquoi deux groupes de ressources sont-ils créés avec AKS ?.

Utilisez les commandes suivantes pour lier votre instance Azure Container Registry à AKS. Remplacez les espaces réservés {Azure Container Registry instance name} et {resource group name} par vos valeurs.

acrName='{Azure Container Registry instance name}'
rgName='{resource group name}'
aksName=$rgName'aks'

Exécutez az aks update pour attacher la ressource Azure Container Registry existante au cluster AKS :

az aks update \
  --resource-group $rgName \
  --name $aksName \
  --attach-acr $acrName

Se connecter au cluster AKS

Pour gérer un cluster Kubernetes, vous utilisez kubectl, le client de ligne de commande Kubernetes. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé. Pour installer kubectl localement, utilisez az aks install-cli :

az aks install-cli

Pour configurer kubectl afin qu’il se connecte à votre cluster Kubernetes, utilisez 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 $rgName \
  --name $aksName

Connecter les pods AKS à Azure Key Vault

Les identités managées par pod Microsoft Entra utilisent des primitives AKS pour associer des identités managées pour les ressources Azure et des identités dans Microsoft Entra ID avec des pods. Vous utilisez ces identités pour accorder au pilote Container Storage Interface (CSI) du magasin de secrets l’accès au fournisseur Azure Key Vault.

Utilisez la commande suivante pour rechercher les valeurs de l’ID de locataire (homeTenantId) :

az account show

Utilisez le modèle YAML suivant pour créer un fichier secretproviderclass.yml. Remplacez les espaces réservés {Tenant Id} et {resource group name} par vos valeurs. Vérifiez également que la valeur pour {resource group name} correspond à la valeur dans param.json.

# This is a SecretProviderClass example that uses aad-pod-identity to access the key vault
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: azure-kvname-podid
spec:
  provider: azure
  parameters:
    usePodIdentity: "true"               
    keyvaultName: "{resource group name}kv"       # Replace resource group name. Bicep generates the key vault name.
    tenantId: "{Tenant Id}"              # The tenant ID of your account. Use the 'homeTenantId' attribute value from  the 'az account show' command output.

Appliquer SecretProviderClass à votre cluster Azure Kubernetes Service

Utilisez la commande kubectl apply pour installer le pilote CSI du magasin de secrets à l’aide de YAML :

kubectl apply \
  --filename secretproviderclass.yml

Générer l’application web ASP.NET

Téléchargez ou clonez le code source de l’application web à partir du dossier Application du référentiel GitHub azure-samples/cosmos-aks-samples :

git clone https://github.com/Azure-Samples/cosmos-aks-samples.git

cd Application/

Ouvrez le dossier Application dans Visual Studio Code. Exécutez l’application à l’aide de la clé F5 ou de la commande Débogage : Démarrer le débogage.

Envoyer (push) l’image conteneur Docker à Azure Container Registry

  1. Pour créer une image conteneur à partir de l’onglet Explorateur dans Visual Studio Code, cliquez avec le bouton droit sur Dockerfile, puis sélectionnez Générer une image.

    Capture d’écran du menu contextuel dans Visual Studio Code avec l’option « Générer une image sélectionnée ».

  2. Dans l’invite qui demande le nom et la version pour étiquetez l’image, entrez le nom todo:latest.

  3. Utilisez le volet Docker pour envoyer l’image générée à Azure Container Registry. Vous trouverez l’image générée sous le nœud Images. Ouvrez le nœud todo, cliquez avec le bouton droit sur latest, puis sélectionnez Push (Envoyer).

    Capture d’écran du menu contextuel dans Visual Studio Code avec l’option « Envoyer (push) » sélectionnée.

  4. Dans les invites, sélectionnez votre abonnement Azure, la ressource Azure Container Registry et les étiquettes d’image. Le format d’étiquette d’image doit être {acrname}.azurecr.io/todo:latest.

  5. Attendez que Visual Studio Code envoie l’image conteneur à Azure Container Registry.

Préparer le fichier YAML de déploiement

Utilisez le modèle YAML suivant pour créer un fichier akstododeploy.yml. Remplacez les espaces réservés {ACR name}, {Image name}, {Version} et {resource group name} par vos valeurs.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: todo
  labels:
    aadpodidbinding: "cosmostodo-apppodidentity"
    app: todo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: todo
  template:
    metadata:
      labels:
        app: todo
        aadpodidbinding: "cosmostodo-apppodidentity"
    spec:
      containers:
      - name: mycontainer
        image: "{ACR name}/{Image name}:{Version}"   # Update per your environment; for example, myacrname.azurecr.io/todo:latest. Do not add https:// in ACR Name.
        ports:
        - containerPort: 80
        env:
        - name: KeyVaultName
          value: "{resource group name}kv"       # Replace resource group name. Key Vault name is generated by Bicep.
      nodeSelector:
        kubernetes.io/os: linux
      volumes:
        - name: secrets-store01-inline
          csi:
            driver: secrets-store.csi.k8s.io
            readOnly: true
            volumeAttributes:
              secretProviderClass: "azure-kvname-podid"       
---
    
kind: Service
apiVersion: v1
metadata:
  name: todo
spec:
  selector:
    app: todo
    aadpodidbinding: "cosmostodo-apppodidentity"    
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

Appliquer le fichier YAML de déploiement

Utilisez kubectl apply à nouveau pour déployer les pods d’application et exposer les pods via un équilibreur de charge :

kubectl apply \
  --filename akstododeploy.yml \
  --namespace 'my-app'

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.

Utilisez la commande kubectl get pour afficher l’adresse IP externe exposée par l’équilibreur de charge :

kubectl get services \
  --namespace "my-app"

Pour accéder à l’application, ouvrez l’adresse IP que vous avez reçue en tant que sortie dans un navigateur.

Nettoyer les ressources

Pour éviter des frais Azure, nettoyez les ressources inutiles lorsque vous n’avez plus besoin du cluster. Utilisez les commandes az group delete et az deployment sub delete pour supprimer respectivement le groupe de ressources et le déploiement d’abonnement :

az group delete \
  --resource-group $rgName 
  --yes

az deployment sub delete \
  --name $deploymentName

Contenu connexe