Condividi tramite

Esercitazione: Distribuire un'applicazione Web ASP.NET usando Azure Cosmos DB per NoSQL, l'identità gestita e il servizio Azure Kubernetes tramite Bicep

  • Articolo

SI APPLICA A: NoSQL

In questa esercitazione si distribuirà un riferimento ASP.NET applicazione Web in un cluster del servizio Azure Kubernetes che si connette ad Azure Cosmos DB per NoSQL.

Azure Cosmos DB è una piattaforma di database completamente distribuita per lo sviluppo di applicazioni moderne con NoSQL o database relazionali.

Il servizio Azure Kubernetes è un servizio Kubernetes gestito che consente di distribuire e gestire rapidamente i cluster.

Importante

  • Questo articolo richiede l'ultima versione dell'interfaccia della riga di comando di Azure. Per altre informazioni, vedere Installare l'interfaccia della riga di comando di Azure. Se si sta usando Azure Cloud Shell, la versione più recente è già installata.
  • Questo articolo richiede anche la versione più recente dell'interfaccia della riga di comando di Bicep all'interno dell'interfaccia della riga di comando di Azure. Per altre informazioni, vedere Installare gli strumenti Bicep.
  • Se si eseguono i comandi in questa esercitazione in locale anziché in Azure Cloud Shell, assicurarsi di usare un account amministratore.

Prerequisiti

Per compilare l'applicazione Web ASP.NET e creare l'immagine del contenitore, sono necessari gli strumenti seguenti:

Panoramica

Questa esercitazione usa un approccio infrastructure as code (IaC) per distribuire le risorse in Azure. Si userà Bicep, che è un nuovo linguaggio dichiarativo che offre le stesse funzionalità dei modelli di Azure Resource Manager. Tuttavia, Bicep include una sintassi più concisa e più facile da usare.

I moduli Bicep distribuiranno le risorse di Azure seguenti nell'ambito della sottoscrizione di destinazione:

Questa esercitazione usa le procedure consigliate per la sicurezza seguenti con Azure Cosmos DB:

Suggerimento

I passaggi di questa esercitazione usano Azure Cosmos DB per NoSQL. Tuttavia, è possibile applicare gli stessi concetti ad Azure Cosmos DB per MongoDB.

Scaricare i moduli Bicep

Scaricare o clonare i moduli Bicep dalla cartella Bicep del repository GitHub azure-samples/cosmos-aks-samples:

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

cd Bicep/

Connettersi alla sottoscrizione di Azure

Usare az login per connettersi alla sottoscrizione di Azure predefinita:

az login

Facoltativamente, usare az account set con il nome o l'ID di una sottoscrizione specifica per impostare la sottoscrizione attiva se si hanno più sottoscrizioni:

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

Inizializzare i parametri di distribuzione

Creare un file param.json usando il codice JSON nell'esempio seguente. Sostituire i segnaposto {resource group name}, {Azure Cosmos DB account name} e {Azure Container Registry instance name} con i propri valori.

Importante

Tutti i nomi di risorse usati nel codice seguente devono essere conformi alle regole di denominazione e alle restrizioni per le risorse di Azure. Assicurarsi inoltre che i valori segnaposto vengano sostituiti in modo coerente e corrispondano ai valori in 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}"
    }
  }
}

Creare una distribuzione Bicep

Impostare le variabili della shell usando i comandi seguenti. Sostituire i segnaposto {deployment name} e {location} con i propri valori.

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

Nella cartella Bicep, usare az deployment sub create per distribuire il modello nell'ambito della sottoscrizione corrente:

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

Durante la distribuzione, la console restituirà un messaggio che indica che la distribuzione è ancora in esecuzione:

 / Running ..

La distribuzione potrebbe richiedere da 20 a 30 minuti. Al termine del provisioning, la console restituirà JSON con Succeeded come stato di provisioning:

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

È anche possibile visualizzare lo stato della distribuzione nel gruppo di risorse:

Screenshot dello stato della distribuzione per il gruppo di risorse nel portale di Azure.

Nota

Quando si crea un cluster del servizio Azure Kubernetes, viene creato automaticamente un secondo gruppo di risorse per archiviare le risorse del servizio Azure Kubernetes. Per altre informazioni, vedere Perché vengono creati due gruppi di risorse con servizio Azure Kubernetes?.

