Kör en Azure-funktion som svar på en blobåterställningshändelse

  • Artikel

Om du vill läsa en blob som finns på arkivnivån måste du först extrahera bloben till den frekventa eller lågfrekventa nivån. Rehydreringsprocessen kan ta flera timmar att slutföra. I stället för att upprepade gånger avsöka status för återfuktningsåtgärden kan du konfigurera Azure Event Grid för att utlösa en händelse när blobrehydreringsåtgärden är klar och hantera den här händelsen i ditt program.

När en händelse inträffar skickar Event Grid händelsen till en händelsehanterare via en slutpunkt. Ett antal Azure-tjänster kan fungera som händelsehanterare, inklusive Azure Functions. En Azure-funktion är ett kodblock som kan köras som svar på en händelse. Den här instruktioner vägleder dig genom processen att utveckla en Azure-funktion och konfigurerar sedan Event Grid för att köra funktionen som svar på en händelse som inträffar när en blob extraheras.

Den här artikeln visar hur du skapar och testar en Azure-funktion med .NET från Visual Studio. Du kan skapa Azure Functions från en mängd olika lokala utvecklingsmiljöer och använda en mängd olika programmeringsspråk. Mer information om språk som stöds för Azure Functions finns i Språk som stöds i Azure Functions. Mer information om utvecklingsalternativ för Azure Functions finns i Koda och testa Azure Functions lokalt.

Mer information om hur du extraherar blobar från arkivnivån finns i Översikt över blobrehydrering från arkivnivån.

Förutsättningar

Den här artikeln visar hur du använder Visual Studio 2019 eller senare för att utveckla en Azure-funktion med .NET. Du kan installera Visual Studio Community kostnadsfritt. Se till att du konfigurerar Visual Studio för Azure Development med .NET.

Om du vill felsöka Azure-funktionen lokalt måste du använda ett verktyg som kan skicka en HTTP-begäran, till exempel Postman.

En Azure-prenumeration krävs. Om du inte redan har ett konto skapar du ett kostnadsfritt innan du börjar.

Skapa en Azure Functions-app

En funktionsapp är en Azure-resurs som fungerar som en container för dina Azure Functions. Du kan använda en ny eller befintlig funktionsapp för att slutföra stegen som beskrivs i den här artikeln.

Följ dessa steg för att skapa en ny funktionsapp i Azure-portalen:

  1. Sök efter Funktionsapp i Azure-portalen. Välj ikonen Funktionsapp för att navigera till listan över funktionsappar i din prenumeration.

  2. Välj knappen Skapa för att skapa en ny funktionsapp.

  3. På fliken Grundläggande anger du en resursgrupp och anger ett unikt namn för den nya funktionsappen .

  4. Kontrollera att alternativet Publicera är inställt på Kod.

  5. I listrutan Körningsstack väljer du .NET. Fältet Version fylls i automatiskt för att använda den senaste versionen av .NET Core.

  6. Välj region för den nya funktionsappen.

    Screenshot showing how to create a new function app in Azure - Basics tab

  7. När du har slutfört fliken Grundläggande går du till fliken Värd .

  8. På fliken Värd väljer du det lagringskonto där din Azure-funktion ska lagras. Du kan välja ett befintligt lagringskonto eller skapa ett nytt.

  9. Kontrollera att fältet Operativsystem är inställt på Windows.

  10. I fältet Plantyp väljer du Förbrukning (serverlös). Mer information om den här planen finns i Värd för Azure Functions-förbrukningsplan.

    Screenshot showing how to create a new function app in Azure - Hosting tab

  11. Välj Granska + Skapa för att skapa den nya funktionsappen.

Mer information om hur du konfigurerar din funktionsapp finns i Hantera din funktionsapp i Azure Functions-dokumentationen.

Skapa en Azure-funktion som en Event Grid-utlösare

Skapa sedan en Azure-funktion som körs när en blob extraheras i ett visst lagringskonto. Följ de här stegen för att skapa en Azure-funktion i Visual Studio med C# och .NET Core:

  1. Starta Visual Studio 2019 och skapa ett nytt Azure Functions-projekt. Mer information finns i anvisningarna i Skapa ett funktionsappsprojekt.

  2. I steget Skapa ett nytt Azure Functions-program väljer du följande värden:

    • Som standard är Azure Functions-körningen inställd på Azure Functions v3 (.NET Core). Microsoft rekommenderar att du använder den här versionen av Azure Functions-körningen.
    • I listan över möjliga utlösare väljer du Event Grid-utlösare. Mer information om varför en Event Grid-utlösare är den rekommenderade typen av utlösare för hantering av en Blob Storage-händelse med en Azure-funktion finns i Använda en funktion som händelsehanterare för Event Grid-händelser.
    • Inställningen Lagringskonto anger var din Azure-funktion ska lagras. Du kan välja ett befintligt lagringskonto eller skapa ett nytt.

  3. Välj Skapa för att skapa det nya projektet i Visual Studio.

  4. Byt sedan namn på klassen och Azure Function enligt beskrivningen i Byt namn på funktionen. Välj ett namn som är lämpligt för ditt scenario.

  5. I Visual Studio väljer du Verktyg | NuGet Package Manager Package Manager | Console och installerar sedan följande paket från konsolen:

    Install-Package Azure.Storage.Blobs
