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

Le versioni precedenti del trigger di Archiviazione BLOB di Funzioni di Azure eseguano il polling del contenitore di archiviazione per le modifiche. Le versioni più recenti dell'estensione Blob Storage (5.x+) utilizzano invece una sottoscrizione di eventi tramite Event Grid sul 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 A consumo flessibile.
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 Consumo Flessibile. 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 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.

Note

L'estensione Archiviazione di Azure per Visual Studio Code è disponibile 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.

Ai prompt, immettere le informazioni seguenti:

Prompt	Azione
Selezionare un linguaggio di programmazione	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	Immettere `EventGridBlobTrigger`.
Specificare uno spazio dei nomi	Immettere `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 nell'account di archiviazione che verrà monitorato dal trigger	Accettare il valore predefinito `samples-workitems`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Prompt	Azione
Selezionare un linguaggio di programmazione	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	Immettere `EventGridBlobTrigger`.
Percorso nell'account di archiviazione che verrà monitorato dal trigger	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`.

Prompt	Azione
Selezionare un linguaggio di programmazione	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.

Prompt	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	Immettere `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 nell'account di archiviazione che verrà monitorato dal trigger	Accettare il valore predefinito `samples-workitems`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Prompt	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	Immettere `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 nell'account di archiviazione che verrà monitorato dal trigger	Accettare il valore predefinito `samples-workitems`.
Selezionare come si vuole aprire il progetto	Selezionare `Open in current window`.

Prompt	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	Immettere `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 nell'account di archiviazione che verrà monitorato dal trigger	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 Filtro Cambia Modello>Tutti.

Ai prompt, immettere le informazioni seguenti:

Prompt	Azione
Specificare un nome di pacchetto	Selezionare `com.function`.
Specificare un nome di funzione	Immettere `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 nell'account di archiviazione che verrà monitorato dal trigger	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

È necessario modificare l'origine del trigger dall'origine predefinita del trigger Blob (polling del contenitore) a una fonte di sottoscrizione eventi.

Aprire il file di progetto function_app.py. Viene visualizzata una definizione per la funzione EventGridBlobTrigger con il decoratore blob_trigger 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")

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

(Facoltativo) Esaminare il codice

Aprire il file generato EventGridBlobTrigger.cs . 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}", name, content);
}

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

Aprire il file generato EventGridBlobTrigger.java . 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 è l'origine dell'evento che avvia il trigger.

Nella cartella EventGridBlobTrigger aprire il file function.json 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":""
        }
    ]
}

path indica che il contenitore BLOB samples-workitems è l'origine dell'evento che avvia il trigger.

Aprire il file generato EventGridBlobTrigger.js . 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 di EventGrid indica che una sottoscrizione di eventi al contenitore BLOB samples-workitems è l'origine dell'evento che avvia il trigger.

Aprire il file generato EventGridBlobTrigger.ts . 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 di EventGrid indica che una sottoscrizione di eventi al contenitore BLOB samples-workitems è l'origine dell'evento che avvia il trigger.

Aggiornare l'estensione di archiviazione

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

Per aggiornare il progetto alla versione dell'estensione richiesta, eseguire questo dotnet add package comando nella finestra Del terminale:

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

Aprire il file di host.json progetto 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. Usare 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 sia "UseDevelopmentStorage=true" impostato per AzureWebJobsStorage. Questa impostazione indica a Core Tools di usare Azurite invece di una connessione reale all'account di archiviazione durante l'esecuzione in locale.
Premere F1 per aprire il riquadro comandi, digitare Azurite: Start Blob Servicee premere INVIO. Questa azione avvia l'emulatore del servizio di archiviazione blob di Azurite.
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. La funzione elabora questo file in un secondo momento 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 F1 per aprire il riquadro comandi e immettere Azure Storage: Create Storage Account.... Specificare queste informazioni quando richiesto:

Prompt	Azione
Immettere il nome del nuovo account di archiviazione	Specificare un nome univoco globale. I nomi degli account di archiviazione devono contenere da 3 a 24 caratteri con solo lettere minuscole e numeri. Per semplificare l'identificazione, usare 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:

Prompt	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 si ospita l'app in un piano Flex Consumption, i trigger di Blob Storage devono usare sottoscrizioni di eventi.

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

Seguire le istruzioni e fornire queste informazioni:

Prompt	Selezione
Immettere un nome univoco 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), ovvero il piano di hosting consigliato per l'hosting serverless.
Selezionare una località per le nuove risorse	Selezionare una località in una regione vicino a te o vicino ad altri servizi a cui accedono le funzioni.
Selezionare uno stack di esecuzione	Selezionare la versione della lingua attualmente eseguita in locale.
Selezionare una dimensione dell'istanza	Selezionare 512. È sempre possibile modificare l'impostazione delle dimensioni dell'istanza impostando dimensioni maggiori in un secondo momento.
Immettere il numero massimo di istanze	Selezionare il valore predefinito 100, che limita la capacità totale di scalabilità dell'app. È anche possibile scegliere un valore diverso compreso tra 40 e 1.000.
Selezionare un gruppo di risorse	Selezionare Crea nuovo gruppo di risorse e accettare l'impostazione predefinita o immettere un altro nome per il nuovo gruppo univoco nella sottoscrizione.
Selezionare il tipo di autenticazione della risorsa	Selezionare Identità gestita in modo che l'app si connetta alle risorse remote usando l'autenticazione CON ID Entra di Microsoft invece di usare segreti condivisi (stringhe di connessione e chiavi), che sono meno sicuri.
Selezionare un'identità assegnata dall'utente	Selezionare Crea nuova identità assegnata dall'utente.
Selezionare una località per le nuove risorse	Selezionare la stessa area dell'account di archiviazione creato. Se questa regione per qualche motivo non è supportata dal modello Consumo Flessibile, non viene visualizzata. In tal caso, scegliere invece un'area nelle vicinanze. 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, premere enter, 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é il processo di pubblicazione non carica automaticamente le impostazioni dell'applicazione necessarie dal local.settings.json file, è 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 delle funzioni sia 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:

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>`

Mentre l'app si connette all'account di archiviazione usando l'autenticazione Microsoft Entra ID, la chiave di accesso dell'estensione BLOB consente di proteggere il webhook dell'estensione BLOB da accessi non autorizzati. Per trovare la chiave di accesso dell'estensione BLOB:

In Visual Studio Code selezionare l'icona di Azure nella barra 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_extension e copiare il valore della chiave.

Includere questo valore 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 nel 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. Creare le altre risorse nello stesso gruppo per semplificare la pulizia delle risorse al termine.
Selezionare l'opzione Eventi nel menu a sinistra.

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

Impostazione	Valore consigliato	Descrizione
Nome	myBlobEventSub	Nome che identifica la sottoscrizione dell'evento. 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 viene usato per le sottoscrizioni di eventi futuri.
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 consigliato	Descrizione
Abilita filtro per l'oggetto	Enabled	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. Questa impostazione attiva la sottoscrizione solo per i BLOB che iniziano con `BLOB_PREFIX` e si trovano nel `CONTAINER_NAME` contenitore.
L'oggetto 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 consigliato	Descrizione
Immettere la directory di destinazione del caricamento	default	Accettare il valore predefinito di `/`, ovvero la radice del contenitore.
Selezionare una risorsa	Nome dell'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

Quando si carica un file nel contenitore samples-workitems , la funzione viene attivata. È possibile verificare la funzione controllando gli elementi seguenti 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. Potrebbero essere presenti fino a cinque minuti di ritardo per la visualizzazione dell'evento 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.

Passaggi successivi

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-11-01