Tutorial: Introdução aos gatilhos e associações do Azure Functions no Cache Redis do Azure

Este tutorial mostra como implementar gatilhos básicos com o Cache do Azure para Redis e Azure Functions. Ele orienta você pelo uso do Visual Studio Code (VS Code) para escrever e implantar uma função do Azure em C#.

Neste tutorial, irá aprender a:

• Configure as ferramentas necessárias.
• Configure e conecte-se a um cache.
• Crie uma função do Azure e implante código nela.
• Confirme o registro de gatilhos.

Pré-requisitos

• Uma subscrição do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita.
• Visual Studio Code.

Configurar uma instância do Cache do Azure para Redis

Crie uma nova instância do Cache do Azure para Redis usando o portal do Azure ou sua ferramenta de CLI preferida. Este tutorial usa uma instância C1 padrão, que é um bom ponto de partida. Use o guia de início rápido para começar.

As configurações padrão devem ser suficientes. Este tutorial usa um ponto de extremidade público para demonstração, mas recomendamos que você use um ponto de extremidade privado para qualquer coisa em produção.

A criação do cache pode levar alguns minutos. Você pode passar para a próxima seção enquanto o processo termina.

Configurar o Visual Studio Code

1. Se você ainda não instalou a extensão do Azure Functions para VS Code, procure Azure Functions no menu EXTENSÕES e selecione Instalar. Se você não tiver a extensão C# instalada, instale-a também.

   

2. Vá para a guia Azure . Entre na sua conta do Azure.

3. Para armazenar o projeto que você está criando, crie uma nova pasta local no seu computador. Este tutorial usa RedisAzureFunctionDemo como exemplo.

4. Na guia Azure, crie um novo aplicativo de função selecionando o ícone de raio no canto superior direito da guia Espaço de trabalho.

5. Selecione Criar função....

   

6. Selecione a pasta que você criou para iniciar a criação de um novo projeto do Azure Functions. Você recebe vários prompts na tela. Selecione:

   • C# como linguagem.
   • .NET 8.0 LTS isolado como o tempo de execução do .NET.
   • Pule por enquanto como o modelo de projeto.

   Se você não tiver o SDK do .NET Core instalado, será solicitado a fazê-lo.

   Importante

   Para funções .NET, o uso do modelo de trabalho isolado é recomendado sobre o modelo em processo . Para obter uma comparação dos modelos de trabalho em processo e isolado, consulte as diferenças entre o modelo de trabalhador isolado e o modelo em processo para .NET no Azure Functions. Este exemplo usa o modelo de trabalhador isolado.

7. Confirme se o novo projeto aparece no painel EXPLORER .

   

Instale o pacote NuGet necessário

Você precisa instalar Microsoft.Azure.Functions.Worker.Extensions.Rediso , o pacote NuGet para a extensão Redis que permite que as notificações do espaço de chave Redis sejam usadas como gatilhos no Azure Functions.

Instale este pacote indo para a guia Terminal no VS Code e digitando o seguinte comando:

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

Nota

O Microsoft.Azure.Functions.Worker.Extensions.Redis pacote é usado para funções de processo de trabalho isoladas do .NET. As funções em processo do .NET e todos os outros idiomas usarão o Microsoft.Azure.WebJobs.Extensions.Redis pacote.

Configurar a cache

1. Vá para sua instância recém-criada do Cache do Azure para Redis.

2. Vá para o cache no portal do Azure e, em seguida:

   1. No menu de recursos, selecione Configurações avançadas.

   2. Role para baixo até a caixa notify-keyspace-events e digite KEA.

      KEA é uma cadeia de configuração que permite notificações de espaço de chave para todas as chaves e eventos. Para obter mais informações sobre cadeias de caracteres de configuração de espaço de chave, consulte a documentação do Redis.

   3. Selecione Salvar na parte superior da janela.

   

3. Localize Teclas de acesso no menu Recurso e, em seguida, anote ou copie o conteúdo da caixa Cadeia de conexão primária. Essa cadeia de caracteres é usada para se conectar ao cache.

   

