Esercitazione: Attivare Funzioni di Azure in contenitori BLOB usando una sottoscrizione di eventi

Articolo
11/12/2024

Le versioni precedenti del trigger di Archiviazione BLOB di Funzioni di Azure eseguano il polling del contenitore di archiviazione per le modifiche. La versione più recente dell'estensione di archiviazione BLOB (5.x+) usa invece una sottoscrizione di eventi di Griglia di eventi nel contenitore. Questa sottoscrizione di eventi riduce la latenza attivando immediatamente la funzione quando si verificano modifiche nel contenitore sottoscritto.

Questo articolo illustra come creare una funzione eseguita in base agli eventi generati quando un BLOB viene aggiunto a un contenitore. Si usa Visual Studio Code per lo sviluppo locale e per convalidare il codice prima di distribuire il progetto in Azure.

Creare una funzione attivata da Archiviazione BLOB basata su eventi in un nuovo progetto.
Convalidare localmente in Visual Studio Code usando l'emulatore Azurite.
Creare un contenitore di archiviazione BLOB in un nuovo account di archiviazione in Azure.
Creare un'app per le funzioni nel piano Flex Consumption.
Creare una sottoscrizione di eventi al nuovo contenitore BLOB.
Distribuire e convalidare il codice della funzione in Azure.

Questo articolo supporta la versione 4 del modello di programmazione Node.js per Funzioni di Azure.

Questo articolo supporta la versione 2 del modello di programmazione Python per Funzioni di Azure.

Questo articolo crea un'app C# eseguita in modalità di lavoro isolata, che supporta .NET 8.0.

Suggerimento

Questa esercitazione illustra come creare un'app che viene eseguita nel piano Flex Consumption. Il piano A consumo flessibile supporta solo la versione basata su eventi del trigger di archiviazione BLOB.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
.NET 8.0 SDK.
Visual Studio Code in una delle piattaforme supportate.
Estensione C# per Visual Studio Code.
Estensione Funzioni di Azure per Visual Studio Code.

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Node.js 14.x o versione successiva. Usare il comando node --version per controllare la versione in uso.
Visual Studio Code in una delle piattaforme supportate.
Estensione Funzioni di Azure per Visual Studio Code. Questa estensione installa Azure Functions Core Tools la prima volta che si eseguono le funzioni in locale.

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
PowerShell 7.2
Runtime di .NET 6.0
Visual Studio Code in una delle piattaforme supportate.
Estensione PowerShell per Visual Studio Code.
Estensione Funzioni di Azure per Visual Studio Code.

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Versioni di Python supportate da Funzioni di Azure. Per altre informazioni, vedere la Procedura per installare Python.
Visual Studio Code in una delle piattaforme supportate.
Estensione Python per Visual Studio Code.
Estensione Funzioni di Azure per Visual Studio Code.

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Java Development Kit, versione 8, 11, 17 o 21(Linux).
Apache Maven, versione 3.0 o successiva.
Visual Studio Code in una delle piattaforme supportate.
Java Extension Pack
Estensione Funzioni di Azure per Visual Studio Code.

Estensione Archiviazione di Azure per Visual Studio Code.

Nota

L'estensione Archiviazione di Azure per Visual Studio Code è attualmente in anteprima.

Creare una funzione attivata dal BLOB

Quando si crea una funzione trigger di archiviazione BLOB usando Visual Studio Code, si crea anche un nuovo progetto. È necessario modificare la funzione per utilizzare una sottoscrizione di eventi come origine, anziché usare il normale contenitore sottoposto a polling.

In Visual Studio Code premere F1 per aprire il riquadro comandi, immettere Azure Functions: Create Function...e selezionare Crea nuovo progetto.

Per l'area di lavoro del progetto selezionare un percorso della directory. Assicurarsi di creare una nuova cartella o scegliere una cartella vuota per l'area di lavoro del progetto.

Non scegliere una cartella di progetto che fa già parte di un'area di lavoro.

Quando richiesto, immettere le informazioni seguenti:

