Esercitazione: distribuire un'applicazione Dapr in App contenitore di Azure usando l'interfaccia della riga di comando di Azure

Dapr (Distributed Application Runtime) consente agli sviluppatori di creare microservizi resilienti e affidabili. In questa esercitazione viene distribuita un'applicazione Dapr di esempio in App contenitore di Azure.

Scopri come:

• Creare un ambiente App contenitore per distribuire le app contenitore
• Creare un archivio stati di Archiviazione BLOB di Azure per l'app contenitore
• Distribuire due app che producono e utilizzano messaggi e rendono questi persistenti nell'archivio stati
• Verificare l'interazione tra i due microservizi.

Con App contenitore di Azure si ottiene una versione completamente gestita delle API Dapr durante la creazione di microservizi. Quando si usa Dapr nelle App contenitore di Azure, è possibile abilitare l'esecuzione sidecar accanto ai microservizi che offrono un set completo di funzionalità. Le API Dapr disponibili includono Chiamate da servizio a servizio, Pub/Sub, Binding evento, Archivi statie Azioni.

In questa esercitazione si distribuiscono le stesse applicazioni dall’avvio rapido Dapr Hello World.

L'applicazione è costituita da:

• un’app contenitore client (Python) per generare messaggi.
• un'app contenitore del servizio (Node) per utilizzare e rendere persistenti tali messaggi in un archivio stati

Il diagramma dell'architettura seguente illustra i componenti che costituiscono questa esercitazione:

Attrezzaggio

Per accedere ad Azure dall'interfaccia della riga di comando, eseguire il comando seguente e seguire le istruzioni per completare il processo di autenticazione.

Bash

az login

Azure PowerShell

Connect-AzAccount

Assicurarsi di eseguire l'ultima versione dell'interfaccia della riga di comando eseguire il comando di aggiornamento.

Bash

az upgrade

Azure PowerShell

Install-Module -Name Az -Scope CurrentUser -Repository PSGallery -Force

Ignorare eventuali avvisi sui moduli attualmente in uso.

Installare o aggiornare quindi l'estensione App contenitore di Azure per l'interfaccia della riga di comando.

Se si ricevono errori relativi ai parametri mancanti quando si eseguono comandi az containerapp nell'interfaccia della riga di comando di Azure o nei cmdlet del modulo Az.App in Azure PowerShell, assicurarsi di avere installato la versione più recente dell'estensione App contenitore di Azure.

Bash

az extension add --name containerapp --upgrade

Nota

A partire da maggio 2024, le estensioni dell'interfaccia della riga di comando di Azure non abilitano più le funzionalità di anteprima per impostazione predefinita. Per accedere alle funzionalità di anteprima di App contenitore, installare l'estensione App contenitore con --allow-preview true.

az extension add --name containerapp --upgrade --allow-preview true

Azure PowerShell

Install-Module -Name Az.App

Assicurarsi di aggiornare il modulo Az.App alla versione più recente.

Update-Module -Name Az.App

Ora che l'estensione o il modulo corrente è installato, registrare gli spazi dei nomi Microsoft.App e Microsoft.OperationalInsights.

Bash

az provider register --namespace Microsoft.App

az provider register --namespace Microsoft.OperationalInsights

Azure PowerShell

Register-AzResourceProvider -ProviderNamespace Microsoft.App

Register-AzResourceProvider -ProviderNamespace Microsoft.OperationalInsights

Impostare le variabili di ambiente

Impostare le variabili di ambiente seguenti. Sostituire i <SEGNAPOSTO> con i valori:

Bash

RESOURCE_GROUP="<RESOURCE_GROUP>"
LOCATION="<LOCATION>"
CONTAINERAPPS_ENVIRONMENT="<CONTAINERAPPS_ENVIRONMENT>"

Azure PowerShell

$ResourceGroupName = '<RESOURCE_GROUP>'
$Location = '<LOCATION>'
$ContainerAppsEnvironment = '<CONTAINERAPPS_ENVIRONMENT>'

Creare un gruppo di risorse di Azure

Creare un gruppo di risorse per organizzare i servizi correlati alla distribuzione dell'app contenitore.

