Esercitazione: Distribuire un processo guidato dagli eventi con App contenitore di Azure

Articolo
12/11/2024

I processi di App contenitore di Azure consentono di eseguire attività in contenitori che vengono eseguite per una durata limitata e poi escono. È possibile attivare l'esecuzione del processo manualmente, in base a una pianificazione o in base a eventi. I processi sono più adatti per attività come l'elaborazione dati, l'apprendimento automatico, la pulizia delle risorse o qualsiasi scenario che richiede risorse di calcolo temporanee serverless.

In questa esercitazione, si apprenderà a usare processi guidati dagli eventi.

Creare un ambiente App contenitore per distribuire le app contenitore
Creare una coda di archiviazione di Azure per inviare messaggi all'app contenitore
Creare un'immagine del contenitore che esegue un processo
Distribuire il processo nell'ambiente App contenitore
Verificare che i messaggi della coda vengano elaborati dall'app contenitore

Il processo creato avvia un'esecuzione per ogni messaggio inviato a una coda di Archiviazione di Azure. L’esecuzione di ogni processo esegue un contenitore che svolge le seguenti operazioni:

Ottiene un messaggio nella coda.
Registra il messaggio nei log di esecuzione del processo.
Elimina il messaggio dalla coda.
Esce.

Importante

Lo scaler monitora la lunghezza della coda per determinare il numero di processi da avviare. Per un ridimensionamento accurato, non eliminare un messaggio della coda fino al termine dell'elaborazione dell'esecuzione del processo.

Il codice sorgente del processo eseguito in questa esercitazione è disponibile in un repository GitHub di esempi di Azure.

Prerequisiti

Un account Azure con una sottoscrizione attiva.
- Se non hai un account, puoi crearlo gratuitamente.
Installare l'interfaccia della riga di comando di Azure.
Per un elenco delle limitazioni, vedere Restrizioni dei processi.

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.
```
az login
```
Assicurarsi di eseguire l’ultima versione dell'interfaccia della riga di comando tramite il comando di aggiornamento.
```
az upgrade
```
Installare l’ultima versione dell'estensione dell'interfaccia della riga di comando di App contenitore di Azure.
```
az extension add --name containerapp --upgrade
```

Registrare gli Microsoft.Appspazi dei nomi , Microsoft.OperationalInsightse Microsoft.Storage se non sono già stati registrati nella sottoscrizione di Azure.

az provider register --namespace Microsoft.App
az provider register --namespace Microsoft.OperationalInsights
az provider register --namespace Microsoft.Storage

Dopo aver completato la configurazione dell'interfaccia della riga di comando di Azure, è possibile definire le variabili di ambiente usate in questo articolo.
```
RESOURCE_GROUP="jobs-quickstart"
LOCATION="northcentralus"
ENVIRONMENT="env-jobs-quickstart"
JOB_NAME="my-job"
```

Creare un ambiente App contenitore

L'ambiente App contenitore di Azure funge da limite sicuro per le app contenitore e i processi, in modo che possano condividere la stessa rete e comunicare tra loro.

Creare un gruppo di risorse usando il comando seguente.

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

Creare l'ambiente App contenitore usando il comando seguente.

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

Configurare una coda di archiviazione

Il processo usa una coda di Archiviazione di Azure per ricevere messaggi. In questa sezione, si creano un account di archiviazione e una coda.

Definire un nome per l'account di archiviazione.
```
STORAGE_ACCOUNT_NAME="<STORAGE_ACCOUNT_NAME>"
QUEUE_NAME="myqueue"
```
Sostituire <STORAGE_ACCOUNT_NAME> con un nome univoco per l'account di archiviazione. I nomi degli account di archiviazione devono essere univoci in Azure e avere una lunghezza compresa tra 3 e 24 caratteri contenenti solo numeri e lettere minuscole.

Creare un account di archiviazione di Azure.

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

Se questo comando restituisce l'errore:

(SubscriptionNotFound) Subscription <SUBSCRIPTION_ID> was not found.
Code: SubscriptionNotFound
Message: Subscription <SUBSCRIPTION_ID> was not found.

Assicurarsi di aver registrato lo Microsoft.Storage spazio dei nomi nella sottoscrizione di Azure.

az provider register --namespace Microsoft.Storage

Salvare la stringa di connessione della coda in una variabile.

