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

Este tutorial mostra como implementar gatilhos básicos com o Azure Functions e o Azure Managed Redis (visualização) ou o Cache do Azure para Redis. 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:

Pré-requisitos

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

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

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";
   

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.

   Importante

   A ferramenta de console ainda não está disponível para o Azure Managed Redis. Em vez disso, considere usar o redis-cli ou uma ferramenta como o Redis Insight para executar comandos diretamente na instância do Redis.

   

   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.

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 dos gatilhos e ligações Redis para o Azure Functions
• Criar um cache write-behind usando o Azure Functions