Bash

az group create \
  --name $RESOURCE_GROUP \
  --location "$LOCATION"

Azure PowerShell

New-AzResourceGroup -Location $Location -Name $ResourceGroupName

Crea un ambiente

Un ambiente di App contenitore di Azure crea un limite sicuro intorno a un gruppo di app contenitore. Le app contenitore nello stesso ambiente vengono distribuite nella stessa rete virtuale e scrivono log nella stessa area di lavoro Log Analytics.

Per creare l'ambiente, eseguire il comando seguente:

Bash

az containerapp env create \
  --name $CONTAINERAPPS_ENVIRONMENT \
  --resource-group $RESOURCE_GROUP \
  --location "$LOCATION"

Azure PowerShell

Per l'ambiente App contenitore è necessaria un'area di lavoro Log Analytics. I comandi seguenti creano un'area di lavoro Log Analytics e salvano l'ID dell'area di lavoro e la chiave condivisa primaria nelle variabili di ambiente.

$WorkspaceArgs = @{
    Name = 'myworkspace'
    ResourceGroupName = $ResourceGroupName
    Location = $Location
    PublicNetworkAccessForIngestion = 'Enabled'
    PublicNetworkAccessForQuery = 'Enabled'
}
New-AzOperationalInsightsWorkspace @WorkspaceArgs
$WorkspaceId = (Get-AzOperationalInsightsWorkspace -ResourceGroupName $ResourceGroupName -Name $WorkspaceArgs.Name).CustomerId
$WorkspaceSharedKey = (Get-AzOperationalInsightsWorkspaceSharedKey -ResourceGroupName $ResourceGroupName -Name $WorkspaceArgs.Name).PrimarySharedKey

Per creare l'ambiente, eseguire il comando seguente:

$EnvArgs = @{
    EnvName = $ContainerAppsEnvironment
    ResourceGroupName = $ResourceGroupName
    Location = $Location
    AppLogConfigurationDestination = 'log-analytics'
    LogAnalyticConfigurationCustomerId = $WorkspaceId
    LogAnalyticConfigurationSharedKey = $WorkspaceSharedKey
}

New-AzContainerAppManagedEnv @EnvArgs

Configurare un archivio stati

Creare un account Archiviazione BLOB di Azure

Con l'ambiente distribuito, il passaggio successivo consiste nel distribuire un Account di archiviazione BLOB di Azure usato da uno dei microservizi per archiviare i dati. Prima di distribuire il servizio, è necessario scegliere un nome per l'account di archiviazione. I nomi degli account di archiviazione devono essere univoci in Azure, avere una lunghezza compresa tra 3 e 24 caratteri e contenere solo numeri e lettere minuscole.

Bash

STORAGE_ACCOUNT_NAME="<storage account name>"

Azure PowerShell

$StorageAcctName = '<storage account name>'

Usare il comando seguente per creare Account di archiviazione di Azure.

Bash

az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location "$LOCATION" \
  --sku Standard_RAGRS \
  --kind StorageV2

Azure PowerShell

Install-Module Az.Storage

$StorageAcctArgs = @{
    Name = $StorageAcctName
    ResourceGroupName = $ResourceGroupName
    Location = $Location
    SkuName = 'Standard_RAGRS'
    Kind = 'StorageV2'
}
$StorageAccount = New-AzStorageAccount @StorageAcctArgs

Configurare un'identità assegnata dall'utente per l'app nodo

Mentre l’App contenitore supporta l'identità gestita assegnata dall'utente e assegnata dal sistema, un'identità assegnata dall'utente fornisce all'app del nodo abilitata per Dapr le autorizzazioni per accedere all'account di archiviazione BLOB.

1. Creare un'identità assegnata dall'utente.

Bash

az identity create --resource-group $RESOURCE_GROUP --name "nodeAppIdentity" --output json

Azure PowerShell

Install-Module -Name AZ.ManagedServiceIdentity

New-AzUserAssignedIdentity -ResourceGroupName $ResourceGroupName -Name 'nodeAppIdentity' -Location $Location

Recuperare le proprietà principalId e id e archiviare nelle variabili.