Richiesta	Azione
Selezionare una lingua	Selezionare `C#`.
Selezionare un runtime .NET	Selezionare `.NET 8.0 Isolated LTS`.
Selezionare un modello per la prima funzione del progetto	Selezionare `Azure Blob Storage trigger (using Event Grid)`.
Specificare un nome di funzione	Immetti `EventGridBlobTrigger`.
Specificare uno spazio dei nomi	Immetti `My.Functions`.
Selezionare l'impostazione da "local.settings.json"	Selezionare `Create new local app setting`.
Selezionare la sottoscrizione	Selezionare la sottoscrizione, se necessario.
Selezionare un account di archiviazione	Usare l'emulatore Azurite per l'archiviazione locale.
Percorso all'interno dell'account di archiviazione che il trigger monitorerà	Accettare il valore predefinito `samples-workitems`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Richiesta	Azione
Selezionare una lingua	Selezionare `Python`.
Selezionare un modello di programmazione Python	Selezionare `Model V2`
Selezionare l'interprete Python per creare un ambiente virtuale	Selezionare l'interprete Python preferito. Se un'opzione non viene visualizzata, inserire il percorso completo del file binario di Python.
Selezionare un modello per la prima funzione del progetto	Selezionare `Blob trigger`. Il modello basato su eventi non è ancora disponibile.
Specificare un nome di funzione	Immetti `EventGridBlobTrigger`.
Percorso all'interno dell'account di archiviazione che il trigger monitorerà	Accettare il valore predefinito `samples-workitems`.
Selezionare l'impostazione da "local.settings.json"	Selezionare `Create new local app setting`.
Selezionare la sottoscrizione	Selezionare la sottoscrizione, se necessario.
Selezionare un account di archiviazione	Usare l'emulatore Azurite per l'archiviazione locale.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Richiesta	Azione
Selezionare una lingua	Selezionare `Java`.
Selezionare una versione di Java	Selezionare `Java 11` o `Java 8`, la versione Java in cui vengono eseguite le funzioni in Azure e che sono state verificate in locale.
Specificare un ID gruppo	Selezionare `com.function`.
Specificare un ID artefatto	Selezionare `EventGridBlobTrigger` (o il valore predefinito).
Specificare una versione	Selezionare `1.0-SNAPSHOT`.
Specificare un nome di pacchetto	Selezionare `com.function`.
Specificare un nome di app	Accettare il nome generato a partire da `EventGridBlobTrigger`.
Selezionare lo strumento di compilazione per il progetto Java	Selezionare `Maven`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Viene creata automaticamente una funzione attivata da HTTP (HttpExample). Questa funzione non verrà usata e dovrà invece creare una nuova funzione.

Richiesta	Azione
Selezionare un linguaggio per il progetto di funzione	Selezionare `TypeScript`.
Selezionare un modello di programmazione TypeScript	Selezionare `Model V4`.
Selezionare un modello per la prima funzione del progetto	Selezionare `Azure Blob Storage trigger (using Event Grid)`.
Specificare un nome di funzione	Immetti `EventGridBlobTrigger`.
Selezionare l'impostazione da "local.settings.json"	Selezionare `Create new local app setting`.
Selezionare la sottoscrizione	Selezionare la sottoscrizione, se necessario.
Selezionare un account di archiviazione	Usare l'emulatore Azurite per l'archiviazione locale.
Percorso all'interno dell'account di archiviazione che il trigger monitorerà	Accettare il valore predefinito `samples-workitems`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Richiesta	Azione
Selezionare un linguaggio per il progetto di funzione	Selezionare `JavaScript`.
Selezionare un modello di programmazione JavaScript	Selezionare `Model V4`.
Selezionare un modello per la prima funzione del progetto	Selezionare `Azure Blob Storage trigger (using Event Grid)`.
Specificare un nome di funzione	Immetti `eventGridBlobTrigger`.
Selezionare l'impostazione da "local.settings.json"	Selezionare `Create new local app setting`.
Selezionare la sottoscrizione	Selezionare la sottoscrizione, se necessario.
Selezionare un account di archiviazione	Usare l'emulatore Azurite per l'archiviazione locale.
Percorso all'interno dell'account di archiviazione che il trigger monitorerà	Accettare il valore predefinito `samples-workitems`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Richiesta	Azione
Selezionare un linguaggio per il progetto di funzione	Selezionare `PowerShell`.
Selezionare un modello per la prima funzione del progetto	Selezionare `Azure Blob Storage trigger (using Event Grid)`.
Specificare un nome di funzione	Immetti `EventGridBlobTrigger`.
Selezionare l'impostazione da "local.settings.json"	Selezionare `Create new local app setting`.
Selezionare la sottoscrizione	Selezionare la sottoscrizione, se necessario.
Selezionare un account di archiviazione	Usare l'emulatore Azurite per l'archiviazione locale.
Percorso all'interno dell'account di archiviazione che il trigger monitorerà	Accettare il valore predefinito `samples-workitems`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Nel riquadro comandi immettere Azure Functions: Create Function... e selezionare EventGridBlobTrigger. Se questo modello non viene visualizzato, selezionare Prima di tutto Cambia filtro>modello.

