Referência do desenvolvedor do script C# do Azure Functions (.csx)

  • Artigo

Este artigo é uma introdução ao desenvolvimento do Azure Functions usando o script C# (.csx).

Importante

O script C# é suportado principalmente para fornecer uma experiência conveniente no portal para ajudá-lo a começar rapidamente a criar e executar funções C#. Para aplicativos com qualidade de produção, você deve, em vez disso, desenvolver suas funções C# localmente como um projeto de biblioteca de classes C# compilado. Para saber como migrar um projeto de script C# para um projeto de biblioteca de classes C# (trabalhador isolado), consulte Converter um aplicativo de script C# em um projeto C#.

O Azure Functions permite desenvolver funções usando C# de uma das seguintes maneiras:

Type Processo de execução Extensão de código Ambiente de desenvolvimento Referência
Script C# em processo .csx Portal
Ferramentas principais		 Este artigo
Biblioteca de classes C# (trabalhador isolado) processo de trabalho isolado .cs Visual Studio
Visual Studio Code
Ferramentas principais		 Funções de processo de trabalho isoladas do .NET
Biblioteca de classes C# (em processo) em processo .cs Visual Studio
Visual Studio Code
Ferramentas principais		 Funções da biblioteca de classes C# em processo

Como funciona o .csx

Os dados fluem para sua função C# por meio de argumentos de método. Os nomes de argumento são especificados em um function.json arquivo e há nomes predefinidos para acessar coisas como o registrador de funções e os tokens de cancelamento.

O formato .csx permite que você escreva menos "clichê" e se concentre em escrever apenas uma função C#. Em vez de envolver tudo em um namespace e classe, basta definir um Run método. Inclua quaisquer referências de assembly e namespaces no início do arquivo, como de costume.

Os arquivos .csx de um aplicativo de função são compilados quando uma instância é inicializada. Esta etapa de compilação significa que coisas como início a frio podem levar mais tempo para funções de script C# em comparação com bibliotecas de classe C#. Esta etapa de compilação também é o motivo pelo qual as funções de script C# são editáveis no portal do Azure, enquanto as bibliotecas de classe C# não são.

Estrutura de pastas

A estrutura de pastas para um projeto de script C# se parece com o exemplo a seguir:

FunctionsProject
 | - MyFirstFunction
 | | - run.csx
 | | - function.json
 | | - function.proj
 | - MySecondFunction
 | | - run.csx
 | | - function.json
 | | - function.proj
 | - host.json
 | - extensions.csproj
 | - bin

Há um arquivo host.json compartilhado que pode ser usado para configurar o aplicativo de função. Cada função tem seu próprio arquivo de código (.csx) e arquivo de configuração de vinculação (function.json).

As extensões de vinculação necessárias na versão 2.x e versões posteriores do tempo de execução do Functions são definidas no extensions.csproj arquivo, com os arquivos de biblioteca reais na bin pasta. Ao desenvolver localmente, você deve registrar extensões de vinculação. Quando você desenvolve funções no portal do Azure, esse registro é feito para você.

Vinculação a argumentos

Os dados de entrada ou saída são vinculados a um parâmetro de função de script C# por meio da name propriedade no arquivo de configuração function.json . O exemplo a seguir mostra um arquivo function.json e um arquivo run.csx para uma função acionada por fila. O parâmetro que recebe dados da mensagem de fila é nomeado myQueueItem porque esse é o valor da name propriedade.

{
    "disabled": false,
    "bindings": [
        {
            "type": "queueTrigger",
            "direction": "in",
            "name": "myQueueItem",
            "queueName": "myqueue-items",
            "connection":"MyStorageConnectionAppSetting"
        }
    ]
}

#r "Microsoft.WindowsAzure.Storage"

using Microsoft.Extensions.Logging;
using Microsoft.WindowsAzure.Storage.Queue;
using System;

public static void Run(CloudQueueMessage myQueueItem, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem.AsString}");
}

A #r afirmação é explicada mais adiante neste artigo.

Tipos suportados para ligações

Cada ligação tem seus próprios tipos suportados; por exemplo, um gatilho de blob pode ser usado com um parâmetro string, um parâmetro POCO, um parâmetro ou qualquer um CloudBlockBlob dos vários outros tipos suportados. O artigo de referência de vinculação para associações de blob lista todos os tipos de parâmetros suportados para gatilhos de blob. Para obter mais informações, consulte Gatilhos e ligações e os documentos de referência de vinculação para cada tipo de associação.

Gorjeta

Se você planeja usar as ligações HTTP ou WebHook, planeje evitar o esgotamento da porta que pode ser causado pela instanciação incorreta do HttpClient. Para obter mais informações, consulte Como gerenciar conexões no Azure Functions.

Fazendo referência a classes personalizadas

Se você precisar usar uma classe Plain Old CLR Object (POCO) personalizada, poderá incluir a definição de classe dentro do mesmo arquivo ou colocá-la em um arquivo separado.

O exemplo a seguir mostra um exemplo run.csx que inclui uma definição de classe POCO.

public static void Run(string myBlob, out MyClass myQueueItem)
{
    log.Verbose($"C# Blob trigger function processed: {myBlob}");
    myQueueItem = new MyClass() { Id = "myid" };
}

public class MyClass
{
    public string Id { get; set; }
}

Uma classe POCO deve ter um getter e setter definidos para cada propriedade.

Reutilizando o código .csx

Você pode usar classes e métodos definidos em outros arquivos .csx em seu arquivo run.csx . Para fazer isso, use #load diretivas em seu arquivo run.csx . No exemplo a seguir, uma rotina de log nomeada MyLogger é compartilhada em myLogger.csx e carregada em run.csx usando a #load diretiva :

Exemplo run.csx:

#load "mylogger.csx"

using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, ILogger log)
{
    log.LogInformation($"Log by run.csx: {DateTime.Now}");
    MyLogger(log, $"Log by MyLogger: {DateTime.Now}");
}

Exemplo mylogger.csx:

public static void MyLogger(ILogger log, string logtext)
{
    log.LogInformation(logtext);
}

Usar um arquivo .csx compartilhado é um padrão comum quando você deseja digitar fortemente os dados passados entre funções usando um objeto POCO. No exemplo simplificado a seguir, um gatilho HTTP e um gatilho de fila compartilham um objeto POCO nomeado Order para digitar fortemente os dados do pedido:

Exemplo run.csx para gatilho HTTP:

#load "..\shared\order.csx"

using System.Net;
using Microsoft.Extensions.Logging;

public static async Task<HttpResponseMessage> Run(Order req, IAsyncCollector<Order> outputQueueItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function received an order.");
    log.LogInformation(req.ToString());
    log.LogInformation("Submitting to processing queue.");

    if (req.orderId == null)
    {
        return new HttpResponseMessage(HttpStatusCode.BadRequest);
    }
    else
    {
        await outputQueueItem.AddAsync(req);
        return new HttpResponseMessage(HttpStatusCode.OK);
    }
}

Exemplo run.csx para gatilho de fila:

#load "..\shared\order.csx"

using System;
using Microsoft.Extensions.Logging;

public static void Run(Order myQueueItem, out Order outputQueueItem, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed order...");
    log.LogInformation(myQueueItem.ToString());

    outputQueueItem = myQueueItem;
}

Exemplo order.csx:

public class Order
{
    public string orderId {get; set; }
    public string custName {get; set;}
    public string custAddress {get; set;}
    public string custEmail {get; set;}
    public string cartId {get; set; }

    public override String ToString()
    {
        return "\n{\n\torderId : " + orderId +
                  "\n\tcustName : " + custName +
                  "\n\tcustAddress : " + custAddress +
                  "\n\tcustEmail : " + custEmail +
                  "\n\tcartId : " + cartId + "\n}";
    }
}

Você pode usar um caminho relativo com a #load diretiva:

  • #load "mylogger.csx" Carrega um arquivo localizado na pasta de funções.
  • #load "loadedfiles\mylogger.csx" Carrega um arquivo localizado em uma pasta na pasta de função.
  • #load "..\shared\mylogger.csx" Carrega um arquivo localizado em uma pasta no mesmo nível da pasta de função, ou seja, diretamente em wwwroot.

A #load diretiva funciona apenas com arquivos .csx, não com arquivos .cs.

Vinculação ao valor de retorno do método

Você pode usar um valor de retorno de método para uma associação de saída, usando o nome $return em function.json.

{
    "name": "$return",
    "type": "blob",
    "direction": "out",
    "path": "output-container/{id}"
}

Aqui está o código de script C# usando o valor de retorno, seguido por um exemplo assíncrono:

public static string Run(WorkItem input, ILogger log)
{
    string json = string.Format("{{ \"id\": \"{0}\" }}", input.Id);
    log.LogInformation($"C# script processed queue message. Item={json}");
    return json;
}

public static Task<string> Run(WorkItem input, ILogger log)
{
    string json = string.Format("{{ \"id\": \"{0}\" }}", input.Id);
    log.LogInformation($"C# script processed queue message. Item={json}");
    return Task.FromResult(json);
}

Use o valor de retorno somente se uma execução de função bem-sucedida sempre resultar em um valor de retorno para passar para a associação de saída. Caso contrário, use ICollector ou IAsyncCollector, conforme mostrado na seção a seguir.

Gravando vários valores de saída

Para gravar vários valores em uma ligação de saída, ou se uma invocação de função bem-sucedida pode não resultar em nada para passar para a associação de saída, use os ICollector tipos ou IAsyncCollector . Esses tipos são coleções somente gravação que são gravadas na associação de saída quando o método é concluído.

Este exemplo grava várias mensagens de fila na mesma fila usando ICollector:

public static void Run(ICollector<string> myQueue, ILogger log)
{
    myQueue.Add("Hello");
    myQueue.Add("World!");
}

Registo

Para registrar a saída em seus logs de streaming em C#, inclua um argumento do tipo ILogger. Recomendamos que você nomeie .log Evite usar Console.Write no Azure Functions.

public static void Run(string myBlob, ILogger log)
{
    log.LogInformation($"C# Blob trigger function processed: {myBlob}");
}

Nota

Para obter informações sobre uma estrutura de log mais recente que você pode usar em vez de , consulte a documentação do ILogger no guia do desenvolvedor da biblioteca de TraceWriterclasses .NET.

Registro de métricas personalizadas

Você pode usar o LogMetric método de extensão para ILogger criar métricas personalizadas no Application Insights. Aqui está uma chamada de método de exemplo:

logger.LogMetric("TestMetric", 1234);

Esse código é uma alternativa à chamada TrackMetric usando a API do Application Insights para .NET.

Assíncrono

Para tornar uma função assíncrona, use a async palavra-chave e retorne um Task objeto.

public async static Task ProcessQueueMessageAsync(
        string blobName,
        Stream blobInput,
        Stream blobOutput)
{
    await blobInput.CopyToAsync(blobOutput, 4096);
}

Não é possível usar out parâmetros em funções assíncronas. Para ligações de saída, use o valor de retorno da função ou um objeto coletor.

Tokens de cancelamento

Uma função pode aceitar um parâmetro CancellationToken , que permite que o sistema operacional notifique seu código quando a função estiver prestes a ser encerrada. Você pode usar essa notificação para garantir que a função não seja encerrada inesperadamente de uma forma que deixe os dados em um estado inconsistente.

O exemplo a seguir mostra como verificar o encerramento iminente da função.

using System;
using System.IO;
using System.Threading;

public static void Run(
    string inputText,
    TextWriter logger,
    CancellationToken token)
{
    for (int i = 0; i < 100; i++)
    {
        if (token.IsCancellationRequested)
        {
            logger.WriteLine("Function was cancelled at iteration {0}", i);
            break;
        }
        Thread.Sleep(5000);
        logger.WriteLine("Normal processing for queue message={0}", inputText);
    }
}

