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

SI APPLICA A: NoSQL

In questa esercitazione si distribuisce 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.

Prerequisiti

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

• Docker Desktop
• Visual Studio Code
  • Estensione C# per Visual Studio Code
  • Estensione Docker per Visual Studio Code
  • Estensione dell’Account di Azure per Visual Studio Code

Panoramica

Questa esercitazione usa un approccio infrastructure as code (IaC) per distribuire le risorse in Azure. Si usa 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 distribuiscono le risorse di Azure seguenti nell'ambito della sottoscrizione di destinazione:

• Un gruppo di risorse per organizzare le risorse
• Un’identità gestita per l'autenticazione
• Un registro contenitori per l'archiviazione di immagini del contenitore
• Un cluster del servizio Azure Kubernetes
• Una rete virtuale per la configurazione del servizio Azure Kubernetes
• Un account Azure Cosmos DB per NoSQL, insieme a un database, a un contenitore e al ruolo SQL
• Un insieme di credenziali delle chiavi per archiviare chiavi sicure
• (Facoltativo) Un'area di lavoro Log Analytics

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

• Implementare il controllo di accesso usando il controllo degli accessi in base al ruolo e un'identità gestita. Queste funzionalità eliminano la necessità per gli sviluppatori di gestire segreti, credenziali, certificati e chiavi per la comunicazione sicura tra i servizi.
• Limitare l'accesso di Azure Cosmos DB alla subnet del servizio Azure Kubernetes configurando un endpoint servizio di rete virtuale.
• Impostare disableLocalAuth = true nella risorsa databaseAccount su applicare il controllo degli accessi in base al ruolo come unico metodo di autenticazione.

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 sign in 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.

{
  "$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 restituisce 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:

Collegare Registro Azure Container al 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 connettersi al cluster Kubernetes, usare az aks 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à vengono usate per concedere l'accesso al provider di Azure Key Vault per il driver Container Storage Interface (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.

   

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.

   

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

Contenuto correlato

• Eseguire query in Azure Cosmos DB for NoSQL.
• Aggiornare il cluster.
• Applicare la scalabilità al cluster.
• Abilitare la distribuzione continua.