Ai prompt, immettere le informazioni seguenti:

Richiesta	Azione
Specificare un nome di pacchetto	Selezionare `com.function`.
Specificare un nome di funzione	Immetti `EventGridBlobTrigger`.
Selezionare l'impostazione da "local.settings.json"	Selezionare `Create new local app setting`.
Selezionare la sottoscrizione	Selezionare la propria sottoscrizione.
Selezionare un account di archiviazione	Usare l'emulatore Azurite per l'archiviazione locale.
Percorso all'interno dell'account di archiviazione che il trigger monitorerà	Accettare il valore predefinito `samples-workitems`.

È ora disponibile una funzione che può essere attivata dagli eventi in un contenitore di archiviazione BLOB.

Aggiornare l'origine del trigger

È prima necessario cambiare l'origine del trigger dall'origine trigger BLOB predefinita (polling del contenitore) a un'origine della sottoscrizione di eventi.

Aprire il file di progetto function_app.py e viene visualizzata una definizione per la EventGridBlobTrigger funzione con l'elemento blob_trigger Decorator applicato.

Aggiornare l'elemento Decorator aggiungendo source = "EventGrid". La funzione dovrebbe ora avere un aspetto simile al seguente:

@app.blob_trigger(arg_name="myblob", source="EventGrid", path="samples-workitems",
                           connection="<STORAGE_ACCOUNT>") 
def EventGridBlobTrigger(myblob: func.InputStream):
logging.info(f"Python blob trigger function processed blob"
            f"Name: {myblob.name}"
            f"Blob Size: {myblob.length} bytes")

In questa definizione source = "EventGrid" indica che una sottoscrizione di eventi al samples-workitems contenitore BLOB viene usata come origine dell'evento che avvia il trigger.

(Facoltativo) Esaminare il codice

Aprire il file generato EventGridBlobTrigger.cs e viene visualizzata una definizione per una EventGridBlobTrigger funzione simile alla seguente:

[Function(nameof(EventGridBlobTriggerCSharp))]
public async Task Run([BlobTrigger("PathValue/{name}", Source = BlobTriggerSource.EventGrid, Connection = "ConnectionValue")] Stream stream, string name)
{
    using var blobStreamReader = new StreamReader(stream);
    var content = await blobStreamReader.ReadToEndAsync();
    _logger.LogInformation($"C# Blob Trigger (using Event Grid) processed blob\n Name: {name} \n Data: {content}");
}

