Partilhar via

Vinculação de saída do Cache do Azure para Redis para o Azure Functions

  • Artigo

As associações de saída do Cache do Azure para Redis permitem alterar as chaves em um cache com base em um conjunto de gatilhos disponíveis no cache.

Para obter informações sobre detalhes de instalação e configuração, consulte a visão geral.

Âmbito de disponibilidade para ligações de funções

Tipo de Enlace Azure Managed Redis Cache do Azure para Redis
Saída Sim Sim

Importante

Ao usar o Azure Managed Redis ou as camadas Enterprise do Cache do Azure para Redis, use a porta 10000 em vez da porta 6380 ou 6379.

Importante

O modelo Node.js v4 para Functions ainda não é suportado pela extensão Cache do Azure para Redis. Para obter mais detalhes sobre como o modelo v4 funciona, consulte o Guia do desenvolvedor do Azure Functions Node.js. Para saber mais sobre as diferenças entre v3 e v4, consulte o guia de migração.

Importante

O modelo Python v2 para Functions ainda não é suportado pela extensão Cache for Redis do Azure. Para obter mais detalhes sobre como o modelo v2 funciona, consulte o guia do desenvolvedor Python do Azure Functions.

Exemplo

Uma função C# pode ser criada usando um dos seguintes modos C#:

  • Modelo de trabalho isolado: função C# compilada que é executada em um processo de trabalho isolado do tempo de execução. O processo de trabalho isolado é necessário para suportar funções C# em execução nas versões LTS e não-LTS .NET e .NET Framework. As extensões para funções isoladas do processo de trabalho usam Microsoft.Azure.Functions.Worker.Extensions.* namespaces.
  • Modelo em processo: função C# compilada que é executada no mesmo processo que o tempo de execução do Functions. Em uma variação desse modelo, as funções podem ser executadas usando scripts em C#, que são suportados principalmente para edição de portal em C#. As extensões para funções em processo usam Microsoft.Azure.WebJobs.Extensions.* namespaces.

O exemplo a seguir mostra um gatilho pub/sub no evento set com uma ligação de saída para a mesma instância do Redis. O evento set aciona o cache e a ligação de saída retorna um comando delete para a chave que disparou a função.

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.


using Microsoft.Extensions.Logging;

namespace Microsoft.Azure.Functions.Worker.Extensions.Redis.Samples.RedisOutputBinding
{
    internal class SetDeleter
    {
        [Function(nameof(SetDeleter))]
        [RedisOutput(Common.connectionString, "DEL")]
        public static string Run(
            [RedisPubSubTrigger(Common.connectionString, "__keyevent@0__:set")] string key,
            ILogger logger)
        {
            logger.LogInformation($"Deleting recently SET key '{key}'");
            return key;
        }
    }
}

using Microsoft.Extensions.Logging;

namespace Microsoft.Azure.WebJobs.Extensions.Redis.Samples.RedisOutputBinding
{
    internal class SetDeleter
    {
        [FunctionName(nameof(SetDeleter))]
        public static void Run(
            [RedisPubSubTrigger(Common.connectionStringSetting, "__keyevent@0__:set")] string key,
            [Redis(Common.connectionStringSetting, "DEL")] out string[] arguments,
            ILogger logger)
        {
            logger.LogInformation($"Deleting recently SET key '{key}'");
            arguments = new string[] { key };
        }
    }
}

O exemplo a seguir mostra um gatilho pub/sub no evento set com uma ligação de saída para a mesma instância do Redis. O evento set aciona o cache e a ligação de saída retorna um comando delete para a chave que disparou a função.

package com.function.RedisOutputBinding;

import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.redis.annotation.*;

public class SetDeleter {
    @FunctionName("SetDeleter")
    @RedisOutput(
                name = "value",
                connection = "redisConnectionString",
                command = "DEL")
    public String run(
            @RedisPubSubTrigger(
                name = "key",
                connection = "redisConnectionString",
                channel = "__keyevent@0__:set")
                String key,
            final ExecutionContext context) {
        context.getLogger().info("Deleting recently SET key '" + key + "'");
        return key;
    }
}

Este exemplo mostra um gatilho pub/sub no evento set com uma ligação de saída para a mesma instância do Redis. O evento set aciona o cache e a ligação de saída retorna um comando delete para a chave que disparou a função.

As ligações são definidas no ficheiro 'function.json'':