Configurar o código de exemplo para gatilhos Redis

1. No VS Code, adicione um arquivo chamado Common.cs ao projeto. Essa classe é usada para ajudar a analisar a resposta serializada JSON para o PubSubTrigger.

2. Copie e cole o seguinte código no arquivo 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. Adicione um arquivo chamado RedisTriggers.cs ao projeto.

4. Copie e cole o seguinte exemplo de código no novo arquivo:

   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. Este tutorial mostra várias maneiras de acionar a atividade do Redis:

   • PubSubTrigger, que é acionado quando uma atividade é publicada no canal Pub/Sub chamado pubsubTest.
   • KeyspaceTrigger, que se baseia no gatilho Pub/Sub. Use-o para procurar alterações na keyspaceTest chave.
   • KeyeventTrigger, que também é construído no gatilho Pub/Sub. Use-o para procurar qualquer uso do DEL comando.
   • ListTrigger, que procura alterações à listTest lista.
   • StreamTrigger, que procura alterações no streamTest fluxo.

Conecte-se ao cache

1. Para acionar a atividade do Redis, você precisa passar a cadeia de conexão da instância do cache. Essas informações são armazenadas no arquivo local.settings.json que foi criado automaticamente em sua pasta. Recomendamos que você use o arquivo de configurações locais como uma prática recomendada de segurança.

2. Para se conectar ao cache, adicione uma ConnectionStrings seção no arquivo local.settings.json e, em seguida, adicione a cadeia de conexão usando o redisConnectionString parâmetro. A seção deve ser semelhante a este exemplo:

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

   O código no Common.cs olha para esse valor quando está sendo executado localmente:

   public const string connectionString = "redisConnectionString";
   

Importante

Este exemplo é simplificado para o tutorial. Para uso em produção, recomendamos que você use o Azure Key Vault para armazenar informações da cadeia de conexão ou autenticar na instância do Redis usando EntraID.

Crie e execute o código localmente

1. Alterne para a guia Executar e depurar no VS Code e selecione a seta verde para depurar o código localmente. Se você não tiver as ferramentas principais do Azure Functions instaladas, será solicitado a fazê-lo. Nesse caso, você precisará reiniciar o VS Code após a instalação.

2. O código deve ser compilado com êxito. Você pode acompanhar seu progresso na saída do terminal.

3. Para testar a funcionalidade do gatilho, tente criar e excluir a keyspaceTest chave.

   Você pode usar qualquer maneira que preferir para se conectar ao cache. Uma maneira fácil é usar a ferramenta de console interna no portal do Cache do Azure para Redis. Vá para a instância de cache no portal do Azure e selecione Console para abri-la.

   

   Depois que o console estiver aberto, tente os seguintes comandos:

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

   

4. Confirme se os gatilhos estão sendo ativados no terminal.

   

Adicionar ligações Redis

As ligações adicionam uma maneira simplificada de ler ou gravar dados armazenados em sua instância do Redis. Para demonstrar o benefício das ligações, adicionamos duas outras funções. Um é chamado , que é acionado SetGettercada vez que uma chave é definida e retorna o novo valor da chave usando uma ligação de entrada. O outro é chamado , que é acionado StreamSetterquando um novo item é adicionado ao fluxo myStream e usa uma ligação de saída para gravar o valor true na chave newStreamEntry.

1. Adicione um arquivo chamado RedisBindings.cs ao projeto.

2. Copie e cole o seguinte exemplo de código no novo arquivo:

   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. Alterne para a guia Executar e depurar no VS Code e selecione a seta verde para depurar o código localmente. O código deve ser compilado com êxito. Você pode acompanhar seu progresso na saída do terminal.

4. Para testar a funcionalidade de vinculação de entrada, tente definir um novo valor para qualquer chave, por exemplo, usando o comando SET hello world Você deve ver que a SetGetter função aciona e retorna o valor atualizado.