In questa definizione Source = BlobTriggerSource.EventGrid indica che una sottoscrizione di eventi al contenitore BLOB (nell'esempio PathValue) viene usata come origine dell'evento che avvia il trigger.

Aprire il file generato EventGridBlobTrigger.java e viene visualizzata una definizione per una EventGridBlobTrigger funzione simile alla seguente:

    @FunctionName("EventGridBlobTrigger")
    @StorageAccount("<STORAGE_ACCOUNT>")
    public void run(
        @BlobTrigger(name = "content", source = "EventGrid", path = "samples-workitems/{name}", dataType = "binary") byte[] content,
        @BindingName("name") String name,
        final ExecutionContext context
    ) {
        context.getLogger().info("Java Blob trigger function processed a blob. Name: " + name + "\n  Size: " + content.length + " Bytes");
    }

In questa definizione source = EventGrid indica che una sottoscrizione di eventi al samples-workitems contenitore BLOB viene usata come origine dell'evento che avvia il trigger.

EventGridBlobTrigger Nella cartella aprire il function.json file e trovare una definizione di associazione simile alla seguente con una type di blobTrigger e una source di EventGrid:

{
    "bindings": [
        {
            "name": "InputBlob",
            "type": "blobTrigger",
            "direction": "in",
            "path": "samples-workitems/{name}",
            "source": "EventGrid",
            "connection":""
        }
    ]
}

Indica path che il samples-workitems contenitore BLOB viene usato come origine dell'evento che avvia il trigger.

Aprire il file generato EventGridBlobTrigger.js e viene visualizzata una definizione per una funzione simile alla seguente:

const { app } = require('@azure/functions');

app.storageBlob('storageBlobTrigger1', {
    path: 'samples-workitems/{name}',
    connection: 'MyStorageAccountAppSetting',
    source: 'EventGrid',
    handler: (blob, context) => {
        context.log(
            `Storage blob function processed blob "${context.triggerMetadata.name}" with size ${blob.length} bytes`
        );
    },
});

In questa definizione, un source valore di EventGrid indica che una sottoscrizione di eventi al samples-workitems contenitore BLOB viene usata come origine dell'evento che avvia il trigger.

Aprire il file generato EventGridBlobTrigger.ts e viene visualizzata una definizione per una funzione simile alla seguente:

import { app, InvocationContext } from '@azure/functions';

export async function storageBlobTrigger1(blob: Buffer, context: InvocationContext): Promise<void> {
    context.log(
        `Storage blob function processed blob "${context.triggerMetadata.name}" with size ${blob.length} bytes`
    );
}

app.storageBlob('storageBlobTrigger1', {
    path: 'samples-workitems/{name}',
    connection: 'MyStorageAccountAppSetting',
    source: 'EventGrid',
    handler: storageBlobTrigger1,
});

In questa definizione, un source valore di EventGrid indica che una sottoscrizione di eventi al samples-workitems contenitore BLOB viene usata come origine dell'evento che avvia il trigger.

Aggiornare l'estensione di archiviazione

Per usare il trigger di archiviazione BLOB basato su Griglia di eventi, è necessario avere almeno la versione 5.x dell'estensione Archiviazione funzioni di Azure.

Per aggiornare il progetto con la versione dell'estensione richiesta, nella finestra Terminale eseguire questo comando dotnet add package:

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs

Aprire il file di progetto host.json ed esaminare l'elemento extensionBundle.

Se extensionBundle.version non è almeno 3.3.0 , sostituire l'elemento extensionBundle con questa versione:

"extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.0.0, 5.0.0)"
}

Preparare l'emulazione dell'archiviazione locale

Visual Studio Code usa Azurite per emulare i servizi di Archiviazione di Azure durante l'esecuzione in locale. Si usa Azurite per emulare il servizio archiviazione BLOB di Azure durante lo sviluppo e il test locali.

Se non è già stato fatto, installare l'estensione Azurite v3 per Visual Studio Code.
Verificare che il file local.settings.json abbia "UseDevelopmentStorage=true" impostato per AzureWebJobsStorage, che indica a Core Tools di usare Azurite invece di una connessione dell'account di archiviazione reale durante l'esecuzione in locale.
Premere F1 per aprire il riquadro comandi, digitare Azurite: Start Blob Service e premere INVIO, che avvia l'emulatore del servizio di archiviazione BLOB di Azure.
Selezionare l'icona di Azure nella barra delle attività, espandere Area di lavoro>Account di archiviazione collegati>Emulatore locale, fare clic con il pulsante destro del mouse su Contenitori BLOB, selezionare Crea contenitore BLOB...,immettere il nome samples-workitems e premere Invio.
Espandere Contenitori BLOB>samples-workitems e selezionare Carica file....
Scegliere un file da caricare nel contenitore emulato in locale. Questo file viene elaborato in un secondo momento dalla funzione per verificare ed eseguire il debug del codice della funzione. Un file di testo potrebbe funzionare meglio con il codice del modello di trigger BLOB.