Importando namespaces

Se precisar importar namespaces, você pode fazê-lo como de costume, com a using cláusula.

using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger log)

Os namespaces a seguir são importados automaticamente e, portanto, opcionais:

  • System
  • System.Collections.Generic
  • System.IO
  • System.Linq
  • System.Net.Http
  • System.Threading.Tasks
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host

Fazendo referência a assemblies externos

Para assemblies de estrutura, adicione referências usando a #r "AssemblyName" diretiva .

#r "System.Web.Http"

using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger log)

Os assemblies a seguir são adicionados automaticamente pelo ambiente de hospedagem do Azure Functions:

  • mscorlib
  • System
  • System.Core
  • System.Xml
  • System.Net.Http
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host
  • Microsoft.Azure.WebJobs.Extensions
  • System.Web.Http
  • System.Net.Http.Formatting

Os seguintes assemblies podem ser referenciados por nome simples, por versão de tempo de execução:

  • Newtonsoft.Json
  • Microsoft.WindowsAzure.Storage*

*Removido na versão 4.x do tempo de execução.

No código, os assemblies são referenciados como o exemplo a seguir:

#r "AssemblyName"

Fazendo referência a assemblies personalizados

Para fazer referência a um assembly personalizado, você pode usar um assembly compartilhado ou um assembly privado:

  • Os assemblies compartilhados são compartilhados em todas as funções dentro de um aplicativo de função. Para fazer referência a um assembly personalizado, carregue o assembly em uma pasta nomeada bin na pasta raiz (wwwroot) do seu aplicativo de função.

  • Os assemblies privados fazem parte do contexto de uma determinada função e suportam sideload de diferentes versões. Os assemblies privados devem ser carregados em uma bin pasta no diretório de funções. Faça referência aos assemblies usando o nome do arquivo, como #r "MyAssembly.dll".

Para obter informações sobre como carregar arquivos para sua pasta de funções, consulte a seção sobre gerenciamento de pacotes.

Diretórios assistidos

O diretório que contém o arquivo de script de função é automaticamente observado para alterações em assemblies. Para observar as alterações de assembly em outros diretórios, adicione-as watchDirectories à lista em host.json.

Usando pacotes NuGet

A maneira como os pacotes de extensão de vinculação e outros pacotes NuGet são adicionados ao seu aplicativo de função depende da versão de destino do tempo de execução do Functions.

Por padrão, o conjunto suportado de pacotes NuGet da extensão Functions é disponibilizado para seu aplicativo de função de script C# usando pacotes de extensão. Para saber mais, consulte Pacotes de extensão.

Se, por algum motivo, você não puder usar pacotes de extensões em seu projeto, também poderá usar as Ferramentas Principais do Azure Functions para instalar extensões com base em associações definidas nos arquivos function.json em seu aplicativo. Ao usar as Ferramentas Principais para registrar extensões, certifique-se de usar a --csx opção. Para saber mais, consulte Instalação de extensões func.

Por padrão, o Core Tools lê os arquivos function.json e adiciona os pacotes necessários a um arquivo de projeto da biblioteca de classes C# extensions.csproj na raiz do sistema de arquivos do aplicativo de função (wwwroot). Como o Core Tools usa dotnet.exe, você pode usá-lo para adicionar qualquer referência de pacote NuGet a esse arquivo de extensões. Durante a instalação, o Core Tools cria o extensions.csproj para instalar as bibliotecas necessárias. Aqui está um exemplo de arquivo extensions.csproj que adiciona uma referência a Microsoft.ProjectOxford.Face versão 1.1.0:

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.ProjectOxford.Face" Version="1.1.0" />
    </ItemGroup>
</Project>

Nota

Para script C# (.csx), você deve definir TargetFramework como um valor de netstandard2.0. Outras estruturas de destino, como net6.0, não são suportadas.

Para usar um feed NuGet personalizado, especifique o feed em um arquivo Nuget.Config na pasta raiz do aplicativo de função. Para obter mais informações, consulte Configurando o comportamento do NuGet.

Se você estiver trabalhando em seu projeto apenas no portal, precisará criar manualmente o arquivo extensions.csproj ou um arquivo Nuget.Config diretamente no site. Para saber mais, consulte Instalar extensões manualmente.

Variáveis de ambiente

Para obter uma variável de ambiente ou um valor de configuração de aplicativo, use System.Environment.GetEnvironmentVariable, conforme mostrado no exemplo de código a seguir:

public static void Run(TimerInfo myTimer, ILogger log)
{
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
    log.LogInformation(GetEnvironmentVariable("AzureWebJobsStorage"));
    log.LogInformation(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
}

public static string GetEnvironmentVariable(string name)
{
    return name + ": " +
        System.Environment.GetEnvironmentVariable(name, EnvironmentVariableTarget.Process);
}

Repetir políticas

O Functions suporta duas políticas de repetição incorporadas. Para obter mais informações, consulte Repetir políticas.

Aqui está a política de repetição no arquivo function.json :

{
    "disabled": false,
    "bindings": [
        {
            ....
        }
    ],
    "retry": {
        "strategy": "fixedDelay",
        "maxRetryCount": 4,
        "delayInterval": "00:00:10"
    }
}
propriedade function.json Description
Estratégia fixedDelayUtilize.
maxRetryCount Obrigatório. O número máximo de tentativas permitidas por execução de função. -1 significa tentar novamente indefinidamente.
delayInterval O atraso usado entre tentativas. Especifique-o como uma cadeia de caracteres com o formato HH:mm:ss.

Vinculação em tempo de execução

Em C# e outras linguagens .NET, você pode usar um padrão de vinculação imperativa , em oposição às associações declarativas em function.json. A vinculação imperativa é útil quando os parâmetros de vinculação precisam ser calculados em tempo de execução em vez de tempo de design. Com esse padrão, você pode vincular ligações de entrada e saída suportadas on-the-fly em seu código de função.

Defina uma ligação imperativa da seguinte forma:

  • Não inclua uma entrada em function.json para suas ligações imperativas desejadas.
  • Passe um parâmetro Binder binder de entrada ou IBinder binder.
  • Use o seguinte padrão C# para executar a associação de dados.
using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))
{
    ...
}

BindingTypeAttribute é o atributo .NET que define sua associação e T é um tipo de entrada ou saída suportado por esse tipo de associação. T não pode ser um tipo de out parâmetro (como out JObject). Por exemplo, a ligação de saída da tabela Aplicativos Móveis suporta seis tipos de saída, mas você só pode usar ICollector<T> ou IAsyncCollector<T> para T.

Exemplo de atributo único

O código de exemplo a seguir cria uma ligação de saída de blob de armazenamento com caminho de blob definido em tempo de execução e, em seguida, grava uma cadeia de caracteres no blob.

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host.Bindings.Runtime;

public static async Task Run(string input, Binder binder)
{
    using (var writer = await binder.BindAsync<TextWriter>(new BlobAttribute("samples-output/path")))
    {
        writer.Write("Hello World!!");
    }
}

BlobAttribute define a ligação de entrada ou saída do blob de armazenamento e TextWriter é um tipo de ligação de saída suportado.

Exemplo de vários atributos

O exemplo anterior obtém a configuração do aplicativo para a cadeia de conexão principal da conta de armazenamento do aplicativo de função (que é AzureWebJobsStorage). Você pode especificar uma configuração de aplicativo personalizada a ser usada para a conta de armazenamento adicionando o StorageAccountAttribute e passando a matriz de atributos para BindAsync<T>(). Use um Binder parâmetro, não IBinder. Por exemplo:

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host.Bindings.Runtime;

public static async Task Run(string input, Binder binder)
{
    var attributes = new Attribute[]
    {
        new BlobAttribute("samples-output/path"),
        new StorageAccountAttribute("MyStorageAccount")
    };

    using (var writer = await binder.BindAsync<TextWriter>(attributes))
    {
        writer.Write("Hello World!");
    }
}

A tabela a seguir lista os atributos .NET para cada tipo de associação e os pacotes nos quais eles são definidos.

Enlace Atributo Adicionar referência
BD do Cosmos para o Azure Microsoft.Azure.WebJobs.DocumentDBAttribute #r "Microsoft.Azure.WebJobs.Extensions.CosmosDB"
Event Hubs Microsoft.Azure.WebJobs.ServiceBus.EventHubAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.Jobs.ServiceBus"
Aplicações Móveis Microsoft.Azure.WebJobs.MobileTableAttribute #r "Microsoft.Azure.WebJobs.Extensions.MobileApps"
Hubs de Notificação Microsoft.Azure.WebJobs.NotificationHubAttribute #r "Microsoft.Azure.WebJobs.Extensions.NotificationHubs"
Service Bus Microsoft.Azure.WebJobs.ServiceBusAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.WebJobs.ServiceBus"
Fila de armazenamento Microsoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Blob de armazenamento Microsoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Tabela de armazenamento Microsoft.Azure.WebJobs.TableAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Twilio Microsoft.Azure.WebJobs.TwilioSmsAttribute #r "Microsoft.Azure.WebJobs.Extensions.Twilio"

Converter um aplicativo de script C# em um projeto C#

A maneira mais fácil de converter um aplicativo de função de script C# em um projeto de biblioteca de classes C# compilado é começar com um novo projeto. Você pode, então, para cada função, migrar o código e a configuração de cada arquivo run.csx e function.json em uma pasta de função para um único novo arquivo de código de biblioteca de classes .cs. Por exemplo, quando você tem uma função de script C# nomeada HelloWorld , você terá dois arquivos: HelloWorld/run.csx e HelloWorld/function.json. Para essa função, você cria um arquivo de código nomeado HelloWorld.cs em seu novo projeto de biblioteca de classes.

Se você estiver usando scripts C# para edição de portal, poderá baixar o conteúdo do aplicativo para sua máquina local. Escolha a opção Conteúdo do site em vez do projeto Conteúdo e Visual Studio. Você não precisa gerar um projeto e não inclui configurações do aplicativo no download. Você está definindo um novo ambiente de desenvolvimento, e esse ambiente não deve ter as mesmas permissões que seu ambiente de aplicativo hospedado.

