Självstudie: Distribuera ett händelsedrivet jobb med Azure Container Apps

2024-12-11

Med Azure Container Apps-jobb kan du köra containerbaserade uppgifter som körs under en begränsad tid och avslutas. Du kan utlösa en jobbkörning manuellt, enligt ett schema eller baserat på händelser. Jobb passar bäst för uppgifter som databehandling, maskininlärning, resursrensning eller alla scenarion som kräver serverlösa tillfälliga beräkningsresurser.

I den här självstudien får du lära dig hur du arbetar med händelsedrivna jobb.

Skapa en Container Apps-miljö för att distribuera dina containerappar
Skapa en Azure Storage-kö för att skicka meddelanden till containerappen
Skapa en containeravbildning som kör ett jobb
Distribuera jobbet till Container Apps-miljön
Kontrollera att kömeddelandena bearbetas av containerappen

Jobbet du skapar startar en körning för varje meddelande som skickas till en Azure Storage-kö. Varje jobbkörning kör en container som utför följande steg:

Hämtar ett meddelande från kön.
Loggar meddelandet till jobbkörningsloggarna.
Tar bort meddelandet från kön.
Utgångar.

Viktigt!

Skalningsmaskinen övervakar köns längd för att avgöra hur många jobb som ska startas. För korrekt skalning tar du inte bort ett meddelande från kön förrän jobbkörningen har slutfört bearbetningen.

Källkoden för det jobb du kör i den här självstudien är tillgänglig på en Azure Samples GitHub-lagringsplats.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration.
- Om du inte har någon sådan nu kan du skapa en kostnadsfritt.
Installera Azure CLI.
Se jobbbegränsningar för en lista över begränsningar.

Ställ in

Om du vill logga in på Azure från CLI kör du följande kommando och följer anvisningarna för att slutföra autentiseringsprocessen.
```
az login
```
Kontrollera att du kör den senaste versionen av CLI via uppgraderingskommandot.
```
az upgrade
```
Installera den senaste versionen av Azure Container Apps CLI-tillägget.
```
az extension add --name containerapp --upgrade
```

Microsoft.AppRegistrera namnrymderna , Microsoft.OperationalInsightsoch Microsoft.Storage om du inte redan har registrerat dem i din Azure-prenumeration.

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

Nu när azure CLI-installationen är klar kan du definiera de miljövariabler som används i hela den här artikeln.
```
RESOURCE_GROUP="jobs-quickstart"
LOCATION="northcentralus"
ENVIRONMENT="env-jobs-quickstart"
JOB_NAME="my-job"
```

Skapa en Container Apps-miljö

Azure Container Apps-miljön fungerar som en säker gräns för containerappar och jobb så att de kan dela samma nätverk och kommunicera med varandra.

Använd följande kommando för att skapa en resursgrupp.

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

Skapa Container Apps-miljön med hjälp av följande kommando.

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

Konfigurera en lagringskö

Jobbet använder en Azure Storage-kö för att ta emot meddelanden. I det här avsnittet skapar du ett lagringskonto och en kö.

Definiera ett namn för ditt lagringskonto.
```
STORAGE_ACCOUNT_NAME="<STORAGE_ACCOUNT_NAME>"
QUEUE_NAME="myqueue"
```
Ersätt <STORAGE_ACCOUNT_NAME> med ett unikt namn för ditt lagringskonto. Lagringskontonamn måste vara unika i Azure och vara mellan 3 och 24 tecken långa och innehåller endast siffror och gemener.

skapa ett Azure Storage-konto

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

Om det här kommandot returnerar felet:

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

Se till att du har registrerat Microsoft.Storage namnområdet i din Azure-prenumeration.

az provider register --namespace Microsoft.Storage

Spara köns anslutningssträng i en variabel.

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

Skapa meddelandekön.

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

Skapa en användartilldelad hanterad identitet

Undvik att använda administrativa autentiseringsuppgifter genom att hämta avbildningar från privata lagringsplatser i Microsoft Azure Container Registry med hanterade identiteter för autentisering. När det är möjligt kan du använda en användartilldelad hanterad identitet för att hämta bilder.

Skapa en användartilldelad hanterad identitet. Innan du kör följande kommandon väljer du ett namn för din hanterade identitet och ersätter \<PLACEHOLDER\> med namnet.
```
IDENTITY="<YOUR_IDENTITY_NAME>"
```
```
az identity create \
    --name $IDENTITY \
    --resource-group $RESOURCE_GROUP
```

Hämta identitetens resurs-ID.

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

Skapa och distribuera jobbet

Om du vill distribuera jobbet måste du först skapa en containeravbildning för jobbet och skicka den till ett register. Sedan kan du distribuera jobbet till Container Apps-miljön.