Eseguire la funzione in locale

Con un file nell'archiviazione emulata, è possibile eseguire la funzione per simulare un evento generato da una sottoscrizione di Griglia di eventi. Le informazioni sull'evento passate al trigger dipendono dal file aggiunto al contenitore locale.

Impostare eventuali punti di interruzione e premere F5 per avviare il progetto per il debug locale. Gli strumenti di base di Funzioni di Azure devono essere in esecuzione nella finestra del terminale.
Nell'area di Azure espandere Area di lavoro>Progetto locale>Funzioni, fare clic con il pulsante destro del mouse sulla funzione e selezionare Esegui funzione ora.....
Nella finestra di dialogo corpo della richiesta digitare samples-workitems/<TEST_FILE_NAME>, sostituendo <TEST_FILE_NAME> con il nome del file caricato nell'emulatore di archiviazione locale.
Premere INVIO per eseguire la funzione. Il valore specificato è il percorso del BLOB nell'emulatore locale. Questa stringa viene passata al trigger nel payload della richiesta, che simula il payload quando una sottoscrizione di eventi chiama la funzione per segnalare l'aggiunta di un BLOB al contenitore.
Esaminare l'output di questa esecuzione della funzione. Nell'output verrà visualizzato il nome del file e il relativo contenuto registrati. Se si impostano punti di interruzione, potrebbe essere necessario continuare l'esecuzione.

Dopo aver convalidato correttamente il codice della funzione in locale, è possibile pubblicare il progetto in una nuova app per le funzioni in Azure.

Preparare l'account di archiviazione di Azure

Le sottoscrizioni di eventi ad Archiviazione di Azure richiedono un account di archiviazione per utilizzo generico v2. È possibile usare l'estensione Archiviazione di Azure per Visual Studio Code per creare questo account di archiviazione.

In Visual Studio Code premere nuovamente F1 per aprire il riquadro comandi e digitare Azure Storage: Create Storage Account.... Specificare queste informazioni quando richiesto:

Richiesta	Azione
Immettere il nome del nuovo account di archiviazione	Specificare un nome globalmente univoco. I nomi degli account di archiviazione devono contenere da 3 a 24 caratteri con solo lettere minuscole e numeri. Per semplificare l'identificazione, viene usato lo stesso nome per il gruppo di risorse e il nome dell'app per le funzioni.
Selezionare una località per le nuove risorse	per prestazioni ottimali, scegliere un'area vicina.

L'estensione crea un account di archiviazione per utilizzo generico v2 con il nome specificato. Lo stesso nome viene usato anche per il gruppo di risorse che contiene l'account di archiviazione. Il trigger di archiviazione BLOB basato su Griglia di eventi richiede un account di archiviazione per utilizzo generico v2.

Premere di nuovo F1 e nel riquadro comandi immettere Azure Storage: Create Blob Container.... Specificare queste informazioni quando richiesto:

Richiesta	Azione
Selezionare una risorsa	Selezionare l'account di archiviazione per utilizzo generico v2 creato.
Immettere un nome per il nuovo contenitore BLOB	Immettere `samples-workitems`, ovvero il nome del contenitore a cui si fa riferimento nel progetto di codice.

Per eseguire l'app per le funzioni è necessario anche un account di archiviazione. Per semplicità, questa esercitazione usa lo stesso account di archiviazione per il trigger BLOB e l'app per le funzioni. Nell'ambiente di produzione, tuttavia, potrebbe essere necessario usare un account di archiviazione separato con l'app per le funzioni. Per altre informazioni, vedere Considerazioni sull'archiviazione per Funzioni di Azure.

