Självstudie: Distribuera ett ASP.NET webbprogram med hjälp av Azure Cosmos DB för NoSQL, hanterad identitet och AKS via Bicep

Artikel
10/18/2023

GÄLLER FÖR: NoSQL

I den här självstudien distribuerar du en referens ASP.NET webbprogram i ett AKS-kluster (Azure Kubernetes Service) som ansluter till Azure Cosmos DB för NoSQL.

Azure Cosmos DB är en fullständigt hanterad distribuerad databasplattform för modern programutveckling med NoSQL eller relationsdatabaser.

AKS är en hanterad Kubernetes-tjänst som hjälper dig att snabbt distribuera och hantera kluster.

Viktigt!

Den här artikeln kräver den senaste versionen av Azure CLI. Mer information finns i Installera Azure CLI. Om du använder Azure Cloud Shell är den senaste versionen redan installerad.
Den här artikeln kräver också den senaste versionen av Bicep CLI i Azure CLI. Mer information finns i Installera Bicep-verktyg.
Om du kör kommandona i den här självstudien lokalt i stället för i Azure Cloud Shell kontrollerar du att du använder ett administratörskonto.

Förutsättningar

Följande verktyg krävs för att kompilera ASP.NET webbappen och skapa dess containeravbildning:

Docker Desktop
Visual Studio Code
- C#-tillägg för Visual Studio Code
- Docker-tillägg för Visual Studio Code
- Azure-kontotillägg för Visual Studio Code

Översikt

I den här självstudien används en IaC-metod (infrastruktur som kod) för att distribuera resurserna till Azure. Du använder Bicep, som är ett nytt deklarativt språk som erbjuder samma funktioner som Azure Resource Manager-mallar. Bicep innehåller dock en syntax som är mer koncis och enklare att använda.

Bicep-modulerna distribuerar följande Azure-resurser inom det riktade prenumerationsomfånget:

En resursgrupp för att organisera resurserna
En hanterad identitet för autentisering
Ett containerregister för lagring av containeravbildningar
Ett AKS-kluster
Ett virtuellt nätverk för att konfigurera AKS
Ett Azure Cosmos DB för NoSQL-konto, tillsammans med en databas, en container och SQL-rollen
Ett nyckelvalv för att lagra säkra nycklar
(Valfritt) En Log Analytics-arbetsyta

I den här självstudien används följande metodtips för säkerhet med Azure Cosmos DB:

Implementera åtkomstkontroll med hjälp av rollbaserad åtkomstkontroll (RBAC) och en hanterad identitet. Dessa funktioner eliminerar behovet av att utvecklare hanterar hemligheter, autentiseringsuppgifter, certifikat och nycklar för säker kommunikation mellan tjänster.
Begränsa Azure Cosmos DB-åtkomsten till AKS-undernätet genom att konfigurera en tjänstslutpunkt för virtuellt nätverk.
Ange disableLocalAuth = true i resursen databaseAccount för att framtvinga RBAC som den enda autentiseringsmetoden.

Dricks

Stegen i den här självstudien använder Azure Cosmos DB för NoSQL. Du kan dock använda samma begrepp för Azure Cosmos DB för MongoDB.

Ladda ned Bicep-modulerna

Ladda ned eller klona Bicep-modulerna från mappen Bicep på GitHub-lagringsplatsen azure-samples/cosmos-aks-samples :

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

cd Bicep/

Ansluta till din Azure-prenumeration

Använd az login för att ansluta till din azure-standardprenumeration:

az login

Du kan också använda az account set med namnet eller ID:t för en specifik prenumeration för att ange den aktiva prenumerationen om du har flera prenumerationer:

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

Initiera distributionsparametrarna

Skapa en param.json fil med hjälp av JSON i följande exempel. {resource group name}Ersätt platshållarna , {Azure Cosmos DB account name}och {Azure Container Registry instance name} med dina egna värden.

Viktigt!

Alla resursnamn som du använder i följande kod ska följa namngivningsreglerna och begränsningarna för Azure-resurser. Kontrollera också att platshållarvärdena ersätts konsekvent och matchar värdena i 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}"
    }
  }
}

Skapa en Bicep-distribution

Ange gränssnittsvariabler med hjälp av följande kommandon. {deployment name} Ersätt platshållarna och {location} med dina egna värden.

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

I mappen Bicep använder du az deployment sub create för att distribuera mallen till det aktuella prenumerationsomfånget:

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

Under distributionen skickar konsolen ett meddelande som anger att distributionen fortfarande körs:

 / Running ..

