Distribuire un'app Python containerizzata nel Servizio App

È possibile eseguire comandi interfaccia della riga di comando di Azure nel Azure Cloud Shell o in un computer locale con il interfaccia della riga di comando di Azure installato.

Creare uno Spazio delle Chiavi con autorizzazione RBAC

Azure Key Vault è un servizio sicuro per l'archiviazione di segreti, chiavi API, stringhe di connessione e certificati. In questo script vengono archiviati la stringa di connessione MongoDB e l'applicazione SECRET_KEY.

Configurare il Key Vault per l'uso di role-based access control (RBAC) per gestire l'accesso tramite ruoli Azure anziché i criteri di accesso tradizionali. L'app Web usa l'identità gestita assegnata dal sistema per recuperare i segreti in modo sicuro in fase di esecuzione.

1. Usa il comando az keyvault create per creare un Azure Key Vault con il controllo degli accessi in base al ruolo (RBAC) abilitato.

   • Bash
   • PowerShell

   #!/bin/bash
   RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   LOCATION="westus"
   KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create \
     --name "$KEYVAULT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --location "$LOCATION" \
     --enable-rbac-authorization true
   

Creare il piano di servizio app e l'app Web

Il piano di servizio app definisce le risorse di calcolo, il piano tariffario e l'area per l'app Web. L'app Web esegue l'applicazione containerizzata ed è configurata con un'identità gestita assegnata dal sistema, che usa per autenticarsi in modo sicuro ad Registro Azure Container (ACR) e ad Azure Key Vault.

In questo passaggio completare le attività seguenti:

• Crea un piano di Servizio app
• Crea l'app web con l'identità gestita
• Configurare l'app Web da distribuire usando un'immagine del contenitore specifica
• Preparati per la distribuzione continua tramite il Registro Azure Container

1. Usare il comando az appservice plan create per effettuare il provisioning dell'ambiente di calcolo per l'app.

   • Bash
   • PowerShell

   #!/bin/bash
   APP_SERVICE_PLAN_NAME="msdocs-web-app-plan"
   
   az appservice plan create \
       --name "$APP_SERVICE_PLAN_NAME" \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --sku B1 \
       --is-linux
   

2. Usare il comando az webapp create per creare l'app Web. Questo comando abilita anche un'identità gestita assegnata dal sistema e imposta l'immagine del contenitore in cui l'app viene eseguita.

   • Bash
   • PowerShell

   #!/bin/bash
   APP_SERVICE_NAME="msdocs-website-name" #APP_SERVICE_NAME must be globally unique as it becomes the website name in the URL `https://<website-name>.azurewebsites.net`.
   # Use the same registry name as in part 2 of this tutorial series.
   REGISTRY_NAME="msdocscontainerregistryname" #REGISTRY_NAME is the registry name you used in part 2 of this tutorial.
   CONTAINER_NAME="$REGISTRY_NAME.azurecr.io/msdocspythoncontainerwebapp:latest" #CONTAINER_NAME is of the form "yourregistryname.azurecr.io/repo_name:tag".
   
   az webapp create \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --plan "$APP_SERVICE_PLAN_NAME" \
     --name "$APP_SERVICE_NAME" \
     --assign-identity '[system]' \
     --deployment-container-image-name "$CONTAINER_NAME" 
   

   Nota

   Quando si esegue questo comando, è possibile che venga visualizzato l'errore seguente:

   No credential was provided to access Azure Container Registry. Trying to look up...
   Retrieving credentials failed with an exception:'Failed to retrieve container registry credentials. Please either provide the credentials or run 'az acr update -n msdocscontainerregistryname --admin-enabled true' to enable admin first.'
   

   Questo errore si verifica perché l'app Web tenta di usare le credenziali di amministratore per accedere al Registro Azure Container, ma le credenziali di amministratore sono disabilitate per impostazione predefinita. Questo messaggio può tranquillamente essere ignorato. Il passaggio successivo configura l'app Web per usare la propria identità gestita per autenticarsi con Azure Container Registry (ACR).

Concedi il ruolo Key Vault Secrets Officer all'utente autenticato

Per archiviare i segreti in Azure Key Vault, l'utente che esegue lo script deve avere il ruolo Key Vault Secrets Officer . Questo ruolo consente di creare e gestire segreti all'interno del vault.

