Självstudie: Kom igång med Azure WebJobs SDK för händelsedriven bakgrundsbearbetning

Artikel
06/01/2023

Kom igång med Azure WebJobs SDK för Azure App Service så att dina webbappar kan köra bakgrundsaktiviteter, schemalagda aktiviteter och svara på händelser.

Använd Visual Studio 2022 för att skapa en .NET Core-konsolapp som använder WebJobs SDK för att svara på Azure Storage Queue-meddelanden, köra projektet lokalt och slutligen distribuera det till Azure.

I den här självstudien får du lära dig hur man:

Skapa en konsolapp
Lägga till en funktion
Testa lokalt
Distribuera till Azure
Aktivera Application Insights-loggning
Lägga till indata-/utdatabindningar

Förutsättningar

Visual Studio 2022 med arbetsbelastningen Azure Development . Installera Visual Studio 2022.
Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.

Skapa en konsolapp

I det här avsnittet börjar du med att skapa ett projekt i Visual Studio 2022. Nu ska du lägga till verktyg för Azure-utveckling, kodpublicering och funktioner som lyssnar efter utlösare och anropsfunktioner. Slutligen konfigurerar du konsolloggning som inaktiverar ett äldre övervakningsverktyg och aktiverar en konsolprovider med standardfiltrering.

Anteckning

Procedurerna i den här artikeln verifieras för att skapa en .NET Core-konsolapp som körs på .NET 6.0.

Skapa ett projekt