5. Para testar a funcionalidade de vinculação de saída, tente adicionar um novo item ao fluxo myStream usando o comando XADD myStream * item Order1. Observe que a função acionada StreamSetter na nova entrada de fluxo e defina o valor true para outra chave chamada newStreamEntry. Este set comando também aciona a SetGetter função.

Implantar código em uma função do Azure

1. Crie uma nova função do Azure:

   1. Volte para a guia Azure e expanda sua assinatura.

   2. Clique com o botão direito do mouse em Aplicativo de Função e selecione Criar Aplicativo de Função no Azure (Avançado).

   

2. Você recebe várias solicitações de informações para configurar o novo aplicativo de função:

   • Introduza um nome exclusivo.
   • Selecione .NET 8 Isolado como a pilha de tempo de execução.
   • Selecione Linux ou Windows (ambos funcionam).
   • Selecione um grupo de recursos novo ou existente para manter o aplicativo de função.
   • Selecione a mesma região que sua instância de cache.
   • Selecione Premium como o plano de hospedagem.
   • Crie um novo plano do Serviço de Aplicativo do Azure.
   • Selecione o nível de preço EP1 .
   • Selecione uma conta de armazenamento existente ou crie uma nova.
   • Crie um novo recurso do Application Insights. Use o recurso para confirmar se o gatilho está funcionando.

   Importante

   Atualmente, os gatilhos Redis não são suportados nas funções de consumo.

3. Aguarde alguns minutos para que o novo aplicativo de função seja criado. Ele aparece em Função App na sua assinatura. Clique com o botão direito do rato na nova aplicação de função e, em seguida, selecione Implementar na Aplicação de Função.

   

4. O aplicativo cria e começa a ser implantado. Você pode acompanhar seu progresso na janela de saída.

Adicionar informações da cadeia de conexão

1. No portal do Azure, vá para seu novo aplicativo de função e selecione Variáveis de ambiente no menu de recursos.

2. No painel de trabalho, vá para Configurações do aplicativo.

3. Em Name, digite redisConnectionString.

4. Em Valor, insira sua cadeia de conexão.

5. Selecione Aplicar na página para confirmar.

6. Navegue até o painel Visão geral e selecione Reiniciar para reiniciar o aplicativo de funções com as informações da cadeia de conexão.

Teste seus gatilhos e ligações

1. Depois que a implantação for concluída e as informações da cadeia de conexão forem adicionadas, abra seu aplicativo de função no portal do Azure. Em seguida, selecione Log Stream no menu de recursos.

2. Aguarde até que o Log Analytics se conecte e use o console Redis para ativar qualquer um dos gatilhos. Confirme se os gatilhos estão sendo registrados aqui.

   

Clean up resources (Limpar recursos)

Se quiser continuar a usar os recursos criados neste artigo, mantenha o grupo de recursos.

Caso contrário, se tiver terminado os recursos, pode eliminar o grupo de recursos do Azure que criou para evitar cobranças.

Importante

A eliminação de um grupo de recursos é irreversível. Quando elimina um grupo de recursos, todos os recursos nele contidos são eliminados permanentemente. Confirme que não elimina acidentalmente o grupo de recursos ou recursos errados. Se você criou os recursos dentro de um grupo de recursos existente que contém recursos que deseja manter, poderá excluir cada recurso individualmente em vez de excluir o grupo de recursos.

Para eliminar um grupo de recursos

1. Inicie sessão no Portal do Azure e selecione Grupos de recursos.

2. Selecione o grupo de recursos que pretende eliminar.

   Se houver muitos grupos de recursos, use a caixa Filtrar para qualquer campo... , digite o nome do grupo de recursos criado para este artigo. Selecione o grupo de recursos na lista de resultados.

   

3. Selecione Eliminar grupo de recursos.

4. É-lhe pedido que confirme a eliminação do grupo de recursos. Escreva o nome do grupo de recursos para confirmar e, em seguida, selecione Eliminar.

   

Após alguns instantes, o grupo de recursos e todos os respetivos recursos são eliminados.

Conteúdos relacionados

• Visão geral das funções do Azure para o Cache Redis do Azure
• Criar um cache write-behind usando o Azure Functions