Självstudie: Skapa en cache för skrivning bakom med hjälp av Azure Functions och Azure Cache for Redis

Målet med den här självstudien är att använda en Azure Cache for Redis-instans som en cache för skrivning bakom. Mönstret bakom skrivning i den här självstudien visar hur skrivningar till cacheutlösaren motsvarar skrivningar till en SQL-databas (en instans av Azure SQL Database-tjänsten).

Du använder Redis-utlösaren för Azure Functions för att implementera den här funktionen. I det här scenariot ser du hur du använder Azure Cache for Redis för att lagra inventerings- och prisinformation, samtidigt som du säkerhetskopierar informationen i en SQL-databas.

Varje nytt objekt eller nytt pris som skrivs till cacheminnet återspeglas sedan i en SQL-tabell i databasen.

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

Förutsättningar

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto.
• Slutförande av den föregående självstudien Kom igång med Azure Functions-utlösare i Azure Cache for Redis med dessa resurser etablerade:
  • Azure Cache for Redis-instans
  • Azure Functions-instans
  • En fungerande kunskap om att använda Azure SQL
  • Visual Studio Code-miljö (VS Code) konfigurerad med NuGet-paket installerade

Skapa och konfigurera en ny SQL-databas

SQL-databasen är bakgrundsdatabasen för det här exemplet. Du kan skapa en SQL-databas via Azure Portal eller via önskad automatiseringsmetod.

Mer information om hur du skapar en SQL-databas finns i Snabbstart: Skapa en enkel databas – Azure SQL Database.

I det här exemplet används portalen:

1. Ange ett databasnamn och välj Skapa ny för att skapa en ny server som ska innehålla databasen.

   

2. Välj Använd SQL-autentisering och ange en administratörsinloggning och ett lösenord. Kom ihåg dessa autentiseringsuppgifter eller skriv ned dem. När du distribuerar en server i produktion använder du Microsoft Entra-autentisering i stället.

   

3. Gå till fliken Nätverk och välj Offentlig slutpunkt som en anslutningsmetod. Välj Ja för båda brandväggsreglerna som visas. Den här slutpunkten ger åtkomst från din Azure-funktionsapp.

   

4. När valideringen är klar väljer du Granska + skapa och sedan Skapa. SQL-databasen börjar distribueras.

5. När distributionen är klar går du till resursen i Azure Portal och väljer fliken Frågeredigeraren. Skapa en ny tabell med namnet inventory som innehåller de data som du skriver till den. Använd följande SQL-kommando för att skapa en ny tabell med två fält:

   • ItemName listar namnet på varje objekt.
   • Price lagrar objektets pris.

   CREATE TABLE inventory (
       ItemName varchar(255),
       Price decimal(18,2)
       );
   

   

6. När kommandot har körts expanderar du mappen Tabeller och kontrollerar att den nya tabellen har skapats.

Konfigurera Redis-utlösaren

Skapa först en kopia av samma VS Code-projekt som du använde i föregående självstudie. Kopiera mappen från föregående självstudie under ett nytt namn, till exempel RedisWriteBehindTrigger, och öppna den i VS Code.

Ta sedan bort filerna RedisBindings.cs och RedisTriggers.cs .

I det här exemplet använder du pub/sub-utlösaren för att utlösa meddelanden keyevent . Målet med exemplet är:

• Utlösare varje gång en SET händelse inträffar. En SET händelse inträffar när antingen nya nycklar skrivs till cacheinstansen eller om värdet för en nyckel ändras.
• När en SET händelse har utlösts öppnar du cacheinstansen för att hitta värdet för den nya nyckeln.
• Kontrollera om nyckeln redan finns i inventeringstabellen i SQL-databasen.
  • I så fall uppdaterar du värdet för den nyckeln.
  • Annars skriver du en ny rad med nyckeln och dess värde.

Så här konfigurerar du utlösaren:

1. System.Data.SqlClient Importera NuGet-paketet för att aktivera kommunikation med SQL-databasen. Gå till VS Code-terminalen och använd följande kommando:

     dotnet add package System.Data.SqlClient
   