Definiera ett namn för containeravbildningen och registret.
```
CONTAINER_IMAGE_NAME="queue-reader-job:1.0"
CONTAINER_REGISTRY_NAME="<CONTAINER_REGISTRY_NAME>"
```
Ersätt <CONTAINER_REGISTRY_NAME> med ett unikt namn för containerregistret. Containerregisternamn måste vara unika i Azure och vara mellan 5 och 50 tecken långa och innehåller endast siffror och gemener.

Skapa ett containerregister.

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

Ditt containerregister måste tillåta Azure Resource Manager-målgruppstoken (ARM) för autentisering för att kunna använda hanterad identitet för att hämta avbildningar.

Använd följande kommando för att kontrollera om ARM-token får åtkomst till ditt Azure Container Registry (ACR).
```
az acr config authentication-as-arm show --registry "$CONTAINER_REGISTRY_NAME"
```
Om ARM-token tillåts matar kommandot ut följande.
```
{
  "status": "enabled"
}
```
status Om är disabledtillåter du ARM-token med följande kommando.
```
az acr config authentication-as-arm update --registry "$CONTAINER_REGISTRY_NAME" --status enabled
```
Källkoden för jobbet är tillgänglig på GitHub. Kör följande kommando för att klona lagringsplatsen och skapa containeravbildningen i molnet med kommandot 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"
```
Avbildningen är nu tillgänglig i containerregistret.

Skapa ett jobb i Container Apps-miljön.

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"

I följande tabell beskrivs de nyckelparametrar som används i kommandot.

Parameter	Description
`--replica-timeout`	Den maximala varaktighet som en replik kan köra.
`--min-executions`	Det minsta antalet jobbkörningar som ska köras per avsökningsintervall.
`--max-executions`	Det maximala antalet jobbkörningar som ska köras per avsökningsintervall.
`--polling-interval`	Avsökningsintervallet för att utvärdera skalningsregeln.
`--scale-rule-name`	Namnet på skalningsregeln.
`--scale-rule-type`	Vilken typ av skalningsregel som ska användas.
`--scale-rule-metadata`	Metadata för skalningsregeln.
`--scale-rule-auth`	Autentiseringen för skalningsregeln.
`--secrets`	Hemligheterna som ska användas för jobbet.
`--registry-server`	Den containerregisterserver som ska användas för jobbet. För ett Azure Container Registry konfigurerar kommandot automatiskt autentisering.
`--mi-user-assigned`	Resurs-ID:t för den användartilldelade hanterade identiteten som ska tilldelas jobbet.
`--registry-identity`	Resurs-ID för en hanterad identitet som ska autentiseras med registerservern i stället för att använda ett användarnamn och lösenord. Om möjligt skapas en "acrpull"-rolltilldelning för identiteten automatiskt.
`--env-vars`	Miljövariablerna som ska användas för jobbet.

Skalningsregelkonfigurationen definierar den händelsekälla som ska övervakas. Den utvärderas på varje avsökningsintervall och avgör hur många jobbkörningar som ska utlösas. Mer information finns i Ange skalningsregler.

Det händelsedrivna jobbet skapas nu i Container Apps-miljön.

Verifiera distributionen

Jobbet är konfigurerat för att utvärdera skalningsregeln var 60:e sekund, vilket kontrollerar antalet meddelanden i kön. För varje utvärderingsperiod startar den en ny jobbkörning för varje meddelande i kön, upp till högst 10 körningar.

För att verifiera att jobbet har konfigurerats korrekt kan du skicka vissa meddelanden till kön, bekräfta att jobbkörningarna har startats och att meddelandena loggas i jobbkörningsloggarna.

Skicka ett meddelande till kön.

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

Visa en lista över körningar av ett jobb.
```
az containerapp job execution list \
    --name "$JOB_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --output json
```
Eftersom jobbet har konfigurerats för att utvärdera skalningsregeln var 60:e sekund kan det ta upp till en hel minut innan jobbkörningen startar. Upprepa kommandot tills du ser jobbkörningen och dess status är Succeeded.

Kör följande kommandon för att se loggade meddelanden. Dessa kommandon kräver Log Analytics-tillägget, så acceptera uppmaningen att installera tillägget när det begärs.

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"

Tills tabellen ContainerAppConsoleLogs_CL är klar returnerar kommandot ett fel: BadArgumentError: The request had some invalid properties. Vänta några minuter och försök igen.

Dricks

Har du problem? Meddela oss på GitHub genom att öppna ett problem i Azure Container Apps-lagringsplatsen.

Rensa resurser

När du är klar kör du följande kommando för att ta bort resursgruppen som innehåller dina Container Apps-resurser.

Varning

Följande kommando tar bort den angivna resursgruppen och alla resurser som ingår i den. Om det finns resurser utanför omfånget för den här självstudien i den angivna resursgruppen tas de också bort.

az group delete \
    --resource-group $RESOURCE_GROUP

Nästa steg

Container Apps-jobb

Feedback

Var den här sidan till hjälp?