Creare l'app per le funzioni

Usare questi passaggi per creare un'app per le funzioni nel piano A consumo flessibile. Quando l'app è ospitata in un piano A consumo flessibile, i trigger di archiviazione BLOB devono usare sottoscrizioni di eventi.

Nel riquadro comandi immettere Funzioni di Azure: Creare un'app in Azure... (Avanzate).

Seguendo le istruzioni, specificare queste informazioni:

Richiesta	Selezione
Immettere un nome univoco a livello globale per la nuova app per le funzioni.	Digitare un nome univoco globale che identifichi la nuova app per le funzioni e quindi selezionare INVIO. I caratteri validi per un nome di app per le funzioni sono `a-z`, `0-9` e `-`.
Selezionare un piano di hosting.	Scegliere Flex Consumption (Consumo flessibile).
Selezionare uno stack di runtime.	Scegliere la versione e lo stack della lingua in cui è stato eseguito localmente.
Selezionare un gruppo di risorse per le nuove risorse.	Scegliere il gruppo di risorse esistente in cui è stato creato l'account di archiviazione.
Selezionare una località per le nuove risorse.	Selezionare una località in un'area supportata nelle vicinanze o nelle vicinanze di altri servizi a cui accedono le funzioni. Le aree non supportate non vengono visualizzate. Per altre informazioni, vedere Visualizzare le aree attualmente supportate.
Selezionare un account di archiviazione.	Scegliere il nome dell'account di archiviazione creato.
Selezionare una risorsa di Application Insights per l'app.	Scegliere Crea nuova risorsa di Application Insights e al prompt specificare il nome dell'istanza usata per archiviare i dati di runtime dalle funzioni.

Una notifica viene visualizzata dopo la creazione dell'app per le funzioni. Selezionare Visualizza output nelle notifiche per visualizzare i risultati della creazione, incluse le risorse di Azure create.

Distribuire il codice di funzione

Importante

La distribuzione in un'app per le funzioni esistente sovrascrive sempre il contenuto di tale app in Azure.

Nel riquadro comandi immettere quindi selezionare Funzioni di Azure: Distribuisci nell'app per le funzioni.
Selezionare l'app per le funzioni appena creata. Quando viene richiesto di sovrascrivere le distribuzioni precedenti, selezionare Distribuisci per distribuire il codice della funzione nella nuova risorsa dell'app per le funzioni.
Al termine della distribuzione, selezionare Visualizza output per visualizzare i risultati della creazione e della distribuzione, incluse le risorse di Azure create. Se non si riesce a visualizzare la notifica, selezionare l'icona della campana nell'angolo in basso a destra per visualizzarla di nuovo.

Aggiornare le impostazioni dell'applicazione

Poiché le impostazioni dell'applicazione necessarie dal file local.settings.json non vengono pubblicate automaticamente, è necessario caricarle nell'app per le funzioni in modo che la funzione venga eseguita correttamente in Azure.

Nel riquadro comandi immettere Azure Functions: Download Remote Settings... e nel prompt Selezionare una risorsa scegliere il nome dell'app per le funzioni.
Quando viene richiesto che l'impostazione AzureWebJobsStorage esista già, selezionare Sì per sovrascrivere l'impostazione dell'emulatore locale con la stringa di connessione effettiva dell'account di archiviazione da Azure.
Nel file local.settings.json sostituire l'impostazione dell'emulatore locale con la stessa stringa di connessione usata per AzureWebJobsStorage.
Rimuovere la voce FUNCTIONS_WORKER_RUNTIME, che non è supportata in un piano A consumo flessibile.
Nel riquadro comandi immettere Azure Functions: Upload Local Settings... e nel prompt Selezionare una risorsa scegliere il nome dell'app per le funzioni.

Ora sia l'host funzioni che il trigger condividono lo stesso account di archiviazione.

Compilare l'URL dell'endpoint