2. Skapa en ny fil med namnet RedisFunction.cs. Kontrollera att du har tagit bort RedisBindings.cs - och RedisTriggers.cs-filerna .

3. Kopiera och klistra in följande kod i RedisFunction.cs för att ersätta den befintliga koden:

using Microsoft.Extensions.Logging;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Redis;
using System.Data.SqlClient;

public class WriteBehindDemo
{
    private readonly ILogger<WriteBehindDemo> logger;

    public WriteBehindDemo(ILogger<WriteBehindDemo> logger)
    {
        this.logger = logger;
    }
    
    public string SQLAddress = System.Environment.GetEnvironmentVariable("SQLConnectionString");

    //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("WriteBehind")]
    public void WriteBehind(
        [RedisPubSubTrigger(Common.connectionString, "__keyevent@0__:set")] Common.ChannelMessage channelMessage,
        [RedisInput(Common.connectionString, "GET {Message}")] string setValue)
    {
        var key = channelMessage.Message; //The name of the key that was set
        var value = 0.0;

        //Check if the value is a number. If not, log an error and return.
        if (double.TryParse(setValue, out double result))
        {
            value = result; //The value that was set. (i.e. the price.)
            logger.LogInformation($"Key '{channelMessage.Message}' was set to value '{value}'");
        }
        else
        {
            logger.LogInformation($"Invalid input for key '{key}'. A number is expected.");
            return;
        }        

        // Define the name of the table you created and the column names.
        String tableName = "dbo.inventory";
        String column1Value = "ItemName";
        String column2Value = "Price";        
        
        logger.LogInformation($" '{SQLAddress}'");
        using (SqlConnection connection = new SqlConnection(SQLAddress))
            {
                connection.Open();
                using (SqlCommand command = new SqlCommand())
                {
                    command.Connection = connection;

                    //Form the SQL query to update the database. In practice, you would want to use a parameterized query to prevent SQL injection attacks.
                    //An example query would be something like "UPDATE dbo.inventory SET Price = 1.75 WHERE ItemName = 'Apple'".
                    command.CommandText = "UPDATE " + tableName + " SET " + column2Value + " = " + value + " WHERE " + column1Value + " = '" + key + "'";
                    int rowsAffected = command.ExecuteNonQuery(); //The query execution returns the number of rows affected by the query. If the key doesn't exist, it will return 0.

                    if (rowsAffected == 0) //If key doesn't exist, add it to the database
                 {
                         //Form the SQL query to update the database. In practice, you would want to use a parameterized query to prevent SQL injection attacks.
                         //An example query would be something like "INSERT INTO dbo.inventory (ItemName, Price) VALUES ('Bread', '2.55')".
                        command.CommandText = "INSERT INTO " + tableName + " (" + column1Value + ", " + column2Value + ") VALUES ('" + key + "', '" + value + "')";
                        command.ExecuteNonQuery();

                        logger.LogInformation($"Item " + key + " has been added to the database with price " + value + "");
                    }

                    else {
                        logger.LogInformation($"Item " + key + " has been updated to price " + value + "");
                    }
                }
                connection.Close();
            }

            //Log the time that the function was executed.
            logger.LogInformation($"C# Redis trigger function executed at: {DateTime.Now}");
    }
}

Konfigurera anslutningssträngar

Du måste uppdatera local.settings.json-filen så att den innehåller anslutningssträng för SQL-databasen. Lägg till en post i avsnittet Values för SQLConnectionString. Filen bör se ut som i detta exempel:

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

Om du vill hitta Redis-anslutningssträng går du till resursmenyn i Azure Cache for Redis-resursen. Leta upp strängen i området Åtkomstnycklar på resursmenyn.

Om du vill hitta SQL-databasen anslutningssträng går du till resursmenyn i SQL-databasresursen. Under Inställningar väljer du Anslutningssträngar och väljer sedan fliken ADO.NET. Strängen finns i området ADO.NET (SQL-autentisering).