I Visual Studio väljer du Arkiv>Nytt>projekt.
Under Skapa ett nytt projekt väljer du Konsolprogram (C#) och sedan Nästa.
Under Konfigurera det nya projektet namnger du projektet WebJobsSDKSample och väljer sedan Nästa.
Välj målramverket och välj Skapa. Den här självstudien har verifierats med hjälp av .NET 6.0.

Installera WebJobs NuGet-paket

Installera det senaste WebJobs NuGet-paketet. Det här paketet innehåller Microsoft.Azure.WebJobs (WebJobs SDK), som gör att du kan publicera funktionskoden till WebJobs i Azure App Service.

Hämta den senaste stabila 4.x-versionen av NuGet-paketet Microsoft.Azure.WebJobs.Extensions.
I Visual Studio går du till Verktyg>NuGet Package Manager.
Välj Package Manager-konsolen. Du ser en lista över NuGet-cmdletar, en länk till dokumentationen och en PM> startpunkt.
I följande kommando ersätter <4_X_VERSION> du med det aktuella versionsnumret som du hittade i steg 1.
```
Install-Package Microsoft.Azure.WebJobs.Extensions -version <4_X_VERSION>
```
Kör kommandot i Package Manager-konsolen. Tilläggslistan visas och installeras automatiskt.

Skapa värden

Värden är körningscontainern för funktioner som lyssnar efter utlösare och anropar funktioner. Följande steg skapar en värd som implementerar IHost, som är den allmänna värden i ASP.NET Core.

Välj fliken Program.cs , ta bort det befintliga innehållet och lägg till följande using instruktioner:
```
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
```

Under Program.cs lägger du även till följande kod:

namespace WebJobsSDKSample
{
    class Program
    {
        static async Task Main()
        {
            var builder = new HostBuilder();
            builder.ConfigureWebJobs(b =>
            {
                b.AddAzureStorageCoreServices();
            });
            var host = builder.Build();
            using (host)
            {
                await host.RunAsync();
            }
        }
    }
}

I ASP.NET Core anges värdkonfigurationer genom att anropa metoder på instansenHostBuilder. Mer information finns i .NET Generic Host. Tilläggsmetoden ConfigureWebJobs initierar WebJobs-värden. I ConfigureWebJobsinitierar du specifika bindningstillägg, till exempel Storage-bindningstillägget, och anger egenskaperna för dessa tillägg.

Aktivera konsolloggning

Konfigurera konsolloggning som använder det ASP.NET Core loggningsramverket. Det här ramverket, Microsoft.Extensions.Logging, innehåller ett API som fungerar med en mängd olika inbyggda och tredje parts loggningsproviders.

Hämta den senaste stabila versionen av Microsoft.Extensions.Logging.Console NuGet-paketet, som innehåller Microsoft.Extensions.Logging.
I följande kommando ersätter <6_X_VERSION> du med det aktuella versionsnumret som du hittade i steg 1. Varje typ av NuGet-paket har ett unikt versionsnummer.
```
Install-Package Microsoft.Extensions.Logging.Console -version <6_X_VERSION>
```
I Package Manager-konsolen fyller du i det aktuella versionsnumret och kör kommandot . Tilläggslistan visas och installeras automatiskt.
Lägg till den här using instruktionen under fliken Program.cs:
```
using Microsoft.Extensions.Logging;
```
Fortsätt under Program.cs och lägg till -metoden HostBuilderi ConfigureLogging före Build kommandot . Metoden AddConsole lägger till konsolloggning i konfigurationen.
```
builder.ConfigureLogging((context, b) =>
{
    b.AddConsole();
});
```
Metoden Main ser nu ut så här:
```
static async Task Main()
{
    var builder = new HostBuilder();
    builder.ConfigureWebJobs(b =>
            {
                b.AddAzureStorageCoreServices();
            });
    builder.ConfigureLogging((context, b) =>
            {
                b.AddConsole();
            });
    var host = builder.Build();
    using (host)
    {
        await host.RunAsync();
    }
}
```
Det här tillägget gör följande ändringar:
- Inaktiverar loggning av instrumentpaneler. Instrumentpanelen är ett äldre övervakningsverktyg och instrumentpanelsloggning rekommenderas inte för produktionsscenarier med högt dataflöde.
- Lägger till konsolprovidern med standardfiltrering.

Nu kan du lägga till en funktion som utlöses av meddelanden som kommer till en Azure Storage-kö.

Lägga till en funktion

En funktion är en kodenhet som körs enligt ett schema, utlöses baserat på händelser eller körs på begäran. En utlösare lyssnar på en tjänsthändelse. I kontexten för WebJobs SDK refererar utlöst inte till distributionsläget. Händelsedrivna eller schemalagda webbjobb som skapats med SDK:t ska alltid distribueras som kontinuerliga webbjobb med "Alltid på" aktiverat.

I det här avsnittet skapar du en funktion som utlöses av meddelanden i en Azure Storage-kö. Först måste du lägga till ett bindningstillägg för att ansluta till Azure Storage.

Installera tillägget för Storage-bindning

Från och med version 3 av WebJobs SDK måste du installera ett separat storage-bindningstilläggspaket för att ansluta till Azure Storage-tjänster.

Anteckning

Från och med 5.x har Microsoft.Azure.WebJobs.Extensions.Storage delats upp av lagringstjänsten och har migrerat tilläggsmetoden AddAzureStorage() efter tjänsttyp.

Hämta den senaste stabila versionen av Microsoft.Azure.WebJobs.Extensions.Storage NuGet-paketet version 5.x.
I följande kommando ersätter <5_X_VERSION> du med det aktuella versionsnumret som du hittade i steg 1. Varje typ av NuGet-paket har ett unikt versionsnummer.
```
Install-Package Microsoft.Azure.WebJobs.Extensions.Storage -Version <5_X_VERSION>
```
I Package Manager-konsolen kör du kommandot med det aktuella versionsnumret vid PM> startpunkten.
I tilläggsmetoden fortsätter du i ConfigureWebJobsProgram.cs och lägger till AddAzureStorageQueues metoden på instansen HostBuilder (före Build kommandot) för att initiera Storage-tillägget. I det här läget ConfigureWebJobs ser metoden ut så här:
```
builder.ConfigureWebJobs(b =>
{
    b.AddAzureStorageCoreServices();
    b.AddAzureStorageQueues();
});
```

Lägg till följande kod i Main -metoden efter builder att har instansierats:

builder.UseEnvironment(EnvironmentName.Development);

Om du kör i utvecklingsläge minskas exponentiell backoff för köavsökning som avsevärt kan fördröja den tid det tar för körningen att hitta meddelandet och anropa funktionen. Du bör ta bort den här kodraden eller växla till Production när du är klar med utveckling och testning.

Metoden Main bör nu se ut som i följande exempel:

static async Task Main()
{
    var builder = new HostBuilder();
    builder.UseEnvironment(EnvironmentName.Development);
    builder.ConfigureLogging((context, b) =>
    {
        b.AddConsole();
    });
    builder.ConfigureWebJobs(b =>
    {
        b.AddAzureStorageCoreServices();
        b.AddAzureStorageQueues();
    });
    var host = builder.Build();
    using (host)
    {
        await host.RunAsync();
    }
}

Skapa en köutlöst funktion

Attributet QueueTrigger instruerar körningen att anropa den här funktionen när ett nytt meddelande skrivs i en Azure Storage-kö med namnet queue. Innehållet i kömeddelandet tillhandahålls till metodkoden i parametern message . I metodens brödtext bearbetar du utlösardata. I det här exemplet loggar koden bara meddelandet.

I Solution Explorer högerklickar du på projektet, väljer Lägg till>nytt objekt och väljer sedan Klass.
Ge den nya C#-klassfilen namnet Functions.cs och välj Lägg till.
I Functions.cs ersätter du den genererade mallen med följande kod:
```
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;

namespace WebJobsSDKSample
{
    public class Functions
    {
        public static void ProcessQueueMessage([QueueTrigger("queue")] string message, ILogger logger)
        {
            logger.LogInformation(message);
        }
    }
}
```
Du bör markera Functions-klassen som public static för att körningen ska komma åt och köra metoden. När ett meddelande läggs till i en kö med namnet queuei kodexemplet ovan körs funktionen och strängen message skrivs till loggarna. Kön som övervakas finns i standardkontot för Azure Storage, som du skapar härnäst.

Parametern message behöver inte vara en sträng. Du kan också binda till ett JSON-objekt, en bytematris eller ett CloudQueueMessage-objekt . Se Användning av köutlösare. Varje bindningstyp (till exempel köer, blobbar eller tabeller) har en annan uppsättning parametertyper som du kan binda till.

Skapa ett Azure Storage-konto

Azure Storage-emulatorn som körs lokalt har inte alla funktioner som WebJobs SDK behöver. Du skapar ett lagringskonto i Azure och konfigurerar projektet så att det använder det.

Information om hur du skapar ett allmänt v2-lagringskonto finns i Skapa ett Azure Storage-konto.

Leta upp och kopiera anslutningssträngen

En anslutningssträng krävs för att konfigurera lagring. Behåll den här anslutningssträngen för nästa steg.

I Azure Portal navigerar du till ditt lagringskonto och väljer Inställningar.
I Inställningar väljer du Åtkomstnycklar.
För Anslutningssträngen under key1 väljer du ikonen Kopiera till Urklipp .

Konfigurera lagring för att köras lokalt

WebJobs SDK söker efter lagringsanslutningssträngen i Programinställningar i Azure. När du kör lokalt söker den efter det här värdet i den lokala konfigurationsfilen eller i miljövariabler.

Högerklicka på projektet, välj Lägg till>nytt objekt, välj JavaScript JSON-konfigurationsfil, ge den nya filen namnet appsettings.json och välj Lägg till.
I den nya filen lägger du till ett AzureWebJobsStorage fält, som i följande exempel:
```
{
    "AzureWebJobsStorage": "{storage connection string}"
}
```
Ersätt {storage connection string} med anslutningssträngen som du kopierade tidigare.
Välj filen appsettings.json i Solution Explorer och i fönstret Egenskaper anger du åtgärden Kopiera till utdatakatalog till Kopiera om den är nyare.

Eftersom den här filen innehåller en anslutningssträngshemlighet bör du inte lagra filen på en fjärrkodslagringsplats. När du har publicerat projektet i Azure kan du lägga till samma appinställning för anslutningssträngar i din app i Azure App Service.

Testa lokalt

Skapa och kör projektet lokalt och skapa en meddelandekö för att utlösa funktionen.

I Azure Portal navigerar du till ditt lagringskonto och väljer fliken Köer (1). Välj + Kö (2) och ange kön som könamn (3). Välj sedan OK (4).
Klicka på den nya kön och välj Lägg till meddelande.
I dialogrutan Lägg till meddelande anger du Hello World! som meddelandetext och väljer sedan OK. Det finns nu ett meddelande i kön.
Tryck på Ctrl+F5 för att köra projektet.

Konsolen visar att körningen hittade din funktion. Eftersom du använde QueueTrigger attributet i ProcessQueueMessage funktionen lyssnar WebJobs-körningen efter meddelanden i kön med namnet queue. När den hittar ett nytt meddelande i den här kön anropar körningen funktionen och skickar in värdet för meddelandesträngen.
Gå tillbaka till köfönstret och uppdatera det. Meddelandet är borta eftersom det har bearbetats av din funktion som körs lokalt.
Stäng konsolfönstret.

Nu är det dags att publicera ditt WebJobs SDK-projekt till Azure.

Distribuera till Azure

Under distributionen skapar du en App Service-instans där du ska köra dina funktioner. När du publicerar en .NET-konsolapp för att App Service i Azure körs den automatiskt som ett webbjobb. Mer information om publicering finns i Utveckla och distribuera webbjobb med Visual Studio.

Skapa Azure-resurser

I Solution Explorer högerklickar du på projektet och väljer Publicera.
I dialogrutan Publicera väljer du Azure för Mål och sedan Nästa.
Välj Azure WebJobs för Specifikt mål och välj sedan Nästa.
Ovanför App Service instanser väljer du plusknappen (+) för att skapa ett nytt Azure-webbjobb.

I dialogrutan App Service (Windows) använder du värdinställningarna i följande tabell.

Inställning	Föreslaget värde	Beskrivning
Namn	Globalt unikt namn	Namn som unikt identifierar din nya funktionsapp.
Prenumeration	Välj din prenumeration	Den Azure-prenumeration som ska användas.
Resursgrupp	myResourceGroup	Namnet på resursgruppen som funktionsappen ska skapas i. Skapa en ny resursgrupp genom att välja Ny.
Värdplan	App Service-plan	En App Service-plan anger plats, storlek och funktioner för webbservergruppen som är värd för din app. Du kan spara pengar när du är värd för flera appar genom att konfigurera webbapparna så att de delar en enda App Service-plan. App Service planer definierar region, instansstorlek, skalningsantal och SKU (kostnadsfritt, delat, grundläggande, standard eller Premium). Välj Ny för att skapa en ny App Service plan. Kostnadsfria och grundläggande nivåer stöder inte alternativet AlwaysOn för att hålla webbplatsen igång kontinuerligt.

Dialogrutan Skapa App Service

Välj Skapa för att skapa ett webbjobb och relaterade resurser i Azure med de här inställningarna och distribuera din projektkod.
Välj Slutför för att återgå till sidan Publicera .

Aktivera AlwaysOn

För ett kontinuerligt webbjobb bör du aktivera inställningen Alltid på på webbplatsen så att dina webbjobb körs korrekt. Om du inte aktiverar Always on blir körningen inaktiv efter några minuters inaktivitet.

På sidan Publicera väljer du de tre punkterna ovanför Värd för att visa avsnittsåtgärder för värdprofil och väljer Öppna i Azure Portal.
Under Inställningar väljer duAllmänna inställningar för konfiguration>, ställer in Alltid på påpå och väljer sedan Spara och Fortsätt för att starta om platsen.

Publicera projektet

När webbappen har skapats i Azure är det dags att publicera webjobs-projektet.

På sidan Publicera under Värd väljer du redigeringsknappen och ändrar webbjobbstypen till Continuous och väljer Spara. Detta säkerställer att webbjobbet körs när meddelanden läggs till i kön. Utlösta webbjobb används vanligtvis endast för manuella webhooks.
Välj knappen Publicera i det övre högra hörnet på sidan Publicera . När åtgärden är klar körs webbjobbet på Azure.

Skapa en appinställning för lagringsanslutning

Du måste skapa samma inställning för lagringsanslutningssträngen i Azure som du använde lokalt i konfigurationsfilen appsettings.json. På så sätt kan du lagra anslutningssträngen på ett säkrare sätt och

På sidan Publicera profil väljer du de tre punkterna ovanför Värd för att visa avsnittsåtgärder för värdprofil och väljer Hantera Azure App Service inställningar.
I Programinställningar väljer du + Lägg till inställning.
I Nytt appinställningsnamn skriver AzureWebJobsStorage du och väljer OK.
I Fjärr klistrar du in anslutningssträngen från din lokala inställning och väljer OK.

Anslutningssträngen har nu angetts i din app i Azure.

Utlösa funktionen i Azure

Kontrollera att du inte kör lokalt. Stäng konsolfönstret om det fortfarande är öppet. Annars kan den lokala instansen vara den första som bearbetar alla kömeddelanden som du skapar.
På sidan Kö i Visual Studio lägger du till ett meddelande i kön som tidigare.
Uppdatera kösidan så försvinner det nya meddelandet eftersom det har bearbetats av funktionen som körs i Azure.

Aktivera Application Insights-loggning

När webbjobbet körs i Azure kan du inte övervaka funktionskörningen genom att visa konsolutdata. För att kunna övervaka ditt webbjobb bör du skapa en associerad Application Insights-instans när du publicerar projektet.

Skapa en Application Insights-instans

På sidan Publicera profil väljer du de tre punkterna ovanför Värd för att visa avsnittsåtgärder för värdprofil och väljer Öppna i Azure-portalen.
I webbappen under Inställningar väljer du Application Insights och sedan Aktivera Application Insights.
Kontrollera det genererade resursnamnet för instansen och platsen och välj Använd.
Under Inställningar väljer du Konfiguration och kontrollerar att en ny APPINSIGHTS_INSTRUMENTATIONKEY har skapats. Den här nyckeln används för att ansluta din WebJob-instans till Application Insights.

Om du vill dra nytta av Application Insights-loggning måste du även uppdatera loggningskoden.

Installera Application Insights-tillägget

Hämta den senaste stabila versionen av NuGet-paketet Microsoft.Azure.WebJobs.Logging.ApplicationInsights , version 3.x.
I följande kommando ersätter <3_X_VERSION> du med det aktuella versionsnumret som du hittade i steg 1. Varje typ av NuGet-paket har ett unikt versionsnummer.
```
Install-Package Microsoft.Azure.WebJobs.Logging.ApplicationInsights -Version <3_X_VERSION>
```
I Package Manager-konsolen kör du kommandot med det aktuella versionsnumret vid PM> startpunkten.

Initiera Application Insights-loggningsprovidern

Öppna Program.cs och lägg till följande initierare i ConfigureLogging efter-anropet till AddConsole:

// If the key exists in settings, use it to enable Application Insights.
string instrumentationKey = context.Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
if (!string.IsNullOrEmpty(instrumentationKey))
{
    b.AddApplicationInsightsWebJobs(o => o.InstrumentationKey = instrumentationKey);
}

Metodkoden Main bör nu se ut som i följande exempel:

static async Task Main()
{
    var builder = new HostBuilder();
    builder.UseEnvironment(EnvironmentName.Development);
    builder.ConfigureWebJobs(b =>
            {
                b.AddAzureStorageCoreServices();
                b.AddAzureStorage();
            });
    builder.ConfigureLogging((context, b) =>
            {
                b.AddConsole();

                // If the key exists in settings, use it to enable Application Insights.
                string instrumentationKey = context.Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
                if (!string.IsNullOrEmpty(instrumentationKey))
                {
                    b.AddApplicationInsightsWebJobs(o => o.InstrumentationKey = instrumentationKey);
                }
            });
    var host = builder.Build();
    using (host)
    {
        await host.RunAsync();
    }
}

Detta initierar Application Insights-loggningsprovidern med standardfiltrering. När du kör lokalt skrivs alla informationsloggar och loggar på högre nivå till både konsolen och Application Insights.

Publicera om projektet och utlös funktionen igen

I Solution Explorer högerklickar du på projektet och väljer Publicera.
Som tidigare använder du Azure Portal för att skapa ett kömeddelande som du gjorde tidigare, förutom att ange Hello App Insights! som meddelandetext.
På sidan Publicera profil väljer du de tre punkterna ovanför Värd för att visa avsnittsåtgärder för värdprofil och väljer Öppna i Azure-portalen.
I webbappen under Inställningar väljer du Application Insights och sedan Visa Application Insights-data.
Välj Sök och välj sedan Visa alla data under de senaste 24 timmarna.
Om du inte ser Hello App Insights! -meddelandet väljer du Uppdatera regelbundet i flera minuter. Loggar visas inte omedelbart eftersom det tar en stund för Application Insights-klienten att tömma loggarna som den bearbetar.

Lägga till indata-/utdatabindningar

Bindningar förenklar kod som läser och skriver data. Indatabindningar förenklar kod som läser data. Utdatabindningar förenklar kod som skriver data.

Lägga till bindningar

Indatabindningar förenklar kod som läser data. I det här exemplet är kömeddelandet namnet på en blob som du använder för att hitta och läsa en blob i Azure Storage. Sedan använder du utdatabindningar för att skriva en kopia av filen till samma container.

I Functions.cs lägger du till en using:
```
using System.IO;
```

Ersätt metoden ProcessQueueMessage med följande kod:

public static void ProcessQueueMessage(
    [QueueTrigger("queue")] string message,
    [Blob("container/{queueTrigger}", FileAccess.Read)] Stream myBlob,
    [Blob("container/copy-{queueTrigger}", FileAccess.Write)] Stream outputBlob,
    ILogger logger)
{
    logger.LogInformation($"Blob name:{message} \n Size: {myBlob.Length} bytes");
    myBlob.CopyTo(outputBlob);
}

I den här koden queueTrigger är ett bindningsuttryck, vilket innebär att det matchar ett annat värde vid körning. Vid körning har den innehållet i kömeddelandet.

Den här koden använder utdatabindningar för att skapa en kopia av filen som identifieras av kömeddelandet. Filkopian är prefixet copy-.

I Program.cs i ConfigureWebJobs tilläggsmetoden lägger du till AddAzureStorageBlobs metoden på instansen HostBuilder (före Build kommandot) för att initiera lagringstillägget. ConfigureWebJobs Nu ser metoden ut så här:
```
builder.ConfigureWebJobs(b =>
{
    b.AddAzureStorageCoreServices();
    b.AddAzureStorageQueues();
    b.AddAzureStorageBlobs();
});
```
Skapa en blobcontainer i ditt lagringskonto.

a. I Azure Portal går du till fliken Containrar under Datalagring och väljer + Container

b. I dialogrutan Ny container anger du containern som containernamn och väljer sedan Skapa.
Ladda upp filen Program.cs till blobcontainern. (Den här filen används här som ett exempel. Du kan ladda upp valfri textfil och skapa ett kömeddelande med filens namn.)

a. Välj den nya containern som du skapade

b. Välj knappen Ladda upp.

c. Leta upp och välj Program.cs och välj sedan OK.

Publicera om projektet

I Solution Explorer högerklickar du på projektet och väljer Publicera.
I dialogrutan Publicera kontrollerar du att den aktuella profilen är markerad och väljer sedan Publicera. Resultatet av publiceringen beskrivs i fönstret Utdata .
Skapa ett kömeddelande i kön som du skapade tidigare, med Program.cs som text i meddelandet.
En kopia av filen , copy-Program.cs, visas i blobcontainern.

Nästa steg

Den här självstudien visade hur du skapar, kör och distribuerar ett WebJobs SDK 3.x-projekt.

Läs mer om WebJobs SDK