Compartilhar via

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

  • Artigo

Este tutorial mostrará como implementar gatilhos básicos com o Azure Functions e o Redis Gerenciado do Azure (versão prévia) ou o Cache do Azure para Redis. Ele orienta você através do uso do Visual Studio Code (VS Code) para escrever e implantar uma função do Azure em C#.

Neste tutorial, você aprenderá como:

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

Pré-requisitos

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 B1 Balanceado, que é um bom ponto de partida. Selecione essa instância ao usar o guia de início rápido para começar.

As configurações padrão são 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 mover para a próxima seção enquanto o processo é concluído.

Configurar o Visual Studio Code

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

    Captura de tela das extensões necessárias instaladas no VS Code.

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

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

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

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

    Captura de tela mostrando o ícone para adicionar uma nova função do VS Code.

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

    • C# como a linguagem.
    • .NET 8.0 LTS isolado como tempo de execução do .NET.
    • Ignorar 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, é recomendado usar o modelo de trabalho isolado em vez do modelo em processo. Para obter uma comparação entre os modelos de trabalhador em processo e isolado, veja diferenças entre o modelo de trabalhador isolado e o modelo em processo para .NET no Azure Functions. Esse exemplo usa o modelo de trabalhador isolado.

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

    Captura de tela de um espaço de trabalho no VS Code.

Instalar o pacote NuGet necessário

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

Instale esse pacote acessando a guia Terminal no VS Code e inserindo o seguinte comando:

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

Observação

O pacote Microsoft.Azure.Functions.Worker.Extensions.Redis é usado para funções de processo de trabalho isolado do .NET. As funções em processo do .NET e todas as outras linguagens usarão o pacote Microsoft.Azure.WebJobs.Extensions.Redis.

  1. Acesse sua instância do Redis Gerenciado do Azure recém-criada.

  2. Acesse o cache no portal do Azure e localize as Chaves de acesso no menu Recurso. Anote ou copie o conteúdo da caixa Primária. Você usará isso para criar sua cadeia de conexão.

  3. Crie uma Cadeia de conexão usando o seguinte formato: {your-cache-hostname}:10000,password={your-access-key},ssl=True,abortConnect=False. Caso tenha desabilitado o TLS/SSL, use ssl=False em vez disso.

  4. Conecte-se à instância do Redis usando sua escolha de método, como a CLI do Redis ou o Redis Insights. Para obter instruções sobre como se conectar à instância do Redis usando a CLI do Redis, consulte Usar a ferramenta de linha de comando Redis com o Redis Gerenciado do Azure.

  5. Configure as notificações do keyspace usando o comando CONFIG SET:

    CONFIG SET notify-keyspace-events KEA

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

Configure 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 a seguinte amostra 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 disparar na atividade do Redis:

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

Conectar-se ao cache

  1. Para disparar a atividade do Redis, você precisa passar a cadeia de conexão da sua instância de 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 seu cache, adicione uma seção ConnectionStrings no arquivo local.settings.json e, em seguida, adicione sua string de conexão usando o parâmetro redisConnectionString. 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 em Common.cs procura 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 de cadeia de conexão ou autenticar na instância do Redis usando o Microsoft Entra ID.

Compile 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 que você faça isso. 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 de gatilho, tente criar e excluir a chave keyspaceTest .

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

    Importante

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

    Captura de tela do código C-Sharp e uma cadeia de conexão.

    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

    Captura de tela de um console e alguns comandos e resultados do Redis.

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

    Captura de tela do editor VS Code com o código em execução.

Adicionar ligações do Redis

As vinculaçõ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 SetGetter, que é acionado cada vez que uma chave é definida e retorna o novo valor da chave usando uma ligação de entrada. O outro é chamado StreamSetter, que é acionado quando 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 a seguinte amostra 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 worldVocê verá que a funçãoSetGetter é acionada 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 StreamSetter foi acionada na nova entrada de fluxo e defina o valor true para outra chave chamada newStreamEntry. Esse comando set também aciona a função SetGetter.

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

  1. Criar 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ções e selecione Criar aplicativo de funções no Azure (Avançado).

    Captura de tela das seleções para criar um aplicativo de funções no VS Code.

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

    • Insira um nome exclusivo.
    • Selecione .NET 8 Isolado como 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ções.
    • Selecione a mesma região que sua instância do cache.
    • Selecione Premium como o plano de hospedagem.
    • Criar um novo plano do Serviço de Aplicativo do Azure.
    • Selecione o tipo de preços EP1.
    • Selecione uma conta de armazenamento existente ou crie uma nova.
    • Criar um novo recurso do Application Insights Você usa o recurso para confirmar se o gatilho está funcionando.

    Importante

    Atualmente, os gatilhos do Redis não são compatíveis com as funções de consumo.

  3. Aguarde alguns minutos para que o novo aplicativo de funções seja criado. Ele aparece em Aplicativo de Funções na sua assinatura. Clique com o botão direito do mouse no novo aplicativo de funções e selecione Implantar no aplicativo de funções.

    Captura de tela das seleções para implementação em um aplicativo de funções no VS Code.

  4. O aplicativo compila e inicia a implantação. Você pode acompanhar seu progresso na janela de saída.

Adicionar informações da cadeia de conexão

Importante

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

  1. No portal do Azure, acesse seu novo aplicativo de funções e selecione Variáveis de ambiente no menu de recursos.

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

  3. Em Nome, insira redisConnectionString.

  4. Em Value, 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 reinicializar 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ções no portal do Azure. Em seguida, selecione Fluxo de Logs no menu de recursos.

  2. Aguarde a conexão do Log Analytics e, em seguida, use o console do Redis para ativar qualquer um dos gatilhos. Confirme se os gatilhos estão sendo registrados aqui.

    Captura de tela de um fluxo de log para um recurso de aplicativo de funções no menu de recursos.

Limpar os recursos

Se quiser continuar a usar os recursos que você criou neste artigo, conserve o grupo de recursos.

Caso contrário, se não pretende mais usar os recursos, você poderá excluir o grupo de recursos criado no Azure para evitar a cobrança.

Importante

A exclusão de um grupo de recursos é irreversível. Ao excluir o grupo de recursos, todos os recursos nele são excluídos permanentemente. Não exclua acidentalmente o grupo de recursos ou os recursos incorretos. Se você criou os recursos dentro de um grupo de recursos existente que contém recursos que você quer manter, você pode excluir cada recurso individualmente em vez de excluir o grupo de recursos.

Para excluir um grupo de recursos

  1. Entre no portal do Azure e selecione Grupos de recursos.

  2. Selecione o grupo de recursos que você quer excluir.

    Se existirem muitos grupos de recursos, use a caixa Filtrar para qualquer campo... e digite o nome do seu grupo de recursos que você criou para este artigo. Selecione o grupo de recursos na lista de resultados.

    Captura de tela mostrando uma lista dos grupos de recursos a serem excluídos no painel de trabalho.

  3. Selecione Excluir grupo de recursos.

  4. Você receberá uma solicitação para confirmar a exclusão do grupo de recursos. Digite o nome do grupo de recursos para confirmar e selecione Excluir.

    Captura de tela mostrando um formulário que requer que a exclusão do nome do recurso seja confirmada.

Após alguns instantes, o grupo de recursos, e todos os recursos nele são excluídos.

Conteúdo relacionado