Install-Package Microsoft.ApplicationInsights.WorkerService
Install-Package Microsoft.Azure.WebJobs.Logging.ApplicationInsights

  6. I klassfilen för din Azure-funktion klistrar du in följande med hjälp av -instruktioner:

    using System;
using System.IO;
using System.Text;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Extensions.Logging;
using Azure;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;

  7. Leta upp metoden Kör i klassfilen. Det här är den metod som körs när en händelse inträffar. Klistra in följande kod i brödtexten i run-metoden . Kom ihåg att ersätta platshållarvärden i vinkelparenteser med dina egna värden:

    // When either Microsoft.Storage.BlobCreated or Microsoft.Storage.BlobTierChanged
// event occurs, write the event details to a log blob in the same container
// as the event subject (the blob for which the event occurred).

// Create a unique name for the log blob.
string logBlobName = string.Format("function-log-{0}.txt", DateTime.UtcNow.Ticks);

// Populate connection string with your Shared Key credentials.
const string ConnectionString = "DefaultEndpointsProtocol=https;AccountName=<account-name>;AccountKey=<account-key>;EndpointSuffix=core.windows.net";

// Get data from the event.
dynamic data = eventGridEvent.Data;
string eventBlobUrl = Convert.ToString(data.url);
string eventApi = Convert.ToString(data.api);