Distributionen kan ta mellan 20 och 30 minuter. När etableringen är klar matar konsolen ut JSON med Succeeded etableringstillståndet:

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

Du kan också se distributionsstatusen i resursgruppen:

Kommentar

När du skapar ett AKS-kluster skapas en andra resursgrupp automatiskt för att lagra AKS-resurserna. Mer information finns i Varför skapas två resursgrupper med AKS?.

Länka Azure Container Registry med AKS

Använd följande kommandon för att länka din Azure Container Registry-instans med AKS. {Azure Container Registry instance name} Ersätt platshållarna och {resource group name} med dina egna värden.

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

Kör az aks update för att koppla den befintliga Azure Container Registry-resursen till AKS-klustret:

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

Ansluta till AKS-klustret

För att hantera Kubernetes-kluster använder du kubectl, Kubernetes kommandoradsklient. Om du använder Azure Cloud Shell är kubectl redan installerat. Om du vill installera kubectl lokalt använder du az aks install-cli:

az aks install-cli

Du konfigurerar kubectl för anslutning till Kubernetes-klustret med kommandot az aks get-credentials. Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

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

Ansluta AKS-poddar till Azure Key Vault

Microsoft Entra-poddhanterade identiteter använder AKS-primitiver för att associera hanterade identiteter för Azure-resurser och identiteter i Microsoft Entra-ID med poddar. Du använder dessa identiteter för att ge åtkomst till Azure Key Vault-providern för Secrets Store CSI-drivrutinen.

Använd följande kommando för att hitta värdena för klientorganisations-ID :t (homeTenantId):

az account show

Använd följande YAML-mall för att skapa en secretproviderclass.yml fil. {Tenant Id} Ersätt platshållarna och {resource group name} med dina egna värden. Kontrollera också att värdet för {resource group name} matchar värdet i 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.

Tillämpa SecretProviderClass på AKS-klustret

Använd kubectl apply för att installera CSI-drivrutinen för Secrets Store med hjälp av YAML:

kubectl apply \
  --filename secretproviderclass.yml

Skapa ASP.NET webbappen

Ladda ned eller klona webbprogrammets källkod från programmappen för GitHub-lagringsplatsen azure-samples/cosmos-aks-samples:

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

cd Application/

Öppna programmappen i Visual Studio Code. Kör programmet med hjälp av antingen F5-nyckeln eller kommandot Felsök: Starta felsökning .

Skicka Docker-containeravbildningen till Azure Container Registry

Om du vill skapa en containeravbildning från fliken Utforskaren i Visual Studio Code högerklickar du på Dockerfile och väljer sedan Skapa avbildning.
Ange namnet todo:latest i prompten som ber om att namnet och versionen ska tagga avbildningen.
Använd Docker-fönstret för att skicka den skapade avbildningen till Azure Container Registry. Du hittar den skapade avbildningen under noden Bilder . Öppna todo-noden, högerklicka på senaste och välj sedan Push.
I anvisningarna väljer du din Azure-prenumeration, Azure Container Registry-resurs och avbildningstaggar. Bildtaggformatet ska vara {acrname}.azurecr.io/todo:latest.
Vänta tills Visual Studio Code skickar containeravbildningen till Azure Container Registry.

Förbereda distributionens YAML

Använd följande YAML-mall för att skapa en akstododeploy.yml fil. {ACR name}Ersätt platshållarna , {Image name}, {Version}och {resource group name} med dina egna värden.

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

Tillämpa distributionens YAML

Använd kubectl apply igen för att distribuera programpoddar och exponera poddarna via en lastbalanserare:

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

Testa programmet

När programmet körs exponerar en Kubernetes-tjänst programmets klientdel till Internet. Den här processen kan ta ett par minuter att slutföra.

Använd kubectl get för att visa den externa IP-adressen som lastbalanseraren exponerar:

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

Öppna DEN IP-adress som du fick som utdata i en webbläsare för att få åtkomst till programmet.

Rensa resurserna

Undvik Azure-avgifter genom att rensa onödiga resurser när du inte längre behöver klustret. Använd az group delete och az deployment sub delete för att ta bort resursgruppen respektive prenumerationsdistributionen:

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

az deployment sub delete \
  --name $deploymentName

Nästa steg

Lär dig hur du utvecklar ett webbprogram med Azure Cosmos DB.
Lär dig hur du kör frågor mot Azure Cosmos DB för NoSQL.
Lär dig hur du uppgraderar klustret.
Lär dig hur du skalar klustret.
Lär dig hur du aktiverar kontinuerlig distribution.

Dela via