Tutorial: Bereitstellen einer ASP.NET Webanwendung mithilfe von Azure Cosmos DB for NoSQL, verwalteter Identität und AKS über Bicep

GILT FÜR: NoSQL

In diesem Tutorial stellen Sie eine ASP.NET-Webanwendung als Verweis in einem Azure Kubernetes Service (AKS)-Cluster bereit, der eine Verbindung mit Azure Cosmos DB for NoSQL herstellt.

Azure Cosmos DB ist eine vollständig verwaltete, verteilte Datenbankplattform für die moderne Anwendungsentwicklung mit NoSQL oder relationalen Datenbanken.

AKS ist ein verwalteter Kubernetes-Dienst, mit dem Sie Cluster schnell bereitstellen und verwalten können.

Wichtig

• Für diesen Artikel ist die aktuelle Azure CLI-Version erforderlich. Weitere Informationen finden Sie unter Installieren der Azure-Befehlszeilenschnittstelle. Bei Verwendung von Azure Cloud Shell ist die aktuelle Version bereits installiert.
• Für diesen Artikel ist auch die aktuelle Bicep CLI-Version in der Azure CLI erforderlich. Weitere Informationen finden Sie unter Installieren von Bicep-Tools.
• Wenn Sie die Befehle in diesem Tutorial lokal anstatt in Azure Cloud Shell ausführen, stellen Sie sicher, dass Sie ein Administratorkonto verwenden.

Voraussetzungen

Die folgenden Tools sind erforderlich, um die ASP.NET-Webanwendung zu kompilieren und das Containerimage zu erstellen:

• Docker Desktop
• Visual Studio Code
  • C#-Erweiterung für Visual Studio Code
  • Docker-Erweiterung für Visual Studio Code
  • Azure-Kontoerweiterung für Visual Studio Code

Übersicht

In diesem Tutorial wird ein Infrastructure-as-Code (IaC)-Ansatz verwendet, um die Ressourcen in Azure bereitzustellen. Sie verwenden Bicep, eine neue deklarative Sprache, die dieselben Funktionen wie Azure Resource Manager-Vorlagen bietet. Bicep enthält jedoch eine Syntax, die präziser und einfacher zu verwenden ist.

Die Bicep-Module stellen die folgenden Azure-Ressourcen im Zielabonnementbereich bereit:

• Ressourcengruppe zum Organisieren der Ressourcen
• Verwaltete Identität zur Authentifizierung
• Containerregistrierung zum Speichern von Containerimages
• AKS-Cluster
• Virtuelles Netzwerk zum Konfigurieren von AKS
• Azure Cosmos DB for NoSQL-Konto, zusammen mit einer Datenbank, einem Container und der SQL-Rolle
• Schlüsseltresor zum Speichern von sicheren Schlüsseln
• (Optional) Log Analytics-Arbeitsbereich

In diesem Tutorial werden die folgenden bewährten Methoden für die Sicherheit von Azure Cosmos DB verwendet:

• Implementieren Sie die Zugriffssteuerung mithilfe der rollenbasierten Zugriffssteuerung (RBAC) und einer verwalteten Identität. Mit diesen Features müssen Entwickler nicht mehr Geheimnisse, Anmeldeinformationen, Zertifikate und Schlüssel für die sichere Kommunikation zwischen Diensten verwalten.
• Schränken Sie den Azure Cosmos DB-Zugriff auf das AKS-Subnetz ein, indem Sie einen VNET-Dienstendpunkt konfigurieren.
• Legen Sie disableLocalAuth = true in der databaseAccount-Ressource fest, um RBAC als einzige Authentifizierungsmethode zu erzwingen.

Tipp

Für die Schritte in diesem Tutorial wird Azure Cosmos DB for NoSQL verwendet. Sie können jedoch die gleichen Konzepte auf Azure Cosmos DB for MongoDB anwenden.

Herunterladen der Bicep-Module