Per creare una sottoscrizione di eventi, è necessario fornire a Griglia di eventi l'URL dell'endpoint specifico per segnalare gli eventi di archiviazione BLOB. Questo URL dell'estensione BLOB è costituito dalle seguenti parti:

In parte	Esempio
URL dell'app per le funzioni di base	`https://<FUNCTION_APP_NAME>.azurewebsites.net`
Percorso specifico del BLOB	`/runtime/webhooks/blobs`
Stringa di query della funzione	`?functionName=Host.Functions.<FUNCTION_NAME>`
Chiave di accesso dell'estensione BLOB	`&code=<BLOB_EXTENSION_KEY>`

La chiave di accesso all'estensione BLOB è progettata per rendere più difficile per altri utenti accedere all'endpoint dell'estensione BLOB. Per determinare la chiave di accesso dell'estensione BLOB:

In Visual Studio Code scegliere l'icona di Azure nella barra delle attività. In Risorseespandere la sottoscrizione, espandere App per le funzioni, fare clic con il pulsante destro del mouse sull'app per le funzioni creata e selezionare Apri nel portale.
In Funzioni nel menu a sinistra selezionare Chiavi dell'app.
In Chiavi di sistema selezionare la chiave denominata blobs_extensione copiare la chiave Valore.

Questo valore viene incluso nella stringa di query del nuovo URL dell'endpoint.
Creare un nuovo URL dell'endpoint per il trigger di archiviazione BLOB in base all'esempio seguente:
```
https://<FUNCTION_APP_NAME>.azurewebsites.net/runtime/webhooks/blobs?functionName=Host.Functions.EventGridBlobTrigger&code=<BLOB_EXTENSION_KEY>
```
In questo esempio sostituire <FUNCTION_APP_NAME> con il nome dell'app per le funzioni e <BLOB_EXTENSION_KEY> con il valore ottenuto dal portale. Se è stato usato un nome diverso per la funzione, sostituire EventGridBlobTrigger con tale nome di funzione.

È ora possibile usare questo URL dell'endpoint per creare una sottoscrizione di eventi.

Creare la sottoscrizione di eventi

Una sottoscrizione di eventi, basata su Griglia di eventi di Azure, genera eventi in base alle modifiche nel contenitore BLOB sottoscritto. Questo evento viene quindi inviato all'endpoint dell'estensione BLOB per la funzione. Dopo aver creato una sottoscrizione di eventi, non è possibile aggiornare l'URL dell'endpoint.

In Visual Studio Code scegliere l'icona di Azure nella barra delle attività. In Risorseespandere la sottoscrizione, espandere Account di archiviazione, fare clic con il pulsante destro del mouse sull'account di archiviazione creato in precedenza e selezionare Apri nel portale.
Accedere al portale di Azure e prendere nota del gruppo di risorse per l'account di archiviazione. Le altre risorse vengono create nello stesso gruppo per semplificare la pulizia delle risorse al termine.
Selezionare l'opzione Eventi dal menu a sinistra.

Nella finestra Eventi selezionare il pulsante + Sottoscrizione di eventi e specificare i valori della tabella seguente nella scheda Basic:

Impostazione	Valore suggerito	Description
Nome	myBlobEventSub	Nome che identifica la sottoscrizione dell'evento. È possibile usare il nome per trovare rapidamente la sottoscrizione di eventi.
Schema di eventi	Schema griglia di eventi	Usare lo schema predefinito per gli eventi.
Nome dell'argomento del sistema	samples-workitems-blobs	Nome per l'argomento, che rappresenta il contenitore. L'argomento viene creato con la prima sottoscrizione e verrà usato per le sottoscrizioni di eventi future.
Filtra per tipi di evento	Blob created (BLOB creato)
Tipo di endpoint	Webhook	Il trigger di archiviazione BLOB usa un endpoint web hook.
Endpoint	Endpoint DELL'URL basato su Azure	Usare l'endpoint URL creato, che include il valore della chiave.

Selezionare Conferma selezione per convalidare l'URL dell'endpoint.