Bash

PRINCIPAL_ID=$(az identity show -n "nodeAppIdentity" --resource-group $RESOURCE_GROUP --query principalId | tr -d \")
IDENTITY_ID=$(az identity show -n "nodeAppIdentity" --resource-group $RESOURCE_GROUP --query id | tr -d \")
CLIENT_ID=$(az identity show -n "nodeAppIdentity" --resource-group $RESOURCE_GROUP --query clientId | tr -d \")

Azure PowerShell

$PrincipalId = (Get-AzUserAssignedIdentity -ResourceGroupName $ResourceGroupName -Name 'nodeAppIdentity').PrincipalId
$IdentityId = (Get-AzUserAssignedIdentity -ResourceGroupName $ResourceGroupName -Name 'nodeAppIdentity').Id
$ClientId = (Get-AzUserAssignedIdentity -ResourceGroupName $ResourceGroupName -Name 'nodeAppIdentity').ClientId

2. Assegnare il ruolo Storage Blob Data Contributor all'identità assegnata dall'utente.

Recuperare l'ID sottoscrizione per la sottoscrizione corrente.

Bash

SUBSCRIPTION_ID=$(az account show --query id --output tsv)

Azure PowerShell

$SubscriptionId=$(Get-AzContext).Subscription.id

Bash

az role assignment create --assignee $PRINCIPAL_ID  \
--role "Storage Blob Data Contributor" \
--scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Storage/storageAccounts/$STORAGE_ACCOUNT_NAME"

Azure PowerShell

Install-Module Az.Resources

New-AzRoleAssignment -ObjectId $PrincipalId -RoleDefinitionName 'Storage Blob Data Contributor' -Scope "/subscriptions/$SubscriptionId/resourceGroups/$ResourceGroupName/providers/Microsoft.Storage/storageAccounts/$StorageAcctName"

Configurare il componente dell'archivio stati

Esistono diversi modi per eseguire l'autenticazione a risorse esterne tramite Dapr. Questo esempio non usa l'API Segreti Dapr in fase di esecuzione, ma usa un archivio stati basato su Azure. Pertanto, è possibile creare un componente dell'archivio di segreti e fornire invece l'accesso diretto dall'app nodo all'archivio BLOB usando l'Identità gestita. Se si vuole usare un archivio stati non Azure o l'API Segreti Dapr in fase di esecuzione, è possibile creare un componente dell'archivio di segreti. Questo componente carica i segreti di runtime in modo che si possa fare riferimento in fase di esecuzione.

Aprire un editor di testo e creare un file di configurazione denominato statestore.yaml con le proprietà di origine dei passaggi precedenti. Questo file consente all'app Dapr di accedere all'archivio stati. L'esempio seguente illustra l'aspetto del file statestore.yaml quando configurato per l'Account di archiviazione BLOB di Azure:

# statestore.yaml for Azure Blob storage component
componentType: state.azure.blobstorage
version: v1
metadata:
  - name: accountName
    value: "<STORAGE_ACCOUNT_NAME>"
  - name: containerName
    value: mycontainer
  - name: azureClientId
    value: "<MANAGED_IDENTITY_CLIENT_ID>"
scopes:
  - nodeapp

Per usare questo file, aggiornare i segnaposto:

• Sostituire <STORAGE_ACCOUNT_NAME> con il valore della variabile STORAGE_ACCOUNT_NAME definita. Per ottenere il valore, eseguire il comando seguente:

Bash

echo $STORAGE_ACCOUNT_NAME

• Sostituire <MANAGED_IDENTITY_CLIENT_ID> con il valore della variabile CLIENT_ID definita. Per ottenere il valore, eseguire il comando seguente:

echo $CLIENT_ID

Passare alla directory in cui è stato archiviato il file yaml del componente ed eseguire il comando seguente per configurare il componente Dapr nell'ambiente App contenitore. Per altre informazioni sulla configurazione dei componenti Dapr, vedere Configurare i componenti Dapr.

az containerapp env dapr-component set \
    --name $CONTAINERAPPS_ENVIRONMENT --resource-group $RESOURCE_GROUP \
    --dapr-component-name statestore \
    --yaml statestore.yaml

Azure PowerShell

$AcctName = New-AzContainerAppDaprMetadataObject -Name "accountName" -Value $StorageAcctName

$ContainerName = New-AzContainerAppDaprMetadataObject -Name "containerName" -Value 'mycontainer'

$ClientId = New-AzContainerAppDaprMetadataObject -Name "azureClientId" -Value $ClientId

$DaprArgs = @{
    EnvName = $ContainerAppsEnvironment
    ResourceGroupName = $ResourceGroupName
    DaprName = 'statestore'
    Metadata = $AcctName, $ContainerName, $ClientId
    Scope = 'nodeapp'
    Version = 'v1'
    ComponentType = 'state.azure.blobstorage'
}

New-AzContainerAppManagedEnvDapr @DaprArgs

Distribuire l'applicazione di servizio (server Web HTTP)

Bash

az containerapp create \
  --name nodeapp \
  --resource-group $RESOURCE_GROUP \
  --user-assigned $IDENTITY_ID \
  --environment $CONTAINERAPPS_ENVIRONMENT \
  --image dapriosamples/hello-k8s-node:latest \
  --min-replicas 1 \
  --max-replicas 1 \
  --enable-dapr \
  --dapr-app-id nodeapp \
  --dapr-app-port 3000 \
  --env-vars 'APP_PORT=3000'

Se si usa un Registro Azure Container, includere il flag --registry-server <REGISTRY_NAME>.azurecr.io nel comando.

Azure PowerShell

$EnvId = (Get-AzContainerAppManagedEnv -ResourceGroupName $ResourceGroupName -EnvName $ContainerAppsEnvironment).Id

$EnvVars = New-AzContainerAppEnvironmentVarObject -Name APP_PORT -Value 3000

$TemplateArgs = @{
  Name = 'nodeapp'
  Image = 'dapriosamples/hello-k8s-node:latest'
  Env = $EnvVars
}
$ServiceTemplateObj = New-AzContainerAppTemplateObject @TemplateArgs

$ServiceArgs = @{
    Name = 'nodeapp'
    ResourceGroupName = $ResourceGroupName
    Location = $Location
    ManagedEnvironmentId = $EnvId
    TemplateContainer = $ServiceTemplateObj
    ScaleMinReplica = 1
    ScaleMaxReplica = 1
    DaprEnabled = $true
    DaprAppId = 'nodeapp'
    DaprAppPort = 3000
    IdentityType = 'UserAssigned'
    IdentityUserAssignedIdentity = @{
        $IdentityId = @{}
    }
}
New-AzContainerApp @ServiceArgs

Se si usa un Registro Azure Container, includere il flag RegistryServer = '<REGISTRY_NAME>.azurecr.io' nel comando.

Per impostazione predefinita, l'immagine viene estratta dal Docker Hub.

Distribuire l'applicazione client (client headless)

Eseguire il comando seguente per distribuire l'app contenitore client.

Bash

az containerapp create \
  --name pythonapp \
  --resource-group $RESOURCE_GROUP \
  --environment $CONTAINERAPPS_ENVIRONMENT \
  --image dapriosamples/hello-k8s-python:latest \
  --min-replicas 1 \
  --max-replicas 1 \
  --enable-dapr \
  --dapr-app-id pythonapp

Se si usa un Registro Azure Container, includere il flag --registry-server <REGISTRY_NAME>.azurecr.io nel comando.

Azure PowerShell

$TemplateArgs = @{
  Name = 'pythonapp'
  Image = 'dapriosamples/hello-k8s-python:latest'
}

$ClientTemplateObj = New-AzContainerAppTemplateObject @TemplateArgs


$ClientArgs = @{
    Name = 'pythonapp'
    ResourceGroupName = $ResourceGroupName
    Location = $Location
    ManagedEnvironmentId = $EnvId
    TemplateContainer = $ClientTemplateObj
    ScaleMinReplica = 1
    ScaleMaxReplica = 1
    DaprEnabled = $true
    DaprAppId = 'pythonapp'
}
New-AzContainerApp @ClientArgs

Se si usa un Registro Azure Container, includere il flag RegistryServer = '<REGISTRY_NAME>.azurecr.io' nel comando.

Verificare i risultati

Confermare il salvataggio permanente dello stato riuscito

È possibile verificare che i servizi funzionino correttamente visualizzando i dati nell'account di Archiviazione di Azure.

1. Aprire il portale di Azure nel browser e passare all'account di archiviazione.

2. Selezionare Contenitori sul lato sinistro del menu.

3. Selezionare mycontainer.

4. Verificare che sia possibile visualizzare il file denominato order nel contenitore.

5. Selezionare il file .

6. Selezionare la scheda Modifica.

7. Selezionare il pulsante Aggiorna per osservare come i dati vengono aggiornati automaticamente.

Visualizza registri

I log delle app contenitore vengono archiviati nella tabella personalizzata ContainerAppConsoleLogs_CL nell'area di lavoro Log Analytics. È possibile visualizzare i log tramite il portale di Azure o tramite l'interfaccia della riga di comando. Inizialmente potrebbe verificarsi un piccolo ritardo per visualizzare la tabella nell'area di lavoro.

Usare il comando seguente dell'interfaccia della riga di comando per visualizzare i log usando la riga di comando.

Bash

LOG_ANALYTICS_WORKSPACE_CLIENT_ID=`az containerapp env show --name $CONTAINERAPPS_ENVIRONMENT --resource-group $RESOURCE_GROUP --query properties.appLogsConfiguration.logAnalyticsConfiguration.customerId --out tsv`

az monitor log-analytics query \
  --workspace $LOG_ANALYTICS_WORKSPACE_CLIENT_ID \
  --analytics-query "ContainerAppConsoleLogs_CL | where ContainerAppName_s == 'nodeapp' and (Log_s contains 'persisted' or Log_s contains 'order') | project ContainerAppName_s, Log_s, TimeGenerated | sort by TimeGenerated | take 5" \
  --out table

Azure PowerShell

$queryResults = Invoke-AzOperationalInsightsQuery -WorkspaceId $WorkspaceId  -Query "ContainerAppConsoleLogs_CL | where ContainerAppName_s == 'nodeapp' and (Log_s contains 'persisted' or Log_s contains 'order') | project ContainerAppName_s, Log_s, TimeGenerated | take 5 "
$queryResults.Results

L'output seguente illustra il tipo di risposta previsto dal comando dell'interfaccia della riga di comando.

ContainerAppName_s    Log_s                            TableName      TimeGenerated
--------------------  -------------------------------  -------------  ------------------------
nodeapp               Got a new order! Order ID: 61    PrimaryResult  2021-10-22T21:31:46.184Z
nodeapp               Successfully persisted state.    PrimaryResult  2021-10-22T21:31:46.184Z
nodeapp               Got a new order! Order ID: 62    PrimaryResult  2021-10-22T22:01:57.174Z
nodeapp               Successfully persisted state.    PrimaryResult  2021-10-22T22:01:57.174Z
nodeapp               Got a new order! Order ID: 63    PrimaryResult  2021-10-22T22:45:44.618Z

Pulire le risorse

Complimenti. Questa esercitazione è stata completata. Per eliminare le risorse create come parte di questa procedura dettagliata, eseguire il comando seguente.

Attenzione

Questo comando elimina il gruppo di risorse specificato e tutte le risorse contenute al suo interno. Se nel gruppo di risorse specificato sono presenti anche risorse diverse da quelle usate in questa esercitazione, verranno eliminate.

Bash

az group delete --resource-group $RESOURCE_GROUP

Azure PowerShell

Remove-AzResourceGroup -Name $ResourceGroupName -Force

Nota

Poiché pythonapp effettua continuamente chiamate a nodeapp con messaggi che vengono salvati in modo permanente nell'archivio stati configurato, è importante completare questi passaggi di pulizia per evitare operazioni fatturabili in corso.

Suggerimento

Problemi? Segnalare i problemi su GitHub aprendo un ticket nel repository App contenitore di Azure.

Passaggi successivi

Application Lifecycle Management