In questo passaggio lo script assegna tale ruolo all'utente attualmente autenticato. Questo utente può quindi archiviare in modo sicuro i segreti dell'applicazione, ad esempio la stringa di connessione MongoDB e l'oggetto dell'app SECRET_KEY.

Questa assegnazione di ruolo è la prima delle due assegnazioni di ruolo correlate al Key Vault. Successivamente, all'identità gestita assegnata dal sistema dell'app web viene concesso l'accesso per recuperare i segreti dal vault.

Utilizzando Azure RBAC, si garantisce un accesso sicuro e verificabile basato sull'identità, quindi non è necessario usare credenziali codificate in modo permanente.

1. Usare il comando az role assignment create per assegnare il ruolo nell'ambito Key Vault.

   • Bash
   • PowerShell

   #!/bin/bash
   CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create \
     --role "Key Vault Secrets Officer" \
     --assignee "$CALLER_ID" \
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

Concedere l'accesso Web ad ACR facendo uso dell'identità gestita

Per eseguire il pull delle immagini da Registro Azure Container (ACR) in modo sicuro, configurare l'app Web per l'uso dell'identità gestita assegnata dal sistema . Usando l'identità gestita, non sono necessarie credenziali di amministratore e possono supportare la distribuzione sicura senza credenziali.

Questo processo prevede due azioni chiave:

• Abilitazione dell'app web a utilizzare la propria identità gestita durante l'accesso al Registro dei Contenitori di Azure
• Assegnazione del ruolo AcrPull a tale identità nell'ACR (Azure Container Registry) di destinazione

