Esercitazione: Introduzione a trigger e associazioni Funzioni di Azure in Azure Redis

Questa esercitazione illustra come implementare trigger di base con Funzioni di Azure e Redis gestito di Azure (anteprima) o cache di Azure per Redis. Illustra l'uso di Visual Studio Code (VS Code) per scrivere e distribuire una funzione di Azure in C#.

In questa esercitazione apprenderai a:

Prerequisiti

• Una sottoscrizione di Azure. Se non hai una sottoscrizione di Azure, crea un account gratuito.
• Visual Studio Code.

Configurare Visual Studio Code

1. Se non è ancora stata installata l'estensione Funzioni di Azure per VS Code, cercare Funzioni di Azure nel menu ESTENSIONI e quindi selezionare Installa. Se non è installata l'estensione C#, installare anche questa.

   

2. Passare alla scheda Azure. Accedere all'account Azure.

3. Per archiviare il progetto che si sta sviluppando, creare una nuova cartella locale nel computer. Questa esercitazione usa RedisAzureFunctionDemo come esempio.

4. Nella scheda Azure creare una nuova app per le funzioni selezionando l'icona a forma di fulmine in alto a destra della scheda Area di lavoro.

5. Selezionare Crea funzione.

   

6. Selezionare la cartella creata per avviare la creazione di un nuovo progetto di Funzioni di Azure. Vengono visualizzati diversi prompt sullo schermo. Selezionare:

   • C# come linguaggio.
   • .NET 8.0 Isolated LTS come runtime .NET.
   • Ignora per ora come modello di progetto.

   Se non è installato .NET Core SDK, viene richiesto di farlo.

   Importante

   Per le funzioni .NET, è consigliabile usare il modello di lavoro isolato nel modello di In-Process. Per un confronto tra il modello In-Process e il modello di lavoro isolato, vedere Differenze tra il modello di lavoro isolato e il modello In-Process per .NET in Funzioni di Azure. Questo esempio usa il modello di lavoro isolato.

7. Confermare che il nuovo progetto venga visualizzato nel riquadro EXPLORER.

   

Installare il pacchetto NuGet necessario

È necessario installare Microsoft.Azure.Functions.Worker.Extensions.Redis, il pacchetto NuGet per l'estensione Redis che consente di usare le notifiche del keyspace Redis come trigger in Funzioni di Azure.

Installare questo pacchetto passando alla scheda Terminale in VS Code e immettendo il comando seguente:

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Redis --prerelease

Configurare il codice di esempio per i trigger Redis

1. In VS Code aggiungere un file denominato Common.cs al progetto. Questa classe viene usata per analizzare la risposta serializzata JSON per PubSubTrigger.

2. Copiare e incollare il codice seguente nel file Common.cs:

   public class Common
   {
       public const string connectionString = "redisConnectionString";
   
       public class ChannelMessage
       {
           public string SubscriptionChannel { get; set; }
           public string Channel { get; set; }
           public string Message { get; set; }
       }
   }
   

3. Aggiungere un file denominato RedisTriggers.cs al progetto.

4. Copiare e incollare il codice di esempio seguente nel nuovo file:

   using Microsoft.Extensions.Logging;
   using Microsoft.Azure.Functions.Worker;
   using Microsoft.Azure.Functions.Worker.Extensions.Redis;
   
   public class RedisTriggers
   {
       private readonly ILogger<RedisTriggers> logger;
   
       public RedisTriggers(ILogger<RedisTriggers> logger)
       {
           this.logger = logger;
       }
   
       // PubSubTrigger function listens to messages from the 'pubsubTest' channel.
       [Function("PubSubTrigger")]
       public void PubSub(
       [RedisPubSubTrigger(Common.connectionString, "pubsubTest")] Common.ChannelMessage channelMessage)
       {
       logger.LogInformation($"Function triggered on pub/sub message '{channelMessage.Message}' from channel '{channelMessage.Channel}'.");
       }
   
       // KeyeventTrigger function listens to key events from the 'del' operation.
       [Function("KeyeventTrigger")]
       public void Keyevent(
           [RedisPubSubTrigger(Common.connectionString, "__keyevent@0__:del")] Common.ChannelMessage channelMessage)
       {
           logger.LogInformation($"Key '{channelMessage.Message}' deleted.");
       }
   
       // KeyspaceTrigger function listens to key events on the 'keyspaceTest' key.
       [Function("KeyspaceTrigger")]
       public void Keyspace(
           [RedisPubSubTrigger(Common.connectionString, "__keyspace@0__:keyspaceTest")] Common.ChannelMessage channelMessage)
       {
           logger.LogInformation($"Key 'keyspaceTest' was updated with operation '{channelMessage.Message}'");
       }
   
       // ListTrigger function listens to changes to the 'listTest' list.
       [Function("ListTrigger")]
       public void List(
           [RedisListTrigger(Common.connectionString, "listTest")] string response)
       {
           logger.LogInformation(response);
       }
   
       // StreamTrigger function listens to changes to the 'streamTest' stream.
       [Function("StreamTrigger")]
       public void Stream(
           [RedisStreamTrigger(Common.connectionString, "streamTest")] string response)
       {
           logger.LogInformation(response);
       }
   }
   

