Självstudie: Kom igång med Azure Functions-utlösare och bindningar i Azure Cache for Redis

Den här självstudien visar hur du implementerar grundläggande utlösare med Azure Cache for Redis och Azure Functions. Den vägleder dig genom att använda Visual Studio Code (VS Code) för att skriva och distribuera en Azure-funktion i C#.

I den här självstudien lär du dig att:

• Konfigurera nödvändiga verktyg.
• Konfigurera och ansluta till en cache.
• Skapa en Azure-funktion och distribuera kod till den.
• Bekräfta loggningen av utlösare.

Förutsättningar

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto.
• Visual Studio Code.

Konfigurera en Azure Cache for Redis-instans

Skapa en ny Azure Cache for Redis-instans med hjälp av Azure-portalen eller ditt önskade CLI-verktyg. I den här självstudien används en Standard C1-instans , vilket är en bra startpunkt. Kom igång med snabbstartsguiden.

Standardinställningarna bör räcka. I den här självstudien används en offentlig slutpunkt för demonstration, men vi rekommenderar att du använder en privat slutpunkt för allt i produktion.

Det kan ta några minuter att skapa cacheminnet. Du kan gå vidare till nästa avsnitt medan processen är klar.

Konfigurera Visual Studio Code

1. Om du inte har installerat Azure Functions-tillägget för VS Code ännu söker du efter Azure Functions på MENYN EXTENSIONS och väljer sedan Installera. Om du inte har C#-tillägget installerat installerar du det också.

   

2. Gå till fliken Azure . Logga in på ditt Azure-konto.

3. Om du vill lagra projektet som du skapar skapar du en ny lokal mapp på datorn. I den här självstudien används RedisAzureFunctionDemo som exempel.

4. På fliken Azure skapar du en ny funktionsapp genom att välja blixtikonen längst upp till höger på fliken Arbetsyta .

5. Välj Skapa funktion....

   

6. Välj den mapp som du skapade för att börja skapa ett nytt Azure Functions-projekt. Du får flera frågor på skärmen. Välj:

   • C# som språk.
   • .NET 8.0 Isolerad LTS som .NET-körning.
   • Hoppa över för tillfället som projektmall.

   Om du inte har installerat .NET Core SDK uppmanas du att göra det.

   Viktigt!

   För .NET-funktioner rekommenderas användning av den isolerade arbetsmodellen över den pågående modellen. En jämförelse av de processbaserade och isolerade arbetsmodellerna finns i skillnader mellan den isolerade arbetsmodellen och den processbaserade modellen för .NET på Azure Functions. Det här exemplet använder den isolerade arbetsmodellen.

7. Bekräfta att det nya projektet visas i explorer-fönstret.

   

Installera det nödvändiga NuGet-paketet

Du måste installera Microsoft.Azure.Functions.Worker.Extensions.RedisNuGet-paketet för Redis-tillägget som gör att Redis-nyckelområdesmeddelanden kan användas som utlösare i Azure Functions.

Installera det här paketet genom att gå till fliken Terminal i VS Code och ange följande kommando:

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

Kommentar

Paketet Microsoft.Azure.Functions.Worker.Extensions.Redis används för .NET-isolerade arbetsprocessfunktioner. .NET-in-processfunktioner och alla andra språk använder paketet Microsoft.Azure.WebJobs.Extensions.Redis i stället.

Konfigurera cachen

1. Gå till din nyligen skapade Azure Cache for Redis-instans.

2. Gå till din cache i Azure-portalen och gör sedan följande:

   1. På resursmenyn väljer du Avancerade inställningar.

   2. Rulla ned till rutan notify-keyspace-events och ange KEA.

      KEA är en konfigurationssträng som aktiverar keyspace-meddelanden för alla nycklar och händelser. Mer information om konfigurationssträngar för nyckelrymder finns i Redis-dokumentationen.

   3. Välj Spara överst i fönstret.

   