Estas instruções mostram como converter funções de script C# (que são executadas em processo com o host Functions) em funções de biblioteca de classes C# que são executadas em um processo de trabalho isolado.

  1. Conclua a seção Criar um projeto de aplicativo de funções no início rápido de sua preferência:

  1. Se o código de script C# original incluir um extensions.csproj arquivo ou quaisquer function.proj arquivos, copie as referências de pacote desses arquivos e adicione-as ao arquivo do novo projeto no mesmo ItemGroup com as dependências .csproj principais do Functions.

    Gorjeta

    A conversão oferece uma boa oportunidade para atualizar para as versões mais recentes de suas dependências. Isso pode exigir alterações adicionais no código em uma etapa posterior.

  2. Copie o conteúdo do arquivo original host.json para o arquivo do novo projetohost.json, exceto para a seção (projetos C# compilados não usam pacotes de extensão e você deve adicionar explicitamente referências a extensionBundles todas as extensões usadas por suas funções). Ao mesclar arquivos host.json, lembre-se de que o esquema é versionado, com a maioria dos aplicativos usando a host.json versão 2.0. O conteúdo da extensions seção pode diferir com base em versões específicas das extensões de vinculação usadas por suas funções. Consulte os artigos de referência de extensão individuais para saber como configurar corretamente o host.json para suas versões específicas.

  3. Para todos os arquivos compartilhados referenciados por uma diretiva, crie um novo .cs arquivo para cada uma #load dessas referências compartilhadas. É mais simples criar um novo .cs arquivo para cada definição de classe compartilhada. Se houver métodos estáticos sem uma classe, você precisará definir novas classes para esses métodos.

  4. Execute as seguintes tarefas para cada <FUNCTION_NAME> pasta no seu projeto original:

    1. Crie um novo arquivo chamado <FUNCTION_NAME>.cs, substituindo <FUNCTION_NAME> pelo nome da pasta que definiu sua função de script C#. Você pode criar um novo arquivo de código de função a partir de um dos modelos específicos do gatilho da seguinte maneira:

      Usando o comando e escolhendo o func new --name <FUNCTION_NAME> modelo de gatilho correto no prompt.

    2. Copie as instruções do seu run.csx arquivo e adicione-as using ao novo arquivo. Não precisa de diretivas #r .

    3. Para qualquer #load instrução em seu run.csx arquivo, adicione uma nova using instrução para o namespace que você usou para o código compartilhado.

    4. No novo arquivo, defina uma classe para sua função sob o namespace que você está usando para o projeto.

    5. Crie um novo método chamado RunHandler ou algo semelhante. Este novo método serve como o novo ponto de entrada para a função.

    6. Copie o método estático que representa sua função, juntamente com quaisquer funções que ele chama, de run.csx sua nova classe como um segundo método. A partir do novo método criado na etapa anterior, chame esse método estático. Esta etapa de indireção é útil para navegar por quaisquer diferenças à medida que você continua a atualização. Você pode manter o método original exatamente igual e simplesmente controlar suas entradas a partir do novo contexto. Talvez seja necessário criar parâmetros no novo método que, em seguida, você passa para a chamada de método estático. Depois de confirmar que a migração funcionou como pretendido, você pode remover esse nível extra de indireção.

    7. Para cada associação no function.json arquivo, adicione o atributo correspondente ao seu novo método. Para encontrar rapidamente exemplos de vinculação, consulte Adicionar associações manualmente com base em exemplos.

    8. Adicione quaisquer pacotes de extensão exigidos pelas associações ao seu projeto, se ainda não o tiver feito.

  5. Recrie todas as Values configurações do aplicativo exigidas pelo seu aplicativo na coleção do arquivo local.settings.json.

  6. Verifique se o projeto é executado localmente:

    Use func start para executar seu aplicativo a partir da linha de comando. Para obter mais informações, consulte Executar funções localmente.

  7. Publique seu projeto em um novo aplicativo de função no Azure:

    Crie seus recursos do Azure e implante o projeto de código no Azure usando o func azure functionapp publish <APP_NAME> comando. Para obter mais informações, consulte Implantar arquivos de projeto.

Exemplo de conversão de função

Esta seção mostra um exemplo da migração para uma única função.

A função original no script C# tem dois arquivos:

  • HelloWorld/function.json
  • HelloWorld/run.csx

Os conteúdos são HelloWorld/function.json :

{
  "bindings": [
    {
      "authLevel": "FUNCTION",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    }
  ]
}

Os conteúdos são HelloWorld/run.csx :

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    string responseMessage = string.IsNullOrEmpty(name)
        ? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
                : $"Hello, {name}. This HTTP triggered function executed successfully.";

            return new OkObjectResult(responseMessage);
}

Depois de migrar para o modelo de trabalho isolado com integração ASP.NET Core, eles são substituídos por um único HelloWorld.cs:

using System.Net;
using Microsoft.Azure.Functions.Worker;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

namespace MyFunctionApp
{
    public class HelloWorld
    {
        private readonly ILogger _logger;

        public HelloWorld(ILoggerFactory loggerFactory)
        {
            _logger = loggerFactory.CreateLogger<HelloWorld>();
        }

        [Function("HelloWorld")]
        public async Task<IActionResult> RunHandler([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequest req)
        {
            return await Run(req, _logger);
        }

        // From run.csx
        public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            string name = req.Query["name"];

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            dynamic data = JsonConvert.DeserializeObject(requestBody);
            name = name ?? data?.name;

            string responseMessage = string.IsNullOrEmpty(name)
                ? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
                        : $"Hello, {name}. This HTTP triggered function executed successfully.";

            return new OkObjectResult(responseMessage);
        }
    }
}

Configuração de vinculação e exemplos

Esta seção contém referências e exemplos para definir gatilhos e associações no script C#.

Blob trigger

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como blobTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direção Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável que representa o blob no código da função.
path O recipiente a monitorizar. Pode ser um padrão de nome de blob.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Blobs do Azure. Consulte Conexões.

O exemplo a seguir mostra uma definição de gatilho de blob em um arquivo function.json e código que usa a ligação. A função grava um log quando um blob é adicionado ou atualizado no samples-workitemscontêiner.

Aqui estão os dados de ligação no arquivo function.json :

{
    "disabled": false,
    "bindings": [
        {
            "name": "myBlob",
            "type": "blobTrigger",
            "direction": "in",
            "path": "samples-workitems/{name}",
            "connection":"MyStorageAccountAppSetting"
        }
    ]
}

A cadeia de caracteres no caminho samples-workitems/{name} do gatilho de blob cria uma expressão de vinculação que você pode usar no código da função para acessar o nome do arquivo do blob de {name} acionamento. Para obter mais informações, consulte Padrões de nome de blob.

Aqui está o código de script C# que se liga a um Stream:

public static void Run(Stream myBlob, string name, ILogger log)
{
   log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
}

Aqui está o código de script C# que se liga a um CloudBlockBlob:

#r "Microsoft.WindowsAzure.Storage"

using Microsoft.WindowsAzure.Storage.Blob;

public static void Run(CloudBlockBlob myBlob, string name, ILogger log)
{
    log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name}\nURI:{myBlob.StorageUri}");
}

Entrada de Blob

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como blob.
direção Deve ser definido como in.
Designação O nome da variável que representa o blob no código da função.
path O caminho para o blob.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Blobs do Azure. Consulte Conexões.

O exemplo a seguir mostra associações de entrada e saída de blob em um arquivo function.json e código de script C# que usa as associações. A função faz uma cópia de um blob de texto. A função é acionada por uma mensagem de fila que contém o nome do blob a ser copiado. O novo blob é chamado {originalblobname}-Copy.

No arquivo function.json, a queueTrigger propriedade metadata é usada para especificar o nome do blob nas path propriedades:

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "myInputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    },
    {
      "name": "myOutputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}-Copy",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "out"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

public static void Run(string myQueueItem, string myInputBlob, out string myOutputBlob, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
    myOutputBlob = myInputBlob;
}

Saída de Blob

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como blob.
direção Deve ser definido como out.
Designação O nome da variável que representa o blob no código da função.
path O caminho para o blob.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Blobs do Azure. Consulte Conexões.

O exemplo a seguir mostra associações de entrada e saída de blob em um arquivo function.json e código de script C# que usa as associações. A função faz uma cópia de um blob de texto. A função é acionada por uma mensagem de fila que contém o nome do blob a ser copiado. O novo blob é chamado {originalblobname}-Copy.

No arquivo function.json, a queueTrigger propriedade metadata é usada para especificar o nome do blob nas path propriedades:

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "myInputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    },
    {
      "name": "myOutputBlob",
      "type": "blob",
      "path": "samples-workitems/{queueTrigger}-Copy",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "out"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

public static void Run(string myQueueItem, string myInputBlob, out string myOutputBlob, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
    myOutputBlob = myInputBlob;
}

Gatilho RabbitMQ

O exemplo a seguir mostra uma ligação de gatilho RabbitMQ em um arquivo function.json e uma função de script C# que usa a ligação. A função lê e registra a mensagem RabbitMQ.

Aqui estão os dados de ligação no arquivo function.json :

{​​
    "bindings": [
        {​​
            "name": "myQueueItem",
            "type": "rabbitMQTrigger",
            "direction": "in",
            "queueName": "queue",
            "connectionStringSetting": "rabbitMQConnectionAppSetting"
        }​​
    ]
}​​

Aqui está o código de script C#:

using System;

public static void Run(string myQueueItem, ILogger log)
{​​
    log.LogInformation($"C# Script RabbitMQ trigger function processed: {​​myQueueItem}​​");
}​​

Queue trigger

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como queueTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direção Somente no arquivo function.json . Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável que contém a carga útil do item de fila no código da função.
queueName O nome da fila a ser pesquisada.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar às Filas do Azure. Consulte Conexões.

O exemplo a seguir mostra uma ligação de gatilho de fila em um arquivo function.json e código de script C# que usa a ligação. A função sonda a fila e grava um log cada vez que um item de fila myqueue-items é processado.

Aqui está o arquivo function.json :

{
    "disabled": false,
    "bindings": [
        {
            "type": "queueTrigger",
            "direction": "in",
            "name": "myQueueItem",
            "queueName": "myqueue-items",
            "connection":"MyStorageConnectionAppSetting"
        }
    ]
}

Aqui está o código de script C#:

#r "Microsoft.WindowsAzure.Storage"

using Microsoft.Extensions.Logging;
using Microsoft.WindowsAzure.Storage.Queue;
using System;

public static void Run(CloudQueueMessage myQueueItem, 
    DateTimeOffset expirationTime, 
    DateTimeOffset insertionTime, 
    DateTimeOffset nextVisibleTime,
    string queueTrigger,
    string id,
    string popReceipt,
    int dequeueCount,
    ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem.AsString}\n" +
        $"queueTrigger={queueTrigger}\n" +
        $"expirationTime={expirationTime}\n" +
        $"insertionTime={insertionTime}\n" +
        $"nextVisibleTime={nextVisibleTime}\n" +
        $"id={id}\n" +
        $"popReceipt={popReceipt}\n" + 
        $"dequeueCount={dequeueCount}");
}

Saída da fila

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como queue. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direção Deve ser definido como out. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável que representa a fila no código da função. Defina como $return para fazer referência ao valor de retorno da função.
queueName O nome da fila.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar às Filas do Azure. Consulte Conexões.

O exemplo a seguir mostra uma ligação de gatilho HTTP em um arquivo function.json e código de script C# que usa a ligação. A função cria um item de fila com uma carga útil do objeto CustomQueueMessage para cada solicitação HTTP recebida.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "authLevel": "function",
      "name": "input"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "$return",
      "queueName": "outqueue",
      "connection": "MyStorageConnectionAppSetting"
    }
  ]
}

Aqui está o código de script C# que cria uma única mensagem de fila:

public class CustomQueueMessage
{
    public string PersonName { get; set; }
    public string Title { get; set; }
}

public static CustomQueueMessage Run(CustomQueueMessage input, ILogger log)
{
    return input;
}

Você pode enviar várias mensagens de uma só vez usando um ICollector parâmetro ou IAsyncCollector . Aqui está o código de script C# que envia várias mensagens, uma com os dados de solicitação HTTP e outra com valores codificados:

public static void Run(
    CustomQueueMessage input, 
    ICollector<CustomQueueMessage> myQueueItems, 
    ILogger log)
{
    myQueueItems.Add(input);
    myQueueItems.Add(new CustomQueueMessage { PersonName = "You", Title = "None" });
}

Entrada de tabela

Esta seção descreve o suporte apenas para a versão da API de tabelas da extensão .

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como table. Essa propriedade é definida automaticamente quando você cria a associação no portal do Azure.
direção Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria a associação no portal do Azure.
Designação O nome da variável que representa a tabela ou entidade no código da função.
nome_da_tabela O nome da tabela.
partitionKey Opcional. A chave de partição da entidade da tabela a ser lida.
rowKey [en] Opcional. A chave de linha da entidade da tabela a ser lida. Não pode ser usado com take ou filter.
tomar Opcional. O número máximo de entidades a devolver. Não pode ser usado com rowKey.
filter Opcional. Uma expressão de filtro OData para as entidades retornarem da tabela. Não pode ser usado com rowKey.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar ao serviço de tabela. Consulte Conexões.