5. Questa esercitazione illustra diversi modi per attivare l'attività Redis:

   • PubSubTrigger, che viene attivato quando un'attività viene pubblicata nel canale di pubblicazione/sottoscrizione denominato pubsubTest.
   • KeyspaceTrigger, che è basato sul trigger di pubblicazione/sottoscrizione. Usarlo per cercare le modifiche apportate alla chiave keyspaceTest.
   • KeyeventTrigger, che è anch'esso basato sul trigger di pubblicazione/sottoscrizione. Usarlo per cercare qualsiasi utilizzo del comando DEL.
   • ListTrigger, che cerca le modifiche apportate all'elenco listTest.
   • StreamTrigger, che cerca le modifiche apportate al flusso streamTest.

Connettersi alla cache

1. Per attivare l'attività Redis, è necessario passare la stringa di connessione dell'istanza della cache. Queste informazioni sono archiviate nel file local.settings.json creato automaticamente nella cartella. Usare il file di impostazioni locali come procedura consigliata per la sicurezza.

2. Per connettersi alla cache, aggiungere una sezione ConnectionStrings nel file local.settings.json e quindi aggiungere la stringa di connessione usando il parametro redisConnectionString. La sezione dovrà essere simile a questo esempio:

   {
     "IsEncrypted": false,
     "Values": {
       "AzureWebJobsStorage": "",
       "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
       "redisConnectionString": "<your-connection-string>"
     }
   }
   

   Il codice in Common.cs cerca questo valore quando è in esecuzione in locale:

   public const string connectionString = "redisConnectionString";
   

Compilare ed eseguire il codice in locale

1. Passare alla scheda Esegui con debug in VS Code e selezionare la freccia verde per eseguire il debug del codice in locale. Se il toolset Azure Functions Core Tools non è installato, viene richiesto di farlo. In tal caso, sarà necessario riavviare VS Code dopo l'installazione.

2. Il codice dovrebbe essere compilato correttamente. È possibile tenere traccia dello stato di avanzamento nell'output del terminale.

3. Per testare la funzionalità del trigger, provare a creare ed eliminare la chiave keyspaceTest.

   È possibile usare qualsiasi metodo per connettersi alla cache. Un modo semplice consiste nell'usare lo strumento console predefinito nel portale della cache di Azure per Redis. Passare all'istanza della cache nel portale di Azure e quindi selezionare Console per aprirla.

   Importante

   Lo strumento console non è ancora disponibile per Redis gestito di Azure. Prendere invece in considerazione l'uso dell'interfaccia della riga di comando redis o di uno strumento come Redis Insight per eseguire comandi direttamente nell'istanza di Redis.

   

   Dopo aver aperto la console, provare i comandi seguenti:

   • SET keyspaceTest 1
   • SET keyspaceTest 2
   • DEL keyspaceTest
   • PUBLISH pubsubTest testMessage
   • LPUSH listTest test
   • XADD streamTest * name Clippy

   

4. Verificare che i trigger siano attivati nel terminale.

   

Aggiungere le associazioni Redis

Le associazioni aggiungono un modo semplificato per leggere o scrivere i dati archiviati nell'istanza di Redis. Per illustrare il vantaggio delle associazioni, vengono aggiunte altre due funzioni. Una, denominata SetGetter, si attiva ogni volta che viene impostata una chiave e restituisce il nuovo valore della chiave usando un'associazione di input. L'altra, denominataStreamSetter, si attiva quando un nuovo elemento viene aggiunto al flusso myStream e usa un'associazione di output per scrivere il valore true nella chiave newStreamEntry.

1. Aggiungere un file denominato RedisBindings.cs al progetto.

2. Copiare e incollare il codice di esempio seguente nel nuovo file:

   using Microsoft.Extensions.Logging;
   using Microsoft.Azure.Functions.Worker;
   using Microsoft.Azure.Functions.Worker.Extensions.Redis;
   
   public class RedisBindings
   {
       private readonly ILogger<RedisBindings> logger;
   
       public RedisBindings(ILogger<RedisBindings> logger)
       {
           this.logger = logger;
       }
   
       //This example uses the PubSub trigger to listen to key events on the 'set' operation. A Redis Input binding is used to get the value of the key being set.
       [Function("SetGetter")]
       public void SetGetter(
           [RedisPubSubTrigger(Common.connectionString, "__keyevent@0__:set")] Common.ChannelMessage channelMessage,
           [RedisInput(Common.connectionString, "GET {Message}")] string value)
       {
           logger.LogInformation($"Key '{channelMessage.Message}' was set to value '{value}'");
       }
   
       //This example uses the PubSub trigger to listen to key events to the key 'key1'. When key1 is modified, a Redis Output binding is used to set the value of the 'key1modified' key to 'true'.
       [Function("SetSetter")]
       [RedisOutput(Common.connectionString, "SET")]
       public string SetSetter(
           [RedisPubSubTrigger(Common.connectionString, "__keyspace@0__:key1")] Common.ChannelMessage channelMessage)
       {
           logger.LogInformation($"Key '{channelMessage.Message}' was updated. Setting the value of 'key1modified' to 'true'");
           return $"key1modified true";
       }
   }
   

