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

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:

1. Ottiene un messaggio nella coda.
2. Registra il messaggio nei log di esecuzione del processo.
3. Elimina il messaggio dalla coda.
4. 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

1. 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
   

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

   az upgrade
   

3. Installare l’ultima versione dell'estensione dell'interfaccia della riga di comando di App contenitore di Azure.

   az extension add --name containerapp --upgrade
   

4. Registrare gli spazi dei nomi Microsoft.App e Microsoft.OperationalInsights se non sono già stati registrati nella sottoscrizione di Azure.

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

5. 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.

1. Creare un gruppo di risorse usando il comando seguente.

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

2. 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.

1. 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.

2. 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
   

3. 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`
   

4. Creare la coda di messaggi.

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

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.

1. 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.

2. Creare un registro contenitori.

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

3. 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.

4. 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" \
       --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.
   --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.

1. Inviare un messaggio alla coda.

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

2. 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.

3. 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 --out 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