Esercitazione: Distribuire un processo basato su eventi utilizzando Azure Container Apps

I job di Azure Container Apps consentono di eseguire attività containerizzate che operano per una durata limitata e poi si arrestano. È possibile attivare l'esecuzione del processo manualmente, in base a una pianificazione o in base a eventi. I job sono ideali per attività come l'elaborazione dati, l'apprendimento automatico, la pulizia delle risorse o qualsiasi scenario che richiede risorse serverless temporanee di calcolo.

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

Creare un ambiente app contenitore in cui distribuire le app contenitore
Creare una coda di archiviazione su Azure per inviare messaggi all'applicazione di contenitore
Creare un'immagine del contenitore che esegue un compito
Distribuire il job all'ambiente Container Apps
Verificare che i messaggi della coda vengano elaborati dall'applicazione contenitore

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

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

Importante

Lo 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 a quando l'esecuzione del lavoro non ha terminato l'elaborazione.

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.
Interfaccia della riga di comando di Azure.

Per informazioni sulle funzionalità non supportate dai job di Container Apps, vedere Restrizioni dei job.

Preparare l'ambiente

Per accedere ad Azure dall'interfaccia della riga di comando di Azure, eseguire il comando seguente e seguire le istruzioni per completare il processo di autenticazione.
```
az login
```
Assicurarsi di eseguire la versione più recente dell'interfaccia della riga di comando di Azure tramite il az upgrade comando .
```
az upgrade
```
Installare la versione più recente dell'estensione dell'interfaccia della riga di comando di Container Apps.
```
az extension add --name containerapp --upgrade
```

Registrare i namespace Microsoft.App, Microsoft.OperationalInsights e Microsoft.Storage se non sono già registrati nel tuo abbonamento Azure.

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

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 Container Apps

L'ambiente Container Apps funge da limite di isolamento per le applicazioni container e i processi, in modo che possano condividere la stessa rete e comunicare tra loro.

Creare un gruppo di risorse tramite il comando seguente.

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

Creare l'ambiente di Container Apps usando il comando seguente.

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

Configurare una coda di archiviazione

** Il processo utilizza una coda di Archiviazione Azure per ricevere i 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 all'interno di Azure. Devono avere una lunghezza compresa tra 3 e 24 caratteri e contenere 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 seguente, assicurati di aver registrato lo Microsoft.Storage spazio dei nomi nel tuo abbonamento di Azure.

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

Usare questo comando per registrare lo spazio dei nomi:

az provider register --namespace Microsoft.Storage

Assegna la stringa di collegamento della coda a 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 Registro Azure Container. Usare 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 creare la variabile seguente:
```
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 task

Per distribuire il processo, è prima necessario compilare un'immagine del contenitore ed eseguire il push del contenitore in un registro. Puoi quindi distribuire il processo nell'ambiente Container Apps.

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 all'interno di Azure. Devono avere una lunghezza compresa tra 5 e 50 caratteri e contenere solo numeri e lettere minuscole.

Creare un registro dei container

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

Il registro dei contenitori deve consentire i token di audience di Azure Resource Manager (ARM) per l'autenticazione, al fine di usare l'identità gestita per estrarre le immagini.

Usare il comando seguente per verificare se i token ARM sono autorizzati ad accedere al Registro Azure Container:
```
az acr config authentication-as-arm show --registry "$CONTAINER_REGISTRY_NAME"
```
Se sono consentiti token ARM, viene visualizzato l'output seguente:
```
{
  "status": "enabled"
}
```
Se status è disabled, abilita i token ARM usando 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:
```
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 lavoro nell'ambiente App di 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 precedente.

Parametro	Descrizione
`--replica-timeout`	Durata massima di esecuzione di una replica.
`--min-executions`	Numero minimo di esecuzioni di processi da eseguire per ciascun intervallo di polling.
`--max-executions`	Numero massimo di esecuzioni di processi da eseguire per intervallo di polling.
`--polling-interval`	Intervallo di polling durante il 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`	I segreti da usare per il lavoro.
`--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`	L'ID risorsa dell'identità gestita assegnata dall'utente da assegnare al job.
`--registry-identity`	ID risorsa di un'identità gestita per autenticarsi con il server del registro 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 valutato in ogni intervallo di polling e determina quante esecuzioni di attività avviare. Per altre informazioni, vedere Impostare le regole di ridimensionamento.

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

Verificare la distribuzione

Il processo è configurato per valutare la regola di scalabilità ogni 60 secondi. Questa valutazione controlla il numero di messaggi nella coda. Per ogni periodo di valutazione, avvia una nuova esecuzione del lavoro per ogni messaggio nella coda, fino al massimo di 10 esecuzioni.

Per verificare che il processo sia configurato correttamente, è possibile inviare alcuni messaggi alla coda e 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 job:
```
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 potrebbe 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 il prompt per installare l'estensione.

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? Fateci sapere su GitHub aprendo un problema nel repository Azure Container Apps.

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 in esso contenute. Se sono presenti risorse esterne all'ambito di questa esercitazione nel gruppo di risorse specificato, vengono eliminate anche.

az group delete \
    --resource-group $RESOURCE_GROUP

Passo successivo

Attività di Container Apps

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-02-20