Esercitazione: Distribuire un processo basato su eventi con App Contenitore di Azure

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

In questa esercitazione si apprenderà come usare processi basati su eventi.

• Creare un ambiente app contenitore per distribuire le app contenitore
• Creare una coda 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. Ogni esecuzione del processo esegue un contenitore che esegue i passaggi seguenti:

1. Ottiene un messaggio dalla coda.
2. Registra il messaggio nei log di esecuzione del processo.
3. Elimina il messaggio dalla coda.
4. Uscite.

Importante

Il scaler monitora la lunghezza della coda per determinare il numero di processi da avviare. Per una scalabilità accurata, non eliminare un messaggio dalla coda fino al termine dell'elaborazione dell'esecuzione del processo.

Il codice sorgente per il 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 la versione più recente dell'interfaccia della riga di comando tramite il comando di aggiornamento.

   az upgrade
   

3. Installare la versione più recente dell'estensione dell'interfaccia della riga di comando di App Azure Container.

   az extension add --name containerapp --upgrade
   

4. Registrare gli Microsoft.App spazi dei nomi 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 Azure Container funge da limite sicuro per le app e i processi del contenitore, 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 viene creato 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. Archiviazione nomi di account devono essere univoci all'interno di Azure e avere una lunghezza compresa tra 3 e 24 caratteri contenente 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 il 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 per il processo è disponibile in GitHub. Eseguire il comando seguente per clonare il repository e compilare l'immagine del contenitore nel cloud usando il az acr build comando .

   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 per la 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 basato su eventi viene ora creato nell'ambiente App contenitore.

Verificare la distribuzione

Il processo è configurato per valutare la regola di scala ogni 60 secondi, che controlla il numero di messaggi nella coda. Per ogni periodo di valutazione, avvia una nuova esecuzione del 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 il prompt per installare l'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 ContainerAppConsoleLogs_CL tabella non è pronta, il comando restituisce un errore: BadArgumentError: The request had some invalid properties. Attendere alcuni minuti e riprovare.

Suggerimento

Problemi? Segnalare il problema in GitHub aprendo un problema nel repository di App contenitore di Azure.

Pulire le risorse

Al termine, eseguire il comando seguente per eliminare il gruppo di risorse che contiene le risorse di App contenitore.

Attenzione

Il comando seguente 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.

az group delete \
    --resource-group $RESOURCE_GROUP

Passaggi successivi

Processi di App contenitore