3. Passare alla scheda Esegui con debug in VS Code e selezionare la freccia verde per eseguire il debug del codice in locale. Il codice dovrebbe essere compilato correttamente. È possibile tenere traccia dello stato di avanzamento nell'output del terminale.

4. Per testare la funzionalità di associazione di input, provare a impostare un nuovo valore per qualsiasi chiave, ad esempio usando il comando SET hello world. Si noterà che la funzione SetGetter viene attivata e restituisce il valore aggiornato.

5. Per testare la funzionalità di associazione di output, provare ad aggiungere un nuovo elemento al flusso myStream usando il comando XADD myStream * item Order1. Si noti che la funzione StreamSetter viene attivata nella nuova voce del flusso e imposta il valore true su un'altra chiave denominata newStreamEntry. Questo comando set attiva anche la funzione SetGetter.

Distribuire il codice in una funzione di Azure

1. Creare una nuova funzione di Azure:

   1. Tornare nella scheda Azure ed espandere la sottoscrizione.

   2. Fare clic con il pulsante destro del mouse su App per le funzioni e quindi scegliere Crea app per le funzioni in Azure (Avanzate).

   

2. Vengono visualizzate diverse richieste di informazioni per configurare la nuova app per le funzioni:

   • Immettere un nome univoco.
   • Selezionare .NET 8 Isolated come stack di runtime.
   • Selezionare Linux o Windows (funzionano entrambi).
   • Selezionare un gruppo di risorse nuovo o esistente in cui contenere l'app per le funzioni.
   • Selezionare la stessa area dell'istanza della cache.
   • Selezionare Premium come piano di hosting.
   • Creare un nuovo piano di servizio app di Azure.
   • Selezionare il piano tariffario EP1.
   • selezionare un account di archiviazione esistente o crearne uno nuovo.
   • Creare una nuova risorsa di Application Insights. Usare la risorsa per verificare che il trigger funzioni.

   Importante

   I trigger Redis non sono attualmente supportati nelle funzioni a consumo.

3. Attendere alcuni minuti che venga creata la nuova app per le funzioni. Viene visualizzata in App per le funzioni nella sottoscrizione. Fare clic con il pulsante destro del mouse sulla nuova app per le funzioni e quindi scegliere Distribuisci in app per le funzioni.

   

4. L'app viene compilata e viene avviata la distribuzione. È possibile tenere traccia dello stato di avanzamento nella finestra di output.

Aggiungere le informazioni della stringa di connessione

1. Nel portale di Azure passare alla nuova app per le funzioni e selezionare Variabili di ambiente nel menu della risorsa.

2. Nel riquadro di lavoro passare a Impostazioni app.

3. Per Nome immettere redisConnectionString.

4. Per Valore immettere la stringa di connessione.

5. Selezionare Applica nella pagina per confermare.

6. Passare al riquadro Panoramica e selezionare Riavvia per riavviare l'app delle funzioni con le informazioni della stringa di connessione.

Testare trigger e associazioni

1. Al termine della distribuzione e dopo aver aggiunto le informazioni della stringa di connessione, aprire l'app per le funzioni nel portale di Azure. Selezionare quindi Flusso di log nel menu della risorsa.

2. Attendere che Log Analytics si connetta e quindi usare la console Redis per attivare uno dei trigger. Verificare che i trigger vengano registrati.

   

Pulire le risorse

Per continuare a usare le risorse create in questo articolo, mantenere il gruppo di risorse.

In caso contrario, se le risorse sono state completate, per evitare addebiti è possibile eliminare il gruppo di risorse di Azure creato.

Per eliminare un gruppo di risorse

1. Accedere al portale di Azure e selezionare Gruppi di risorse.

2. Scegliere il gruppo di risorse da eliminare.

   Se sono presenti molti gruppi di risorse, usare la casella Filtro per qualsiasi campo... e digitare il nome del gruppo di risorse creato per questo articolo. Nell’elenco dei risultati selezionare il gruppo di risorse.

   

3. Selezionare Elimina gruppo di risorse.

4. Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Digitare il nome del gruppo di risorse per confermare e quindi selezionare Elimina.

   

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Contenuto correlato

• Panoramica dei trigger e delle associazioni Redis per Funzioni di Azure
• Creare una cache write-behind con Funzioni di Azure