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

Med Azure Container Apps-jobb kan du köra containerbaserade uppgifter som körs under en begränsad tid och sedan stoppas. Du kan utlösa en jobb 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 handledningen får du lära dig hur du arbetar med händelsestyrda jobb.

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

1. Hämtar ett meddelande från kön.
2. Loggar meddelandet till jobbkörningsloggarna.
3. Tar bort meddelandet från kön.
4. Stannar.

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.
• Azure CLI.

Information om funktioner som Container Apps-jobb inte stöder finns i Jobbbegränsningar.

Förbereda miljön

1. Om du vill logga in på Azure från Azure CLI kör du följande kommando och följer anvisningarna för att slutföra autentiseringsprocessen.

   az login
   

2. Kontrollera att du kör den senaste versionen av Azure CLI via az upgrade kommandot .

   az upgrade
   

3. Installera den senaste versionen av CLI-tillägget för Container Apps.

   az extension add --name containerapp --upgrade
   

4. Microsoft.AppRegistrera namnrymderna , Microsoft.OperationalInsightsoch Microsoft.Storage om de inte redan är registrerade i din Azure-prenumeration.

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

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

Container Apps-miljön fungerar som en isoleringsgräns runt containerappar och jobb så att de kan dela samma nätverk och kommunicera med varandra.

1. Skapa en resursgrupp med hjälp av följande kommando.

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

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

1. 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. De måste vara mellan 3 och 24 tecken långa och endast innehålla siffror och gemener.

2. 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 följande fel kontrollerar du att du har registrerat Microsoft.Storage namnområdet i din Azure-prenumeration.

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

   Använd det här kommandot för att registrera namnområdet:

   az provider register --namespace Microsoft.Storage
   

3. Spara anslutningssträngen för kön i en variabel:

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

4. 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 Azure Container Registry. Använd 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.

1. Skapa en användartilldelad hanterad identitet. Innan du kör följande kommandon väljer du ett namn på din hanterade identitet och skapar följande variabel:

   IDENTITY="<YOUR_IDENTITY_NAME>"
   

   az identity create \
       --name $IDENTITY \
       --resource-group $RESOURCE_GROUP
   

2. 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 det och skicka containern till ett register. Du kan sedan distribuera jobbet till Container Apps-miljön.

1. 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. De måste vara mellan 5 och 50 tecken långa och endast innehålla siffror och gemener.

2. Skapa ett containerregister:

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

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

   az acr config authentication-as-arm show --registry "$CONTAINER_REGISTRY_NAME"
   

   Om ARM-token tillåts visas följande utdata:

   {
     "status": "enabled"
   }
   

   Om status är disabled, tillåt ARM-token genom att använda följande kommando:

   az acr config authentication-as-arm update --registry "$CONTAINER_REGISTRY_NAME" --status enabled
   

4. 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:

   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.

5. 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ändes i föregående kommando.

   Parameter	Beskrivning
   --replica-timeout	Den maximala varaktigheten som en replik kan köras.
   --min-executions	Det minsta antalet jobbkörningar som ska utföras för varje avsökningsintervall.
   --max-executions	Det maximala antalet jobb som ska utfö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-containerregister 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 användarnamn och lösenord. Om möjligt skapas en acrpull rolltilldelning automatiskt för identiteten.
   --env-vars	Miljövariablerna som ska användas för jobbet.

   Skalningsregelkonfigurationen definierar den händelsekälla som ska övervakas. Den utvärderas vid varje pollningsintervall 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 utplaceringen

Jobbet är konfigurerat för att utvärdera skalningsregeln var 60:e sekund. Den här utvärderingen 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 kontrollera att jobbet är korrekt konfigurerat kan du skicka några meddelanden till kön och bekräfta att jobbkörningarna startar och att meddelandena loggas i jobbkörningsloggarna.

1. Skicka ett meddelande till kön:

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

2. 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 är konfigurerat för att utvärdera skalningsregeln var 60:e sekund kan det ta upp till en minut innan jobbutförandet startar. Upprepa kommandot tills du ser jobbkörningen och dess status är Succeeded.

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

   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.

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.

az group delete \
    --resource-group $RESOURCE_GROUP

Nästa steg