Usare i comandi seguenti per collegare l'istanza di Registro Azure Container al servizio Azure Kubernetes. Sostituire i segnaposto {Azure Container Registry instance name} e {resource group name} con i propri valori.

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

Eseguire az aks update per collegare la risorsa esistente di Registro Azure Container al cluster del servizio Azure Kubernetes:

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

Connettersi al cluster servizio Azure Kubernetes

Per gestire un cluster Kubernetes, usare kubectl, il client della riga di comando Kubernetes. Se si usa Azure Cloud Shell, kubectl è già installato. Per installare kubectl localmente, usare az aks install-cli:

az aks install-cli

Per configurare kubectl per la connessione al cluster Kubernetes, usare az servizio Azure Kubernetes get-credentials. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarli.

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

Connettere i pod del servizio Azure Kubernetes ad Azure Key Vault

Le identità gestite dai pod di Microsoft Entra usano primitive AKS per associare identità gestite per le risorse e le identità di Azure nell'ID Microsoft Entra con i pod. Queste identità verranno usate per concedere l'accesso al provider di Azure Key Vault per il driver CSI dell'archivio segreti.

Usare il comando seguente per trovare i valori dell'ID tenant (homeTenantId):

az account show

Usare il modello YAML seguente per creare un file secretproviderclass.yml. Sostituire i segnaposto {Tenant Id} e {resource group name} con i propri valori. Assicurarsi anche che il valore per {resource group name} corrisponda al valore in 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.

Applicare SecretProviderClass al cluster del servizio Azure Kubernetes

Usare kubectl apply per installare il driver CSI dell'archivio segreti usando YAML:

kubectl apply \
  --filename secretproviderclass.yml

Compilare l'applicazione Web ASP.NET

Scaricare o clonare il codice sorgente dell'applicazione Web dalla cartella Applicazione del repository GitHub azure-samples/cosmos-aks-samples:

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

cd Application/

Aprire la cartella Applicazione in Visual Studio Code. Eseguire l'applicazione usando il tasto F5 o il comando Debug: Avvia debug.

Eseguire il push dell'immagine del contenitore Docker in Registro Azure Container

  1. Per creare un'immagine del contenitore dalla scheda Explorer in Visual Studio Code, fare clic con il pulsante destro del mouse su Dockerfile e quindi scegliereCompila immagine.

    Screenshot del menu di scelta rapida in Visual Studio Code con l'opzione Compila immagine selezionata.

  2. Nel prompt che richiede il nome e la versione per contrassegnare l'immagine, immettere il nome todo:latest.

  3. Usare il riquadro Docker per eseguire il push dell'immagine compilata in Registro Azure Container. L'immagine compilata è disponibile nel nodo Immagini. Aprire il nodo todo, fare clic con il pulsante destro del mouse su più recente e quindi selezionare Push.

    Screenshot del menu di scelta rapida in Visual Studio Code con l'opzione Push selezionata.

  4. Nei prompt selezionare la sottoscrizione di Azure, la risorsa registro Azure Container e i tag immagine. Il formato del tag immagine deve essere {acrname}.azurecr.io/todo:latest.

  5. Attendere il push dell'immagine del contenitore in Registro Azure Container in Visual Studio Code.

Preparare la distribuzione YAML

Usare il modello YAML seguente per creare un file akstododeploy.yml. Sostituire i segnaposto {ACR name}, {Image name}, {Version} e {resource group name} con i propri valori.

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

Applicare la distribuzione YAML

Usare di nuovo kubectl apply per distribuire i pod dell'applicazione ed esporre i pod tramite un servizio di bilanciamento del carico:

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

Testare l'applicazione

Durante l'esecuzione dell'applicazione, un servizio Kubernetes espone il front-end dell'applicazione a Internet. Questo processo può richiedere alcuni minuti.

Usare kubectl get per visualizzare l'indirizzo IP esterno esposto dal servizio di bilanciamento del carico:

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

Per accedere all'applicazione, aprire l'indirizzo IP ricevuto come output in un browser.

Pulire le risorse

Per evitare addebiti di Azure, pulire le risorse non necessarie quando il cluster non è più necessario. Usare az group delete e az deployment sub delete per eliminare rispettivamente il gruppo di risorse e la distribuzione della sottoscrizione:

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

az deployment sub delete \
  --name $deploymentName

Passaggi successivi