Laden Sie die Bicep-Module aus dem Bicep-Ordner des GitHub-Repository azure-samples/cosmos-aks-samples herunter oder klonen Sie sie:

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

cd Bicep/

Verbinden mit Ihrem Azure-Abonnement

Verwenden Sie az sign in, um eine Verbindung mit Ihrer Azure-Standardsubscription herzustellen:

az login

Verwenden Sie optional az account set mit dem Namen oder der ID eines bestimmten Abonnements, um das aktive Abonnement festzulegen, wenn Sie mehrere Abonnements haben:

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

Initialisieren der Bereitstellungsparameter

Erstellen Sie eine param.json-Datei mithilfe des JSON-Codes im folgenden Beispiel. Ersetzen Sie die Platzhalter {resource group name}, {Azure Cosmos DB account name} und {Azure Container Registry instance name} durch Ihre eigenen Werte.

Wichtig

Alle Ressourcennamen, die Sie im folgenden Code verwenden, sollten den Benennungsregeln und -einschränkungen für Azure-Ressourcen entsprechen. Stellen Sie außerdem sicher, dass die Platzhalterwerte konsistent ersetzt werden und den Werten in param.json entsprechen.

{
  "$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}"
    }
  }
}

Erstellen einer Bicep-Bereitstellung

Legen Sie Shellvariablen mithilfe der folgenden Befehle fest. Ersetzen Sie die Platzhalter {deployment name} und {location} durch Ihre eigenen Werte.

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

Verwenden Sie az deployment sub create im Bicep-Ordner, um die Vorlage im aktuellen Abonnementbereich bereitzustellen:

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

Während der Bereitstellung gibt die Konsole eine Meldung aus, die besagt, dass die Bereitstellung weiterhin ausgeführt wird:

 / Running ..

Die Bereitstellung kann 20 bis 30 Minuten dauern. Nach Abschluss der Bereitstellung gibt die Konsole JSON mit Succeeded als Bereitstellungsstatus aus:

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

Sie können auch den Bereitstellungsstatus in der Ressourcengruppe anzeigen:

Hinweis

Beim Erstellen eines AKS-Clusters wird automatisch eine zweite Ressourcengruppe erstellt, um die AKS-Ressourcen zu speichern. Weitere Informationen finden Sie unter Warum werden zwei Ressourcengruppen mit AKS erstellt?

Verbinden von Azure Container Registry mit AKS

Verwenden Sie die folgenden Befehle, um Ihre Azure Container Registry-Instanz mit AKS zu verknüpfen. Ersetzen Sie die Platzhalter {Azure Container Registry instance name} und {resource group name} durch Ihre eigenen Werte.

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

Führen Sie az aks update aus, um die vorhandene Azure Container Registry-Ressource dem AKS-Cluster anzuschließen:

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

Herstellen einer Verbindung mit dem AKS-Cluster

Verwenden Sie zum Verwalten eines Kubernetes-Clusters den Kubernetes-Befehlszeilenclient kubectl. Bei Verwendung von Azure Cloud Shell ist kubectl bereits installiert. Um kubectl lokal zu installieren, verwenden Sie az aks install-cli:

az aks install-cli

Mit dem Befehl az aks get-credentials können Sie kubectl konfigurieren, um die Verbindung mit dem Kubernetes-Cluster herzustellen. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

az aks get-credentials \
  --resource-group $rgName \
  --name $aksName

Herstellen der Verbindung von AKS-Pods mit Azure Key Vault

Für verwaltete Microsoft Entra-Podidentitäten werden AKS-Primitive verwendet, um verwaltete Identitäten für Azure-Ressourcen und Identitäten in Microsoft Entra ID Pods zuzuordnen. Mithilfe dieser Identitäten können Sie Zugriff auf den Azure Key Vault-Anbieter für den Geheimnisspeicher Container Storage Interface-Treiber (CSI) gewähren.

Verwenden Sie den folgenden Befehl, um die Werte der Mandanten-ID (homeTenantId) anzuzeigen:

az account show

Verwenden Sie die folgende YAML-Vorlage, um eine secretproviderclass.yml-Datei zu erstellen. Ersetzen Sie die Platzhalter {Tenant Id} und {resource group name} durch Ihre eigenen Werte. Stellen Sie außerdem sicher, dass der Wert für {resource group name} mit dem Wert in param.json übereinstimmt.

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

Anwenden von SecretProviderClass auf den AKS-Cluster

Verwenden Sie kubectl apply, um den Secrets Store CSI-Treiber mithilfe von YAML zu installieren:

kubectl apply \
  --filename secretproviderclass.yml

Erstellen der ASP.NET-Webanwendung

Laden Sie den Quellcode der Webanwendung aus dem Ordner Application des GitHub-Repository azure-samples/cosmos-aks-samples herunter oder klonen Sie ihn:

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

cd Application/

Öffnen Sie den Ordner Application in Visual Studio Code. Führen Sie die Anwendung entweder mit der Taste F5 oder dem Befehl Debuggen: Debuggen starten aus.

Pushen des Docker-Containerimage in Azure Container Registry

1. Wenn Sie ein Containerimage über die Registerkarte Explorer in Visual Studio Code erstellen möchten, klicken Sie mit der rechten Maustaste auf Dockerfile, und wählen Sie dann Image erstellen aus.

   

2. Geben Sie in der Eingabeaufforderung, die den Namen und die Version zum Kennzeichnen des Images anfordert, den Namen todo:latest ein.

3. Verwenden Sie den Docker-Bereich, um das integrierte Image an Azure Container Registry zu übertragen. Das erstellte Image finden Sie unter dem Knoten Bilder. Öffnen Sie den Knoten todo, klicken Sie mit der rechten Maustaste auf latest, und wählen Sie dann Push aus.

   

4. Wählen Sie in den Eingabeaufforderungen Ihr Azure-Abonnement, die Azure Container Registry-Ressource und Imagetags aus. Das Format des Image-Tag muss {acrname}.azurecr.io/todo:latest sein.

5. Warten Sie, bis in Visual Studio Code das Containerimage an Azure Container Registry gepusht werden kann.

Vorbereiten der Bereitstellungs-YAML

Verwenden Sie die folgende YAML-Vorlage, um eine akstododeploy.yml-Datei zu erstellen. Ersetzen Sie die Platzhalter {ACR name}, {Image name}, {Version} und {resource group name} durch Ihre eigenen Werte.

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

Anwenden der Bereitstellungs-YAML

Verwenden Sie kubectl apply erneut, um die Anwendungspods bereitzustellen und die Pods über einen Lastenausgleich verfügbar zu machen:

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

Testen der Anwendung

Wenn die Anwendung ausgeführt wird, macht ein Kubernetes-Dienst das Front-End der Anwendung im Internet verfügbar. Dieser Vorgang kann einige Minuten dauern.

Verwenden Sie kubectl get zum Anzeigen der externen IP-Adresse, die vom Lastenausgleich verfügbar gemacht wird:

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

Um auf die Anwendung zuzugreifen, öffnen Sie die IP-Adresse, die Sie als Ausgabe in einem Browser erhalten haben.

Bereinigen der Ressourcen

Zum Vermeiden von Azure-Gebühren sollten Sie nicht erforderliche Ressourcen bereinigen, wenn Sie den Cluster nicht mehr benötigen. Verwenden Sie az group delete und az deployment sub delete, um die Ressourcengruppe bzw. die Abonnementbereitstellung zu löschen:

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

az deployment sub delete \
  --name $deploymentName

Zugehöriger Inhalt

• Führen Sie eine Abfrage auf Azure Cosmos DB for NoSQL durch.
• Führen Sie ein Upgrade Ihres Clusters durch.
• Skalieren Sie Ihren Cluster.
• Aktivieren Sie Continuous Deployment.