QUEUE_CONNECTION_STRING=$(az storage account show-connection-string -g $RESOURCE_GROUP --name $STORAGE_ACCOUNT_NAME --query connectionString --output tsv)

Creare la coda di messaggi.

az storage queue create \
    --name "$QUEUE_NAME" \
    --account-name "$STORAGE_ACCOUNT_NAME" \
    --connection-string "$QUEUE_CONNECTION_STRING"

Creare un'identità gestita assegnata dall'utente

Per evitare di usare credenziali amministrative, eseguire il pull delle immagini dai repository privati in Microsoft Registro Azure Container usando le identità gestite per l'autenticazione. Quando possibile, usare un'identità gestita assegnata dall'utente per eseguire il pull delle immagini.

Creare un'identità gestita assegnata dall'utente. Prima di eseguire i comandi seguenti, scegliere un nome per l'identità gestita e sostituire con \<PLACEHOLDER\> il nome .
```
IDENTITY="<YOUR_IDENTITY_NAME>"
```
```
az identity create \
    --name $IDENTITY \
    --resource-group $RESOURCE_GROUP
```

Ottenere l'ID risorsa dell'identità.

IDENTITY_ID=$(az identity show \
    --name $IDENTITY \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

Compilare e distribuire il processo

Per distribuire il processo, è prima necessario compilare un'immagine del contenitore per il processo ed eseguirne il push in un registro. È quindi possibile distribuire il processo nell'ambiente App contenitore.

Definire un nome per l'immagine del contenitore e il registro.
```
CONTAINER_IMAGE_NAME="queue-reader-job:1.0"
CONTAINER_REGISTRY_NAME="<CONTAINER_REGISTRY_NAME>"
```
Sostituire <CONTAINER_REGISTRY_NAME> con un nome univoco per il registro contenitori. I nomi del registro contenitori devono essere univoci in Azure e avere una lunghezza compresa tra 5 e 50 caratteri contenenti solo numeri e lettere minuscole.

Creare un registro contenitori.

az acr create \
    --name "$CONTAINER_REGISTRY_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --location "$LOCATION" \
    --sku Basic

Il registro contenitori deve consentire token di destinatari di Azure Resource Manager (ARM) per l'autenticazione per usare l'identità gestita per eseguire il pull delle immagini.

Usare il comando seguente per verificare se i token ARM sono autorizzati ad accedere al Registro Azure Container (ACR).
```
az acr config authentication-as-arm show --registry "$CONTAINER_REGISTRY_NAME"
```
Se sono consentiti token ARM, il comando restituisce quanto segue.
```
{
  "status": "enabled"
}
```
status Se è disabled, consentire i token ARM con il comando seguente.
```
az acr config authentication-as-arm update --registry "$CONTAINER_REGISTRY_NAME" --status enabled
```
Il codice sorgente del processo è disponibile in GitHub. Eseguire il comando seguente per clonare il repository e compilare l'immagine del contenitore nel cloud usando il comando az acr build.
```
az acr build \
    --registry "$CONTAINER_REGISTRY_NAME" \
    --image "$CONTAINER_IMAGE_NAME" \
    "https://github.com/Azure-Samples/container-apps-event-driven-jobs-tutorial.git"
```
L'immagine è ora disponibile nel registro contenitori.

Creare un processo nell'ambiente App contenitore.

az containerapp job create \
    --name "$JOB_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --environment "$ENVIRONMENT" \
    --trigger-type "Event" \
    --replica-timeout "1800" \
    --min-executions "0" \
    --max-executions "10" \
    --polling-interval "60" \
    --scale-rule-name "queue" \
    --scale-rule-type "azure-queue" \
    --scale-rule-metadata "accountName=$STORAGE_ACCOUNT_NAME" "queueName=$QUEUE_NAME" "queueLength=1" \
    --scale-rule-auth "connection=connection-string-secret" \
    --image "$CONTAINER_REGISTRY_NAME.azurecr.io/$CONTAINER_IMAGE_NAME" \
    --cpu "0.5" \
    --memory "1Gi" \
    --secrets "connection-string-secret=$QUEUE_CONNECTION_STRING" \
    --registry-server "$CONTAINER_REGISTRY_NAME.azurecr.io" \
    --mi-user-assigned "$IDENTITY_ID" \
    --registry-identity "$IDENTITY_ID" \
    --env-vars "AZURE_STORAGE_QUEUE_NAME=$QUEUE_NAME" "AZURE_STORAGE_CONNECTION_STRING=secretref:connection-string-secret"

Nella tabella seguente vengono descritti i parametri chiave usati nel comando.

Parametro	Descrizione
`--replica-timeout`	Durata massima di esecuzione di una replica.
`--min-executions`	Numero minimo di esecuzioni di processi da eseguire per intervallo di polling.
`--max-executions`	Numero massimo di esecuzioni di processi da eseguire per intervallo di polling.
`--polling-interval`	Intervallo di polling in corrispondenza del quale valutare la regola di scalabilità.
`--scale-rule-name`	Nome della regola di scalabilità.
`--scale-rule-type`	Tipo di regola di scalabilità da usare.
`--scale-rule-metadata`	Metadati della regola di scalabilità.
`--scale-rule-auth`	Autenticazione per la regola di scalabilità.
`--secrets`	Segreti da usare per il processo.
`--registry-server`	Server del registro contenitori da usare per il processo. Per un Registro Azure Container, il comando configura automaticamente l'autenticazione.
`--mi-user-assigned`	ID risorsa dell'identità gestita assegnata dall'utente da assegnare al processo.
`--registry-identity`	ID risorsa di un'identità gestita da autenticare con il server del Registro di sistema anziché usare un nome utente e una password. Se possibile, viene creata automaticamente un'assegnazione di ruolo "acrpull" per l'identità.
`--env-vars`	Variabili di ambiente da usare per il processo.

La configurazione della regola di scalabilità definisce l'origine evento da monitorare. Viene valutata in ogni intervallo di polling e determina il numero di esecuzioni di processi da attivare. Per altre informazioni, vedere Impostare le regole di ridimensionamento.

Il processo guidato dagli eventi viene così creato nell'ambiente App contenitore.

Verificare la distribuzione

Il processo è configurato per valutare ogni 60 secondi la regola di ridimensionamento, che controlla il numero di messaggi nella coda. Per ogni periodo di valutazione, avvia una nuova esecuzione di processo per ogni messaggio nella coda, fino a un massimo di 10 esecuzioni.

Per verificare che il processo sia stato configurato correttamente, è possibile inviare alcuni messaggi alla coda, verificare che le esecuzioni del processo siano avviate e che i messaggi vengano registrati nei log di esecuzione del processo.

Inviare un messaggio alla coda.

az storage message put \
    --content "Hello Queue Reader Job" \
    --queue-name "$QUEUE_NAME" \
    --connection-string "$QUEUE_CONNECTION_STRING"

Elencare le esecuzioni di un processo.
```
az containerapp job execution list \
    --name "$JOB_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --output json
```
Poiché il processo è configurato per valutare la regola di scalabilità ogni 60 secondi, l'avvio dell'esecuzione del processo può richiedere fino a un minuto. Ripetere il comando fino a visualizzare l'esecuzione del processo e il relativo stato Succeeded.

Eseguire i comandi seguenti per visualizzare i messaggi registrati. Questi comandi richiedono l'estensione Log Analytics, quindi accettare la richiesta di installazione dell'estensione quando richiesto.

LOG_ANALYTICS_WORKSPACE_ID=$(az containerapp env show --name $ENVIRONMENT --resource-group $RESOURCE_GROUP --query properties.appLogsConfiguration.logAnalyticsConfiguration.customerId --output tsv)

az monitor log-analytics query \
    --workspace "$LOG_ANALYTICS_WORKSPACE_ID" \
    --analytics-query "ContainerAppConsoleLogs_CL | where ContainerJobName_s == '$JOB_NAME' | order by _timestamp_d asc"

Finché la tabella ContainerAppConsoleLogs_CL non è pronta, il comando restituisce un errore: BadArgumentError: The request had some invalid properties. Attendere alcuni minuti e riprovare.

Suggerimento

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

Pulire le risorse

Una volta terminato, eseguire il comando seguente per eliminare il gruppo di risorse che contiene le risorse di App contenitore.

Attenzione

Nell'esempio seguente, il gruppo di risorse specificato e tutte le risorse al suo interno vengono eliminati. Se nel gruppo di risorse specificato sono presenti anche risorse diverse da quelle usate in questa esercitazione, verranno eliminate.

az group delete \
    --resource-group $RESOURCE_GROUP

Passaggi successivi

Processi di App contenitore

Condividi tramite