// Build string containing log information.
StringBuilder eventInfo = new StringBuilder();
eventInfo.AppendLine(string.Format("{0} operation occurred.", eventApi));
eventInfo.AppendLine(string.Format("Blob URL: {0}", eventBlobUrl));
eventInfo.AppendLine($@"Additional event details:
    Id=[{eventGridEvent.Id}]
    EventType=[{eventGridEvent.EventType}]
    EventTime=[{eventGridEvent.EventTime}]
    Subject=[{eventGridEvent.Subject}]
    Topic=[{eventGridEvent.Topic}]");

// If event was BlobCreated and API call was CopyBlob, respond to the event.
bool copyBlobEventOccurred = (eventGridEvent.EventType == "Microsoft.Storage.BlobCreated") &&
                             (eventApi == "CopyBlob");

// If event was BlobTierChanged and API call was SetBlobTier, respond to the event.
bool setTierEventOccurred = (eventGridEvent.EventType == "Microsoft.Storage.BlobTierChanged") &&
                            (eventApi == "SetBlobTier");

// If one of these two events occurred, write event info to a log blob.
if (copyBlobEventOccurred | setTierEventOccurred)
{
    // Create log blob in same account and container.
    BlobUriBuilder logBlobUriBuilder = new BlobUriBuilder(new Uri(eventBlobUrl))
    {
        BlobName = logBlobName
    };

    BlobClient logBlobClient = new BlobClient(ConnectionString,
                                              logBlobUriBuilder.BlobContainerName,
                                              logBlobName);

    byte[] byteArray = Encoding.ASCII.GetBytes(eventInfo.ToString());

    try
    {
        // Write the log info to the blob.
        // Overwrite if the blob already exists.
        using (MemoryStream memoryStream = new MemoryStream(byteArray))
        {
            BlobContentInfo blobContentInfo =
                logBlobClient.Upload(memoryStream, overwrite: true);
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine(e.Message);
        throw;
    }
}

Mer information om hur du utvecklar Azure Functions finns i Vägledning för att utveckla Azure Functions.

Mer information om den information som ingår när en Blob Storage-händelse publiceras till en händelsehanterare finns i Azure Blob Storage som Event Grid-källa.

Kör Azure-funktionen lokalt i felsökningsprogrammet

Om du vill testa Din Azure-funktionskod lokalt måste du skicka en HTTP-begäran manuellt som utlöser händelsen. Du kan publicera begäran med hjälp av ett verktyg som Postman.

Högst upp i klassfilen för din Azure-funktion finns en URL-slutpunkt som du kan använda för testning i den lokala miljön. När du publicerar begäran med den här URL:en utlöses händelsen i den lokala miljön så att du kan felsöka koden. URL:en har följande format:

http://localhost:7071/runtime/webhooks/EventGrid?functionName={functionname}

Den begäran som du skickar till den här slutpunkten är en simulerad begäran. Den skickar eller tar inte emot data från ditt Azure Storage-konto.

Följ de här stegen för att skapa och skicka en begäran till den här slutpunkten. Det här exemplet visar hur du skickar begäran med Postman.

  1. Skapa en ny begäran i Postman.

  2. Klistra in url:en som visas ovan i fältet för begärande-URL:en, ersätt namnet på funktionen för {functionname} och ta bort klammerparenteserna. Kontrollera att begärandeverb är inställt på GET.

    Screenshot showing how to specify local URL for event trigger in Postman

  3. Lägg till rubriken Innehållstyp och ange den till application/json.

  4. Lägg till huvudet aeg-event-type och ställ in det på Meddelande.

    Screenshot showing header configuration for local request to trigger event

  5. I Postman anger du begärandetexten, med brödtexttypen inställd på JSON och formatet raw. I följande exempel simuleras en begäran om kopieringsblob. Ersätt platshållarvärden i vinkelparenteser med dina egna värden. Observera att det inte är nödvändigt att ändra värden för datum/tid eller identifierare, eftersom det här är en simulerad begäran:

    [{
  "topic": "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>",
  "subject": "/blobServices/default/containers/<container-name>/blobs/<blob-name>",
  "eventType": "Microsoft.Storage.BlobCreated",
  "id": "2bfb587b-501e-0094-2746-8b2884065d32",
  "data": {
    "api": "CopyBlob",
    "clientRequestId": "3d4dedc7-6c27-4816-9405-fdbfa806b00c",
    "requestId": "2bfb587b-501e-0094-2746-8b2884000000",
    "eTag": "0x8D9595DCA505BDF",
    "contentType": "text/plain",
    "contentLength": 48,
    "blobType": "BlockBlob",
    "url": "https://<storage-account>.blob.core.windows.net/<container-name>/<blob-name>",
    "sequencer": "0000000000000000000000000000201B00000000004092a5",
    "storageDiagnostics": {
      "batchId": "8a92736a-6006-0026-0046-8bd7f5000000"
    }
  },
  "dataVersion": "",
  "metadataVersion": "1",
  "eventTime": "2021-08-07T04:42:41.0730463Z"
}]

  6. I Visual Studio placerar du önskade brytpunkter i koden och trycker på F5 för att köra felsökningsprogrammet.

  7. I Postman väljer du knappen Skicka för att skicka begäran till slutpunkten.

När du skickar begäran anropar Event Grid din Azure-funktion och du kan felsöka den normalt. Mer information och exempel finns i Publicera begäran manuellt i Azure Functions-dokumentationen.

Begäran som utlöser händelsen simuleras, men Den Azure-funktion som körs när händelsen utlöses skriver logginformation till en ny blob i ditt lagringskonto. Du kan verifiera innehållet i bloben och visa dess senaste ändringstid i Azure-portalen, som du ser i följande bild:

Screenshot showing the contents of the log blob in the Azure portal

Publicera Azure-funktionen

När du har testat din Azure-funktion lokalt är nästa steg att publicera Azure-funktionen till azure-funktionsappen som du skapade tidigare. Funktionen måste publiceras så att du kan konfigurera Event Grid att skicka händelser som inträffar på lagringskontot till funktionsslutpunkten.

Följ dessa steg för att publicera funktionen:

  1. I Solution Explorer väljer du och håller ned (eller högerklickar på) ditt Azure Functions-projekt och väljer Publicera.

  2. I fönstret Publicera väljer du Azure som mål och sedan Nästa.

  3. Välj Azure Function App (Windows) som det specifika målet och välj sedan Nästa.

  4. På fliken Functions-instans väljer du din prenumeration på den nedrullningsbara menyn och letar sedan upp din Azure-funktionsapp i listan över tillgängliga funktionsappar.

  5. Kontrollera att kryssrutan Kör från paketfil är markerad.

  6. Välj Slutför för att förbereda för att publicera funktionen.

  7. På sidan Publicera kontrollerar du att konfigurationen är korrekt. Om du ser en varning om att tjänstberoendet till Application Insights inte har konfigurerats kan du konfigurera det från den här sidan.

  8. Välj knappen Publicera för att börja publicera Azure-funktionen till den Azure-funktionsapp som du skapade tidigare.

    Screenshot showing page to publish Azure Function from Visual Studio

När du gör ändringar i koden i din Azure-funktion måste du publicera den uppdaterade funktionen till Azure.

Prenumerera på blobrehydreringshändelser från ett lagringskonto

Nu har du en funktionsapp som innehåller en Azure-funktion som kan köras som svar på en händelse. Nästa steg är att skapa en händelseprenumeration från ditt lagringskonto. Händelseprenumerationen konfigurerar lagringskontot för att publicera en händelse via Event Grid som svar på en åtgärd på en blob i ditt lagringskonto. Event Grid skickar sedan händelsen till den händelsehanterarslutpunkt som du har angett. I det här fallet är händelsehanteraren den Azure-funktion som du skapade i föregående avsnitt.

När du skapar händelseprenumerationen kan du filtrera vilka händelser som skickas till händelsehanteraren. De händelser som ska avbildas när du extraherar en blob från arkivnivån är Microsoft.Storage.BlobTierChanged, som motsvarar en åtgärd för att ange blobnivå , och händelser i Microsoft.Storage.BlobCreated som motsvarar en kopieringsblobåtgärd . Beroende på ditt scenario kanske du bara vill hantera en av dessa händelser.

Följ dessa steg för att skapa händelseprenumerationen:

  1. I Azure-portalen går du till lagringskontot som innehåller blobar för att extrahera från arkivnivån.

  2. Välj inställningen Händelser i det vänstra navigeringsfönstret.

  3. På sidan Händelser väljer du Fler alternativ.

  4. Välj Skapa händelseprenumeration.

  5. På sidan Skapa händelseprenumeration i avsnittet Händelseprenumerationsinformation anger du ett namn för händelseprenumerationen.

  6. I avsnittet Ämnesinformation anger du ett namn för systemämnet. Systemavsnittet representerar en eller flera händelser som publiceras av Azure Storage. Mer information om systemämnen finns i Systemämnen i Azure Event Grid.

  7. I avsnittet Händelsetyper väljer du händelserna Blob Skapad och Ändrad blobnivå. Beroende på hur du väljer att extrahera en blob från arkivnivån utlöses en av dessa två händelser.

    Screenshot showing how to select event types for blob rehydration events in the Azure portal

  8. I avsnittet Slutpunktsinformation väljer du Azure-funktion på den nedrullningsbara menyn.

  9. Välj Välj en slutpunkt för att ange den funktion som du skapade i föregående avsnitt. I dialogrutan Välj Azure-funktion väljer du prenumeration, resursgrupp och funktionsapp för din Azure-funktion. Välj slutligen funktionsnamnet i listrutan och välj Bekräfta markeringen.

    Screenshot showing how to select an Azure Function as the endpoint for an Event Grid subscription

  10. Välj knappen Skapa för att skapa händelseprenumerationen och börja skicka händelser till Azure Function-händelsehanteraren.

Mer information om händelseprenumerationer finns i Begrepp för Azure Event Grid.

Testa händelsehanteraren för Azure Function

Om du vill testa Azure-funktionen kan du utlösa en händelse i lagringskontot som innehåller händelseprenumerationen. Händelseprenumerationen som du skapade tidigare filtrerar på två händelser, Microsoft.Storage.BlobCreated och Microsoft.Storage.BlobTierChanged. När någon av dessa händelser utlöses utlöses din Azure-funktion.

Azure-funktionen som visas i den här artikeln skriver till en loggblob i två scenarier:

  • När händelsen är Microsoft.Storage.BlobCreated och API-åtgärden är Kopiera blob.
  • När händelsen är Microsoft.Storage.BlobTierChanged och API-åtgärden är Ange blobnivå.

Information om hur du testar funktionen genom att extrahera en blob finns i någon av följande två procedurer:

När uttorkningen är klar skrivs loggbloben till samma container som den blob som du rehydrerade. När du till exempel har extraherat en blob med en kopieringsåtgärd kan du se i Azure-portalen att den ursprungliga källbloben finns kvar på arkivnivån, att den fullständigt uttorkade målbloben visas på onlinenivån och att loggbloben som skapades av Azure-funktionen också visas i listan.

Screenshot showing the original blob in the archive tier, the rehydrated blob in the hot tier, and the log blob written by the event handler.

Tänk på att det kan ta upp till 15 timmar att extrahera en blob, beroende på inställningen för rehydreringsprioritet. Om du ställer in rehydreringsprioriteten på Hög kan återfuktning slutföras på mindre än en timme för blobar som är mindre än 10 GB stora. En högprioriterad rehydrering medför dock en högre kostnad. Mer information finns i Översikt över blobrehydrering från arkivnivån.

Dricks

Även om målet med den här instruktioner är att hantera dessa händelser i samband med blob rehydrering, för testningsändamål kan det också vara bra att observera dessa händelser som svar på uppladdning av en blob eller ändra en online blob nivå (dvs. från frekvent till lågfrekvent), eftersom händelsen utlöses omedelbart.

Mer information om hur du filtrerar händelser i Event Grid finns i Filtrera händelser för Azure Event Grid.

Se även