O exemplo a seguir mostra uma associação de entrada de tabela em um arquivo function.json e código de script C# que usa a ligação. A função usa um gatilho de fila para ler uma única linha de tabela.

O arquivo function.json especifica a e a rowKeypartitionKey . O rowKey valor {queueTrigger} indica que a chave de linha vem da cadeia de caracteres de mensagem da fila.

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "personEntity",
      "type": "table",
      "tableName": "Person",
      "partitionKey": "Test",
      "rowKey": "{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

#r "Azure.Data.Tables"
using Microsoft.Extensions.Logging;
using Azure.Data.Tables;

public static void Run(string myQueueItem, Person personEntity, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
    log.LogInformation($"Name in Person entity: {personEntity.Name}");
}

public class Person : ITableEntity
{
    public string Name { get; set; }

    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }
}

Saída da tabela

Esta seção descreve o suporte apenas para a versão da API de tabelas da extensão .

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como table. Essa propriedade é definida automaticamente quando você cria a associação no portal do Azure.
direção Deve ser definido como out. Essa propriedade é definida automaticamente quando você cria a associação no portal do Azure.
Designação O nome da variável usada no código da função que representa a tabela ou entidade. Defina como $return para fazer referência ao valor de retorno da função.
nome_da_tabela O nome da tabela na qual escrever.
partitionKey A chave de partição da entidade da tabela a ser gravada.
rowKey [en] A chave de linha da entidade da tabela a ser gravada.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar ao serviço de tabela. Consulte Conexões.

O exemplo a seguir mostra uma ligação de saída de tabela em um arquivo function.json e código de script C# que usa a ligação. A função grava várias entidades de tabela.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "name": "input",
      "type": "manualTrigger",
      "direction": "in"
    },
    {
      "tableName": "Person",
      "connection": "MyStorageConnectionAppSetting",
      "name": "tableBinding",
      "type": "table",
      "direction": "out"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

public static void Run(string input, ICollector<Person> tableBinding, ILogger log)
{
    for (int i = 1; i < 10; i++)
        {
            log.LogInformation($"Adding Person entity {i}");
            tableBinding.Add(
                new Person() { 
                    PartitionKey = "Test", 
                    RowKey = i.ToString(), 
                    Name = "Name" + i.ToString() }
                );
        }

}

public class Person
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public string Name { get; set; }
}

Acionador de temporizador

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como timerTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direção Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável que representa o objeto de temporizador no código da função.
schedule Uma expressão CRON ou um valor TimeSpan . A TimeSpan só pode ser usado para um aplicativo de função executado em um Plano do Serviço de Aplicativo. Você pode colocar a expressão de agenda em uma configuração de aplicativo e definir essa propriedade como o nome da configuração do aplicativo encapsulado em % sinais, como neste exemplo: "%ScheduleAppSetting%".
runOnStartup Se true, a função é invocada quando o tempo de execução é iniciado. Por exemplo, o runtime começa quando a aplicação de funções é reativada depois de ficar inativa devido a inatividade. quando o aplicativo de função é reiniciado devido a alterações de função e quando o aplicativo de função é dimensionado. Use com cuidado.runOnStartup raramente ou nunca deve ser definido como true, especialmente em produção.
usarMonitor Defina como true ou false para indicar se o agendamento deve ser monitorizado. A monitorização do agendamento guarda as ocorrências para ajudar a garantir que o agendamento é mantido corretamente, mesmo quando as instâncias da aplicação de funções são reiniciadas. Se não for definido explicitamente, o padrão é true para agendas que têm um intervalo de recorrência maior ou igual a 1 minuto. Para agendas que são acionadas mais de uma vez por minuto, o padrão é false.

O exemplo a seguir mostra uma ligação de gatilho de temporizador em um arquivo function.json e uma função de script C# que usa a ligação. A função grava um log indicando se essa invocação de função é devido a uma ocorrência de agenda perdida. O TimerInfo objeto é passado para a função.

Aqui estão os dados de ligação no arquivo function.json :

{
    "schedule": "0 */5 * * * *",
    "name": "myTimer",
    "type": "timerTrigger",
    "direction": "in"
}

Aqui está o código de script C#:

public static void Run(TimerInfo myTimer, ILogger log)
{
    if (myTimer.IsPastDue)
    {
        log.LogInformation("Timer is running late!");
    }
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}" );  
}

Acionador HTTP

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

propriedade function.json Description
tipo Obrigatório - deve ser definido como httpTrigger.
direção Obrigatório - deve ser definido como in.
Designação Obrigatório - o nome da variável usado no código de função para a solicitação ou corpo da solicitação.
authLevel Determina quais chaves, se houver, precisam estar presentes na solicitação para invocar a função. Para obter os valores suportados, consulte Nível de autorização.
Metodologia Uma matriz dos métodos HTTP aos quais a função responde. Se não for especificada, a função responde a todos os métodos HTTP. Consulte personalizar o ponto de extremidade HTTP.
Percurso Define o modelo de rota, controlando a quais URLs de solicitação sua função responde. O valor padrão, se nenhum for fornecido, é <functionname>. Para obter mais informações, consulte personalizar o ponto de extremidade HTTP.
webHookType Suportado apenas para o tempo de execução da versão 1.x.

Configura o gatilho HTTP para atuar como um recetor webhook para o provedor especificado. Para valores suportados, consulte Tipo de WebHook.

O exemplo a seguir mostra uma ligação de gatilho em um arquivo function.json e uma função de script C# que usa a ligação. A função procura um name parâmetro na cadeia de caracteres de consulta ou no corpo da solicitação HTTP.

Aqui está o arquivo function.json :

{
    "disabled": false,
    "bindings": [
        {
            "authLevel": "function",
            "name": "req",
            "type": "httpTrigger",
            "direction": "in",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "name": "$return",
            "type": "http",
            "direction": "out"
        }
    ]
}

Aqui está o código de script C# que se liga a HttpRequest:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];
    
    string requestBody = String.Empty;
    using (StreamReader streamReader =  new  StreamReader(req.Body))
    {
        requestBody = await streamReader.ReadToEndAsync();
    }
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;
    
    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

Você pode vincular a um objeto personalizado em vez de HttpRequest. Este objeto é criado a partir do corpo da solicitação e analisado como JSON. Da mesma forma, um tipo pode ser passado para a ligação de saída de resposta HTTP e retornado como o corpo da resposta, juntamente com um código de 200 status.

using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static string Run(Person person, ILogger log)
{   
    return person.Name != null
        ? (ActionResult)new OkObjectResult($"Hello, {person.Name}")
        : new BadRequestObjectResult("Please pass an instance of Person.");
}

public class Person {
     public string Name {get; set;}
}

Saída HTTP

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

Property Descrição
tipo Deve ser definido como http.
direção Deve ser definido como out.
Designação O nome da variável usado no código de função para a resposta ou $return para usar o valor de retorno.

Os Hubs de Eventos disparam

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

propriedade function.json Description
tipo Deve ser definido como eventHubTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direção Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável que representa o item de evento no código de função.
eventHubName Funções 2.x e superiores. O nome do hub de eventos. Quando o nome do hub de eventos também está presente na cadeia de conexão, esse valor substitui essa propriedade no tempo de execução. Pode ser referenciado através das configurações do%eventHubName% aplicativo. Na versão 1.x, esta propriedade é denominada path.
Grupo de consumidores Uma propriedade opcional que define o grupo de consumidores usado para se inscrever em eventos no hub. Em caso de omissão, utiliza-se o grupo de $Default consumidores.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar a Hubs de Eventos. Consulte Conexões.

O exemplo a seguir mostra uma ligação de gatilho de Hubs de Eventos em um arquivo function.json e uma função de script C# que usa a ligação. A função registra o corpo da mensagem do gatilho Hubs de Eventos.

Os exemplos a seguir mostram dados de vinculação de Hubs de Eventos no arquivo function.json para o tempo de execução do Functions versão 2.x e versões posteriores.

{
  "type": "eventHubTrigger",
  "name": "myEventHubMessage",
  "direction": "in",
  "eventHubName": "MyEventHub",
  "connection": "myEventHubReadConnectionAppSetting"
}

Aqui está o código de script C#:

using System;

public static void Run(string myEventHubMessage, TraceWriter log)
{
    log.Info($"C# function triggered to process a message: {myEventHubMessage}");
}

Para obter acesso aos metadados do evento no código da função, associe-se a um objeto EventData . Você também pode acessar as mesmas propriedades usando expressões de associação na assinatura do método. O exemplo a seguir mostra as duas maneiras de obter os mesmos dados:

#r "Microsoft.Azure.EventHubs"

using System.Text;
using System;
using Microsoft.ServiceBus.Messaging;
using Microsoft.Azure.EventHubs;

public void Run(EventData myEventHubMessage,
    DateTime enqueuedTimeUtc,
    Int64 sequenceNumber,
    string offset,
    TraceWriter log)
{
    log.Info($"Event: {Encoding.UTF8.GetString(myEventHubMessage.Body)}");
    log.Info($"EnqueuedTimeUtc={myEventHubMessage.SystemProperties.EnqueuedTimeUtc}");
    log.Info($"SequenceNumber={myEventHubMessage.SystemProperties.SequenceNumber}");
    log.Info($"Offset={myEventHubMessage.SystemProperties.Offset}");

    // Metadata accessed by using binding expressions
    log.Info($"EnqueuedTimeUtc={enqueuedTimeUtc}");
    log.Info($"SequenceNumber={sequenceNumber}");
    log.Info($"Offset={offset}");
}

Para receber eventos em um lote, marca string ou EventData matriz:

public static void Run(string[] eventHubMessages, TraceWriter log)
{
    foreach (var message in eventHubMessages)
    {
        log.Info($"C# function triggered to process a message: {message}");
    }
}

Saída de Hubs de Eventos

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

propriedade function.json Description
tipo Deve ser definido como eventHub.
direção Deve ser definido como out. Esse parâmetro é definido automaticamente quando você cria a associação no portal do Azure.
Designação O nome da variável usada no código da função que representa o evento.
eventHubName Funções 2.x e superiores. O nome do hub de eventos. Quando o nome do hub de eventos também está presente na cadeia de conexão, esse valor substitui essa propriedade no tempo de execução. Em Functions 1.x, esta propriedade é denominada path.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar a Hubs de Eventos. Para saber mais, consulte Conexões.

O exemplo a seguir mostra uma ligação de gatilho de hub de eventos em um arquivo function.json e uma função de script C# que usa a ligação. A função grava uma mensagem em um hub de eventos.

Os exemplos a seguir mostram dados de vinculação de Hubs de Eventos no arquivo function.json para o tempo de execução do Functions versão 2.x e versões posteriores.

{
    "type": "eventHub",
    "name": "outputEventHubMessage",
    "eventHubName": "myeventhub",
    "connection": "MyEventHubSendAppSetting",
    "direction": "out"
}

Aqui está o código de script C# que cria uma mensagem:

using System;
using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, out string outputEventHubMessage, ILogger log)
{
    String msg = $"TimerTriggerCSharp1 executed at: {DateTime.Now}";
    log.LogInformation(msg);   
    outputEventHubMessage = msg;
}

Aqui está o código de script C# que cria várias mensagens:

public static void Run(TimerInfo myTimer, ICollector<string> outputEventHubMessage, ILogger log)
{
    string message = $"Message created at: {DateTime.Now}";
    log.LogInformation(message);
    outputEventHubMessage.Add("1 " + message);
    outputEventHubMessage.Add("2 " + message);
}

Event Grid trigger

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json . Não há parâmetros ou propriedades do construtor para definir no EventGridTrigger atributo.