1. In questo passaggio, recupera l'ID principale (ID oggetto univoco) dell'identità gestita dell'app Web usando il comando az webapp identity show. Abilita quindi l'uso dell'identità gestita per l'autenticazione di ACR impostando la proprietà acrUseManagedIdentityCreds su true mediante az webapp config set. Assegnare quindi il ruolo AcrPull all'identità gestita dell'app Web usando il comando az role assignment create . Questo ruolo concede all'app Web l'autorizzazione per eseguire il pull delle immagini dal Registro di sistema.

   • Bash
   • PowerShell

   #!/bin/bash
   PRINCIPAL_ID=$(az webapp identity show \
     --name "$APP_SERVICE_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --query principalId \
     -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful 'AcrPull' role assignment using `az role assignment list`.    
   
   az webapp config set \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --name "$APP_SERVICE_NAME" \
     --generic-configurations '{"acrUseManagedIdentityCreds": true}'
   
   az role assignment create \
   --role "AcrPull" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ContainerRegistry/registries/$REGISTRY_NAME"
   
   

Concedi l'accesso all'insieme di credenziali all'identità gestita dell'applicazione web

L'app Web deve disporre dell'autorizzazione per accedere ai segreti, ad esempio la stringa di connessione MongoDB e .SECRET_KEY Per concedere queste autorizzazioni, assegna il ruolo Key Vault Secrets User all'identità gestita assegnata dal sistema dell'app Web.

1. In questo passaggio, usa l'identificatore univoco (ID entità servizio) dell'identità gestita assegnata dal sistema dell'app Web per concedere all'app Web l'accesso a Key Vault con il ruolo Key Vault Secrets User usando il comando az role assignment create.

   • Bash
   • PowerShell

   #!/bin/bash
   
   az role assignment create \
   --role "Key Vault Secrets User" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

Archiviare dei segreti in Key Vault

Per evitare di codificare direttamente i segreti nell'applicazione, archivia la stringa di connessione di MongoDB e la chiave segreta dell'app Web in Azure Key Vault. L'app Web può accedere in modo sicuro a questi segreti in fase di esecuzione tramite l'identità gestita, quindi non è necessario archiviare le credenziali nel codice o nella configurazione.

1. Usare il comando az cosmosdb keys list per recuperare il stringa di connessione MongoDB. Usare quindi il comando az keyvault secret set per archiviare sia il stringa di connessione che una chiave privata generata in modo casuale in Key Vault.

   • Bash
   • PowerShell

   #!/bin/bash
   ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   MONGO_CONNECTION_STRING=$(az cosmosdb keys list \
     --name "$ACCOUNT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --type connection-strings \
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" -o tsv)
   
   SECRET_KEY=$(openssl rand -base64 32 | tr -dc 'a-zA-Z0-9')
   # This key is cryptographically secure, using OpenSSL’s strong random number generator.
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoConnectionString" \
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoSecretKey" \
     --value "$SECRET_KEY"
   

Configurare l'app web per usare i segreti di Key Vault

Per accedere ai segreti in modo sicuro in fase di esecuzione, configurare l'app Web per fare riferimento ai segreti archiviati in Azure Key Vault. Usare i riferimenti di Key Vault per iniettare i valori dei segreti nell'ambiente dell'applicazione tramite la relativa identità gestita assegnata dal sistema.

Questo approccio evita i segreti hardcoding e consente all'app di recuperare in modo sicuro valori sensibili come la stringa di connessione MongoDB e la chiave privata durante l'esecuzione.

1. Usare il comando az webapp config appsettings set per aggiungere le impostazioni dell'applicazione che fanno riferimento ai segreti Key Vault. In particolare, impostare le impostazioni dell'app MongoConnectionString e MongoSecretKey per fare riferimento ai segreti corrispondenti archiviati in Key Vault.

   • Bash
   • PowerShell

   #!/bin/bash
   MONGODB_NAME="restaurants_reviews"
   MONGODB_COLLECTION_NAME="restaurants_reviews"
   
   az webapp config appsettings set \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --name "$APP_SERVICE_NAME" \
     --settings \
         CONNECTION_STRING="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoConnectionString)" \
         SECRET_KEY="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)" \
         DB_NAME="$MONGODB_NAME" \
         COLLECTION_NAME="$MONGODB_COLLECTION_NAME"
   

Abilitare la distribuzione continua da ACR

Quando si abilita la distribuzione continua, l'app web esegue automaticamente il pull ed esegue l'immagine del contenitore più recente ogni volta che si esegue il push di un'immagine del contenitore in Registro Azure Container (ACR). Questa funzionalità riduce i passaggi di distribuzione manuali e garantisce che l'app rimanga aggiornata.

1. Usa il comando az webapp deployment container config per abilitare la distribuzione continua da ACR all'app Web.

   • Bash
   • PowerShell

   #!/bin/bash
   az webapp deployment container config \
     --name "$APP_SERVICE_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --enable-cd true
   

Registrare un webhook di Azure Container Registry per la distribuzione continua

Per automatizzare le distribuzioni, registrare un webhook in Registro Azure Container che notifica all'applicazione web ogni volta che viene eseguito il push di una nuova immagine del container. Utilizzando il webhook, l'app recupera ed esegue automaticamente la versione più recente.

Il webhook configurato in Registro Azure Container invia una richiesta POST all'endpoint SCM dell'app Web (SERVICE_URI) ogni volta che viene eseguito il push di una nuova immagine nel repository msdocspythoncontainerwebapp. Questa azione attiva l'app Web per scaricare e distribuire l'immagine aggiornata, completando la pipeline di distribuzione continua tra Azure Container Registry e Servizio app di Azure.

1. Usare il comando az acr webhook create per registrare il webhook e configurarlo per attivarsi per gli eventi push.

   • Bash
   • PowerShell

   #!/bin/bash
   CREDENTIAL=$(az webapp deployment list-publishing-credentials \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --name "$APP_SERVICE_NAME" \
       --query publishingPassword --output tsv)
   # Web app publishing credentials may not be available immediately. In production, poll until non-empty.   
   
   SERVICE_URI="https://$APP_SERVICE_NAME:$CREDENTIAL@$APP_SERVICE_NAME.scm.azurewebsites.net/api/registry/webhook"
   
   az acr webhook create \
     --name webhookforwebapp \
     --registry "$REGISTRY_NAME" \
     --scope msdocspythoncontainerwebapp:* \
     --uri "$SERVICE_URI" \
     --actions push
   
   

Esplorare il sito

Per verificare che l'app Web sia in esecuzione, aprire https://<website-name>.azurewebsites.net, sostituendo <website-name> con il nome del servizio app. Dovresti vedere l'app di esempio per le recensioni del ristorante. Il caricamento della prima volta potrebbe richiedere alcuni istanti.

Una volta visualizzato il sito, provare ad aggiungere un ristorante e inviare una recensione per verificare che l'app funzioni correttamente.

Se si usa il interfaccia della riga di comando di Azure in locale, usare il comando az webapp browse per aprire il sito nel browser predefinito:

az webapp browse --name $APP_SERVICE_NAME --resource-group $RESOURCE_GROUP_NAME

È possibile usare l'estensione Docker in Visual Studio Code per compilare e distribuire l'applicazione Web in contenitori nel servizio app di Azure. Questa estensione semplifica il processo di creazione del pacchetto dell'app e il push nel cloud. Dopo la distribuzione, usare l'estensione Strumenti di Azure per configurare le impostazioni dell'app Web, inclusa la stringa di connessione MongoDB e una chiave privata per l'applicazione.

Inizialmente, configurate e testate l'app utilizzando valori codificati direttamente nel codice per assicurarvi che si avvii e si connetta correttamente al database MongoDB. Dopo aver verificato il funzionamento dell'app, usare l'interfaccia della riga di comando di Azure (in locale o in Cloud Shell) per creare un'istanza di Azure Key Vault. Concedere quindi all'utente l'autorizzazione di creazione dell'app in VS Code per archiviare le informazioni riservate e quindi archiviare il stringa di connessione MongoDB e la chiave privata dell'app come segreti Key Vault.

Infine, in Visual Studio Code aggiornare le impostazioni dell'applicazione dell'app Web per fare riferimento ai segreti archiviati in Key Vault. L'app può ora accedere in modo sicuro ai valori di configurazione senza incorporarli direttamente nel codice.

Creare l'app Web

Questi passaggi richiedono l'installazione dell'estensione Docker per VS Code.

1. Aggiornare Registro Azure Container nell'estensione Docker per verificare che il contenitore compilato venga visualizzato nella sezione REGISTRIES dell'estensione Docker. Se non lo fa, fare clic con il pulsante destro del mouse sul nome del Registro di sistema e selezionare Aggiorna.

   

2. Seleziona F1 o CTRL+MAIUSC+P per aprire la palette dei comandi, digita "Docker Registries" e seleziona l'attività Docker Registries: Distribuisci immagine su Servizio app di Azure....

3. Immettere i valori seguenti come richiesto per distribuire l'immagine:

   • Selezionare il provider del Registro di sistema: Azure
   • Sottoscrizione: selezionare la sottoscrizione che contiene il Registro Azure Container creato in precedenza.
   • Selezionare il Registro di sistema: immettere il nome del Registro di sistema creato in precedenza in questa esercitazione.
   • Selezionare repository: immettere il nome del repository msdocscontainerregistryname. Se non vedi questo repository, aggiorna la sezione REGISTRIES dell'estensione Docker.
   • Selezionare tag: latest per il tag immagine.
   • Immettere un nome univoco globale per l'app Web: immettere un nome univoco a livello globale per il servizio app di Azure. Ad esempio, se si usa msdocs-website-name, l'URL dell'app Web sarà http://msdocs-website-name.azurewebsites.net.
   • Selezionare un gruppo di risorse: usare il gruppo di risorse che contiene il Registro Azure Container creato in precedenza.
   • Selezionare un piano di servizio app Linux: usare un piano esistente o crearne uno nuovo.

4. Visualizza la finestra OUTPUT per i dettagli della distribuzione. Una delle righe di output è "Concessione dell'autorizzazione al Servizio App per il pull dell'immagine dal Registro dei container di Azure...", al quale il Servizio App accede usando l'identità gestita.

   

   Il sito finale https://<app-name>.azurewebsites.net non è ancora pronto perché è necessario specificare le informazioni di MongoDB.

   Nota

   Quando si esegue la distribuzione con Visual Studio Code, l'identità gestita è già impostata per l'App Service per effettuare il pull delle immagini dal Registro di sistema. È possibile verificare che l'identità gestita sia abilitata visualizzando i log nella finestra OUTPUT e cercando il messaggio "Concessione dell'autorizzazione per App Service per effettuare il pull dell'immagine dal Registro Azure Container...".

Configurare l'identità gestita e il webhook

Durante la distribuzione con VS Code, si crea un webhook che consente all'app Web di eseguire il pull di nuove immagini dal Registro Azure Container.

1. Esaminare la configurazione dei webhook nel portale di Azure per verificare che l'URI del servizio termini con "/api/registry/webhook". Per esaminare l'URI del servizio, aprire l'estensione Docker in VS Code e trovare il Registro di sistema creato. Fare clic con il pulsante destro del mouse sul Registro di sistema e selezionare Apri nel portale. Il registro contenitori viene aperto nel portale di Azure. Fare clic su Servizi e quindi su Webhook. Aprire il menu di scelta rapida e fare clic su Configura.

   

2. Verificare che l'URI del servizio termini con "/api/registry/webhook". In caso contrario, aggiungerlo alla fine della stringa e fare clic su Salva.

Configurare la connessione a MongoDB utilizzando valori codificati staticamente

In questo passaggio specificare le variabili di ambiente necessarie per la connessione dell'applicazione Web a MongoDB.

1. Nella visualizzazione di Azure in VS Code (dall'estensione Strumenti di Azure):

   1. Espandi RISORSE e trova Servizi App nella sottoscrizione. Assicurarsi di visualizzare le risorse in base al tipo di risorsa per gruppo.

   2. Espandi Servizi app e trova l'app Web creata.

   3. Espandi l'app Web e fai clic con il pulsante destro del mouse su Impostazioni applicazione.

   4. Selezionare Aggiungi nuova impostazione....

   

2. Ogni volta che si aggiunge una nuova impostazione, viene visualizzata una finestra di dialogo nella parte superiore della finestra di VS Code in cui è possibile aggiungere il nome dell'impostazione seguito dal relativo valore. Aggiungere le impostazioni seguenti:

   • CONNECTION_STRING: stringa di connessione MongoDB. Più avanti in questa esercitazione, impostare questo valore sulla stringa di connessione archiviata in Azure Key Vault.
   • DB_NAME: restaurants_reviews
   • COLLECTION_NAME: restaurants_reviews
   • WEBSITES_PORT: 8000 per Django e 5000 per Flask. Questa variabile di ambiente specifica la porta su cui il contenitore ascolta.
   • SECRET_KEY: supersecretkeythatispassedtopythonapp. Questa chiave privata è una stringa casuale usata da Django e Flask per crittografare i dati della sessione. Più avanti in questa esercitazione impostare questo valore sulla stringa casuale archiviata in Azure Key Vault.

Sfoglia il sito utilizzando valori codificati in modo statico

Nella visualizzazione di Azure in VS Code (dall'estensione Strumenti di Azure):

1. Espandi RISORSE e trova Servizi App nella sottoscrizione. Assicurarsi di visualizzare le risorse in base al tipo di risorsa per gruppo.

2. Fare clic con il pulsante destro del mouse sull'app Web e selezionare Sfoglia sito Web. Se il sito Web visualizza un errore, attendere alcuni minuti e riprovare. L'avvio dell'app Web potrebbe richiedere alcuni minuti. Vedere anche Risoluzione dei problemi del servizio app.

Creare uno Spazio delle Chiavi con autorizzazione RBAC

In questo passaggio, crei un Azure Key Vault per archiviare la stringa di connessione MongoDB e l'SECRET_KEYdell'app Web. Azure Key Vault è un servizio sicuro per l'archiviazione di segreti, chiavi API, stringhe di connessione e certificati. Configurare il Key Vault per l'uso di role-based access control (RBAC) per gestire l'accesso tramite ruoli Azure anziché i criteri di accesso tradizionali. L'app Web usa l'identità gestita assegnata dal sistema per recuperare i segreti in modo sicuro in fase di esecuzione.

1. Digitare il seguente comando interfaccia della riga di comando di Azure per creare un nuovo Key Vault. Questo comando usa bash oppure PowerShell per creare un Key Vault con l'autorizzazione RBAC abilitata.

   • Bash
   • PowerShell

   #!/bin/bash
   RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   LOCATION="westus"
   KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create \
     --name "$KEYVAULT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --location "$LOCATION" \
     --enable-rbac-authorization true
   

Concedi il ruolo Key Vault Secrets Officer all'utente autenticato

Per archiviare i segreti in Azure Key Vault, concedere il ruolo Key Vault Secrets Officer all'utente che esegue lo script. Questo ruolo concede la possibilità di creare e gestire segreti all'interno dell'insieme di credenziali.

In questo passaggio, lo script assegna questo ruolo all'utente attualmente autenticato, consentendo loro di archiviare in modo sicuro i dati sensibili dell'applicazione, ad esempio il stringa di connessione MongoDB e il SECRET_KEY.

Usando Azure Role-Based Controllo di accesso (RBAC), questo approccio garantisce l'accesso sicuro e controllabile alle Key Vault in base all'identità, quindi non è necessario incorporare le credenziali direttamente nei file di codice o di configurazione.

1. Usare il comando az role assignment create per assegnare il ruolo nell'ambito Key Vault.

   • Bash
   • PowerShell

   #!/bin/bash
   CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create \
     --role "Key Vault Secrets Officer" \
     --assignee "$CALLER_ID" \
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

Archiviare dei segreti in Key Vault

Per evitare di codificare i segreti direttamente nell'applicazione, memorizza in Azure Key Vault la stringa di connessione di MongoDB per l'istanza di MongoDB e la chiave segreta dell'app Web. L'app Web può accedere in modo sicuro a questi segreti in fase di esecuzione tramite l'identità gestita, senza la necessità di archiviare le credenziali nel codice o nella configurazione.

1. Usare il comando az cosmosdb keys list per recuperare il stringa di connessione MongoDB. Usare quindi il comando az keyvault secret set per archiviare sia il stringa di connessione che una chiave privata generata in modo casuale in Key Vault.

   • Bash
   • PowerShell

   #!/bin/bash
   ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   MONGO_CONNECTION_STRING=$(az cosmosdb keys list \
     --name "$ACCOUNT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --type connection-strings \
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" -o tsv)
   
   SECRET_KEY=$(openssl rand -base64 32 | tr -dc 'a-zA-Z0-9')
   # This key is cryptographically secure, using OpenSSL’s strong random number generator.
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoConnectionString" \
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoSecretKey" \
     --value "$SECRET_KEY"
   

Concedi l'accesso all'insieme di credenziali all'identità gestita dell'applicazione web

L'app Web deve disporre dell'autorizzazione per accedere alla stringa di connessione MongoDB e all'oggetto SECRET_KEY che hai archiviato nel Key Vault. Per concedere queste autorizzazioni, assegna il ruolo Key Vault Secrets User all'identità gestita assegnata dal sistema dell'app Web.

1. In questo passaggio, usa l'identificatore univoco (ID entità servizio) dell'identità gestita assegnata dal sistema dell'app Web per concedere all'app Web l'accesso a Key Vault con il ruolo Key Vault Secrets User usando il comando az role assignment create.

   • Bash
   • PowerShell

   #!/bin/bash
     APP_SERVICE_NAME="msdocs-website-name"
     PRINCIPAL_ID=$(az webapp identity show \
       --name "$APP_SERVICE_NAME" \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --query principalId \
       -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful 'AcrPull' role assignment using `az role assignment list`.    
   
   az role assignment create \
   --role "Key Vault Secrets User" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

Configurare la connessione a MongoDB usando i segreti di Key Vault

In questo passaggio, aggiorni le variabili di ambiente necessarie per connettersi a MongoDB utilizzando i valori archiviati nel key vault.

1. Nella visualizzazione di Azure in VS Code (dall'estensione Strumenti di Azure):

   1. Espandi RISORSE e trova Servizi App nella sottoscrizione. Assicurarsi di visualizzare le risorse in base al tipo di risorsa per gruppo.

   2. Espandi Servizi app, espandi l'app web e quindi espandi Impostazioni applicazione.

   3. Modificare le impostazioni seguenti:

   • STRINGA_DI_CONNESSIONE: @Microsoft.KeyVault(SecretUri=https://msdocs-web-app-rg-kv.vault.azure.net/secrets/MongoConnectionString)
   • SECRET_KEY: @Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)

   Nota

   Per verificare che le impostazioni dell'applicazione siano impostate correttamente, usare il comando az webapp config appsettings list per elencare le impostazioni dell'applicazione per l'app Web. Il formato del comando è: az webapp config appsettings list --/<resource-group msdocs-web-app-rg/> --name /<website-name/>. Questo comando elenca tutte le impostazioni dell'applicazione per l'app Web, incluse quelle appena impostate.

Esplora il sito utilizzando i segreti di Key Vault

Nella visualizzazione di Azure in VS Code (dall'estensione Strumenti di Azure):

1. Espandi RISORSE e trova Servizi App nella sottoscrizione. Assicurarsi di visualizzare le risorse in base al tipo di risorsa per gruppo.

2. Fare clic con il pulsante destro del mouse sull'app Web e selezionare Sfoglia sito Web. Se il sito Web visualizza un errore, attendere alcuni minuti e riprovare. L'avvio dell'app Web potrebbe richiedere alcuni minuti. Vedere anche Risoluzione dei problemi del servizio app.