Share via

Eseguire una funzione di Azure in risposta a un evento di riattivazione BLOB

  • Articolo

Per leggere un BLOB incluso nel livello archivio, è prima necessario riattivare il BLOB nel livello ad accesso frequente o sporadico. Il completamento del processo di riattivazione può richiedere diverse ore. Invece di eseguire ripetutamente il polling dello stato dell'operazione di riattivazione, è possibile configurare Griglia di eventi di Azure per generare un evento al termine dell'operazione di riattivazione blob e gestire questo evento nell'applicazione.

Quando si verifica un evento, Griglia di eventi invia l'evento a un gestore eventi tramite un endpoint. Diversi servizi di Azure possono fungere da gestori eventi, tra cui Funzioni di Azure. Una funzione di Azure è un blocco di codice che può essere eseguito in risposta a un evento. Questa procedura illustra il processo di sviluppo di una funzione di Azure e quindi la configurazione di Griglia di eventi per eseguire la funzione in risposta a un evento che si verifica quando un BLOB viene riattivato.

Questo articolo illustra come creare e testare una funzione di Azure con .NET da Visual Studio. È possibile creare Funzioni di Azure da un'ampia gamma di ambienti di sviluppo locali e usare diversi linguaggi di programmazione. Per altre informazioni sulle lingue supportate per Funzioni di Azure, vedere Lingue supportate in Funzioni di Azure. Per altre informazioni sulle opzioni di sviluppo per Funzioni di Azure, vedere Codice e test Funzioni di Azure in locale.

Per altre informazioni sulla riattivazione dei BLOB dal livello archivio, vedere Panoramica della riattivazione dei BLOB dal livello archivio.

Prerequisiti

Questo articolo illustra come usare Visual Studio 2019 o versione successiva per sviluppare una funzione di Azure con .NET. È possibile installare gratuitamente Visual Studio Community. Assicurarsi di configurare Visual Studio per lo sviluppo di Azure con .NET.

Per eseguire il debug della funzione di Azure in locale, è necessario usare uno strumento in grado di inviare una richiesta HTTP, ad esempio Postman.

È necessaria una sottoscrizione di Azure. Se non si ha già un account, crearne uno gratuito prima di iniziare.

Creare un'app per le funzioni di Azure

Un'app per le funzioni è una risorsa di Azure che funge da contenitore per l'Funzioni di Azure. È possibile usare un'app per le funzioni nuova o esistente per completare i passaggi descritti in questo articolo.

Per creare una nuova app per le funzioni nella portale di Azure, seguire questa procedura:

  1. Nella portale di Azure cercare App per le funzioni. Selezionare l'icona app per le funzioni per passare all'elenco delle app per le funzioni nella sottoscrizione.

  2. Selezionare il pulsante Crea per creare una nuova app per le funzioni.

  3. Nella scheda Informazioni di base specificare un gruppo di risorse e specificare un nome univoco per la nuova app per le funzioni.

  4. Assicurarsi che l'opzione Pubblica sia impostata su Codice.

  5. Nell'elenco a discesa Stack di runtime selezionare .NET. Il campo Versione viene popolato automaticamente per usare la versione più recente di .NET Core.

  6. Selezionare l'area per la nuova app per le funzioni.

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

  7. Dopo aver completato la scheda Informazioni di base , passare alla scheda Hosting .

  8. Nella scheda Hosting selezionare l'account di archiviazione in cui verrà archiviata la funzione di Azure. È possibile scegliere un account di archiviazione esistente o crearne uno nuovo.

  9. Assicurarsi che il campo Sistema operativo sia impostato su Windows.

  10. Nel campo Tipo di piano selezionare Consumo (serverless). Per altre informazioni su questo piano, vedere Funzioni di Azure hosting del piano a consumo.

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

  11. Selezionare Rivedi e crea per creare la nuova app per le funzioni.

Per altre informazioni sulla configurazione dell'app per le funzioni, vedere Gestire l'app per le funzioni nella documentazione di Funzioni di Azure.