propriedade function.json Description
tipo Obrigatório - deve ser definido como eventGridTrigger.
direção Obrigatório - deve ser definido como in.
Designação Obrigatório - o nome da variável usada no código de função para o parâmetro que recebe os dados do evento.

O exemplo a seguir mostra um gatilho Event Grid definido no arquivo function.json .

Aqui estão os dados de ligação no arquivo function.json :

{
  "bindings": [
    {
      "type": "eventGridTrigger",
      "name": "eventGridEvent",
      "direction": "in"
    }
  ],
  "disabled": false
}

Aqui está um exemplo de uma função de script C# que usa um EventGridEvent parâmetro de ligação:

#r "Azure.Messaging.EventGrid"
using Azure.Messaging.EventGrid;
using Microsoft.Extensions.Logging;

public static void Run(EventGridEvent eventGridEvent, ILogger log)
{
    log.LogInformation(eventGridEvent.Data.ToString());
}

Aqui está um exemplo de uma função de script C# que usa um JObject parâmetro de ligação:

#r "Newtonsoft.Json"

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public static void Run(JObject eventGridEvent, TraceWriter log)
{
    log.Info(eventGridEvent.ToString(Formatting.Indented));
}

Saída da grade de eventos

A tabela a seguir explica as propriedades de configuração de vinculação para script C# que você definiu no arquivo function.json .

propriedade function.json Description
tipo Deve ser definido como eventGrid.
direção Deve ser definido como out. Esse parâmetro é definido automaticamente quando você cria a associação no portal do Azure.
Designação O nome da variável usada no código da função que representa o evento.
tópicoEndpointUri O nome de uma configuração de aplicativo que contém o URI do tópico personalizado, como MyTopicEndpointUri.
topicKeySetting O nome de uma configuração de aplicativo que contém uma chave de acesso para o tópico personalizado.

O exemplo a seguir mostra os dados de vinculação de saída da Grade de Eventos no arquivo function.json .

{
    "type": "eventGrid",
    "name": "outputEvent",
    "topicEndpointUri": "MyEventGridTopicUriSetting",
    "topicKeySetting": "MyEventGridTopicKeySetting",
    "direction": "out"
}

Aqui está o código de script C# que cria um evento:

#r "Microsoft.Azure.EventGrid"
using System;
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, out EventGridEvent outputEvent, ILogger log)
{
    outputEvent = new EventGridEvent("message-id", "subject-name", "event-data", "event-type", DateTime.UtcNow, "1.0");
}

Aqui está o código de script C# que cria vários eventos:

#r "Microsoft.Azure.EventGrid"
using System;
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, ICollector<EventGridEvent> outputEvent, ILogger log)
{
    outputEvent.Add(new EventGridEvent("message-id-1", "subject-name", "event-data", "event-type", DateTime.UtcNow, "1.0"));
    outputEvent.Add(new EventGridEvent("message-id-2", "subject-name", "event-data", "event-type", DateTime.UtcNow, "1.0"));
}

Gatilho do Service Bus

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

propriedade function.json Description
tipo Deve ser definido como serviceBusTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direção Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável que representa a fila ou a mensagem de tópico no código da função.
queueName Nome da fila a monitorar. Defina somente se estiver monitorando uma fila, não para um tópico.
nome_tópico Nome do tópico a monitorar. Defina somente se estiver monitorando um tópico, não para uma fila.
nome_do-assinante Nome da subscrição a monitorizar. Defina somente se estiver monitorando um tópico, não para uma fila.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar ao Service Bus. Consulte Conexões.
Direitos de acesso Direitos de acesso para a cadeia de conexão. Os valores disponíveis são manage e listen. O padrão é manage, que indica que o connection tem a permissão Gerenciar . Se você usar uma cadeia de conexão que não tenha a permissão Gerenciar , defina accessRights como "ouvir". Caso contrário, o tempo de execução do Functions pode falhar ao tentar fazer operações que exigem direitos de gerenciamento. No Azure Functions versão 2.x e superior, essa propriedade não está disponível porque a versão mais recente do SDK do Service Bus não oferece suporte a operações de gerenciamento.
isSessionsEnabled true se estiver se conectando a uma fila ou assinatura com reconhecimento de sessão. false caso contrário, que é o valor padrão.
Preenchimento automático true Quando o gatilho deve chamar automaticamente Complete após o processamento, ou se o código da função chamará manualmente Complete.

A configuração como false só é suportada em C#.

Se definido como true, o gatilho conclui a mensagem automaticamente se a execução da função for concluída com êxito e abandona a mensagem caso contrário.
<br/Quando definido como false, você é responsável por chamar os métodos ServiceBusReceiver para completar, abandonar ou fazer deadletter na mensagem, sessão ou lote. Quando uma exceção é lançada (e nenhum dos ServiceBusReceiver métodos é chamado), o bloqueio permanece. Quando o bloqueio expirar, a mensagem é novamente enfileirada com o incrementado e o bloqueio é renovado DeliveryCount automaticamente.

Esta propriedade está disponível apenas no Azure Functions 2.x e superior.

O exemplo a seguir mostra uma ligação de gatilho do Service Bus em um arquivo function.json e uma função de script C# que usa a ligação. A função lê metadados de mensagem e registra uma mensagem de fila do Service Bus.

Aqui estão os dados de ligação no arquivo function.json :

{
"bindings": [
    {
    "queueName": "testqueue",
    "connection": "MyServiceBusConnection",
    "name": "myQueueItem",
    "type": "serviceBusTrigger",
    "direction": "in"
    }
],
"disabled": false
}

Aqui está o código de script C#:

using System;

public static void Run(string myQueueItem,
    Int32 deliveryCount,
    DateTime enqueuedTimeUtc,
    string messageId,
    TraceWriter log)
{
    log.Info($"C# ServiceBus queue trigger function processed message: {myQueueItem}");

    log.Info($"EnqueuedTimeUtc={enqueuedTimeUtc}");
    log.Info($"DeliveryCount={deliveryCount}");
    log.Info($"MessageId={messageId}");
}

Saída do Service Bus

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

propriedade function.json Description
tipo Deve ser definido como serviceBus. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direção Deve ser definido como out. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável que representa a fila ou a mensagem de tópico no código da função. Defina como "$return" para fazer referência ao valor de retorno da função.
queueName Nome da fila. Defina apenas se enviar mensagens de fila, não para um tópico.
nome_tópico Nome do tópico. Defina somente se estiver enviando mensagens de tópico, não para uma fila.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar ao Service Bus. Consulte Conexões.
accessRights (apenas v1) Direitos de acesso para a cadeia de conexão. Os valores disponíveis são manage e listen. O padrão é manage, que indica que o connection tem a permissão Gerenciar . Se você usar uma cadeia de conexão que não tenha a permissão Gerenciar , defina accessRights como "ouvir". Caso contrário, o tempo de execução do Functions pode falhar ao tentar fazer operações que exigem direitos de gerenciamento. No Azure Functions versão 2.x e superior, essa propriedade não está disponível porque a versão mais recente do SDK do Service Bus não oferece suporte a operações de gerenciamento.

O exemplo a seguir mostra uma ligação de saída do Service Bus em um arquivo function.json e uma função de script C# que usa a ligação. A função usa um gatilho de temporizador para enviar uma mensagem de fila a cada 15 segundos.

Aqui estão os dados de ligação no arquivo function.json :

{
    "bindings": [
        {
            "schedule": "0/15 * * * * *",
            "name": "myTimer",
            "runsOnStartup": true,
            "type": "timerTrigger",
            "direction": "in"
        },
        {
            "name": "outputSbQueue",
            "type": "serviceBus",
            "queueName": "testqueue",
            "connection": "MyServiceBusConnection",
            "direction": "out"
        }
    ],
    "disabled": false
}

Aqui está o código de script C# que cria uma única mensagem:

public static void Run(TimerInfo myTimer, ILogger log, out string outputSbQueue)
{
    string message = $"Service Bus queue message created at: {DateTime.Now}";
    log.LogInformation(message); 
    outputSbQueue = message;
}

Aqui está o código de script C# que cria várias mensagens:

public static async Task Run(TimerInfo myTimer, ILogger log, IAsyncCollector<string> outputSbQueue)
{
    string message = $"Service Bus queue messages created at: {DateTime.Now}";
    log.LogInformation(message); 
    await outputSbQueue.AddAsync("1 " + message);
    await outputSbQueue.AddAsync("2 " + message);
}

Gatilho do Azure Cosmos DB v2

Esta seção descreve o suporte apenas para a versão 4.x+ da extensão .

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

propriedade function.json Description
tipo Deve ser definido como cosmosDBTrigger.
direção Deve ser definido como in. Esse parâmetro é definido automaticamente quando você cria o gatilho no portal do Azure.
Designação O nome da variável usada no código da função que representa a lista de documentos com alterações.
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar à conta do Azure Cosmos DB que está sendo monitorada. Para obter mais informações, consulte Conexões.
Nome do banco de dados O nome do banco de dados do Azure Cosmos DB com o contêiner sendo monitorado.
containerName O nome do contêiner que está sendo monitorado.
arrendarConexão (Opcional) O nome de uma configuração de aplicativo ou contêiner de configuração que especifica como se conectar à conta do Azure Cosmos DB que contém o contêiner de concessão.

Quando não definido, o connection valor é usado. Este parâmetro é definido automaticamente quando a ligação é criada no portal. A cadeia de conexão para o contêiner de concessões deve ter permissões de gravação.
leaseDatabaseName (Opcional) O nome do banco de dados que contém o contêiner usado para armazenar concessões . Quando não está definido, o databaseName valor da configuração é usado.
leaseContainerName (Opcional) O nome do contêiner usado para armazenar locações. Quando não definido, o valor leases é usado.
createLeaseContainerIfNotExists (Opcional) Quando definido como true, o contêiner de concessões é criado automaticamente quando ainda não existe. O valor predefinido é false. Ao usar identidades do Microsoft Entra, se você definir o valor como true, a criação de contêineres não é uma operação permitida e sua Função não poderá ser iniciada.
leasesContainerThroughput (Opcional) Define o número de Unidades de Solicitação a serem atribuídas quando o contêiner de concessões é criado. Essa configuração só é usada quando createLeaseContainerIfNotExists está definida como true. Este parâmetro é definido automaticamente quando a associação é criada usando o portal.
leaseContainerPrefix (Opcional) Quando definido, o valor é adicionado como um prefixo às concessões criadas no contêiner Lease para essa função. O uso de um prefixo permite que duas Funções do Azure separadas compartilhem o mesmo contêiner de Concessão usando prefixos diferentes.
feedPollDelay (Opcional) O tempo (em milissegundos) para o atraso entre a sondagem de uma partição para novas alterações no feed, depois que todas as alterações atuais são drenadas. O padrão é 5.000 milissegundos ou 5 segundos.
leaseAcquireInterval (Opcional) Quando definido, ele define, em milissegundos, o intervalo para iniciar uma tarefa para calcular se as partições são distribuídas uniformemente entre instâncias de host conhecidas. O padrão é 13000 (13 segundos).
leaseExpirationInterval (Opcional) Quando definido, ele define, em milissegundos, o intervalo para o qual a concessão é tomada em uma concessão que representa uma partição. Se a concessão não for renovada dentro desse intervalo, ela expirará e a propriedade da partição será movida para outra instância. O padrão é 60000 (60 segundos).
leaseRenewInterval (Opcional) Quando definido, ele define, em milissegundos, o intervalo de renovação para todas as concessões de partições atualmente mantidas por uma instância. O padrão é 17000 (17 segundos).
maxItemsPerInvocation (Opcional) Quando definida, essa propriedade define o número máximo de itens recebidos por chamada de função. Se as operações no contêiner monitorado forem executadas por meio de procedimentos armazenados, o escopo da transação será preservado ao ler itens do feed de alterações. Como resultado, o número de itens recebidos pode ser maior do que o valor especificado para que os itens alterados pela mesma transação sejam retornados como parte de um lote atômico.
startFromBeginning (Opcional) Essa opção informa ao Gatilho para ler as alterações desde o início do histórico de alterações do contêiner em vez de começar no momento atual. A leitura desde o início só funciona na primeira vez que o gatilho é iniciado, pois nas execuções subsequentes, os pontos de verificação já estão armazenados. Definir essa opção para true quando houver concessões já criadas não terá efeito.
startFromTime (Opcional) Obtém ou define a data e a hora a partir das quais inicializar a operação de leitura do feed de alterações. O formato recomendado é ISO 8601 com o designador UTC, como 2021-02-16T14:19:29Z. Isso é usado apenas para definir o estado inicial do gatilho. Depois que o gatilho tiver um estado de concessão, alterar esse valor não terá efeito.
preferredLocations (Opcional) Define locais preferenciais (regiões) para contas de banco de dados replicadas geograficamente no serviço Azure Cosmos DB. Os valores devem ser separados por vírgula. Por exemplo, "Leste dos EUA, Centro-Sul dos EUA, Norte da Europa".

