Esercitazione: Distribuire un'applicazione Dapr in App Azure Container 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 le app contenitore
• Creare un archivio stati Archiviazione BLOB di Azure per l'app contenitore
• Distribuire due app che producono e usano messaggi e renderli persistenti nell'archivio stati
• Verificare l'interazione tra i due microservizi.

Con App Azure Container si ottiene una versione completamente gestita delle API Dapr durante la creazione di microservizi. Quando si usa Dapr nelle app Azure Container, è possibile abilitare l'esecuzione sidecars accanto ai microservizi che offrono un set completo di funzionalità. Le API Dapr disponibili includono chiamate da servizio a servizio, pub/sub, associazioni di eventi, archivi di stato e attori.

In questa esercitazione si distribuiscono le stesse applicazioni dalla guida introduttiva a 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

Per assicurarsi di eseguire la versione più recente 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 Azure Container per l'interfaccia della riga di comando.

Bash

az extension add --name containerapp --upgrade

Azure PowerShell

Install-Module -Name Az.App

Se è installata una versione precedente del modulo Az.App, aggiornarla.

Update-Module -Name Az.App

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

Nota

Le risorse di App Azure Container sono state migrate dallo Microsoft.Web spazio dei nomi allo Microsoft.App spazio dei nomi . Per altri dettagli, vedere Migrazione dello spazio dei nomi da Microsoft.Web a Microsoft.App nel mese di marzo 2022.

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 <PLACEHOLDERS> 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 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. Archiviazione nomi di account devono essere univoci all'interno di Azure, da 3 a 24 caratteri e devono 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 l'account 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 node

Mentre 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 principalId proprietà 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 Storage Blob Data Contributor ruolo 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 segreti e fornire invece l'accesso diretto dall'app node all'archivio BLOB usando l'identità gestita. Se si vuole usare un archivio stati non Di Azure o l'API Segreti dapr in fase di esecuzione, è possibile creare un componente dell'archivio segreti. Questo componente carica i segreti di runtime in modo da poterli 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 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 STORAGE_ACCOUNT_NAME variabile definita. Per ottenere il valore, eseguire il comando seguente:

Bash

echo $STORAGE_ACCOUNT_NAME

• Sostituire <MANAGED_IDENTITY_CLIENT_ID> con il valore della CLIENT_ID variabile 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'

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

Per impostazione predefinita, l'immagine viene estratta dall'hub Docker.

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

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

Verificare i risultati

Confermare la persistenza dello stato riuscito

È possibile verificare che i servizi funzionino correttamente visualizzando i dati nell'account 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 ContainerAppConsoleLogs_CL tabella personalizzata nell'area di lavoro Log Analytics. È possibile visualizzare i log tramite il portale di Azure o tramite l'interfaccia della riga di comando. Potrebbe verificarsi un piccolo ritardo inizialmente per la visualizzazione della 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 il problema in GitHub aprendo un problema nel repository di App contenitore di Azure.

Passaggi successivi

Gestione del ciclo di vita delle applicazioni