Creare una funzione di Azure come trigger di Griglia di eventi

Creare quindi una funzione di Azure che verrà eseguita quando un BLOB viene riattivato in un account di archiviazione specifico. Seguire questa procedura per creare una funzione di Azure in Visual Studio con C# e .NET Core:

  1. Avviare Visual Studio 2019 e creare un nuovo progetto Funzioni di Azure. Per informazioni dettagliate, seguire le istruzioni descritte in Creare un progetto di app per le funzioni.

  2. Nel passaggio Crea una nuova applicazione Funzioni di Azure selezionare i valori seguenti:

    • Per impostazione predefinita, il runtime di Funzioni di Azure è impostato su Funzioni di Azure v3 (.NET Core). Microsoft consiglia di usare questa versione del runtime di Funzioni di Azure.
    • Nell'elenco dei possibili trigger selezionare Trigger griglia di eventi. Per altre informazioni sul motivo per cui un trigger di Griglia di eventi è il tipo consigliato di trigger per la gestione di un evento blob Archiviazione con una funzione di Azure, vedere Usare una funzione come gestore eventi per gli eventi di Griglia di eventi.
    • L'impostazione dell'account Archiviazione indica dove verrà archiviata la funzione di Azure. È possibile selezionare un account di archiviazione esistente o crearne uno nuovo.

  3. Selezionare Crea per creare il nuovo progetto in Visual Studio.

  4. Rinominare quindi la classe e la funzione di Azure, come descritto in Rinominare la funzione. Scegliere un nome appropriato per lo scenario.

  5. In Visual Studio selezionare Strumenti | NuGet Gestione pacchetti | Gestione pacchetti Console e quindi installare i pacchetti seguenti dalla console:

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

  6. Nel file di classe per la funzione di Azure incollare le istruzioni using seguenti:

    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. Individuare il metodo Run nel file di classe. Questo è il metodo che viene eseguito quando si verifica un evento. Incollare il codice seguente nel corpo del metodo Run . È necessario ricordare di sostituire i valori segnaposto tra parentesi uncinate con i valori personalizzati:

    // 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;
    }
}

Per altre informazioni sullo sviluppo di Funzioni di Azure, vedere Linee guida per lo sviluppo di Funzioni di Azure.

Per altre informazioni sulle informazioni incluse quando un evento blob Archiviazione viene pubblicato in un gestore eventi, vedere Archiviazione BLOB di Azure come origine di Griglia di eventi.

Eseguire la funzione di Azure in locale nel debugger

Per testare il codice della funzione di Azure in locale, è necessario inviare manualmente una richiesta HTTP che attiva l'evento. È possibile pubblicare la richiesta usando uno strumento come Postman.

Nella parte superiore del file di classe per la funzione di Azure è un endpoint URL che è possibile usare per il test nell'ambiente locale. La registrazione della richiesta con questo URL attiva l'evento nell'ambiente locale in modo da poter eseguire il debug del codice. L'URL è nel formato seguente:

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

La richiesta inviata a questo endpoint è una richiesta simulata. Non invia o riceve dati dall'account Archiviazione di Azure.