O exemplo a seguir mostra uma ligação de gatilho do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a ligação. A função grava mensagens de log quando os registros do Azure Cosmos DB são adicionados ou modificados.

Aqui estão os dados de ligação no arquivo function.json :

{
    "type": "cosmosDBTrigger",
    "name": "documents",
    "direction": "in",
    "leaseContainerName": "leases",
    "connection": "<connection-app-setting>",
    "databaseName": "Tasks",
    "containerName": "Items",
    "createLeaseContainerIfNotExists": true
}

Aqui está o código de script C#:

    using System;
    using System.Collections.Generic;
    using Microsoft.Extensions.Logging;

    // Customize the model with your own desired properties
    public class ToDoItem
    {
        public string id { get; set; }
        public string Description { get; set; }
    }

    public static void Run(IReadOnlyList<ToDoItem> documents, ILogger log)
    {
      log.LogInformation("Documents modified " + documents.Count);
      log.LogInformation("First document Id " + documents[0].id);
    }

Entrada do Azure Cosmos DB v2

Esta seção descreve o suporte apenas para a versão 4.x+ da extensão .

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

propriedade function.json Description
tipo Deve ser definido como cosmosDB.
direção Deve ser definido como in.
Designação O nome da variável usada no código da função que representa a lista de documentos com alterações.
conexão O nome de uma configuração de aplicativo ou contêiner de configuração que especifica como se conectar à conta do Azure Cosmos DB que está sendo monitorada. Para obter mais informações, consulte Conexões.
Nome do banco de dados O nome do banco de dados do Azure Cosmos DB com o contêiner sendo monitorado.
containerName O nome do contêiner que está sendo monitorado.
partitionKey Especifica o valor da chave de partição para a pesquisa. Pode incluir parâmetros de vinculação. É necessário para pesquisas em contêineres particionados .
id A ID do documento a ser recuperado. Esta propriedade suporta expressões de ligação. Não defina as id propriedades e sqlQuery . Se você não definir nenhum deles, todo o contêiner será recuperado.
sqlQuery Uma consulta SQL do Azure Cosmos DB usada para recuperar vários documentos. A propriedade suporta associações de tempo de execução, como neste exemplo: SELECT * FROM c where c.departmentId = {departmentId}. Não defina as id propriedades e sqlQuery . Se você não definir nenhum deles, todo o contêiner será recuperado.
preferredLocations (Opcional) Define locais preferenciais (regiões) para contas de banco de dados replicadas geograficamente no serviço Azure Cosmos DB. Os valores devem ser separados por vírgula. Por exemplo, East US,South Central US,North Europe.

Esta seção contém os seguintes exemplos:

Os exemplos de gatilho HTTP referem-se a um tipo simples ToDoItem :

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Gatilho de fila, procurar ID da string

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função lê um único documento e atualiza o valor de texto do documento.

Aqui estão os dados de ligação no arquivo function.json :

{
    "name": "inputDocument",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger}",
    "partitionKey": "{partition key value}",
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "in"
}

Aqui está o código de script C#:

    using System;

    // Change input document contents using Azure Cosmos DB input binding
    public static void Run(string myQueueItem, dynamic inputDocument)
    {
      inputDocument.text = "This has changed.";
    }

Gatilho de fila, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função recupera vários documentos especificados por uma consulta SQL, usando um gatilho de fila para personalizar os parâmetros de consulta.

O gatilho de fila fornece um parâmetro departmentId. Uma mensagem de fila de { "departmentId" : "Finance" } retornaria todos os registros para o departamento financeiro.

Aqui estão os dados de ligação no arquivo function.json :

{
    "name": "documents",
    "type": "cosmosDB",
    "direction": "in",
    "databaseName": "MyDb",
    "collectionName": "MyCollection",
    "sqlQuery": "SELECT * from c where c.departmentId = {departmentId}",
    "connectionStringSetting": "CosmosDBConnection"
}

Aqui está o código de script C#:

    public static void Run(QueuePayload myQueueItem, IEnumerable<dynamic> documents)
    {
        foreach (var doc in documents)
        {
            // operate on each document
        }
    }

    public class QueuePayload
    {
        public string departmentId { get; set; }
    }

Gatilho HTTP, ID de pesquisa da cadeia de caracteres de consulta

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar o ID e o valor da chave de partição a serem pesquisados. Esse ID e o valor da chave de partição são usados para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "Id": "{Query.id}",
      "PartitionKey" : "{Query.partitionKeyValue}"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

using System.Net;
using Microsoft.Extensions.Logging;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
         log.LogInformation($"ToDo item not found");
    }
    else
    {
        log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Gatilho HTTP, procure ID a partir de dados de rota

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por uma solicitação HTTP que usa dados de rota para especificar o ID e o valor da chave de partição a serem pesquisados. Esse ID e o valor da chave de partição são usados para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ],
      "route":"todoitems/{partitionKeyValue}/{id}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "id": "{id}",
      "partitionKey": "{partitionKeyValue}"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