Selezionare la scheda Filtri e fornire le informazioni seguenti alle richieste:

Impostazione	Valore suggerito	Descrizione
Abilitare il filtro dell'oggetto	Abilitato	Abilita il filtro in base ai BLOB che possono attivare la funzione.
L'oggetto inizia con	`/blobServices/default/containers/<CONTAINER_NAME>/blobs/<BLOB_PREFIX>`	Sostituire `<CONTAINER_NAME` e `<BLOB_PREFIX>` con i valori scelti. Imposta la sottoscrizione in modo che venga attivata solo per i BLOB che iniziano con `BLOB_PREFIX` e si trovano nel `CONTAINER_NAME` contenitore.
Il soggetto termina con	.txt	Assicura che la funzione venga attivata solo dai BLOB che terminano con `.txt`.

Per altre informazioni sul filtro per BLOB specifici, vedere Filtro eventi per Hub eventi di Azure.

Selezionare Crea per creare la sottoscrizione di eventi.

Caricare un file nel contenitore

È possibile caricare un file dal computer nel contenitore di archiviazione BLOB usando Visual Studio Code.

In Visual Studio Code premere F1 per aprire il riquadro comandi e digitare Azure Storage: Upload Files....
Nella finestra di dialogo Apri scegliere un file, preferibilmente un file di testo e selezionare Carica.

Quando richiesto, immettere le informazioni seguenti:

Impostazione	Valore suggerito	Descrizione
Immettere la directory di destinazione del caricamento	impostazione predefinita	Accettare solo il valore predefinito di `/`, ovvero la radice del contenitore.
Selezionare una risorsa	Nome account di archiviazione	Scegliere il nome dell'account di archiviazione creato in un passaggio precedente.
Selezionare un tipo di risorsa	Contenitori BLOB	Si sta caricando in un contenitore BLOB.
Selezionare il contenitore BLOB	samples-workitems	Questo valore è il nome del contenitore creato in un passaggio precedente.

Esplorare il file system locale per trovare un file da caricare, quindi selezionare il pulsante Carica per caricare il file.

Verificare la funzione in Azure

Ora che è stato caricato un file nel contenitore samples-workitems, la funzione deve essere attivata. È possibile verificare controllando quanto segue nel portale di Azure:

Nell'account di archiviazione andare alla pagina Eventi e selezionare Sottoscrizioni a eventi; si dovrebbe vedere che è stato recapitato un evento. Potrebbe verificarsi un ritardo di cinque minuti per l'evento da visualizzare nel grafico.
Tornare alla pagina dell'app per le funzioni nel portale, in Funzioni trovare la funzione e selezionare Chiamate e altro ancora. Verranno visualizzate tracce scritte dall'esecuzione corretta della funzione.

Pulire le risorse

Per continuare con il passaggio successivo e aggiungere alla funzione un'associazione alla coda di Archiviazione di Azure, sarà necessario mantenere tutte le risorse esistenti per poterle riutilizzare.

In caso contrario, seguire questa procedura per eliminare l'app per le funzioni e le risorse correlate per evitare l'addebito di costi aggiuntivi.

In Visual Studio Code premere F1 per aprire il riquadro comandi. Nel riquadro comandi cercare e selezionare Azure: Open in portal.
Scegliere l'app per le funzioni e premere INVIO. La pagina dell'app per le funzioni viene aperta nel portale di Azure.
Nella scheda Panoramica selezionare il collegamento accanto a Gruppo di risorse.
Nella pagina Gruppo di risorse esaminare l'elenco delle risorse incluse e verificare che siano quelle da eliminare.
Selezionare Elimina gruppo di risorse e seguire le istruzioni.

L'eliminazione potrebbe richiedere alcuni minuti. Al termine, viene visualizzata una notifica per pochi secondi. È anche possibile selezionare l'icona a forma di campana nella parte superiore della pagina per visualizzare la notifica.

Per altre informazioni sui costi di Funzioni di Azure, vedere Stima dei costi del piano a consumo.

Condividi tramite