3. Leta upp åtkomstnycklar på resursmenyn och skriv sedan ned eller kopiera innehållet i rutan Primär anslutningssträng. Den här strängen används för att ansluta till cacheminnet.

   

Konfigurera exempelkoden för Redis-utlösare

1. I VS Code lägger du till en fil med namnet Common.cs i projektet. Den här klassen används för att parsa det serialiserade JSON-svaret för PubSubTrigger.

2. Kopiera och klistra in följande kod i filen 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. Lägg till en fil med namnet RedisTriggers.cs i projektet.

4. Kopiera och klistra in följande kodexempel i den nya filen:

   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. Den här självstudien visar flera sätt att utlösa redis-aktivitet:

   • PubSubTrigger, som utlöses när en aktivitet publiceras till pub-/underkanalen med namnet pubsubTest.
   • KeyspaceTrigger, som bygger på pub-/underutlösaren. Använd den för att leta efter ändringar i keyspaceTest nyckeln.
   • KeyeventTrigger, som också bygger på Pub/Sub-utlösaren. Använd den för att söka efter all användning av DEL kommandot.
   • ListTrigger, som söker efter ändringar i listTest listan.
   • StreamTrigger, som söker efter ändringar i streamTest strömmen.

Anslut till cacheminnet

1. Om du vill utlösa Redis-aktivitet måste du skicka in anslutningssträng för cacheinstansen. Den här informationen lagras i den local.settings.json fil som skapades automatiskt i mappen. Vi rekommenderar att du använder filen med lokala inställningar som bästa praxis för säkerhet.

2. Om du vill ansluta till cacheminnet lägger du till ett ConnectionStrings avsnitt i local.settings.json-filen och lägger sedan till din anslutningssträng med hjälp av parametern redisConnectionString . Avsnittet bör se ut så här:

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

   Koden i Common.cs ser till det här värdet när den körs lokalt:

   public const string connectionString = "redisConnectionString";
   

Viktigt!

Det här exemplet är förenklat för självstudien. För produktionsanvändning rekommenderar vi att du använder Azure Key Vault för att lagra anslutningssträng information eller autentisera till Redis-instansen med Hjälp av EntraID.

Skapa och kör koden lokalt

1. Växla till fliken Kör och felsök i VS Code och välj den gröna pilen för att felsöka koden lokalt. Om du inte har installerat Azure Functions-kärnverktyg uppmanas du att göra det. I så fall måste du starta om VS Code efter installationen.

2. Koden bör skapas. Du kan spåra dess förlopp i terminalutdata.

3. Testa utlösarfunktionen genom att försöka skapa och ta keyspaceTest bort nyckeln.

   Du kan använda alla sätt som du föredrar att ansluta till cachen. Ett enkelt sätt är att använda det inbyggda konsolverktyget i Azure Cache for Redis-portalen. Gå till cacheinstansen i Azure-portalen och välj sedan Konsol för att öppna den.

   

   När konsolen är öppen kan du prova följande kommandon:

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

   

4. Bekräfta att utlösarna aktiveras i terminalen.

   

Lägga till Redis-bindningar

Bindningar lägger till ett effektivt sätt att läsa eller skriva data som lagras på din Redis-instans. För att visa fördelarna med bindningar lägger vi till två andra funktioner. En kallas SetGetter, som utlöses varje gång en nyckel anges och returnerar det nya värdet för nyckeln med hjälp av en indatabindning. Den andra kallas StreamSetter, som utlöses när ett nytt objekt läggs till i dataströmmen myStream och använder en utdatabindning för att skriva värdet true till nyckeln newStreamEntry.

1. Lägg till en fil med namnet RedisBindings.cs i projektet.

2. Kopiera och klistra in följande kodexempel i den nya filen:

   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. Växla till fliken Kör och felsök i VS Code och välj den gröna pilen för att felsöka koden lokalt. Koden bör skapas. Du kan spåra dess förlopp i terminalutdata.