using System.Net;
using Microsoft.Extensions.Logging;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
         log.LogInformation($"ToDo item not found");
    }
    else
    {
        log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP trigger, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. A consulta é especificada na SqlQuery propriedade atributo.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItems",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "in",
      "sqlQuery": "SELECT top 2 * FROM c order by c._ts desc"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

using System.Net;
using Microsoft.Extensions.Logging;

public static HttpResponseMessage Run(HttpRequestMessage req, IEnumerable<ToDoItem> toDoItems, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    foreach (ToDoItem toDoItem in toDoItems)
    {
        log.LogInformation(toDoItem.Description);
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Gatilho HTTP, obtenha vários documentos, usando DocumentClient

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. O código usa uma instância fornecida pela associação do Azure Cosmos DB para ler uma DocumentClient lista de documentos. A DocumentClient instância também pode ser usada para operações de gravação.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "cosmosDB",
      "name": "client",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "inout"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

#r "Microsoft.Azure.Documents.Client"

using System.Net;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Microsoft.Extensions.Logging;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, DocumentClient client, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    Uri collectionUri = UriFactory.CreateDocumentCollectionUri("ToDoItems", "Items");
    string searchterm = req.GetQueryNameValuePairs()
        .FirstOrDefault(q => string.Compare(q.Key, "searchterm", true) == 0)
        .Value;

    if (searchterm == null)
    {
        return req.CreateResponse(HttpStatusCode.NotFound);
    }

    log.LogInformation($"Searching for word: {searchterm} using Uri: {collectionUri.ToString()}");
    IDocumentQuery<ToDoItem> query = client.CreateDocumentQuery<ToDoItem>(collectionUri)
        .Where(p => p.Description.Contains(searchterm))
        .AsDocumentQuery();

    while (query.HasMoreResults)
    {
        foreach (ToDoItem result in await query.ExecuteNextAsync())
        {
            log.LogInformation(result.Description);
        }
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Saída do Azure Cosmos DB v2

Esta seção descreve o suporte apenas para a versão 4.x+ da extensão .

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

propriedade function.json Description
conexão O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar à conta do Azure Cosmos DB que está sendo monitorada. Para obter mais informações, consulte Conexões.
Nome do banco de dados O nome do banco de dados do Azure Cosmos DB com o contêiner sendo monitorado.
containerName O nome do contêiner que está sendo monitorado.
createIfNotExists Um valor booleano para indicar se o contêiner é criado quando ele não existe. O padrão é falso porque novos contêineres são criados com taxa de transferência reservada, o que tem implicações de custo. Para obter mais informações, consulte a página de preços.
partitionKey Quando createIfNotExists é true, ele define o caminho da chave de partição para o contêiner criado. Pode incluir parâmetros de vinculação.
taxa de transferência de contêiner Quando createIfNotExists é true, ele define a taxa de transferência do contêiner criado.
preferredLocations (Opcional) Define locais preferenciais (regiões) para contas de banco de dados replicadas geograficamente no serviço Azure Cosmos DB. Os valores devem ser separados por vírgula. Por exemplo, East US,South Central US,North Europe.

Esta seção contém os seguintes exemplos:

Gatilho de fila, escreva um documento

O exemplo a seguir mostra uma ligação de saída do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função usa uma ligação de entrada de fila para uma fila que recebe JSON no seguinte formato:

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

A função cria documentos do Azure Cosmos DB no seguinte formato para cada registro:

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Aqui estão os dados de ligação no arquivo function.json :

{
    "name": "employeeDocument",
    "type": "cosmosDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "createIfNotExists": true,
    "connectionStringSetting": "MyAccount_COSMOSDB",
    "direction": "out"
}

Aqui está o código de script C#:

    #r "Newtonsoft.Json"

    using Microsoft.Azure.WebJobs.Host;
    using Newtonsoft.Json.Linq;
    using Microsoft.Extensions.Logging;

    public static void Run(string myQueueItem, out object employeeDocument, ILogger log)
    {
      log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

      dynamic employee = JObject.Parse(myQueueItem);

      employeeDocument = new {
        id = employee.name + "-" + employee.employeeId,
        name = employee.name,
        employeeId = employee.employeeId,
        address = employee.address
      };
    }

Gatilho de fila, escrever documentos usando IAsyncCollector

Para criar vários documentos, você pode vincular a ICollector<T> ou IAsyncCollector<T> onde T é um dos tipos suportados.

Este exemplo refere-se a um tipo simples ToDoItem :

namespace CosmosDBSamplesV2
{
    public class ToDoItem
    {
        public string id { get; set; }
        public string Description { get; set; }
    }
}

Aqui está o arquivo function.json:

{
  "bindings": [
    {
      "name": "toDoItemsIn",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "todoqueueforwritemulti",
      "connectionStringSetting": "AzureWebJobsStorage"
    },
    {
      "type": "cosmosDB",
      "name": "toDoItemsOut",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connectionStringSetting": "CosmosDBConnection",
      "direction": "out"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

using System;
using Microsoft.Extensions.Logging;

public static async Task Run(ToDoItem[] toDoItemsIn, IAsyncCollector<ToDoItem> toDoItemsOut, ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

    foreach (ToDoItem toDoItem in toDoItemsIn)
    {
        log.LogInformation($"Description={toDoItem.Description}");
        await toDoItemsOut.AddAsync(toDoItem);
    }
}

Gatilho do Azure Cosmos DB v1

O exemplo a seguir mostra uma ligação de gatilho do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a ligação. A função grava mensagens de log quando os registros do Azure Cosmos DB são modificados.

Aqui estão os dados de ligação no arquivo function.json :

{
    "type": "cosmosDBTrigger",
    "name": "documents",
    "direction": "in",
    "leaseCollectionName": "leases",
    "connectionStringSetting": "<connection-app-setting>",
    "databaseName": "Tasks",
    "collectionName": "Items",
    "createLeaseCollectionIfNotExists": true
}

Aqui está o código de script C#:

    #r "Microsoft.Azure.Documents.Client"
    
    using System;
    using Microsoft.Azure.Documents;
    using System.Collections.Generic;
    

    public static void Run(IReadOnlyList<Document> documents, TraceWriter log)
    {
        log.Info("Documents modified " + documents.Count);
        log.Info("First document Id " + documents[0].Id);
    }

Entrada do Azure Cosmos DB v1

Esta seção contém os seguintes exemplos:

Os exemplos de gatilho HTTP referem-se a um tipo simples ToDoItem :

namespace CosmosDBSamplesV1
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Gatilho de fila, procurar ID da string

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função lê um único documento e atualiza o valor de texto do documento.

Aqui estão os dados de ligação no arquivo function.json :

{
    "name": "inputDocument",
    "type": "documentDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "id" : "{queueTrigger}",
    "partitionKey": "{partition key value}",
    "connection": "MyAccount_COSMOSDB",
    "direction": "in"
}

Aqui está o código de script C#:

    using System;

    // Change input document contents using Azure Cosmos DB input binding
    public static void Run(string myQueueItem, dynamic inputDocument)
    {
        inputDocument.text = "This has changed.";
    }

Gatilho de fila, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma associação de entrada do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a associação. A função recupera vários documentos especificados por uma consulta SQL, usando um gatilho de fila para personalizar os parâmetros de consulta.

O gatilho de fila fornece um parâmetro departmentId. Uma mensagem de fila de { "departmentId" : "Finance" } retornaria todos os registros para o departamento financeiro.

Aqui estão os dados de ligação no arquivo function.json :

{
    "name": "documents",
    "type": "documentdb",
    "direction": "in",
    "databaseName": "MyDb",
    "collectionName": "MyCollection",
    "sqlQuery": "SELECT * from c where c.departmentId = {departmentId}",
    "connection": "CosmosDBConnection"
}

Aqui está o código de script C#:

    public static void Run(QueuePayload myQueueItem, IEnumerable<dynamic> documents)
    {
        foreach (var doc in documents)
        {
            // operate on each document
        }
    }

    public class QueuePayload
    {
        public string departmentId { get; set; }
    }

Gatilho HTTP, ID de pesquisa da cadeia de caracteres de consulta

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por um pedido HTTP que utiliza uma cadeia de consulta para especificar o ID a procurar. Esse ID é usado para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "Id": "{Query.id}"
    }
  ],
  "disabled": true
}

Aqui está o código de script C#:

using System.Net;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
        log.Info($"ToDo item not found");
    }
    else
    {
        log.Info($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Gatilho HTTP, procure ID a partir de dados de rota

O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é acionada por uma solicitação HTTP que usa dados de rota para especificar o ID a ser pesquisado. Esse ID é usado para recuperar um ToDoItem documento do banco de dados e da coleção especificados.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ],
      "route":"todoitems/{id}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "toDoItem",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "Id": "{id}"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

using System.Net;

public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    if (toDoItem == null)
    {
        log.Info($"ToDo item not found");
    }
    else
    {
        log.Info($"Found ToDo item, Description={toDoItem.Description}");
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

HTTP trigger, obter vários documentos, usando SqlQuery

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. A consulta é especificada na SqlQuery propriedade atributo.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "toDoItems",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "in",
      "sqlQuery": "SELECT top 2 * FROM c order by c._ts desc"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

using System.Net;

public static HttpResponseMessage Run(HttpRequestMessage req, IEnumerable<ToDoItem> toDoItems, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    foreach (ToDoItem toDoItem in toDoItems)
    {
        log.Info(toDoItem.Description);
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Gatilho HTTP, obtenha vários documentos, usando DocumentClient

O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é acionada por uma solicitação HTTP. O código usa uma instância fornecida pela associação do Azure Cosmos DB para ler uma DocumentClient lista de documentos. A DocumentClient instância também pode ser usada para operações de gravação.

Aqui está o arquivo function.json :

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "type": "documentDB",
      "name": "client",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "inout"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

#r "Microsoft.Azure.Documents.Client"

using System.Net;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, DocumentClient client, TraceWriter log)
{
    log.Info("C# HTTP trigger function processed a request.");

    Uri collectionUri = UriFactory.CreateDocumentCollectionUri("ToDoItems", "Items");
    string searchterm = req.GetQueryNameValuePairs()
        .FirstOrDefault(q => string.Compare(q.Key, "searchterm", true) == 0)
        .Value;

    if (searchterm == null)
    {
        return req.CreateResponse(HttpStatusCode.NotFound);
    }

    log.Info($"Searching for word: {searchterm} using Uri: {collectionUri.ToString()}");
    IDocumentQuery<ToDoItem> query = client.CreateDocumentQuery<ToDoItem>(collectionUri)
        .Where(p => p.Description.Contains(searchterm))
        .AsDocumentQuery();

    while (query.HasMoreResults)
    {
        foreach (ToDoItem result in await query.ExecuteNextAsync())
        {
            log.Info(result.Description);
        }
    }
    return req.CreateResponse(HttpStatusCode.OK);
}

Saída do Azure Cosmos DB v1

Esta seção contém os seguintes exemplos:

  • Gatilho de fila, escreva um documento
  • Gatilho de fila, escreva documentos usando IAsyncCollector

Gatilho de fila, escreva um documento

O exemplo a seguir mostra uma associação de saída do Azure Cosmos DB em um arquivo function.json e uma função de script C# que usa a ligação. A função usa uma ligação de entrada de fila para uma fila que recebe JSON no seguinte formato:

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

A função cria documentos do Azure Cosmos DB no seguinte formato para cada registro:

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Aqui estão os dados de ligação no arquivo function.json :

{
    "name": "employeeDocument",
    "type": "documentDB",
    "databaseName": "MyDatabase",
    "collectionName": "MyCollection",
    "createIfNotExists": true,
    "connection": "MyAccount_COSMOSDB",
    "direction": "out"
}

Aqui está o código de script C#:

    #r "Newtonsoft.Json"

    using Microsoft.Azure.WebJobs.Host;
    using Newtonsoft.Json.Linq;

    public static void Run(string myQueueItem, out object employeeDocument, TraceWriter log)
    {
        log.Info($"C# Queue trigger function processed: {myQueueItem}");

        dynamic employee = JObject.Parse(myQueueItem);

        employeeDocument = new {
            id = employee.name + "-" + employee.employeeId,
            name = employee.name,
            employeeId = employee.employeeId,
            address = employee.address
        };
    }

Gatilho de fila, escrever documentos usando IAsyncCollector

Para criar vários documentos, você pode vincular a ICollector<T> ou IAsyncCollector<T> onde T é um dos tipos suportados.

Este exemplo refere-se a um tipo simples ToDoItem :

namespace CosmosDBSamplesV1
{
    public class ToDoItem
    {
        public string Id { get; set; }
        public string Description { get; set; }
    }
}

Aqui está o arquivo function.json:

{
  "bindings": [
    {
      "name": "toDoItemsIn",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "todoqueueforwritemulti",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "documentDB",
      "name": "toDoItemsOut",
      "databaseName": "ToDoItems",
      "collectionName": "Items",
      "connection": "CosmosDBConnection",
      "direction": "out"
    }
  ],
  "disabled": false
}

Aqui está o código de script C#:

using System;

public static async Task Run(ToDoItem[] toDoItemsIn, IAsyncCollector<ToDoItem> toDoItemsOut, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

    foreach (ToDoItem toDoItem in toDoItemsIn)
    {
        log.Info($"Description={toDoItem.Description}");
        await toDoItemsOut.AddAsync(toDoItem);
    }
}

Gatilho SQL do Azure

Mais exemplos para o gatilho SQL do Azure estão disponíveis no repositório GitHub.

O exemplo refere-se a uma ToDoItem classe e uma tabela de banco de dados correspondente:

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

O controlo de alterações está ativado na base de dados e na tabela:

ALTER DATABASE [SampleDatabase]
SET CHANGE_TRACKING = ON
(CHANGE_RETENTION = 2 DAYS, AUTO_CLEANUP = ON);

ALTER TABLE [dbo].[ToDo]
ENABLE CHANGE_TRACKING;

O gatilho SQL se liga a um , uma lista de SqlChange objetos cada um IReadOnlyList<SqlChange<T>>com duas propriedades:

  • Item: o item que foi alterado. O tipo do item deve seguir o esquema de tabela como visto na ToDoItem classe.
  • Operação: um valor de SqlChangeOperation enum. Os valores possíveis são Insert, Updatee Delete.

O exemplo a seguir mostra um gatilho ToDo SQL em um arquivo function.json e uma função de script C# que é invocada quando há alterações na tabela:

O seguinte é a ligação de dados no arquivo function.json:

{
    "name": "todoChanges",
    "type": "sqlTrigger",
    "direction": "in",
    "tableName": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

A seguinte é a função de script C#:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static void Run(IReadOnlyList<SqlChange<ToDoItem>> todoChanges, ILogger log)
{
    log.LogInformation($"C# SQL trigger function processed a request.");

    foreach (SqlChange<ToDoItem> change in todoChanges)
    {
        ToDoItem toDoItem = change.Item;
        log.LogInformation($"Change operation: {change.Operation}");
        log.LogInformation($"Id: {toDoItem.Id}, Title: {toDoItem.title}, Url: {toDoItem.url}, Completed: {toDoItem.completed}");
    }
}

Entrada SQL do Azure

Mais exemplos para a associação de entrada SQL do Azure estão disponíveis no repositório GitHub.

Esta seção contém os seguintes exemplos:

Os exemplos referem-se a uma classe e a uma ToDoItem tabela de banco de dados correspondente:

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Gatilho HTTP, obter linha por ID da cadeia de caracteres de consulta

O exemplo a seguir mostra uma associação de entrada SQL do Azure em um arquivo function.json e uma função de script C# que usa a associação. A função é acionada por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID. Esse ID é usado para recuperar um ToDoItem registro com a consulta especificada.

Nota

O parâmetro HTTP query string diferencia maiúsculas de minúsculas.

Aqui estão os dados de ligação no arquivo function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

Aqui está o código de script C#:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Collections.Generic;

public static IActionResult Run(HttpRequest req, ILogger log, IEnumerable<ToDoItem> todoItem)
{
    return new OkObjectResult(todoItem);
}

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma associação de entrada SQL do Azure em um arquivo function.json e uma função de script C# que usa a associação para executar um procedimento armazenado com entrada do parâmetro de consulta de solicitação HTTP. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

O procedimento dbo.DeleteToDo armazenado deve ser criado no banco de dados SQL.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

Aqui estão os dados de ligação no arquivo function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace AzureSQL.ToDo
{
    public static class DeleteToDo
    {
        // delete all items or a specific item from querystring
        // returns remaining items
        // uses input binding with a stored procedure DeleteToDo to delete items and return remaining items
        [FunctionName("DeleteToDo")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "DeleteFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "DeleteToDo", commandType: System.Data.CommandType.StoredProcedure, 
                parameters: "@Id={Query.id}", connectionStringSetting: "SqlConnectionString")] 
                IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

Aqui está o código de script C#:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Collections.Generic;

public static IActionResult Run(HttpRequest req, ILogger log, IEnumerable<ToDoItem> todoItems)
{
    return new OkObjectResult(todoItems);
}

Saída SQL do Azure

Mais exemplos para a associação de saída SQL do Azure estão disponíveis no repositório GitHub.

Esta seção contém os seguintes exemplos:

Os exemplos referem-se a uma classe e a uma ToDoItem tabela de banco de dados correspondente:

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Gatilho HTTP, gravar registros em uma tabela

O exemplo a seguir mostra uma ligação de saída SQL em um arquivo function.json e uma função de script C# que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

O seguinte é a ligação de dados no arquivo function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

Segue-se um exemplo de código de script C#:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static IActionResult Run(HttpRequest req, ILogger log, out ToDoItem todoItem)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = new StreamReader(req.Body).ReadToEnd();
    todoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

    return new OkObjectResult(todoItem);
}

Gatilho HTTP, gravar em duas tabelas

O exemplo a seguir mostra uma ligação de saída SQL em um arquivo function.json e uma função de script C# que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e ), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e dbo.RequestLogvárias ligações de saída.

O segundo quadro, , dbo.RequestLogcorresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

O seguinte é a ligação de dados no arquivo function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
},
{
    "name": "requestLog",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.RequestLog",
    "connectionStringSetting": "SqlConnectionString"
}

Segue-se um exemplo de código de script C#:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static IActionResult Run(HttpRequest req, ILogger log, out ToDoItem todoItem, out RequestLog requestLog)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = new StreamReader(req.Body).ReadToEnd();
    todoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

    requestLog = new RequestLog();
    requestLog.RequestTimeStamp = DateTime.Now;
    requestLog.ItemCount = 1;

    return new OkObjectResult(todoItem);
}

public class RequestLog {
    public DateTime RequestTimeStamp { get; set; }
    public int ItemCount { get; set; }
}

Saída RabbitMQ

O exemplo a seguir mostra uma ligação de saída RabbitMQ em um arquivo function.json e uma função de script C# que usa a ligação. A função lê a mensagem de um gatilho HTTP e a envia para a fila RabbitMQ.

Aqui estão os dados de ligação no arquivo function.json :

{
    "bindings": [
        {
            "type": "httpTrigger",
            "direction": "in",
            "authLevel": "function",
            "name": "input",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "type": "rabbitMQ",
            "name": "outputMessage",
            "queueName": "outputQueue",
            "connectionStringSetting": "rabbitMQConnectionAppSetting",
            "direction": "out"
        }
    ]
}

Aqui está o código de script C#:

using System;
using Microsoft.Extensions.Logging;

public static void Run(string input, out string outputMessage, ILogger log)
{
    log.LogInformation(input);
    outputMessage = input;
}

Saída SendGrid

O exemplo a seguir mostra uma ligação de saída SendGrid em um arquivo function.json e uma função de script C# que usa a ligação.

Aqui estão os dados de ligação no arquivo function.json :

{
    "bindings": [
        {
          "type": "queueTrigger",
          "name": "mymsg",
          "queueName": "myqueue",
          "connection": "AzureWebJobsStorage",
          "direction": "in"
        },
        {
          "type": "sendGrid",
          "name": "$return",
          "direction": "out",
          "apiKey": "SendGridAPIKeyAsAppSetting",
          "from": "{FromEmail}",
          "to": "{ToEmail}"
        }
    ]
}

Aqui está o código de script C#:

#r "SendGrid"

using System;
using SendGrid.Helpers.Mail;
using Microsoft.Azure.WebJobs.Host;

public static SendGridMessage Run(Message mymsg, ILogger log)
{
    SendGridMessage message = new SendGridMessage()
    {
        Subject = $"{mymsg.Subject}"
    };
    
    message.AddContent("text/plain", $"{mymsg.Content}");

    return message;
}
public class Message
{
    public string ToEmail { get; set; }
    public string FromEmail { get; set; }
    public string Subject { get; set; }
    public string Content { get; set; }
}

Gatilho SignalR

Veja um exemplo de dados de vinculação no arquivo function.json :

{
    "type": "signalRTrigger",
    "name": "invocation",
    "hubName": "SignalRTest",
    "category": "messages",
    "event": "SendMessage",
    "parameterNames": [
        "message"
    ],
    "direction": "in"
}

E, aqui está o código:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using System;
using Microsoft.Azure.WebJobs.Extensions.SignalRService;
using Microsoft.Extensions.Logging;

public static void Run(InvocationContext invocation, string message, ILogger logger)
{
    logger.LogInformation($"Receive {message} from {invocationContext.ConnectionId}.");
}

Entrada SignalR

O exemplo a seguir mostra uma ligação de entrada de informações de conexão SignalR em um arquivo function.json e uma função de script C# que usa a associação para retornar as informações de conexão.

Aqui estão os dados de ligação no arquivo function.json :

Exemplo function.json:

{
    "type": "signalRConnectionInfo",
    "name": "connectionInfo",
    "hubName": "chat",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "direction": "in"
}

Aqui está o código de script C#:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static SignalRConnectionInfo Run(HttpRequest req, SignalRConnectionInfo connectionInfo)
{
    return connectionInfo;
}

Você pode definir a userId propriedade da associação para o valor de qualquer cabeçalho usando uma expressão de ligação: {headers.x-ms-client-principal-id} ou {headers.x-ms-client-principal-name}.

Exemplo function.json:

{
    "type": "signalRConnectionInfo",
    "name": "connectionInfo",
    "hubName": "chat",
    "userId": "{headers.x-ms-client-principal-id}",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "direction": "in"
}

Aqui está o código de script C#:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static SignalRConnectionInfo Run(HttpRequest req, SignalRConnectionInfo connectionInfo)
{
    // connectionInfo contains an access key token with a name identifier
    // claim set to the authenticated user
    return connectionInfo;
}

Saída SignalR

Aqui estão os dados de ligação no arquivo function.json :

Exemplo function.json:

{
  "type": "signalR",
  "name": "signalRMessages",
  "hubName": "<hub_name>",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Aqui está o código de script C#:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    object message,
    IAsyncCollector<SignalRMessage> signalRMessages)
{
    return signalRMessages.AddAsync(
        new SignalRMessage
        {
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

Você pode enviar uma mensagem somente para conexões que foram autenticadas para um usuário definindo o ID do usuário na mensagem do SignalR.

Exemplo function.json:

{
  "type": "signalR",
  "name": "signalRMessages",
  "hubName": "<hub_name>",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Aqui está o código de script C#:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    object message,
    IAsyncCollector<SignalRMessage> signalRMessages)
{
    return signalRMessages.AddAsync(
        new SignalRMessage
        {
            // the message will only be sent to this user ID
            UserId = "userId1",
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

Você pode enviar uma mensagem somente para conexões que foram adicionadas a um grupo definindo o nome do grupo na mensagem SignalR.

Exemplo function.json:

{
  "type": "signalR",
  "name": "signalRMessages",
  "hubName": "<hub_name>",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Aqui está o código de script C#:

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    object message,
    IAsyncCollector<SignalRMessage> signalRMessages)
{
    return signalRMessages.AddAsync(
        new SignalRMessage
        {
            // the message will be sent to the group with this name
            GroupName = "myGroup",
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

O Serviço SignalR permite que usuários ou conexões sejam adicionados a grupos. As mensagens podem então ser enviadas para um grupo. Você pode usar a SignalR associação de saída para gerenciar grupos.

O exemplo a seguir adiciona um usuário a um grupo.

Exemplo function.json

{
    "type": "signalR",
    "name": "signalRGroupActions",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "hubName": "chat",
    "direction": "out"
}

Run.csx

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    HttpRequest req,
    ClaimsPrincipal claimsPrincipal,
    IAsyncCollector<SignalRGroupAction> signalRGroupActions)
{
    var userIdClaim = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier);
    return signalRGroupActions.AddAsync(
        new SignalRGroupAction
        {
            UserId = userIdClaim.Value,
            GroupName = "myGroup",
            Action = GroupAction.Add
        });
}

O exemplo a seguir remove um usuário de um grupo.

Exemplo function.json

{
    "type": "signalR",
    "name": "signalRGroupActions",
    "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
    "hubName": "chat",
    "direction": "out"
}

Run.csx

#r "Microsoft.Azure.WebJobs.Extensions.SignalRService"
using Microsoft.Azure.WebJobs.Extensions.SignalRService;

public static Task Run(
    HttpRequest req,
    ClaimsPrincipal claimsPrincipal,
    IAsyncCollector<SignalRGroupAction> signalRGroupActions)
{
    var userIdClaim = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier);
    return signalRGroupActions.AddAsync(
        new SignalRGroupAction
        {
            UserId = userIdClaim.Value,
            GroupName = "myGroup",
            Action = GroupAction.Remove
        });
}

Saída Twilio

O exemplo a seguir mostra uma ligação de saída Twilio em um arquivo function.json e uma função de script C# que usa a ligação. A função usa um out parâmetro para enviar uma mensagem de texto.

Aqui estão os dados de ligação no arquivo function.json :

Exemplo function.json:

{
  "type": "twilioSms",
  "name": "message",
  "accountSidSetting": "TwilioAccountSid",
  "authTokenSetting": "TwilioAuthToken",
  "from": "+1425XXXXXXX",
  "direction": "out",
  "body": "Azure Functions Testing"
}

Aqui está o código de script C#:

#r "Newtonsoft.Json"
#r "Twilio"
#r "Microsoft.Azure.WebJobs.Extensions.Twilio"

using System;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Microsoft.Azure.WebJobs.Extensions.Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

public static void Run(string myQueueItem, out CreateMessageOptions message,  ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

    // In this example the queue item is a JSON string representing an order that contains the name of a
    // customer and a mobile number to send text updates to.
    dynamic order = JsonConvert.DeserializeObject(myQueueItem);
    string msg = "Hello " + order.name + ", thank you for your order.";

    // You must initialize the CreateMessageOptions variable with the "To" phone number.
    message = new CreateMessageOptions(new PhoneNumber("+1704XXXXXXX"));

    // A dynamic message can be set instead of the body in the output binding. In this example, we use
    // the order information to personalize a text message.
    message.Body = msg;
}

Não é possível usar parâmetros em código assíncrono. Aqui está um exemplo de código de script C# assíncrono:

#r "Newtonsoft.Json"
#r "Twilio"
#r "Microsoft.Azure.WebJobs.Extensions.Twilio"

using System;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Microsoft.Azure.WebJobs.Extensions.Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

public static async Task Run(string myQueueItem, IAsyncCollector<CreateMessageOptions> message,  ILogger log)
{
    log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

    // In this example the queue item is a JSON string representing an order that contains the name of a
    // customer and a mobile number to send text updates to.
    dynamic order = JsonConvert.DeserializeObject(myQueueItem);
    string msg = "Hello " + order.name + ", thank you for your order.";

    // You must initialize the CreateMessageOptions variable with the "To" phone number.
    CreateMessageOptions smsText = new CreateMessageOptions(new PhoneNumber("+1704XXXXXXX"));

    // A dynamic message can be set instead of the body in the output binding. In this example, we use
    // the order information to personalize a text message.
    smsText.Body = msg;

    await message.AddAsync(smsText);
}

Gatilho de aquecimento

O exemplo a seguir mostra um gatilho de aquecimento em um arquivo function.json e uma função de script C# que é executada em cada nova instância quando é adicionada ao seu aplicativo.

Não suportado para a versão 1.x do tempo de execução do Functions.

Aqui está o arquivo function.json :

{
    "bindings": [
        {
            "type": "warmupTrigger",
            "direction": "in",
            "name": "warmupContext"
        }
    ]
}

public static void Run(WarmupContext warmupContext, ILogger log)
{
    log.LogInformation("Function App instance is warm.");  
}

Próximos passos

Saiba mais sobre gatilhos e ligações

Saiba mais sobre as práticas recomendadas para o Azure Functions