Seguire questa procedura per costruire e inviare una richiesta a questo endpoint. Questo esempio illustra come inviare la richiesta con Postman.

  1. In Postman creare una nuova richiesta.

  2. Incollare l'URL mostrato sopra nel campo per l'URL della richiesta, sostituendo il nome della funzione per {functionname} e rimuovendo le parentesi graffe. Assicurarsi che il verbo della richiesta sia impostato su GET.

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

  3. Aggiungere l'intestazione Content-Type e impostarla su application/json.

  4. Aggiungere l'intestazione aeg-event-type e impostarla su Notifica.

    Screenshot showing header configuration for local request to trigger event

  5. In Postman specificare il corpo della richiesta, con il tipo di corpo impostato su JSON e il formato su raw. Nell'esempio seguente viene simulata una richiesta copy blob . Sostituire i valori segnaposto tra parentesi angolari con i propri valori. Si noti che non è necessario modificare i valori di data/ora o identificatore, perché si tratta di una richiesta simulata:

    [{
  "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. In Visual Studio posizionare i punti di interruzione desiderati nel codice e premere F5 per eseguire il debugger.

  7. In Postman selezionare il pulsante Invia per inviare la richiesta all'endpoint.

Quando si invia la richiesta, Griglia di eventi chiama la funzione di Azure ed è possibile eseguirne il debug normalmente. Per altre informazioni ed esempi, vedere Pubblicare manualmente la richiesta nella documentazione di Funzioni di Azure.

La richiesta che attiva l'evento viene simulata, ma la funzione di Azure che viene eseguita quando l'evento genera scrive informazioni di log in un nuovo BLOB nell'account di archiviazione. È possibile verificare il contenuto del BLOB e visualizzarne l'ora dell'ultima modifica nel portale di Azure, come illustrato nell'immagine seguente:

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

Pubblicare la funzione di Azure

Dopo aver testato la funzione di Azure in locale, il passaggio successivo consiste nel pubblicare la funzione di Azure nell'app per le funzioni di Azure creata in precedenza. La funzione deve essere pubblicata in modo da poter configurare Griglia di eventi per inviare eventi che si verificano nell'account di archiviazione all'endpoint della funzione.

Per pubblicare la funzione, seguire questa procedura:

  1. In Esplora soluzioni selezionare e tenere premuto (o fare clic con il pulsante destro del mouse) sul progetto Funzioni di Azure e scegliere Pubblica.

  2. Nella finestra Pubblica selezionare Azure come destinazione e quindi scegliere Avanti.

  3. Selezionare App per le funzioni di Azure (Windows) come destinazione specifica, quindi scegliere Avanti.

  4. Nella scheda Istanza di Funzioni selezionare la sottoscrizione dal menu a discesa, quindi individuare l'app per le funzioni di Azure nell'elenco delle app per le funzioni disponibili.

  5. Assicurarsi che la casella di controllo Esegui dal file del pacchetto sia selezionata.

  6. Selezionare Fine per preparare la pubblicazione della funzione.

  7. Nella pagina Pubblica verificare che la configurazione sia corretta. Se viene visualizzato un avviso che indica che la dipendenza del servizio in Application Insights non è configurata, è possibile configurarla da questa pagina.

  8. Selezionare il pulsante Pubblica per iniziare a pubblicare la funzione di Azure nell'app per le funzioni di Azure creata in precedenza.

    Screenshot showing page to publish Azure Function from Visual Studio

Ogni volta che si apportano modifiche al codice nella funzione di Azure, è necessario pubblicare la funzione aggiornata in Azure.

Sottoscrivere eventi di riattivazione BLOB da un account di archiviazione

È ora disponibile un'app per le funzioni che contiene una funzione di Azure che può essere eseguita in risposta a un evento. Il passaggio successivo consiste nel creare una sottoscrizione di eventi dall'account di archiviazione. La sottoscrizione di eventi configura l'account di archiviazione per pubblicare un evento tramite Griglia di eventi in risposta a un'operazione su un BLOB nell'account di archiviazione. Griglia di eventi invia quindi l'evento all'endpoint del gestore eventi specificato. In questo caso, il gestore eventi è la funzione di Azure creata nella sezione precedente.

Quando si crea la sottoscrizione di eventi, è possibile filtrare gli eventi inviati al gestore eventi. Gli eventi da acquisire durante la riattivazione di un BLOB dal livello archivio sono Microsoft.Archiviazione. BlobTierChanged, corrispondente a un'operazione Imposta livello BLOB e Microsoft.Archiviazione. Eventi BlobCreated, corrispondenti a un'operazione Copia BLOB. A seconda dello scenario, è possibile gestire solo uno di questi eventi.

Per creare la sottoscrizione di eventi, seguire questa procedura:

  1. Nella portale di Azure passare all'account di archiviazione che contiene BLOB da riattivare dal livello archivio.

  2. Selezionare l'impostazione Eventi nel riquadro di spostamento sinistro.

  3. Nella pagina Eventi selezionare Altre opzioni.

  4. Selezionare Crea sottoscrizione di eventi.

  5. Nella sezione Dettagli sottoscrizione eventi della pagina Crea sottoscrizione di eventi specificare un nome per la sottoscrizione di eventi.

  6. Nella sezione Dettagli argomento specificare un nome per l'argomento di sistema. L'argomento di sistema rappresenta uno o più eventi pubblicati da Archiviazione di Azure. Per altre informazioni sugli argomenti di sistema, vedere Argomenti di sistema in Griglia di eventi di Azure.

  7. Nella sezione Tipi di evento selezionare gli eventi Blob Created and Blob Tier Changed . A seconda di come si sceglie di riattivare un BLOB dal livello di archivio, verrà generato uno di questi due eventi.

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

  8. Nella sezione Dettagli endpoint selezionare Funzione di Azure dal menu a discesa.

  9. Scegliere Selezionare un endpoint per specificare la funzione creata nella sezione precedente. Nella finestra di dialogo Seleziona funzione di Azure scegliere la sottoscrizione, il gruppo di risorse e l'app per le funzioni per la funzione di Azure. Infine, selezionare il nome della funzione nell'elenco a discesa e scegliere Conferma selezione.

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

  10. Selezionare il pulsante Crea per creare la sottoscrizione di eventi e iniziare a inviare eventi al gestore eventi di Funzioni di Azure.

Per altre informazioni sulle sottoscrizioni di eventi, vedere Griglia di eventi di Azure concetti.

Testare il gestore eventi della funzione di Azure

Per testare la funzione di Azure, è possibile attivare un evento nell'account di archiviazione che contiene la sottoscrizione di eventi. La sottoscrizione di eventi creata in precedenza filtra due eventi, Microsoft.Archiviazione. BlobCreated e Microsoft.Archiviazione. BlobTierChanged. Quando viene generato uno di questi eventi, verrà attivata la funzione di Azure.

La funzione di Azure illustrata in questo articolo scrive in un BLOB di log in due scenari:

  • Quando l'evento è Microsoft.Archiviazione. BlobCreated e l'operazione API è Copy Blob.
  • Quando l'evento è Microsoft.Archiviazione. BlobTierChanged e l'operazione API è Imposta livello BLOB.

Per informazioni su come testare la funzione riattivando un BLOB, vedere una delle due procedure seguenti:

Al termine della riattivazione, il BLOB di log viene scritto nello stesso contenitore del BLOB riattivato. Ad esempio, dopo aver riattivato un BLOB con un'operazione di copia, è possibile vedere nel portale di Azure che il BLOB di origine originale rimane nel livello archivio, il BLOB di destinazione completamente riattivato viene visualizzato nel livello online di destinazione e il BLOB di log creato dalla funzione di Azure viene visualizzato anche nell'elenco.

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.

Tenere presente che la riattivazione di un BLOB può richiedere fino a 15 ore, a seconda dell'impostazione della priorità di riattivazione. Se si imposta la priorità di riattivazione su Alta, la riattivazione può essere completata in meno di un'ora per i BLOB con dimensioni inferiori a 10 GB. Tuttavia, una riattivazione ad alta priorità comporta un costo maggiore. Per altre informazioni, vedere Panoramica della riattivazione del BLOB dal livello archivio.

Suggerimento

Anche se l'obiettivo di questa procedura consiste nel gestire questi eventi nel contesto della riattivazione blob, a scopo di test può anche essere utile osservare questi eventi in risposta al caricamento di un BLOB o alla modifica del livello di un BLOB online (ad esempio, da accesso frequente ad accesso sporadico), perché l'evento viene generato immediatamente.

Per altre informazioni su come filtrare gli eventi in Griglia di eventi, vedere Come filtrare gli eventi per Griglia di eventi di Azure.

Vedi anche