4. Testa indatabindningsfunktionen genom att prova att ange ett nytt värde för valfri nyckel, till exempel med kommandot SET hello world Du bör se att SetGetter funktionen utlöses och returnerar det uppdaterade värdet.

5. Testa utdatabindningsfunktionen genom att prova att lägga till ett nytt objekt i strömmen myStream med kommandot XADD myStream * item Order1. Observera att StreamSetter funktionen som utlöstes på den nya dataströmposten och anger värdet true till en annan nyckel som heter newStreamEntry. Det här set kommandot utlöser SetGetter också funktionen.

Distribuera kod till en Azure-funktion

1. Skapa en ny Azure-funktion:

   1. Gå tillbaka till fliken Azure och expandera din prenumeration.

   2. Högerklicka på Funktionsapp och välj sedan Skapa funktionsapp i Azure (Avancerat).

   

2. Du får flera frågor om information för att konfigurera den nya funktionsappen:

   • Ange ett unikt namn.
   • Välj .NET 8 Isolerad som körningsstack.
   • Välj antingen Linux eller Windows (fungerar antingen).
   • Välj en befintlig eller ny resursgrupp som ska innehålla funktionsappen.
   • Välj samma region som cacheinstansen.
   • Välj Premium som värdplan.
   • Skapa en ny Azure App Service-plan.
   • Välj prisnivån EP1.
   • Välj ett befintligt lagringskonto eller skapa ett nytt.
   • Skapa en ny Application Insights-resurs. Du använder resursen för att bekräfta att utlösaren fungerar.

   Viktigt!

   Redis-utlösare stöds för närvarande inte i förbrukningsfunktioner.

3. Vänta några minuter tills den nya funktionsappen har skapats. Den visas under Funktionsapp i din prenumeration. Högerklicka på den nya funktionsappen och välj sedan Distribuera till funktionsapp.

   

4. Appen skapar och börjar distribuera. Du kan spåra förloppet i utdatafönstret.

Lägg till anslutningssträng information

1. I Azure-portalen går du till din nya funktionsapp och väljer Miljövariabler på resursmenyn.

2. Gå till Appinställningar i arbetsfönstret.

3. Som Namn anger du redis Anslut ionString.

4. Ange din anslutningssträng som Värde.

5. Välj Använd på sidan för att bekräfta.

6. Gå till fönstret Översikt och välj Starta om för att starta om funktionsappen med anslutningssträng information.

Testa utlösare och bindningar

1. När distributionen är klar och anslutningssträng informationen har lagts till öppnar du funktionsappen i Azure-portalen. Välj sedan Log Stream på resursmenyn.

2. Vänta tills Log Analytics ansluter och använd sedan Redis-konsolen för att aktivera någon av utlösarna. Bekräfta att utlösare loggas här.

   

Rensa resurser

Om du vill fortsätta att använda de resurser som du skapade i den här artikeln behåller du resursgruppen.

Om du är klar med resurserna kan du ta bort den Azure-resursgrupp som du skapade för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. När du tar bort en resursgrupp tas alla resurser som ingår i den bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna i en befintlig resursgrupp som innehåller resurser som du vill behålla kan du ta bort varje resurs individuellt i stället för att ta bort resursgruppen.

Ta bort en resursgrupp

1. Logga in på Azure-portalen och välj Resursgrupper.

2. Välj den resursgrupp som du vill ta bort.

   Om det finns många resursgrupper använder du rutan Filter för alla fält... och skriver namnet på resursgruppen som du skapade för den här artikeln. Välj resursgruppen i resultatlistan.

   

3. Välj Ta bort resursgrupp.

4. Du blir ombedd att bekräfta borttagningen av resursgruppen. Skriv namnet på din resursgrupp för att bekräfta och välj sedan Ta bort.

   

Efter en liten stund tas resursgruppen och de resurser som finns i den bort.

Relaterat innehåll

• Översikt över Azure-funktioner för Azure Cache for Redis
• Skapa en cache för skrivning bakom med hjälp av Azure Functions