{
    "bindings": [
        {
            "type": "redisPubSubTrigger",
            "connection": "redisConnectionString",
            "channel": "__keyevent@0__:set",
            "name": "key",
            "direction": "in"
        },
        {
            "type": "redis",
            "connection": "redisConnectionString",
            "command": "DEL",
            "name": "$return",
            "direction": "out"
        }
    ],
    "scriptFile": "index.js"
}

Esse código do arquivo pega index.js a chave do gatilho e a retorna para a associação de saída para excluir o item armazenado em cache.

module.exports = async function (context, key) {
    context.log("Deleting recently SET key '" + key + "'");
    return key;
}

Este exemplo mostra um gatilho pub/sub no evento set com uma ligação de saída para a mesma instância do Redis. O evento set aciona o cache e a ligação de saída retorna um comando delete para a chave que disparou a função.

As ligações são definidas neste function.json arquivo:

{
    "bindings": [
        {
            "type": "redisPubSubTrigger",
            "connection": "redisLocalhost",
            "channel": "__keyevent@0__:set",
            "name": "key",
            "direction": "in"
        },
        {
            "type": "redis",
            "connection": "redisLocalhost",
            "command": "DEL",
            "name": "retVal",
            "direction": "out"
        }
    ],
    "scriptFile": "run.ps1"
}

Esse código do arquivo pega run.ps1 a chave do gatilho e a passa para a ligação de saída para excluir o item armazenado em cache.

param($key, $TriggerMetadata)
Write-Host "Deleting recently SET key '$key'"
Push-OutputBinding -Name retVal -Value $key

Este exemplo mostra um gatilho pub/sub no evento set com uma ligação de saída para a mesma instância do Redis. O evento set aciona o cache e a ligação de saída retorna um comando delete para a chave que disparou a função.

As ligações são definidas neste function.json arquivo:

{
    "bindings": [
        {
            "type": "redisPubSubTrigger",
            "connection": "redisLocalhost",
            "channel": "__keyevent@0__:set",
            "name": "key",
            "direction": "in"
        },
        {
            "type": "redis",
            "connection": "redisLocalhost",
            "command": "DEL",
            "name": "$return",
            "direction": "out"
        }
    ],
    "scriptFile": "__init__.py"
}

Esse código do arquivo pega __init__.py a chave do gatilho e a passa para a ligação de saída para excluir o item armazenado em cache.

import logging

def main(key: str) -> str:
    logging.info("Deleting recently SET key '" + key + "'")
    return key

Atributos

Nota

Todos os comandos são suportados para esta ligação.

A maneira como você define um parâmetro de vinculação de saída depende se suas funções C# são executadas em processo ou em um processo de trabalho isolado.

A ligação de saída é definida desta forma:

Definição Exemplo Description
Em um out parâmetro [Redis(<Connection>, <Command>)] out string <Return_Variable> A variável string retornada pelo método é um valor de chave que a associação usa para executar o comando no cache específico.

Nesse caso, o tipo retornado pelo método é um valor de chave que a associação usa para executar o comando no cache específico.

Quando sua função tem várias ligações de saída, você pode, em vez disso, aplicar o atributo binding à propriedade de um tipo que é um valor de chave, que a associação usa para executar o comando no cache específico. Para obter mais informações, consulte Várias ligações de saída.

Independentemente do modo de processo C#, as mesmas propriedades são suportadas pelo atributo de vinculação de saída:

Propriedade Attribute Description
Connection O nome da configuração do aplicativo que contém a cadeia de conexão de cache, como:<cacheName>.redis.cache.windows.net:6380,password...
Command O comando redis-cli a ser executado no cache, como: DEL.

Anotações

A RedisOutput anotação suporta estas propriedades:

Property Description
name O nome da ligação de entrada específica.
connection O nome da configuração do aplicativo que contém a cadeia de conexão de cache, como:<cacheName>.redis.cache.windows.net:6380,password...
command O comando redis-cli a ser executado no cache, como: DEL.

Configuração

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

Property Description
name O nome da ligação de entrada específica.
connection O nome da configuração do aplicativo que contém a cadeia de conexão de cache, como:<cacheName>.redis.cache.windows.net:6380,password...
command O comando redis-cli a ser executado no cache, como: DEL.

Consulte a seção Exemplo para obter exemplos completos.

Utilização

A saída retorna uma cadeia de caracteres, que é a chave da entrada de cache na qual se aplica o comando específico.

Há três tipos de conexões que são permitidas de uma instância do Azure Functions para um Cache Redis em suas implantações. Para o desenvolvimento local, você também pode usar segredos principais de serviço. Use o appsettings para configurar cada um dos seguintes tipos de autenticação de cliente, supondo que o Connection foi definido como Redis na função.

Conteúdos relacionados