Du måste ange lösenordet för SQL-databasen manuellt anslutningssträng eftersom lösenordet inte klistras in automatiskt.

Skapa och köra -projektet

1. I VS Code går du till fliken Kör och felsök och kör projektet.

2. Gå tillbaka till Din Azure Cache for Redis-instans i Azure Portal och välj knappen Konsol för att ange Redis-konsolen. Prova att använda några SET kommandon:

   • SET apple 5.25
   • SET bread 2.25
   • SET apple 4.50

3. I VS Code registreras utlösarna. Så här verifierar du att utlösarna fungerar:

   1. Gå till SQL-databasen i Azure Portal.

   2. På resursmenyn väljer du Frågeredigeraren.

   3. För Ny fråga skapar du en fråga med följande SQL-kommando för att visa de 100 främsta objekten i inventeringstabellen:

      SELECT TOP (100) * FROM [dbo].[inventory]
      

      Bekräfta att objekten som skrivits till Din Azure Cache for Redis-instans visas här.

   

Distribuera koden till funktionsappen

Den här självstudien bygger på den tidigare självstudien. Mer information finns i Distribuera kod till en Azure-funktion.

1. Gå till fliken Azure i VS Code.

2. Leta upp din prenumeration och expandera den. Leta sedan upp avsnittet Funktionsapp och expandera det.

3. Välj och håll (eller högerklicka) på funktionsappen och välj sedan Distribuera till funktionsapp.

Lägg till anslutningssträng information

Den här självstudien bygger på den tidigare självstudien. Mer information om finns i redisConnectionStringLägg till anslutningssträng information.

1. Gå till funktionsappen i Azure Portal. På resursmenyn väljer du Miljövariabler.

2. I fönstret Appinställningar anger du SQLConnectionString som ett nytt fält. Ange din anslutningssträng som Värde.

3. Välj Använd.

4. Gå till bladet Översikt och välj Starta om för att starta om appen med den nya anslutningssträng informationen.

Verifiera distributionen

När distributionen är klar går du tillbaka till Din Azure Cache for Redis-instans och använder SET kommandon för att skriva fler värden. Bekräfta att de också visas i DIN SQL-databas.

Om du vill bekräfta att funktionsappen fungerar korrekt går du till appen i portalen och väljer Loggström på resursmenyn. Du bör se utlösarna som körs där och motsvarande uppdateringar som görs i SQL-databasen.

Om du någonsin vill rensa SQL Database-tabellen utan att ta bort den kan du använda följande SQL-fråga:

TRUNCATE TABLE [dbo].[inventory]

Rensa resurser

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

Annars kan du ta bort den Azure-resursgrupp som du skapade om du är klar med resurserna för att undvika kostnader som är relaterade till resurserna.

Ta bort en resursgrupp

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

2. Välj den resursgrupp som ska tas bort.

   Om det finns många resursgrupper anger du namnet på den resursgrupp som du skapade för att slutföra den här artikeln i Filtrera efter valfritt fält. I listan med sökresultat väljer du resursgruppen.

   

3. Välj Ta bort resursgrupp.

4. I fönstret Ta bort en resursgrupp anger du namnet på resursgruppen som ska bekräftas och väljer sedan Ta bort.

   

Inom en liten stund tas resursgruppen och alla dess resurser bort.

Sammanfattning

Den här självstudien och Kom igång med Azure Functions-utlösare i Azure Cache for Redis visar hur du använder Azure Cache for Redis för att utlösa Azure-funktionsappar. De visar också hur du använder Azure Cache for Redis som en cache för skrivning bakom med Azure SQL Database. Att använda Azure Cache for Redis med Azure Functions är en kraftfull kombination som kan lösa många integrerings- och prestandaproblem.

Relaterat innehåll

• Översikt över Azure-funktioner för Azure Cache for Redis
• Självstudie: Kom igång med Azure Functions-utlösare i Azure Cache for Redis