Azure Functions PDF

Contents
Documentação do Functions
Visão geral
Sobre o Azure Functions
Funções duráveis
Comparação sem servidor
Opções do plano de hospedagem
Guia de início rápido
Criar função – C#
Criar função – Java
Criar função – JavaScript
Criar função – PowerShell
Criar função - Python
Conectar-se a serviços
Armazenamento – C#
Armazenamento – Java
Armazenamento – JavaScript
Armazenamento – Python
Tutoriais
Functions com Aplicativos Lógicos
Desenvolver funções Python com o VS Code
Definição de OpenAPI para APIs sem servidor
Conectar-se a uma rede virtual
Redimensionamento de imagem com a Grade de Eventos
Criar um aplicativo web sem servidor
Aprendizado de máquina com o TensorFlow
Criar uma imagem personalizada do Linux
Funções no dispositivo do IoT Edge
Java com Azure Cosmos DB e Hubs de Eventos
Exemplos
Azure Serverless Community Library
Exemplos do Azure
C#
Java
JavaScript
PowerShell
Python
TypeScript
CLI do Azure
Conceitos
Comparar versões de tempo de execução
Plano Premium
Implantações
Eventos e mensagens
Processamento de eventos confiável
Como criar para entrada idêntica
Gatilhos e associações
Sobre gatilhos e associações
Exemplo de associação
Registrar as extensões de associação
Padrões de expressões de associação
Usar valores de retorno de associação
Tratar erros de associação
Languages
Idiomas com suporte
C# (biblioteca de classes)
Script do C# (.csx)
F#
JavaScript
Java
PowerShell
Python
TypeScript
Diagnósticos
Custos de plano de consumo
Considerações sobre o desempenho
Proxies de Funções
Opções de rede
Endereços IP
Funções no Kubernetes
Guias de instruções
Desenvolver
Guia do desenvolvedor
Desenvolvimento local
Desenvolver e depurar localmente
Desenvolvimento do Visual Studio Code
Desenvolvimento do Visual Studio
Desenvolvimento das Principais Ferramentas
Criar funções
Gatilho HTTP
Portal do Azure
Linha de comando
Visual Studio
Visual Studio Code
Java usando o Eclipse
Java usando o IntelliJ IDEA
Plano do Serviço de Aplicativo do Linux
Plano de consumo em Linux
Azure for Students Starter
Gatilho do Azure Cosmos DB
Gatilho de armazenamento Blob
Gatilho de armazenamento de filas
Gatilho de temporizador
Adicionar associações
Status do Azure Cosmos DB – portal
Armazenamento – portal
Armazenamento – Visual Studio Code
Armazenamento – Visual Studio
Depurar e testar
Testar funções
Depurar funções locais do PowerShell
Depurar gatilho da Grade de Eventos localmente
Injeção de dependência
Gerenciar conexões
Tratamento de erros
Executar manualmente uma função não disparada por HTTP
Implantar
Implantação contínua
Slots de implantação
Criar e implantar usando o Azure Pipelines
Criar e implantar usando Ações do GitHub
implantação do Zip
Execução a partir do pacote
Automatizar implantação de recursos
Funções locais
Implantar usando o plug-in do Jenkins
Configurar
Gerenciar um aplicativo de funções
Defina a versão de runtime
Registrar manualmente uma extensão
Desabilitar uma função
Recuperação de desastre geográfico
Monitoramento
Monitorar funções
Analisar logs
Segurança
Adicionar certificado SSL
Autenticar usuários
Autenticar com o Azure AD
Autenticar com o Facebook
Autenticar com o Google
Autenticar com a conta da Microsoft
Autenticar com o Twitter
Autenticação avançada
Restringir IPs
Usar uma identidade gerenciada
Referenciar segredos do Key Vault
Integração
Status do Azure Cosmos DB – portal
Armazenamento – portal
Armazenamento – Visual Studio Code
Armazenamento – Visual Studio
Conectar-se ao Banco de Dados SQL
Conectar-se a uma Rede virtual
Criar uma definição Open API 2.0
Exportar para o PowerApps e para o Microsoft Flow
Usar uma identidade gerenciada
Personalizar ponto de extremidade da função HTTP
Gerenciar recursos locais
Solucionar problemas
Solucionar problemas de armazenamento
Referência
Referências de API
Java
Python
Referência de configurações do aplicativo
Armazenamento de blob
Azure Cosmos DB
Funções 1.x
Funções 2.x
Grade de Eventos
Hubs de Eventos
Hub IoT
HTTP e webhooks
Microsoft Graph
Aplicativos Móveis
Hubs de Notificação
Armazenamento de filas
SendGrid
Barramento de Serviço
Serviço SignalR
Armazenamento de tabela
Timer
Twilio
Referência do host.json 2.x
Referência do host.json 1.x
Perguntas frequentes sobre a rede
Referência do OpenAPI
Recursos
Desenvolva suas habilidades com o Microsoft Learn
Roteiro do Azure
Preços
Calculadora de preço
Informações de cota
Disponibilidade regional
vídeos
Fórum do MSDN
Stack Overflow
Twitter
Fornecer comentários sobre o produto
Repositório de GitHub do Azure Functions
Atualizações de serviço
Uma introdução ao Azure Functions
25/05/2018 • 10 minutes to read • Edit Online
O Azure Functions é uma solução para executar facilmente pequenos trechos de código, ou "funções", na nuvem.
Você pode simplesmente escrever o código de que necessita para o problema em questão, sem se preocupar
com todo o aplicativo ou a infraestrutura para executá-lo. As funções podem tornar o desenvolvimento ainda
mais produtivo e você pode usar a linguagem de desenvolvimento de sua escolha, como C#, Java, JavaScript,
PowerShell e Python. Pague somente pelo tempo de execução do seu código e confie no Azure para
dimensioná-lo conforme a necessidade. O Azure Functions permite desenvolver aplicativos sem servidor no
Microsoft Azure.
Este tópico fornece uma visão geral de alto nível do Azure Functions. Se você quiser começar a usar
imediatamente o Functions, comece com Criar seu primeiro Azure Function. Se você estiver procurando
informações mais técnicas sobre o Functions, confira a referência do desenvolvedor.
Recursos
Aqui estão alguns dos principais recursos do Functions:
Opção de linguagem – escreva funções usando a linguagem que quiser: C#, Java, JavaScript, Python ou
outra. Consulte as Linguagens compatíveis para obter a lista completa.
Modelo de preços de pagamento por uso – pague somente pelo tempo gasto na execução de seu código.
Veja a opção de plano de hospedagem de consumo na seção de preços.
Traga suas próprias dependências – o Functions dá suporte a NuGet e NPM e, portanto, você pode usar
suas bibliotecas favoritas.
Segurança integrada – proteja funções disparadas por HTTP com provedores de OAuth como Azure Active
Directory, Facebook, Google, Twitter e Conta da Microsoft.
Integração simplificada – aproveite facilmente as ofertas dos serviços do Azure e de SaaS (software como
um serviço). Confira a seção de integrações para obter alguns exemplos.
Desenvolvimento flexível – escreva suas funções diretamente no portal ou configure a integração
contínua e implante seu código por meio do GitHub, do Azure DevOps Services e de outras ferramentas de
desenvolvimento com suporte.
Software livre – O Functions é um software livre e está disponível no GitHub.
O que posso fazer com o Functions?

O Functions é uma ótima solução para processamento de dados, integração de sistemas, trabalho com a IoT
(Internet das coisas) e criação de APIs e microsserviços simples. Considere o Functions para tarefas como
processamento de imagens ou pedidos, manutenção de arquivos ou tarefas que você deseja executar de maneira
agendada.
O Functions fornece modelos para você poder começar em cenários chave, incluindo os seguintes:
HTTPTrigger – dispara a execução do seu código usando uma solicitação HTTP. Para obter um exemplo,
consulte Criar sua primeira função.
TimerTrigger – execute limpeza ou outras tarefas em lotes em uma programação predefinida. Para um
exemplo, consulte Criar uma função disparada por um temporizador.
CosmosDBTrigger – processe documentos do Azure Cosmos DB quando eles forem adicionados ou
atualizados em coleções em um banco de dados NoSQL. Para saber mais, veja Associações do Azure
Cosmos DB.
BlobTrigger – processa blobs do Armazenamento do Azure quando são adicionados a contêineres. Você
pode usar essa função para o redimensionamento de imagens. Para obter mais informações, consulte
Associações de armazenamento de blobs.
QueueTrigger – responde às mensagens que chegam em uma fila do Armazenamento do Azure. Para saber
mais, veja Associações de armazenamento do Azure Queue.
EventGridTrigger- responder a eventos entregues a uma assinatura na Grade de Eventos do Azure. Dá
suporte a um modelo baseado em assinatura para recebimento de eventos, o que inclui a filtragem. Uma boa
solução para a criação de arquiteturas baseadas em evento. Para obter um exemplo, veja Automatizar o
redimensionamento de imagens carregadas usando a Grade de Eventos.
EventHubTrigger - responder a eventos entregues a um Hub de Eventos do Azure. É especialmente útil em
cenários de instrumentação de aplicativos, de processamento de fluxo de trabalho ou experiência do usuário
e de Internet das Coisas (IoT). Para obter mais informações, consulte Associações de Hubs de Eventos.
ServiceBusQueueTrigger – conecte seu código a outros serviços do Azure ou serviços locais por meio da
escuta de filas de mensagens. Para obter mais informações, consulte Associações de Barramento de Serviço.
ServiceBusTopicTrigger – conecte seu código a outros serviços do Azure ou serviços locais por meio da
assinatura de tópicos. Para obter mais informações, consulte Associações de Barramento de Serviço.
O Azure Functions dá suporte a gatilhos, que são maneiras de iniciar a execução do seu código, e associações,
que são maneiras de simplificar a codificação de dados de entrada e de saída. Para obter uma descrição
detalhada dos gatilhos e associações que o Azure Functions fornece, confira a Referência do desenvolvedor de
disparadores e associações do Azure Functions.
Integrações
O Azure Functions integra-se com uma variedade de serviços do Azure e de terceiros. Esses serviços podem
disparar a sua função e iniciar a execução ou podem servir como entrada e saída para seu código. As integrações
de serviço a seguir têm suporte do Azure Functions:
Azure Cosmos DB
Hubs de eventos do Azure
Grade de Eventos do Azure
Hubs de Notificação do Azure
Barramento de Serviço do Azure (filas e tópicos)
Armazenamento do Azure (blob, filas e tabelas)
No local (usando o Barramento de Serviço)
Twilio (mensagens SMS )
Quanto custa o Functions?

As funções do Azure têm dois tipos de planos de preços. Escolha a opção que melhor atende às suas
necessidades:
Plano de consumo – quando sua função é executada, o Azure fornece todos os recursos computacionais
necessários. Você não precisa se preocupar com o gerenciamento de recursos e paga apenas pelo tempo de
execução do seu código.
Plano do Serviço de Aplicativo – executa suas funções da mesma forma que os aplicativos Web. Quando
você já estiver usando o Serviço de Aplicativo para os outros aplicativos, poderá executar suas funções no
mesmo plano sem custo adicional.
Para obter mais informações sobre planos de hospedagem, consulte Comparação de planos de hospedagem do
Azure Functions. Os detalhes de preços completos estão disponíveis na página Preço do Functions.
Próximas etapas
Criar sua primeira função
Crie diretamente sua primeira função usando o início rápido do Azure Functions.
Referência do desenvolvedor do Azure Functions
Fornece informações mais técnicas sobre o tempo de execução do Azure Functions e uma referência para
funções de codificação e definição de associações e gatilhos.
Testando o Azure Functions
Descreve várias ferramentas e técnicas para testar suas funções.
Como escalar o Azure Functions
Discute os planos de serviço disponíveis com o Azure Functions, incluindo o plano de hospedagem de
consumo e como escolher o plano certo.
Saiba mais sobre o Serviço de Aplicativo do Azure
O Azure Functions aproveita o Serviço de Aplicativo do Azure para a funcionalidade básica como
implantações, variáveis de ambiente e diagnóstico.
O que são as Durable Functions?
As Durable Functions são uma extensão do Azure Functions que permite escrever funções com estado em um
ambiente de computação sem servidor. A extensão permite definir fluxos de trabalho com estado pela escrita de
funções de orquestrador e entidades com estado pela escrita de funções de entidade usando o modelo de
programação do Azure Functions. Nos bastidores, a extensão gerencia o estado, os pontos de verificação e as
reinicializações para você, permitindo que você se concentre na lógica de negócios.
Linguagens compatíveis
Atualmente, as Durable Functions dão suporte às seguintes linguagens:
C# : bibliotecas de classes pré-compiladas e script C#.
F# : bibliotecas de classes pré-compiladas e script F#. Só há suporte para o script F# na versão 1.x do Azure
Functions Runtime.
JavaScript: compatível apenas com a versão 2.x do Azure Functions Runtime. Exige a versão 1.7.0 da extensão
das Durable Functions ou uma versão posterior.
As Durable Functions têm o objetivo de dar suporte a todas as linguagens do Azure Functions. Confira a lista de
problemas das Durable Functions para obter o último status do trabalho para dar suporte a linguagens adicionais.
Assim como o Azure Functions, há modelos para ajudá-lo a desenvolver as Durable Functions usando o Visual
Studio 2019, o Visual Studio Code e o portal do Azure.
Padrões de aplicativo
O principal caso de uso das Durable Functions é simplificar requisitos complexos de coordenação com estado em
aplicativos sem servidor. As seguintes seções descrevem padrões de aplicativo típicos que podem se beneficiar
com as Durable Functions:
Encadeamento de funções
Fan-out/fan-in
APIs HTTP assíncronas
Monitoramento
Interação humana
Agregador
Padrão 1: Encadeamento de funções
No padrão de encadeamento de funções, uma sequência de funções é executada em uma ordem específica. Nesse
padrão, a saída de uma função é aplicada à entrada de outra função.
Use as Durable Functions para implementar o padrão de encadeamento de funções de forma concisa, conforme
mostrado no seguinte exemplo:
C#
[FunctionName("Chaining")]
public static async Task<object> Run(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
try
{
var x = await context.CallActivityAsync<object>("F1", null);
var y = await context.CallActivityAsync<object>("F2", x);
var z = await context.CallActivityAsync<object>("F3", y);
return await context.CallActivityAsync<object>("F4", z);
}
catch (Exception)
{
// Error handling or compensation goes here.
}
}
JavaScript (apenas Funções 2.x )
const df = require("durable-functions");
module.exports = df.orchestrator(function*(context) {
const x = yield context.df.callActivity("F1");
const y = yield context.df.callActivity("F2", x);
const z = yield context.df.callActivity("F3", y);
return yield context.df.callActivity("F4", z);
});
Nesse exemplo, os valores F1 , F2 , F3 e F4 são os nomes de outras funções no aplicativo de funções.

Implemente o fluxo de controle usando construtos de codificação imperativa normal. O código é executado de
cima para baixo. Ele pode envolver a semântica do fluxo de controle da linguagem existente, como condicionais e
loops. Você pode incluir a lógica de tratamento de erro em blocos try / catch / finally .
Use o parâmetro context [DurableOrchestrationContext] (.NET) e o objeto context.df (JavaScript) para invocar
outras funções por nome, passar parâmetros e retornar a saída da função. Sempre que o código chama await
(C#) ou yield (JavaScript), a estrutura das Durable Functions faz a verificação pontual do progresso da instância
da função atual. Se o processo ou a VM for reciclada no meio da execução, a instância da função retomará na
chamada await ou yield anterior. Para obter mais informações, confira a próxima seção, Padrão nº2: Fan-
out/fan-in.
NOTE
O objeto context no JavaScript representa o contexto de função inteiro, não apenas o parâmetro
[DurableOrchestrationContext].
Padrão 2: Fan-out/fan-in
No padrão fan-out/fan-in, execute várias funções em paralelo e, em seguida, aguarde a conclusão de todas as
funções. Frequentemente, algum trabalho de agregação é feito nos resultados retornados pelas funções.
Com funções normais, realize fan-out fazendo com que a função envie várias mensagens para uma fila. No
entanto, o processo de realizar fan-in é muito mais complexo. Para o fan-in, em uma função normal, você escreve
o código a ser controlado quando as funções disparadas por fila terminam e, em seguida, armazena saídas da
função.
A extensão Durable Functions cuida desse padrão com um código relativamente simples:
C#
[FunctionName("FanOutFanIn")]
public static async Task Run(
{
var parallelTasks = new List<Task<int>>();
// Get a list of N work items to process in parallel.

object[] workBatch = await context.CallActivityAsync<object[]>("F1", null);
for (int i = 0; i < workBatch.Length; i++)
{
Task<int> task = context.CallActivityAsync<int>("F2", workBatch[i]);
parallelTasks.Add(task);
}
await Task.WhenAll(parallelTasks);
// Aggregate all N outputs and send the result to F3.

int sum = parallelTasks.Sum(t => t.Result);
await context.CallActivityAsync("F3", sum);
}

const parallelTasks = [];
// Get a list of N work items to process in parallel.

const workBatch = yield context.df.callActivity("F1");
for (let i = 0; i < workBatch.length; i++) {
parallelTasks.push(context.df.callActivity("F2", workBatch[i]));
}
yield context.df.Task.all(parallelTasks);
// Aggregate all N outputs and send the result to F3.

const sum = parallelTasks.reduce((prev, curr) => prev + curr, 0);
yield context.df.callActivity("F3", sum);
});
O trabalho de fan-out é distribuído para várias instâncias da função F2 . O trabalho é acompanhado usando uma
lista dinâmica de tarefas. A API Task.WhenAll .NET ou context.df.Task.all JavaScript é chamada para aguardar
até que todas as funções chamadas sejam concluídas. Em seguida, as saídas da função F2 são agregadas da lista
de tarefas dinâmicas e passadas para a função F3 .
O ponto de verificação automático que ocorre na chamada await ou yield em Task.WhenAll ou
context.df.Task.all garante que uma possível falha ou reinicialização no meio do processo não exija a
reinicialização de uma tarefa já concluída.
NOTE
Em raras circunstâncias, é possível que uma falha ocorra na janela depois que uma função de atividade for concluída, mas
antes de sua conclusão ser salva no histórico de orquestração. Se isso acontecer, a função de atividade será executada
novamente desde o início depois que o processo for recuperado.
Padrão 3: APIs HTTP assíncronas

O padrão de API HTTP assíncrona trata do problema de coordenar o estado de operações de execução longa com
clientes externos. Uma maneira comum de implementar esse padrão é fazer com que um ponto de extremidade
HTTP dispare a ação de execução longa. Em seguida, redirecione o cliente para um ponto de extremidade de
status que é sondado pelo cliente para saber quando a operação é concluída.
As Durable Functions fornecem suporte interno para esse padrão, simplificando ou, até mesmo, removendo o
código que você precisa escrever para interagir com execuções de função de execução longa. Por exemplo, as
amostras de início rápido das Durable Functions (C# e JavaScript) mostram um comando REST simples que você
pode usar para iniciar novas instâncias de função de orquestrador. Depois que uma instância é iniciada, a extensão
expõe as APIs HTTP de webhook que consultam o status da função de orquestrador.
O exemplo a seguir mostra os comandos REST que iniciam um orquestrador e consultam seu status. Para maior
clareza, alguns detalhes do protocolo foram omitidos do exemplo.
> curl -X POST https://myfunc.azurewebsites.net/orchestrators/DoWork -H "Content-Length: 0" -i

HTTP/1.1 202 Accepted
Content-Type: application/json
Location: https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/b79baf67f717453ca9e86c5da21e03ec
{"id":"b79baf67f717453ca9e86c5da21e03ec", ...}
> curl https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/b79baf67f717453ca9e86c5da21e03ec -i

HTTP/1.1 202 Accepted
Location: https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/b79baf67f717453ca9e86c5da21e03ec
{"runtimeStatus":"Running","lastUpdatedTime":"2019-03-16T21:20:47Z", ...}
> curl https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/b79baf67f717453ca9e86c5da21e03ec -i

HTTP/1.1 200 OK
Content-Length: 175
{"runtimeStatus":"Completed","lastUpdatedTime":"2019-03-16T21:20:57Z", ...}
Como o runtime das Durable Functions gerencia o estado para você, você não precisa implementar seu próprio
mecanismo de acompanhamento de status.
A extensão Durable Functions expõe as APIs HTTP internas que gerenciam orquestrações de execução longa.
Como alternativa, você pode implementar esse padrão por conta própria usando seus próprios gatilhos de função
(como HTTP, uma fila ou os Hubs de Eventos do Azure) e a associação de cliente de orquestração. Por exemplo,
você pode usar uma mensagem da fila para disparar o encerramento. Ou você pode usar um gatilho HTTP
protegido por uma política de autenticação do Azure Active Directory, em vez de APIs HTTP internas que usam
uma chave gerada para autenticação.
Para obter mais informações, confira o artigo Recursos HTTP, que explica como você pode expor processos
assíncronos de execução longa via HTTP usando a extensão das Durable Functions.
Padrão 4: Monitoramento
O padrão de monitor refere-se a um processo recorrente e flexível em um fluxo de trabalho. Um exemplo é fazer
uma sondagem até que condições específicas sejam atendidas. Você pode usar um gatilho de temporizador
normal para lidar com um cenário básico, como um trabalho de limpeza periódico, mas seu intervalo é estático e
o gerenciamento do tempo de vida da instância torna-se complexo. Use as Durable Functions para criar intervalos
de recorrência flexíveis, gerenciar os tempos de vida de tarefas e criar vários processos de monitor com base em
uma única orquestração.
Um exemplo do padrão de monitor é reverter o cenário de API HTTP assíncrona anterior. Em vez de expor um
ponto de extremidade para um cliente externo monitorar uma operação de execução longa, o monitor de
execução longa consome um ponto de extremidade externo e, em seguida, aguarda uma alteração de estado.
Em poucas linhas de código, você pode usar as Durable Functions para criar vários monitores que observam
pontos de extremidade arbitrários. Os monitores podem encerrar a execução quando uma condição é atendida ou
o DurableOrchestrationClient pode encerrar os monitores. Você pode alterar o intervalo de wait de um monitor
de acordo com uma condição específica (por exemplo, retirada exponencial).
O seguinte código implementa um monitor básico:
C#
[FunctionName("MonitorJobStatus")]
{
int jobId = context.GetInput<int>();
int pollingInterval = GetPollingInterval();
DateTime expiryTime = GetExpiryTime();
while (context.CurrentUtcDateTime < expiryTime)

{
var jobStatus = await context.CallActivityAsync<string>("GetJobStatus", jobId);
if (jobStatus == "Completed")
{
// Perform an action when a condition is met.
await context.CallActivityAsync("SendAlert", machineId);
break;
}
// Orchestration sleeps until this time.

var nextCheck = context.CurrentUtcDateTime.AddSeconds(pollingInterval);
await context.CreateTimer(nextCheck, CancellationToken.None);
}
// Perform more work here, or let the orchestration end.

}

const moment = require("moment");
const jobId = context.df.getInput();
const pollingInternal = getPollingInterval();
const expiryTime = getExpiryTime();
while (moment.utc(context.df.currentUtcDateTime).isBefore(expiryTime)) {
const jobStatus = yield context.df.callActivity("GetJobStatus", jobId);
if (jobStatus === "Completed") {
// Perform an action when a condition is met.
yield context.df.callActivity("SendAlert", machineId);
break;
}
// Orchestration sleeps until this time.

const nextCheck = moment.utc(context.df.currentUtcDateTime).add(pollingInterval, 's');
yield context.df.createTimer(nextCheck.toDate());
}
// Perform more work here, or let the orchestration end.

});
Quando uma solicitação é recebida, uma nova instância de orquestração é criada para essa ID do trabalho. A
instância sonda um status até que uma condição seja atendida e o loop seja encerrado. Um temporizador durável
controla o intervalo de sondagem. Em seguida, mais trabalho pode ser realizado ou a orquestração pode ser
encerrada. Quando o context.CurrentUtcDateTime (.NET) ou o context.df.currentUtcDateTime (JavaScript) excede
o valor expiryTime , o monitor é encerrado.
Padrão 5: Interação humana
Muitos processos automatizados envolvem algum tipo de interação humana. Envolver humanos em um processo
automatizado é complicado, porque as pessoas não estão tão altamente disponíveis nem são tão dinâmicas
quanto os serviços de nuvem. Um processo automatizado pode permitir essa interação usando tempos limite e a
lógica de compensação.
Um processo de aprovação é um exemplo de um processo empresarial que envolve a interação humana. A
aprovação de um gerente pode ser necessária para um relatório de despesas que exceda determinado valor em
dólares. Se o gerente não aprovar o relatório de despesas em até 72 horas (talvez ele esteja de férias), um
processo de escalonamento será iniciado para obter a aprovação de outra pessoa (talvez o gerente do gerente).
Você pode implementar o padrão nesse exemplo usando uma função de orquestrador. O orquestrador usa um
temporizador durável para solicitar aprovação. O orquestrador fará o escalonamento se o tempo limite se esgotar.
O orquestrador aguarda um evento externo, como uma notificação gerada por uma interação humana.
Estes exemplos criam um processo de aprovação para demonstrar o padrão de interação humana:
C#
[FunctionName("ApprovalWorkflow")]
{
await context.CallActivityAsync("RequestApproval", null);
using (var timeoutCts = new CancellationTokenSource())
{
DateTime dueTime = context.CurrentUtcDateTime.AddHours(72);
Task durableTimeout = context.CreateTimer(dueTime, timeoutCts.Token);
Task<bool> approvalEvent = context.WaitForExternalEvent<bool>("ApprovalEvent");

if (approvalEvent == await Task.WhenAny(approvalEvent, durableTimeout))
{
timeoutCts.Cancel();
await context.CallActivityAsync("ProcessApproval", approvalEvent.Result);
}
else
{
await context.CallActivityAsync("Escalate", null);
}
}
}
const moment = require('moment');
yield context.df.callActivity("RequestApproval");
const dueTime = moment.utc(context.df.currentUtcDateTime).add(72, 'h');

const durableTimeout = context.df.createTimer(dueTime.toDate());
const approvalEvent = context.df.waitForExternalEvent("ApprovalEvent");

if (approvalEvent === yield context.df.Task.any([approvalEvent, durableTimeout])) {
durableTimeout.cancel();
yield context.df.callActivity("ProcessApproval", approvalEvent.result);
} else {
yield context.df.callActivity("Escalate");
}
});
Para criar o temporizador durável, chame context.CreateTimer (.NET) ou context.df.createTimer (JavaScript). A

notificação é recebida pelo context.WaitForExternalEvent (.NET) ou context.df.waitForExternalEvent (JavaScript).
Em seguida, Task.WhenAny (.NET) ou context.df.Task.any (JavaScript) é chamado para decidir se o próximo
passo é escalonar (o tempo limite ocorre primeiro) ou processar a aprovação (a aprovação é recebida antes do
tempo limite).
Um cliente externo pode entregar a notificação de eventos para uma função de orquestrador em espera usando as
APIs HTTP internas ou a API DurableOrchestrationClient.RaiseEventAsync em outra função:
[FunctionName("RaiseEventToOrchestration")]
[HttpTrigger] string instanceId,
[OrchestrationClient] DurableOrchestrationClient client)
{
bool isApproved = true;
await client.RaiseEventAsync(instanceId, "ApprovalEvent", isApproved);
}
module.exports = async function (context) {

const client = df.getClient(context);
const isApproved = true;
await client.raiseEvent(instanceId, "ApprovalEvent", isApproved);
};
curl -d "true"
http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}/raiseEvent/ApprovalEvent -H
"Content-Type: application/json"
Padrão nº 6: Agregador (versão prévia)

O sexto padrão trata da agregação de dados de evento durante um período em uma única entidade endereçável.
Nesse padrão, os dados que estão sendo agregados podem vir de várias fontes, podem ser entregues em lotes ou
podem estar distribuídos por longos períodos. O agregador pode precisar executar uma ação nos dados de
evento quando eles são recebidos e os clientes externos talvez precisem consultar os dados agregados.
A complexidade de tentar implementar esse padrão com as funções normais sem estado é que o controle de
simultaneidade se torna um grande desafio. Além de se preocupar com vários threads modificando os mesmos
dados ao mesmo tempo, você precisa se preocupar em garantir que o agregador só seja executado em uma única
VM por vez.
Usando uma função de Entidade Durável, é possível implementar esse padrão com facilidade como uma única
função.
[FunctionName("Counter")]
public static void Counter([EntityTrigger] IDurableEntityContext ctx)
{
int currentValue = ctx.GetState<int>();
switch (ctx.OperationName.ToLowerInvariant())
{
case "add":
int amount = ctx.GetInput<int>();
currentValue += amount;
break;
case "reset":
currentValue = 0;
break;
case "get":
ctx.Return(currentValue);
break;
}
ctx.SetState(currentValue);
}
As Entidades Duráveis também podem ser modeladas como classes .NET. Esse modelo pode ser útil se a lista de
operações é fixa e se torna grande. O exemplo a seguir é uma implementação equivalente da entidade Counter
usando métodos e classes .NET.
public class Counter

{
[JsonProperty("value")]
public int CurrentValue { get; set; }
public void Add(int amount) => this.CurrentValue += amount;
public void Reset() => this.CurrentValue = 0;
public int Get() => this.CurrentValue;
[FunctionName(nameof(Counter))]
public static Task Run([EntityTrigger] IDurableEntityContext ctx)
=> ctx.DispatchAsync<Counter>();
}
Os clientes podem enfileirar operações de uma função de entidade (também conhecido como "sinalização")
usando a associação do cliente de entidade.
[FunctionName("EventHubTriggerCSharp")]
[EventHubTrigger("device-sensor-events")] EventData eventData,
[OrchestrationClient] IDurableOrchestrationClient entityClient)
{
var metricType = (string)eventData.Properties["metric"];
var delta = BitConverter.ToInt32(eventData.Body, eventData.Body.Offset);
// The "Counter/{metricType}" entity is created on-demand.

var entityId = new EntityId("Counter", metricType);
await entityClient.SignalEntityAsync(entityId, "add", delta);
}
Os proxies gerados dinamicamente também estão disponíveis para sinalizar entidades para torná-las fortemente
tipadas. Além da sinalização, os clientes também podem consultar o estado de uma função de entidade usando
métodos fortemente tipados na associação do cliente de orquestração.
NOTE
Atualmente, as funções de entidade só estão disponíveis no .NET como parte da versão prévia das Durable Functions 2.0.
A tecnologia
Nos bastidores, a extensão Durable Functions baseia-se na Durable Task Framework, uma biblioteca open-source
no GitHub usada para a criação de fluxos de trabalho em código. Assim como o Azure Functions é a evolução sem
servidor do Azure WebJobs, as Durable Functions são a evolução sem servidor da Durable Task Framework. A
Microsoft e outras organizações usam a Durable Task Framework extensivamente para automatizar processos
críticos. Ele é uma opção natural para o ambiente sem servidor do Azure Functions.
Restrições de código
Para fornecer garantias de execução confiáveis e de execução longa, as funções de orquestrador têm um conjunto
de regras de codificação que precisam ser seguidas. Para obter mais informações, confira o artigo Restrições de
código na função de orquestrador.
Cobrança
As Durable Functions são cobradas da mesma forma que o Azure Functions. Para saber mais, confira Preços do
Azure Functions. Ao executar funções de orquestrador no plano de Consumo do Azure Functions, há alguns
comportamentos de cobrança para sua informação. Para obter mais informações sobre esses comportamentos,
confira o artigo Cobrança das Durable Functions.
Comece a usar agora

Comece a usar as Durable Functions em menos de 10 minutos concluindo um destes tutoriais de início rápido
específicos a uma linguagem:
C# usando o Visual Studio 2019
JavaScript usando o Visual Studio Code
Nos dois inícios rápidos, você criará e testará uma durable function "Olá, Mundo" localmente. Em seguida, você
publicará o código de função no Azure. A função que você criará orquestra e encadeia chamadas para outras
funções.
Saiba mais
O seguinte vídeo destaca os benefícios das Durable Functions:
Para obter uma discussão mais detalhada sobre as Durable Functions e a tecnologia subjacente, confira o seguinte
vídeo (ele se concentra no .NET, mas os conceitos também se aplicam a outras linguagens compatíveis):
Como as Durable Functions são uma extensão avançada do Azure Functions, elas não são apropriadas para todos
os aplicativos. Para obter uma comparação com outras tecnologias de orquestração do Azure, confira Comparar o
Azure Functions e os Aplicativos Lógicos do Azure.
Próximas etapas
Tipos de função e recursos das Durable Functions
O que são o Microsoft Flow, os Aplicativos Lógicos, o
Functions e o WebJobs?
Este artigo compara os seguintes serviços em nuvem da Microsoft:

Microsoft Flow
Aplicativos Lógicos do Azure
Funções do Azure
WebJobs no Serviço de Aplicativo do Azure
Todos esses serviços podem resolver problemas de integração e automatizar processos empresariais. Todos eles
definem entrada e saída, condições e ações. Você pode executar cada um em um cronograma ou gatilho. Cada
serviço traz vantagens exclusivas e este artigo explica as diferenças.
Se estiver procurando uma comparação mais geral entre o Azure Functions e outras opções de computação do
Azure, confira Critérios para escolha de um serviço de computação do Azure e Como escolher uma opção de
computação do Azure para microsserviços.
Comparar o Microsoft Flow e os Aplicativos Lógicos do Azure

O Microsoft Flow e os Aplicativos Lógicos são serviços de integração centrados no designer que podem criar
fluxos de trabalho. Ambos os serviços se integram a vários aplicativos SaaS e empresariais.
O Microsoft Flow se baseia nos Aplicativos Lógicos. Eles compartilham o mesmo designer de fluxo de trabalho e
os mesmos conectores.
O Microsoft Flow capacita qualquer trabalhador a realizar integrações simples (por exemplo, um processo de
aprovação em uma biblioteca de documentos do SharePoint) sem passar pelos desenvolvedores nem pelo
departamento de TI. Os Aplicativos Lógicos também podem permitir integrações avançadas (por exemplo,
processos B2B ), em que o Azure DevOps de nível empresarial e práticas de segurança são necessárias. É comum
que um fluxo de trabalho de negócios aumente de complexidade ao longo do tempo. Da mesma forma, você pode
começar com um fluxo e, em seguida, convertê-lo em um aplicativo lógico, conforme necessário.
A seguinte tabela ajuda você a determinar a melhor opção para uma integração específica, o Microsoft Flow ou os
Aplicativos Lógicos:
MICROSOFT FLOW APLICATIVOS LÓGICOS
Usuários Funcionários do escritório, usuários de Integradores profissionais e

negócios, administradores do desenvolvedores, profissionais de TI
SharePoint
Cenários Autoatendimento Integrações avançadas
Ferramenta de design Aplicativo do navegador e móvel, No navegador e no Visual Studio,

somente interface do usuário Exibição de código disponível
MICROSOFT FLOW APLICATIVOS LÓGICOS
ALM (Gerenciamento do Ciclo de Vida Design e teste em ambientes de não Azure DevOps: controle do código-
do Aplicativo) produção; promoção para produção fonte, teste, suporte, automação e
quando pronto capacidade de gerenciamento no Azure
Resource Manager
Experiência de admin Gerenciar ambientes do Microsoft Flow Gerenciar grupos de recursos, conexões,
e políticas DLP (prevenção contra perda gerenciamento de acesso e log: Portal
de dados), acompanhamento do do Azure
licenciamento: Centro de Administração
do Microsoft Flow
Segurança Logs de auditoria de Segurança e Garantia de segurança do Azure:

Conformidade do Office 365, DLP e Segurança do Azure, Central de
criptografia em repouso para dados Segurança do Azure e logs de auditoria
confidenciais
Comparar o Azure Functions e os Aplicativos Lógicos do Azure

O Functions e os Aplicativos Lógicos são os serviços do Azure que permitem as cargas de trabalho sem servidor. O
Azure Functions é um serviço de computação sem servidor, enquanto os Aplicativos Lógicos do Azure fornecem
fluxos de trabalho sem servidor. Ambos podem criar orquestrações complexas. Uma orquestração é uma coleção
de funções ou etapas, chamadas ações nos Aplicativos Lógicos, que são executadas para realizar uma tarefa
complexa. Por exemplo, para processar um lote de pedidos, você pode executar várias instâncias de uma função em
paralelo, aguardar a conclusão de todas as instâncias e, em seguida, executar uma função que calcula um resultado
na agregação.
Para o Azure Functions, você desenvolve orquestrações escrevendo o código e usando a extensão Durable
Functions. Para os Aplicativos Lógicos, você pode criar orquestrações usando uma GUI ou editando arquivos de
configuração.
Você pode misturar e fazer a correspondência de serviços quando você compila uma orquestração, chamando
funções de aplicativos lógicos e chamando aplicativos lógicos de funções. Escolha como criar cada orquestração
com base em recursos dos serviços ou de sua preferência pessoal. A tabela a seguir lista algumas das principais
diferenças entre esses serviços:
FUNÇÕES DURÁVEIS APLICATIVOS LÓGICOS
Desenvolvimento Primeiro o código (obrigatória) Primeiro o designer (declarativa)
Conectividade Vários tipos de associação integradas, Grande coleção de conectores,

escrever código para associações Enterprise Integration Pack para
personalizadas cenários de B2B, criar conectores
personalizados
Ações Cada atividade é uma função do Azure. Grande coleção de ações predefinidas
Escrever código para funções de
atividade
Monitoramento Azure Application Insights Portal do Azure, Logs do Azure Monitor
Gerenciamento API REST, Visual Studio Portal do Azure, API REST, PowerShell,
Visual Studio
FUNÇÕES DURÁVEIS APLICATIVOS LÓGICOS
Contexto de execução Pode ser executado localmente ou na É executado somente na nuvem

nuvem
Comparar Functions e WebJobs

Como no Azure Functions, o WebJobs do Serviço de Aplicativo do Azure com o SDK do WebJobs é um serviço de
integração com prioridade de código que foi projetado para desenvolvedores. Ambos são criados no Serviço de
Aplicativo do Azure e dão suporte a recursos como integração de controle de origem, autenticação e
monitoramento com integração do Application Insights.
WebJobs e SDK do WebJobs
Use o recurso WebJobs do Serviço de Aplicativo para executar um script ou um código no contexto de um
aplicativo Web do Serviço de Aplicativo. O SDK do WebJobs é uma estrutura projetada para WebJobs que
simplifica o código que você cria para responder a eventos nos serviços do Azure. Por exemplo, você pode
responder à criação de um blob de imagem no Armazenamento do Azure criando uma imagem em miniatura. O
SDK do WebJobs é executado como um aplicativo de console do .NET, que você pode implantar em um WebJob.
O WebJobs e o SDK do WebJobs funcionam melhor em conjunto, mas você pode usar o WebJobs sem o SDK do
WebJobs e vice-versa. Um WebJob pode executar qualquer programa ou script que possa ser executado na área
restrita do Serviço de Aplicativo. Um aplicativo de console do SDK do WebJobs pode ser executado em qualquer
lugar que execute aplicativos de console, como servidores locais.
Tabela de comparação
O Azure Functions se baseia no SDK do WebJobs e, portanto, compartilha muitos dos mesmos gatilhos de evento
e conexões com outros serviços do Azure. Estes são alguns fatores a serem considerados quando você escolher
entre o Azure Functions e o WebJobs com o SDK do WebJobs:
FUNÇÕES WEBJOBS COM O SDK DO WEBJOBS
Modelo de aplicativo sem servidor com ✔

dimensionamento automático
Desenvolver e testar no navegador ✔
Preço de pagamento por uso ✔
Integração com os Aplicativos Lógicos ✔
Eventos de gatilho Timer Timer

Blobs e filas do Armazenamento do Blobs e filas do Armazenamento do
Azure Azure
Filas e tópicos do Barramento de Filas e tópicos do Barramento de
Serviço do Azure Serviço do Azure
Azure Cosmos DB Azure Cosmos DB
Hubs de eventos do Azure Hubs de eventos do Azure
HTTP/WebHook (GitHub, Slack) Sistema de Arquivos
Grade de Eventos do Azure
Idiomas com suporte C# C#1

F#
JavaScript
Java
Python
FUNÇÕES WEBJOBS COM O SDK DO WEBJOBS
Gerenciador de pacotes NPM e NuGet NuGet2
1O WebJobs (sem o SDK do WebJobs) é compatível com C#, Java, JavaScript, Bash, .cmd, .bat, PowerShell, PHP,
TypeScript, Python, entre outros. Essa não é uma lista completa. Um WebJob pode executar qualquer programa ou
script que possa ser executado na área restrita do Serviço de Aplicativo.
2O WebJobs (sem o SDK do WebJobs) dá suporte ao NPM e ao NuGet.
Resumo
O Azure Functions oferece mais produtividade para o desenvolvedor do que o WebJobs do Serviço de Aplicativo
do Azure. Também oferece mais opções de linguagens de programação, ambientes de desenvolvimento, integração
de serviços do Azure e preços. Na maioria dos cenários, é a melhor opção.
Aqui estão dois cenários para os quais o WebJobs pode ser a melhor opção:
Você precisa de mais controle sobre o código que escuta eventos, o objeto JobHost . O Functions oferece um
número limitado de maneiras de personalizar o comportamento do JobHost no arquivo host.json. Às vezes,
você precisa fazer coisas que não podem ser especificadas por uma cadeia de caracteres em um arquivo JSON.
Por exemplo, somente o SDK do WebJobs permite configurar uma política de repetição personalizada para o
Armazenamento do Azure.
Você tem um aplicativo do Serviço de Aplicativo para o qual deseja executar snippets de código e deseja
gerenciá-los juntos no mesmo ambiente do Azure DevOps.
Para outros cenários em que você deseja executar snippets de código para integrar o Azure ou serviços de
terceiros, escolha o Azure Functions em vez do WebJobs com o SDK do WebJobs.
Microsoft Flow, Aplicativos Lógicos, Functions e WebJobs juntos

Você não precisa escolher apenas um desses serviços. Eles se integram entre si e a serviços externos.
Um fluxo pode chamar um aplicativo lógico. Um lógica de aplicativo pode chamar uma função e uma função pode
chamar um aplicativo lógico. Consulte, por exemplo, Criar uma função que se integra aos Aplicativos Lógicos do
Azure.
A integração entre o Microsoft Flow, os Aplicativos Lógicos e o Functions continua melhorando com o tempo.
Você pode criar algo em um serviço e usá-lo em outros serviços.
Obtenha mais informações sobre os serviços de integração usando os seguintes links:
Aproveitando o Azure Functions e o Serviço de Aplicativo do Azure em cenários de integração, por Christopher
Anderson
Integração simplificada, por Charles Lamanna
Webcast ao vivo sobre os Aplicativos Lógicos
Perguntas frequentes sobre o Microsoft Flow
Próximas etapas
Comece criando seu primeiro fluxo, aplicativo lógico ou aplicativo de funções. Selecione um dos seguintes links:
Introdução ao Microsoft Flow
Criar um aplicativo lógico
Como criar a sua primeira função do Azure
Escala e hospedagem no Azure Functions
Ao criar um aplicativo de funções no Azure, você deve escolher um plano de hospedagem para seu aplicativo. Há
três planos de hospedagem disponíveis para Azure Functions: plano de consumo, plano Premiume plano do
serviço de aplicativo.
O plano de hospedagem que você escolher ditará os seguintes comportamentos:
Como seu aplicativo de funções é dimensionado.
Os recursos disponíveis para cada instância do aplicativo de funções.
Suporte para recursos avançados, como conectividade VNET.
Os planos de consumo e Premium adicionam capacidade de computação automaticamente quando seu código
está em execução. Seu aplicativo é escalado horizontalmente quando necessário para lidar com a carga e diminuído
verticalmente quando o código para de ser executado. Para o plano de consumo, você também não precisa pagar
por VMs ociosas ou reservar a capacidade antecipadamente.
O plano Premium fornece recursos adicionais, como instâncias de computação Premium, a capacidade de manter
instâncias quentes indefinidamente e conectividade VNet.
O plano do serviço de aplicativo permite que você aproveite a infraestrutura dedicada, que você gerencia. Seu
aplicativo de funções não é dimensionado com base em eventos, o que significa que nunca é dimensionado para
zero. (Requer que o Always on esteja habilitado.)
NOTE
Você pode alternar entre consumo e planos Premium alterando a propriedade Plan do recurso de aplicativo de funções.
Suporte ao plano de hospedagem

O suporte a recursos se enquadra nas duas categorias a seguir:
Disponibilidade geral (GA ) : suporte completo e aprovado para uso em produção.
Versão prévia: ainda não há suporte total e aprovado para uso em produção.
A tabela a seguir indica o nível de suporte atual para os três planos de hospedagem, quando executado no
Windows ou no Linux:
PLANO DE CONSUMO PLANO PREMIUM PLANO DEDICADO
Windows GA GA GA
Linux GA GA GA
Plano de consumo
Quando você estiver usando o plano de consumo, as instâncias do host Azure Functions serão adicionadas e
removidas dinamicamente com base no número de eventos de entrada. Esse plano sem servidor escala
automaticamente, e você é cobrado pelos recursos de computação apenas durante a execução de suas funções. Em
um plano de consumo, a execução de uma função expire após um período configurável.
A cobrança baseia-se no número de execuções, no tempo de execução e na memória usada. A cobrança é agregada
entre todas as funções em um aplicativo de funções. Para saber mais, confira a página de preços do Azure
Functions.
O plano de Consumo é o plano de hospedagem padrão e oferece os seguintes benefícios:
Pague apenas quando suas funções forem executadas
Escale horizontalmente de forma automática, mesmo durante períodos de carga alta
Os aplicativos de funções na mesma região podem ser atribuídos ao mesmo plano de consumo. Não há nenhuma
desvantagem ou impacto para ter vários aplicativos em execução no mesmo plano de consumo. A atribuição de
vários aplicativos ao mesmo plano de consumo não afeta a resiliência, a escalabilidade ou a confiabilidade de cada
aplicativo.
Para saber mais sobre como estimar os custos durante a execução em um plano de consumo, consulte noções
básicas sobre custos do plano de consumo.
Plano Premium
Quando você estiver usando o plano Premium, as instâncias do host Azure Functions serão adicionadas e
removidas com base no número de eventos de entrada, assim como o plano de consumo. O plano Premium dá
suporte aos seguintes recursos:
Instâncias passivas perpétuas para evitar qualquer início frio
Conectividade de VNet
Duração de execução ilimitada
Tamanhos de instância Premium (um núcleo, duas principais e quatro instâncias de núcleo)
Preços mais previsíveis
Alocação de aplicativo de alta densidade para planos com vários aplicativos de funções
Informações sobre como você pode configurar essas opções podem ser encontradas no documento Azure
Functions plano Premium.
Em vez de cobrança por execução e memória consumida, a cobrança pelo plano Premium é baseada no número de
segundos de núcleo e na memória usada nas instâncias necessárias e pré-configuradas. Pelo menos uma instância
deve estar sempre em espera por plano. Isso significa que há um custo mensal mínimo por plano ativo,
independentemente do número de execuções. Tenha em mente que todos os aplicativos de funções em um plano
Premium compartilham instâncias ativas e pré-configuradas.
Considere o plano Azure Functions Premium nas seguintes situações:
Os aplicativos de funções executam continuamente ou quase continuamente.
Você tem um número alto de execuções pequenas e tem uma cobrança de alta execução, mas a cobrança de
baixo GB por segundo no plano de consumo.
Você precisa de mais opções de CPU ou memória do que o fornecido pelo plano de consumo.
Seu código precisa ser executado por mais tempo do que o máximo permitido no plano de consumo.
Você precisa de recursos que estão disponíveis apenas em um plano Premium, como conectividade VNET/VPN.
Ao executar funções de JavaScript em um plano Premium, você deve escolher uma instância que tenha menos
vCPUs. Para obter mais informações, consulte escolher planos Premium de núcleo único.
Plano dedicado (serviço de aplicativo)

Seus aplicativos de funções também podem ser executados nas mesmas VMs dedicadas que outros aplicativos do
serviço de aplicativo (SKUs Basic, Standard, Premium e Isolated).
Considere um plano do serviço de aplicativo nas seguintes situações:
Você tem VMs subutilizadas que já estão executando outras instâncias do Serviço de Aplicativo.
Você deseja fornecer uma imagem personalizada na qual executar suas funções.
Você paga o mesmo para aplicativos de funções em um plano do serviço de aplicativo como faria para outros
recursos do serviço de aplicativo, como aplicativos Web. Para obter detalhes sobre como o plano do Serviço de
Aplicativo funciona, consulte Visão geral detalhada de planos de Serviço de Aplicativo do Azure.
Com um plano do serviço de aplicativo, você pode escalar horizontalmente manualmente Adicionando mais
instâncias de VM. Você também pode habilitar o dimensionamento automático. Para saber mais, confira
Dimensionar a contagem de instâncias manual ou automaticamente. Você também pode escalar verticalmente
escolhendo um plano do Serviço de Aplicativo diferente. Para obter mais informações, consulte Escalar
verticalmente um aplicativo no Azure.
Ao executar funções JavaScript em um plano do Serviço de Aplicativo, você deve escolher um plano que tenha
menos vCPUs. Para obter mais informações, consulte escolher planos de serviço de aplicativo de núcleo único.
Always On
Se executar em um plano do Serviço de Aplicativo, você deverá habilitar a configuração Always On para que o
aplicativo de funções execute corretamente. Em um plano do Serviço de Aplicativo, o tempo de execução das
funções ficará ocioso após alguns minutos de inatividade, portanto, apenas gatilhos HTTP "despertarão" suas
funções. Always On está disponível apenas em um plano de Serviço de Aplicativo. Em um plano de Consumo, a
plataforma ativa automaticamente os aplicativos de função.
Duração do tempo limite do aplicativo de funções

A duração do tempo limite de um aplicativo de funções é definida pela propriedade functionTimeout no arquivo de
projeto host. JSON . A tabela a seguir mostra os valores padrão e máximo em minutos para ambos os planos e em
ambas as versões de tempo de execução:
VERSÃO DE TEMPO DE
PLANO EXECUÇÃO OS MÁXIMO
Consumo 1.x 5 10
Consumo 2. x 5 10
Consumo 3. x (visualização) 5 10
Serviço de aplicativo 1.x Ilimitado Ilimitado
Serviço de aplicativo 2. x 30 Ilimitado
Serviço de aplicativo 3. x (visualização) 30 Ilimitado
NOTE
Independentemente da configuração do tempo limite do aplicativo de funções, 230 segundos é a quantidade máxima de
tempo que uma função disparada por HTTP pode levar para responder a uma solicitação. Isso ocorre devido ao tempo limite
de ociosidade padrão de Azure Load Balancer. Para tempos de processamento mais longos, considere usar o padrão
assíncrono Durable Functions ou adiar o trabalho real e retornar uma resposta imediata.
Mesmo com Always On habilitado, o tempo limite de execução para funções individuais é controlado pela
configuração functionTimeout no arquivo de projeto host.json.
Determinar o plano de Hospedagem de um aplicativo existente

Para determinar o plano de hospedagem usado pelo aplicativo de funções, consulte plano do Serviço de
Aplicativo/tipo de preço na guia Visão geral do aplicativo de funções no portal do Azure. Para planos do
Serviço de Aplicativo, o tipo de preço também é indicado.
Também é possível usar a CLI do Azure para determinar o plano, da seguinte maneira:
appServicePlanId=$(az functionapp show --name <my_function_app_name> --resource-group <my_resource_group> --

query appServicePlanId --output tsv)
az appservice plan list --query "[?id=='$appServicePlanId'].sku.tier" --output tsv
Quando a saída desse comando for dynamic , o aplicativo de funções estará no plano de Consumo. Quando a saída
desse comando for ElasticPremium , seu aplicativo de funções estará no plano Premium. Todos os outros valores
indicam diferentes camadas de um plano do serviço de aplicativo.
Requisitos da conta de armazenamento

Em qualquer plano, um aplicativo de funções requer uma conta de armazenamento do Azure geral, que dá suporte
ao blob do Azure, à fila, aos arquivos e ao armazenamento de tabelas. Isso ocorre porque o Functions depende do
Armazenamento do Microsoft Azure para operações como o gerenciamento de gatilhos e execuções de funções de
registro em log, mas algumas contas de armazenamento não dão suporte a filas e tabelas. Essas contas, que
incluem contas de armazenamento somente blob (incluindo armazenamento Premium) e contas de
armazenamento para uso geral com replicação de armazenamento com redundância de zona, são filtradas das
seleções da Conta de Armazenamento existente quando você cria um aplicativo de funções.
A mesma conta de armazenamento usada por seu aplicativo de funções também pode ser usada por seus gatilhos
e associações para armazenar os dados do aplicativo. No entanto, para operações com uso intensivo de
armazenamento, você deve usar uma conta de armazenamento separada.
Para saber mais sobre os tipos de conta de armazenamento, consulte Apresentando os serviços de armazenamento
do Azure.
Como funcionam os planos de consumo e Premium

Nos planos de consumo e Premium, a infraestrutura de Azure Functions escala recursos de CPU e memória
adicionando instâncias adicionais do host do functions, com base no número de eventos em que suas funções são
disparadas. Cada instância do host do Functions no plano de consumo é limitada a 1,5 GB de memória e uma CPU.
Uma instância do host é o aplicativo de funções inteiro, o que significa que todas as funções em um aplicativo de
funções compartilham recursos dentro de uma instância e são dimensionadas ao mesmo tempo. Os aplicativos de
funções que compartilham o mesmo plano de consumo são dimensionados de forma independente. No plano
Premium, o tamanho do plano determinará a memória disponível e a CPU para todos os aplicativos nesse plano
nessa instância.
Os arquivos de código de função são armazenados em compartilhamentos de arquivos do Azure na conta de
armazenamento principal da função. Quando você exclui a conta de armazenamento principal do aplicativo de
funções, os arquivos de código de função são excluídos e não podem ser recuperados.
Escalonamento de tempo de execução
O Azure Functions usa um componente chamado controlador de escala para monitorar a taxa de eventos e
determinar se deve aumentar ou reduzir. O controlador de escala usa heurística para cada tipo de gatilho. Por
exemplo, ao usar um gatilho do armazenamento de Filas do Azure, ele escala com base no tamanho da fila e na
idade da mensagem em fila mais antiga.
A unidade de escala para Azure Functions é o aplicativo de funções. Quando o aplicativo de funções é
dimensionado na horizontal, mais recursos são alocados para executar várias instâncias do host do Azure
Functions. Em contrapartida, quando a demanda por computação é reduzida, o controlador de escala remove as
instâncias do host de função. O número de instâncias é eventualmente reduzido a zero quando nenhuma função
está em execução em um aplicativo de funções.
Noções básicas dos comportamentos de dimensionamento

O dimensionamento pode variar em uma série de fatores e ser diferente com base no gatilho e na linguagem
selecionada. Há algumas complexidades de comportamentos de dimensionamento a serem considerados:
Um único aplicativo de funções será escalado verticalmente somente para um máximo de 200 instâncias. Uma
única instância pode processar mais de uma mensagem ou solicitação por vez, portanto, não há um limite
definido de número de execuções simultâneas.
Para gatilhos HTTP, novas instâncias só serão alocadas no máximo uma vez a cada 1 segundo.
Para gatilhos não HTTP, novas instâncias só serão alocadas no máximo uma vez a cada 30 segundos.
Gatilhos diferentes também podem ter diferentes limites de dimensionamento, como documentado abaixo:
Hub de Evento
Melhores práticas e padrões para aplicativos escalonáveis
Há muitos aspectos de um aplicativo de funções que afetarão a qualidade da escala, incluindo a configuração do
host, o espaço de tempo de execução e a eficiência dos recursos. Para obter mais informações, consulte a seção de
escalabilidade do artigo sobre considerações de desempenho. Adicionalmente, é necessário que você saiba como
as conexões se comportam na medida em que o aplicativo de funções é dimensionado. Para saber mais, confira
Como gerenciar conexões no Azure Functions.
Modelo de cobrança
A cobrança pelos diferentes planos é descrita em detalhes na página de preços de Azure Functions. O uso é
agregado no nível do aplicativo de funções e conta apenas o tempo durante o qual o código de função é executado.
Veja a seguir as unidades de cobrança:
Consumo de recursos em GB/s (gigabyte por segundo) . Calculado como uma combinação do tamanho da
memória e o tempo de execução para todas as funções dentro de um aplicativo de Funções.
Execuções. Contadas toda vez que uma função é executada em resposta a um gatilho de evento.
Consultas e informações úteis sobre como entender sua fatura de consumo podem ser encontradas nas perguntas
frequentes sobre cobrança.
Limites de serviço
A tabela a seguir indica os limites que se aplicam a aplicativos de funções ao serem executados em vários planos de
hospedagem:
PLANO DE SERVIÇO DE
GRUPOS PLANO DE CONSUMO PLANO PREMIUM APLICATIVO1
Expansão Controlado por evento Controlado por evento Manual/dimensionamento

automático
Máximo de instâncias 200 20 10-20
Duração do tempo limite 5 30 302

padrão (min)
Duração máxima de tempo 10 não associado Não associado3

limite (min)
Máximo de conexões de 600 ativo (total de 1200) não associado não associado
saída (por instância)
Tamanho máximo da 100 100 100

solicitação (MB)4
Tamanho máximo da cadeia 4096 4096 4096

de caracteres de consulta4
Comprimento máximo da 8192 8192 8192

URL de solicitação4
ACU por instância 100 210-840 100-840

GRUPOS PLANO DE CONSUMO PLANO PREMIUM APLICATIVO
Memória máxima (GB por 1.5 3,5-14 1,75-14

instância)
Aplicativos de funções por 100 100 Não associado5

plano
Planos do Serviço de 100 por região 100 por grupo de recursos 100 por grupo de recursos
Aplicativo
Armazenamento6 1 GB 250 GB 50-1000 GB
Domínios personalizados por 5007 500 500

aplicativo
domínio personalizado conexão SSL SNI não conexões SSL SNI não conexões SSL SNI não
Suporte a SSL vinculada incluída associadas e 1 IP SSL associadas e 1 IP SSL
incluídas incluídas
1 para limites específicos para as várias opções do plano do serviço de aplicativo, consulte os limites do plano do
serviço de aplicativo.
2 por padrão, o tempo limite para o tempo de execução do Functions 1. x em um plano do serviço de aplicativo é
não associado.
3 requer que o plano do serviço de aplicativo seja definido como Always on. Pague com tarifaspadrão.
4 esses limites são definidos no host.
5 o número real de aplicativos de funções que você pode hospedar depende da atividade dos aplicativos, do
tamanho das instâncias de máquina e da utilização de recursos correspondente.

6 o limite de armazenamento é o tamanho total do conteúdo no armazenamento temporário em todos os
aplicativos no mesmo plano do serviço de aplicativo. O plano de consumo usa os arquivos do Azure para
armazenamento temporário.
7 quando seu aplicativo de funções está hospedado em um plano de consumo, somente a opção CNAME tem
suporte. Para aplicativos de funções em um plano Premium ou um plano do serviço de aplicativo, é possível
mapear um domínio personalizado usando um registro CNAME ou um.
Criar sua primeira função usando o Visual Studio
O Azure Functions lhe permite executar seu código em um ambiente sem servidor sem que seja preciso primeiro
criar uma VM ou publicar um aplicativo Web.
Neste artigo, você aprenderá a usar o Visual Studio 2019 para criar e testar localmente uma função “olá, mundo”
e publicá-la no Azure. Este início rápido foi criado para o Visual Studio 2019. Ao criar um projeto do Functions
usando o Visual Studio 2017, é necessário instalar primeiro as ferramentas de Azure Functions mais recentes.
Pré-requisitos
Para concluir este tutorial, é necessário instalar primeiro o Visual Studio 2019. Garanta que a carga de trabalho
de desenvolvimento do Azure também seja instalada.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
Crie um projeto de aplicativo de funções

O modelo de projeto do Azure Functions no Visual Studio cria um projeto que pode ser publicado em um
aplicativo de funções no Azure. Você pode usar um aplicativo de funções para as funções do grupo como uma
unidade lógica para gerenciamento, implantação e compartilhamento de recursos.
1. No Visual Studio, no menu Arquivo, selecione Novo > Projeto.
2. Na caixa de diálogo Criar um projeto, pesquise functions , escolha o modelo do Azure Functions e
selecione Avançar.
3. Insira um nome para seu projeto e selecione Criar. O nome do aplicativo de funções deve ser válido como
um namespace do C# e, portanto, não use outros caracteres não alfanuméricos, hífens ou sublinhados.
4. Em Criar um aplicativo Azure Functions, use as opções a seguir:
Azure Functions v2 (.NET Core) 1
Gatilho HTTP
Conta de Armazenamento: Emulador de armazenamento
Nível de autorização: Anônimo
OPÇÃO VALOR SUGERIDO DESCRIÇÃO
Tempo de execução do Functions Azure Functions 2.x Essa configuração cria um projeto de
(.NET Core) função que usa o tempo de
execução versão 2.x do Azure
Functions, o qual dá suporte a .NET
Core. O Azure Functions 1.x dá
suporte ao .NET Framework. Para
obter mais informações, consulte
Direcionar o tempo de execução do
Azure Functions.
Modelo de função Gatilho HTTP Essa configuração cria uma função

acionada por uma solicitação HTTP.
Conta de armazenamento Emulador de armazenamento Um gatilho HTTP não usa a conexão

da conta de Armazenamento do
Microsoft Azure. Todos os outros
tipos de gatilho exigem uma cadeia
de conexão de conta de
armazenamento válida. Como o
Functions requer uma conta de
armazenamento, uma é atribuída ou
criada quando você publica seu
projeto no Azure.
Nível de autorização Anônimo A função criada pode ser acionada

por qualquer cliente sem fornecer
uma chave. Essa configuração de
autorização torna fácil testar a nova
função. Para obter mais informações
sobre chaves e autorização, consulte
Chaves de autorização no
associações HTTP e webhook.
NOTE
Verifique se você definiu o Nível de autorização como Anonymous . Se você escolher o nível padrão de
Function , é necessário que você apresente a chave da função em solicitações para acessar seu ponto de
extremidade da função.
5. Selecione Criar para criar o projeto de função e a função disparada por HTTP.
O Visual Studio cria um projeto e uma classe que contém o código clichê do tipo de função do gatilho HTTP. O
atributo FunctionName no método define o nome da função, que é HttpTrigger por padrão. O atributo
HttpTrigger especifica que a função é disparada por uma solicitação HTTP. O código padronizado envia uma
resposta HTTP que inclui um valor do corpo de solicitação ou da cadeia de consulta.
É possível estender as funcionalidades de sua função usando associações de entrada e de saída aplicando os
atributos adequados ao método. Para obter mais informações, consulte a seção Gatilhos e associações da
referência do desenvolvedor C# do Azure Functions.
Agora que você criou o seu projeto de função e uma função disparada por HTTP, poderá testá-la em seu
computador local.
Executar a função localmente

O Visual Studio integra-se ao Azure Functions Core Tools para que você possa testar suas funções localmente
usando o tempo de execução completo do Functions.
1. Para executar a função, pressione F5. É necessário habilitar a exceção de firewall para que as ferramentas
possam lidar com solicitações HTTP. Os níveis de autorização nunca são impostos quando estão em
execução localmente.
2. Copie a URL da sua função da saída de tempo de execução do Azure Functions.
3. Cole a URL para a solicitação HTTP na barra de endereços do navegador. Acrescente o valor de cadeia de
consulta ?name=<YOUR_NAME> a essa URL e execute a solicitação. O exemplo a seguir mostra a resposta no
navegador à solicitação GET local retornada pela função:
4. Para interromper a depuração, pressione Shift + F5.

Após verificar se a função foi executada corretamente no computador local, é hora de publicar o projeto no
Azure.
Publicar o projeto no Azure

Você deve ter um aplicativo de funções em sua assinatura do Azure antes de publicar seu projeto. A publicação
do Visual Studio cria um aplicativo de funções para você na primeira vez que você publica seu projeto.
1. No Gerenciador de Soluções, clique com o botão direito do mouse no nome do projeto e selecione
Publicar.
2. Na caixa de diálogo Selecione um destino de publicação, use as opções publicar, conforme
especificado na tabela embaixo da imagem:
OPÇÃO DESCRIÇÃO
Plano de consumo do Azure Functions Quando você publica seu projeto em um aplicativo de
funções executado em um Plano de consumo, você paga
apenas pelas execuções do seu aplicativo de funções.
Outros planos de hospedagem incorrem em custos mais
altos. Para saber mais, confira Escala e hospedagem do
Azure Functions.
Criar novo Um novo aplicativo de funções com recursos relacionados

é criado no Azure. Quando você escolhe selecionar
existente, todos os arquivos no aplicativo de funções
existente no Azure são substituídos pelos arquivos do
projeto local. Use essa opção somente quando republicar
atualizações para um aplicativo de funções existente.
Executar com base no arquivo de pacote Seu aplicativo de funções é implantado usando a
Implantação de Zip com o modo Run-From-Package
habilitado. Essa é a maneira recomendada de executar
suas funções, que resulta em um melhor desempenho.
Quando não estiver usando essa opção, verifique se você
interrompeu a execução local do projeto de aplicativo de
funções antes de publicar no Azure.
3. Selecione Publicar. Se você ainda não entrou em sua conta do Azure do Visual Studio, selecione Entrar.
Também é possível criar uma conta gratuita do Azure.
4. No Serviço de Aplicativo: Criar, use as configurações de Hospedagem conforme especificadas na
tabela embaixo da imagem:
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO
Nome Nome globalmente exclusivo Nome que identifica seu novo

aplicativo de funções de forma
exclusiva. Os caracteres válidos são
a-z , 0-9 e - .
Assinatura Escolha sua assinatura A assinatura do Azure a utilizar.
Grupo de Recursos myResourceGroup Nome do grupo de recursos no qual

criar o seu aplicativo de funções.
Escolha Novo para criar um novo
grupo de recursos.
Plano de hospedagem Plano de consumo Escolha o Consumo em Tamanho

após selecionar Novo para criar um
plano sem servidor. Também, escolha
um Local em uma região perto de
você ou perto de outros serviços
que suas funções acessam. Quando
você executa em um plano diferente
de Consumo, deve gerenciar o
dimensionamento de seu aplicativo
de funções.
Armazenamento do Azure Conta de armazenamento para uso Uma conta de armazenamento do

geral Azure é necessária para o tempo de
execução de funções. Selecione
Novo para criar uma conta de
armazenamento para uso geral.
Você também pode usar uma conta
existente que atenda aos requisitos
da conta de armazenamento.
5. Selecione Criar para criar um aplicativo de funções e recursos relacionados no Azure com essas
configurações e implantar seu código de projeto de função.
6. Após a conclusão da implantação, anote o valor da URL do Site, que é o endereço do seu aplicativo de
funções no Azure.
Testar sua função no Azure

1. Copie a URL base do aplicativo de funções da página de perfil de publicação. Substitua a parte
localhost:port da URL que você usou ao testar a função localmente pela nova URL base. Como
anteriormente, acrescente o valor de cadeia de consulta ?name=<YOUR_NAME> a essa URL e execute a
solicitação.
A URL que chama a função HTTP disparada deve ser no seguinte formato:
http://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?name=<YOUR_NAME>
2. Cole essa nova URL para a solicitação HTTP na barra de endereços do navegador. O exemplo a seguir
mostra a resposta no navegador à solicitação GET remota retornada pela função:
Próximas etapas
Você usou o Visual Studio para criar e publicar um aplicativo de funções C# no Azure com uma função disparada
por HTTP simples. Para saber mais sobre como desenvolver funções como bibliotecas de classes do .NET,
consulte Referência do desenvolvedor de C# do Azure Functions.
Adicionar uma associação de fila do Armazenamento do Azure à sua função
Início Rápido: Usar o Java e o Maven para criar e
publicar uma função no Azure
Este artigo mostra como criar e publicar uma função Java no Azure Functions com a ferramenta de linha de
comando Maven. Quando você terminar, o código de função será executado no Azure em um plano de
hospedagem sem servidor e será disparado por uma solicitação HTTP.
Pré-requisitos
Para desenvolver funções usando Java, você deve ter o seguinte instalado:
Java Developer Kit, versão 8
Apache Maven, versão 3.0 ou posterior
CLI do Azure
Azure Functions Core Tools versão 2.6.666 ou posterior
Uma assinatura do Azure.
IMPORTANT
A variável de ambiente JAVA_HOME deve ser definida como o local de instalação do JDK para concluir este guia de
início rápido.
Gerar um novo projeto do Functions

Em uma pasta vazia, execute o seguinte comando para gerar o projeto do Functions a partir de um
arquétipo Maven.
Linux/macOS
mvn archetype:generate \
-DarchetypeGroupId=com.microsoft.azure \
-DarchetypeArtifactId=azure-functions-archetype
NOTE
Se você estiver com problemas com a execução do comando, verifique qual versão do maven-archetype-plugin é
usada. Como você está executando o comando em um diretório vazio sem nenhum arquivo .pom , ele pode estar
tentando usar um plug-in da versão mais antiga do
~/.m2/repository/org/apache/maven/plugins/maven-archetype-plugin , se você atualizou o Maven de uma
versão anterior. Nesse caso, tente excluir o diretório maven-archetype-plugin e executar novamente o comando.
Windows
mvn archetype:generate `
"-DarchetypeGroupId=com.microsoft.azure" `
"-DarchetypeArtifactId=azure-functions-archetype"
mvn archetype:generate ^
"-DarchetypeGroupId=com.microsoft.azure" ^
"-DarchetypeArtifactId=azure-functions-archetype"
O Maven solicita os valores necessários para concluir a geração do projeto na implantação. Forneça os
seguintes valores quando solicitado:
VALOR DESCRIÇÃO
groupId Um valor que identifica exclusivamente o projeto em todos

os projetos, seguindo as regras de nomenclatura do
pacote para Java. Os exemplos deste início rápido usam
com.fabrikam.functions .
artifactId Um valor que é o nome do jar, sem um número de versão.

Os exemplos deste início rápido usam
fabrikam-functions .
version Escolha o valor padrão 1.0-SNAPSHOT .
package Um valor que é o pacote Java para o código de função

gerado. Use o padrão. Os exemplos deste início rápido
usam com.fabrikam.functions .
appName Nome global exclusivo que identifica seu novo aplicativo

de funções no Azure. Use o padrão, que é a artifactId
acrescentada a um número aleatório. Anote esse valor;
você precisará dele mais tarde.
appRegion Escolha uma região perto de você ou perto de outros

serviços que suas funções acessam. O padrão é westus .
Execute este comando da CLI do Azure para obter uma
lista de todas as regiões:
az account list-locations --query '[].
{Name:name}' -o tsv
resourceGroup Nome do novo grupo de recursos no qual o aplicativo de

funções será criado. Use myResourceGroup , que é usado
pelos exemplos neste início rápido. Um grupo de recursos
precisa ser exclusivo em sua assinatura do Azure.
Digite Y ou pressione Enter para confirmar.

O Maven cria os arquivos de projeto em uma nova pasta com o nome artifactId, que, neste exemplo, é
fabrikam-functions .
Abra o novo arquivo Function.java do caminho src/main/java em um editor de texto e examine o código
gerado. Esse código é uma função disparada por HTTP que ecoa o corpo da solicitação.

Execute o seguinte comando, que altera o diretório para a pasta de projeto recém-criada e, em seguida,
compila e executa o projeto de função:
cd fabrikam-function
mvn clean package
mvn azure-functions:run
Você verá uma saída semelhante à seguinte no Azure Functions Core Tools quando executar o projeto
localmente:
...
Now listening on: http://0.0.0.0:7071

Application started. Press Ctrl+C to shut down.
Http Functions:
HttpTrigger-Java: [GET,POST] http://localhost:7071/api/HttpTrigger-Java

...
Dispare a função na linha de comando usando o cURL em uma nova janela de terminal:
curl -w "\n" http://localhost:7071/api/HttpTrigger-Java --data AzureFunctions
Hello AzureFunctions!
A chave de função não é necessária na execução local. Use Ctrl+C no terminal para interromper o código
da função.
Implantar a função no Azure

Um aplicativo de funções e os recursos relacionados são criados no Azure quando você implanta o
aplicativo de funções pela primeira vez. Para fazer a implantação, use o comando az login da CLI do Azure
para entrar em sua assinatura do Azure.
az login
TIP
Caso a sua conta possa acessar várias assinaturas, use az account set para definir a assinatura padrão para essa
sessão.
Use o comando do Maven a seguir para implantar o projeto em um novo aplicativo de funções.
mvn azure-functions:deploy
Este destino azure-functions:deploy do Maven cria os seguintes recursos no Azure:

Grupo de recursos. Nomeado com o resourceGroup fornecido.
Conta de armazenamento. Necessária para o Functions. O nome é gerado aleatoriamente de acordo com
os requisitos de nome da conta de armazenamento.
Plano do Serviço de Aplicativo. Hospedagem sem servidor para o aplicativo de funções na appRegion
especificada. O nome é gerado aleatoriamente.
Aplicativo de funções. Um aplicativo de funções é a unidade de implantação e execução para suas
funções. O nome é o appName, acrescentado a um número gerado aleatoriamente.
A implantação também empacota os arquivos de projeto e implanta-os no novo aplicativo de funções
usando zip deployment, com o modo run-from-package habilitado.
Após a conclusão da implantação, você verá a URL que poderá usar para acessar os pontos de extremidade
do aplicativo de funções. Como o gatilho HTTP que publicamos usa
authLevel = AuthorizationLevel.FUNCTION , você precisa obter a chave de função para chamar o ponto de
extremidade da função via HTTP. A maneira mais fácil de obter a chave de função é no portal do Azure.
Obter a URL do gatilho HTTP

Obtenha a URL necessária para disparar a função, com a chave de função, no portal do Azure.
1. Navegue até o portal do Azure, entre nele, digite o appName do aplicativo de funções em Pesquisar
na parte superior da página e pressione Enter.
2. No aplicativo de funções, expanda Funções (Somente Leitura) , selecione a função e, em seguida,
selecione </> Obter URL da função no canto superior direito.
3. Escolha padrão (Chave de função) e selecione Copiar.

Agora você pode usar a URL copiada para acessar a função.
Verificar a função no Azure

Para verificar o aplicativo de funções em execução no Azure usando cURL , substitua a URL da amostra
abaixo pela URL copiada do portal.
curl -w "\n" https://fabrikam-functions-20190929094703749.azurewebsites.net/api/HttpTrigger-Java?

code=zYRohsTwBlZ68YF.... --data AzureFunctions
Isso envia uma solicitação POST ao ponto de extremidade da função com AzureFunctions no corpo da
solicitação. Você verá a resposta a seguir.
Hello AzureFunctions!
Próximas etapas
Você criou um projeto de funções Java com uma função disparada por HTTP, executou-o no computador
local e implantou-o no Azure. Agora, estenda sua função por meio da...
Adição de uma associação de saída de fila do Armazenamento do Azure
Code
O Azure Functions lhe permite executar seu código em um ambiente sem servidor sem que seja preciso
primeiro criar uma VM ou publicar um aplicativo Web.
Neste artigo, você aprenderá a usar a extensão Azure Functions para Visual Studio Code para criar e testar
uma função "hello world" no computador local usando o Microsoft Visual Studio Code. Em seguida, você
publicará o código de função no Azure do Visual Studio Code.
A extensão atualmente dá suporte a funções C#, JavaScript, Java e Python. As etapas neste artigo e no artigo
seguinte são compatíveis somente com as funções JavaScript e C#. Para saber como usar o Visual Studio
Code para criar e publicar funções do Python, veja Implantar Python no Azure Functions. Para saber como
usar o Visual Studio Code para criar e publicar funções do PowerShell, veja Criar sua primeira função do
PowerShell no Azure.
Atualmente, a extensão está em versão prévia. Para obter mais informações, consulte a página da extensão
Extensão Azure Functions para Visual Studio Code.
Pré-requisitos
Para concluir este guia de início rápido:
Instale o Visual Studio Code em uma das plataformas compatíveis.
Instale a versão 2.x do Azure Functions Core Tools.
Instale os requisitos específicos para a linguagem de programação escolhida:
LINGUAGEM REQUISITO
C# Extensão C#
JavaScript Node.js*
* Active LTS e versões LTS de manutenção (8.11.1 e 10.14.1 recomendadas).

Instalar a extensão do Azure Functions

É possível usar a extensão do Azure Functions para criar e testar funções e implantá-las no Azure.
1. No Visual Studio Code, abra Extensões e pesquise azure functions ou selecione este link no Visual
Studio Code.
2. Selecione Instalar para instalar a extensão do Visual Studio Code:
3. Reinicie o Visual Studio Code e selecione o ícone do Azure na barra Atividade. Você deve ver uma área
do Azure Functions na barra lateral.
Criar seu projeto do Functions com uma função
O modelo de projeto do Azure Functions no Visual Studio Code cria um projeto que pode ser publicado em
um aplicativo de funções no Azure. Um aplicativo de funções permite a você agrupar funções como uma
unidade lógica para o gerenciamento, implantação e compartilhamento de recursos.
1. No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos,
pesquise e selecione Azure Functions: Create new project... .
2. Escolha um local de diretório para o workspace do projeto e escolha Selecionar.
NOTE
Estas etapas foram projetadas para serem concluídas fora de um workspace. Nesse caso, não selecione uma
pasta de projeto que faz parte de um workspace.
3. Após os prompts, forneça as seguintes informações:
PROMPT VALOR DESCRIÇÃO
Selecione uma linguagem de C# ou JavaScript Este artigo é compatível com C# e

programação para o seu projeto de JavaScript. Para Python, consulte
aplicativo de função. neste artigo do Python e para
PowerShell, consulte este artigo do
PowerShell.
Selecione um modelo para a Gatilho HTTP Crie uma função disparada por
primeira função do projeto HTTP no novo aplicativo de
funções.
Forneça um nome de função HttpTrigger Pressione Enter para usar o nome

padrão.
Forneça um namespace My.Functions (Somente C#) As bibliotecas de

classe C# devem ter um
namespace.
Nível de autorização Função Requer uma tecla de função para

chamar o ponto de extremidade
HTTP da função.
Selecione como você gostaria de Adicionar ao workspace Cria o aplicativo de funções no

abrir seu projeto workspace atual.
O Visual Studio Code cria o projeto de aplicativo de função em um novo workspace. Este projeto contém os
arquivos de configuração host.json e local.settings.json, além de quaisquer arquivos de projeto específicos a
uma linguagem.
Uma nova função disparada por HTTP também é criada na pasta HttpTrigger do projeto do aplicativo de
função.

As Ferramentas Principais do Azure Functions permitem executar um projeto do Azure Functions no seu
computador de desenvolvimento local.
1. Para testar sua função, defina um ponto de interrupção no código da função e pressione F5 para iniciar
o projeto de aplicativo de funções. A saída do Core Tools é exibida no painel Terminal.
2. No painel Terminal, copie o ponto de extremidade de URL da sua função disparada por HTTP.
3. Cole a URL para a solicitação HTTP na barra de endereços do navegador. Acrescente o valor de cadeia
de consulta ?name=<yourname> a essa URL e execute a solicitação. A execução é pausada quando o
ponto de interrupção é atingido.
4. Quando você continua a execução, o exemplo a seguir mostra a resposta no navegador à solicitação
GET:

Azure.
Entrar no Azure
Antes de poder publicar seu aplicativo, você precisa entrar no Azure.
1. Na área Azure: Functions, escolha Entrar no Azure… . Se você não tiver uma, poderá Criar uma
conta gratuita do Azure.
2. Quando solicitado, selecione Copiar e abrir, ou copie o código exibido e abra

https://aka.ms/devicelogin no seu navegador.
3. Cole o código copiado na página Logon do dispositivo, verifique a entrada para o Visual Studio Code
e selecione Continuar.
4. Conclua a entrada usando as credenciais da conta do Azure. Depois de entrar com sucesso, você pode
fechar o navegador.

O Visual Studio Code permite que você publique seu projeto de funções diretamente no Azure. No processo,
você criará um aplicativo de funções e recursos relacionados em sua assinatura do Azure. O aplicativo de
funções fornece um contexto de execução para suas funções. O projeto é empacotado e implantado para o
novo aplicativo de função em sua assinatura do Azure.
Por padrão, o Visual Studio Code cria todos os recursos do Azure necessários para criar seu aplicativo de
funções. Os nomes desses recursos são baseados no nome do aplicativo de funções escolhido. Se precisar ter
controle total sobre os recursos criados, você pode publicar usando opções avançadas.
Esta seção pressupõe que você está criando um novo aplicativo de funções no Azure.
IMPORTANT
Publicar em um aplicativo de funções existente substitui o conteúdo desse aplicativo no Azure.
1. No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos,
pesquise e selecione Azure Functions: Deploy to function app... .
2. Se você ainda não estiver conectado, será solicitado a Entrar no Azure. Você também pode Criar uma
conta gratuita do Azure. Após entrar pelo navegador, volte ao Visual Studio Code.
3. Se você tiver mais de uma assinatura, Escolha uma assinatura para o aplicativo de funções e, em
seguida, escolha + Criar novo aplicativo de funções no Azure.
4. Digite um nome globalmente exclusivo que identifica seu aplicativo de funções e pressione Enter.
Caracteres válidos para um nome de aplicativo de funções são a-z , 0-9 e - .
Quando você pressiona Enter, os seguintes recursos do Azure são criados em sua assinatura:
Grupo de recursos : Contém todos os recursos criados do Azure. O nome é baseado no nome de
seu aplicativo de funções.
Conta de armazenamento : Uma conta de armazenamento padrão é criada com um nome
exclusivo baseado no nome de seu aplicativo de funções.
Plano de hospedagem : Um plano de consumo é criado na região Oeste dos EUA para hospedar
seu aplicativo de funções sem servidor.
Aplicativo de funções: Seu projeto é implantado e executado no novo aplicativo de funções.
Uma notificação é exibida depois que seu aplicativo de funções é criado e o pacote de implantação é
aplicado. Escolha Exibir Saída nessa notificação para exibir a criação e os resultados da implantação,
incluindo os recursos do Azure que você criou.
5. De volta na área Azure: Functions, expanda o novo aplicativo de funções em sua assinatura. Expanda
Funções, clique com botão direito do mouse em HttpTrigger e, em seguida, escolha Copiar URL da
função.
Executar a função no Azure
1. Copie a URL do gatilho de HTTP do painel Saída. Essa URL inclui a chave de função, que é passada
para o parâmetro de consulta code . Assim como anteriormente, certifique-se de adicionar o valor de
cadeia de caracteres de consulta ?name=<yourname> a essa URL e execute a solicitação.
A URL que chama a função HTTP disparada deve estar no seguinte formato:
http://<functionappname>.azurewebsites.net/api/<functionname>?code=<function_key>&name=<yourname>
2. Cole essa nova URL para a solicitação HTTP na barra de endereços do navegador. O exemplo a seguir
mostra a resposta no navegador à solicitação GET remota retornada pela função:
Próximas etapas
Você usou o Visual Studio Code para criar um aplicativo de funções com uma função disparada por HTTP
simples. No próximo artigo, você pode expandir essa função adicionando uma associação de saída. Essa
associação grava a cadeia de caracteres da solicitação HTTP em uma mensagem em uma fila do
Armazenamento de Filas do Azure. O próximo artigo também mostra como limpar esses novos recursos do
Azure, removendo o grupo de recursos que você criou.
Adicionar uma associação de fila do Armazenamento do Azure à sua função
Criar sua primeira função do PowerShell no Azure
Este artigo de Início Rápido explica como criar sua primeira função sem servidor do PowerShell usando o Visual
Studio Code.
Você usará a Extensão Azure Functions para Visual Studio Code para criar uma função do PowerShell
localmente e, em seguida, implantá-la em um novo aplicativo de funções no Azure. Atualmente, a extensão está
em versão prévia. Para obter mais informações, consulte a página da extensão Extensão Azure Functions para
Visual Studio Code.
NOTE
No momento, o suporte do PowerShell para a extensão do Azure Functions está desabilitado por padrão. A habilitação do
suporte do PowerShell é uma das etapas deste artigo.
As etapas a seguir são compatíveis com macOS, Windows e sistemas operacionais baseados em Linux.
Pré-requisitos
Instale o PowerShell Core
Instale o Visual Studio Code em uma das plataformas compatíveis.
Instale a extensão do PowerShell para Visual Studio Code.
Instale o SDK do .NET Core 2.2 e posterior (necessário para o Azure Functions Core Tools e disponível
em todas as plataformas compatíveis).
Instale a versão 2.x do Azure Functions Core Tools.
Você também precisará de uma assinatura ativa do Azure.

Studio Code.
3. Reinicie o Visual Studio Code e selecione o ícone do Azure na barra Atividade. Você deve ver uma área do
Azure Functions na barra lateral.
Crie um projeto de aplicativo de funções
O modelo de projeto do Azure Functions no Visual Studio Code cria um projeto que pode ser publicado em um
aplicativo de funções no Azure. Um aplicativo de funções permite a você agrupar funções como uma unidade
lógica para o gerenciamento, implantação e compartilhamento de recursos.
1. No Visual Studio Code, selecione o logotipo do Azure para exibir a área Azure: Functions e, em seguida,
selecione o ícone Criar Projeto.
2. Escolha uma localização para seu workspace do projeto do Functions e escolha Selecionar.
NOTE
Este artigo foi projetado para ser concluídas fora de um workspace. Nesse caso, não selecione uma pasta de
projeto que faz parte de um workspace.
3. Escolha o Powershell como a linguagem do projeto de aplicativo de funções e, em seguida Azure

Functions v2.
4. Escolha Gatilho HTTP como o modelo para sua primeira função, use HTTPTrigger como o nome da
função e, em seguida, escolha um nível de autorização igual a Função.
NOTE
O nível de autorização Função exige um valor de chave de função ao chamar o ponto de extremidade da função
no Azure. Isso dificulta para outras pessoas chamarem a função.
5. Quando solicitado, escolha Adicionar ao workspace.

O Visual Studio Code cria o projeto de aplicativo de funções do PowerShell em um novo workspace. Esse
projeto contém os arquivos de configuração host.json e local.settings.json, que se aplicam a toda a função no
projeto. Esse projeto do PowerShell é o mesmo que um aplicativo de funções em execução no Azure.

O Azure Functions Core Tools é integrado ao Visual Studio Code para permitir que você execute e depure um
projeto do Azure Functions localmente.
1. Para depurar a função, insira uma chamada ao cmdlet Wait-Debugger no código da função antes de
anexar o depurador e, em seguida, pressione F5 para iniciar o projeto de aplicativo de funções e anexar o
depurador. A saída do Core Tools é exibida no painel Terminal.
3. Acrescente a cadeia de consulta ?name=<yourname> a essa URL e, em seguida, use Invoke-RestMethod para
executar a solicitação da seguinte maneira:
PS > Invoke-RestMethod -Method Get -Uri http://localhost:7071/api/HttpTrigger?name=PowerShell

Hello PowerShell
Você também pode executar a solicitação GET em um navegador.

Quando você chama o ponto de extremidade do HttpTrigger sem passar um parâmetro name como um
parâmetro de consulta ou no corpo, a função retorna um erro [HttpStatusCode]::BadRequest. Quando
você examinar o código em run.ps1, verá que esse erro ocorre por design.
Azure.
NOTE
Lembre-se de remover todas as chamadas a Wait-Debugger antes de publicar suas funções no Azure.
A criação de um aplicativo de funções no Azure apenas solicitará o nome do aplicativo de funções. Outros valores são
definidos para você. Defina azureFunctions.advancedCreation como true para que seja solicitado a fornecer todos os
outros valores.

O Visual Studio Code permite que você publique seu projeto de funções diretamente no Azure. No processo,
você criará um aplicativo de funções e recursos relacionados em sua assinatura do Azure. O aplicativo de
funções fornece um contexto de execução para suas funções. O projeto é empacotado e implantado para o novo
aplicativo de função em sua assinatura do Azure.
Por padrão, o Visual Studio Code cria todos os recursos do Azure necessários para criar seu aplicativo de
funções. Os nomes desses recursos são baseados no nome do aplicativo de funções escolhido. Se precisar ter
controle total sobre os recursos criados, você pode publicar usando opções avançadas.
Esta seção pressupõe que você está criando um novo aplicativo de funções no Azure.
IMPORTANT
1. No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, pesquise
e selecione Azure Functions: Deploy to function app... .
2. Se você ainda não estiver conectado, será solicitado a Entrar no Azure. Você também pode Criar uma
conta gratuita do Azure. Após entrar pelo navegador, volte ao Visual Studio Code.
3. Se você tiver mais de uma assinatura, Escolha uma assinatura para o aplicativo de funções e, em
seguida, escolha + Criar novo aplicativo de funções no Azure.
4. Digite um nome globalmente exclusivo que identifica seu aplicativo de funções e pressione Enter.
Caracteres válidos para um nome de aplicativo de funções são a-z , 0-9 e - .
Quando você pressiona Enter, os seguintes recursos do Azure são criados em sua assinatura:
Grupo de recursos : Contém todos os recursos criados do Azure. O nome é baseado no nome de seu
aplicativo de funções.
Conta de armazenamento : Uma conta de armazenamento padrão é criada com um nome exclusivo
baseado no nome de seu aplicativo de funções.
Plano de hospedagem : Um plano de consumo é criado na região Oeste dos EUA para hospedar seu
aplicativo de funções sem servidor.
Aplicativo de funções: Seu projeto é implantado e executado no novo aplicativo de funções.
5. De volta na área Azure: Functions, expanda o novo aplicativo de funções em sua assinatura. Expanda
Funções, clique com botão direito do mouse em HttpTrigger e, em seguida, escolha Copiar URL da
função.
Executar a função no Azure

Para verificar se a função publicada é executada no Azure, execute o comando do PowerShell a seguir,
substituindo o parâmetro Uri pela URL da função HTTPTrigger da etapa anterior. Como antes, acrescente a
cadeia de consulta &name=<yourname> à URL, como no seguinte exemplo:
PS > Invoke-WebRequest -Method Get -Uri "https://glengatest-vscode-
powershell.azurewebsites.net/api/HttpTrigger?code=nrY05eZutfPqLo0som...&name=PowerShell"
StatusCode : 200
StatusDescription : OK
Content : Hello PowerShell
RawContent : HTTP/1.1 200 OK
Content-Length: 16
Content-Type: text/plain; charset=utf-8
Date: Thu, 25 Apr 2019 16:01:22 GMT
Hello PowerShell
Forms : {}
Headers : {[Content-Length, 16], [Content-Type, text/plain; charset=utf-8], [Date, Thu, 25 Apr
2019 16:01:22 GMT]}
Images : {}
InputFields : {}
Links : {}
ParsedHtml : mshtml.HTMLDocumentClass
RawContentLength : 16
Próximas etapas
Você usou o Visual Studio Code para criar um aplicativo de funções do PowerShell com uma função simples
disparada por HTTP. Talvez você também deseje saber mais sobre como depurar uma função do PowerShell
localmente usando o Azure Functions Core Tools. Confira o guia do desenvolvedor do PowerShell do Azure
Functions.
Habilitar a integração do Application Insights
Criar uma função disparada por HTTP no Azure
Este artigo mostra como usar ferramentas de linha de comando para criar um projeto do Python executado
no Azure Functions. Também é possível criar uma função disparada por uma solicitação HTTP. Por fim, você
publicará seu projeto para ser executado como uma função sem servidor no Azure.
Este artigo é o primeiro de dois inícios rápidos do Python para o Azure Functions. Depois de concluir este
início rápido, você poderá adicionar uma associação de saída de fila do Armazenamento do Azure à sua
função.
Pré-requisitos
Antes de começar, é necessário:
Instale o Python 3.6.8. Essa versão do Python é verificada com o Functions. Ainda não há suporte
para a versão 3.7 e versões posteriores.
Instale o Azure Functions Core Tools versão 2.7.1575 ou posterior.
Instalar a CLI do Azure versão 2.x ou posterior.
Ter uma assinatura ativa do Azure.
Criar e ativar um ambiente virtual (opcional)

Você deve usar um ambiente Python 3.6.x para desenvolver localmente funções do Python. Execute os
seguintes comandos para criar e ativar um ambiente virtual chamado .venv .
NOTE
Se o Python não instalou o venv em sua distribuição do Linux, você pode instalá-lo usando o seguinte comando:
sudo apt-get install python3-venv
Bash:
python -m venv .venv

source .venv/bin/activate
PowerShell ou um prompt de comando do Windows:
py -m venv .venv
.venv\scripts\activate
Agora que você ativou o ambiente virtual, execute os comandos restantes nele. Para sair do ambiente
virtual, execute deactivate .
Criar um projeto local do Functions
Um projeto do Functions é o equivalente a um aplicativo de funções no Azure. Ele pode conter várias
funções que compartilham as mesmas configurações locais e de hospedagem.
1. No ambiente virtual, execute o seguinte comando:
func init MyFunctionProj
2. Selecione python como seu runtime de trabalho.

O comando cria uma pasta MyFunctionProj. Ela contém estes três arquivos:
local.settings.json: usado para armazenar as configurações do aplicativo e as cadeias de conexão
durante a execução local. Esse arquivo não é publicado no Azure.
requirements.txt: contém a lista de pacotes que o sistema instalará na publicação no Azure.
host.json: contém opções de configuração global que afetam todas as funções em um aplicativo de
funções. Esse arquivo é publicado do Azure.
3. Navegue até a nova pasta MyFunctionProj:
cd MyFunctionProj
Criar uma função

Adicionar uma função ao novo projeto.
1. Para adicionar uma função ao projeto, execute o seguinte comando:
func new
2. Use a seta para baixo para selecionar o modelo do gatilho HTTP.

3. Quando for solicitado um nome de função, digite HttpTrigger e pressione Enter.
Esses comandos criam uma subpasta chamada HttpTrigger. Ele contém os seguintes arquivos:
function.json: arquivo de configuração que define a função, o gatilho e outras associações. Veja que,
nesse arquivo, o valor de scriptFile aponta para o arquivo que contém a função, enquanto o gatilho
de invocação e as associações são definidos na matriz bindings .
Cada associação exige uma direção, um tipo e um nome exclusivo. O gatilho HTTP tem uma
associação de entrada do tipo httpTrigger e uma associação de saída do tipo http .
__init__.py: arquivo de script que é a função disparada por HTTP. Observe que esse script tem um
main() padrão. Os dados HTTP do gatilho passam para a função usando o req chamado
binding parameter . O req , que é definido em function.json, é uma instância da classe
azure.functions.HttpRequest.
O objeto de retorno, definido como $return em function.json, é uma instância da classe
azure.functions.HttpResponse. Para saber mais, confira Gatilhos e associações HTTP do Azure
Functions.

A função é executada localmente usando o Azure Functions Runtime.
1. Esse comando inicia o aplicativo de funções:
func host start
Quando o host do Azure Functions é iniciado, ele escreve algo parecido com a seguinte saída. Ele
está truncado aqui para que você possa ler melhor:
%%%%%%
%%%%%%
@ %%%%%% @
@@ %%%%%% @@
@@@ %%%%%%%%%%% @@@
@@ %%%%%%%%%% @@
@@ %%%% @@
@@ %%% @@
@@ %% @@
%%
%
...
Content root path: C:\functions\MyFunctionProj

...
Http Functions:
HttpTrigger: http://localhost:7071/api/HttpTrigger
[8/27/2018 10:38:27 PM] Host started (29486ms)

[8/27/2018 10:38:27 PM] Job host started
2. Copie a URL da função HttpTrigger da saída do tempo de execução de função e cole-a na barra de
endereços do navegador.
3. Acrescente o valor de cadeia de consulta ?name=<yourname> a essa URL e execute a solicitação. A
captura de tela a seguir mostra a resposta no navegador à solicitação GET retornada pela função
local:
4. Selecione CTRL + C para desligar seu aplicativo de funções.

Agora que você executou a função localmente, poderá criar o aplicativo de funções e outros recursos
necessários no Azure.
Criar um grupo de recursos
Crie um grupo de recursos com o comando az group create. Um grupo de recursos do Azure é um
contêiner lógico no qual os recursos do Azure, como os aplicativos de funções, bancos de dados e contas de
armazenamento, são implantados e gerenciados.
O seguinte exemplo cria um grupo de recursos chamado myResourceGroup .
Caso você não esteja usando o Cloud Shell, entre primeiro usando az login .
az group create --name myResourceGroup --location westeurope
Em geral, você cria seu grupo de recursos e os recursos em uma região próxima a você.
Criar uma conta de Armazenamento do Azure

O Functions usa uma conta de propósito geral do Armazenamento do Azure para manter o estado e outras
informações sobre suas funções. Crie uma conta de propósito geral de armazenamento no grupo de
recursos que você criou ao utilizar o comando az storage account create.
No comando a seguir, substitua um nome da conta de armazenamento globalmente exclusivo quando você
vir o espaço reservado <storage_name> . Os nomes da conta de armazenamento devem ter entre 3 e 24
caracteres e podem conter apenas números e letras minúsculas.
az storage account create --name <storage_name> --location westeurope --resource-group myResourceGroup -

-sku Standard_LRS
Criar um aplicativo de funções no Azure

Um aplicativo de funções fornece um ambiente para execução do código de função. Ele permite que você
agrupe funções como uma unidade lógica para facilitar o gerenciamento, a implantação e o
compartilhamento de recursos.
Execute o comando a seguir. Substitua <APP_NAME> por um nome de aplicativo de funções exclusivo.
Substitua <STORAGE_NAME> pelo nome da conta de armazenamento. O <APP_NAME> também é o domínio do
DNS padrão para o aplicativo de funções. O nome precisa ser exclusivo em todos os aplicativos no Azure.
NOTE
Você não pode hospedar aplicativos Windows e Linux no mesmo grupo de recursos. Se você tiver um grupo de
recursos chamado myResourceGroup com um aplicativo de funções ou um aplicativo Web do Windows, você
precisará usar um grupo de recursos diferente.
az functionapp create --resource-group myResourceGroup --os-type Linux \

--consumption-plan-location westeurope --runtime python \
--name <APP_NAME> --storage-account <STORAGE_NAME>
O comando anterior também provisiona uma instância do Aplicativo Azure insights associada no mesmo
grupo de recursos. Você pode usar essa instância para monitorar seu aplicativo de funções e exibir logs.
Agora você está pronto para publicar seu projeto de funções local no aplicativo de funções no Azure.
Implantar o projeto de aplicativo de funções no Azure

Depois que o aplicativo de funções for criado no Azure, você poderá usar o comando do Core Tools func
azure functionapp publish para implantar o código do projeto no Azure. Nesse exemplo, substitua
<APP_NAME> pelo nome de seu aplicativo.
func azure functionapp publish <APP_NAME> --build remote
A opção --build remote cria seu projeto do Python remotamente no Azure usando os arquivos no pacote
de implantação.
Você verá uma saída semelhante ao exemplo a seguir. Ele está truncado aqui para que você possa ler
melhor:
Getting site publishing info...

...
Preparing archive...
Uploading content...
Upload completed successfully.
Deployment completed successfully.
Syncing triggers...
Functions in myfunctionapp:
HttpTrigger - [httpTrigger]
Invoke url: https://myfunctionapp.azurewebsites.net/api/httptrigger?
code=cCr8sAxfBiow548FBDLS1....
Você pode copiar o valor Invoke url para seu HttpTrigger e usá-lo para verificar sua função no Azure. A
URL contém um valor de cadeia de caracteres de consulta code que é sua tecla de função, o que dificulta
para outras pessoas chamarem seu ponto de extremidade de gatilho HTTP no Azure.

Use o cURL para verificar a função implantada. Usando a URL, incluindo a chave de função, que você
copiou da etapa anterior, acrescente a cadeia de consulta &name=<yourname> à URL.
Cole também a URL copiada, incluindo a chave de função, na barra de endereços do navegador da Web.
Acrescente novamente o valor de cadeia de consulta &name=<yourname> à URL e execute a solicitação.
NOTE
Para exibir logs quase em tempo real para um aplicativo do Python publicado, use o Application Insights Live Metrics
Stream.
Próximas etapas
Você criou um projeto de funções do Python com uma função disparada por HTTP, executou-a no
computador local e implantou-a no Azure. Agora, estenda sua função por meio da...
Adição de uma associação de saída de fila do Armazenamento do Azure
Conectar funções ao Armazenamento do Azure
usando o Visual Studio
O Azure Functions lhe permite conectar os serviços do Azure e outros recursos às funções sem precisar escrever
seu próprio código de integração. Essas associações, que representam a entrada e a saída, são declaradas na
definição de função. Dados de associações são fornecidos à função como parâmetros. Um gatilho é um tipo
especial de associação de entrada. Embora uma função tenha apenas um gatilho, ela pode ter várias associações de
entrada e de saída. Para saber mais, confira Conceitos de gatilhos e de associações do Azure Functions.
Este artigo mostra como usar Visual Studio para conectar a função criada no artigo de Início Rápido anterior do
Armazenamento do Azure. A associação de saída que você adiciona a essa função escreve dados da solicitação
HTTP em uma mensagem na fila.
A maioria das associações requer uma cadeia de conexão armazenada que o Functions usa para acessar o serviço
vinculado. Para facilitar, use a Conta de armazenamento que você criou com o seu aplicativo de funções. A conexão
com essa conta já está armazenada em uma configuração de aplicativo chamada AzureWebJobsStorage .
Pré-requisitos
Antes de iniciar este artigo, você deve:
Concluir a [parte 1 do Início Rápido do Visual Studio][./functions-create-first-function-vs-code.md].
Entrar em sua assinatura do Azure por meio do Visual Studio.
Baixar as configurações do aplicativo de funções

No artigo de início rápido anterior, você criou um aplicativo de funções no Azure, juntamente com a Conta de
armazenamento necessária. A cadeia de conexão dessa conta é armazenada com segurança nas configurações do
aplicativo no Azure. Neste artigo, você escreverá mensagens em uma Fila de armazenamento na mesma conta.
Para se conectar à Conta de armazenamento ao executar a função localmente, é necessário baixar as configurações
do aplicativo para o arquivo local.settings.json.
Publicar.
2. Em Ações, selecione Editar Configurações do Serviço de Aplicativo do Azure.
3. Em AzureWebJobsStorage, copie o valor da cadeia de caracteres Remote para Local e, em seguida,
selecione OK.
A associação de armazenamento, que usa a configuração AzureWebJobsStorage para a conexão, agora pode se
conectar ao armazenamento de filas ao executar localmente.

Como está usando uma associação de saída Armazenamento de Filas, você precisa ter a extensão de associações
de armazenamento instalada antes de executar o projeto. Com exceção dos gatilhos de timer e HTTP, as
associações são implementadas como pacotes de extensão.
1. No menu Ferramentas selecione Gerenciador de Pacotes NuGet > Console do Gerenciador de
Pacotes.
2. No console, execute o comando Install-Package a seguir para instalar as extensões de armazenamento:
Install-Package Microsoft.Azure.WebJobs.Extensions.Storage -Version 3.0.6
Agora, você pode adicionar a associação de saída do armazenamento ao seu projeto.
Adicionar uma associação de saída

Em um projeto de biblioteca de classes C#, as associações são definidas como atributos de associação no método
de função. O arquivo function.json é gerado automaticamente com base nesses atributos.
Abra o arquivo de projeto HttpTrigger.cs e adicione a seguinte instrução using :
using Microsoft.Azure.WebJobs.Extensions.Storage;
Adicione o seguinte parâmetro à definição do método Run :
[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg
O parâmetro msg é um tipo ICollector<T> , que representa uma coleção de mensagens que são gravadas em uma
associação de saída quando a função é concluída. Nesse caso, a saída é uma fila de armazenamento denominada
outqueue . A cadeia de conexão para a Conta de armazenamento é definida pelo StorageAccountAttribute . Esse
atributo indica a configuração que contém a cadeia de conexão da Conta de armazenamento e pode ser aplicada no
nível de classe, método ou parâmetro. Nesse caso, você poderia omitir StorageAccountAttribute porque já está
usando a conta de armazenamento padrão.
A definição do método Executar deve agora se parecer com o seguinte:
[FunctionName("HttpTrigger")]
public static async Task<IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, ILogger log)
Adicionar o código que usa a associação de saída

Depois que a associação é definida, você pode usar o name da associação para acessá-la como um atributo na
assinatura de função. Ao usar uma associação de saída, não é necessário usar o código do SDK do Armazenamento
do Azure para se autenticar, para obter uma referência de fila ou para escrever dados. O tempo de execução do
Functions e a associação de saída da fila fazem essas tarefas para você.
Adicione um código que usa o objeto de associação de saída de msg para criar uma mensagem da fila. Adicione
esse código antes do método retornar.
if (!string.IsNullOrEmpty(name))
{
// Add a message to the output collection.
msg.Add(string.Format("Name passed to the function: {0}", name));
}
Neste ponto, sua função deve ser a seguinte:
{
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;
{
}
return name != null
? (ActionResult)new OkObjectResult($"Hello, {name}")
: new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}


Uma nova fila denominada outqueue é criada na conta de armazenamento pelo tempo de execução do Functions
quando a associação de saída é usada pela primeira vez. Você usará o Cloud Explorer para verificar se a fila foi
criada junto com a nova mensagem.
Examinar a fila de saída

1. No menu Exibir no Visual Studio, selecione Cloud Explorer.
2. No Cloud Explorer, expanda sua assinatura do Azure e Contas de Armazenamento e, em seguida,
expanda a conta de armazenamento usada pela função. Se você não conseguir se lembrar do nome da conta
de armazenamento, verifique a configuração da cadeia de conexão AzureWebJobsStorage no arquivo
local.settings.json.
3. Expanda o nó Filas e clique duas vezes na fila chamada subfila para exibir o conteúdo dela no Visual Studio.
A fila contém a mensagem que a associação de saída de fila criou quando você executou a função disparada
por HTTP. Se você tiver invocado a função com o valor name padrão do Azure, a mensagem da fila será
Nome transmitido à função: Azure.
4. Execute a função novamente, envie outra solicitação e você verá uma nova mensagem na fila.
Agora, chegou a hora de republicar o aplicativo de funções atualizado no Azure.
Reimplementar e verificar o aplicativo atualizado

1. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto, selecione Publicar e, em
seguida, escolha Publicar para republicar o projeto no Azure.
2. Após a conclusão da implantação, você poderá usar o navegador novamente para testar a função
reimplementada. Assim como antes, acrescente a cadeia de caracteres de consulta &name=<yourname> à URL.
3. Novamente, Examinar a Mensagem da fila de armazenamento para verificar se a associação de saída gera
novamente uma nova mensagem na fila.
Limpar recursos
Outros inícios rápidos nessa coleção aproveitam esse início rápido. Se você planeja trabalhar com inícios rápidos
subsequentes, tutoriais ou com qualquer serviço criado por você nesse início rápido, não limpe os recursos.
Os Recursos no Azure se referem a aplicativos de funções, funções, contas de armazenamento e assim por diante.
Eles são agrupados em grupos de recursos, e você pode excluir tudo junto ao excluir o grupo.
Você criou recursos para concluir esses guias de início rápido. Você pode ser cobrado por esses recursos,
dependendo do status de conta e preços do serviço. Caso não precise mais dos recursos, é possível excluí-los desta
maneira:
1. No portal do Azure, vá até a página Grupo de recursos.
Para ir até essa página a partir da página de aplicativo de funções, selecione a guia Visão geral e depois
selecione o link em Grupo de recursos.
Para ir até essa página a partir do painel, selecione Grupos de recursos e depois selecione o grupo de
recursos que você usou para esse guia de início rápido.
2. Na página Grupo de recursos, examine a lista de recursos incluídos e verifique se eles são aqueles que
deseja excluir.
3. Selecione Excluir grupo de recursos e siga as instruções.
A exclusão poderá levar alguns minutos. Ao ser concluída, uma notificação será exibida por alguns
segundos. Também é possível selecionar o ícone de sino na parte superior da página para exibir a
notificação.
Próximas etapas
Você atualizou sua função disparada por HTTP para gravar dados em uma Fila de armazenamento. Para saber mais
sobre o desenvolvimento do Functions, confira Desenvolver o Azure Functions usando o Visual Studio.
Em seguida, você deve habilitar o monitoramento do Application Insights para seu aplicativo de funções:
Conectar a função Java ao Armazenamento do Azure
Este artigo mostra como integrar a função criada no artigo de início rápido anterior com uma fila de
Armazenamento do Azure. A associação de saída que você adiciona a essa função escreve dados de uma
solicitação HTTP em uma mensagem na fila.
vinculado. Para facilitar essa conexão, use a conta de armazenamento que você criou com o seu aplicativo de
funções. A conexão com essa conta já está armazenada em uma configuração de aplicativo chamada
AzureWebJobsStorage .
Pré-requisitos
Antes de iniciar este artigo, conclua as etapas na parte 1 do início rápido do Java.

Você já criou um aplicativo de funções no Azure, juntamente com a conta de armazenamento necessária. A cadeia
de conexão dessa conta é armazenada com segurança nas configurações do aplicativo no Azure. Neste artigo, você
escreverá mensagens em uma Fila de armazenamento na mesma conta. Para se conectar à sua Conta de
armazenamento ao executar a função localmente, é necessário baixar as configurações do aplicativo para o arquivo
Na raiz do projeto, execute o seguinte comando do Azure Functions Core Tools para baixar as configurações em
local.settings.json, substituindo <APP_NAME> pelo nome do aplicativo de funções do artigo anterior:
func azure functionapp fetch-app-settings <APP_NAME>
Talvez você precise entrar em sua conta do Azure.
IMPORTANT
Esse comando substitui todas as configurações existentes por valores do aplicativo de funções no Azure.
Como ela contém segredos, o arquivo local.settings.json nunca é publicado e deve ser excluído do controle do código-fonte.
É necessário ter o valor AzureWebJobsStorage , que é a cadeia de conexão da Conta de armazenamento. Use esta
conexão para verificar se a associação de saída funciona conforme o esperado.
Habilitar pacotes de extensão

A maneira mais fácil de instalar as extensões de associação é habilitar pacotes de extensão. Quando você habilita
os pacotes, um conjunto predefinido de pacotes de extensão é instalado automaticamente.
Para habilitar pacotes de extensão, abra o arquivo host.json e atualize seu conteúdo de acordo com o código a
seguir:
{
"version": "2.0",
"extensionBundle": {
"id": "Microsoft.Azure.Functions.ExtensionBundle",
"version": "[1.*, 2.0.0)"
}
}
Agora, você pode adicionar a associação de saída do Armazenamento ao seu projeto.

Em um projeto Java, as associações são definidas como anotações de associação no método de função. O arquivo
function.json é então gerado automaticamente com base nessas anotações.
Procure a localização do código de função em src/main/java, abra o arquivo de projeto Function.java e adicione o
seguinte parâmetro à definição do método run :
@QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage") OutputBinding<String>

msg
O parâmetro msg é um tipo OutputBinding<T> , que representa uma coleção de cadeias de caracteres que são
gravadas como mensagens em uma associação de saída quando a função é concluída. Nesse caso, a saída é uma
fila de armazenamento denominada outqueue . A cadeia de conexão para a conta de armazenamento é definida
pelo método connection . Em vez da própria cadeia de conexão, passe a configuração de aplicativo que contém a
cadeia de conexão da conta de armazenamento.
A definição do método run agora deverá ser semelhante ao seguinte exemplo:
@FunctionName("HttpTrigger-Java")
public HttpResponseMessage run(
@HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel =
AuthorizationLevel.FUNCTION)
HttpRequestMessage<Optional<String>> request,
@QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage")
OutputBinding<String> msg, final ExecutionContext context) {
...
}

Agora, você pode usar o novo parâmetro msg para fazer a gravação na associação de saída por meio do código de
função. Adicione a linha de código a seguir antes da resposta de êxito para adicionar o valor de name à associação
de saída msg .
msg.setValue(name);
Ao usar uma associação de saída, não é necessário usar o código do SDK do Armazenamento do Azure para se
autenticar, para obter uma referência de fila ou para escrever dados. O tempo de execução do Functions e a
associação de saída da fila fazem essas tarefas para você.
O método run agora deverá ser semelhante ao seguinte exemplo:
@FunctionName("HttpTrigger-Java")
AuthorizationLevel.FUNCTION) HttpRequestMessage<Optional<String>> request,
@QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage")
OutputBinding<String> msg, final ExecutionContext context) {
context.getLogger().info("Java HTTP trigger processed a request.");
// Parse query parameter

String query = request.getQueryParameters().get("name");
String name = request.getBody().orElse(query);
if (name == null) {
return request.createResponseBuilder(HttpStatus.BAD_REQUEST).body("Please pass a name on the query
string or in the request body").build();
} else {
// Write the name to the message queue.
msg.setValue(name);
return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();

}
}
Atualizar os testes
Como o arquétipo também cria um conjunto de testes, você precisa atualizar esses testes para manipular o novo
parâmetro msg na assinatura do método run .
Procure a localização do código de teste em src/test/java, abra o arquivo de projeto Function.java e substitua a
linha de código em //Invoke pelo código a seguir.
@SuppressWarnings("unchecked")
final OutputBinding<String> msg = (OutputBinding<String>)mock(OutputBinding.class);
// Invoke
final HttpResponseMessage ret = new Function().run(req, msg, context);
Agora você está pronto para experimentar a nova associação de saída localmente.

Como anteriormente, use o seguinte comando para compilar o projeto e iniciar o Functions Runtime localmente:
mvn clean package

mvn azure-functions:run
NOTE
Como você habilitou os pacotes de extensões no host.json, a extensão de associação do armazenamento foi baixada e
instalada para você durante a inicialização, juntamente com outras extensões de associação da Microsoft.
Como anteriormente, dispare a função na linha de comando usando o cURL em uma nova janela de terminal:
curl -w "\n" http://localhost:7071/api/HttpTrigger-Java --data AzureFunctions
Dessa vez, a associação de saída também cria uma fila denominada outqueue em sua Conta de armazenamento e
adiciona uma mensagem com essa mesma cadeia de caracteres.
Em seguida, use a CLI do Azure para exibir a nova fila e verifique se uma mensagem foi adicionada. Também é
possível exibir sua fila usando o Gerenciador de Armazenamento do Microsoft Azure ou no portal do Azure.
Definir a conexão da Conta de armazenamento
Abra o arquivo local.settings.json e copie o valor de AzureWebJobsStorage , que é a cadeia de conexão da Conta de
armazenamento. Defina a variável de ambiente AZURE_STORAGE_CONNECTION_STRING como a cadeia de conexão
usando o seguinte comando do Bash:
AZURE_STORAGE_CONNECTION_STRING="<STORAGE_CONNECTION_STRING>"
Quando você definir a cadeia de conexão na variável de ambiente AZURE_STORAGE_CONNECTION_STRING , é possível

acessar a conta de Armazenamento sem ter que fornecer a autenticação toda vez.
Consultar a Fila de armazenamento
É possível usar o comando az storage queue list para exibir as Filas de armazenamento em sua conta, como no
exemplo a seguir:
az storage queue list --output tsv
A saída desse comando inclui uma fila denominada outqueue , que é a fila que foi criada quando a função foi
executada.
Em seguida, use o comando az storage message peek para exibir as mensagens nessa fila, como no exemplo a
seguir:
echo ècho $(az storage message peek --queue-name outqueue -o tsv --query '[].{Message:content}') | base64 --
decode`
A cadeia de caracteres retornada deve ser a mesma que a mensagem enviada para testar a função.
NOTE
O exemplo anterior decodifica a cadeia de caracteres retornada de base64. Isso ocorre porque as associações de
Armazenamento de fila gravam e leem do Armazenamento do Azure como cadeias de caracteres base64.
Reimplantar o projeto
Para atualizar o aplicativo publicado, execute o seguinte comando novamente:
Novamente, use o cURL para testar a função implantada. Como anteriormente, passe o valor AzureFunctions no
corpo da solicitação POST para a URL, como neste exemplo:
curl -w "\n" https://fabrikam-functions-20190929094703749.azurewebsites.net/api/HttpTrigger-Java?

code=zYRohsTwBlZ68YF.... --data AzureFunctions
Examine a mensagem da Fila de armazenamento novamente para verificar se a associação de saída gera uma nova
mensagem na fila, conforme esperado.
Limpar recursos
Outros inícios rápidos nessa coleção aproveitam esse início rápido. Se você planeja continuar com Inícios Rápidos
ou tutoriais subsequentes, não limpe os recursos criados neste Início Rápido. Se você não planeja continuar, use o
comando a seguir para excluir todos os recursos criados neste Início Rápido:
az group delete --name myResourceGroup
Quando solicitado, selecione y .
Próximas etapas
Você atualizou a função disparada por HTTP para gravar dados em uma fila de armazenamento. Para saber mais
sobre como desenvolver o Azure Functions com o Java, confira o Guia do desenvolvedor de Java para o Azure
Functions e Gatilhos e associações do Azure Functions. Para obter exemplos de projetos completos de funções em
Java, confira as Amostras de funções Java.
usando o Visual Studio Code
Este artigo mostra como usar Visual Studio Code para conectar a função criada no artigo de início rápido anterior
ao Armazenamento do Azure. A associação de saída que você adiciona a essa função escreve dados da solicitação
Pré-requisitos
Antes de iniciar este artigo, você deve atender aos seguintes requisitos:
Instale a extensão de Armazenamento do Azure para o Visual Studio Code.
Instale o Gerenciador de Armazenamento do Azure. O Gerenciador de Armazenamento é uma ferramenta que
você usará para examinar as mensagens da fila geradas pela associação de saída. O Gerenciador de
Armazenamento tem suporte em sistemas operacionais baseados em macOS, Windows e Linux.
Instale ferramentas de CLI do .NET Core (somente projetos C#).
Conclua as etapas na parte 1 do início rápido do Visual Studio Code.
Este artigo pressupõe que você já esteja conectado à sua assinatura do Azure do Visual Studio Code. Você pode
entrar executando Azure: Sign In na paleta de comandos.

Para se conectar à sua Conta de armazenamento ao executar a função localmente, é necessário baixar as
configurações do aplicativo para o arquivo local.settings.json.
1. Pressione a tecla F1 para abrir a paleta de comandos, pesquise e execute o comando
Azure Functions: Download Remote Settings.... .
2. Escolha o aplicativo de função que você criou no artigo anterior. Selecione Sim para todos para substituir
as configurações locais existentes.
IMPORTANT
Como ela contém segredos, o arquivo local.settings.json nunca é publicado e é excluído do controle do código-fonte.
3. Copie o valor AzureWebJobsStorage , que é a chave do valor da cadeia de conexão da Conta de
armazenamento. Use esta conexão para verificar se a associação de saída funciona conforme o esperado.

de Armazenamento instalada antes de executar o projeto.
JavaScript
C#
A maneira mais fácil de instalar as extensões de associação é habilitar pacotes de extensão. Quando você habilita os
pacotes, um conjunto predefinido de pacotes de extensão é instalado automaticamente.
seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}

No Functions, cada tipo de associação requer que um direction , type e um name exclusivo seja definido no
arquivo functions.json. A maneira como você define esses atributos depende do idioma do seu aplicativo de
funções.
JavaScript
C#
Atributos de associação são definidos diretamente no arquivo function.json. Dependendo do tipo de associação,
outras propriedades podem ser necessárias. A configuração de saída da fila descreve os campos obrigatórios para
uma associação de fila do Armazenamento do Azure. A extensão facilita a inclusão de associações no arquivo
function.json.
Para criar uma associação, clique com o botão direito do mouse (Ctrl+clique no macOS ) no arquivo function.json
na pasta HttpTrigger e escolha Adicionar associação... . Siga os prompts para definir as seguintes propriedades
de associação para a nova associação:
Selecionar direção de associação out A associação é uma associação de saída.
Selecionar associação com direção... Azure Queue Storage A associação é uma associação de fila do
O nome usado para identificar essa msg Nome que identifica o parâmetro de
associação em seu código associação referenciado em seu código.
A fila à qual a mensagem será outqueue O nome da fila na qual a associação

enviada escreve. Quando o queueName não
existe, a associação o cria no primeiro
uso.
Selecione a configuração de AzureWebJobsStorage O nome de uma configuração de

"local.setting.json" aplicativo que contém a cadeia de
conexão da Conta de armazenamento.
A configuração AzureWebJobsStorage
contém a cadeia de conexão para a
Conta de armazenamento criada com o
Uma associação é incluída na matriz bindings no seu arquivo function.json, que agora deve se parecer com o
seguinte exemplo:
{
...
"bindings": [
{
"authLevel": "function",
"type": "httpTrigger",
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
},
{
"type": "queue",
"direction": "out",
"name": "msg",
"queueName": "outqueue",
"connection": "AzureWebJobsStorage"
}
]
}

assinatura de função. Ao usar uma associação de saída, não é necessário usar o código do SDK do Armazenamento
do Azure para se autenticar, para obter uma referência de fila ou para escrever dados. O tempo de execução do
Functions e a associação de saída da fila fazem essas tarefas para você.
JavaScript
C#
Adicione um código que usa o objeto de associação de saída msg em context.bindings para criar uma mensagem
da fila. Adicione esse código antes da instrução context.res .
// Add a message to the Storage queue.
context.bindings.msg = "Name passed to the function: " +
(req.query.name || req.body.name);
module.exports = async function (context, req) {

context.log('JavaScript HTTP trigger function processed a request.');
if (req.query.name || (req.body && req.body.name)) {

context.res = {
// status: 200, /* Defaults to 200 */
body: "Hello " + (req.query.name || req.body.name)
};
}
else {
context.res = {
status: 400,
body: "Please pass a name on the query string or in the request body"
};
}
};

1. Para testar sua função, defina um ponto de interrupção no código da função e pressione F5 para iniciar o
projeto de aplicativo de funções. A saída do Core Tools é exibida no painel Terminal.
consulta ?name=<yourname> a essa URL e execute a solicitação. A execução é pausada quando o ponto de
interrupção é atingido.
4. Quando você continua a execução, o exemplo a seguir mostra a resposta no navegador à solicitação GET:
Uma nova fila denominada outqueue é criada na sua conta de armazenamento pelo tempo de execução do
Functions quando a associação de saída é usada pela primeira vez. Você usará o Gerenciador de Armazenamento
para verificar se a fila foi criada junto com a nova mensagem.
Conectar o Gerenciador de Armazenamento à sua conta
Ignore esta seção se você já instalou o Gerenciador de Armazenamento do Azure e o conectou à sua conta do
Azure.
1. Execute a ferramenta Gerenciador de Armazenamento do Azure, selecione o ícone de conexão à esquerda e
selecione Adicionar uma conta.
2. Na caixa de diálogo Conectar, escolha Adicionar uma conta do Azure, escolha seu Ambiente do Azure
e selecione Entrar... .
Depois de entrar na sua conta, você verá todas as assinaturas do Azure associadas à ela.
1. No Visual Studio Code, pressione a tecla F1 para abrir a paleta de comandos, em seguida, procure e execute
o comando Azure Storage: Open in Storage Explorer e escolha o nome da sua conta de armazenamento.
Sua conta de armazenamento é aberta no Gerenciador de Armazenamento do Azure.
2. Expanda o nó Filas e selecione a fila denominada outqueue.

1. No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, pesquise e
selecione Azure Functions: Deploy to function app... .
2. Escolha o aplicativo de funções que você criou no primeiro artigo. Como você está reimplementando seu
projeto para o mesmo aplicativo, selecione Implantar para descartar o aviso de substituição de arquivos.
3. Após a conclusão da implantação, você poderá usar novamente o cURL ou um navegador para testar a
função reimplementada. Como antes, acrescente a cadeia de consulta &name=<yourname> à URL, como no
seguinte exemplo:
curl https://myfunctionapp.azurewebsites.net/api/httptrigger?code=cCr8sAxfBiow548FBDLS1....&name=
<yourname>
Limpar recursos
maneira:
selecione Azure Functions: Open in portal .
2. Escolha seu aplicativo de funções e pressione Enter. A página do aplicativo de funções é aberta no portal do
Azure.
3. Na guia Visão geral, selecione o link nomeado em Grupo de Recursos.
deseja excluir.
notificação.
Próximas etapas
Você atualizou sua função disparada por HTTP para gravar dados em uma Fila de armazenamento. Para saber mais
sobre o desenvolvimento de funções, confira Desenvolver Funções do Azure usando o Visual Studio Code.
Adicionar uma associação de fila do Armazenamento
do Azure à sua função do Python
Armazenamento do Azure. A associação de saída que você adiciona a essa função escreve dados de uma solicitação
Pré-requisitos
Antes de iniciar este artigo, conclua as etapas na parte 1 do início rápido do Python.
NOTE
Os comandos da CLI do Azure neste artigo funcionam em Bash e são verificados para serem executados no Azure Cloud
Shell. Você deve modificá-los para eles serem executados em um prompt de comando local do Windows.

de conexão dessa conta é armazenada com segurança nas configurações do aplicativo no Azure. Neste artigo, você
escreverá mensagens em uma Fila de armazenamento na mesma conta. Para se conectar à sua Conta de
armazenamento ao executar a função localmente, é necessário baixar as configurações do aplicativo para o arquivo
IMPORTANT

A maneira mais fácil de instalar as extensões de associação é habilitar pacotes de extensão. Quando você habilita os
pacotes, um conjunto predefinido de pacotes de extensão é instalado automaticamente.
seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}

funções.
function.json.
Para criar uma associação, clique com o botão direito do mouse (Ctrl+clique no macOS ) no arquivo function.json
na pasta HttpTrigger e escolha Adicionar associação... . Siga os prompts para definir as seguintes propriedades
de associação para a nova associação:
Selecionar associação com direção... Azure Queue Storage A associação é uma associação de fila do

uso.

seguinte exemplo:
{
...
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
},
{
"type": "queue",
"direction": "out",
"name": "msg",
}
]
}

Depois que o name estiver configurado, será possível começar a usá-lo para acessar a associação como um
atributo de método na assinatura de função. No exemplo a seguir, msg é uma instância do
azure.functions.InputStream class .
import logging
import azure.functions as func
def main(req: func.HttpRequest, msg: func.Out[func.QueueMessage]) -> str:
name = req.params.get('name')
if not name:
try:
req_body = req.get_json()
except ValueError:
pass
else:
name = req_body.get('name')
if name:
msg.set(name)
return func.HttpResponse(f"Hello {name}!")
else:
return func.HttpResponse(
"Please pass a name on the query string or in the request body",
status_code=400
)

Como anteriormente, use o seguinte comando para iniciar o tempo de execução do Functions localmente:
func host start
NOTE
Copie a URL da função HttpTrigger da saída do tempo de execução de função e cole-a na barra de endereços do
navegador. Acrescente o valor de cadeia de consulta ?name=<yourname> a essa URL e execute a solicitação. Você
deve ver a mesma resposta no navegador como você viu no artigo anterior.
armazenamento. Defina a variável de ambiente AZURE_STORAGE_CONNECTION_STRING como a cadeia de conexão usando
o seguinte comando do Bash:
exemplo a seguir:
executada.
seguir:
decode`
NOTE
Para atualizar o aplicativo publicado, use o comando func azure functionapp publish do Core Tools para implantar
o código do projeto no Azure. Nesse exemplo, substitua <APP_NAME> pelo nome de seu aplicativo.
Novamente, é possível usar cURL ou um navegador para testar a função implantada. Como antes, acrescente a
cadeia de caracteres de consulta &name=<yourname> à URL, como mostrado no exemplo a seguir:
curl https://myfunctionapp.azurewebsites.net/api/httptrigger?code=cCr8sAxfBiow548FBDLS1....&name=<yourname>
Examine a mensagem da Fila de armazenamento novamente para verificar se a associação de saída gera uma nova
mensagem na fila, conforme esperado.
Limpar recursos
Próximas etapas
sobre como desenvolver o Azure Functions usando o Python, confira o Guia do desenvolvedor de Python para o
Azure Functions e Gatilhos e associações do Azure Functions. Para obter exemplos de projetos de funções
completos no Python, confira os Exemplos de funções de Python.
Criar uma função que se integra aos Aplicativos
Lógicos do Azure
O Azure Functions integra-se aos Aplicativos Lógicos do Azure no Designer de Aplicativos Lógicos. Essa
integração permite usar o poder de computação do Functions em orquestrações com outros serviços de terceiros
e do Azure.
Este tutorial mostra como usar o Functions com os Aplicativos Lógicos e os Serviços Cognitivos no Azure para
executar a análise de sentimento de postagens do Twitter. Uma função HTTP disparada categoriza tweets com
cores verde, amarelo ou vermelho com base na pontuação de sentimento. Um email é enviado quando um
sentimento inadequado é detectado.
Neste tutorial, você aprenderá como:

Crie um Recurso de API de Serviços Cognitivos.
Crie uma função que categorize o sentimento do tweet.
Crie um aplicativo lógico que se conecte ao Twitter.
Adicione a detecção de sentimento ao aplicativo lógico.
Conecte o aplicativo lógico à função.
Envie um email com base na resposta da função.
Pré-requisitos
Uma conta do Twitter ativa.
Uma conta do Outlook.com (para enviar notificações).
Este artigo usa como ponto de partida os recursos criados em Criar sua primeira função no portal do Azure.
Se você ainda não fez isso, conclua estas etapas agora para criar seu aplicativo de função.
Criar um recurso dos Serviços Cognitivos
As APIs de Serviços Cognitivos estão disponíveis no Azure como recursos individuais. Use a API de Análise de
Texto para detectar o sentimento dos tweets que estão sendo monitorados.
1. Entre no Portal do Azure.
2. Clique em Criar um recurso no canto superior esquerdo do Portal do Azure.
3. Clique em IA + Machine Learning > Análise de Texto. Em seguida, use as configurações especificadas
na tabela para criar o recurso.
Nome MyCognitiveServicesAccnt Escolha um nome de conta exclusivo.
Localidade Oeste dos EUA Use o local mais próximo de você.
Tipo de preços F0 Comece com o nível mais baixo. Caso

suas chamadas se esgotem,
dimensione para uma camada mais
elevada.
Grupo de recursos myResourceGroup Use o mesmo grupo de recursos

para todos os serviços neste tutorial.
4. Clique em Criar para criar seu recurso.

5. Clique em Visão Geral e copie o valor do Ponto de Extremidade para um editor de texto. Esse valor é
usado para criar uma conexão com a API dos Serviços Cognitivos.
6. Na coluna de navegação à esquerda, clique em Chaves, copie o valor da Chave 1 e salve-o em um editor
de texto. Você pode usar a chave para conectar o aplicativo lógico à API dos Serviços Cognitivos.
Crie o aplicativo de funções

O Functions fornece uma ótima maneira de descarregar tarefas de processamento em um fluxo de trabalho de
aplicativos lógicos. Este tutorial usa uma função HTTP disparada para processar pontuações de sentimento de
tweet dos Serviços Cognitivos e retornar um valor de categoria.
1. No menu do portal do Azure, selecione Criar um recurso.
2. Na página Novo, selecione Computação > Aplicativo de Funções.
3. Use as configurações do aplicativo de funções especificadas na tabela abaixo da imagem.
Assinatura Sua assinatura A assinatura na qual este novo

aplicativo de funções será criado.
Grupo de Recursos myResourceGroup Nome do novo grupo de recursos no

qual criar o seu aplicativo de funções.
Nome do aplicativo de funções Nome globalmente exclusivo Nome que identifica seu novo
aplicativo de funções. Os caracteres
válidos são a-z (não diferencia
maiúsculas de minúsculas), 0-9 e
- .
Publicar Código Opção para publicar arquivos de

código ou um contêiner do Docker.
Pilha de runtime Linguagem preferencial Escolha um runtime compatível com

sua linguagem de programação de
funções favorita. Escolha .NET para
funções C# e F#.
Região Região preferencial Escolha uma região perto de você ou

perto de outros serviços que suas
funções acessam.
Selecione o botão Avançar: Hospedagem > .

4. Insira as configurações a seguir para a hospedagem.
Conta de armazenamento Nome globalmente exclusivo Crie uma conta de armazenamento

usada pelo seu aplicativo de funções.
Os nomes da conta de
armazenamento devem ter entre 3 e
24 caracteres e podem conter apenas
números e letras minúsculas. Use
também uma conta existente, que
precisará atender aos requisitos da
conta de armazenamento.
Sistema operacional Sistema operacional preferencial Um sistema operacional é pré-

selecionado para você com base na
seleção da pilha de runtime, mas
você pode alterar a configuração, se
necessário.
Plano Plano de consumo Plano de hospedagem que define

como os recursos são alocados para
seu aplicativo de funções. No Plano
de Consumo padrão, os recursos
são adicionados dinamicamente
conforme exigido por suas funções.
Nesta hospedagem sem servidor,
você só paga pelo tempo durante o
qual suas funções são executadas.
Quando você executa em um Plano
do Serviço de Aplicativo, deve
gerenciar o dimensionamento do
Selecione o botão Avançar: Monitoramento > .

5. Insira as configurações a seguir para o monitoramento.
Application Insights Padrão Cria um recurso do Application

Insights do mesmo nome do
aplicativo na região com suporte
mais próxima. Ao expandir essa
configuração, você pode alterar o
Novo nome do recurso ou escolher
um Local diferente em uma
geografia do Azure onde deseja
armazenar seus dados.
Selecione Examinar + Criar para examinar as seleções de configuração de aplicativo.

6. Selecione Criar para provisionar e implantar o aplicativo de funções.
7. Selecione o ícone da Notificação no canto superior direito do portal e veja se a mensagem Implantação
concluída com êxito é exibida.
8. Selecione Ir para recursos para exibir o novo aplicativo de funções. Você também pode selecionar Fixar
no painel. A fixação torna mais fácil retornar a esse recurso de aplicativo de função no seu painel.
Crie uma função disparada por HTTP

1. Expanda seu aplicativo de funções e clique no botão + ao lado de Functions. Se essa for a primeira função
em seu aplicativo de funções, selecione No portal.
2. Em seguida, selecione Webhook + API e clique em Criar.

3. Substitua o conteúdo do arquivo run.csx pelo código abaixo e clique em Salvar:
#r "Newtonsoft.Json"
using System;
using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
public static async Task<IActionResult> Run(HttpRequest req, ILogger log)

{
string category = "GREEN";

log.LogInformation(string.Format("The sentiment score received is '{0}'.", requestBody));
double score = Convert.ToDouble(requestBody);
if(score < .3)

{
category = "RED";
}
else if (score < .6)
{
category = "YELLOW";
}
return requestBody != null

? (ActionResult)new OkObjectResult(category)
: new BadRequestObjectResult("Please pass a value on the query string or in the request body");
}
Esse código de função retorna uma categoria de cor com base na pontuação de sentimento recebida na
solicitação.
4. Para testar a função, clique em Testar na extremidade direita para expandir a guia Teste. Digite um valor de
0.2 para o corpo da solicitaçãoe clique em Executar. Um valor RED é retornado no corpo da resposta.
Agora você tem uma função que categoriza as pontuações de sentimento. Em seguida, você pode criar um
aplicativo lógico que integra sua função ao Twitter e à API dos Serviços Cognitivos.
Criar um aplicativo lógico

1. Clique no botão Novo no canto superior esquerdo do portal do Azure.
2. Clique em Web > Aplicativo Lógico.
3. Em seguida, digite um valor para Nome, como TweetSentiment , e use as configurações conforme
especificado na tabela.
Nome TweetSentiment Escolha um nome apropriado para

seu aplicativo.
Grupo de recursos myResourceGroup Escolha o mesmo grupo de recursos

existente.
Localidade Leste dos EUA Escolha um local perto de você.
4. Depois de inserir os valores de configurações corretos, clique em Criar para criar o aplicativo lógico.
5. Depois que o aplicativo for criado, clique em seu novo aplicativo lógico fixado no painel. Em seguida, no
Designer de Aplicativos Lógicos, role para baixo e clique no modelo Aplicativo Lógico em Branco.
Agora você pode usar o Designer de Aplicativos Lógicos para adicionar serviços e gatilhos ao aplicativo.
Conectar-se ao Twitter
Primeiro, crie uma conexão para sua conta do Twitter. O aplicativo lógico sonda tweets, o que dispara a execução
do aplicativo.
1. No designer, clique no serviço Twitter e clique no gatilho Quando um novo tweet é publicado. Entre na
sua conta do Twitter e autorize os Aplicativos Lógicos a usar sua conta.
2. Use as configurações de gatilho do Twitter conforme especificado na tabela.
Texto da pesquisa #Azure Use uma hashtag que seja popular o

suficiente para gerar novos tweets no
intervalo escolhido. Quando você usa
a camada gratuita e a hashtag é
muito popular, é possível consumir
rapidamente a cota de transação na
API dos Serviços Cognitivos.
Intervalo 15 O tempo decorrido entre as

solicitações do Twitter, em unidades
de frequência.
Frequência Minuto A unidade de frequência usada para

sondar o Twitter.
3. Clique em Salvar para se conectar à sua conta do Twitter.

Agora, seu aplicativo está conectado ao Twitter. Em seguida, conecte-se à análise de texto para detectar o
sentimento dos tweets coletados.
Adicionar detecção de sentimento

1. Clique em Nova Etapa e em Adicionar uma ação.
2. Em Escolher uma ação, digite Análise de Textoe clique na ação Detectar sentimento.
3. Digite um nome de conexão, como MyCognitiveServicesConnection , cole a chave da API dos Serviços
Cognitivos e o ponto de extremidade de Serviços Cognitivos que você anotou em um editor de texto e
clique em Criar.
4. Em seguida, insira Texto do Tweet na caixa de texto e clique em Nova Etapa.
Agora que a detecção de sentimento está configurada, você pode adicionar uma conexão à função que consome a
saída da pontuação de sentimento.
Conecte a saída de sentimento à função

1. No Designer de Aplicativos Lógicos, clique em Nova Etapa > Adicionar uma ação, filtre pelo Azure
Functions e clique em Escolher uma função do Azure.
2. Selecione o aplicativo de funções que você criou anteriormente.
3. Selecione a função que você criou para este tutorial.

4. Em Corpo da Solicitação, clique em Pontuação e em Salvar.
Agora, sua função é disparada quando uma pontuação de sentimento é enviada do aplicativo lógico. Uma
categoria com codificação de cores é retornada para o aplicativo lógico pela função. Em seguida, adicione uma
notificação por email que é enviada quando um valor de sentimento RED é retornado pela função.
Adicionar notificações por email

A última parte do fluxo de trabalho é disparar um email quando o sentimento foi classificado como RED. Este
tópico usa um conector do Outlook.com. Você pode executar etapas semelhantes para usar um conector Gmail ou
Outlook do Office 365.
1. No Designer de Aplicativos Lógicos, clique em Nova etapa > Adicionar uma condição.
2. Clique em Escolha um valor e clique em Corpo. Selecione é igual a, clique em Escolha um valor, digite
RED e clique em Salvar.
3. Em SE VERDADEIRO, clique em Adicionar uma ação, procure outlook.com , clique em Enviar um

emaile entre sua conta do Outlook.com.
NOTE
Se você não tiver uma conta do Outlook.com, poderá escolher outro conector, como Gmail ou Outlook do Office
365
4. Na ação Enviar um email, use as configurações de email conforme especificadas na tabela.

Para Digitar endereço de email O endereço de email que recebe a

notificação.
Assunto Sentimento de tweet negativo A linha de assunto do email de

detectado notificação.
Corpo Texto do Tweet, local Clique nos parâmetros Texto do tweet

e Local.
1. Clique em Save (Salvar).

Agora que o fluxo de trabalho foi concluído, você poderá habilitar o aplicativo lógico e consultar a função em
operação.
Testar o fluxo de trabalho

1. No Designer de Aplicativos Lógicos, clique em Executar para iniciar o aplicativo.
2. Na coluna à esquerda, clique em Visão Geral para ver o status do aplicativo lógico.
3. (Opcional) Clique em uma das execuções para ver os detalhes da execução.
4. Vá para sua função, exiba os logs e verifique se os valores de sentimento foram recebidos e processados.
5. Quando um sentimento potencialmente negativo é detectado, você recebe um email. Se você ainda não
recebeu um email, poderá alterar o código de função para retornar RED sempre que:
return (ActionResult)new OkObjectResult("RED");
Depois de verificar as notificações por email, altere para o código original:
return requestBody != null

? (ActionResult)new OkObjectResult(category)
: new BadRequestObjectResult("Please pass a value on the query string or in the request body");
IMPORTANT
Depois de concluir este tutorial, você deverá desabilitar o aplicativo lógico. Ao desabilitar o aplicativo, você evita ser
cobrado pelas execuções e não consome as transações em sua API dos Serviços Cognitivos.
Agora você viu como é fácil integrar o Functions a um fluxo de trabalho dos Aplicativos Lógicos.
Desabilitar o aplicativo lógico

Para desabilitar o aplicativo lógico, clique em Visão Geral e clique em Desabilitar na parte superior da tela. A
desabilitação do aplicativo impede que ele seja executado e incorra em encargos sem precisar ser excluído.
Próximas etapas
Neste tutorial, você aprendeu como:
Crie um Recurso de API de Serviços Cognitivos.
Crie uma função que categorize o sentimento do tweet.
Crie um aplicativo lógico que se conecte ao Twitter.
Adicione a detecção de sentimento ao aplicativo lógico.
Conecte o aplicativo lógico à função.
Envie um email com base na resposta da função.
Vá para o próximo tutorial para aprender a criar uma API sem servidor para sua função.
Criar uma API sem servidor usando o Azure Functions
Para saber mais sobre os Aplicativos Lógicos, consulte Aplicativos Lógicos do Azure.
Crie uma definição de OpenAPI para uma API sem
servidor usando o Gerenciamento de API do Azure
APIs REST geralmente são descritas usando uma definição de OpenAPI. Esta definição contém informações sobre
as operações que estão disponíveis em uma API e como os dados de solicitação e resposta para a API devem ser
estruturados.
Neste tutorial, você deve criar uma função que determina se um reparo de emergência em uma turbina eólica é
eficaz em termos de custo. Em seguida, crie uma definição de OpenAPI para o aplicativo de funções usando o
Gerenciamento de API do Azure para que a função possa ser chamada de outros aplicativos e serviços.
Criar uma função no Azure
Gerar uma definição de OpenAPI usando o Gerenciamento de API do Azure
Testar a definição chamando a função
Baixar a definição de OpenAPI
Criar um aplicativo de funções

Você deve ter um aplicativo de funções para hospedar a execução de suas funções. Um aplicativo de funções lhe
permite agrupar funções como uma unidade lógica para facilitar o gerenciamento, a implantação, o
dimensionamento e o compartilhamento de recursos.


- .


funções C# e F#.

funções acessam.



seleção da pilha de runtime, mas você
pode alterar a configuração, se
necessário.

de Consumo padrão, os recursos são
adicionados dinamicamente conforme
exigido por suas funções. Nesta
hospedagem sem servidor, você só
paga pelo tempo durante o qual suas
funções são executadas. Quando
você executa em um Plano do Serviço
de Aplicativo, deve gerenciar o
dimensionamento do aplicativo de
funções.



8. Selecione Ir para recursos para exibir o novo aplicativo de funções. Você também pode selecionar Fixar no
painel. A fixação torna mais fácil retornar a esse recurso de aplicativo de função no seu painel.
Criar a função
Este tutorial usa uma função disparada por HTTP que usa dois parâmetros:
O tempo estimado para reparar uma turbina, em horas.
A capacidade da turbina, em quilowatts.
A função, em seguida, calcula o custo do reparo e o valor da receita que a turbina proporcionaria em um período
de 24 horas. PARA criar uma função disparada pelo HTTP no portal do Azure.
1. Expanda seu aplicativo de funções e selecione o botão + ao lado de Functions. Selecione No portal >
Continuar.
2. Selecione Mais modelos... e, em seguida, Concluir e exibir modelos
3. Selecione o acionador HTTP, digite TurbineRepair para sua função Nome, escolha Function para Nível
de autenticação e, em seguida, selecione Criar.
4. Substitua o conteúdo do arquivo do script C# run.csx pelo código abaixo e selecione Salvar:
using System.Net;
const double revenuePerkW = 0.12;

const double technicianCost = 250;
const double turbineCost = 100;
public static async Task<IActionResult> Run(HttpRequest req, ILogger log)

{
// Get query strings if they exist
int tempVal;
int? hours = Int32.TryParse(req.Query["hours"], out tempVal) ? tempVal : (int?)null;
int? capacity = Int32.TryParse(req.Query["capacity"], out tempVal) ? tempVal : (int?)null;
// Get request body

// Use request body if a query was not sent

capacity = capacity ?? data?.capacity;
hours = hours ?? data?.hours;
// Return bad request if capacity or hours are not passed in

if (capacity == null || hours == null){
return new BadRequestObjectResult("Please pass capacity and hours on the query string or in the
request body");
}
// Formulas to calculate revenue and cost
double? revenueOpportunity = capacity * revenuePerkW * 24;
double? costToFix = (hours * technicianCost) + turbineCost;
string repairTurbine;
if (revenueOpportunity > costToFix){

repairTurbine = "Yes";
}
else {
repairTurbine = "No";
};
return (ActionResult)new OkObjectResult(new{

message = repairTurbine,
revenueOpportunity = "$"+ revenueOpportunity,
costToFix = "$"+ costToFix
});
}
Esse código de função retorna uma mensagem de Yes ou No para indicar se um reparo de emergência é
econômico, bem como as oportunidades de receita que representa a turbina e o custo para reparar a
turbina.
5. Para testar a função, clique em Testar na extremidade direita para expandir a guia Teste. Digite o seguinte
valor para o Corpo da solicitação e clique em Executar.
{
"hours": "6",
"capacity": "2500"
}
O valor a seguir é retornado no corpo da resposta.
{"message":"Yes","revenueOpportunity":"$7200","costToFix":"$1600"}
Agora você tem uma função que determina o custo-benefício de reparos de emergências. Em seguida, você pode
gerar uma definição de OpenAPI para o aplicativo de funções.
Gerar a definição de OpenAPI

Agora você está pronto para gerar a definição de OpenAPI.
1. Selecione o aplicativo de função; em seguida, em Funcionalidades da plataforma, escolha
Gerenciamento de API e selecione Criar novo no Gerenciamento de API.
2. Use as configurações de Gerenciamento de API conforme especificado na tabela abaixo da imagem.

Nome Nome globalmente exclusivo Um nome é gerado com base no

nome do seu aplicativo de funções.

recurso será criado.
Grupo de Recursos myResourceGroup O mesmo recurso que seu aplicativo

de funções, que deve estar definido
para você.
Localidade Oeste dos EUA Escolha o local Oeste dos EUA.
Nome da organização Contoso O nome da organização usado no

portal do desenvolvedor e para
notificações por email.
Email do administrador seu email Email que recebeu notificações do

sistema de Gerenciamento de API.
Tipo de preços Consumo (versão prévia) A camada de consumo está em

versão prévia e não está disponível
em todas as regiões. Para obter
detalhes completos sobre preços,
confira a Página de preços de
Gerenciamento de API
3. Escolha Criar para criar a instância de Gerenciamento de API, o que pode levar vários minutos.
4. Selecione Habilitar o Application Insights para enviar logs para o mesmo local que o aplicativo de
função, aceite os padrões restantes e selecione API de link.
5. Importar Funções do Azure é exibido com a função TurbineRepair realçada. Clique em Selecionar para
continuar.
6. Na página Criar do Aplicativo de funções, aceite os padrões e selecione Criar

A API foi criada para a função.
Testar a API
Antes de usar a definição de OpenAPI, você deve verificar se a API funciona.
1. Na guia Testar da sua função, selecione a operação POST.
2. Insira valores para horas e capacidade
{
"hours": "6",
"capacity": "2500"
}
3. Clique em Enviar e exiba a resposta HTTP.

Baixar a definição de OpenAPI
Se sua API funcionar conforme esperado, será possível baixar a definição de OpenAPI.
1. Selecione Baixar definição de OpenAPI na parte superior da página.
2. Abra o arquivo JSON baixado e examine a definição.
Limpar recursos
Nas etapas anteriores, você criou os recursos do Azure em um grupo de recursos. Se você não espera precisar
desses recursos no futuro, poderá excluí-los ao excluir o grupo de recursos.
No menu do portal do Azure ou na página Inicial, selecione Grupos de Recursos e, na página Grupos de
Recursos, selecione myResourceGroup.
Na página myResourceGroup, certifique-se de que os recursos listados são aqueles que deseja excluir.
Selecione Excluir, digite myResourceGroup na caixa de texto e selecione Excluir.
Próximas etapas
Você usou a integração do Gerenciamento de API para gerar uma definição de OpenAPI de suas funções. Agora
você pode editar a definição no Gerenciamento de API no portal. Também é possível saber mais sobre o
Gerenciamento de API.
Editar a definição de OpenAPI no Gerenciamento de API
Tutorial: integrar funções com uma rede virtual do
Azure
Este tutorial mostra como usar Azure Functions para se conectar a recursos em uma rede virtual do Azure. Você
criará uma função que tem acesso à Internet e a uma VM que executa o WordPress na rede virtual.
Criar um aplicativo de funções no plano Premium
Implantar um site do WordPress na VM em uma rede virtual
Conectar o aplicativo de funções à rede virtual
Criar um proxy de função para acessar recursos do WordPress
Solicitar um arquivo do WordPress de dentro da rede virtual
Topologia
O diagrama a seguir mostra a arquitetura da solução que você cria:
As funções em execução no plano Premium têm os mesmos recursos de hospedagem que os aplicativos Web no
serviço Azure App, que inclui o recurso de integração VNet. Para saber mais sobre a integração VNet, incluindo
solução de problemas e configuração avançada, confira integrar seu aplicativo a uma rede virtual do Azure.
Pré-requisitos
Para este tutorial, é importante que você compreenda o endereçamento IP e a sub-rede. Você pode começar com
Este artigo que aborda os conceitos básicos de endereçamento e sub-rede. Muitos outros artigos e vídeos estão
disponíveis online.
Criar um aplicativo de funções em um plano Premium

Primeiro, você cria um aplicativo de funções no plano Premium. Este plano fornece escala sem servidor enquanto
dá suporte à integração de rede virtual.
1. Abrir o portal do Azure de https://portal.azure.com
2. Selecione o botão criar um recurso
3. Selecione > de computação aplicativo de funções.



Nome do Aplicativo de funções Nome globalmente exclusivo Nome que identifica seu novo
- .
Publicar Codificar Opção para publicar arquivos de

Pilha de tempo de execução Linguagem preferencial Escolha um runtime compatível com

funções C# e F#.
Região Região preferida Escolha uma região perto de você ou

funções acessam.
Selecione o botão Avançar: hospedagem > .

5. Insira as seguintes configurações de hospedagem.

24 caracteres e podem conter
apenas números e letras minúsculas.
existente, que deve atender aos
requisitos da conta de
armazenamento.
Sistema operacional Sistema operacional preferencial Um sistema operacional é

previamente selecionado para você
com base em sua seleção de pilha de
tempo de execução, mas você pode
alterar a configuração, se necessário.
Intenção Premium Para tipo de plano, selecione

Premium (visualização) e selecione
padrões para as seleções de plano e
SKU e tamanho do Windows .
Selecione o botão Avançar: monitoramento > .

6. Insira as configurações de monitoramento a seguir.

Novo nome do recurso ou
escolher um Local diferente em uma
Selecione examinar + criar para revisar as seleções de configuração de aplicativo.

Você pode fixar o aplicativo de funções no painel selecionando o ícone de pino no canto superior direito. A fixação
torna mais fácil retornar a esse aplicativo de funções depois de criar sua VM.
Criar uma VM dentro de uma rede virtual

Em seguida, crie uma VM pré-configurada que executa o WordPress dentro de uma rede virtual ( WordPress
LEMP7 desempenho máximo por Jetware). Uma VM do WordPress é usada devido a seu baixo custo e
conveniência. Esse mesmo cenário funciona com qualquer recurso em uma rede virtual, como APIs REST,
ambientes de serviço de aplicativo e outros serviços do Azure.
1. No portal, escolha + criar um recurso no painel de navegação esquerdo, no campo de pesquisa, digite
WordPress LEMP7 Max Performance e pressione Enter.
2. Escolha o desempenho máximo do WordPress LEMP nos resultados da pesquisa. Selecione um plano
de software de desempenho do WordPress LEMP Max para centos como o plano de software e
selecione criar.
3. Na guia noções básicas , use as configurações da VM, conforme especificado na tabela abaixo da imagem:
Assinatura Sua assinatura A assinatura sob a qual seus recursos

são criados.
Grupo de recursos myResourceGroup Escolha myResourceGroup ou o

grupo de recursos que você criou
com seu aplicativo de funções. Usar
o mesmo grupo de recursos para o
aplicativo de funções, a VM do
WordPress e o plano de
hospedagem facilita a limpeza de
recursos quando você concluir este
tutorial.
Nome da máquina virtual VNET-WordPress O nome da VM precisa ser exclusivo

no grupo de recursos
Regionais Oeste da Europa (Europa) Escolha uma região perto de você ou

perto das funções que acessam a
VM.
Tamanho B1s Escolha alterar tamanho e, em

seguida, selecione a imagem B1s
padrão, que tem 1 vCPU e 1 GB de
memória.
Tipo de autenticação Senha Para usar a autenticação de senha,

você também deve especificar um
nome de usuário, uma
senhasegura e, em seguida,
confirmar a senha. Para este
tutorial, você não precisará entrar na
VM, a menos que precise solucionar
problemas.
4. Escolha a guia rede e, em configurar redes virtuais, selecione criar novo.

5. Em criar rede virtual, use as configurações na tabela abaixo da imagem:

Nome MyResource-vnet Você pode usar o nome padrão

gerado para sua rede virtual.
Intervalo de endereços 10.10.0.0/16 Use um único intervalo de endereços

para a rede virtual.
Nome da sub-rede Tutorial – net Nome da sub-rede.
Intervalo de endereços (sub-rede) 10.10.1.0/24 O tamanho da sub-rede define

quantas interfaces podem ser
adicionadas à sub-rede. Essa sub-
rede é usada pelo site do WordPress.
Uma sub-rede /24 fornece
endereços de host 254.
6. Selecione OK para criar a rede virtual.

7. De volta à guia rede , escolha nenhum para IP público.
8. Escolha a guia Gerenciamento e, em conta de armazenamento de diagnóstico, escolha a conta de
armazenamento que você criou com seu aplicativo de funções.
9. Selecione Examinar + criar. Após a conclusão da validação, selecione criar. O processo de criação de VM
leva alguns minutos. A VM criada só pode acessar a rede virtual.
10. Depois que a VM for criada, escolha ir para o recurso para exibir a página de sua nova VM e, em seguida,
escolha rede em configurações.
11. Verifique se não há um IP público. Anote o IP privado, que você usa para se conectar à VM do seu
Agora você tem um site do WordPress implantado inteiramente em sua rede virtual. Esse site não pode ser
acessado pela Internet pública.
Conectar seu aplicativo de funções à rede virtual

Com um site do WordPress em execução em uma VM em uma rede virtual, agora você pode conectar seu
aplicativo de funções a essa rede virtual.
1. Em seu novo aplicativo de funções, selecione recursos de plataforma > rede.
2. Em integração VNet, selecione clique aqui para configurar.
3. Na página de integração de rede virtual, selecione Adicionar VNet (versão prévia) .

4. Em status do recurso de rede, use as configurações na tabela abaixo da imagem:
Rede Virtual MyResource-vnet Essa rede virtual é aquela que você

criou anteriormente.
Sub-rede Criar nova sub-rede Crie uma sub-rede na rede virtual

para uso do seu aplicativo de
funções. A integração VNet deve ser
configurada para usar uma sub-rede
vazia. Não importa que suas funções
usem uma sub-rede diferente da
VM. A rede virtual roteia
automaticamente o tráfego entre as
duas sub-redes.
Nome da sub-rede Função-net Nome da nova sub-rede.
Bloco de endereço de rede 10.10.0.0/16 Escolha o mesmo bloco de endereço

virtual usado pelo site do WordPress. Você
deve ter apenas um bloco de
endereço definido.
Intervalo de endereços 10.10.2.0/24 O tamanho da sub-rede restringe o

número total de instâncias para as
quais seu aplicativo de funções de
plano Premium pode ser expandido.
Este exemplo usa uma sub-rede
/24 com endereços de host 254
disponíveis. Essa sub-rede está
excessivamente provisionada, mas
fácil de calcular.
5. Selecione OK para adicionar a sub-rede. Feche as páginas integração VNet e status do recurso de rede
para retornar à página do aplicativo de funções.
O aplicativo de funções agora pode acessar a rede virtual onde o site do WordPress está em execução. Em
seguida, você usa proxies do Azure Functions para retornar um arquivo do site do WordPress.
Criar um proxy para acessar os recursos da VM

Com a integração VNet habilitada, você pode criar um proxy em seu aplicativo de funções para encaminhar
solicitações para a VM em execução na rede virtual.
1. Em seu aplicativo de funções, selecione proxies > + e, em seguida, use as configurações de proxy na tabela
abaixo da imagem:
Nome Plant O nome pode ser qualquer valor. Ele

é usado para identificar o proxy.
Modelo de rota /plant Rota que mapeia para um recurso de

VM.
URL de back-end http://< YOUR_VM_IP >/wp- Substitua <YOUR_VM_IP> pelo

content/themes/twentyseventeen/as endereço IP da sua VM do
sets/images/header.jpg WordPress que você criou
anteriormente. Esse mapeamento
retorna um único arquivo do site.
2. Selecione criar para adicionar o proxy ao seu aplicativo de funções.
Experimentar
1. No navegador, tente acessar a URL usada como a URL de back-end. Conforme esperado, a solicitação
atinge o tempo limite. Um tempo limite ocorre porque o site do WordPress está conectado somente à sua
rede virtual e não à Internet.
2. Copie o valor da URL do proxy do seu novo proxy e cole-o na barra de endereços do seu navegador. A
imagem retornada é do site do WordPress em execução dentro de sua rede virtual.
Seu aplicativo de funções está conectado à Internet e à sua rede virtual. O proxy está recebendo uma solicitação
pela Internet pública e, em seguida, agindo como um proxy HTTP simples para encaminhar essa solicitação para a
rede virtual conectada. Em seguida, o proxy transmite a resposta de volta para você publicamente pela Internet.
Limpar recursos
Próximas etapas
Neste tutorial, o site do WordPress serve como uma API que é chamada usando um proxy no aplicativo de
funções. Esse cenário faz um bom tutorial porque é fácil de configurar e Visualizar. Você pode usar qualquer outra
API implantada em uma rede virtual. Você também pode ter criado uma função com código que chama APIs
implantadas na rede virtual. Um cenário mais realista é uma função que usa APIs de cliente de dados para chamar
uma instância de SQL Server implantada na rede virtual.
As funções em execução em um plano Premium compartilham a mesma infraestrutura de serviço de aplicativo
subjacente que aplicativos Web em planos de PremiumV2. Toda a documentação dos aplicativos Web no serviço
Azure app se aplica às suas funções de plano Premium.
Saiba mais sobre as opções de rede no functions
Tutorial: Automatizar o redimensionamento de
imagens carregadas usando a Grade de Eventos
A Grade de Eventos do Azure é um serviço de eventos para a nuvem. A Grade de Eventos permite criar
assinaturas em eventos gerados pelos serviços do Azure ou por recursos de terceiros.
Este tutorial é a segunda parte de uma série de tutoriais sobre o Armazenamento. Ele estende o tutorial anterior
sobre o Armazenamento para adicionar a geração automática de miniaturas sem servidor usando a Grade de
Eventos do Azure e o Azure Functions. A Grade de Eventos permite que o Azure Functions responda aos eventos
do armazenamento de Blobs do Azure e gere miniaturas das imagens carregadas. Uma assinatura de evento é
criada no evento de criação do armazenamento de Blobs. Quando um blob é adicionado a um contêiner de
armazenamento de Blobs específico, um ponto de extremidade de função é chamado. Os dados passados para a
associação de função da Grade de Eventos são usados para acessar o blob e gerar a imagem em miniatura.
Use a CLI do Azure e o portal do Azure para adicionar a funcionalidade de redimensionamento a um aplicativo
de upload de imagens existente.
.NET
SDK do Node.js V2
SDK do Node.js V10
Criar uma conta geral do Armazenamento do Azure
Implantar o código sem servidor usando o Azure Functions
Criar uma assinatura de evento do armazenamento de Blobs na Grade de Eventos
Pré-requisitos
NOTE
Este artigo foi atualizado para usar o novo módulo Az do Azure PowerShell. Você ainda pode usar o módulo AzureRM, que
continuará a receber as correções de bugs até pelo menos dezembro de 2020. Para saber mais sobre o novo módulo Az e a
compatibilidade com o AzureRM, confira Apresentação do novo módulo Az do Azure PowerShell. Para obter instruções de
instalação do módulo Az, confira Instalar o Azure PowerShell.
Para concluir este tutorial:

É necessário concluir o tutorial de Armazenamento de Blobs anterior: Carregue os dados de imagem na nuvem
com o Armazenamento do Azure.
Se você não tiver registrado o provedor de recursos da Grade de Eventos em sua assinatura, verifique se que ele
está registrado.
az provider register --namespace Microsoft.EventGrid
Usar o Azure Cloud Shell

O Azure hospeda o Azure Cloud Shell, um ambiente de shell interativo que pode ser usado por meio do
navegador. O Cloud Shell permite usar bash ou PowerShell para trabalhar com serviços do Azure. É possível
usar os comandos pré-instalados do Cloud Shell para executar o código neste artigo sem precisar instalar nada
no seu ambiente local.
Para iniciar o Azure Cloud Shell:
OPÇÃO EXEMPLO/LINK
Selecione Experimente no canto superior direito de um

bloco de código. Selecionar Experimente não copia
automaticamente o código para o Cloud Shell.
Acesse https://shell.azure.com ou clique no botão Iniciar o

Cloud Shell para abri-lo no navegador.
Clique no botão Cloud Shell na barra de menus no canto

superior direito do portal do Azure.
Para executar o código neste artigo no Azure Cloud Shell:

1. Inicie o Cloud Shell.
2. Clique no botão Copiar no bloco de código para copiá-lo.
3. Cole o código na sessão do Cloud Shell com Ctrl+Shift+V no Windows e no Linux ou Cmd+Shift+V no
macOS.
4. Pressione Enter para executar o código.
Caso opte por instalar e usar a CLI localmente, este tutorial exigirá a CLI do Azure versão 2.0.14 ou posterior.
Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do
Azure.
Se você não estiver usando o Cloud Shell, primeiro você deve entrar usando az login .

O Azure Functions exige uma conta de armazenamento geral. Além da conta de Armazenamento de Blobs que
você criou no tutorial anterior, crie uma conta de armazenamento geral separada no grupo de recursos usando o
comando az storage account create. Os nomes da conta de armazenamento devem ter entre 3 e 24 caracteres e
podem conter apenas números e letras minúsculas.
1. Defina uma variável para conter o nome do grupo de recursos que você criou no tutorial anterior.
resourceGroupName=myResourceGroup
2. Defina uma variável para o nome da nova conta de armazenamento necessária para o Azure Functions.
functionstorage=<name of the storage account to be used by the function>
3. Crie a conta de armazenamento para a função do Azure.
az storage account create --name $functionstorage --location southeastasia \

--resource-group $resourceGroupName --sku Standard_LRS --kind storage

Você deve ter um aplicativo de funções para hospedar a execução da função. O aplicativo de funções fornece um
ambiente para execução sem servidor do seu código de função. Crie um aplicativo de funções ao usar o comando
az functionapp create.
No comando a seguir, forneça seu próprio nome exclusivo do aplicativo de funções. O nome do aplicativo de
funções é usado como domínio DNS padrão para o aplicativo de funções, portanto, o nome deve ser exclusivo
entre todos os aplicativos no Azure.
1. Especifique um nome para o aplicativo de funções será criado.
functionapp=<name of the function app>
2. Crie a função do Azure.
az functionapp create --name $functionapp --storage-account $functionstorage \

--resource-group $resourceGroupName --consumption-plan-location southeastasia
Agora você deve configurar o aplicativo de função para se conectar à conta de armazenamento de Blobs criada
no tutorial anterior.
Configurar o aplicativo de funções

A função precisa ter credenciais para a conta de Armazenamento de Blobs, que são adicionadas às configurações
do aplicativo de funções usando o comando az functionapp config appsettings set.
.NET
SDK do Node.js V2
SDK do Node.js V10
blobStorageAccount=<name of the Blob storage account you created in the previous tutorial>
storageConnectionString=$(az storage account show-connection-string --resource-group $resourceGroupName \
--name $blobStorageAccount --query connectionString --output tsv)
az functionapp config appsettings set --name $functionapp --resource-group $resourceGroupName \

--settings AzureWebJobsStorage=$storageConnectionString THUMBNAIL_CONTAINER_NAME=thumbnails \
THUMBNAIL_WIDTH=100 FUNCTIONS_EXTENSION_VERSION=~2
A configuração FUNCTIONS_EXTENSION_VERSION=~2 faz com que o aplicativo de funções execute na versão 2.x do
Azure Functions Runtime.
Agora você pode implantar um projeto de código de função nesse aplicativo de funções.
Implantar o código de função

.NET
SDK do Node.js V2
SDK do Node.js V10
A função de redimensionamento do C# de exemplo está disponível no GitHub. Implante esse projeto de código
no aplicativo de funções usando o comando az functionapp deployment source config.
az functionapp deployment source config --name $functionapp --resource-group $resourceGroupName --branch

master --manual-integration --repo-url https://github.com/Azure-Samples/function-image-upload-resize
A função de redimensionamento de imagem é disparada por solicitações HTTP enviadas a ele a partir do serviço
de Grade de Eventos. Você informa à Grade de Eventos que você deseja obter essas notificações na URL da
função criando uma assinatura de evento. Neste tutorial, você assina eventos criados de blob.
Os dados passados para a função da notificação de Grade de Eventos incluem a URL do blob. Essa URL, por sua
vez, é passada para a associação de entrada para obter a imagem carregada a partir do armazenamento de Blob.
A função gera uma imagem em miniatura e grava o fluxo resultante em um contêiner separado no
armazenamento de Blobs.
Este projeto usa EventGridTrigger para o tipo de gatilho. O uso do gatilho de Grade de Eventos é recomendado
em gatilhos HTTP genéricos. A Grade de Eventos valida automaticamente os gatilhos de Função da Grade de
Eventos. Com os gatilhos HTTP genéricos, você deve implementar a resposta de validação.
.NET
SDK do Node.js V2
SDK do Node.js V10
Para saber mais sobre essa função, consulte os arquivos function.json e run.csx.
O código de projeto de função é implantado diretamente no repositório público de exemplo. Para saber mais
sobre as opções de implantação para o Azure Functions, consulte Implantação contínua para o Azure Functions.
Criar uma assinatura de evento

Uma assinatura de evento indica quais eventos gerados pelo provedor você deseja que sejam enviados para um
ponto de extremidade específico. Nesse caso, o ponto de extremidade é exposto pela função. Use as seguintes
etapas para criar uma assinatura de evento que envia notificações à sua função no portal do Azure:
1. No portal do Azure, selecione Todos os Serviços no menu à esquerda e, em seguida, selecione
Aplicativos de Funções.
2. Expanda o aplicativo de funções, escolha a função Miniatura e, em seguida, selecione Adicionar
assinatura da Grade de Eventos.
3. Use as configurações da assinatura de evento, conforme especificado na tabela.

Nome imageresizersub Nome que identifica a nova

assinatura de evento.
Tipo de tópico Contas de armazenamento Escolha o provedor de eventos da

conta de Armazenamento.
Assinatura Sua assinatura do Azure Por padrão, sua assinatura atual do

Azure é selecionada.
Grupo de recursos myResourceGroup Selecione Usar existente e escolha o

grupo de recursos que está sendo
usado neste tutorial.
Recurso Sua conta de armazenamento de Escolha a conta de armazenamento

Blobs de Blobs criada.
Tipos de evento Blob criado Desmarque todos os tipos que não

sejam Blob criado. Somente os
tipos de evento
Microsoft.Storage.BlobCreated
são passados para a função.
Tipo de assinante gerado automaticamente Pré-definidas como Web Hook.

Ponto de extremidade do gerado automaticamente Use a URL de ponto de extremidade

assinante gerada para você.
4. Alterne para a guia Filtro e execute as seguintes ações:

a. Selecione a opção Habilitar filtragem por assunto.
b. Em O assunto começa com, insira o seguinte valor:
/blobServices/default/containers/images/blobs/ .
5. Selecione Criar para adicionar a assinatura de evento. Isso criará uma assinatura de evento que dispara a
função Thumbnail quando um blob é adicionado ao contêiner images . A função redimensiona as imagens
e as adiciona ao contêiner thumbnails .
Agora que os serviços de back-end estão configurados, teste a funcionalidade de redimensionamento da imagem
no aplicativo Web de exemplo.
Testar o aplicativo de exemplo

Para testar o redimensionamento de imagem no aplicativo Web, navegue para a URL do aplicativo publicado. A
URL padrão do aplicativo Web é https://<web_app>.azurewebsites.net .
.NET
SDK do Node.js V2
SDK do Node.js V10
Clique na região Carregar fotos para selecionar e carregar um arquivo. Também arraste uma foto para essa
região.
Observe que, depois que a imagem carregada desaparece, uma cópia da imagem carregada é exibida no
carrossel Miniaturas geradas. Essa imagem foi redimensionada pela função, adicionada ao contêiner de
miniaturas e baixada pelo cliente Web.
Próximas etapas
Neste tutorial, você aprendeu como:
Criar uma conta geral do Armazenamento do Azure
Implantar o código sem servidor usando o Azure Functions
Criar uma assinatura de evento do armazenamento de Blobs na Grade de Eventos
Avance até a terceira parte da série de tutoriais sobre o Armazenamento para saber como proteger o acesso à
Proteger o acesso aos dados de um aplicativo na nuvem
Para saber mais sobre a Grade de Eventos, consulte Uma introdução à Grade de Eventos do Azure.
Para experimentar outro tutorial que mostra o Azure Functions, consulte Criar uma função que é integrada
aos Aplicativos Lógicos do Azure.
Tutorial: Aplicar modelos de machine learning no
Azure Functions com o Python e o TensorFlow
Este artigo demonstra como o Azure Functions permite que você use o Python e o TensorFlow com um modelo de
machine learning para classificar uma imagem com base no respectivo conteúdo.
Neste tutorial, você aprenderá a:
Inicializar um ambiente local para o desenvolvimento de Azure Functions no Python
Importar um modelo de machine learning do TensorFlow personalizado para um aplicativo de funções
Criar uma API HTTP sem servidor para prever se uma foto contém um cão ou um gato
Consumir a API de um aplicativo Web
Pré-requisitos
Para criar Azure Functions em Python, você precisa instalar algumas ferramentas.
Python 3.6
Ferramentas básicas do Azure Functions
Um editor de códigos como o Visual Studio Code
Clonar o repositório do tutorial

Para começar, abra um terminal e clone o repositório a seguir usando o Git:
git clone https://github.com/Azure-Samples/functions-python-tensorflow-tutorial.git

cd functions-python-tensorflow-tutorial
O repositório contém algumas pastas.

start: Essa é sua pasta de trabalho para o tutorial
end: Esse é o resultado final e a implementação completa para sua referência
resources: Contém o modelo de machine learning e as bibliotecas auxiliares
frontend: Um site que chama o aplicativo de funções
Criar e ativar um ambiente virtual do Python

O Azure Functions requer o Python 3.6.x. Você criará um ambiente virtual para garantir que está usando a versão
necessária do Python.
Altere o diretório de trabalho atual para a pasta start. Em seguida, crie e ative um ambiente virtual chamado .venv.
Dependendo da instalação do Python, os comandos para criar um ambiente virtual do Python 3.6 podem ser
diferentes das instruções a seguir.
Linux e macOS:
cd start
python3.6 -m venv .venv
source .venv/bin/activate
Windows:
cd start
py -3.6 -m venv .venv
.venv\scripts\activate
o prompt de terminal agora é prefixado com (.venv) , o que indica que você ativou com êxito o ambiente virtual.
Verifique se o python , no ambiente virtual, é de fato o Python 3.6.x.
python --version
NOTE
Para o restante do tutorial, você executa comandos no ambiente virtual. Se você precisar reativar o ambiente virtual em um
terminal, execute o comando de ativação apropriado para o sistema operacional.
Criar um projeto do Azure Functions

Na pasta start, use o Azure Functions Core Tools para inicializar um aplicativo de funções do Python.
func init --worker-runtime python
Um aplicativo de funções pode conter uma ou mais Azure Functions. Abra a pasta start em um editor e examine o
conteúdo.
local.settings.json: contém as configurações de aplicativo usadas para desenvolvimento local
host.json: contém configurações para o host e as extensões do Azure Functions
requirements.txt: contém os pacotes do Python exigidos por este aplicativo
Criar uma função HTTP

O aplicativo requer um único ponto de extremidade de API HTTP que usa uma URL de imagem como entrada e
retorna uma previsão quanto à imagem conter um cachorro ou um gato.
No terminal, use o Azure Functions Core Tools para fazer scaffold de uma nova função HTTP denominada classify.
func new --language python --template HttpTrigger --name classify
Uma nova pasta chamada classify é criada, contendo dois arquivos.

__init__.py: um arquivo para a função principal
function.json: um arquivo que descreve o gatilho da função e as respectivas associações de entrada e saída
Executar a função
No terminal, com o ambiente virtual Python ativado, inicie o aplicativo de funções.
func start
Abra uma janela de navegador e navegue até a URL a seguir. A função deve ser executada e retornar Olá Azure!
http://localhost:7071/api/classify?name=Azure
Use Ctrl-C para interromper o aplicativo de funções.
Importar o modelo TensorFlow

Você usará um modelo TensorFlow predefinido que foi treinado e exportado do Serviço de Visão Personalizada do
Azure.
NOTE
Se quiser criar seu próprio modelo usando a camada gratuita do Serviço de Visão Personalizada, você poderá seguir as
instruções no repositório do projeto de exemplo.
O modelo consiste em dois arquivos na pasta <RAIZ_DO_REPOSITÓRIO>/resources/model: model.pb e labels.txt.

Copie-os para a pasta da função classify.
Linux e macOS:
cp ../resources/model/* classify
Windows:
copy ..\resources\model\* classify
verifique se você incluiu o * no comando acima. Verifique se classify agora contém arquivos denominados
model.pb e labels.txt.
Adicionar as funções auxiliares e dependências
Algumas funções auxiliares para preparar a imagem de entrada e fazer uma previsão usando o TensorFlow estão
em um arquivo chamado predict.py, na pasta resources. Copie esse arquivo para a pasta da função classify.
Linux e macOS:
cp ../resources/predict.py classify
Windows:
copy ..\resources\predict.py classify
verifique se classify agora contém um arquivo denominado predict.py.

Instalar dependências
A biblioteca auxiliar tem algumas dependências que precisam ser instaladas. Abra start/requirements.txt no editor e
adicione as dependências a seguir ao arquivo.
tensorflow==1.14
Pillow
requests
Salve o arquivo.
No terminal com o ambiente virtual ativado, execute o comando a seguir na pasta start para instalar as
dependências. Algumas etapas de instalação podem levar alguns minutos para serem concluídas.
pip install --no-cache-dir -r requirements.txt
Armazenando em cache o modelo em variáveis globais

No editor, abra predict.py e examine a função _initialize próxima à parte superior do arquivo. Observe que o
modelo TensorFlow é carregado do disco na primeira vez em que a função é executada e salvo em variáveis
globais. O carregamento do disco é ignorado nas execuções subsequentes da função _initialize . Armazenar em
cache o modelo na memória com essa técnica acelera as previsões posteriores.
Para obter mais informações sobre variáveis globais, confira o Guia do desenvolvedor do Python para o Azure
Functions.
Atualizar função para executar previsões

Abra classify/__init__.py no editor. Importe a biblioteca predict que você adicionou à mesma pasta anteriormente.
Adicione as instruções import a seguir abaixo das outras importações que já estão no arquivo.
import json
from .predict import predict_image_from_url
Substitua o código do modelo de função por este a seguir.

def main(req: func.HttpRequest) -> func.HttpResponse:
image_url = req.params.get('img')
results = predict_image_from_url(image_url)
headers = {
"Content-type": "application/json",
"Access-Control-Allow-Origin": "*"
}
return func.HttpResponse(json.dumps(results), headers = headers)
Certifique-se de salvar as alterações.

Essa função recebe uma URL de imagem em um parâmetro de cadeia de caracteres de consulta chamado img . Ele
chama predict_image_from_url da biblioteca auxiliar que baixa a imagem e retorna uma previsão usando o modelo
do TensorFlow. Em seguida, a função retorna uma resposta HTTP com os resultados.
Já que o ponto de extremidade HTTP é chamado por uma página da Web hospedada em outro domínio, a resposta
HTTP inclui um cabeçalho Access-Control-Allow-Origin para atender aos requisitos de CORS (compartilhamento
de recursos entre origens) do navegador.
NOTE
Em um aplicativo de produção, altere * para a origem específica da página da Web para obter segurança adicional.
Executar o aplicativo de funções

Verifique se o ambiente virtual do Python ainda está ativado e inicie o aplicativo de funções usando o comando a
seguir.
func start
Em um navegador, abra esta URL que chama sua função com a URL de uma foto de gato. Verifique se um
resultado de previsão válido é retornado.
http://localhost:7071/api/classify?img=https://raw.githubusercontent.com/Azure-Samples/functions-python-
tensorflow-tutorial/master/resources/assets/samples/cat1.png
Mantenha o aplicativo de funções em execução.

Executar o aplicativo Web
Há um aplicativo Web simples na pasta frontend que consome a API HTTP no aplicativo de funções.
Abra um terminal separado e altere para a pasta frontend. Inicie um servidor HTTP com o Python 3.6.
Linux e macOS:
cd <FRONT_END_FOLDER>
python3.6 -m http.server
Windows:
cd <FRONT_END_FOLDER>
py -3.6 -m http.server
Em um navegador, navegue até a URL do servidor HTTP que é exibida no terminal. Um aplicativo Web deve
aparecer. Insira uma das URLs de foto a seguir na caixa de texto. Você também pode usar uma URL de uma foto de
gato ou de cachorro publicamente acessível.
https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-
tutorial/master/resources/assets/samples/cat1.png
tutorial/master/resources/assets/samples/cat2.png
tutorial/master/resources/assets/samples/dog1.png
tutorial/master/resources/assets/samples/dog2.png
Quando você clica em enviar, o aplicativo de funções é chamado e um resultado é exibido na página.
Limpar recursos
Todo este tutorial é executado localmente em seu computador, portanto, não há recursos ou serviços do Azure a
serem limpos.
Próximas etapas
Neste tutorial, você aprendeu a criar e personalizar uma API HTTP com o Azure Functions para fazer previsões
usando um modelo do TensorFlow. Você também aprendeu como chamar a API de um aplicativo Web.
É possível usar as técnicas deste tutorial para criar APIs de qualquer complexidade, fazendo-o simultaneamente à
execução no modelo de computação sem servidor fornecido pelo Azure Functions.
Para implantar o aplicativo de funções no Azure, use o Azure Functions Core Tools ou o Visual Studio Code.
Guia do desenvolvedor do Python para o Azure Functions
Crie uma função no Linux usando uma imagem
personalizada
O Azure Functions permite hospedar suas funções no Linux em seu próprio contêiner personalizado. Você
também pode hospedar em um contêiner padrão do Serviço de Aplicativo do Azure. Essa funcionalidade requer o
tempo de execução do Functions 2.x.
Neste tutorial, você aprenderá a implantar suas funções no Azure como uma imagem personalizada do Docker.
Esse padrão será útil quando você precisar personalizar a imagem de contêiner interna. Convém usar uma
imagem personalizada quando suas funções precisarem de uma versão de idioma específico, ou exigirem uma
configuração ou dependência específica que não é fornecida na imagem interna. Imagens base com suporte para
Azure Functions encontram-se no repositório de imagens de base do Azure Functions.
Este tutorial explica como usar o Azure Functions Core Tools para criar uma função em uma imagem
personalizada do Linux. Publique essa imagem em um aplicativo de funções no Azure, que foi criado usando a
CLI do Azure. Posteriormente, você atualizará a função para se conectar ao armazenamento de Filas do Azure.
Você também a habilitará.
Crie um aplicativo de funções e o Dockerfile usando o Core Tools.
Compile uma imagem personalizada usando o Docker.
Publique uma imagem personalizada em um registro de contêiner.
Criar uma conta do Armazenamento do Azure.
Criar um plano de hospedagem Premium.
Implante um aplicativo de funções do Hub do Docker.
Adicione configurações de aplicativo ao aplicativo de funções.
Habilitar a implantação contínua.
Habilitar conexões SSH para o contêiner.
Adicionar uma associação de saída de armazenamento de filas.
Adicionar o monitoramento do Application Insights.
As etapas a seguir têm suporte em um computador Mac, Windows ou Linux.
Pré-requisitos
Antes de executar este exemplo, você deve ter o seguinte:
Instale a versão do Azure Core Tools 2.x.
Instale a CLI do Azure. Este artigo requer a CLI do Azure versão 2.0 ou posterior. Execute az --version
descobrir a versão que você tem.
Você também pode usar o Azure Cloud Shell.
Uma assinatura ativa do Azure.
NOTE
Criar o projeto local

Execute o comando a seguir na linha de comando para criar um projeto de aplicativo de funções na pasta
MyFunctionProj do diretório local atual. Para um projeto Python, você precisa estar executando em um ambiente
virtual.
func init MyFunctionProj --docker
Quando você inclui a opção --docker , um dockerfile é gerada para o projeto. Esse arquivo é usado para criar um
contêiner personalizado no qual executar o projeto. A imagem base usada depende da linguagem do tempo de
execução do trabalho escolhida.
Quando solicitado, escolha um tempo de execução do trabalho com as seguintes linguagens:
dotnet : cria um projeto de biblioteca de classes do .NET Core (.csproj).
node : cria um projeto de JavaScript.
python : cria um projeto do Python.
Use o comando a seguir para navegar até a nova pasta do projeto MyFunctionProj .
cd MyFunctionProj
Criar uma função

O comando a seguir cria uma função disparada por HTTP denominada MyHttpTrigger .
func new --name MyHttpTrigger --template "HttpTrigger"
Quando o comando for executado, você verá algo parecido com a seguinte saída:
The function "MyHttpTrigger" was created successfully from the "HttpTrigger" template.

O comando a seguir inicia o aplicativo de funções. O aplicativo é executado usando o mesmo tempo de execução
do Azure Functions no Azure. O comando start varia, dependendo da linguagem do projeto.
C#
func start --build
JavaScript
func start
TypeScript
npm install
npm start
Quando o host do Functions é iniciado, ele escreve algo parecido com a seguinte saída, que foi truncada para
facilitar a leitura:
%%%%%%
%%%%%%
@ %%%%%% @
@@ %%%%%% @@
@@@ %%%%%%%%%%% @@@
@@ %%%%%%%%%% @@
@@ %%%% @@
@@ %%% @@
@@ %% @@
%%
%
...

...
Http Functions:
HttpTrigger: http://localhost:7071/api/MyHttpTrigger

navegador. Acrescente o valor de cadeia de consulta ?name=<yourname> a essa URL e execute a solicitação. O
exemplo a seguir mostra a resposta no navegador à solicitação GET retornada pela função local:
Agora que você executou a função localmente, poderá criar o aplicativo de funções e outros recursos necessários
no Azure.
Compilar do arquivo do Docker

Examine o Dockerfile na pasta raiz do projeto. Este arquivo descreve o ambiente necessário para executar o
aplicativo de funções no Linux. O exemplo a seguir é um Dockerfile que cria um contêiner que executa um
aplicativo de funções no tempo de execução do trabalho em JavaScript (Node.js):
FROM mcr.microsoft.com/azure-functions/node:2.0
ENV AzureWebJobsScriptRoot=/home/site/wwwroot
COPY . /home/site/wwwroot
NOTE
A lista completa de imagens base com suporte para Azure Functions encontram-se na página de imagens de base do Azure
Functions.
Execute o comando build
Na pasta raiz, execute o comando docker build e forneça um nome, mydockerimage , e uma marca, v1.0.0 .
Substitua <docker-id> pela ID da conta do Hub do Docker. Esse comando compila a imagem do Docker para o
contêiner.
docker build --tag <docker-id>/mydockerimage:v1.0.0 .
Quando o comando for concluído, você poderá executar o novo contêiner localmente.
Executar a imagem localmente
Verifique se a imagem criada funciona executando a imagem do Docker em um contêiner local. Execute o
comando docker run e envie o nome e a marcação da imagem para ele. Lembre-se de especificar a porta usando
o argumento -p .
docker run -p 8080:80 -it <docker-ID>/mydockerimage:v1.0.0
Com a imagem personalizada em execução em um contêiner local do Docker, verifique se o aplicativo de funções
e o contêiner estão funcionando corretamente navegando até http://localhost:8080.
NOTE
Neste ponto, ao tentar chamar sua função HTTP específica, você obtém uma resposta de erro HTTP 401. Isso ocorre porque
sua função é executada no contêiner local como ocorreria no Azure, o que significa que a chave de função é necessária.
Como o contêiner ainda não foi publicado em um aplicativo de funções, não há nenhuma chave de função disponível. Você
verá posteriormente que, quando usar as Core Tools para publicar seu contêiner, as teclas de função serão mostradas a
você. Se quiser testar sua função em execução no contêiner local, você poderá alterar a chave de autorização para
anonymous .
Depois de verificar o aplicativo de funções no contêiner, interrompa a execução. Agora, você pode enviar por push
a imagem personalizada à sua conta do Hub do Docker.
Enviar por push para o Docker Hub

Um Registro é um aplicativo que hospeda imagens e fornece a imagem de serviços e serviços de contêiner. Para
compartilhar sua imagem, você deve enviá-la por push para um registro. O Hub do Docker é um Registro para
imagens do Docker que permite hospedar seus próprios repositórios públicos ou particulares.
Antes de enviar uma imagem por push, você deve entrar no Hub do Docker usando o comando docker login.
Substitua <docker-id> pelo nome de sua conta e digite sua senha no console do prompt. Para obter outras
opções de senha de Hub do Docker, confira a documentação de comandos de logon do docker.
docker login --username <docker-id>
Uma mensagem “logon com êxito” confirma que você está conectado. Depois de conectado, envie a imagem por
push para o Hub do Docker usando o comando docker push.
docker push <docker-id>/mydockerimage:v1.0.0

Após o push ter êxito, você pode usar a imagem como a origem de implantação para um novo aplicativo de
funções no Azure.

Crie um grupo de recursos com o comando az group create. Um grupo de recursos do Azure é um contêiner
lógico no qual os recursos do Azure, como os aplicativos de funções, bancos de dados e contas de

informações sobre suas funções. Crie uma conta de propósito geral de armazenamento no grupo de recursos que
você criou ao utilizar o comando az storage account create.
No comando a seguir, substitua um nome da conta de armazenamento globalmente exclusivo quando você vir o
espaço reservado <storage_name> . Os nomes da conta de armazenamento devem ter entre 3 e 24 caracteres e
az storage account create --name <storage_name> --location westeurope --resource-group myResourceGroup --sku
Standard_LRS
Criar um plano Premium

Hospedagem do Linux para contêineres personalizados do Functions compatíveis em planos Dedicados (Serviço
de Aplicativo) e planos Premium. Este tutorial usa um plano Premium, que pode ser dimensionado conforme
necessário. Para saber mais sobre hospedagem, confira Comparação de planos de hospedagem do Azure
Functions.
O exemplo a seguir cria um plano Premium chamado myPremiumPlan no tipo de preço Elástico Premium 1 (
--sku EP1 ), na região Oeste dos EUA ( -location WestUS ) e em um contêiner do Linux ( --is-linux ).
az functionapp plan create --resource-group myResourceGroup --name myPremiumPlan \

--location WestUS --number-of-workers 1 --sku EP1 --is-linux
Criar um aplicativo com base na imagem

O aplicativo de funções gerencia a execução das funções em seu plano de hospedagem. Crie um aplicativo de
funções a partir de uma imagem do Hub do Docker usando o comando az functionapp create.
No comando a seguir, substitua um nome de aplicativo de funções exclusivo quando você vir o espaço reservado
<app_name> e o nome da conta de armazenamento por <storage_name> . O <app_name> é usado como domínio
DNS padrão para o aplicativo de funções, portanto, o nome deve ser exclusivo entre todos os aplicativos no
Azure. Como antes, <docker-id> é o nome de conta do Docker.
az functionapp create --name <app_name> --storage-account <storage_name> --resource-group myResourceGroup \
--plan myPremiumPlan --deployment-container-image-name <docker-id>/mydockerimage:v1.0.0
O parâmetro deployment-container-image-name indica a imagem hospedada no Hub do Docker a ser usada

para criar o aplicativo de funções. Use o comando az functionapp config container show para exibir informações
sobre a imagem usada para a implantação. Use o comando az functionapp config container set para implantar de
uma imagem diferente.
Configurar o aplicativo de funções

A função precisa da cadeia de conexão para se conectar à conta de armazenamento padrão. Quando você estiver
publicando sua imagem personalizada em uma conta de contêiner privado, defina essas configurações de
aplicativo como variáveis de ambiente no Dockerfile usando a instrução ENV, ou algo semelhante.
Nesse caso, <storage_name> é o nome da conta de armazenamento criada. Obtenha a cadeia de conexão com o
comando az storage account show -connection-string. Adicione essas configurações de aplicativo ao aplicativo de
funções com o comando az functionapp config appsettings set.
storageConnectionString=$(az storage account show-connection-string \

--resource-group myResourceGroup --name <storage_name> \
--query connectionString --output tsv)
az functionapp config appsettings set --name <app_name> \

--resource-group myResourceGroup \
--settings AzureWebJobsDashboard=$storageConnectionString \
AzureWebJobsStorage=$storageConnectionString
NOTE
Se o contêiner for privado, você precisaria definir as seguintes configurações de aplicativo também
DOCKER_REGISTRY_SERVER_USERNAME
DOCKER_REGISTRY_SERVER_PASSWORD
Você terá que parar e iniciar o aplicativo de função para que esses valores sejam coletados
Verificar as funções
A função disparada por HTTP que você criou requer uma chave de função ao chamar o ponto de extremidade.
Neste momento, a maneira mais fácil de obter a URL da função, incluindo a chave, é do portal do Azure.
TIP
Você também pode obter suas chaves de função usando as APIs de gerenciamento de chaves, o que exige que você
apresente um token de portador para autenticação.
Localize seu novo aplicativo de funções no portal do Azure digitando o nome do aplicativo de funções na caixa
Pesquisar na parte superior da página e selecionando o recurso Serviço de Aplicativo.
Selecione a função MyHttpTrigger, selecione </> Obter URL da função > padrão (Chave de função) >
Copiar.
Nessa URL, a chave de função é o parâmetro de consulta code .
NOTE
Já que seu aplicativo de funções é implantado como um contêiner, você não pode fazer alterações no seu código de função
no portal. Em vez disso, você deve atualizar o projeto no contêiner local e republicá-lo no Azure.
Cole a URL de função na barra de endereços do navegador. Adicione o valor da cadeia de caracteres de consulta
&name=<yourname> ao final desta URL e pressione Enter em seu teclado para executar a solicitação. Você deverá
ver a resposta retornada pela função exibida no navegador.
O exemplo a seguir mostra a resposta no navegador:
A URL da solicitação inclui uma chave que é necessária, por padrão, para acessar sua função via HTTP.
Habilitar a implantação contínua

Um dos benefícios de usar contêineres é o suporte para implantação contínua. O Functions permite que você
implante atualizações automaticamente quando o contêiner é atualizado no Registro. Habilitar a implantação
contínua com o comando az functionapp deployment container config.
az functionapp deployment container config --enable-cd \
--query CI_CD_URL --output tsv \
--name <app_name> --resource-group myResourceGroup
Esse comando retorna a URL de webhook de implantação após a implantação contínua ser habilitada. Você
também pode usar o comando az functionapp deployment container show -cd-url para retornar essa URL.
Copie a URL de implantação e navegue até seu repositório DockerHub, escolha a guia Webhooks, digite um
nome do Webhook para o webhook, cole a URL em URL do Webhooke, em seguida, escolha o sinal de adição
( + ).
Com o conjunto de webhook, todas as atualizações para a imagem vinculada no DockerHub fazem com que o
aplicativo de funções baixe e instale a imagem mais recente.
Habilitar conexões SSH

O SSH permite a comunicação segura entre um contêiner e um cliente. Com o SSH habilitado, você pode se
conectar ao contêiner usando as Ferramentas Avançadas do Serviço de Aplicativo (Kudu). Para facilitar a conexão
com o contêiner usando SSH, o Functions fornece uma imagem base que já tem o SSH habilitado.
Alterar a imagem base
Em seu Dockerfile, acrescente a cadeia de caracteres -appservice à imagem base na instrução FROM , que para
um projeto JavaScript é semelhante à mostrada a seguir.
FROM mcr.microsoft.com/azure-functions/node:2.0-appservice
As diferenças nas duas imagens base habilitam conexões SSH em seu contêiner. Essas diferenças são detalhadas
neste tutorial dos Serviços de Aplicativos.
Recompilar e reimplantar a imagem
Na pasta raiz, execute o comando docker build novamente e, assim como antes, substitua <docker-id> pela ID da
conta do Docker Hub.
Envie por push a imagem atualizada de volta para o Docker Hub.
A imagem atualizada é reimplantada para o aplicativo de funções.

Conectar-se ao contêiner no Azure
No navegador, navegue até o seguinte ponto de extremidade do scm. das Ferramentas Avançadas (Kudu) para o
contêiner do aplicativo de funções, substituindo <app_name> pelo nome do aplicativo de funções.
https://<app_name>.scm.azurewebsites.net/
Entre em sua conta do Azure e selecione a guia SSH para criar uma conexão SSH em seu contêiner.
Depois que a conexão for estabelecida, execute o comando top para exibir os processos em execução
atualmente.
Gravar no Armazenamento de Fila

O Functions permite que você conecte os serviços do Azure e outros recursos às funções sem precisar escrever
especial de associação de entrada. Embora uma função tenha apenas um gatilho, ela pode ter várias associações
de entrada e de saída. Para saber mais, confira Conceitos de gatilhos e de associações do Azure Functions.
Esta seção mostra como integrar sua função a uma fila do Armazenamento do Azure. A associação de saída que
você adiciona a essa função escreve dados de uma solicitação HTTP em uma mensagem na fila.
de conexão dessa conta é armazenada com segurança nas configurações do aplicativo no Azure. Neste artigo,
você escreverá mensagens em uma Fila de armazenamento na mesma conta. Para se conectar à sua Conta de
armazenamento ao executar a função localmente, é necessário baixar as configurações do aplicativo para o
arquivo local.settings.json.
IMPORTANT
JavaScript/Python
C#
seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}
Agora, você pode adicionar uma associação de saída do Armazenamento ao projeto.

funções.
JavaScript/Python
C#
function.json.
Para criar uma associação, clique com o botão direito do mouse (Ctrl+clique no macOS ) no arquivo
function.json na pasta HttpTrigger e escolha Adicionar associação... . Siga os prompts para definir as
seguintes propriedades de associação para a nova associação:
Selecionar direção de associação out A associação é uma associação de

saída.
Selecionar associação com Azure Queue Storage A associação é uma associação de fila
direção... do Armazenamento do Azure.

uso.

seguinte exemplo:
{
...
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
},
{
"type": "queue",
"direction": "out",
"name": "msg",
}
]
}

assinatura de função. Ao usar uma associação de saída, não é necessário usar o código do SDK do
Armazenamento do Azure para se autenticar, para obter uma referência de fila ou para escrever dados. O tempo
de execução do Functions e a associação de saída da fila fazem essas tarefas para você.
JavaScript
Python
C#
Adicione um código que usa o objeto de associação de saída msg em context.bindings para criar uma
mensagem da fila. Adicione esse código antes da instrução context.res .



context.res = {
};
}
else {
context.res = {
status: 400,
};
}
};
Atualizar o contêiner hospedado

Na pasta raiz, execute o comando docker build novamente e, desta vez, atualize a versão na tag para v1.0.2 .
Como antes, substitua <docker-id> pela ID da conta do Docker Hub.
Envie por push a imagem atualizada de volta para o repositório.
Verificar as atualizações no Azure

Use a mesma URL de antes do navegador para disparar sua função. Você deverá ver a mesma resposta. No
entanto, desta vez, a cadeia de caracteres que você passa como o parâmetro name é gravada na fila de
armazenamento outqueue .

exemplo a seguir:
executada.
seguir:
decode`
NOTE
Limpar recursos
Outros inícios rápidos nessa coleção aproveitam esse início rápido. Se você planeja continuar com Inícios
Rápidos ou tutoriais subsequentes, não limpe os recursos criados neste Início Rápido. Se você não planeja
continuar, use o comando a seguir para excluir todos os recursos criados neste Início Rápido:
Próximas etapas
Agora que você implantou com êxito o contêiner personalizado em um aplicativo de funções no Azure, considere
ler mais sobre os seguintes tópicos:
Funções de monitoramento
Opções de escala e de hospedagem
Hospedagem sem servidor baseada em Kubernetes
Tutorial: Implantar funções do Azure como módulos
do IoT Edge
Use o Azure Functions para implantar um código que implementa a lógica de negócios diretamente em seus
dispositivos Azure IoT Edge. Este tutorial o orienta através da criação e implantação de uma função do Azure que
filtra dados do sensor em um dispositivo IoT Edge simulado. Use o dispositivo IoT Edge simulado que foi criado
em Implantar Azure IoT Edge em um dispositivo simulado nos inícios rápidos do Windows ou do Linux. Neste
tutorial, você aprenderá como:
Usar o Visual Studio Code para criar uma função do Azure.
Usar o VS Code e o Docker para criar uma imagem do Docker e publicá-la em um registro de contêiner.
Implantar o módulo do registro do contêiner para seu dispositivo IoT Edge.
Exibir dados filtrados.
NOTE
Os módulos de funções do Azure no Azure IoT Edge são públicos na versão prévia.
A função do Azure criada neste tutorial filtra os dados de temperatura gerados pelo seu dispositivo. Ela só envia
mensagens upstream para o Hub IoT do Azure quando a temperatura estiver acima de um limite especificado.
Pré-requisitos
Antes de iniciar este tutorial, você deve ter passado pelo tutorial anterior para configurar seu ambiente de
desenvolvimento para o desenvolvimento de contêiner do Linux: Desenvolver módulos do IoT Edge para
dispositivos Linux. Ao concluir esse tutorial, você deve ter os seguintes pré-requisitos implementados:
Um Hub IoT na camada padrão ou gratuito no Azure.
Um dispositivo Linux que executa o Azure IoT Edge
Um registro de contêiner, como o Registro de Contêiner do Azure.
O Visual Studio Code configurado com o Azure IoT Tools.
O Docker CE configurado para executar contêineres do Linux.
Para desenvolver um módulo do IoT Edge com o Azure Functions, instale os seguintes pré-requisitos adicionais
em seu computador de desenvolvimento:
C# para extensão do Visual Studio Code (com OmniSharp).
O SDK 2.1 do .NET Core.
Criar um projeto de função

As Ferramentas de IoT do Azure para Visual Studio Code instaladas nos pré-requisitos fornecem funcionalidades
de gerenciamento, bem como alguns modelos de código. Nesta seção, você pode usar o Visual Studio Code para
criar uma solução de IoT Edge que contém uma função do Azure.
Criar um novo projeto
Crie um modelo de solução de Função C# que possa ser personalizado com seu próprio código.
1. Abra o Visual Studio Code no seu computador de desenvolvimento.
2. Abra a paleta de comandos do VS Code selecionando Exibir > Paleta de comandos.
3. Na paleta de comandos, digite e execute o comando Azure IoT Edge: nova solução do IoT Edge. Siga os
prompts na paleta de comandos para criar sua solução.
CAMPO VALOR
Selecionar pasta Escolha o local no computador de desenvolvimento em

que o VS Code criará os arquivos de solução.
Fornecer um nome para a solução Insira um nome descritivo para a solução, como
FunctionSolution ou aceite o padrão.
Selecionar modelo do módulo Escolha Azure Functions – C# .
Fornecer um nome de módulo Nomeie seu módulo CSharpFunction.
Fornecer o repositório de imagem do Docker para o Um repositório de imagem inclui o nome do registro de
módulo contêiner e o nome da imagem de contêiner. Sua imagem
de contêiner foi preenchida automaticamente na última
etapa. Substitua localhost:5000 pelo valor do servidor de
logon do seu registro de contêiner do Azure. Você pode
recuperar o servidor de logon da página Visão Geral do
seu registro de contêiner no portal do Azure. A cadeia de
caracteres final se parece com <nome do
registro>.azurecr.io/CSharpFunction.
Adicionar suas credenciais de registro

O arquivo do ambiente armazena as credenciais para o registro de contêiner e as compartilha com o tempo de
execução do IoT Edge. O tempo de execução precisa dessas credenciais para efetuar pull de imagens privadas para
o dispositivo IoT Edge.
1. No explorador do VS Code, abra o arquivo .env.
2. Atualize os campos com os valores de nome de usuário e senha que você copiou do registro de contêiner do
Azure.
3. Salve o arquivo.
Selecione sua arquitetura de destino
No momento, o Visual Studio Code pode desenvolver módulos em C para os dispositivos Linux AMD64 e Linux
ARM32v7. É necessário selecionar qual arquitetura você deseja usar para cada solução, porque o contêiner é
criado e executado de maneira diferente para cada tipo de arquitetura. O padrão é o Linux AMD64.
1. Abra a paleta de comandos e pesquise Azure IoT Edge: definir a plataforma de destino padrão para a
solução Edge ou selecione o ícone de atalho na barra lateral na parte inferior da janela.
2. Na paleta de comandos, selecione a arquitetura de destino na lista de opções. Para este tutorial, estamos
usando uma máquina virtual Ubuntu como o dispositivo IoT Edge, portanto, manteremos o padrão amd64.
Atualizar o módulo com código personalizado
Vamos adicionar algum código adicional para que o módulo processe as mensagens na borda antes de encaminhá-
las ao Hub IoT.
1. No Visual Studio Code, abra módulos > CSharpFunction > CSharpFunction.cs.
2. Substitua o conteúdo do arquivo CSharpFunction.cs pelo código a seguir. Esse código recebe telemetria
sobre o ambiente e a temperatura da máquina e apenas encaminha a mensagem de logon no Hub IoT se a
temperatura da máquina estiver acima do limite definido.
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Devices.Client;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EdgeHub;
using Microsoft.Azure.WebJobs.Host;
namespace Functions.Samples
{
public static class CSharpFunction
{
[FunctionName("CSharpFunction")]
public static async Task FilterMessageAndSendMessage(
[EdgeHubTrigger("input1")] Message messageReceived,
[EdgeHub(OutputName = "output1")] IAsyncCollector<Message> output,
ILogger logger)
{
const int temperatureThreshold = 20;
byte[] messageBytes = messageReceived.GetBytes();
var messageString = System.Text.Encoding.UTF8.GetString(messageBytes);
if (!string.IsNullOrEmpty(messageString))
{
logger.LogInformation("Info: Received one non-empty message");
// Get the body of the message and deserialize it.
var messageBody = JsonConvert.DeserializeObject<MessageBody>(messageString);
if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
{
// Send the message to the output as the temperature value is greater than the
threshold.
using (var filteredMessage = new Message(messageBytes))
{
// Copy the properties of the original message into the new Message object.
foreach (KeyValuePair<string, string> prop in messageReceived.Properties)
{filteredMessage.Properties.Add(prop.Key, prop.Value);}
// Add a new property to the message to indicate it is an alert.
filteredMessage.Properties.Add("MessageType", "Alert");
// Send the message.
await output.AddAsync(filteredMessage);
logger.LogInformation("Info: Received and transferred a message with
temperature above the threshold");
}
}
}
}
}
//Define the expected schema for the body of incoming messages.
class MessageBody
{
public Machine machine {get; set;}
public Ambient ambient {get; set;}
public string timeCreated {get; set;}
}
class Machine
{
public double temperature {get; set;}
public double pressure {get; set;}
}
class Ambient
{
public double temperature {get; set;}
public int humidity {get; set;}
}
}
3. Salve o arquivo.
Criar solução IoT Edge

Na seção anterior, você criou uma solução IoT Edge e adicionou um código a CSharpFunction para filtrar
mensagens em que a temperatura relatada do computador for menor do que o limite aceitável. Agora você precisa
compilar a solução como uma imagem de contêiner e enviá-la por push para seu registro de contêiner.
Nesta seção, forneça as credenciais do seu registro de contêiner pela segunda vez (a primeira foi no arquivo .env
da solução IoT Edge) entrando localmente do seu computador de desenvolvimento para que o Visual Studio Code
possa enviar imagens por push ao registro.
1. Abra o terminal integrado do VS Code selecionando Exibir > Terminal.
2. Entre no seu registro de contêiner, inserindo o seguinte comando no terminal integrado. Use o nome de
usuário e o servidor de logon que você copiou do seu Registro de Contêiner do Azure anteriormente.
docker login -u <ACR username> <ACR login server>
Quando você for solicitado a inserir a senha, cole a senha (ela não ficará visível na janela do terminal) do seu
registro de contêiner e pressione Enter.
Password: <paste in the ACR password and press enter>
Login Succeeded
3. No explorador do VS Code, clique com o botão direito do mouse no arquivo deployment.template.json e

selecione Compilar e enviar por push solução IoT Edge.
Quando você solicitar ao Visual Studio Code para compilar sua solução, primeiro ele usará as informações no
modelo de implantação e gerará um arquivo deployment.json em uma nova pasta chamada config. Em seguida,
ele executará dois comandos no terminal integrado: docker build e docker push . Esses dois comandos compilam
seu código, conteinerizam as funções e enviam o código por push para o registro de contêiner que você especificou
ao inicializar a solução.
Exibir sua imagem de contêiner

O Visual Studio Code gera uma mensagem de êxito quando sua imagem de contêiner é enviada por push para seu
registro de contêiner. Caso deseje confirmar a operação com êxito por conta própria, é possível exibir a imagem no
registro.
1. No portal do Azure, navegue até seu registro de contêiner do Azure.
2. Selecione Repositórios.
3. Você deve ver o repositório csharpfunction na lista. Escolhe este repositório para ver mais detalhes.
4. Na seção Marcas, você deve ver a marca 0.0.1-amd64. Essa marca indica a versão e a plataforma da imagem
que você compilou. Esses valores são definidos no arquivo module.json na pasta CSharpFunction.
Implantar e executar a solução

Você pode usar o portal do Azure para implantar o módulo da função em um dispositivo IoT Edge como foi feito
no guia de início rápido. Você também pode implantar e monitorar os módulos no Visual Studio Code. As seções a
seguir usam as Ferramentas de IoT do Azure para VS Code que estavam listadas nos pré-requisitos. Instale a
extensão agora, caso ainda não tenha feito isso.
1. No explorador do VS Code, expanda a seção Dispositivos do Hub IoT do Azure.
2. Clique com o botão direito no nome do seu dispositivo do IoT Edge e selecione Criar implantação para
um único dispositivo.
3. Navegue até a pasta da solução que contém CSharpFunction. Abra a pasta de configuração, escolha o
arquivo deployment.json e depois Selecionar manifesto de implantação do Edge.
4. Atualize a seção Dispositivos Hub IoT do Azure. Você deve ver o novo CSharpFunction sendo
executado junto com o módulo SimulatedTemperatureSensor e $edgeAgent e $edgeHub. Pode
demorar um pouco para que os novos módulos apareçam. Seu dispositivo IoT Edge tem de recuperar suas
novas informações de implantação do IoT Hub, iniciar novos contêineres e depois retornar o status ao Hub
IoT.
Exibir os dados gerados
Você pode ver todas as mensagens que chegam em seu hub IoT executando Hub IoT do Azure: Iniciar o
Monitoramento do Ponto de Extremidade de Evento Interno na paleta de comandos.
Você também pode filtrar o modo de exibição para ver todas as mensagens que chegam ao seu Hub IoT vindas de
um dispositivo específico. Clique com o botão direito do mouse na seção Dispositivos do Hub IoT do Azure e
selecione Iniciar Monitoramento de Ponto de Extremidade Interno.
Para interromper o monitoramento de mensagens, execute o comando Hub IoT do Azure: Parar o
Monitoramento do Ponto de Extremidade de Evento Interno na paleta de comandos.
Limpar recursos
Se você pretende continuar no próximo artigo recomendado, pode manter os recursos e as configurações já
criados e reutilizá-los. Você também pode continuar usando o mesmo dispositivo IoT Edge como um dispositivo
de teste.
Caso contrário, você pode excluir as configurações locais e os recursos do Azure criados neste artigo para evitar
encargos.
Excluir recursos do Azure
A exclusão de recursos do Azure e dos grupos de recursos é irreversível. Não exclua acidentalmente grupo de
recursos ou recursos incorretos. Caso tenha criado o hub IoT dentro de um grupo de recursos existente com
recursos que você deseja manter, exclua o próprio recurso hub IoT em vez de excluir o grupo de recursos.
Para excluir os recursos:
1. Entre no portal do Azure e selecione Grupos de recursos.
2. Selecione o nome do grupo de recursos que contém os recursos de teste do IoT Edge.
3. Reveja a lista de recursos contidos no grupo de recursos. Se você deseja excluir todos eles, selecione Excluir
grupo de recursos. Se você quiser excluir apenas alguns deles, clique em cada recurso para excluí-los
individualmente.
Próximas etapas
Neste tutorial, você criou um módulo de função do Azure com o código para filtrar os dados brutos gerados pelo
seu dispositivo IoT Edge. Quando estiver pronto para criar seus próprios módulos, você poderá saber mais sobre
como Desenvolver com o Azure IoT Edge para Visual Studio Code.
Siga para os próximos tutoriais para conhecer outras formas pelas quais o Azure IoT Edge pode ajudá-lo a
transformar dados em informações de negócios na borda.
Localizar médias usando uma janela flutuante no Azure Stream Analytics
Exemplos de CLI do Azure
A tabela a seguir inclui links para scripts bash criados para Azure Functions que usam a CLI do Azure.
CRIAR APLICATIVO DESCRIÇÃO
Criar um Aplicativo de funções para execução sem servidor Cria um aplicativo de funções em um plano de consumo.
Criar um Aplicativo de funções em um Plano do Serviço de Crie um aplicativo de funções em um Plano do Serviço de
Aplicativo Aplicativo dedicado.
INTEGRAÇÃO DESCRIÇÃO
Criar um aplicativo de funções e conectá-lo a uma conta de Crie um aplicativo de funções e conecte-o a uma conta de
armazenamento armazenamento.
Criar um aplicativo de funções e conectá-lo a um Banco de Criar um aplicativo de funções e conectá-lo a um Azure
Dados Cosmo do Azure Cosmos DB.
IMPLANTAÇÃO CONTÍNUA DESCRIÇÃO
Implantar do GitHub Crie um aplicativo de função que implanta de um repositório

do GitHub.
Implantar do Azure DevOps Crie um aplicativo de função que implanta de um repositório

do Azure DevOps.
CONFIGURAR APLICATIVO DESCRIÇÃO
Mapear um domínio personalizado para um aplicativo de Defina um domínio personalizado para suas funções.
funções
Associar um certificado SSL em um Aplicativo de funções Carregue certificados SSL para funções em um domínio
personalizado.
Visão geral das versões do Azure Functions
Runtime
As versões principais do tempo de execução do Azure Functions estão relacionadas à versão do .NET na qual
o tempo de execução se baseia. A tabela a seguir indica a versão atual do tempo de execução, o nível de
versão e a versão do .NET relacionada.
VERSÃO DE RUNTIME NÍVEL DE LIBERAÇÃO1 VERSÃO DO .NET
3.x versão prévia .NET Core 3. x
2. x GA .NET Core 2,2
1.x GA2 .NET Framework 4,63
1 As versões de GA têm suporte para cenários de produção.

2A versão 1. x está no modo de manutenção. Os aprimoramentos são fornecidos somente em versões
posteriores.
3 O só dá suporte ao desenvolvimento no portal do Azure ou localmente em computadores com Windows.
NOTE
A versão 3. x do tempo de execução do Functions está em versão prévia e não tem suporte para ambientes de
produção. Para obter mais informações sobre como experimentar a versão 3. x, consulte este comunicado.
Este artigo detalha algumas das diferenças entre as várias versões, como você pode criar cada versão e como
alterar versões.
Linguagens
A partir da versão 2. x, o tempo de execução usa um modelo de extensibilidade de linguagem e todas as
funções em um aplicativo de funções devem compartilhar o mesmo idioma. O idioma das funções em um
aplicativo de funções é escolhido ao criar o aplicativo e é mantido na configuração _WORKER _RUNTIME do
Functions .
As linguagens experimentais Azure Functions 1. x não podem usar o novo modelo, portanto, não há suporte
no 2. x. A tabela a seguir indica quais linguagens de programação têm suporte no momento em cada versão
de tempo de execução.
IDIOMA 1.X 2. X 3. X 1
C# GA (.NET Framework 4.7) GA (.NET Core 2,2) Visualização (.NET Core 3.

x)
JavaScript GA (Nó 6) GA (Nó 8 e 10) Visualização (nó 8 & 10)
F# GA (.NET Framework 4.7) GA (.NET Core 2,2) Visualização (.NET Core 3.

x)
IDIOMA 1.X 2. X 3. X
Java N/D GA (Java 8) Versão prévia (Java 8)
PowerShell Experimental GA (PowerShell Core 6) Visualização (PowerShell

Core 6)
Python Experimental GA (Python 3.7. x) Visualização (Python 3.7. x)
TypeScript Experimental GA2 Visualização2
Bash Experimental N/D N/D
Lote (.cmd, .bat) Experimental N/D N/D
PHP Experimental N/D N/D
1O tempo de execução das funções v3. x está em visualização.

2 Com suporte por meio de transpiling para JavaScript.
Para obter informações sobre alterações planejadas para o suporte de linguagem, consulte o roteiro do
Azure.
Para obter mais informações, consulte idiomas com suporte.
Executar em uma versão específica

Por padrão, os aplicativos de funções criados no portal do Azure e pelo CLI do Azure são definidos como a
versão 2. x. Quando possível, você deve usar essa versão de tempo de execução. Se precisar, você ainda
poderá executar um aplicativo de funções no tempo de execução da versão 1. x. Você só pode alterar a versão
de tempo de execução depois de criar seu aplicativo de funções, mas antes de adicionar qualquer função.
Para saber como fixar a versão de tempo de execução para 1. x, consulte Exibir e atualizar a versão de tempo
de execução atual.
Você também pode atualizar para a versão 3. x do tempo de execução, que está em visualização. Faça isso se
você precisar ser capaz de executar suas funções no .NET Core 3. x. Para saber como atualizar para o 3. x,
consulte Exibir e atualizar a versão de tempo de execução atual.
Migrando do 1. x para versões posteriores

Você pode optar por migrar um aplicativo existente gravado para usar o tempo de execução da versão 1. x
para, em vez disso, usar a versão 2. x. A maioria das alterações que você precisa fazer está relacionada a
alterações no tempo de execução de linguagem, C# como alterações de API entre o .NET Framework 4,7 e o
.NET Core 2. Você também precisará certificar-se de que seu código e suas bibliotecas são compatíveis com o
Language Runtime escolhido. Por fim, lembre-se de anotar as alterações em gatilho, associações e recursos
realçados abaixo. Para obter os melhores resultados de migração, você deve criar um novo aplicativo de
funções para a versão 2. x e portar seu código de função existente da versão 1. x para o novo aplicativo.
Alterações em gatilhos e associações
A versão 2. x exige que você instale as extensões para gatilhos e associações específicas usados pelas funções
em seu aplicativo. A única exceção para esses gatilhos HTTP e Timer, que não exigem uma extensão. Para
obter mais informações, consulte registrar e instalar extensões de associação.
Também há algumas alterações no function.json ou atributos da função entre as versões. Por exemplo, a
propriedade path do hub de eventos agora é eventHubName . Consulte a tabela de associação existente para
obter links para a documentação de cada associação.
Alterações nos recursos e funcionalidades
Alguns recursos que também foram removidos, atualizados ou substituídos na nova versão. Esta seção
detalha as alterações que você vê na versão 2. x após ter usado a versão 1. x.
Na versão 2. x, as seguintes alterações foram feitas:
As chaves para chamar pontos de extremidade HTTP são sempre armazenadas criptografadas no
armazenamento de BLOBs do Azure. Na versão 1. x, as chaves armazenadas no armazenamento de
arquivos do Azure são padrão. Ao atualizar um aplicativo da versão 1. x para a versão 2. x, os segredos
existentes que estão no armazenamento de arquivos são redefinidos.
O tempo de execução da versão 2. x não inclui suporte interno para provedores de webhook. Essa
alteração foi feita para melhorar o desempenho. Você ainda pode usar gatilhos HTTP como pontos de
extremidade para WebHooks.
O arquivo de configuração do host (host. JSON ) deve estar vazio ou ter a cadeia de caracteres
"version": "2.0" .
Para melhorar o monitoramento, o painel trabalhos Web no portal, que usou a configuração
AzureWebJobsDashboard , é substituído por aplicativo Azure insights, que usa a configuração
APPINSIGHTS_INSTRUMENTATIONKEY . Para obter mais informações, consulte monitorar Azure Functions.
Todas as funções em um aplicativo de funções devem compartilhar o mesmo idioma. Ao criar um

aplicativo de funções, você deve escolher uma pilha de tempo de execução para o aplicativo. A pilha de
tempo de execução é especificada pelo valor FUNCTIONS_WORKER_RUNTIME nas configurações do
aplicativo. Esse requisito foi adicionado para melhorar a superfície e o tempo de inicialização. Ao
desenvolver localmente, você também deve incluir essa configuração no arquivo local. Settings. JSON.
O tempo limite padrão para funções em um plano do serviço de aplicativo é alterado para 30 minutos.
Você pode alterar manualmente o tempo limite de volta para ilimitado usando a configuração
functionTimeout em host. JSON.
As restrições de simultaneidade HTTP são implementadas por padrão para funções de plano de
consumo, com um padrão de 100 solicitações simultâneas por instância. Você pode alterar isso na
configuração de maxConcurrentRequests no arquivo host. JSON.
Devido a limitações do .NET Core, o F# suporte para funções de script (. fsx) foi removido. As F#
funções compiladas (. FS ) ainda têm suporte.
O formato da URL dos WebHooks do gatilho da grade de eventos foi alterado para
https://{app}/runtime/webhooks/{triggerName} .
Migrando um aplicativo desenvolvido localmente

Você pode ter projetos de aplicativo de funções existentes que você desenvolveu localmente usando o tempo
de execução da versão 1. x. Para atualizar para a versão 2. x, você deve criar um projeto de aplicativo de
função local com a versão 2. x e portar seu código existente para o novo aplicativo. Você pode atualizar
manualmente o projeto e o código existentes, um tipo de atualização "in-loco". No entanto, há uma série de
outros aprimoramentos entre a versão 1. x e a versão 2. x que talvez você ainda precise fazer. Por exemplo, no
C# objeto de depuração foi alterado de TraceWriter para ILogger . Ao criar um novo projeto de versão 2. x,
você começa com as funções atualizadas com base nos modelos da versão 2. x mais recentes.
Versões de runtime do Visual Studio
No Visual Studio, você seleciona a versão de tempo de execução ao criar um projeto. O Azure Functions
Tools para Visual Studio dá suporte às principais versões de tempo de execução. A versão correta é usada ao
depurar e publicar com base nas configurações do projeto. As configurações de versão são definidas no
arquivo de .csproj nas seguintes propriedades:
Ve r sã o 1 . x
<TargetFramework>net461</TargetFramework>
<AzureFunctionsVersion>v1</AzureFunctionsVersion>
Ve r sã o 2 . x
<TargetFramework>netcoreapp2.2</TargetFramework>
Quando você depura ou publica seu projeto, a versão correta do runtime é usada.
VS Code e Azure Functions Core Tools
Azure Functions Core Tools é usado para o desenvolvimento de linha de comando e também pela extensão
de Azure Functions para Visual Studio Code. Para desenvolver na versão 2. x, instale a versão 2. x das
principais ferramentas. O desenvolvimento da versão 1. x requer a versão 1. x das principais ferramentas.
Para obter mais informações, consulte instalar o Azure Functions Core Tools.
Para o desenvolvimento de Visual Studio Code, talvez você também precise atualizar a configuração de
usuário do azureFunctions.projectRuntime para corresponder à versão das ferramentas instaladas. Essa
configuração também atualiza os modelos e os idiomas usados durante a criação do aplicativo de funções.
Alterando a versão dos aplicativos no Azure
A versão do tempo de execução do Functions usada por aplicativos publicados no Azure é ditada pela
configuração do aplicativo FUNCTIONS_EXTENSION_VERSION . Um valor de ~2 tem como alvo o tempo de
execução da versão 2. x e ~1 tem como alvo o tempo de execução da versão 1. x. Não altere arbitrariamente
essa configuração, pois é provável que outras alterações de configuração de aplicativo e alterações de código
em suas funções sejam necessárias. Para saber mais sobre a maneira recomendada de migrar seu aplicativo
de funções para uma versão de tempo de execução diferente, consulte como direcionar Azure Functions
versões de tempo de execução.
Associações
A partir da versão 2. x, o tempo de execução usa um novo modelo de extensibilidade de associação que
oferece essas vantagens:
Suporte para extensões de associação de terceiros.
Desacoplamento de runtime e associações. Essa alteração permite que as extensões de ligação tenham
controle de versão e sejam liberadas de forma independente. Você pode, por exemplo, optar por
atualizar para uma versão de uma extensão que dependa de uma versão mais recente de um SDK
subjacente.
Um ambiente de execução mais leve, em que apenas as associações em uso são conhecidas e
carregadas pelo tempo de execução.
Com exceção dos gatilhos HTTP e Timer, todas as associações devem ser adicionadas explicitamente ao
projeto de aplicativo de funções ou registradas no Portal. Para obter mais informações, consulte registrar
extensões de associação.
A tabela a seguir mostra quais associações têm suporte em cada versão de tempo de execução.
Esta tabela mostra as associações com suporte nas duas versões principais do tempo de execução de Azure
Functions:
TIPO 1.X 2. X 1 OF ENTRADA SAÍDA
Armazenamento ✔ ✔ ✔ ✔ ✔
de Blobs
BD Cosmos ✔ ✔ ✔ ✔ ✔
Grade de ✔ ✔ ✔
eventos
Hubs de ✔ ✔ ✔ ✔
Eventos
WebHooks de & ✔ ✔ ✔ ✔
de HTTP
Hub IoT ✔ ✔ ✔ ✔
Microsoft Graph ✔ ✔ ✔
Excel tabelas
Arquivos de ✔ ✔ ✔
OneDrive
Microsoft Graph
Microsoft Graph ✔ ✔
Outlook email
Microsoft Graph ✔ ✔ ✔ ✔
events
Tokens de ✔ ✔
Auth Microsoft
Graph
Aplicativos ✔ ✔ ✔
Móveis
Hubs de ✔ ✔
Notificação
Armazenamento ✔ ✔ ✔ ✔
de filas
SendGrid ✔ ✔ ✔
Barramento de ✔ ✔ ✔ ✔
Serviço
SignalR ✔ ✔ ✔
de tabelas
Timer ✔ ✔ ✔
TIPO 1.X 2. X OF ENTRADA SAÍDA
Twilio ✔ ✔ ✔
1 no tempo de execução da versão 2. x, todas as associações, exceto http e Timer, devemser registradas.
Consulte registrar extensões de associação. Todas as associações 2. x com suporte também têm suporte na
versão 3. x, salvo indicação em contrário.

A duração do tempo limite de um aplicativo de funções é definida pela propriedade functionTimeout no
arquivo de projeto host. JSON . A tabela a seguir mostra os valores padrão e máximo em minutos para
ambos os planos e em ambas as versões de tempo de execução:
VERSÃO DE TEMPO DE
Consumo 1.x 5 10
Consumo 2. x 5 10
NOTE
Independentemente da configuração do tempo limite do aplicativo de funções, 230 segundos é a quantidade máxima
de tempo que uma função disparada por HTTP pode levar para responder a uma solicitação. Isso ocorre devido ao
tempo limite de ociosidade padrão de Azure Load Balancer. Para tempos de processamento mais longos, considere
usar o padrão assíncrono Durable Functions ou adiar o trabalho real e retornar uma resposta imediata.
Próximos passos
Para obter mais informações, consulte os seguintes recursos:
Codificar e testar Azure Functions localmente
Como direcionar Azure Functions versões de tempo de execução
Notas de versão
Plano Premium do Azure Functions
O plano Premium Azure Functions é uma opção de hospedagem para aplicativos de funções. O plano Premium
fornece recursos como conectividade VNet, sem início frio e hardware Premium. Vários aplicativos de funções
podem ser implantados no mesmo plano Premium e o plano permite que você configure o tamanho da instância
de computação, o tamanho do plano base e o tamanho máximo do plano. Para obter uma comparação do plano
Premium e outros tipos de plano e hospedagem, consulte Opções de escala e Hospedagem de função.

1. Abrir o portal do Azure de https://portal.azure.com
2. Selecione o botão criar um recurso
3. Selecione > de computação aplicativo de funções.


Grupo de Recursos myResourceGroup Nome do novo grupo de recursos

no qual criar o seu aplicativo de
funções.
Nome do Aplicativo de funções Nome globalmente exclusivo Nome que identifica seu novo
- .
Publicar Codificar Opção para publicar arquivos de

Pilha de tempo de execução Linguagem preferencial Escolha um runtime compatível com

funções C# e F#.
Região Região preferida Escolha uma região perto de você

ou perto de outros serviços que
suas funções acessam.
Selecione o botão Avançar: hospedagem > .

5. Insira as seguintes configurações de hospedagem.

existente, que deve atender aos
armazenamento.
Sistema operacional Sistema operacional preferencial Um sistema operacional é

previamente selecionado para você
com base em sua seleção de pilha de
tempo de execução, mas você pode
alterar a configuração, se necessário.
Intenção Premium Para tipo de plano, selecione

Premium (visualização) e selecione
padrões para as seleções de plano e
SKU e tamanho do Windows .
Selecione o botão Avançar: monitoramento > .

6. Insira as configurações de monitoramento a seguir.

Selecione examinar + criar para revisar as seleções de configuração de aplicativo.

Você também pode criar um plano Premium usando AZ functionapp Plan Create na CLI do Azure. O exemplo a
seguir cria um plano de camada Premium 1 elástico :
az functionapp plan create --resource-group <RESOURCE_GROUP> --name <PLAN_NAME> \

--location <REGION> --sku EP1
Neste exemplo, substitua <RESOURCE_GROUP> pelo seu grupo de recursos e <PLAN_NAME> com um nome para seu
plano que seja exclusivo no grupo de recursos. Especifique um <REGION> com suporte . Para criar um plano
Premium que ofereça suporte ao Linux, inclua a opção --is-linux .
Com o plano criado, você pode usar AZ functionapp Create para criar seu aplicativo de funções. No portal, o
plano e o aplicativo são criados ao mesmo tempo.
Recursos
Os recursos a seguir estão disponíveis para aplicativos de funções implantados em um plano Premium.
Instâncias pré -passivas
Se nenhum evento e execução ocorrer hoje no plano de consumo, seu aplicativo poderá reduzir verticalmente até
zero instâncias. Quando novos eventos chegam, uma nova instância precisa ser especializada em seu aplicativo
em execução. A especialização de novas instâncias pode levar algum tempo, dependendo do aplicativo. Essa
latência adicional na primeira chamada geralmente é chamada de inicialização a frio do aplicativo.
No plano Premium, você pode fazer com que seu aplicativo fique quente em um número especificado de
instâncias, até o tamanho mínimo do plano. As instâncias pré-configuradas também permitem que você
dimensione previamente um aplicativo antes da alta carga. À medida que o aplicativo é dimensionado, ele é
dimensionado primeiro para as instâncias pré-configuradas. As instâncias adicionais continuam a ficar em buffer
e ficam quentes imediatamente em preparação para a próxima operação de escala. Tendo um buffer de instâncias
pré-configuradas, você pode evitar latências de início frio. As instâncias pré-configuradas são um recurso do
plano Premium, e você precisa manter pelo menos uma instância em execução e disponível sempre que o plano
estiver ativo.
Você pode configurar o número de instâncias pré-configuradas no portal do Azure selecionando sua aplicativo
de funções, acessando a guia recursos da plataforma e selecionando as opções de scale out . Na janela Editar
do aplicativo de funções, as instâncias pré-configuradas são específicas para esse aplicativo, mas as instâncias
mínima e máxima se aplicam ao seu plano inteiro.
Você também pode configurar instâncias pré-configuradas para um aplicativo com o CLI do Azure
az resource update -g <resource_group> -n <function_app_name>/config/web --set

properties.preWarmedInstanceCount=<desired_prewarmed_count> --resource-type Microsoft.Web/sites
Conectividade de rede privada

Azure Functions implantadas em um plano Premium aproveita a nova integração de VNet para aplicativos Web.
Quando configurado, seu aplicativo pode se comunicar com recursos em sua VNet ou protegidos por meio de
pontos de extremidade de serviço. As restrições de IP também estão disponíveis no aplicativo para restringir o
tráfego de entrada.
Ao atribuir uma sub-rede ao seu aplicativo de funções em um plano Premium, você precisa de uma sub-rede
com endereços IP suficientes para cada instância em potencial. Exigimos um bloco de IP com pelo menos 100
endereços disponíveis.
Para obter mais informações, consulte integrar seu aplicativo de funções a uma VNet.
Escala elástica rápida
Instâncias de computação adicionais são adicionadas automaticamente para seu aplicativo usando a mesma
lógica de dimensionamento rápido que o plano de consumo. Para saber mais sobre como o dimensionamento
funciona, consulte escala de funções e hospedagem.
Duração da execução não associada
Azure Functions em um plano de consumo são limitados a 10 minutos para uma única execução. No plano
Premium, o padrão de duração da execução é de 30 minutos para evitar execuções de fuga. No entanto, você
pode Modificar a configuração de host. JSON para torná-la desassociada para aplicativos de plano Premium.
Configurações de plano e SKU

Ao criar o plano, você define duas configurações: o número mínimo de instâncias (ou o tamanho do plano) e o
limite máximo de intermitência. As instâncias mínimas são reservadas e sempre em execução.
IMPORTANT
Você é cobrado por cada instância alocada na contagem mínima de instâncias, independentemente de as funções serem
executadas ou não.
Se seu aplicativo exigir instâncias além do tamanho do plano, ele poderá continuar a escalar horizontalmente até
que o número de instâncias atinja o limite máximo de intermitência. Você será cobrado por instâncias além do
tamanho do plano somente enquanto eles estiverem em execução e alugados para você. Faremos um melhor
esforço em dimensionar seu aplicativo para o limite máximo definido, enquanto que as instâncias de plano
mínimas são garantidas para seu aplicativo.
Você pode configurar o tamanho do plano e os máximos no portal do Azure selecionando as opções de scale
out no plano ou um aplicativo de funções implantado nesse plano (em recursos da plataforma).
Você também pode aumentar o limite máximo de intermitência do CLI do Azure:
az resource update -g <resource_group> -n <premium_plan_name> --set properties.maximumElasticWorkerCount=

<desired_max_burst> --resource-type Microsoft.Web/serverfarms
SKUs da instância disponível

Ao criar ou dimensionar seu plano, você pode escolher entre três tamanhos de instância. Você será cobrado pelo
número total de núcleos e memória consumida por segundo. Seu aplicativo pode ser dimensionado
automaticamente para várias instâncias, conforme necessário.
SKU NÚCLEOS MEMÓRIA ARMAZENAMENTO
EP1 1 3,5 GB 250 GB
EP2 2 7 GB 250 GB
EP3 4 14 GB 250 GB
Regiões
Abaixo estão as regiões com suporte no momento para cada sistema operacional.
REGIÃO WINDOWS LINUX
Austrália Central ✔1
REGIÃO WINDOWS LINUX
Austrália Central 2 ✔1
Leste da Austrália ✔
Sudeste da Austrália ✔ ✔
Sul do Brasil ✔2
Canadá Central ✔
Centro dos EUA ✔
Ásia Oriental ✔
Leste dos EUA ✔ ✔
Leste dos EUA 2 ✔
França Central ✔
Leste do Japão ✔ ✔
Oeste do Japão ✔
Coreia Central ✔
Centro-Norte dos EUA ✔
Norte da Europa ✔ ✔
Centro-Sul dos Estados Unidos ✔
Sul da Índia ✔
Sudeste Asiático ✔ ✔
Sul do Reino Unido ✔
Oeste do Reino Unido ✔
Europa Ocidental ✔ ✔
Índia Ocidental ✔
Oeste dos EUA ✔ ✔
Oeste dos EUA 2 ✔
1 Redução máxima limitada a 20 instâncias.

2 Expansão máxima limitada a 60 instâncias.
Próximas etapas
Entender Azure Functions escala e opções de hospedagem
Tecnologias de implantação no Azure Functions
Você pode usar algumas tecnologias diferentes para implantar o código do projeto Azure Functions no Azure. Este artigo fornece uma lista completa dessas
tecnologias, descreve quais tecnologias estão disponíveis para quais tipos de funções, explica o que acontece quando você usa cada método e fornece
recomendações para o melhor método a ser usado em vários cenários . As várias ferramentas que dão suporte à implantação em Azure Functions são ajustadas
para a tecnologia certa com base em seu contexto. Em geral, a implantação de zip é a tecnologia de implantação recomendada para Azure Functions.
Disponibilidade de tecnologia de implantação

O Azure Functions dá suporte ao desenvolvimento local de plataforma cruzada e à hospedagem no Windows e no Linux. Atualmente, três planos de hospedagem
estão disponíveis:
Utilização
Premium
Dedicado (serviço de aplicativo)
Cada plano tem comportamentos diferentes. Nem todas as tecnologias de implantação estão disponíveis para cada tipo de Azure Functions. O gráfico a seguir
mostra quais tecnologias de implantação têm suporte para cada combinação de sistema operacional e plano de hospedagem:
TECNOLOGIA DE CONSUMO DO
IMPLANTAÇÃO WINDOWS WINDOWS PREMIUM WINDOWS DEDICADO CONSUMO DO LINUX LINUX PREMIUM LINUX DEDICADO
URL do pacote ✔ ✔ ✔ ✔ ✔ ✔
externo1
Implantação de zip ✔ ✔ ✔ ✔ ✔ ✔
Contêiner do Docker ✔ ✔
Implantação da Web ✔ ✔ ✔
Controle do código- ✔ ✔ ✔ ✔ ✔
fonte
Git local1 ✔ ✔ ✔ ✔ ✔
Sincronização de ✔ ✔ ✔ ✔ ✔
nuvem1
FTP1 ✔ ✔ ✔ ✔ ✔
Edição do portal ✔ ✔ ✔ ✔2 ✔2
1 tecnologia de implantação que requer sincronização de gatilho manual.

2 a edição do portal é habilitada apenas para gatilhos http e de temporizador para funções no Linux usando planos Premium e dedicados.
Principais conceitos
Alguns conceitos importantes são essenciais para entender como as implantações funcionam em Azure Functions.
Disparar sincronização
Quando você altera qualquer um de seus gatilhos, a infraestrutura do Functions deve estar ciente das alterações. A sincronização ocorre automaticamente para
muitas tecnologias de implantação. No entanto, em alguns casos, você deve sincronizar manualmente seus gatilhos. Ao implantar suas atualizações referenciando
uma URL de pacote externo, git local, sincronização de nuvem ou FTP, você deve sincronizar manualmente seus gatilhos. Você pode sincronizar gatilhos de uma
destas três maneiras:
Reinicie seu aplicativo de funções no portal do Azure
Envie uma solicitação HTTP POST para https://{functionappname}.azurewebsites.net/admin/host/synctriggers?code=<API_KEY> usando a chave mestra.
Enviar uma solicitação HTTP POST para
https://management.azure.com/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP_NAME>/providers/Microsoft.Web/sites/<FUNCTION_APP_NAME>/syncfunctiontriggers?
api-version=2016-08-01
. Substitua os espaços reservados por sua ID de assinatura, nome do grupo de recursos e o nome do seu aplicativo de funções.
Build remoto
Azure Functions pode executar compilações automaticamente no código que recebe após implantações de zip. Essas compilações se comportam um pouco
diferente dependendo se seu aplicativo está em execução no Windows ou no Linux. As compilações remotas não são executadas quando um aplicativo tiver sido
previamente definido para execução em execução no modo de pacote . Para saber como usar a compilação remota, navegue até a implantação de zip.
NOTE
Se você estiver tendo problemas com a compilação remota, pode ser porque seu aplicativo foi criado antes de o recurso ser disponibilizado (1º de agosto de 2019). Tente criar um
novo aplicativo de funções ou execute az functionapp update -g <RESOURCE_GROUP_NAME> -n <APP_NAME> para atualizar seu aplicativo de funções. Esse comando pode levar
duas tentativas de sucesso.
Build remoto no Windows

Todos os aplicativos de funções em execução no Windows têm um pequeno aplicativo de gerenciamento, o site do SCM (ou kudu). Esse site manipula grande
parte da implantação e da lógica de compilação para Azure Functions.
Quando um aplicativo é implantado no Windows, comandos específicos de idioma, comoC# dotnet restore () ou npm install (JavaScript), são executados.
Build remoto no Linux
Para habilitar a compilação remota no Linux, as seguintes configurações de aplicativo devem ser definidas:
ENABLE_ORYX_BUILD=true
SCM_DO_BUILD_DURING_DEPLOYMENT=true
Por padrão, Azure Functions Core Tools e a extensão Azure Functions para Visual Studio Code executar compilações remotas ao implantar no Linux. Por isso,
ambas as ferramentas criam automaticamente essas configurações para você no Azure.
Quando os aplicativos são criados remotamente no Linux, eles são executados a partir do pacote de implantação.
P l a n o d e c o n su m o
Os aplicativos de funções do Linux em execução no plano de consumo não têm um site SCM/kudu, que limita as opções de implantação. No entanto, os
aplicativos de funções no Linux em execução no plano de consumo oferecem suporte a compilações remotas.
Pl an o s dedi c ado e Pr em i u m
Os aplicativos de funções em execução no Linux no plano dedicado (serviço de aplicativo) e no plano Premium também têm um site do SCM/kudu limitado.
Detalhes da tecnologia de implantação

Os métodos de implantação a seguir estão disponíveis no Azure Functions.
URL do pacote externo
Você pode usar uma URL de pacote externo para fazer referência a um arquivo de pacote remoto (. zip) que contém seu aplicativo de funções. O arquivo é baixado
da URL fornecida e o aplicativo é executado em execução no modo de pacote .
Como usá-lo: Adicione WEBSITE_RUN_FROM_PACKAGE às configurações do aplicativo. O valor dessa configuração deve ser uma URL (o local do arquivo de pacote
específico que você deseja executar). Você pode adicionar configurações no portal ou usando o CLI do Azure.
Se você usar o armazenamento de BLOBs do Azure, use um contêiner privado com uma assinatura de acesso compartilhado (SAS) para dar acesso às funções
ao pacote. Sempre que o aplicativo for reiniciado, ele buscará uma cópia do conteúdo. Sua referência deve ser válida durante o tempo de vida do aplicativo.
Quando usá-lo: A URL do pacote externo é o único método de implantação com suporte para Azure Functions em execução no Linux no plano de consumo,
se o usuário não quiser que uma compilação remota ocorra. Ao atualizar o arquivo de pacote que um aplicativo de funções referencia, você deve sincronizar os
gatilhos manualmente para informar ao Azure que seu aplicativo foi alterado.
Implantação de zip
Use a implantação de zip para enviar por push um arquivo. zip que contém seu aplicativo de funções para o Azure. Opcionalmente, você pode definir seu
aplicativo para iniciar a execução a partir do pacoteou especificar que ocorra uma compilação remota .
Como usá-lo: Implante usando sua ferramenta de cliente favorita: Visual Studio Code, Visual Studio, o Azure Functions Core Toolsou o CLI do Azure. Por
padrão, essas ferramentas usam a implantação zip e são executadas a partir do pacote. As ferramentas principais e a extensão Visual Studio Code habilitam a
compilação remota ao implantar no Linux. Para implantar manualmente um arquivo. zip em seu aplicativo de funções, siga as instruções em implantar de um
arquivo. zip ou de uma URL.
Ao implantar usando a implantação de zip, você pode definir seu aplicativo para ser executado do pacote. Para executar a partir do pacote, defina o valor de
configuração WEBSITE_RUN_FROM_PACKAGE aplicativo como 1 . Recomendamos a implantação de zip. Ele produz tempos de carregamento mais rápidos para seus
aplicativos e é o padrão para VS Code, o Visual Studio e o CLI do Azure.
Quando usá-lo: A implantação de zip é a tecnologia de implantação recomendada para Azure Functions.
Contêiner do Docker
Você pode implantar uma imagem de contêiner do Linux que contém seu aplicativo de funções.
Como usá-lo: Crie um aplicativo de funções do Linux no plano Premium ou dedicado e especifique a imagem de contêiner a ser executada. É possível fazer
isso de duas formas:
Crie um aplicativo de funções do Linux em um plano de serviço Azure App no portal do Azure. Para publicar, selecione imagem do Dockere configure o
contêiner. Insira o local onde a imagem está hospedada.
Crie um aplicativo de funções do Linux em um plano do serviço de aplicativo usando o CLI do Azure. Para saber como, consulte criar uma função no Linux
usando uma imagem personalizada.
Para implantar em um aplicativo existente usando um contêiner personalizado, em Azure Functions Core Tools, use o comando func deploy .
Quando usá-lo: Use a opção de contêiner do Docker quando precisar de mais controle sobre o ambiente do Linux em que seu aplicativo de funções é
executado. Esse mecanismo de implantação está disponível somente para funções em execução no Linux.
Implantação da Web (MSDeploy)

Implantação da Web pacotes e implanta seus aplicativos do Windows em qualquer servidor IIS, incluindo seus aplicativos de função em execução no Windows no
Azure.
Como usá-lo: Use as Ferramentas do Visual Studio para Azure Functions. Desmarque a caixa de seleção Executar do arquivo de pacote (recomendado)
.
Você também pode baixar Implantação da Web 3,6 e chamar MSDeploy.exe diretamente.
Quando usá-lo: Implantação da Web tem suporte e não tem problemas, mas o mecanismo preferencial é a implantação de zip com a execução do pacote
habilitado. Para saber mais, consulte o Guia de desenvolvimento do Visual Studio.
Controle do código-fonte
Use o controle do código-fonte para conectar seu aplicativo de funções a um repositório git. Uma atualização de código nesse repositório dispara a implantação.
Para obter mais informações, consulte o wiki do kudu.
Como usá-lo: Use a central de implantação na área funções do portal para configurar a publicação do controle do código-fonte. Para saber mais, confira
Implantação contínua do Azure Functions.
Quando usá-lo: Usar o controle do código-fonte é a melhor prática para as equipes que colaboram com seus aplicativos de funções. O controle do código-
fonte é uma boa opção de implantação que permite pipelines de implantação mais sofisticados.
Git local
Você pode usar o Git local para enviar código por push do computador local para Azure Functions usando o git.
Como usá-lo: Siga as instruções em implantação do git local para Azure app serviço.
Quando usá-lo: Em geral, recomendamos que você use um método de implantação diferente. Ao publicar do git local, você deve sincronizar os gatilhos
manualmente.
Sincronização de nuvem
Use a sincronização de nuvem para sincronizar seu conteúdo do Dropbox e do OneDrive para Azure Functions.
Como usá-lo: Siga as instruções em sincronizar conteúdo de uma pasta de nuvem.
Quando usá-lo: Em geral, recomendamos outros métodos de implantação. Ao publicar usando a sincronização de nuvem, você deve sincronizar os gatilhos
manualmente.
FTP
Você pode usar o FTP para transferir arquivos diretamente para o Azure Functions.
Como usá-lo: Siga as instruções em implantar conteúdo usando FTP/s.
Quando usá-lo: Em geral, recomendamos outros métodos de implantação. Ao publicar usando FTP, você deve sincronizar os gatilhos manualmente.
Edição do portal
No editor baseado em portal, você pode editar diretamente os arquivos que estão em seu aplicativo de funções (essencialmente implantando sempre que você
salvar suas alterações).
Como usá-lo: Para poder editar suas funções no portal do Azure, você deve ter criado suas funções no portal. Para preservar uma única fonte de verdade,
usar qualquer outro método de implantação torna sua função somente leitura e impede a edição continuada do Portal. Para retornar a um estado no qual você
pode editar os arquivos na portal do Azure, você pode ativar manualmente o modo de edição para Read/Write e remover quaisquer configurações de
aplicativo relacionadas à implantação (como WEBSITE_RUN_FROM_PACKAGE ).
Quando usá-lo: O portal é uma boa maneira de começar a usar o Azure Functions. Para um trabalho de desenvolvimento mais intenso, recomendamos que
você use uma das seguintes ferramentas de cliente:
Visual Studio Code
Azure Functions Core Tools (linha de comando)
Visual Studio
A tabela a seguir mostra os sistemas operacionais e idiomas que dão suporte à edição do portal:
CONSUMO DO
WINDOWS WINDOWS PREMIUM WINDOWS DEDICADO CONSUMO DO LINUX LINUX PREMIUM LINUX DEDICADO
C#
Script do C# ✔ ✔ ✔ ✔* ✔*
CONSUMO DO
WINDOWS WINDOWS PREMIUM WINDOWS DEDICADO CONSUMO DO LINUX LINUX PREMIUM LINUX DEDICADO
F#
Java
JavaScript (Node.js) ✔ ✔ ✔ ✔* ✔*
Python (versão
prévia)
PowerShell ✔ ✔ ✔
(visualização)
TypeScript (Node. js)
* A edição do portal é habilitada apenas para gatilhos HTTP e de temporizador para funções no Linux usando planos Premium e dedicados.
Slots de implantação
Ao implantar seu aplicativo de funções no Azure, você pode implantar em um slot de implantação separado em vez de diretamente na produção. Para obter mais
informações sobre slots de implantação, consulte a documentação dos Slots de implantação do Azure Functions para obter detalhes.
Próximas etapas
Leia estes artigos para saber mais sobre como implantar seus aplicativos de funções:
Implantação contínua para Azure Functions
Entrega contínua usando o Azure DevOps
Implantações zip para Azure Functions
Executar o Azure Functions de um arquivo de pacote
Automatizar a implantação de recursos para seu aplicativo de funções no Azure Functions
Azure Functions o processamento confiável de
eventos
O processamento de eventos é um dos cenários mais comuns associados à arquitetura sem servidor. Este artigo
descreve como criar um processador de mensagens confiável com Azure Functions para evitar a perda de
mensagens.
Desafios dos fluxos de eventos em sistemas distribuídos

Considere um sistema que envia eventos a uma taxa constante de 100 eventos por segundo. A essa taxa, em
minutos, várias instâncias de funções paralelas podem consumir os eventos 100 de entrada a cada segundo.
No entanto, qualquer uma das seguintes condições menos ideais é possível:
E se o Publicador de eventos enviar um evento corrompido?
E se sua instância do Functions encontrar exceções sem tratamento?
E se um sistema downstream ficar offline?
Como lidar com essas situações enquanto preserva a taxa de transferência de seu aplicativo?
Com as filas, as mensagens confiáveis são naturalmente. Quando emparelhado com um gatilho functions, a
função cria um bloqueio na mensagem da fila. Se o processamento falhar, o bloqueio será liberado para permitir
que outra instância seja processada novamente. Em seguida, o processamento continua até que a mensagem seja
avaliada com êxito ou adicionada a uma fila de suspeitas.
Mesmo que uma única mensagem de fila possa permanecer em um ciclo de repetição, outras execuções paralelas
continuam a manter a remoção da fila de mensagens restantes. O resultado é que a taxa de transferência geral
permanece em grande parte não afetada por uma mensagem inadequada. No entanto, as filas de armazenamento
não garantem pedidos e não são otimizadas para as demandas de alta taxa de transferência exigidas pelos hubs de
eventos
Por outro lado, os hubs de eventos do Azure não incluem um conceito de bloqueio. Para permitir recursos como
alta taxa de transferência, vários grupos de consumidores e capacidade de reprodução, os eventos de hubs de
eventos se comportam mais como um player de vídeo. Os eventos são lidos de um único ponto no fluxo por
partição. No ponteiro, você pode ler ou retroceder a partir desse local, mas você precisa escolher mover o ponteiro
para eventos a serem processados.
Quando ocorrerem erros em um fluxo, se você decidir manter o ponteiro no mesmo ponto, o processamento de
eventos será bloqueado até que o ponteiro seja avançado. Em outras palavras, se o ponteiro for interrompido para
lidar com problemas de processamento de um único evento, os eventos não processados começarão a
empilhando-los.
Azure Functions evita deadlocks avançando o ponteiro do fluxo, independentemente de êxito ou falha. Como o
ponteiro continua avançando, suas funções precisam lidar com falhas adequadamente.
Como o Azure Functions consome eventos de hubs de eventos

O Azure Functions consome eventos do hub de eventos ao percorrer as seguintes etapas:
1. Um ponteiro é criado e mantido no armazenamento do Azure para cada partição do hub de eventos.
2. Quando novas mensagens são recebidas (em um lote por padrão), o host tenta disparar a função com o lote de
mensagens.
3. Se a função concluir a execução (com ou sem exceção), o ponteiro avançará e um ponto de verificação será
salvo na conta de armazenamento.
4. Se as condições impedirem a conclusão da execução da função, o host não conseguirá progredir o ponteiro. Se
o ponteiro não for avançado, as verificações posteriores acabarão processando as mesmas mensagens.
5. Repita as etapas 2 a 4
Esse comportamento revela alguns pontos importantes:
Exceções sem tratamento podem causar a perda de mensagens. As execuções que resultam em uma exceção
continuarão a progredir o ponteiro.
As funções garantem a entrega pelo menos uma vez. Seu código e sistemas dependentes podem precisar
considerar o fato de que a mesma mensagem pode ser recebida duas vezes.
Tratamento de exceções
Como regra geral, cada função deve incluir um bloco try/catch no nível mais alto de código. Especificamente,
todas as funções que consomem eventos de hubs de eventos devem ter um bloco catch . Dessa forma, quando
uma exceção é gerada, o bloco catch trata o erro antes de o ponteiro progredir.
Mecanismos e políticas de repetição
Algumas exceções são transitórias por natureza e não são reexibidas quando uma operação é tentada novamente
mais tarde. É por isso que a primeira etapa é sempre repetir a operação. Você pode escrever novas regras de
processamento, mas elas são tão comuns que várias ferramentas disponíveis. O uso dessas bibliotecas permite
que você defina políticas de repetição robustas, que também podem ajudar a preservar a ordem de
processamento.
A introdução de bibliotecas de tratamento de falhas às suas funções permite que você defina políticas básicas e
avançadas de repetição. Por exemplo, você pode implementar uma política que segue um fluxo de trabalho
ilustrado pelas seguintes regras:
Tente inserir uma mensagem três vezes (potencialmente com um atraso entre repetições).
Se o resultado eventual de todas as novas tentativas for uma falha, adicione uma mensagem a uma fila para
que o processamento possa continuar no fluxo.
As mensagens corrompidas ou não processadas são tratadas posteriormente.
NOTE
Polly é um exemplo de uma biblioteca de resiliência e de tratamento de falhas transitórias C# para aplicativos.
Ao trabalhar com bibliotecas de C# classes previamente compatíveis, os filtros de exceção permitem que você
execute o código sempre que uma exceção sem tratamento ocorrer.
Exemplos que demonstram como usar filtros de exceção estão disponíveis no repositório SDK do Azure WebJobs .
Erros de não exceção

Alguns problemas surgem mesmo quando um erro não está presente. Por exemplo, considere uma falha que
ocorra no meio de uma execução. Nesse caso, se uma função não concluir a execução, o ponteiro de deslocamento
nunca será progredido. Se o ponteiro não avançar, qualquer instância que for executada após uma falha de
execução continuará lendo as mesmas mensagens. Essa situação fornece uma garantia "pelo menos uma vez".
A garantia de que cada mensagem seja processada pelo menos uma vez implica que algumas mensagens podem
ser processadas mais de uma vez. Seus aplicativos de funções precisam estar cientes dessa possibilidade e devem
ser criados com base nos princípios do Idempotência.
Parar e reiniciar a execução

Embora alguns erros possam ser aceitáveis, e se seu aplicativo apresentar falhas significativas? Talvez você queira
parar de disparar eventos até que o sistema alcance um estado íntegro. Ter o processamento de pausa de
oportunidade geralmente é obtido com um padrão de disjuntor. O padrão de disjuntor permite que seu aplicativo
"quebre o circuito" do processo de evento e retome em um momento posterior.
Há duas partes necessárias para implementar um disjuntor em um processo de evento:
Estado compartilhado em todas as instâncias para acompanhar e monitorar a integridade do circuito
Processo mestre que pode gerenciar o estado do circuito (aberto ou fechado)
Os detalhes da implementação podem variar, mas para compartilhar o estado entre as instâncias, você precisa de
um mecanismo de armazenamento. Você pode optar por armazenar o estado no armazenamento do Azure, um
cache Redis ou qualquer outra conta que possa ser acessada por uma coleção de funções.
Os aplicativos lógicos do Azure ou as entidades duráveis são uma opção natural para gerenciar o fluxo de trabalho
e o estado do circuito. Outros serviços também podem funcionar, mas os aplicativos lógicos são usados para este
exemplo. Usando aplicativos lógicos, você pode pausar e reiniciar a execução de uma função, dando a você o
controle necessário para implementar o padrão de disjuntor.
Definir um limite de falha entre instâncias
Para considerar várias instâncias processando eventos simultaneamente, é necessário persistir o estado externo
compartilhado para monitorar a integridade do circuito.
Uma regra que você pode optar por implementar pode impor isso:
Se houver mais de 100 falhas eventuals dentro de 30 segundos em todas as instâncias, quebre o circuito e pare
de disparar em novas mensagens.
Os detalhes da implementação variam de acordo com suas necessidades, mas, em geral, você pode criar um
sistema que:
1. Registrar falhas em uma conta de armazenamento (armazenamento do Azure, Redis, etc.)
2. Quando uma nova falha for registrada, inspecione a contagem de rolagem para ver se o limite foi atingido (por
exemplo, mais de 100 nos últimos 30 segundos).
3. Se o limite for atingido, emita um evento para a grade de eventos do Azure informando ao sistema para
interromper o circuito.
Gerenciando o estado do circuito com os aplicativos lógicos do Azure
A descrição a seguir destaca uma maneira de criar um aplicativo lógico do Azure para interromper o
processamento de um aplicativo de funções.
Os aplicativos lógicos do Azure vêm com conectores internos para diferentes serviços, recursos de orquestrações
com monitoração de estado e é uma opção natural para gerenciar o estado do circuito. Depois de detectar que o
circuito precisa ser interrompido, você pode criar um aplicativo lógico para implementar o seguinte fluxo de
trabalho:
1. Disparar um fluxo de trabalho de grade de eventos e parar a função do Azure (com o conector de recursos do
Azure)
2. Enviar um email de notificação que inclui uma opção para reiniciar o fluxo de trabalho
O destinatário do email pode investigar a integridade do circuito e, quando apropriado, reiniciar o circuito por
meio de um link no email de notificação. À medida que o fluxo de trabalho reinicia a função, as mensagens são
processadas a partir do último ponto de verificação do hub de eventos.
Usando essa abordagem, nenhuma mensagem é perdida, todas as mensagens são processadas em ordem e você
pode dividir o circuito, desde que seja necessário.
Recursos
Exemplos de processamento de eventos confiáveis
Disjuntor de Durable Functions do Azure
Próximas etapas
Tratamento de erros do Azure Functions
Automatizar o redimensionamento de imagens carregadas usando a Grade de Eventos
Criar uma função que se integra nos Aplicativos Lógicos do Azure
Criando Azure Functions para entrada idêntica
A realidade da arquitetura baseada em eventos e orientada a mensagens determina a necessidade de aceitar

solicitações idênticas, preservando a integridade dos dados e a estabilidade do sistema.
Para ilustrar, considere um botão de chamada de elevador.À medida que você pressiona o botão, ele acende e um
elevador é enviado para o andar. Alguns instantes depois, outra pessoa ingressa no lobby. Essa pessoa sorrisos
em você e pressiona o botão iluminado uma segunda vez. Você vai fazer um sorriso e Chuckle como você está
lembrado de que o comando para chamar um elevador é idempotente.
Pressionar um botão de chamada de elevador uma segunda, terceira ou quarta vez não tem nenhuma influência
sobre o resultado final. Quando você pressiona o botão, independentemente do número de vezes, o elevador é
enviado para o andar. Os sistemas idempotentes, como o elevador, resultam no mesmo resultado, não importa
quantas vezes comandos idênticos são emitidos.
Quando se trata de criar aplicativos, considere os seguintes cenários:
O que acontece se o seu aplicativo de controle de inventário tentar excluir o mesmo produto mais de uma
vez?
Como o aplicativo de recursos humanos se comporta se há mais de uma solicitação para criar um registro de
funcionário para a mesma pessoa?
Onde o dinheiro vai se seu aplicativo bancário receber 100 solicitações para fazer a mesma retirada?
Há muitos contextos em que as solicitações para uma função podem receber comandos idênticos. Algumas
situações incluem:
Políticas de repetição enviando a mesma solicitação muitas vezes
Comandos em cache reproduzidos para o aplicativo
Erros de aplicativo enviando várias solicitações idênticas
Para proteger a integridade dos dados e a integridade do sistema, um aplicativo idempotente contém uma lógica
que pode conter os seguintes comportamentos:
Verificando a existência de dados antes de tentar executar uma exclusão
Verificando se os dados já existem antes de tentar executar uma ação de criação
Reconciliação de lógica que cria consistência eventual nos dados
Controles de simultaneidade
Detecção de duplicação
Validação de atualização de dados
Lógica de proteção para verificar os dados de entrada
Em última instância, o Idempotência é obtido garantindo que uma determinada ação seja possível e seja
executada apenas uma vez.
Conceitos de gatilhos e de associações do
Azure Functions
Neste artigo, você aprende os conceitos de alto nível em torno de gatilhos e associações de
funções.
Os gatilhos são o que causa a execução de uma função. Um gatilho define como uma função é
invocada e uma função deve ter exatamente um gatilho. Os gatilhos têm dados associados,
que geralmente são fornecidos como a carga da função.
A associação a uma função é uma maneira de conectar declarativamente outro recurso à
função; as associações podem ser conectadas como associações de entrada, associações de
saídaou ambas. Dados de associações são fornecidos à função como parâmetros.
Você pode misturar e combinar associações diferentes para atender às suas necessidades.
Associações são opcionais e uma função pode ter uma ou várias associações de entrada e/ou
saída.
Gatilhos e associações permitem que você evite codificar o acesso a outros serviços. Sua
função recebe dados (por exemplo, o conteúdo de uma mensagem da fila) em parâmetros de
função. Você envia dados (por exemplo, para criar uma mensagem da fila) usando o valor
retornado da função.
Considere os exemplos a seguir de como você pode implementar funções diferentes.
ASSOCIAÇÃO DE
CENÁRIO DE EXEMPLO DISPARADOR ENTRADA ASSOCIAÇÃO DE SAÍDA
Uma nova mensagem Espera* Nenhum Espera*

de fila chega, que
executa uma função
para gravar em outra
fila.
Um trabalho Temporizador Armazenamento de Cosmos DB

agendado lê o Blob
conteúdo do
armazenamento de
BLOBs e cria um novo
documento Cosmos
DB.
A grade de eventos é Grade do Evento Armazenamento de SendGrid

usada para ler uma BLOBs e Cosmos DB
imagem do
armazenamento de
BLOBs e um
documento do
Cosmos DB para
enviar um email.
ASSOCIAÇÃO DE
CENÁRIO DE EXEMPLO DISPARADOR ENTRADA ASSOCIAÇÃO DE SAÍDA
Um webhook que usa HTTP Nenhum Microsoft Graph

Microsoft Graph para
atualizar uma planilha
do Excel.
* Representa filas diferentes
Esses exemplos não devem ser completos, mas são fornecidos para ilustrar como você pode
usar gatilhos e associações juntos.
Definições de associação e gatilho
Os gatilhos e as associações são definidos de forma diferente, dependendo da abordagem de
desenvolvimento.
PLATAFORMA GATILHOS E ASSOCIAÇÕES SÃO CONFIGURADOS POR...
C#biblioteca de classes decoração de métodos e parâmetros C# com

atributos
Todos os outros (incluindo portal do Azure) Atualizando Function. JSON (esquema)
O portal fornece uma interface do usuário para essa configuração, mas você pode editar o
arquivo diretamente abrindo o Editor avançado disponível por meio da guia integrar da sua
função.
No .NET, o tipo de parâmetro define o tipo de dados para dados de entrada. Por exemplo, use
string para associar ao texto de um gatilho de fila, uma matriz de bytes para ler como
binário e um tipo personalizado para desserializar para um objeto.
Para idiomas que são digitados dinamicamente como JavaScript, use a propriedade dataType
no arquivo function.json. Por exemplo, para ler o conteúdo de uma solicitação HTTP em
formato binário, defina dataType para binary :
{
"dataType": "binary",
"name": "req",
"direction": "in"
}
Outras opções para dataType são stream e string .
Direção de associação
Todos os disparadores e associações têm uma propriedade direction no arquivo
function.json:
Para gatilhos, a direção sempre é in
Associações de entrada e saída usam in e out
Algumas associações dão suporte a uma direção especial inout . Se você usar inout ,
somente o Editor avançado estará disponível por meio da guia integrar no Portal.
Quando você usa atributos em uma biblioteca de classes para configurar associações e
gatilhos, a direção é fornecida em um construtor de atributo ou inferida do tipo de parâmetro.
Associações com suporte

Esta tabela mostra as associações com suporte nas duas versões principais do tempo de
execução de Azure Functions:
Armazename ✔ ✔ ✔ ✔ ✔
nto de Blobs
eventos
Eventos
WebHooks ✔ ✔ ✔ ✔
de & de
HTTP
Microsoft ✔ ✔ ✔
Graph
Excel tabelas
OneDrive
Microsoft
Graph
Microsoft ✔ ✔
Graph
Outlook
email
Microsoft ✔ ✔ ✔ ✔
Graph
events
Tokens de ✔ ✔
Auth
Microsoft
Graph
Móveis
Hubs de ✔ ✔
Notificação
Armazename ✔ ✔ ✔ ✔
nto de filas
Barramento ✔ ✔ ✔ ✔
de Serviço
SignalR ✔ ✔ ✔
Armazename ✔ ✔ ✔ ✔
nto de
tabelas
Timer ✔ ✔ ✔
Twilio ✔ ✔ ✔
1 no tempo de execução da versão 2. x, todas as associações, exceto http e Timer, devem ser
registradas. Consulte registrar extensões de associação. Todas as associações 2. x com suporte
também têm suporte na versão 3. x, salvo indicação em contrário.
Para obter informações sobre quais associações estão na visualização ou são aprovadas para
o uso de produção, consulte Idiomas com suporte.
Recursos
Expressões e padrões de associação
Usando o valor de retorno da função do Azure
Como registrar uma expressão de associação
Teste:
Estratégias para testar seu código no Azure Functions
Tratamento de erros de associação
Próximas etapas
Registrar Azure Functions extensões de associação
Exemplo de gatilho e Associação de Azure Functions
Este artigo demonstra como configurar um gatilho e associações em uma função do Azure.
Suponha que você deseja gravar uma nova linha no Armazenamento de Tabelas do Azure sempre que uma nova
mensagem aparece no Armazenamento de Filas do Azure. Esse cenário pode ser implementado usando um
gatilho do Armazenamento de Filas do Azure e uma associação de saída do Armazenamento de Tabelas do Azure.
Aqui está um arquivo function.json para esse cenário.
{
"bindings": [
{
"type": "queueTrigger",
"direction": "in",
"name": "order",
"queueName": "myqueue-items",
"connection": "MY_STORAGE_ACCT_APP_SETTING"
},
{
"type": "table",
"direction": "out",
"name": "$return",
"tableName": "outTable",
"connection": "MY_TABLE_STORAGE_ACCT_APP_SETTING"
}
]
}
O primeiro elemento na matriz bindings é o gatilho do Armazenamento de Filas. As propriedades type e

direction identificam o gatilho. A propriedade name identifica o parâmetro de função que recebe o conteúdo da
mensagem de fila. O nome da fila a ser monitorada está em queueName e a cadeia de conexão está na configuração
de aplicativo identificada por connection .
O segundo elemento na matriz bindings é a associação de saída do Armazenamento de Tabelas do Azure. As
propriedades type e direction identificam a associação. A propriedade name especifica como a função fornece a
nova linha da tabela, nesse caso, usando o valor retornado da função. O nome da tabela está em tableName e a
cadeia de conexão está na configuração de aplicativo identificada por connection .
Para exibir e editar o conteúdo de function.json no Portal do Azure, clique na opção Editor avançado na guia
Integrar da sua função.
NOTE
O valor de connection é o nome de uma configuração de aplicativo que contém a cadeia de conexão, não a cadeia de
conexão propriamente dita. Associações usam cadeias de conexão armazenadas em configurações de aplicativo para impor a
melhor prática que dita que function.json não contêm segredos do serviço.
Exemplo 2 de C# script
Aqui está o código de script C# que funciona com esse gatilho e essa associação. Observe que o nome do
parâmetro que fornece o conteúdo da mensagem da fila é order ; esse nome é necessário porque o valor da
propriedade name em function.json é order
using Newtonsoft.Json.Linq;
// From an incoming queue message that is a JSON object, add fields and write to Table storage
// The method return value creates a new row in Table Storage
public static Person Run(JObject order, ILogger log)
{
return new Person() {
PartitionKey = "Orders",
RowKey = Guid.NewGuid().ToString(),
Name = order["Name"].ToString(),
MobileNumber = order["MobileNumber"].ToString() };
}
public class Person

{
public string PartitionKey { get; set; }
public string RowKey { get; set; }
public string Name { get; set; }
public string MobileNumber { get; set; }
}
Exemplo de JavaScript
O mesmo arquivo Function. JSON pode ser usado com uma função JavaScript:
// From an incoming queue message that is a JSON object, add fields and write to Table Storage
// The second parameter to context.done is used as the value for the new row
module.exports = function (context, order) {
order.PartitionKey = "Orders";
order.RowKey = generateRandomId();
context.done(null, order);
};
function generateRandomId() {
return Math.random().toString(36).substring(2, 15) +
Math.random().toString(36).substring(2, 15);
}
Exemplo de biblioteca de classes

Em uma biblioteca de classes, o mesmo gatilho e informações de associação — nomes de fila e tabela, contas de
armazenamento, parâmetros de função para entrada e saída — é fornecido por atributos em vez de um arquivo
function.json. Veja um exemplo:
public static class QueueTriggerTableOutput
{
[FunctionName("QueueTriggerTableOutput")]
[return: Table("outTable", Connection = "MY_TABLE_STORAGE_ACCT_APP_SETTING")]
public static Person Run(
[QueueTrigger("myqueue-items", Connection = "MY_STORAGE_ACCT_APP_SETTING")]JObject order,
ILogger log)
{
return new Person() {
PartitionKey = "Orders",
RowKey = Guid.NewGuid().ToString(),
Name = order["Name"].ToString(),
MobileNumber = order["MobileNumber"].ToString() };
}
}
public class Person

{
public string MobileNumber { get; set; }
}
Agora você tem uma função funcional que é disparada por uma fila do Azure e gera dados para o armazenamento
de tabelas do Azure.
Próximas etapas
Padrões de expressão de associação de Azure Functions
Registrar Azure Functions extensões de associação
No Azure Functions versão 2. x, as associações estão disponíveis como pacotes separados do tempo de
execução do functions. Enquanto as funções do .NET acessam associações por meio de pacotes NuGet, os
pacotes de extensão permitem que outras funções acessem todas as associações por meio de um parâmetro de
configuração.
Considere os seguintes itens relacionados a extensões de associação:
As extensões de associação não são explicitamente registradas no functions 1. x, exceto ao criar uma
biblioteca de classes usando C# o Visual Studio.
Os gatilhos HTTP e Timer têm suporte por padrão e não exigem uma extensão.
A tabela a seguir indica quando e como você registra as associações.
REGISTRO REGISTRO
AMBIENTE DE DESENVOLVIMENTO EM FUNÇÕES DE 1. X EM FUNÇÕES 2. X
Portal do Azure Automático Automático
Idiomas Non-.NET ou Automático Usar Azure Functions Core Tools e

desenvolvimento de ferramentas pacotes de extensão
principais do Azure local
C#biblioteca de classes usando o Usar as ferramentas do NuGet Usar as ferramentas do NuGet

Visual Studio
Biblioteca de classes C# usando o N/D Use o .NET Core CLI

código do Visual Studio
Pacotes de extensão para desenvolvimento local

Os pacotes de extensão são uma tecnologia de desenvolvimento local para o tempo de execução da versão 2. x
que permite adicionar um conjunto compatível de extensões de associação de funções ao seu projeto de
aplicativo de funções. Esses pacotes de extensão são então incluídos no pacote de implantação quando você
implanta no Azure. Os pacotes tornam todas as associações publicadas pela Microsoft disponíveis por meio de
uma configuração no arquivo host. JSON . Os pacotes de extensão definidos em um pacote são compatíveis
entre si, o que ajuda a evitar conflitos entre pacotes. Ao desenvolver localmente, verifique se você está usando a
versão mais recente do Azure Functions Core Tools.
Use pacotes de extensão para todo o desenvolvimento local usando Azure Functions Core Tools ou Visual
Studio Code.
Se você não usar pacotes de extensão, deverá instalar o SDK do .NET Core 2. x em seu computador local antes
de instalar qualquer extensão de associação. Os pacotes eliminam esse requisito para o desenvolvimento local.
Para usar pacotes de extensão, atualize o arquivo host. JSON para incluir a seguinte entrada para
extensionBundle :
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}
As seguintes propriedades estão disponíveis em extensionBundle :
PROPRIEDADE DESCRIÇÃO
id O namespace para pacotes de extensão do Microsoft Azure

functions.
version A versão do pacote a ser instalado. O tempo de execução do

Functions sempre escolhe a versão máxima permitida
definida pelo intervalo de versão ou intervalo. O valor da
versão acima permite todas as versões do pacote da 1.0.0
até, mas não incluindo 2.0.0. Para obter mais informações,
consulte a notação de intervalo para especificar intervalos
de versão.
As versões do pacote são incrementadas como pacotes na alteração do pacote. As alterações de versão
principal ocorrem quando os pacotes no pacote são incrementados por uma versão principal, que geralmente
coincide com uma alteração na versão principal do tempo de execução do functions.
O conjunto atual de extensões instaladas pelo pacote padrão é enumerado neste arquivo Extensions. JSON.
Biblioteca# de classes C com o Visual Studio

No Visual Studio, você pode instalar pacotes do console do Gerenciador de pacotes usando o comando
install-Package , conforme mostrado no exemplo a seguir:
Install-Package Microsoft.Azure.WebJobs.Extensions.ServiceBus -Version <TARGET_VERSION>
O nome do pacote usado para uma determinada associação é fornecido no artigo de referência para essa
associação. Para obter um exemplo, consulte o pacotes seção do artigo de referência de associação do
barramento de serviço.
Substituir <TARGET_VERSION> no exemplo com uma versão específica do pacote, como 3.0.0-beta5 . Versões
válidas são listadas nas páginas de pacotes individuais em NuGet.org. As versões principais que correspondem
às funções de tempo de execução 1. x ou 2. x são especificadas no artigo de referência para a associação.
Se você usar Install-Package o para fazer referência a uma associação, não será necessário usar pacotes de
extensão. Essa abordagem é específica para bibliotecas de classes criadas no Visual Studio.
C# biblioteca de classes com Visual Studio Code

NOTE
É recomendável usar pacotes de extensão para que o Functions instale automaticamente um conjunto compatível de
pacotes de extensão de associação.
No Visual Studio Code, instale pacotes para um C# projeto de biblioteca de classes do prompt de comando
usando o comando dotnet adicionar pacote na CLI do .NET Core. O exemplo a seguir demonstra como você
adiciona uma associação:
dotnet add package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE_NAME> --version <TARGET_VERSION>
O .NET Core CLI só pode ser usado para o desenvolvimento do Azure Functions 2.x.
Substitua <BINDING_TYPE_NAME> pelo nome do pacote fornecido no artigo de referência para a associação
desejada. Você pode encontrar o artigo de referência de associação desejada na lista de associações com
suporte.
Substituir <TARGET_VERSION> no exemplo com uma versão específica do pacote, como 3.0.0-beta5 . Versões
válidas são listadas nas páginas de pacotes individuais em NuGet.org. As versões principais que correspondem
às funções de tempo de execução 1. x ou 2. x são especificadas no artigo de referência para a associação.
Próximas etapas
Exemplo de gatilho e associação do Azure function
Padrões de expressão de associação de Azure
Functions
Um dos recursos mais poderosos de gatilhos e associações é a Associação de expressões. No arquivo

function.json e em parâmetros de função e de código, você pode usar expressões que são resolvidas para
valores de várias fontes.
A maioria das expressões são identificadas, encapsulando-as entre chaves. Por exemplo, em uma função de
gatilho de fila, {queueTrigger} resolve para o texto de mensagem da fila. Se a propriedade path para uma
associação de saída de blob é container/{queueTrigger} e a função é disparada por uma mensagem da fila
HelloWorld , um blob denominado HelloWorld é criado.
Tipos de expressões de associação

Configurações do aplicativo
Nome do arquivo de gatilho
Gatilho metadados
Cargas JSON
Novo GUID
Data e hora atuais
Expressões de associação - configurações do aplicativo

Como prática recomendada, os segredos e cadeias de conexão devem ser gerenciados usando configurações
do aplicativo, em vez de arquivos de configuração. Isso limita o acesso a esses segredos e torna seguro
armazenar arquivos como function.json em repositórios de controle do código-fonte público.
Configurações do aplicativo também são úteis sempre que você desejar alterar a configuração com base no
ambiente. Por exemplo, em um ambiente de teste, pode ser útil monitorar um contêiner de armazenamento de
filas ou de blobs diferente.
Expressões de associação de configuração do aplicativo são identificadas diferentemente de outras expressões
de associação: elas são dispostas em sinais de porcentagem em vez de chaves. Por exemplo, se o caminho de
associação de saída de blob é %Environment%/newblob.txt e o Environment valor de configuração do aplicativo
é Development , um blob será criado no contêiner Development .
Quando uma função é executada localmente, os valores de configuração do aplicativo são provenientes do
Observe que a propriedade connection dos gatilhos e associações é um caso especial e resolve
automaticamente os valores de configurações do aplicativo, sem os sinais de porcentagem.
O exemplo a seguir é um gatilho do Armazenamento de Filas do Azure que usa uma configuração de
aplicativo %input-queue-name% para definir a fila em que o gatilho é disparado.
{
"bindings": [
{
"name": "order",
"direction": "in",
"queueName": "%input-queue-name%",
"connection": "MY_STORAGE_ACCT_APP_SETTING"
}
]
}
Você pode usar a mesma abordagem em bibliotecas de classes:
[FunctionName("QueueTrigger")]
public static void Run(
[QueueTrigger("%input-queue-name%")]string myQueueItem,
ILogger log)
{
log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
}
Nome do arquivo de gatilho

O path para um gatilho de Blob pode ser um padrão que permite que você se refera ao nome do blob que
dispara em outras associações e código de função. O padrão também pode incluir critérios de filtragem que
especifique os blobs que podem disparar uma invocação de função.
Por exemplo, na seguinte associação de gatilho de Blob, o path padrão é sample-images/{filename} , que cria
uma expressão de associação denominada filename :
{
"bindings": [
{
"name": "image",
"type": "blobTrigger",
"path": "sample-images/{filename}",
"direction": "in",
"connection": "MyStorageConnection"
},
...
A expressão filename pode ser usada em uma associação de saída para especificar o nome do blob que está
sendo criado:
...
{
"name": "imageSmall",
"type": "blob",
"path": "sample-images-sm/{filename}",
"direction": "out",
}
],
}
Código de função tem acesso a esse mesmo valor usando filename como um nome de parâmetro:
// C# example of binding to {filename}
public static void Run(Stream image, string filename, Stream imageSmall, ILogger log)
{
log.LogInformation($"Blob trigger processing: {filename}");
// ...
}
A mesma capacidade de usar padrões e expressões de associação se aplica a atributos em bibliotecas de

classes. No exemplo a seguir, os parâmetros do construtor de atributo são os mesmos path valores dos
exemplos de function.json anteriores:
[FunctionName("ResizeImage")]
[BlobTrigger("sample-images/{filename}")] Stream image,
[Blob("sample-images-sm/{filename}", FileAccess.Write)] Stream imageSmall,
string filename,
ILogger log)
{
log.LogInformation($"Blob trigger processing: {filename}");
// ...
}
Você também pode criar expressões para partes do nome do arquivo, como a extensão. Para obter mais
informações sobre como usar padrões e expressões na cadeia de caracteres de caminho de Blob, consulte a
referência de associação de blob de Armazenamento.
Metadados de gatilho
Além do conteúdo dos dados fornecido por um gatilho (como o conteúdo da mensagem da fila que disparou
uma função), vários gatilhos fornecem valores de metadados adicionais. Esses valores podem ser usados
como parâmetros de entrada em C# e F# ou propriedades no objeto context.bindings em JavaScript.
Por exemplo, um gatilho do Armazenamento de Filas do Azure é compatível com as seguintes propriedades:
QueueTrigger – disparar o conteúdo da mensagem em caso de uma cadeia de caracteres válida
DequeueCount
ExpirationTime
Id
InsertionTime
NextVisibleTime
PopReceipt
Esses valores de metadados estão acessíveis nas propriedades do arquivo function.json. Por exemplo, suponha
que você usa um gatilho de fila e que a mensagem da fila contém o nome de um blob que você deseja ler. No
arquivo function.json, você pode usar a propriedade de metadados queueTrigger na propriedade path do
blob, conforme mostrado no exemplo a seguir:
"bindings": [
{
"name": "myQueueItem",
"connection": "MyStorageConnection",
},
{
"name": "myInputBlob",
"type": "blob",
"path": "samples-workitems/{queueTrigger}",
"direction": "in",
}
]
Detalhes de propriedades de metadados para cada gatilho são descritos no artigo de referência
correspondente. Para obter um exemplo, consulte metadados de gatilho de fila. A documentação também está
disponível na guia Integrar do portal, na seção Documentação abaixo da área de configuração de
associação.
Cargas JSON
Quando uma carga de gatilho for JSON, você pode consultar as propriedades na configuração de outras
associações na mesma função e no código de função.
A exemplo a seguir mostra o arquivo function.json arquivo para uma função de webhook que recebe um nome
de blob em JSON: {"BlobName":"HelloWorld.txt"} . Uma associação de entrada do Blob lê o blob e associação
de saída HTTP retorna o conteúdo de blob na resposta HTTP. Observe que a associação de entrada do Blob
obtém o nome do blob referindo-se diretamente à BlobName propriedade ( "path": "strings/{BlobName}" )
{
"bindings": [
{
"name": "info",
"direction": "in",
"webHookType": "genericJson"
},
{
"name": "blobContents",
"type": "blob",
"direction": "in",
"path": "strings/{BlobName}",
},
{
"name": "res",
"type": "http",
"direction": "out"
}
]
}
Para este trabalho em C# e F#, você precisa de uma classe que define os campos a serem desserializados,
como no exemplo a seguir:
using System.Net;
public class BlobInfo

{
public string BlobName { get; set; }
}
public static HttpResponseMessage Run(HttpRequestMessage req, BlobInfo info, string blobContents, ILogger
log)
{
if (blobContents == null) {
return req.CreateResponse(HttpStatusCode.NotFound);
}
log.LogInformation($"Processing: {info.BlobName}");
return req.CreateResponse(HttpStatusCode.OK, new {

data = $"{blobContents}"
});
}
No JavaScript, a desserialização JSON é executada automaticamente.
module.exports = function (context, info) {

if ('BlobName' in info) {
context.res = {
body: { 'data': context.bindings.blobContents }
}
}
else {
context.res = {
status: 404
};
}
context.done();
}
Notação de ponto
Se algumas das propriedades na sua carga JSON são objetos com propriedades, você pode consultar esses
diretamente usando a notação de ponto. Por exemplo, suponha que o JSON tem esta aparência:
{
"BlobName": {
"FileName":"HelloWorld",
"Extension":"txt"
}
}
Você pode se referir diretamente a FileName como BlobName.FileName . Com esse formato JSON, aqui está
como se parece a propriedade path no exemplo anterior:
"path": "strings/{BlobName.FileName}.{BlobName.Extension}",
Em C#, você precisaria de duas classes:

public class BlobInfo
{
public BlobName BlobName { get; set; }
}
public class BlobName
{
public string FileName { get; set; }
public string Extension { get; set; }
}
Criar GUIDs
A expressão de associação {rand-guid} cria um GUID. O seguinte caminho de blob em um function.json
arquivo cria um blob com um nome como 50710cb5 -84b9 -4d87 -9d 83 -a03d6976a682.txt.
{
"type": "blob",
"name": "blobOutput",
"direction": "out",
"path": "my-output-container/{rand-guid}"
}
Hora atual
A expressão de associação DateTime resolve para DateTime.UtcNow . O seguinte caminho de blob em um
function.json arquivo cria um blob com um nome como 2018 -02 -16T17 -59 -55Z.txt.
{
"type": "blob",
"name": "blobOutput",
"direction": "out",
"path": "my-output-container/{DateTime}"
}
Associando no tempo de execução

No C#, e em outras linguagens .NET, você pode usar um padrão de associação obrigatório, em vez de
associações declarativas em function.json e atributos. A associação obrigatória é útil quando os parâmetros de
associação precisam ser calculado no tempo de execução, em vez do tempo de design. Para obter mais
informações, consulte a referência do desenvolvedor C# ou referência do desenvolvedor de script C#.
Próximas etapas
Este artigo explica como os valores de retorno funcionam dentro de uma função.
Em idiomas que têm um valor de retorno, você pode associar uma Associação de saída de função ao valor de
retorno:
Em uma biblioteca de classe C#, aplique o atributo de associação de saída para o valor de retorno do método.
Em outras linguagens, defina a propriedade name em function.json para $return .
Se houver várias associações de saída, use o valor de retorno de apenas um deles.
No C# e script C#, formas alternativas de enviar os dados para uma associação de saída são parâmetros out e
objetos de coletor.
Veja o exemplo específico de uma linguagem que mostra o uso do valor de retorno:
C#
Script do C# (.csx)
F#
JavaScript
Python
Exemplo de C#
Aqui está o código C# que usa o valor de retorno para uma associação de saída, seguido por um exemplo de
assíncrono:
[return: Blob("output-container/{id}")]
public static string Run([QueueTrigger("inputqueue")]WorkItem input, ILogger log)
{
string json = string.Format("{{ \"id\": \"{0}\" }}", input.Id);
log.LogInformation($"C# script processed queue message. Item={json}");
return json;
}
[return: Blob("output-container/{id}")]
public static Task<string> Run([QueueTrigger("inputqueue")]WorkItem input, ILogger log)
{
return Task.FromResult(json);
}
Aqui está a associação de saída no arquivo function.json:
{
"name": "$return",
"type": "blob",
"direction": "out",
"path": "output-container/{id}"
}
Aqui está o código de script C#, seguido por um exemplo de assíncrono:
public static string Run(WorkItem input, ILogger log)

{
return json;
}
public static Task<string> Run(WorkItem input, ILogger log)

{
return Task.FromResult(json);
}
Exemplo de F#
{
"name": "$return",
"type": "blob",
"direction": "out",
}
O código F# é o seguinte:
let Run(input: WorkItem, log: ILogger) =

let json = String.Format("{{ \"id\": \"{0}\" }}", input.Id)
log.LogInformation(sprintf "F# script processed queue message '%s'" json)
json
{
"name": "$return",
"type": "blob",
"direction": "out",
}
No JavaScript, o valor de retorno fica no segundo parâmetro para context.done :

module.exports = function (context, input) {
var json = JSON.stringify(input);
context.log('Node.js script processed queue message', json);
context.done(null, json);
}
Exemplo de Python
{
"name": "$return",
"type": "blob",
"direction": "out",
}
Aqui está o código Python:
def main(input: azure.functions.InputStream) -> str:

return json.dumps({
'name': input.name,
'length': input.length,
'content': input.read().decode('utf-8')
})
Próximas etapas
Manipular erros de associação de Azure Functions
Manipular erros de associação de Azure Functions
Os erros gerados em um Azure Functions podem vir de qualquer uma das seguintes origens:
Uso de gatilhos e associações de Azure Functions internos
Chamadas para APIs de serviços subjacentes do Azure
Chamadas para pontos de extremidade REST
Chamadas para bibliotecas de cliente, pacotes ou APIs de terceiros
Seguir as práticas sólidas de tratamento de erros é importante para evitar a perda de dados ou mensagens
perdidas. As práticas recomendadas de tratamento de erros incluem as seguintes ações:
Habilitar Application Insights
Usar tratamento de erro estruturado
Design para Idempotência
Implementar políticas de repetição (quando apropriado)
Capturar e publicar erros é essencial para monitorar a integridade do seu aplicativo. O nível mais alto de qualquer
código de função deve incluir um bloco try/catch. No bloco catch, você pode capturar e publicar erros.
Tentar suporte novamente
Os seguintes gatilhos têm suporte interno de repetição:
Armazenamento de Blobs do Azure
Armazenamento de Filas do Azure
Barramento de Serviço do Azure (fila/tópico)
Por padrão, esses gatilhos retentam solicitações até cinco vezes. Após a quinta repetição, os dois gatilhos gravam
uma mensagem em uma fila suspeita.
Você precisa implementar manualmente as políticas de repetição para quaisquer outros tipos de associações ou
disparadores. Implementações manuais podem incluir a gravação de informações de erro em uma fila de
mensagens suspeitas. Ao gravar em uma fila suspeita, você tem a oportunidade de tentar novamente as operações
mais tarde. Essa abordagem é a mesma usada pelo gatilho do armazenamento de BLOBs.
Para obter informações sobre erros retornados por serviços com suporte pelas funções, consulte a seção códigos
de erro de ligação do artigo Azure Functions visão geral de tratamento de erros .
Linguagens com suporte no Azure Functions
Este artigo explica os níveis de suporte oferecido para linguagens que você pode usar com o Azure Functions.
Níveis de suporte
Há três níveis de suporte:
Geralmente disponível (GA ) – com suporte total e aprovado para uso em produção.
Versão prévia – ainda não tem suporte, mas é esperado para alcançar o status de GA no futuro.
Experimental – não tem suporte e pode ser abandonado no futuro; nenhuma garantia de status de GA ou
de versão prévia eventual.
Idiomas por versão de tempo de execução

Duas versões do tempo de execução do Azure Functions estão disponíveis. A tabela a seguir indica quais
linguagens têm suporte em cada versão de runtime.
IDIOMA 1.X 2. X 3. X 1
C# GA (.NET Framework 4.7) GA (.NET Core 2,2) Visualização (.NET Core 3. x)
JavaScript GA (Nó 6) GA (Nó 8 e 10) Visualização (nó 8 & 10)
F# GA (.NET Framework 4.7) GA (.NET Core 2,2) Visualização (.NET Core 3. x)
Java N/D GA (Java 8) Versão prévia (Java 8)
PowerShell Experimental GA (PowerShell Core 6) Visualização (PowerShell

Core 6)
Python Experimental GA (Python 3.7. x) Visualização (Python 3.7. x)
TypeScript Experimental GA2 Visualização2
Bash Experimental N/D N/D
Lote (.cmd, .bat) Experimental N/D N/D
PHP Experimental N/D N/D
1O tempo de execução das funções v3. x está em visualização.

2 Com suporte por meio de transpiling para JavaScript.
Para obter informações sobre alterações planejadas para o suporte de linguagem, consulte o roteiro do Azure.
Linguagens experimentais
As linguagens experimentais na versão 1.x não escalam bem e não oferecem suporte a todas as associações.
Não use recursos experimentais para algo em que você confia, pois não há suporte oficial para eles. Não devem
ser abertos casos de suporte para problemas com linguagens experimentais.
O runtime versão 2.x não oferece suporte a linguagens experimentais. O suporte para novos idiomas é
adicionado somente quando o idioma pode ter suporte em produção.
Extensibilidade de linguagem
A partir da versão 2. x, o tempo de execução foi projetado para oferecer extensibilidade de linguagem. As
linguagens JavaScript e Java no runtime 2.x são criadas com essa extensibilidade.
Próximos passos
Para saber mais sobre como desenvolver funções nos idiomas com suporte, consulte os seguintes recursos:
C#referência do desenvolvedor da biblioteca de classes
C#referência do desenvolvedor de script
Referência do desenvolvedor Java
Referência do desenvolvedor de JavaScript
Referência do desenvolvedor do PowerShell
Referência do desenvolvedor do Python
Referência do desenvolvedor TypeScript
Referência do desenvolvedor de C#
do Azure Functions
Este artigo é uma introdução ao desenvolvimento do Azure Functions usando o

script C# em biblioteca de classes .NET.
O Azure Functions oferece suporte às linguagens de programação C# e script C#.
Se estiver procurando diretrizes sobre como usar C# no portal do Azure, consulte
Referência do desenvolvedor de script C# (.csx).
Este artigo pressupõe que você tenha completado as seguintes etapas:
Guia do desenvolvedor do Azure Functions
Ferramentas do Azure Functions Visual Studio 2019
Versões com suporte

O tempo de execução do Azure Functions 2. x usa o .NET Core 2,2. O código de
função pode usar as APIs do .NET Core 2,2 Atualizando as configurações do projeto
do Visual Studio. Os modelos de função não têm como padrão o .NET Core 2,2 para
evitar afetar negativamente os clientes que não têm o .NET Core 2,2 instalado.
Projeto de biblioteca de classes de funções

No Visual Studio, o modelo de projeto do Azure Functions cria um projeto de
biblioteca de classes do C# que contém os seguintes arquivos:
host.json – armazena conjuntos de configurações que afetam todas as funções
no projeto quando estão em execução localmente ou no Azure.
local.settings.json – armazena as configurações de aplicativo e as cadeias de
conexão que são usadas quando estão em execução localmente. Este arquivo
contém segredos e não é publicado no aplicativo de funções no Azure. Em vez
disso, adicione configurações de aplicativo ao seu aplicativo de funções.
Quando você cria o projeto, uma estrutura de pastas parecida com o exemplo a
seguir é gerada no diretório de saída da compilação:
<framework.version>
| - bin
| - MyFirstFunction
| | - function.json
| - MySecondFunction
| | - function.json
| - host.json
Esse é o diretório implantado no aplicativo de funções no Azure. As extensões de

associação necessárias na versão 2.x do tempo de execução das Funções são
adicionadas ao projeto como pacotes do NuGet.
IMPORTANT
O processo de compilação cria um arquivo function.json para cada função. Esse arquivo
function.json não deve ser editado diretamente. Você não pode alterar a configuração de
associação ou desabilitar a função por meio da edição desse arquivo. Para aprender como
desabilitar uma função, consulte Como desabilitar funções.
Métodos reconhecidos como funções

Em uma biblioteca de classe, uma função é um método estático com um
FunctionName e um atributo de gatilho, conforme mostrado no exemplo a seguir:
public static class SimpleExample

{
[QueueTrigger("myqueue-items")] string myQueueItem,
ILogger log)
{
log.LogInformation($"C# function processed: {myQueueItem}");
}
}
O atributo FunctionName marca o método como um ponto de entrada da função. O

nome deve ser exclusivo em um projeto, começar com uma letra e conter apenas
letras, números, _ e - , até 127 caracteres de comprimento. Modelos de projeto
geralmente criam um método chamado Run , mas o nome do método pode ser
qualquer nome de método C# válido.
O atributo de gatilho especifica o tipo de gatilho e associa dados de entrada a um
parâmetro de método. A função de exemplo é disparada por uma mensagem de fila,
a qual é transmitida para o método no parâmetro myQueueItem .
Parâmetros de assinatura do método

A assinatura do método pode conter parâmetros diferentes daquela usada com o
atributo de gatilho. Aqui estão alguns dos parâmetros adicionais que você pode
incluir:
Associações de entrada e saída marcadas como tal, decorando-os com atributos.
Um ILogger ou TraceWriter (versão 1. x somente) parâmetro para log.
Um parâmetro CancellationToken para desligamento normal.
Parâmetros de expressões de associação para obter metadados de gatilho.
Não importa a ordem dos parâmetros na assinatura de função. Por exemplo, você
pode inserir os parâmetros de gatilho antes ou depois de outras associações e
inserir o parâmetro do agente antes ou depois dos parâmetros de gatilho ou
associação.
Exemplo de associação de saída
O exemplo a seguir modifica o anterior por adicionar uma associação de fila de
saída. A função grava a mensagem da fila que aciona a função para uma nova
mensagem de fila em uma fila diferente.
public static class SimpleExampleWithOutput
{
[FunctionName("CopyQueueMessage")]
[QueueTrigger("myqueue-items-source")] string myQueueItem,
[Queue("myqueue-items-destination")] out string myQueueItemCopy,
ILogger log)
{
log.LogInformation($"CopyQueueMessage function processed:
{myQueueItem}");
myQueueItemCopy = myQueueItem;
}
}
Os artigos de referência de associação ( Filas de armazenamento, por exemplo)

explicam quais tipos de parâmetro você pode usar com os atributos de associação
de gatilho, entrada ou saída.
Exemplo de expressões de associação
O código a seguir obtém o nome da fila para monitorar a partir de uma
configuração de aplicativo, e ele obtém a hora de criação da mensagem da fila no
parâmetro insertionTime .
public static class BindingExpressionsExample

{
[FunctionName("LogQueueMessage")]
[QueueTrigger("%queueappsetting%")] string myQueueItem,
DateTimeOffset insertionTime,
ILogger log)
{
log.LogInformation($"Message content: {myQueueItem}");
log.LogInformation($"Created at: {insertionTime}");
}
}
function.json gerado automaticamente

O processo de compilação cria um arquivo function.json em uma pasta de função na
pasta de compilação. Conforme observado anteriormente, esse arquivo não deve
ser editado diretamente. Você não pode alterar a configuração de associação ou
desabilitar a função por meio da edição desse arquivo.
O objetivo desse arquivo é fornecer informações para o controlador de escala usado
para dimensionar decisões no plano de consumo. Por esse motivo, o arquivo não
tem informações de associações de entrada ou saída, apenas de gatilho.
O arquivo function.json gerado inclui uma propriedade configurationSource que
indica o tempo de execução a ser usado em atributos .NET para associações, em vez
da configuração do function.json. Veja um exemplo:
{
"generatedBy": "Microsoft.NET.Sdk.Functions-1.0.0.0",
"configurationSource": "attributes",
"bindings": [
{
"queueName": "%input-queue-name%",
"name": "myQueueItem"
}
],
"disabled": false,
"scriptFile": "..\\bin\\FunctionApp1.dll",
"entryPoint": "FunctionApp1.QueueTrigger.Run"
}
Microsoft.NET.Sdk.Functions
A geração do arquivo function.json é realizada pelo pacote NuGet
Microsoft.NET.Sdk.Functions.
O mesmo pacote é usado para a versão 1.x e 2.x do tempo de execução do
Functions. A estrutura de destino é o que diferencia um projeto de 1.x de um projeto
de 2.x. Estas são as partes relevantes dos arquivos .csproj, mostrando estruturas de
destino diferentes e o mesmo pacote Sdk :
Functions 1.x
<PropertyGroup>
<TargetFramework>net461</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Sdk.Functions" Version="1.0.8" />
</ItemGroup>
Functions 2.x
<PropertyGroup>
<TargetFramework>netcoreapp2.1</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Sdk.Functions" Version="1.0.8" />
</ItemGroup>
Entre as dependências do pacote Sdk estão os gatilhos e associações. Um projeto 1.

x refere-se a gatilhos e associações de 1. x porque esses gatilhos e associações se
destinam ao .NET Framework, enquanto os gatilhos de 2. x e associações são
direcionadas ao .NET Core.
O pacote Sdk também depende do Newtonsoft.Json e, indiretamente, do
WindowsAzure.Storage. Essas dependências garantem que seu projeto use as
versões desses pacotes que funcionam com a versão de tempo de execução do
Functions para a qual o projeto é direcionado. Por exemplo, o Newtonsoft.Json tem
a versão 11 para o .NET Framework 4.6.1, mas o tempo de execução do Functions
direcionado para o .NET Framework 4.6.1 só é compatível com o Newtonsoft.Json
9.0.1. Portanto, o código de sua função nesse projeto também tem que usar
Newtonsoft.Json 9.0.1.
O código-fonte para Microsoft.NET.Sdk.Functions está disponível no repositório
GitHub azure-functions-vs-build-sdk.
Versão de tempo de execução

O Visual Studio usa as Ferramentas Essenciais do Azure Functions para executar
projetos do Functions. As Ferramentas Essenciais são uma interface de linha de
comando para o tempo de execução do Functions.
Se você instalar as Ferramentas Essenciais usando npm, isso não afetará a versão
das Ferramentas Essenciais usada pelo Visual Studio. Para a versão de tempo de
execução do Functions 1.x, o Visual Studio armazena as versões das Ferramentas
Essenciais em %USERPROFILE%\AppData\Local\Azure.Functions.Cli e usa a versão
mais recente armazenada ali. Para o Functions 2.x, as Ferramentas Essenciais serão
incluídas na extensão Azure Functions e Ferramentas de Trabalhos Web. Para
1.x e 2.x, você pode ver qual versão está sendo usado na saída do console ao
executar um projeto do Functions:
[3/1/2018 9:59:53 AM] Starting Host (HostId=contoso2-1518597420,

Version=2.0.11353.0, ProcessId=22020, Debug=False, Attempt=0,
FunctionsExtensionVersion=)
Tipos com suporte para associações

Cada associação tem seus próprios tipos com suporte. Por exemplo, um atributo de
gatilho de blob pode ser aplicado a um parâmetro de cadeia de caracteres, um
parâmetro POCO, um parâmetro CloudBlockBlob ou qualquer um dos vários outros
tipos com suporte. O artigo de referência de associação para associações de blob
lista todos os tipos de parâmetro com suporte. Para obter mais informações,
consulte Gatilhos e associações e os documentos de referência de associação para
cada tipo de associação.
TIP
Se você planeja usar as ligações HTTP ou WebHook, planeje evitar o esgotamento de
porta que pode ser causado pela instanciação incorreta do HttpClient . Para saber mais,
confira Como gerenciar conexões no Azure Functions.
Associando ao valor de retorno do método

Você pode usar um valor de retorno do método para uma associação de saída,
aplicando o atributo ao valor de retorno do método. Para obter exemplos, consulte
Gatilhos e associações.
Use o valor retornado apenas se uma execução de função com êxito sempre resultar
em um valor retornado a ser passado 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 associação de saída ou se uma invocação de
função com êxito não resultar em nada a ser passado para a associação de saída, use
os tipos ICollector 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 class ICollectorExample

{
[FunctionName("CopyQueueMessageICollector")]
[QueueTrigger("myqueue-items-source-3")] string myQueueItem,
[Queue("myqueue-items-destination")] ICollector<string>
myDestinationQueue,
ILogger log)
{
myDestinationQueue.Add($"Copy 1: {myQueueItem}");
myDestinationQueue.Add($"Copy 2: {myQueueItem}");
}
}
Registrando em log
A saída de log para logs de streaming em C#, inclue um argumento do tipo ILogger.
É recomendável que você nomeie log , conforme mostrado no exemplo a seguir:
public static class SimpleExample

{
ILogger log)
{
}
}
Evite usar Console.Write no Azure Functions. Para obter mais informações,

consulte Gravar logs mas funções C# no artigo Monitorar o Azure Functions.
Assíncrono
Para tornar uma função assíncrona, use a palavra-chave async e retorne um objeto
Task .
public static class AsyncExample

{
[FunctionName("BlobCopy")]
public static async Task RunAsync(
[BlobTrigger("sample-images/{blobName}")] Stream blobInput,
[Blob("sample-images-copies/{blobName}", FileAccess.Write)] Stream
blobOutput,
CancellationToken token,
ILogger log)
{
log.LogInformation($"BlobCopy function processed.");
await blobInput.CopyToAsync(blobOutput, 4096, token);
}
}
Não é possível usar parâmetros out em funções assíncronas. Para associações de

saída, use o valor de retorno de função ou um objeto coletor.
Tokens de cancelamento
Uma função pode aceitar um parâmetro CancellationToken que permite ao sistema
operacional notificar seu código quando a função está prestes a ser encerrada. Você
pode usar essa notificação para certificar-se de que a função não finalize
inesperadamente de uma maneira que os dados fiquem em um estado
inconsistente.
O exemplo a seguir mostra como verificar o encerramento da função iminente.
public static class CancellationTokenExample

{
[QueueTrigger("inputqueue")] 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);
}
}
}
Variáveis de ambiente
Para obter uma variável de ambiente ou um valor de configuração do aplicativo, use
System.Environment.GetEnvironmentVariable , conforme mostrado no exemplo de
código a seguir:
public static class EnvironmentVariablesExample

{
[FunctionName("GetEnvironmentVariables")]
public static void Run([TimerTrigger("0 */5 * * * *")]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);
}
}
As configurações do aplicativo podem ser lidas de variáveis de ambiente ao

desenvolver localmente e ao executar no Azure. Ao desenvolver localmente, as
configurações do aplicativo são provenientes da coleção Values no arquivo
local.settings.json. Em ambos os ambientes, local e do Azure,
GetEnvironmentVariable("<app setting name>") recupera o valor da configuração de
aplicativo nomeada. Por exemplo, quando você estivesse executando localmente,
"Nome do Meu Site" seria retornado se o arquivo local.settings.json contivesse
{ "Values": { "WEBSITE_SITE_NAME": "My Site Name" } } .
A propriedade System.Configuration.ConfigurationManager.AppSettings é uma API

alternativa para obter os valores de configuração do aplicativo, mas é recomendável
que você use GetEnvironmentVariable conforme mostrado aqui.
Associando no tempo de execução

No C# e em outras linguagens .NET, é possível usar um padrão de associação
obrigatório em vez de associações declarativas em atributos. A associação
obrigatória é útil quando os parâmetros de associação precisam ser calculado no
tempo de execução, em vez do tempo de design. Com esse padrão, é possível se
vincular a associações de entrada e saída com suporte instantaneamente no código
da função.
Defina uma associação obrigatória da seguinte maneira:
Não inclua um atributo em na assinatura de função para as associações
obrigatórias desejadas.
Passe um parâmetro de entrada Binder binder ou IBinder binder .
Use o padrão de C# a seguir para realizar a associação de dados.
using (var output = await binder.BindAsync<T>(new

BindingTypeAttribute(...)))
{
...
}
BindingTypeAttribute é o atributo do .NET que define a associação, e T é

um tipo de entrada ou saída com suporte nesse tipo de associação. T não
pode ser um tipo de parâmetro out (como out JObject ). Por exemplo, a
associação de saída de tabela de aplicativos móveis dá suporte a seis tipos de
saída, mas você só pode usar ICollector @ no__t-2T > ou IAsyncCollector @
no__t-4T suporta > com associação imperativa.
Exemplo de atributo único
O código de exemplo a seguir cria uma associação de saída do Armazenamento de
Blobs com o caminho do blob definido em tempo de execução e grava uma cadeia
de caracteres no blob.
public static class IBinderExample
{
[FunctionName("CreateBlobUsingBinder")]
[QueueTrigger("myqueue-items-source-4")] string myQueueItem,
IBinder binder,
ILogger log)
{
log.LogInformation($"CreateBlobUsingBinder function processed:
{myQueueItem}");
using (var writer = binder.Bind<TextWriter>(new BlobAttribute(
$"samples-output/{myQueueItem}", FileAccess.Write)))
{
writer.Write("Hello World!");
};
}
}
BlobAttribute define a associação de entrada ou saída do Armazenamento de Blobs

e TextWriter é um tipo de associação de saída com suporte.
Exemplo de atributo múltiplo
O exemplo anterior obtém a configuração do aplicativo para a cadeia de conexão da
conta de armazenamento principal do aplicativo de funções (que é
AzureWebJobsStorage ). É possível especificar uma configuração de aplicativo
personalizada a ser usada para a conta de armazenamento adicionando
StorageAccountAttribute e passando a matriz de atributos para BindAsync<T>() .
Use um parâmetro Binder , não IBinder . Por exemplo:
public static class IBinderExampleMultipleAttributes

{
[FunctionName("CreateBlobInDifferentStorageAccount")]
public async static Task RunAsync(
[QueueTrigger("myqueue-items-source-binder2")] string myQueueItem,
Binder binder,
ILogger log)
{
log.LogInformation($"CreateBlobInDifferentStorageAccount function
processed: {myQueueItem}");
var attributes = new Attribute[]
{
new BlobAttribute($"samples-output/{myQueueItem}", FileAccess.Write),
new StorageAccountAttribute("MyStorageAccount")
};
using (var writer = await binder.BindAsync<TextWriter>(attributes))
{
await writer.WriteAsync("Hello World!!");
}
}
}
Esta tabela mostra as associações com suporte nas duas versões principais do
tempo de execução de Azure Functions:
Armazenam ✔ ✔ ✔ ✔ ✔
ento de
Blobs
eventos
Eventos
WebHooks ✔ ✔ ✔ ✔
de & de
HTTP
Graph
Excel
tabelas
OneDrive
Microsoft
Graph
Microsoft ✔ ✔
Graph
Outlook
email
Graph
events
Tokens de ✔ ✔
Auth
Microsoft
Graph
Móveis
Hubs de ✔ ✔
Notificação
Armazenam ✔ ✔ ✔ ✔
ento de
filas
Barramento ✔ ✔ ✔ ✔
de Serviço
SignalR ✔ ✔ ✔
Armazenam ✔ ✔ ✔ ✔
ento de
tabelas
Timer ✔ ✔ ✔
Twilio ✔ ✔ ✔
1 no tempo de execução da versão 2. x, todas as associações, exceto http e Timer,
devem ser registradas. Consulte registrar extensões de associação. Todas as

associações 2. x com suporte também têm suporte na versão 3. x, salvo indicação
em contrário.
Próximas etapas
Saiba mais sobre gatilhos e associações
Saiba mais sobre práticas recomendadas do Azure Functions
Referência do desenvolvedor de scripts C# (.csx) do
Azure Functions
Este artigo é uma introdução ao desenvolvimento do Azure Functions usando o script C# ( .csx).
O Azure Functions oferece suporte às linguagens de programação C# e script C#. Se você estiver procurando
diretrizes sobre usar C# em um projeto de biblioteca de classes do Visual Studio, consulte Referência do
desenvolvedor C#.
Este artigo pressupõe que você já tenha lido o Guia de desenvolvedores do Azure Functions.
Como o .csx funciona

A experiência de scripts C# do Azure Functions baseia-se no SDK do Azure WebJobs. Fluxos de dados na sua
função C# por meio de argumentos de método. Os nomes de argumentos são especificados em um arquivo
function.json , e há nomes predefinidos para acessar itens como a função logger e os tokens de cancelamento.
O formato .csx permite escrever menos “texto clichê” e se concentrar apenas em escrever uma função C#. Em vez
de encapsular tudo em um namespace e uma classe, basta definir um método Run . Inclua todas as referências de
assembly e todos os namespaces no início do arquivo, como de costume.
Arquivos .csx do aplicativo de função são compilados quando uma instância é inicializada. Nessa etapa de
compilação, coisas como a inicialização a frio podem levar mais tempo para funções de script C# em comparação a
bibliotecas de classes do C#. Essa etapa de compilação também mostra porque funções do script C# são editáveis
no portal do Azure enquanto objetos visuais do C# não são.
Estrutura de pastas
A estrutura de pastas para um projeto de script C# é semelhante à seguinte:
FunctionsProject
| - MyFirstFunction
| | - run.csx
| | - function.json
| | - function.proj
| | - 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ções. Cada função
possui seu próprio arquivo de código (.csx) e arquivo de configuração de associação (function.json).
As extensões de associação necessárias na versão 2.x do tempo de execução do Functions são definidas no arquivo
extensions.csproj , com os arquivos de biblioteca reais na pasta bin . Ao desenvolver localmente, você precisa
registrar as extensões de associação. Ao desenvolver funções no portal do Azure, esse registro é feito para você.
Binding para argumentos

Dados de entrada ou de saída são associados a um parâmetro de função de script C# por meio da propriedade
name no arquivo de configuração function.json. O exemplo a seguir mostra um arquivo function.json e arquivo
run.csx para uma função disparada por fila. O parâmetro que recebe dados da mensagem da fila é chamado de
myQueueItem porque esse é o valor de propriedade name .
{
"disabled": false,
"bindings": [
{
"direction": "in",
"connection":"MyStorageConnectionAppSetting"
}
]
}
#r "Microsoft.WindowsAzure.Storage"
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 instrução #r será explicada mais adiante neste artigo.
Tipos com suporte para associações

Cada associação tem seus próprios tipos com suporte. Por exemplo, um gatilho de blob pode ser usado com um
parâmetro de cadeia de caracteres, um parâmetro POCO, um parâmetro CloudBlockBlob ou qualquer um dos
vários outros tipos com suporte. O artigo de referência de associação para associações de blob lista todos os tipos
de parâmetro com suporte para gatilhos de blob. Para obter mais informações, consulte Gatilhos e associações e
os documentos de referência de associação para cada tipo de associação.
TIP
Se você planeja usar as ligações HTTP ou WebHook, planeje evitar o esgotamento de porta que pode ser causado pela
instanciação incorreta do HttpClient . Para saber mais, confira Como gerenciar conexões no Azure Functions.
Referenciando classes personalizadas

Se precisa usar uma classe de objeto CRL básico (POCO ) personalizada, você pode incluir a definição de classe
dentro do mesmo arquivo ou colocá-la em um arquivo separado.
O exemplo a seguir mostra um 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 getter e setter definidos para cada propriedade.
Reutilização de código .csx

Você pode usar classes e métodos definidos em outros arquivos .csx no seu arquivo run.csx. Para fazer isso, use
diretivas #load no arquivo run.csx. No exemplo a seguir, uma rotina de log chamada MyLogger é compartilhada
em myLogger.csx e carregada em run.csx usando a diretiva #load :
Exemplo de run.csx:
#load "mylogger.csx"
public static void Run(TimerInfo myTimer, ILogger log)

{
log.LogInformation($"Log by run.csx: {DateTime.Now}");
MyLogger(log, $"Log by MyLogger: {DateTime.Now}");
}
Exemplo de 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 tipar fortemente os argumentos
transmitidos entre as funções usando um objeto POCO. No seguinte exemplo simplificado, um gatilho HTTP e um
gatilho de fila compartilham um objeto POCO chamado Order para tipar fortemente os dados do pedido:
Exemplo run.csx para o gatilho HTTP:
#load "..\shared\order.csx"
using System.Net;
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 o gatilho da fila:
#load "..\shared\order.csx"
using System;
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 diretiva #load :

#load "mylogger.csx" carrega um arquivo localizado na pasta de função.
#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 que a pasta de
função, ou seja, diretamente em wwwroot.
A diretiva #load só funciona com arquivos .csx, não com arquivos .cs.
Associando ao valor de retorno do método

Use um valor retornado de um método em uma associação de saída, usando o nome $return em function.json.
Para obter exemplos, consulte Gatilhos e associações.
Use o valor retornado apenas se uma execução de função com êxito sempre resultar em um valor retornado a ser
passado 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 associação de saída ou se uma invocação de função com êxito não resultar em
nada a ser passado para a associação de saída, use os tipos ICollector 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!");
}
Registro em log
A saída de log para logs de streaming em C#, inclue um argumento do tipo ILogger. Recomendamos nomeá-lo
como log . Evite usar Console.Write no Azure Functions.
public static void Run(string myBlob, ILogger log)

{
log.LogInformation($"C# Blob trigger function processed: {myBlob}");
}
NOTE
Para obter informações sobre uma estrutura de log mais recente que pode ser usada no lugar de TraceWriter , consulte
Gravar logs nas funções C# no artigo Monitorar o Azure Functions.
Assíncrono
Para tornar uma função assíncrona, use a palavra-chave async e retorne um objeto Task .
public async static Task ProcessQueueMessageAsync(

string blobName,
Stream blobInput,
Stream blobOutput)
{
await blobInput.CopyToAsync(blobOutput, 4096);
}
Não é possível usar parâmetros out em funções assíncronas. Para associações de saída, use o valor de retorno de
função ou um objeto coletor.
Tokens de cancelamento
Uma função pode aceitar um parâmetro CancellationToken que permite ao sistema operacional notificar seu
código quando a função está prestes a ser encerrada. Você pode usar essa notificação para certificar-se de que a
função não finalize inesperadamente de uma maneira que os dados fiquem em um estado inconsistente.
O exemplo a seguir mostra como verificar o encerramento da função iminente.
using System;
using System.IO;
using System.Threading;

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ê poderá fazer como geralmente faz, com a cláusula using .
using System.Net;
public static Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger log)
Os seguintes namespaces são automaticamente importados e, portanto, são opcionais:

System
System.Collections.Generic
System.IO
System.Linq
System.Net.Http
System.Threading.Tasks
Microsoft.Azure.WebJobs
Microsoft.Azure.WebJobs.Host
Referenciando assemblies externos
Para assemblies da estrutura, adicione referências usando a diretiva #r "AssemblyName" .
#r "System.Web.Http"
using System.Net;
using System.Net.Http;
public static Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger log)
Os seguintes assemblies são adicionados automaticamente pelo ambiente de hospedagem do Azure Functions:
mscorlib
System
System.Core
System.Xml
System.Net.Http
Microsoft.Azure.WebJobs.Extensions
System.Web.Http
System.Net.Http.Formatting
Os seguintes assemblies podem ser referenciados por um nome simples (por exemplo, #r "AssemblyName" ):
Newtonsoft.Json
Microsoft.WindowsAzure.Storage
Microsoft.ServiceBus
Microsoft.AspNet.WebHooks.Receivers
Microsoft.AspNet.WebHooks.Common
Microsoft.Azure.NotificationHubs
Referenciando assemblies personalizados

Para referenciar um assembly personalizado, use um assembly compartilhado ou particular:
Assemblies compartilhados são compartilhados entre todas as funções em um aplicativo de funções. Para
fazer referência a um assembly personalizado, carregue o assembly em uma pasta chamada bin em sua
pasta raiz do aplicativo de funções (wwwroot).
Assemblies particulares fazem parte do contexto de determinada função e dão suporte ao sideload de
versões diferentes. Os assemblies particulares devem ser carregados em uma pasta bin do diretório da
função. Referencie os assemblies usando o nome de arquivo, como #r "MyAssembly.dll" .
Para obter informações sobre como carregar arquivos na pasta da função, consulte a seção sobre gerenciamento
de pacotes.
Diretórios inspecionados
O diretório que contém o arquivo de script da função é inspecionado automaticamente quanto às alterações nos
assemblies. Para inspecionar alterações de assembly em outros diretórios, adicione-os à lista watchDirectories em
host.json.
Usando pacotes NuGet

Para usar os pacotes NuGet em uma função 2 C# . x, carregue um arquivo Function. proj para a pasta da função no
sistema de arquivos do aplicativo de funções. Este é um arquivo function.proj de exemplo 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>
Para usar um feed do NuGet personalizado, especifique o feed em um arquivo Nuget.Config na raiz do Aplicativo
de Funções. Para obter mais informações, consulte Configurando o comportamento do NuGet.
NOTE
Em funções 1. C# x, os pacotes NuGet são referenciados com um arquivo Project. JSON em vez de um arquivo Function. proj
.
Para funções 1. x, use um arquivo Project. JSON em vez disso. Aqui está um exemplo de arquivo Project. JSON :
{
"frameworks": {
"net46":{
"dependencies": {
"Microsoft.ProjectOxford.Face": "1.1.0"
}
}
}
}
Usando um arquivo function. proj

1. Abra a função no portal do Azure. A guia logs exibe o resultado da instalação do pacote.
2. Para carregar um arquivo Function. proj , use um dos métodos descritos em como atualizar os arquivos do
aplicativo de funções no tópico Azure Functions referência do desenvolvedor.
3. Depois que o arquivo Function. proj for carregado, você verá uma saída semelhante ao exemplo a seguir no log
de streaming da função:
2018-12-14T22:00:48.658 [Information] Restoring packages.

2018-12-14T22:00:48.681 [Information] Starting packages restore
2018-12-14T22:00:57.064 [Information] Restoring packages for D:\local\Temp\9e814101-fe35-42aa-ada5-
f8435253eb83\function.proj...
2016-04-04T19:02:50.511 Restoring packages for D:\home\site\wwwroot\HttpTriggerCSharp1\function.proj...
2018-12-14T22:01:00.844 [Information] Installing Newtonsoft.Json 10.0.2.
2018-12-14T22:01:01.041 [Information] Installing Microsoft.ProjectOxford.Common.DotNetStandard 1.0.0.
2018-12-14T22:01:01.140 [Information] Installing Microsoft.ProjectOxford.Face.DotNetStandard 1.0.0.
2018-12-14T22:01:09.799 [Information] Restore completed in 5.79 sec for D:\local\Temp\9e814101-fe35-42aa-ada5-
f8435253eb83\function.proj.
2018-12-14T22:01:10.905 [Information] Packages restored.
System.Environment.GetEnvironmentVariable , conforme mostrado no exemplo de código a seguir:
{
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);
}
Associando no runtime
No C#, e em outras linguagens .NET, você pode usar um padrão de associação obrigatório, em vez de associações
declarativas em function.json. A associação obrigatória é útil quando os parâmetros de associação precisam ser
calculado no runtime, em vez do tempo de design. Com esse padrão, é possível se vincular a associações de
entrada e saída com suporte instantaneamente no código da função.
Defina uma associação obrigatória da seguinte maneira:
Não inclua uma entrada em function.json para as associações obrigatórias desejadas.
Passe um parâmetro de entrada Binder binder ou IBinder binder .
Use o padrão de C# a seguir para realizar a associação de dados.
using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))

{
...
}
BindingTypeAttribute é o atributo do .NET que define a associação, e T é um tipo de entrada ou saída com
suporte nesse tipo de associação. T não pode ser um tipo de parâmetro out (como out JObject ). Por exemplo, a
associação de saída de tabela de aplicativos móveis dá suporte a 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 associação de saída do Armazenamento de Blobs com o caminho do blob
definido em tempo de execução e grava uma cadeia de caracteres no blob.
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 associação de entrada ou saída do Armazenamento de Blobs e TextWriter é um tipo de

associação de saída com suporte.
Exemplo de atributo múltiplo
O exemplo anterior obtém a configuração do aplicativo para a cadeia de conexão da conta de armazenamento
principal do aplicativo de funções (que é AzureWebJobsStorage ). É possível especificar uma configuração de
aplicativo personalizada a ser usada para a conta de armazenamento adicionando StorageAccountAttribute e
passando a matriz de atributos para BindAsync<T>() . Use um parâmetro Binder , não IBinder . Por exemplo:
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 no qual eles são definidos.
ASSOCIAÇÃO ATRIBUTO ADICIONAR REFERÊNCIA
Cosmos DB Microsoft.Azure.WebJobs.DocumentDBAttribute
#r
"Microsoft.Azure.WebJobs.Extensions.CosmosDB"
Hubs de evento Microsoft.Azure.WebJobs.ServiceBus.EventHubAttribute

#r
, "Microsoft.Azure.Jobs.ServiceBus"
Microsoft.Azure.WebJobs.ServiceBusAccountAttribute
Aplicativos 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.NotificationHu
Service Bus Microsoft.Azure.WebJobs.ServiceBusAttribute

#r
"Microsoft.Azure.WebJobs.ServiceBus"
,
Microsoft.Azure.WebJobs.ServiceBusAccountAttribute
Fila de armazenamento Microsoft.Azure.WebJobs.QueueAttribute

,
Microsoft.Azure.WebJobs.StorageAccountAttribute
Armazenamento de blobs Microsoft.Azure.WebJobs.BlobAttribute

,
Tabela de armazenamento Microsoft.Azure.WebJobs.TableAttribute

,
Twilio Microsoft.Azure.WebJobs.TwilioSmsAttribute
#r
"Microsoft.Azure.WebJobs.Extensions.Twilio"
Próximos passos
Saiba mais sobre gatilhos e associações
Saiba mais sobre práticas recomendadas do Azure Functions
Referência do desenvolvedor em F# do Azure
Functions
F# para Azure Functions é uma solução para executar facilmente pequenos trechos de código, ou
"funções", na nuvem. Fluxos de dados em sua função F# por meio de argumentos de função. Os nomes
de argumentos são especificados em function.json e há nomes predefinidos para acessar itens como a
função logger e os tokens de cancelamento.
IMPORTANT
O script F# (.fsx) só tem suporte da versão 1.x do tempo de execução do Azure Functions. Se você desejar usar o
F# com o tempo de execução da versão 2.x, deverá usar um projeto de biblioteca de classes F# pré-compilado (.fs).
Crie, gerencie e publique um projeto de biblioteca de classe F# usando o Visual Studio como faria com um projeto
de biblioteca de classe C#. Para saber mais sobre as versões do Functions, confira Visão geral de versões de tempo
de execução do Azure Functions.
Este artigo pressupõe que você já tenha lido a referência do desenvolvedor do Azure Functions.
Como funciona o .fsx

Um arquivo .fsx é um script de F#. Ele pode ser considerado um projeto em F# contido em um único
arquivo. O arquivo contém o código para seu programa (nesse caso, o Azure Function) e diretivas para
gerenciar as dependências.
Quando você usa um .fsx para um Azure Function, os assemblies normalmente exibidos são incluídos
automaticamente, permitindo que você se concentre na função em vez do código "clichê".
Estrutura de pastas
A estrutura de pastas para um projeto de script F# é semelhante à seguinte:
FunctionsProject
| - MyFirstFunction
| | - run.fsx
| | - function.json
| | - function.proj
| | - run.fsx
| | - function.json
| | - function.proj
| - host.json
| - bin
Há um arquivo host.json compartilhado que pode ser usado para configurar o aplicativo de funções. Cada
função possui seu próprio arquivo de código (.fsx) e arquivo de configuração de associação (function.json).
As extensões de associação necessárias na versão 2.x do tempo de execução do Functions são definidas
no arquivo extensions.csproj , com os arquivos de biblioteca reais na pasta bin . Ao desenvolver
localmente, você precisa registrar as extensões de associação. Ao desenvolver funções no portal do Azure,
esse registro é feito para você.
Binding para argumentos

Cada associação oferece suporte a um conjunto de argumentos, conforme detalhado na Referências de
gatilhos e de associações do Azure Functions para desenvolvedores. Por exemplo, uma das associações de
argumento com suporte de um gatilho de blob é um POCO, que pode ser expresso usando um registro
em F#. Por exemplo:
type Item = { Id: string }
let Run(blob: string, output: byref<Item>) =

let item = { Id = "Some ID" }
output <- item
O Azure Function em F# usará um ou mais argumentos. Quando falamos sobre os argumentos do Azure
Functions, nos referimos a argumentos de entrada e argumentos de saída. Um argumento de entrada é
exatamente o que parece: uma entrada para o Azure Function em F#. Um argumento de saída são dados
mutáveis ou um argumento byref<> que serve como uma maneira de passar dados de volta saindo de
sua função.
No exemplo acima, blob é um argumento de entrada e output é um argumento de saída. Observe que
utilizamos byref<> para output (não é necessário adicionar a anotação [<Out>] ). O uso de um tipo
byref<> permite que sua função altere o registro ou o objeto ao qual o argumento se refere.
Quando um registro em F# é usado como um tipo de entrada, a definição de registro deve ser marcada
com [<CLIMutable>] para permitir que a estrutura do Azure Functions defina os campos adequadamente
antes de passar o registro para a função. Nos bastidores, [<CLIMutable>] gera setters para as
propriedades de registro. Por exemplo:
[<CLIMutable>]
type TestObject =
{ SenderName : string
Greeting : string }
let Run(req: TestObject, log: ILogger) =

{ req with Greeting = sprintf "Hello, %s" req.SenderName }
Uma classe de F# também pode ser usada para ambos os argumentos. Para uma classe, as propriedades
geralmente exigirão getters e setters. Por exemplo:
type Item() =
member val Id = "" with get,set
member val Text = "" with get,set
let Run(input: string, item: byref<Item>) =

let result = Item(Id = input, Text = "Hello from F#!")
item <- result
Registrando em log
Para registrar a saída em seus logs de streaming em F#, sua função deve usar um argumento do tipo
ILogger. Para manter a consistência, recomendamos que esse argumento seja denominado log . Por
exemplo:
let Run(blob: string, output: byref<string>, log: ILogger) =
log.LogInformation(sprintf "F# Azure Function processed a blob: %s" blob)
output <- input
Assíncrono
O fluxo de trabalho de async pode ser usado, mas o resultado precisa retornar um Task . Isso pode ser
feito com Async.StartAsTask , por exemplo:
let Run(req: HttpRequestMessage) =

async {
return new HttpResponseMessage(HttpStatusCode.OK)
} |> Async.StartAsTask
Token de cancelamento
Se a sua função precisar manipular o desligamento com cuidado, atribua um argumento
CancellationToken . Isso pode ser combinado com async , por exemplo:
let Run(req: HttpRequestMessage, token: CancellationToken)

let f = async {
do! Async.Sleep(10)
return new HttpResponseMessage(HttpStatusCode.OK)
}
Async.StartAsTask(f, token)
Importando namespaces
É possível abrir os namespaces como de costume:
open System.Net
open System.Threading.Tasks
open Microsoft.Extensions.Logging
let Run(req: HttpRequestMessage, log: ILogger) =

...
Os namespaces a seguir são abertos automaticamente:

System
System.Collections.Generic
System.IO
System.Linq
System.Net.Http
System.Threading.Tasks
Microsoft.Azure.WebJobs.Host .
Referenciando Assemblies Externos

Da mesma forma, referências ao assembly da estrutura podem ser adicionadas com a diretiva
#r "AssemblyName" .
#r "System.Web.Http"
open System.Net
open System.Net.Http
open System.Threading.Tasks
let Run(req: HttpRequestMessage, log: ILogger) =

...
Os seguintes assemblies são adicionados automaticamente pelo ambiente de hospedagem do Azure

Functions:
mscorlib ,
System
System.Core
System.Xml
System.Net.Http
Microsoft.Azure.WebJobs.Extensions
System.Web.Http
System.Net.Http.Formatting .
Além disso, os seguintes assemblies têm regras de maiúsculas e minúsculas especiais e podem ser
referenciados por simplename (por exemplo, #r "AssemblyName" ):
Newtonsoft.Json
Microsoft.WindowsAzure.Storage
Microsoft.ServiceBus
Microsoft.AspNet.WebHooks.Receivers
Microsoft.AspNEt.WebHooks.Common .
Se precisar fazer referência a um assembly particular, carregue o arquivo do assembly em uma pasta bin
relativa à sua função e faça referência a ela usando o nome do arquivo (por exemplo, #r "MyAssembly.dll"
). Para obter informações sobre como carregar arquivos na pasta da função, consulte a seção a seguir
sobre gerenciamento de pacotes.
Prelúdio do editor
Um editor que oferece suporte aos Serviços de compilador em F# não estará ciente dos namespaces e
assemblies que o Azure Functions inclui automaticamente. Dessa forma, pode ser útil incluir um prelúdio
que ajuda o editor a encontrar os assemblies que você está usando e a abrir explicitamente os
namespaces. Por exemplo:
#if !COMPILED
#I "../../bin/Binaries/WebJobs.Script.Host"
#r "Microsoft.Azure.WebJobs.Host.dll"
#endif
open System
open Microsoft.Azure.WebJobs.Host
let Run(blob: string, output: byref<string>, log: ILogger) =

...
Quando o Azure Functions executa seu código, ele processa o código-fonte com COMPILED definido, e o
prelúdio do editor é ignorado.
Gerenciamento de pacote
Para usar os pacotes do NuGet em uma função F#, adicione um arquivo project.json à pasta da função,
no sistema de arquivos do aplicativo de funções. Veja um exemplo de arquivo project.json que adiciona
uma referência do pacote NuGet ao Microsoft.ProjectOxford.Face versão 1.1.0:
{
"frameworks": {
"net46":{
"dependencies": {
"Microsoft.ProjectOxford.Face": "1.1.0"
}
}
}
}
Somente o .NET Framework 4.6 tem suporte. Desse modo, tenha certeza de que o arquivo project.json
especifica net46 , como mostrado aqui.
Quando você carrega um arquivo project.json , o tempo de execução obtém os pacotes e adiciona
referências automaticamente aos assemblies do pacote. Você não precisa adicionar diretivas
#r "AssemblyName" . Basta adicionar as instruções open necessárias ao seu arquivo .fsx .
Talvez você queira colocar automaticamente assemblies de referência no prelúdio de seu editor, para
melhorar a interação do editor com os Serviços de compilação em F#.
Como adicionar um arquivo project.json ao Azure Function
1. Comece verificando se o aplicativo está em execução, o que pode ser feito abrindo a função no portal
do Azure. Isso também permite acessar os logs de streaming nos quais a saída da instalação do pacote
será exibida.
2. Para carregar um arquivo project.json , use um dos métodos descritos em Como atualizar os
arquivos de aplicativo de funções. Se você estiver usando a Implantação contínua para o Azure
Functions, adicione um arquivo project.json à sua ramificação de preparo a fim de testar antes de
adicioná-lo à sua ramificação de implantação.
3. Depois que o arquivo project.json for adicionado, você verá uma saída semelhante ao exemplo a
seguir em seu log de streaming da função:
2016-04-04T19:02:48.745 Restoring packages.
2016-04-04T19:02:48.745 Starting NuGet restore
2016-04-04T19:02:50.183 MSBuild auto-detection: using msbuild version '14.0' from 'D:\Program Files
(x86)\MSBuild\14.0\bin'.
2016-04-04T19:02:50.261 Feeds used:
2016-04-04T19:02:50.261 C:\DWASFiles\Sites\facavalfunctest\LocalAppData\NuGet\Cache
2016-04-04T19:02:50.261 https://api.nuget.org/v3/index.json
2016-04-04T19:02:50.261
2016-04-04T19:02:50.511 Restoring packages for D:\home\site\wwwroot\HttpTriggerCSharp1\Project.json...
2016-04-04T19:02:52.800 Installing Newtonsoft.Json 6.0.8.
2016-04-04T19:02:52.800 Installing Microsoft.ProjectOxford.Face 1.1.0.
2016-04-04T19:02:57.095 All packages are compatible with .NETFramework,Version=v4.6.
2016-04-04T19:02:57.189
2016-04-04T19:02:57.189
2016-04-04T19:02:57.455 Packages restored.
System.Environment.GetEnvironmentVariable , por exemplo:
open System.Environment
let Run(timer: TimerInfo, log: ILogger) =

log.LogInformation("Storage = " + GetEnvironmentVariable("AzureWebJobsStorage"))
log.LogInformation("Site = " + GetEnvironmentVariable("WEBSITE_SITE_NAME"))
Reutilizar o código .fsx

Você pode usar código de outros arquivos .fsx usando uma diretiva #load . Por exemplo:
run.fsx
#load "logger.fsx"
let Run(timer: TimerInfo, log: ILogger) =

mylog log (sprintf "Timer: %s" DateTime.Now.ToString())
logger.fsx
let mylog(log: ILogger, text: string) =

log.LogInformation(text);
Os caminhos fornecidos para a diretiva #load são relativos ao local de seu arquivo .fsx .
#load "logger.fsx" carrega um arquivo localizado na pasta de função.
#load "package\logger.fsx" carrega um arquivo localizado na pasta package na pasta da função.
#load "..\shared\mylogger.fsx" carrega um arquivo localizado em uma pasta shared no mesmo nível
que a pasta de função, ou seja, diretamente em wwwroot .
A diretiva #load só funciona com arquivos .fsx (script em F#) e não com arquivos .fs .
Próximas etapas
Para saber mais, consulte os recursos a seguir:
Guia de F#
Práticas recomendadas para o Azure Functions
Gatilhos e associações de Azure Functions
Teste do Azure Functions
Dimensionamento do Azure Functions
Guia do desenvolvedor de JavaScript do Azure
Functions
Este guia contém informações sobre as complexidades de escrever Azure Functions com JavaScript.
Uma função JavaScript é um function exportado que é executado quando acionado ( acionadores são
configurados em function.json). O primeiro argumento passado para cada função é um objeto context , que é
usado para receber e enviar dados de associação, registro em log e comunicação com o tempo de execução.
Este artigo pressupõe que você já tenha lido a Referência do desenvolvedor do Azure Functions. Conclua o início
rápido do Functions para criar sua primeira função, usando Visual Studio Code ou no portal.
Este artigo também dá suporte ao desenvolvimento de aplicativos TypeScript.
Estrutura de pastas
A estrutura de pastas necessárias para um projeto JavaScript é semelhante à seguinte. Este padrão pode ser
alterado. Para mais informações, consulte a seção scriptArquivo abaixo.
FunctionsProject
| - MyFirstFunction
| | - index.js
| | - function.json
| | - index.js
| | - function.json
| - SharedCode
| | - myFirstHelperFunction.js
| | - mySecondHelperFunction.js
| - node_modules
| - host.json
| - package.json
Na raiz do projeto, há um arquivo host.json compartilhado que pode ser usado para configurar o aplicativo de
funções. Cada função tem uma pasta com seu próprio arquivo de código (.js) e o arquivo de configuração de
associação (function.json). O nome do diretório pai de function.json é sempre o nome da sua função.
As extensões de associação necessárias na versão 2.x do tempo de execução do Functions são definidas no arquivo
extensions.csproj , com os arquivos de biblioteca reais na pasta bin . Ao desenvolver localmente, você precisa
registrar as extensões de associação. Ao desenvolver funções no portal do Azure, esse registro é feito para você.
Exportando uma função

As funções JavaScript precisam ser exportadas por meio de module.exports (ou exports ). Sua função exportada
deve ser uma função JavaScript que é executada quando acionada.
Por padrão, o tempo de execução de Funções procura sua função em index.js , onde index.js compartilha o
mesmo diretório pai que o function.json correspondente. No caso padrão, sua função exportada deve ser a única
exportação de seu arquivo ou a exportação denominada run ou index . Para configurar o local do arquivo e o
nome de exportação da função, leia Configurando o ponto de entrada da função abaixo.
Sua função exportada é passada um número de argumentos na execução. O primeiro argumento é sempre um
objeto context . Se sua função for síncrona (não retorna uma promessa), você deve passar o objeto context , já
que a chamada context.done é necessária para uso correto.
// You should include context, other arguments are optional

module.exports = function(context, myTrigger, myInput, myOtherInput) {
// function logic goes here :)
context.done();
};
Exportando uma função assíncrona

Ao usar a declaração async function ou o JavaScript simples Promises na versão 2.x do tempo de execução
Functions, não é necessário chamar explicitamente o context.done retorno de chamada para sinalizar que sua
função foi concluída. Sua função é concluída quando a função assíncrona exportada / Promise é concluída. Para
funções que visam o tempo de execução da versão 1.x, você ainda deve chamar context.done quando seu código
terminar de ser executado.
O exemplo a seguir é uma função simples que registra que foi acionada e imediatamente conclui a execução.

context.log('JavaScript trigger function processed a request.');
};
Ao exportar uma função assíncrona, você também pode configurar uma ligação de saída para obter o valor return
. Isso é recomendado se você tiver apenas uma associação de saída.
Para atribuir uma saída usando return , altere o name propriedade a ser $return em function.json .
{
"type": "http",
"direction": "out",
"name": "$return"
}
Nesse caso, sua função deve se parecer com o seguinte exemplo:

// You can call and await an async method here
return {
body: "Hello, world!"
};
}
Associações
Em JavaScript, ligações são configuradas e definidas na função function.json. As funções interagem com as ligações
de várias maneiras.
Entradas
As entradas são divididas em duas categorias no Azure Functions: uma é a entrada de gatilho e a outra é a entrada
adicional. Trigger e outras ligações de entrada (ligações de direction === "in" ) podem ser lidas por uma função de
três maneiras:
[Recomendado] Como parâmetros passados para sua função. Eles são passados para a função na
mesma ordem em que são definidos function.json. A propriedade name definida em Function. JSON não
precisa corresponder ao nome do parâmetro, embora deva ser.
module.exports = async function(context, myTrigger, myInput, myOtherInput) { ... };
Como os membros de context.bindings objeto. Observe que a propriedade name definida em

function.json não precisa corresponder ao nome do seu parâmetro, embora deva....
module.exports = async function(context) {

context.log("This is myTrigger: " + context.bindings.myTrigger);
context.log("This is myInput: " + context.bindings.myInput);
context.log("This is myOtherInput: " + context.bindings.myOtherInput);
};
Como entradas usando o arguments objeto JavaScript. Isso é essencialmente o mesmo que passar
entradas como parâmetros, mas permite que você manipule dinamicamente entradas.

context.log("This is myTrigger: " + arguments[1]);
context.log("This is myInput: " + arguments[2]);
context.log("This is myOtherInput: " + arguments[3]);
};
outputs
As saídas (ligações de direction === "out" ) podem ser gravadas por uma função de várias maneiras. Em todos os
casos, a propriedade name da ligação, conforme definido em function.json, corresponde ao nome do membro do
objeto gravado na sua função.
Você pode atribuir dados a associações de saída de uma das seguintes maneiras (não Combine esses métodos):
[Recomendado para várias saídas] Retornando um objeto. Se você estiver usando uma função de
retorno de Async/Promise, poderá retornar um objeto com os dados de saída atribuídos. No exemplo
abaixo, as ligações de saída são nomeadas "httpResponse" e "queueOutput" em function.json.

let retMsg = 'Hello, world!';
return {
httpResponse: {
body: retMsg
},
queueOutput: retMsg
};
};
Se você estiver usando uma função síncrona, você pode retornar este objeto usando context.done (veja o
exemplo).
[Recomendado para saída única] Retornando um valor diretamente e usando o nome de ligação $
return. Isso funciona apenas para as funções de retorno assíncrono / Promessa. Veja o exemplo em
exportando uma função assíncrona.
Atribuindo valores a serem context.bindings você pode atribuir valores diretamente para Context.
Bindings.
context.bindings.httpResponse = {
body: retMsg
};
context.bindings.queueOutput = retMsg;
return;
};
Tipo de dados de associações

Para definir o tipo de dados para uma associação de entrada, use a propriedade dataType na definição de
associação. Por exemplo, para ler o conteúdo de uma solicitação HTTP em formato binário, use o tipo binary :
{
"name": "req",
"direction": "in",
"dataType": "binary"
}
As opções para dataType são: binary , stream e string .
objeto de contexto
O tempo de execução usa um objeto context para passar dados de/para sua função e permitir que você se
comunique com o tempo de execução. O objeto de contexto pode ser usado para ler e definir os dados de
associações, gravar logs e usando o context.done retorno de chamada quando a função exportada é síncrona.
O context objeto é sempre o primeiro parâmetro para uma função. Deve ser incluído porque tem métodos
importantes, como context.done e context.log . Você pode nomear o objeto de acordo com a sua preferência (por
exemplo, ctx ou c ).
// You must include a context, but other arguments are optional

module.exports = function(ctx) {
ctx.done();
};
Propriedade context.bindings
context.bindings
Retorna um objeto nomeado que é usado para ler ou atribuir dados de associação. Dados de associação de entrada
e gatilho podem ser acessados pela leitura de propriedades em context.bindings . Os dados de associação de saída
podem ser atribuídos adicionando dados a context.bindings
Por exemplo, as seguintes definições de ligação em sua função.json permitem acessar o conteúdo de uma fila de
context.bindings.myInput e atribuir saídas a uma fila usando context.bindings.myOutput .
{
"type":"queue",
"direction":"in",
"name":"myInput"
...
},
{
"type":"queue",
"direction":"out",
"name":"myOutput"
...
}
// myInput contains the input data, which may have properties such as "name"
var author = context.bindings.myInput.name;
// Similarly, you can set your output data
context.bindings.myOutput = {
some_text: 'hello world',
a_number: 1 };
Você pode optar por definir os dados de ligação de saída usando o método context.done em vez do objeto
context.binding (veja abaixo).
Propriedade context.bindingData
context.bindingData
Retorna um objeto nomeado que contém dados de invocação de função e os metadados do gatilho ( invocationId ,
sys.methodName , sys.utcNow , sys.randGuid ). Para obter um exemplo de metadados de gatilho, confira este
exemplo de hubs de eventos.
Método context.done
context.done([err],[propertyBag])
Permite que o runtime saiba que seu código foi concluído. Quando sua função usa a declaração async function ,
você não precisa usar context.done() . O context.done retorno de chamada é chamado implicitamente. As funções
assíncronas estão disponíveis no Nó 8 ou em uma versão posterior, que requer a versão 2.x do runtime de Funções.
Se a função não é uma função assíncrona, você precisa chamar context.done para informar ao tempo de
execução que a função está concluída. Os tempos de execução se está ausente.
O método context.done permite que você retorne um erro definido pelo usuário ao tempo de execução e um
objeto JSON que contém dados de associação de saída. As propriedades transmitidas para context.done
sobrescrevem qualquer coisa definida no objeto context.bindings .
// Even though we set myOutput to have:

// -> text: 'hello world', number: 123
context.bindings.myOutput = { text: 'hello world', number: 123 };
// If we pass an object to the done function...
context.done(null, { myOutput: { text: 'hello there, world', noNumber: true }});
// the done method overwrites the myOutput binding to be:
// -> text: 'hello there, world', noNumber: true
Método context.log
context.log(message)
Permite que você grave em logs de função de streaming no nível de rastreamento padrão. No context.log , há
métodos de registro adicionais disponíveis para permitir que você grave logs de função em outros níveis de
rastreamento:
MÉTODO DESCRIÇÃO
error(message) Grava no registro em log no nível do erro, ou em um nível

inferior.
warn(message) Grava no registro em log no nível do aviso, ou em um nível

inferior.
info(message) Grava no registro em log no nível da informação, ou em um

nível inferior.
verbose(message) Grava no registro em log no nível detalhado.
O exemplo a seguir grava um log no nível de rastreamento de aviso:
context.log.warn("Something has happened.");
Você pode configurar o limite do nível de rastreamento para registro em log no arquivo host.json. Para obter mais
informações sobre como gravar logs, confira Gravando saídas de rastreamento abaixo.
Leia Monitorado o Azure Functions para saber mais sobre como exibir e consultar logs de função.
Gravar a saída de rastreamento no console

No Functions, use os métodos context.log para gravar a saída de rastreamento no console. No Functions v2.x, as
saídas de rastreio usando console.log são capturadas no nível do Aplicativo Function. Isso significa que as saídas
de console.log não estão vinculadas a uma invocação de função específica e não são exibidas em logs de uma
função específica. Eles, no entanto, se propagam para o Application Insights. No Functions v1.x, não é possível usar
console.log para gravar no console.
Quando você chama context.log() , sua mensagem é gravada no console no nível de rastreamento padrão, que é
o nível de rastreamento de informações. O código a seguir grava no console no nível de rastreamento de
informações:
context.log({hello: 'world'});
Esse código é equivalente ao código acima:
context.log.info({hello: 'world'});
Esse código grava no console no nível de erro:
context.log.error("An error has occurred.");
Como erro é o nível de rastreamento mais alto, esse rastreamento é gravado na saída em todos os níveis de
rastreamento enquanto o registro em log estiver habilitado.
Todos os métodos context.log dão suporte ao mesmo formato de parâmetro que o método util.format de
Node.js. Considere o código a seguir, que grava logs de função usando o nível de rastreamento padrão:
context.log('Node.js HTTP trigger function processed a request. RequestUri=' + req.originalUrl);

context.log('Request Headers = ' + JSON.stringify(req.headers));
Você também pode escrever o mesmo código no formato a seguir:
context.log('Node.js HTTP trigger function processed a request. RequestUri=%s', req.originalUrl);

context.log('Request Headers = ', JSON.stringify(req.headers));
Configurar o nível de rastreamento para o registro em log no console

O Functions 1.x permite a definição do nível de rastreamento de limite para gravar no console, o que facilita o
controle do modo de gravação dos rastreamentos no console da sua função. Para definir o limite para todos os
rastreamentos gravados no console, use a propriedade tracing.consoleLevel no arquivo host.json. Essa
configuração se aplica a todas as funções em seu aplicativo de função. O exemplo a seguir define o limite de
rastreamento para habilitar o registro em log detalhado:
{
"tracing": {
"consoleLevel": "verbose"
}
}
Os valores de consoleLevel correspondem aos nomes dos métodos context.log . Para desabilitar todo o registro
em log do rastreamento no console, defina consoleLevel como off. Para obter mais informações, consulte a
referência para host.json.
Gatilhos e associações HTTP

HTTP e gatilhos de webhook e associações de saída HTTP usam objetos de solicitação e resposta para representar
as mensagens HTTP.
Objeto da solicitação
O objeto context.req (solicitação) tem as seguintes propriedades:
body Um objeto que contém o corpo da solicitação.
headers Um objeto que contém os cabeçalhos da solicitação.
method O método HTTP da solicitação.
originalUrl A URL da solicitação.
params Um objeto que contém os parâmetros de roteamento da

solicitação.
query Um objeto que contém os parâmetros da consulta.

rawBody O corpo da mensagem como uma cadeia de caracteres.
Objeto de resposta
O objeto context.res (resposta) tem as seguintes propriedades:
body Um objeto que contém o corpo da resposta.
headers Um objeto que contém os cabeçalhos da resposta.
isRaw Indica que a formatação foi ignorada para a resposta.
status O código de status HTTP da resposta.
Acessar a solicitação e a resposta

Ao trabalhar com gatilhos HTTP, há várias maneiras de acessar os objetos de solicitação e resposta HTTP:
Partir req e res propriedades no context objeto. Dessa forma, você pode usar o padrão convencional
para acessar os dados HTTP a partir do objeto de contexto, em vez de usar o padrão context.bindings.name
completo. O exemplo a seguir mostra como acessar os objetos req e res no context :
// You can access your http request off the context ...
if(context.req.body.emoji === ':pizza:') context.log('Yay!');
// and also set your http response
context.res = { status: 202, body: 'You successfully ordered more coffee!' };
Na entrada nomeada e associações de saída. Dessa forma, o gatilho e as associações de HTTP

funcionam da mesma forma que qualquer outra associação. O exemplo a seguir define o objeto de resposta
usando uma associação chamada response :
{
"type": "http",
"direction": "out",
"name": "response"
}
context.bindings.response = { status: 201, body: "Insert succeeded." };
[Somente Resposta] Chamando context.res.send(body?: any) . Uma resposta HTTP é criada com a
entrada body como o corpo da resposta. context.done() é chamado implicitamente.
[Somente Resposta] Chamando context.done() . Um tipo especial de associação HTTP retorna a resposta
que é passada para o método context.done() . A seguinte associação de saída HTTP define um parâmetro
de saída $return :
{
"type": "http",
"direction": "out",
"name": "$return"
}
// Define a valid response object.

res = { status: 201, body: "Insert succeeded." };
context.done(null, res);
Versão do nó
A tabela a seguir mostra a versão do Node.js usada por cada versão principal do runtime do Functions:
VERSÃO DO FUNCTIONS VERSÃO DO NODE.JS
1.x 6.11.2 (bloqueada pelo runtime)
2. x Active LTS e Maintenance LTS versões do node. js

(aproximadamente, 10 recomendado). Direcione a versão no
Azure definindo a configuração do aplicativo
WEBSITE_NODE_DEFAULT_VERSION como ~10 .
Veja versão atual que o tempo de execução está usando verificando a configuração de aplicativo acima ou
imprimindo process.version de qualquer função.
Gerenciamento de dependências
Para usar as bibliotecas da comunidade no código JavaScript, como é mostrado no exemplo abaixo, você precisa
garantir que todas as dependências sejam instaladas no aplicativo de funções no Azure.
// Import the underscore.js library

var _ = require('underscore');
var version = process.version; // version === 'v6.5.0'
module.exports = function(context) {
// Using our imported underscore.js library
var matched_names = _
.where(context.bindings.myInput.names, {first: 'Carla'});
NOTE
Você deve definir um arquivo package.json na raiz do seu aplicativo de função. A definição de arquivo permite que todas as
funções no aplicativo compartilhem os mesmos pacotes armazenados em cache, o que oferece o melhor desempenho. Se
houver conflitos de versão, você poderá resolver o conflito adicionando um arquivo package.json na pasta de uma função
específica.
Ao implantar os aplicativos de função do controle de origem, qualquer arquivo package.json presente em seu
repositório acionará um npm install em sua pasta durante a implantação. Mas ao implantar via Portal ou CLI,
você terá que instalar manualmente os pacotes.
Há duas maneiras de instalar pacotes no aplicativo de funções:
Implantando com dependências
1. Instale todos os pacotes necessários localmente executando npm install .
2. Implante o código e verifique se a pasta node_modules está incluída na implantação.
Usando o Kudu
1. Vá para https://<function_app_name>.scm.azurewebsites.net .
2. Clique em Console de Depuração > CMD.
3. Acesse D:\home\site\wwwroot e arraste o arquivo package.json para a pasta wwwroot na metade superior da
página.
Também há outras maneiras de carregar arquivos em seu aplicativo de função. Para saber mais, confira
Como atualizar os arquivos do aplicativo de função.
4. Depois que o arquivo package.json é carregado, execute o comando npm install no console de execução
remota do Kudu.
Essa ação baixa os pacotes indicados no arquivo package.json e reinicia o aplicativo de função.
Em funções, configurações do aplicativo, como conexão de serviço cadeias de caracteres, são expostas como
variáveis de ambiente durante a execução. Você pode acessar essas configurações usando process.env , conforme
mostrado aqui na segunda e terceira chamadas para context.log() em que registramos as variáveis de ambiente
AzureWebJobsStorage e WEBSITE_SITE_NAME :
module.exports = async function (context, myTimer) {

var timeStamp = new Date().toISOString();
context.log('Node.js timer trigger function ran!', timeStamp);

context.log("AzureWebJobsStorage: " + process.env["AzureWebJobsStorage"]);
context.log("WEBSITE_SITE_NAME: " + process.env["WEBSITE_SITE_NAME"]);
};
Há várias maneiras de adicionar, atualizar e excluir configurações do aplicativo de funções:

No portal do Azure.
Usando a CLI do Azure.
Ao executar localmente, as configurações do aplicativo são lidos a partir de Settings arquivo de projeto.
Configurar o ponto de entrada de função

As propriedades scriptFile e entryPoint do function.json podem ser usadas para configurar o local e o nome
da função exportada. Essas propriedades podem ser importantes quando seu JavaScript é transferido.
Usando o scriptFile
Por padrão, uma função JavaScript é executada do index.js , um arquivo que compartilha o mesmo diretório pai
que seu function.json correspondente.
scriptFile pode ser usado para obter uma estrutura de pastas semelhante ao exemplo a seguir:
FunctionApp
| - host.json
| - myNodeFunction
| | - function.json
| - lib
| | - sayHello.js
| - node_modules
| | - ... packages ...
| - package.json
O function.json da myNodeFunction deve incluir uma propriedade scriptFile que aponte para o arquivo com a
função exportada a ser executada.
{
"scriptFile": "../lib/sayHello.js",
"bindings": [
...
]
}
Usando o entryPoint
No scriptFile (ou index.js ), uma função precisa ser exportada usando module.exports para ser localizada e
executada. Por padrão, a função que é executada quando disparada é a única exportação desse arquivo, a
exportação denominada run ou a exportação denominada index .
Isso pode ser configurado usando entryPoint em function.json , como no exemplo a seguir:
{
"entryPoint": "logFoo",
"bindings": [
...
]
}
No Functions v2.x, que suporta o parâmetro this nas funções do usuário, o código da função poderia ser como
no seguinte exemplo:
class MyObj {
constructor() {
this.foo = 1;
};
logFoo(context) {
context.log("Foo is " + this.foo);
context.done();
}
}
const myObj = new MyObj();

module.exports = myObj;
Neste exemplo, é importante observar que, embora um objeto esteja sendo exportado, não há nenhuma garantia
para preservar o estado entre as execuções.
Depuração local
Quando iniciado com o parâmetro --inspect , um processo node. js escuta um cliente de depuração na porta
especificada. No Azure Functions 2. x, você pode especificar argumentos para passar para o processo node. js que
executa seu código adicionando a variável de ambiente ou configuração de aplicativo
languageWorkers:node:arguments = <args> .
Para depurar localmente, adicione "languageWorkers:node:arguments": "--inspect=5858" em Values no arquivo

local. Settings. JSON e anexe um depurador à porta 5858.
Ao depurar usando VS Code, o parâmetro --inspect é adicionado automaticamente usando o valor port no
arquivo launch. JSON do projeto.
Na versão 1. x, a configuração languageWorkers:node:arguments não funcionará. A porta de depuração pode ser
selecionada com o parâmetro --nodeDebugPort no Azure Functions Core Tools.
TypeScript
Quando você visa a versão 2. x do tempo de execução do functions, ambos Azure Functions para Visual Studio
Code e o Azure Functions Core Tools permitem criar aplicativos de funções usando um modelo que ofereça
suporte a projetos de aplicativo de função TypeScript. O modelo gera package.json e tsconfig.json arquivos de
projeto que facilitam a transcompile, a execução e a publicação de funções JavaScript a partir do código TypeScript
com essas ferramentas.
Um arquivo de .funcignore gerado é usado para indicar quais arquivos são excluídos quando um projeto é
publicado no Azure.
Os arquivos TypeScript (. TS ) são transcompilados em arquivos JavaScript (. js) no diretório de saída dist . Os
modelos do TypeScript usam o parâmetro scriptFile no function.json para indicar o local do arquivo. js
correspondente na pasta dist . O local de saída é definido pelo modelo usando outDir parâmetro no arquivo de
tsconfig.json . Se você alterar essa configuração ou o nome da pasta, o tempo de execução não será capaz de
localizar o código a ser executado.
NOTE
O suporte experimental para TypeScript existe na versão 1. x do tempo de execução do functions. A versão experimental
compila os arquivos TypeScript em arquivos JavaScript quando a função é invocada. Na versão 2. x, esse suporte experimental
foi substituído pelo método controlado por ferramentas que faz transpilação antes do host ser inicializado e durante o
processo de implantação.
A maneira como você desenvolve e implanta localmente a partir de um projeto TypeScript depende de sua
ferramenta de desenvolvimento.
Código do Visual Studio
O Azure Functions para Visual Studio Code extensão permite desenvolver suas funções usando o TypeScript. As
ferramentas principais são um requisito da extensão de Azure Functions.
Para criar um aplicativo de função TypeScript no Visual Studio Code, escolha TypeScript como seu idioma ao criar
um aplicativo de funções.
Quando você pressiona F5 para executar o aplicativo localmente, o transpilação é feito antes que o host (Func. exe)
seja inicializado.
Quando você implanta seu aplicativo de funções no Azure usando o botão implantar no aplicativo de funções...
, a extensão Azure Functions primeiro gera uma compilação pronta para produção de arquivos JavaScript dos
arquivos de origem do TypeScript.
Azure Functions Core Tools
Há várias maneiras pelas quais um projeto TypeScript difere de um projeto JavaScript ao usar as ferramentas
principais.
Criar projeto
Para criar um projeto de aplicativo de função TypeScript usando ferramentas básicas, você deve especificar a opção
de linguagem TypeScript ao criar seu aplicativo de funções. Você pode fazer isso de uma das seguintes maneiras:
Execute o comando func init , selecione node como sua pilha de idiomas e, em seguida, selecione
typescript .
Execute o comando func init --worker-runtime typescript .

Executar local
Para executar o código do aplicativo de funções localmente usando as ferramentas básicas, use os seguintes
comandos em vez de func host start :
npm install
npm start
O comando npm start é equivalente aos seguintes comandos:

npm run build
func extensions install
tsc
func start
Publicar no Azure
Antes de usar o comando func azure functionapp publish para implantar no Azure, você cria uma compilação de
arquivos JavaScript pronta para produção a partir dos arquivos de origem do TypeScript.
Os comandos a seguir preparam e publicam seu projeto TypeScript usando ferramentas básicas:
npm run build:production

func azure functionapp publish <APP_NAME>
Neste comando, substitua <APP_NAME> pelo nome do seu aplicativo de funções.
Considerações para funções em JavaScript

Ao trabalhar com funções JavaScript, lembre-se das considerações nas seções a seguir.
Escolher Planos do Serviço de Aplicativo de vCPU único
Ao criar um aplicativo de funções que usa o Plano do Serviço de Aplicativo, recomendamos que você selecione um
plano de vCPU único em vez de um plano com vários vCPUs. Atualmente, o Functions executa funções em
JavaScript com mais eficiência em VMs de vCPU único, e o uso de VMs maiores não produz os aprimoramentos
de desempenho esperados. Quando necessário, você pode escalar horizontalmente manualmente Adicionando
mais instâncias de VM de vCPU único ou pode habilitar o dimensionamento automático. Para obter mais
informações, consulte Dimensionar a contagem de instâncias manual ou automaticamente.
Inicialização a frio
No desenvolvimento de Azure Functions no modelo de hospedagem sem servidor, as inicializações a frio são uma
realidade. Partida a frio refere-se ao fato de que, quando seu aplicativo de função é iniciado pela primeira vez após
um período de inatividade, leva mais tempo para inicializar. Para funções JavaScript com árvores de dependência
grandes em particular, o cold start pode ser significativo. Para acelerar o processo de inicialização a frio, execute
suas funções como um arquivo de pacote quando possível. Muitos métodos de implantação usam a execução do
modelo de pacote por padrão, mas se você estiver experimentando grandes reinicializações a frio e não estiver
sendo executado dessa maneira, essa alteração poderá oferecer uma melhoria significativa.
Limites de conexão
Quando você usa um cliente específico do serviço em um aplicativo Azure Functions, não crie um novo cliente com
cada invocação de função. Em vez disso, crie um único cliente estático no escopo global. Para obter mais
informações, consulte Managing Connections in Azure Functions.
Usar async e await
Ao escrever Azure Functions em JavaScript, você deve escrever código usando as palavras-chave async e await .
Escrever código usando async e await em vez de retornos de chamada ou .then e .catch com promessas
ajuda a evitar dois problemas comuns:
Lançar exceções não capturadas que falham no processo node. js, potencialmente afetando a execução de outras
funções.
Comportamento inesperado, como logs ausentes de Context. log, causados por chamadas assíncronas que não
estão aguardando corretamente.
No exemplo a seguir, o método assíncrono fs.readFile é invocado com uma função de retorno de chamada de
erro-primeiro como seu segundo parâmetro. Esse código causa os dois problemas mencionados acima. Uma
exceção que não é detectada explicitamente no escopo correto falha em todo o processo (problema #1). Chamar
context.done() fora do escopo da função de retorno de chamada significa que a invocação de função pode
terminar antes da leitura do arquivo (problema #2). Neste exemplo, a chamada a context.done() muito mais cedo
resulta em entradas de log ausentes começando com Data from file: .
// NOT RECOMMENDED PATTERN

const fs = require('fs');
module.exports = function (context) {

fs.readFile('./hello.txt', (err, data) => {
if (err) {
context.log.error('ERROR', err);
// BUG #1: This will result in an uncaught exception that crashes the entire process
throw err;
}
context.log(`Data from file: ${data}`);
// context.done() should be called here
});
// BUG #2: Data is not guaranteed to be read before the Azure Function's invocation ends
context.done();
}
Usar as palavras-chave async e await ajuda a evitar esses dois erros. Você deve usar a função utilitário node. js
util.promisify para ativar as funções de estilo de retorno de chamada de erro primeiro em funções awaitable.
No exemplo a seguir, todas as exceções não tratadas lançadas durante a execução da função falham apenas na
invocação individual que gerou uma exceção. A palavra-chave await significa que as etapas a seguir
readFileAsync executadas somente após a readFile ser concluída. Com async e await , você também não
precisa chamar o retorno de chamada do context.done() .
// Recommended pattern
const util = require('util');
const readFileAsync = util.promisify(fs.readFile);

let data;
try {
data = await readFileAsync('./hello.txt');
} catch (err) {
// This rethrown exception will be handled by the Functions Runtime and will only fail the individual
invocation
throw err;
}
}
Próximos passos
Guia do desenvolvedor de Java do Azure
Functions
O tempo de execução do Azure Functions dá suporte a Java se 8 LTS (Zulu 8.31.0.2-JRE 8.0.181-
win_x64). Este guia contém informações sobre as complexidades de escrever Azure Functions com Java.
Como acontece com outras linguagens, um Aplicativo de funções pode ter uma ou mais funções. Uma
função Java é um método public , decorado com a @FunctionName de anotação. Esse método define a
entrada para uma função Java e deve ser exclusivo em um pacote específico. Uma Aplicativo de funções
escrita em Java pode ter várias classes com vários métodos públicos anotados com @FunctionName .
Este artigo pressupõe que você já tenha lido a Referência do desenvolvedor do Azure Functions. Você
também deve concluir o guia de início rápido do Functions para criar sua primeira função, usando Visual
Studio Code ou Maven.
Modelo de programação
Os conceitos de gatilhos e ligações são fundamentais para as Funções do Azure. Os gatilhos iniciam a
execução do seu código. As ligações fornecem uma maneira de transmitir dados e retornar dados de uma
função, sem precisar escrever código de acesso a dados personalizado.
Criar funções Java

Para facilitar a criação de funções Java, há ferramentas baseadas no Maven e arquétipos que usam
modelos Java predefinidos para ajudá-lo a criar projetos com um gatilho de função específico.
Ferramentas baseadas no Maven
Os seguintes ambientes de desenvolvedor têm Azure Functions ferramentas que permitem criar projetos
de funções Java:
Visual Studio Code
Eclipse
IntelliJ
O artigo links acima mostra como criar suas primeiras funções usando o IDE de sua escolha.
Scaffolding do projeto
Se você preferir o desenvolvimento de linha de comando do terminal, a maneira mais simples de
scaffoldr projetos de funções baseados em Java é usar Apache Maven arquétipos. Atualmente, há duas
funções arquétipos para Maven:
Arquétipo Java: publicado sob o seguinte GroupID e artefatoid com. Microsoft. Azure: Azure-
Functions-arquétipo:
-DarchetypeArtifactId=azure-functions-archetype
Para começar a usar esse arquétipo, consulte o início rápido do Java.

Arquétipo Kotlin (visualização) publicado sob o seguinte GroupID e artefatoid com. Microsoft.
Azure: Azure-Functions-Kotlin-arquétipo:
-DarchetypeArtifactId=azure-functions-kotlin-archetype
O código-fonte desses arquétipos pode ser encontrado no repositório GitHub de arquétipos do Azure
Maven.
Estrutura de pastas
Aqui está a estrutura de pastas de um projeto Azure Functions Java:
FunctionsProject
| - src
| | - main
| | | - java
| | | | - FunctionApp
| | | | | - MyFirstFunction.java
| | | | | - MySecondFunction.java
| - target
| | - azure-functions
| | | - FunctionApp
| | | | - FunctionApp.jar
| | | | - host.json
| | | | - MyFirstFunction
| | | | | - function.json
| | | | - MySecondFunction
| | | | | - function.json
| | | | - bin
| | | | - lib
| - pom.xml
* O projeto Kotlin parece muito semelhante, pois ainda é Maven

Você pode usar um arquivo host. JSON compartilhado para configurar o aplicativo de funções. Cada
função possui seu próprio arquivo de código (.java) e arquivo de configuração de associação
(function.json).
Você pode colocar mais de uma função em um projeto. Evite colocar suas funções no jars separados. O
FunctionApp no diretório de destino é o que é implantado em seu aplicativo de funções no Azure.
Gatilhos e anotações
As funções são invocadas por um gatilho, como uma solicitação HTTP, um temporizador ou uma
atualização para os dados. Sua função precisa processar esse gatilho e quaisquer outras entradas para
produzir uma ou mais saídas.
Use as anotações Java incluídas no pacote com.microsoft.azure.functions.annotation. * para ligar entradas
e saídas a seus métodos. Para obter mais informações, consulte os documentos de referência do Java.
IMPORTANT
Você deve configurar uma conta de armazenamento do Azure no seu local. Settings. JSON para executar o
armazenamento de BLOBs do Azure, o armazenamento de filas do Azure ou os gatilhos de armazenamento de
tabelas do Azure localmente.
Exemplo:
public class Function {

public String echo(@HttpTrigger(name = "req",
methods = {"post"}, authLevel = AuthorizationLevel.ANONYMOUS)
String req, ExecutionContext context) {
return String.format(req);
}
}
Aqui está o function.json correspondente gerado pelo plug-in Azure-Functions-Maven:
{
"scriptFile": "azure-functions-example.jar",
"entryPoint": "com.example.Function.echo",
"bindings": [
{
"name": "req",
"direction": "in",
"authLevel": "anonymous",
"methods": [ "post" ]
},
{
"type": "http",
"name": "$return",
"direction": "out"
}
]
}
Suporte e disponibilidade de runtime do JDK

Para o desenvolvimento local de aplicativos de funções Java, baixe e use o azul Zulu Enterprise para o
Azure Java 8 JDKs de sistemas azul. O Azure Functions usa o runtime do JDK Java 8 da Azul quando
você implanta seus aplicativos de funções na nuvem.
O suporte do Azure para problemas com o JDKs e os aplicativos de função está disponível com um plano
de suporte qualificado.
Personalizar JVM
O Functions permite que você personalize a JVM (máquina virtual Java) usada para executar suas
funções Java. As seguintes opções de JVM são usadas por padrão:
-XX:+TieredCompilation
-XX:TieredStopAtLevel=1
-noverify
-Djava.net.preferIPv4Stack=true
-jar
Você pode fornecer argumentos adicionais em uma configuração de aplicativo chamada JAVA_OPTS . Você
pode adicionar configurações de aplicativo ao seu aplicativo de funções implantado no Azure no portal do
Azure ou no CLI do Azure.
Portal do Azure
No portal do Azure, use a guia Configurações do aplicativo para adicionar a configuração de JAVA_OPTS .
Azure CLI
Você pode usar o comando AZ functionapp config appSettings Set para definir JAVA_OPTS , como no
exemplo a seguir:
az functionapp config appsettings set --name <APP_NAME> \

--resource-group <RESOURCE_GROUP> \
--settings "JAVA_OPTS=-Djava.awt.headless=true"
Este exemplo habilita o modo sem periféricos. Substitua <APP_NAME> pelo nome do seu aplicativo de
funções e <RESOURCE_GROUP> com o grupo de recursos.
WARNING
No plano de consumo, você deve adicionar a configuração de WEBSITE_USE_PLACEHOLDER com um valor de 0 .
Essa configuração aumenta as horas de início frio para funções Java.
Bibliotecas de terceiros
O Azure Functions oferece suporte ao uso de bibliotecas de terceiros. Por padrão, todas as dependências
especificadas em seu projeto pom.xml arquivo são automaticamente agrupadas durante a meta
mvn package . Para bibliotecas não especificadas como dependências no pom.xml arquivo, coloque-as em
um diretório lib no diretório-raiz da função. As dependências colocadas no diretório lib são
adicionadas ao carregador de classe do sistema em tempo de execução.
A dependência de com.microsoft.azure.functions:azure-functions-java-library é fornecida no classpath
por padrão e não precisa ser incluída no diretório lib . Além disso, o Azure-Functions-Java-Worker
adiciona dependências listadas aqui ao classpath.
Suporte ao tipo de dados

Você pode usar objetos Java simples (POJOs), tipos definidos em azure-functions-java-library ou tipos
de dados primitivos, como String e Integer, para associar a associações de entrada ou saída.
POJOs
Para converter dados de entrada em POJO, o Azure-Functions-Java-Worker usa a biblioteca Gson . Tipos
de POJO usados como entradas para funções devem ser public .
Dados binários
Associe entradas binárias ou saídas a byte[] , definindo o campo dataType em seu function. JSON como
binary :
@FunctionName("BlobTrigger")
@StorageAccount("AzureWebJobsStorage")
public void blobTrigger(
@BlobTrigger(name = "content", path = "myblob/{fileName}", dataType = "binary") byte[]
content,
@BindingName("fileName") String fileName,
final ExecutionContext context
) {
context.getLogger().info("Java Blob trigger function processed a blob.\n Name: " + fileName +
"\n Size: " + content.length + " Bytes");
}
Se você espera valores nulos, use Optional<T> .
Associações
As ligações de entrada e saída fornecem uma maneira declarativa de se conectar aos dados de dentro do
seu código. Uma função pode ter várias ligações de entrada e saída.
Exemplo de associação de entrada
package com.example;
import com.microsoft.azure.functions.annotation.*;

@FunctionName("echo")
public static String echo(
@HttpTrigger(name = "req", methods = { "put" }, authLevel = AuthorizationLevel.ANONYMOUS,
route = "items/{id}") String inputReq,
@TableInput(name = "item", tableName = "items", partitionKey = "Example", rowKey = "{id}",
connection = "AzureWebJobsStorage") TestInputData inputData
@TableOutput(name = "myOutputTable", tableName = "Person", connection = "AzureWebJobsStorage")
OutputBinding<Person> testOutputData,
) {
testOutputData.setValue(new Person(httpbody + "Partition", httpbody + "Row", httpbody +
"Name"));
return "Hello, " + inputReq + " and " + inputData.getKey() + ".";
}
public static class TestInputData {

public String getKey() { return this.RowKey; }
private String RowKey;
}
public static class Person {
public String PartitionKey;
public String RowKey;
public String Name;
public Person(String p, String r, String n) {

this.PartitionKey = p;
this.RowKey = r;
this.Name = n;
}
}
}
Você invoca essa função com uma solicitação HTTP.

A carga de solicitação HTTP é passada como um String para o argumento inputReq .
Uma entrada é recuperada do armazenamento de tabela e é passada como TestInputData para o
argumento inputData .
Para receber um lote de entradas, você pode associar a String[] , POJO[] , List<String> ou List<POJO> .
@FunctionName("ProcessIotMessages")
public void processIotMessages(
@EventHubTrigger(name = "message", eventHubName = "%AzureWebJobsEventHubPath%", connection =
"AzureWebJobsEventHubSender", cardinality = Cardinality.MANY) List<TestEventData> messages,
final ExecutionContext context)
{
context.getLogger().info("Java Event Hub trigger received messages. Batch size: " +
messages.size());
}
public class TestEventData {

public String id;
}
Essa função é acionada sempre que houver novos dados no hub de eventos configurado. Como o
cardinality é definido como MANY , a função recebe um lote de mensagens do hub de eventos.
EventData do hub de eventos é convertido em TestEventData para a execução da função.
Exemplo de associação de saída

Você pode associar uma associação de saída ao valor de retorno usando $return .

@FunctionName("copy")
@StorageAccount("AzureWebJobsStorage")
@BlobOutput(name = "$return", path = "samples-output-java/{name}")
public static String copy(@BlobTrigger(name = "blob", path = "samples-input-java/{name}") String
content) {
return content;
}
}
Se houver várias associações de saída, use o valor de retorno de apenas um deles.

Para enviar vários valores de saída, use OutputBinding<T> definido no pacote
azure-functions-java-library .
@FunctionName("QueueOutputPOJOList")
public HttpResponseMessage QueueOutputPOJOList(@HttpTrigger(name = "req", methods = {
HttpMethod.GET,
HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS)
@QueueOutput(name = "itemsOut", queueName = "test-output-java-pojo", connection =
"AzureWebJobsStorage") OutputBinding<List<TestData>> itemsOut,
final ExecutionContext context) {
context.getLogger().info("Java HTTP trigger processed a request.");
String query = request.getQueryParameters().get("queueMessageId");

String queueMessageId = request.getBody().orElse(query);
itemsOut.setValue(new ArrayList<TestData>());
if (queueMessageId != null) {
TestData testData1 = new TestData();
testData1.id = "msg1"+queueMessageId;
TestData testData2 = new TestData();
testData2.id = "msg2"+queueMessageId;
itemsOut.getValue().add(testData1);
itemsOut.getValue().add(testData2);
return request.createResponseBuilder(HttpStatus.OK).body("Hello, " +

queueMessageId).build();
} else {
return request.createResponseBuilder(HttpStatus.INTERNAL_SERVER_ERROR)
.body("Did not find expected items in CosmosDB input list").build();
}
}
public static class TestData {

public String id;
}
Você invoca essa função em um HttpRequest. Ele grava vários valores no armazenamento de fila.
HttpRequestMessage e HttpResponseMessage
Eles são definidos em azure-functions-java-library . Eles são tipos auxiliares para trabalhar com as
funções HttpTrigger.
TIPO ESPECIALIZADO ESCOLHA O DESTINO USO TÍPICO
HttpRequestMessage<T> Gatilho de HTTP Obtém o método, os cabeçalhos ou

as consultas
HttpResponseMessage Associação de saída HTTP Retorna o status diferente de 200
Metadados
Poucos gatilhos enviam gatilhos de metadados juntamente com dados de entrada. Você pode usar a
anotação @BindingName para associar aos metadados do gatilho.
import java.util.Optional;

@FunctionName("metadata")
public static String metadata(
@HttpTrigger(name = "req", methods = { "get", "post" }, authLevel =
AuthorizationLevel.ANONYMOUS) Optional<String> body,
@BindingName("name") String queryValue
) {
return body.orElse(queryValue);
}
}
No exemplo anterior, a queryValue está associada ao parâmetro de cadeia de caracteres de consulta

name na URL de solicitação HTTP http://{example.host}/api/metadata?name=test . Aqui está outro
exemplo, mostrando como associar a Id de metadados de gatilho de fila.
@FunctionName("QueueTriggerMetadata")
public void QueueTriggerMetadata(
@QueueTrigger(name = "message", queueName = "test-input-java-metadata", connection =
"AzureWebJobsStorage") String message,@BindingName("Id") String metadataId,
@QueueOutput(name = "output", queueName = "test-output-java-metadata", connection =
"AzureWebJobsStorage") OutputBinding<TestData> output,
) {
context.getLogger().info("Java Queue trigger function processed a message: " + message + "
with metadaId:" + metadataId );
TestData testData = new TestData();
testData.id = metadataId;
output.setValue(testData);
}
NOTE
O nome fornecido na anotação precisa corresponder à propriedade de metadados.
Contexto de execução
ExecutionContext, definido na azure-functions-java-library , contém métodos auxiliares para se
comunicar com o tempo de execução do functions.
Agente
Use getLogger , definido em ExecutionContext , para gravar logs do código de função.
Exemplo:
import com.microsoft.azure.functions.*;

public String echo(@HttpTrigger(name = "req", methods = {"post"}, authLevel =
AuthorizationLevel.ANONYMOUS) String req, ExecutionContext context) {
if (req.isEmpty()) {
context.getLogger().warning("Empty request body received by function " +
context.getFunctionName() + " with invocation " + context.getInvocationId());
}
}
}
Exibir logs e rastreamento

Você pode usar o CLI do Azure para transmitir o log Java stdout e stderr, bem como outros logs de
aplicativo.
Veja como configurar seu aplicativo de funções para gravar o log do aplicativo usando o CLI do Azure:
az webapp log config --name functionname --resource-group myResourceGroup --application-logging true
Para transmitir a saída de log para seu aplicativo de funções usando o CLI do Azure, abra um novo
prompt de comando, bash ou sessão de terminal e digite o seguinte comando:
az webapp log tail --name webappname --resource-group myResourceGroup
O comando AZ webapp log tail tem opções para filtrar a saída usando a opção --provider .
Para baixar os arquivos de log como um único arquivo ZIP usando o CLI do Azure, abra um novo prompt
de comando, bash ou sessão de terminal e digite o seguinte comando:
az webapp log download --resource-group resourcegroupname --name functionappname
Você deve ter habilitado o log do sistema de arquivos na portal do Azure ou na CLI do Azure antes de
executar esse comando.
Em funções, configurações do aplicativo, como conexão de serviço cadeias de caracteres, são expostas
como variáveis de ambiente durante a execução. Você pode acessar essas configurações usando,
System.getenv("AzureWebJobsStorage") .
O exemplo a seguir obtém a configuração do aplicativo, com a chave chamada myAppSetting :

public String echo(@HttpTrigger(name = "req", methods = {"post"}, authLevel =
AuthorizationLevel.ANONYMOUS) String req, ExecutionContext context) {
context.getLogger().info("My app setting value: "+ System.getenv("myAppSetting"));
}
}
Próximos passos
Para obter mais informações sobre o desenvolvimento em Java Azure Functions, consulte os seguintes
recursos:
Desenvolvimento local e depuração com Visual Studio Code, IntelliJe Eclipse
Azure Functions de Java de Depuração Remota com Visual Studio Code
Plug-in do Maven para Azure Functions
Simplifique a criação da função por meio do objetivo de azure-functions:add e prepare um diretório
de preparo para a implantação de arquivo zip.
PowerShell
Este artigo fornece detalhes sobre como você escreve Azure Functions usando o PowerShell.
NOTE
O PowerShell para o Azure Functions está atualmente em versão prévia. Para receber atualizações importantes, assine o
repositório Anúncios do Serviço de Aplicativo do Azure no GitHub.
Uma função do PowerShell do Azure (função) é representada como um script do PowerShell que é executado
quando disparado. Cada script de função tem um arquivo de function.json relacionado que define como a
função se comporta, como a forma como ela é disparada e seus parâmetros de entrada e saída. Para saber mais,
confira o artigo gatilhos e Associação.
Assim como outros tipos de funções, as funções de script do PowerShell assumem parâmetros que
correspondem aos nomes de todas as associações de entrada definidas no arquivo function.json . Um
parâmetro TriggerMetadata também é passado que contém informações adicionais sobre o gatilho que iniciou a
função.
Este artigo pressupõe que você já tenha lido o Azure Functions referência do desenvolvedor. Você também deve
ter concluído o guia de início rápido do Functions para o PowerShell para criar sua primeira função do
PowerShell.
Estrutura de pastas
A estrutura de pastas necessária para um projeto do PowerShell é semelhante ao seguinte. Esse padrão pode ser
alterado. Para obter mais informações, consulte a seção scriptfile abaixo.
PSFunctionApp
| - MyFirstFunction
| | - run.ps1
| | - function.json
| | - run.ps1
| | - function.json
| - Modules
| | - myFirstHelperModule
| | | - myFirstHelperModule.psd1
| | | - myFirstHelperModule.psm1
| | - mySecondHelperModule
| | | - mySecondHelperModule.psd1
| | | - mySecondHelperModule.psm1
| - local.settings.json
| - host.json
| - requirements.psd1
| - profile.ps1
| - bin
Na raiz do projeto, há um arquivo de host.json compartilhado que pode ser usado para configurar o aplicativo
de funções. Cada função tem uma pasta com seu próprio arquivo de código (. ps1) e arquivo de configuração de
associação ( function.json ). O nome do diretório pai do arquivo function. JSON é sempre o nome da sua
função.
Determinadas associações exigem a presença de um arquivo de extensions.csproj . As extensões de associação,
necessárias na versão 2. x do tempo de execução do functions, são definidas no arquivo extensions.csproj , com
os arquivos de biblioteca reais na pasta bin . Ao desenvolver localmente, você deve registrar extensões de
associação. Ao desenvolver funções no portal do Azure, esse registro é feito para você.
Em aplicativos de funções do PowerShell, você pode, opcionalmente, ter um profile.ps1 que é executado
quando um aplicativo de funções começa a ser executado (caso contrário, é conhecido como um início frio . Para
obter mais informações, consulte perfil do PowerShell.
Definindo um script do PowerShell como uma função

Por padrão, o tempo de execução do Functions procura sua função em run.ps1 , em que run.ps1 compartilha o
mesmo diretório pai que seu function.json correspondente.
Seu script é passado por vários argumentos na execução. Para lidar com esses parâmetros, adicione um bloco de
param na parte superior do seu script, como no exemplo a seguir:
# $TriggerMetadata is optional here. If you don't need it, you can safely remove it from the param block
param($MyFirstInputBinding, $MySecondInputBinding, $TriggerMetadata)
Parâmetro TriggerMetadata
O parâmetro TriggerMetadata é usado para fornecer informações adicionais sobre o gatilho. Os metadados
adicionais variam de associação à associação, mas todos contêm uma propriedade sys que contém os
seguintes dados:
$TriggerMetadata.sys
PROPRIEDADE DESCRIÇÃO TIPO
UtcNow Quando, em UTC, a função foi DateTime

disparada
MethodName O nome da função que foi disparada cadeia de caracteres
RandGuid um GUID exclusivo para esta execução cadeia de caracteres

da função
Cada tipo de gatilho tem um conjunto diferente de metadados. Por exemplo, o $TriggerMetadata para
QueueTrigger contém a InsertionTime , Id , DequeueCount , entre outras coisas. Para obter mais informações
sobre os metadados do gatilho de fila, acesse a documentação oficial para gatilhos de fila. Verifique a
documentação nos gatilhos com os quais você está trabalhando para ver o que acontece nos metadados do
gatilho.
Associações
No PowerShell, as associações são configuradas e definidas no function. JSON de uma função. As funções
interagem com associações de várias maneiras.
Lendo dados de gatilho e de entrada
As associações de entrada e gatilho são lidas como parâmetros passados para sua função. As associações de
entrada têm um direction definido como in em function. JSON. A propriedade name definida em
function.json é o nome do parâmetro, no bloco de param . Como o PowerShell usa parâmetros nomeados para
associação, a ordem dos parâmetros não importa. No entanto, é uma prática recomendada seguir a ordem das
associações definidas no function.json .
param($MyFirstInputBinding, $MySecondInputBinding)
Gravando dados de saída

No functions, uma associação de saída tem um direction definido como out no function. JSON. Você pode
gravar em uma associação de saída usando o cmdlet Push-OutputBinding , que está disponível para o tempo de
execução do functions. Em todos os casos, a propriedade name da associação, conforme definido em
function.json , corresponde ao parâmetro Name do cmdlet Push-OutputBinding .
O seguinte mostra como chamar Push-OutputBinding em seu script de função:
Push-OutputBinding -Name myQueue -Value $myValue
Você também pode passar um valor para uma ligação específica por meio do pipeline.
Produce-MyOutputValue | Push-OutputBinding -Name myQueue
Push-OutputBinding se comporta de maneira diferente com base no valor especificado para -Name :
Quando o nome especificado não puder ser resolvido para uma associação de saída válida, um erro será
gerado.
Quando a associação de saída aceita uma coleção de valores, você pode chamar Push-OutputBinding
repetidamente para enviar vários valores por push.
Quando a associação de saída aceita apenas um valor singleton, chamar Push-OutputBinding uma
segunda vez gera um erro.
sintaxe de Push-OutputBinding
Veja a seguir os parâmetros válidos para chamar Push-OutputBinding :
NAME TIPO POSITION DESCRIÇÃO
-Name Cadeia de caracteres 1 O nome da Associação de

saída que você deseja
definir.
-Value Objeto 2 O valor da Associação de

saída que você deseja
definir, que é aceita do
pipeline ByValue.
-Clobber SwitchParameter nomeado Adicional Quando

especificado, força o valor a
ser definido para uma
associação de saída
especificada.
Os seguintes parâmetros comuns também têm suporte:
Verbose
Debug
ErrorAction
ErrorVariable
WarningAction
WarningVariable
OutBuffer
PipelineVariable
OutVariable
Para obter mais informações, consulte sobre CommonParameters.

Exemplo de push-OutputBinding: respostas HTTP
Um gatilho HTTP retorna uma resposta usando uma associação de saída chamada response . No exemplo a
seguir, a associação de saída de response tem o valor de "saída #1":
PS >Push-OutputBinding -Name response -Value ([HttpResponseContext]@{

StatusCode = [System.Net.HttpStatusCode]::OK
Body = "output #1"
})
Como a saída é para HTTP, que aceita apenas um valor singleton, um erro é gerado quando Push-OutputBinding
é chamado uma segunda vez.

Body = "output #2"
})
Para saídas que aceitam apenas valores singleton, você pode usar o parâmetro -Clobber para substituir o valor
antigo em vez de tentar adicionar a uma coleção. O exemplo a seguir pressupõe que você já adicionou um valor.
Usando -Clobber , a resposta do exemplo a seguir substitui o valor existente para retornar um valor de "saída
#3":

Body = "output #3"
}) -Clobber
Exemplo de push-OutputBinding: Associação de saída da fila

Push-OutputBinding é usado para enviar dados para associações de saída, como uma Associação de saída do
armazenamento de filas do Azure. No exemplo a seguir, a mensagem gravada na fila tem um valor de "saída #1":
PS >Push-OutputBinding -Name outQueue -Value "output #1"
A associação de saída para uma fila de armazenamento aceita vários valores de saída. Nesse caso, chamar o
exemplo a seguir após a primeira gravação na fila em uma lista com dois itens: "output #1" e "output #2".
PS >Push-OutputBinding -Name outQueue -Value "output #2"

O exemplo a seguir, quando chamado após os dois anteriores, adiciona mais dois valores à coleção de saída:
PS >Push-OutputBinding -Name outQueue -Value @("output #3", "output #4")
Quando gravado na fila, a mensagem contém estes quatro valores: "saída #1", "saída #2", "saída #3" e "#4 de
saída".
Get-OutputBinding cmdlet
Você pode usar o cmdlet Get-OutputBinding para recuperar os valores definidos atualmente para suas
associações de saída. Esse cmdlet recupera uma tabela de hash que contém os nomes das associações de saída
com seus respectivos valores.
Veja a seguir um exemplo de como usar Get-OutputBinding para retornar os valores de associação atuais:
Get-OutputBinding
Name Value
---- -----
MyQueue myData
MyOtherQueue myData
Get-OutputBinding também contém um parâmetro chamado -Name , que pode ser usado para filtrar a
associação retornada, como no exemplo a seguir:
Get-OutputBinding -Name MyQ*
Name Value
---- -----
MyQueue myData
Há suporte para caracteres curinga (*) em Get-OutputBinding .
Registro em log
O registro em log nas funções do PowerShell funciona como log normal do PowerShell. Você pode usar os
cmdlets de log para gravar em cada fluxo de saída. Cada cmdlet é mapeado para um nível de log usado pelas
funções.
NÍVEL DE LOG DE FUNÇÕES CMDLET DE REGISTRO EM LOG
Erro Write-Error
Aviso Write-Warning
Informações Write-Information Informações Grava no log do nível de

Write-Host informações .
Write-Output
Depuração Write-Debug
NÍVEL DE LOG DE FUNÇÕES CMDLET DE REGISTRO EM LOG
Rastreamento Write-Progress
Write-Verbose
Além desses cmdlets, qualquer coisa gravada no pipeline é redirecionada para o nível de log Information e
exibido com a formatação padrão do PowerShell.
IMPORTANT
O uso dos cmdlets Write-Verbose ou Write-Debug não é suficiente para ver o log detalhado e de nível de depuração.
Você também deve configurar o limite de nível de log, que declara o nível de logs que você realmente importa. Para saber
mais, confira Configurar o nível de log do aplicativo de funções.
Configurar o nível de log do aplicativo de funções

Azure Functions permite que você defina o nível de limite para facilitar o controle da maneira como as funções
são gravadas nos logs. Para definir o limite para todos os rastreamentos gravados no console, use a propriedade
logging.logLevel.default nareferência de host. JSONdo [arquivo host.json ]. Essa configuração se aplica a
todas as funções em seu aplicativo de funções.
O exemplo a seguir define o limite para habilitar o log detalhado para todas as funções, mas define o limite para
habilitar o log de depuração para uma função chamada MyFunction :
{
"logging": {
"logLevel": {
"Function.MyFunction": "Debug",
"default": "Trace"
}
}
}
Para obter mais informações, consulte referência de host. JSON.

Exibindo os logs
Se o Aplicativo de funções estiver em execução no Azure, você poderá usar Application Insights para monitorá-
lo. Leia Azure Functions de monitoramento para saber mais sobre como exibir e consultar logs de função.
Se você estiver executando o Aplicativo de funções localmente para desenvolvimento, os logs serão padrão para
o sistema de arquivos. Para ver os logs no console, defina a variável de ambiente AZURE_FUNCTIONS_ENVIRONMENT
como Development antes de iniciar a Aplicativo de funções.
Tipos de associações e gatilhos

Há vários gatilhos e associações disponíveis para você usar com seu aplicativo de funções. A lista completa de
gatilhos e associações pode ser encontrada aqui.
Todos os gatilhos e associações são representados no código como alguns tipos de dados reais:
Tabela
cadeia de caracteres
Byte []
int
Clique
HttpRequestContext
HttpResponseContext
Os cinco primeiros tipos nessa lista são tipos .NET padrão. Os dois últimos são usados somente pelo gatilho
HttpTrigger.
Cada parâmetro de associação em suas funções deve ser um desses tipos.
Os gatilhos HTTP e webhook e as associações de saída HTTP usam objetos Request e Response para
representar as mensagens HTTP.
Objeto de solicitação
O objeto de solicitação que é passado para o script é do tipo HttpRequestContext , que tem as seguintes
propriedades:
Body Um objeto que contém o corpo da objeto

solicitação. Body é serializado no
melhor tipo com base nos dados. Por
exemplo, se os dados forem JSON, eles
serão passados como uma tabela de
hash. Se os dados forem uma cadeia
de caracteres, eles serão passados
como uma cadeia de caracteres.
Headers Um dicionário que contém os < De cadeia de caracteres, Cadeia de

cabeçalhos de solicitação. caracteres > de dicionário *
Method O método HTTP da solicitação. cadeia de caracteres
Params Um objeto que contém os parâmetros < De cadeia de caracteres, Cadeia de

de roteamento da solicitação. caracteres > de dicionário *
Query Um objeto que contém os parâmetros < De cadeia de caracteres, Cadeia de

de consulta. caracteres > de dicionário *
Url A URL da solicitação. cadeia de caracteres
* Todas as chaves de Dictionary<string,string> não diferenciam maiúsculas de minúsculas.

Objeto de resposta
O objeto de resposta que você deve enviar de volta é do tipo HttpResponseContext , que tem as seguintes
propriedades:
Body Um objeto que contém o corpo da objeto

resposta.
ContentType Uma pequena mão para definir o tipo cadeia de caracteres

de conteúdo para a resposta.
Headers Um objeto que contém os cabeçalhos Dicionário ou Hashtable

de resposta.
StatusCode O código de status HTTP da resposta. Cadeia de caracteres ou int
Acessando a solicitação e a resposta

Ao trabalhar com gatilhos HTTP, você pode acessar a solicitação HTTP da mesma maneira que faria com
qualquer outra associação de entrada. Está no bloco de param .
Use um objeto HttpResponseContext para retornar uma resposta, conforme mostrado a seguir:
function.json
{
"bindings": [
{
"direction": "in",
"authLevel": "anonymous"
},
{
"type": "http",
"direction": "out"
}
]
}
run.ps1
param($req, $TriggerMetadata)
$name = $req.Query.Name
Push-OutputBinding -Name res -Value ([HttpResponseContext]@{

Body = "Hello $name!"
})
O resultado da invocação dessa função seria:
PS > irm http://localhost:5001?Name=Functions

Hello Functions!
Conversão de tipo para gatilhos e associações

Para determinadas associações como a associação de BLOB, você pode especificar o tipo do parâmetro.
Por exemplo, para ter dados do armazenamento de BLOBs fornecidos como uma cadeia de caracteres, adicione
a seguinte conversão de tipo ao meu bloco de param :
param([string] $myBlob)
Perfil do PowerShell
No PowerShell, há o conceito de um perfil do PowerShell. Se você não estiver familiarizado com os perfis do
PowerShell, consulte about Profiles.
Em funções do PowerShell, o script de perfil é executado quando o aplicativo de funções é iniciado. Os
aplicativos de funções começam quando são implantados pela primeira vez e depois ficam ociosos (inicialização
a frio).
Quando você cria um aplicativo de funções usando ferramentas, como Visual Studio Code e Azure Functions
Core Tools, um profile.ps1 padrão é criado para você. O perfil padrão é mantido no repositório GitHub das
ferramentas principais e contém:
Autenticação automática de MSI para o Azure.
A capacidade de ativar o Azure PowerShell AzureRM aliases do PowerShell, se desejar.
Versão do PowerShell
A tabela a seguir mostra a versão do PowerShell usada por cada versão principal do tempo de execução do
Functions:
VERSÃO DAS FUNÇÕES VERSÃO DO POWERSHELL
1.x Windows PowerShell 5,1 (bloqueado pelo tempo de

execução)
2. x PowerShell Core 6
Você pode ver a versão atual imprimindo $PSVersionTable de qualquer função.
Gerenciamento de dependência
O Functions permite aproveitar a Galeria do PowerShell para gerenciar dependências. Com o gerenciamento de
dependência habilitado, o arquivo Requirements. psd1 é usado para baixar automaticamente os módulos
necessários. Você habilita esse comportamento definindo a propriedade managedDependency como true na raiz
do arquivo host. JSON, como no exemplo a seguir:
{
"managedDependency": {
"enabled": true
}
}
Quando você cria um novo projeto de funções do PowerShell, o gerenciamento de dependência é habilitado por
padrão, com o módulo de Az do Azure incluído. O número máximo de módulos com suporte no momento é
10. A sintaxe com suporte é MajorNumber .* ou versão exata do módulo, conforme mostrado nos seguintes
requisitos. psd1 exemplo:
@{
Az = '1.*'
SqlServer = '21.1.18147'
}
Quando você atualiza o arquivo Requirements. psd1, os módulos atualizados são instalados após uma
reinicialização.
NOTE
As dependências gerenciadas exigem acesso ao www.powershellgallery.com para baixar módulos. Ao executar localmente,
verifique se o tempo de execução pode acessar essa URL adicionando as regras de firewall necessárias.
As configurações de aplicativo a seguir podem ser usadas para alterar a forma como as dependências
gerenciadas são baixadas e instaladas. A atualização do aplicativo é iniciada no MDMaxBackgroundUpgradePeriod e o
processo de atualização é concluído em aproximadamente o MDNewSnapshotCheckPeriod .
APLICATIVO DE FUNÇÕES CONFIGURAÇÃO VALOR PADRÃO DESCRIÇÃO
MDMaxBackgroundUpgradePeriod 7.00:00:00 (7 dias) Cada processo de trabalho do

PowerShell inicia a verificação de
atualizações de módulo no Galeria do
PowerShell no início do processo e a
cada MDMaxBackgroundUpgradePeriod
depois disso. Quando uma nova versão
de módulo está disponível no Galeria
do PowerShell, ela é instalada no
sistema de arquivos e disponibilizada
para trabalhadores do PowerShell.
Diminuir esse valor permite que seu
aplicativo de funções obtenha versões
mais recentes do módulo mais cedo,
mas também aumenta o uso de
recursos do aplicativo (e/s de rede,
CPU, armazenamento). Aumentar esse
valor diminui o uso de recursos do
aplicativo, mas também pode atrasar a
entrega de novas versões de módulo
ao seu aplicativo.
MDNewSnapshotCheckPeriod 01:00:00 (1 hora) Depois que novas versões de módulo

são instaladas no sistema de arquivos,
todos os processos de trabalho do
PowerShell devem ser reiniciados.
Reiniciar os trabalhadores do
PowerShell afeta a disponibilidade do
aplicativo, pois ele pode interromper a
execução da função atual. Até que
todos os processos de trabalho do
PowerShell sejam reiniciados, as
invocações de função podem usar as
versões de módulo antiga ou nova. A
reinicialização de todos os
trabalhadores do PowerShell é
concluída dentro do
MDNewSnapshotCheckPeriod .
Aumentar esse valor diminui a
frequência de interrupções, mas
também pode aumentar o período de
tempo em que as invocações de função
usam as versões de módulo antigo ou
novo de forma não determinística.
MDMinBackgroundUpgradePeriod 1.00:00:00 (1 dia) Para evitar atualizações excessivas de

módulo em reinicializações de
trabalhador frequentes, a verificação de
atualizações de módulo não será
executada quando algum trabalho já
tiver iniciado essa verificação na última
MDMinBackgroundUpgradePeriod .
Aproveitar seus próprios módulos personalizados é um pouco diferente de como você faria normalmente.
No computador local, o módulo é instalado em uma das pastas disponíveis globalmente em seu
$env:PSModulePath . Ao executar no Azure, você não tem acesso aos módulos instalados em seu computador. Isso
significa que o $env:PSModulePath para um aplicativo de funções do PowerShell difere de $env:PSModulePath em
um script do PowerShell regular.
No functions, PSModulePath contém dois caminhos:
Uma pasta Modules que existe na raiz do seu aplicativo de funções.
Um caminho para uma pasta de Modules que é controlada pelo operador de linguagem do PowerShell.
Pasta de Modules no nível do aplicativo de funções
Para usar módulos personalizados, você pode posicionar os módulos nos quais suas funções dependem de uma
pasta Modules . Nessa pasta, os módulos ficam automaticamente disponíveis para o tempo de execução do
functions. Qualquer função no aplicativo de funções pode usar esses módulos.
NOTE
Os módulos especificados no arquivo Requirements. psd1 são baixados e incluídos automaticamente no caminho para que
você não precise incluí-los na pasta modules. Eles são armazenados localmente na pasta
$env:LOCALAPPDATA/AzureFunctions e na pasta /data/ManagedDependencies quando executados na nuvem.
Para aproveitar o recurso de módulo personalizado, crie uma pasta Modules na raiz do seu aplicativo de funções.
Copie os módulos que você deseja usar em suas funções para esse local.
mkdir ./Modules
Copy-Item -Path /mymodules/mycustommodule -Destination ./Modules -Recurse
Com uma pasta Modules , seu aplicativo de funções deve ter a seguinte estrutura de pastas:
PSFunctionApp
| - MyFunction
| | - run.ps1
| | - function.json
| - Modules
| | - MyCustomModule
| | - MyOtherCustomModule
| | - MySpecialModule.psm1
| - host.json
| - requirements.psd1
Quando você inicia seu aplicativo de funções, o operador de linguagem do PowerShell adiciona essa pasta
Modules ao $env:PSModulePath para que você possa contar com o carregamento automático de módulo,
exatamente como faria em um script do PowerShell regular.
Pasta Modules nível de trabalho de idioma
Vários módulos são geralmente usados pelo operador de linguagem do PowerShell. Esses módulos são
definidos na última posição de PSModulePath .
A lista atual de módulos é a seguinte:
Microsoft. PowerShell. Archive: módulo usado para trabalhar com arquivos mortos, como .zip , .nupkg e
outros.
ThreadJob: uma implementação baseada em thread das APIs de trabalho do PowerShell.
Por padrão, o Functions usa a versão mais recente desses módulos. Para usar uma versão de módulo específica,
coloque essa versão específica na pasta Modules do seu aplicativo de funções.
Em funções, as configurações de aplicativo, como cadeias de conexão de serviço, são expostas como variáveis de
ambiente durante a execução. Você pode acessar essas configurações usando $env:NAME_OF_ENV_VAR , conforme
mostrado no exemplo a seguir:
param($myTimer)
Write-Host "PowerShell timer trigger function ran! $(Get-Date)"

Write-Host $env:AzureWebJobsStorage
Write-Host $env:WEBSITE_SITE_NAME

No portal do Azure.
Ao executar localmente, as configurações do aplicativo são lidas no arquivo de projeto local. Settings. JSON .
Simultaneidade
Por padrão, o tempo de execução do PowerShell do Functions só pode processar uma invocação de uma função
por vez. No entanto, esse nível de simultaneidade pode não ser suficiente nas seguintes situações:
Quando você está tentando lidar com um grande número de invocações ao mesmo tempo.
Quando você tem funções que invocam outras funções dentro do mesmo aplicativo de funções.
Você pode alterar esse comportamento definindo a seguinte variável de ambiente como um valor inteiro:
PSWorkerInProcConcurrencyUpperBound
Você define essa variável de ambiente nas configurações de aplicativo de seu aplicativo de funções.
Considerações sobre o uso de simultaneidade
O PowerShell é uma linguagem de script de thread único por padrão. No entanto, a simultaneidade pode ser
adicionada usando vários espaços de uso do PowerShell no mesmo processo. A quantidade de Runspaces
criados corresponderá à configuração do aplicativo PSWorkerInProcConcurrencyUpperBound. A taxa de
transferência será afetada pela quantidade de CPU e memória disponíveis no plano selecionado.
Azure PowerShell usa alguns contextos de nível de processo e um estado para ajudá-lo a evitar a digitação de
excesso de tipos. No entanto, se você ativar a simultaneidade em seu aplicativo de funções e invocar ações que
alteram o estado, poderá acabar com condições de corrida. Essas condições de corrida são difíceis de depurar
porque uma invocação depende de um determinado Estado e a outra invocação alterou o estado.
Há um grande valor em simultaneidade com Azure PowerShell, já que algumas operações podem levar um
tempo considerável. No entanto, você deve continuar com cautela. Se você suspeitar de que está enfrentando
uma condição de corrida, defina a configuração de aplicativo PSWorkerInProcConcurrencyUpperBound como
1 e, em vez disso, use o isolamento de nível de processo de trabalho de linguagem para simultaneidade.
Configurar scriptFile de função

Por padrão, uma função do PowerShell é executada a partir de run.ps1 , um arquivo que compartilha o mesmo
diretório pai que seu function.json correspondente.
A propriedade scriptFile na function.json pode ser usada para obter uma estrutura de pastas parecida com o
exemplo a seguir:
FunctionApp
| - host.json
| - myFunction
| | - function.json
| - lib
| | - PSFunction.ps1
Nesse caso, o function.json para myFunction inclui uma propriedade scriptFile referenciando o arquivo com
a função exportada a ser executada.
{
"scriptFile": "../lib/PSFunction.ps1",
"bindings": [
// ...
]
}
Usar módulos do PowerShell Configurando um ponto de entrada

Este artigo mostrou as funções do PowerShell no arquivo de script padrão run.ps1 gerado pelos modelos. No
entanto, você também pode incluir suas funções em módulos do PowerShell. Você pode referenciar seu código
de função específico no módulo usando os campos scriptFile e entryPoint no arquivo de configuração
function. JSON.
Nesse caso, entryPoint é o nome de uma função ou cmdlet no módulo do PowerShell referenciado em
scriptFile .
Considere a seguinte estrutura de pastas:
FunctionApp
| - host.json
| - myFunction
| | - function.json
| - lib
| | - PSFunction.psm1
Onde PSFunction.psm1 contém:
function Invoke-PSTestFunc {
param($InputBinding, $TriggerMetadata)
Push-OutputBinding -Name OutputBinding -Value "output"

}
Export-ModuleMember -Function "Invoke-PSTestFunc"
Neste exemplo, a configuração de myFunction inclui uma propriedade scriptFile que faz referência a
PSFunction.psm1 , que é um módulo do PowerShell em outra pasta. A propriedade entryPoint faz referência à
função Invoke-PSTestFunc , que é o ponto de entrada no módulo.
{
"scriptFile": "../lib/PSFunction.psm1",
"entryPoint": "Invoke-PSTestFunc",
"bindings": [
// ...
]
}
Com essa configuração, a Invoke-PSTestFunc é executada exatamente como uma run.ps1 .
Considerações para funções do PowerShell

Ao trabalhar com as funções do PowerShell, esteja ciente das considerações nas seções a seguir.
Início frio
Ao desenvolver Azure Functions no modelo de hospedagem sem servidor, inícios frios são uma realidade. Início
frio refere-se ao período de tempo que leva para seu aplicativo de funções iniciar a execução para processar uma
solicitação. A inicialização a frio acontece com mais frequência no plano de consumo porque seu aplicativo de
funções é desligado durante períodos de inatividade.
Agrupar módulos em vez de usar Install-Module
O script é executado em cada invocação. Evite usar Install-Module em seu script. Em vez disso, use
Save-Module antes da publicação para que sua função não precise perder tempo baixando o módulo. Se a frio
for iniciada, afetando suas funções, considere implantar seu aplicativo de funções em um plano do serviço de
aplicativo definido como Always on ou em um plano Premium.
Próximos passos
Guia do desenvolvedor de Python para o Azure
Functions
Este artigo é uma introdução ao desenvolvimento do Azure Functions usando Python. O conteúdo
abaixo pressupõe que você já tenha lido o Guia de desenvolvedores do Azure Functions.
Para projetos de exemplo de função autônoma no Python, consulte os exemplos de funções do Python.
Modelo de programação
Azure Functions espera que uma função seja um método sem estado em seu script Python que
processa a entrada e produz a saída. Por padrão, o tempo de execução espera que o método seja
implementado como um método global chamado main() no arquivo __init__.py . Você também pode
especificar um ponto de entrada alternativo.
Os dados de gatilhos e associações são associados à função por meio de atributos de método usando a
propriedade name definida no arquivo Function. JSON . Por exemplo, a Function. JSON abaixo
descreve uma função simples disparada por uma solicitação HTTP chamada req :
{
"bindings": [
{
"name": "req",
"direction": "in",
},
{
"name": "$return",
"direction": "out",
"type": "http"
}
]
}
O arquivo __init__.py contém o seguinte código de função:
def main(req):
user = req.params.get('user')
return f'Hello, {user}!'
Você também pode declarar explicitamente os tipos de atributo e o tipo de retorno na função usando
anotações do tipo Python. Isso ajuda você a usar o IntelliSense e os recursos de preenchimento
automático fornecidos por muitos editores de código Python.
import azure.functions
def main(req: azure.functions.HttpRequest) -> str:

user = req.params.get('user')
return f'Hello, {user}!'
Use as anotações do Python incluídas no pacote azure.functions.* para associar a entrada e as saídas a
seus métodos.
Ponto de entrada alternativo

Você pode alterar o comportamento padrão de uma função especificando opcionalmente as
propriedades scriptFile e entryPoint no arquivo Function. JSON . Por exemplo, a função. JSON a
seguir informa o tempo de execução para usar o método customentry() no arquivo Main.py , como o
ponto de entrada para sua função do Azure.
{
"scriptFile": "main.py",
"entryPoint": "customentry",
"bindings": [
...
]
}
Estrutura de pastas
A estrutura de pastas para um projeto de funções do Python é semelhante ao exemplo a seguir:
FunctionApp
| - MyFirstFunction
| | - __init__.py
| | - function.json
| | - example.py
| | - __init__.py
| | - function.json
| - SharedCode
| | - myFirstHelperFunction.py
| | - mySecondHelperFunction.py
| - host.json
| - requirements.txt
Há um arquivo host.json compartilhado que pode ser usado para configurar o aplicativo de funções.
Cada função possui seu próprio arquivo de código e arquivo de configuração de associação
(function.json).
O código compartilhado deve ser mantido em uma pasta separada. Para fazer referência a módulos na
pasta SharedCode, você pode usar a seguinte sintaxe:
from __app__.SharedCode import myFirstHelperFunction
Para fazer referência a módulos locais para uma função, você pode usar a sintaxe de importação
relativa da seguinte maneira:
from . import example
Ao implantar um projeto de função em seu aplicativo de funções no Azure, todo o conteúdo da pasta
FunctionApp deve ser incluído no pacote, mas não na própria pasta.
Gatilhos e entradas
As entradas são divididas em duas categorias no Azure Functions: entrada do gatilho e entrada
adicional. Embora sejam diferentes no arquivo function.json , o uso é idêntico no código Python.
Cadeias de conexão ou segredos para fontes de entrada e gatilho são mapeados para valores no
arquivo local.settings.json ao serem executados localmente e as configurações do aplicativo durante
a execução no Azure.
Por exemplo, o código a seguir demonstra a diferença entre os dois:
// function.json
{
"scriptFile": "__init__.py",
"bindings": [
{
"name": "req",
"direction": "in",
"route": "items/{id}"
},
{
"name": "obj",
"direction": "in",
"type": "blob",
"path": "samples/{id}",
}
]
}
// local.settings.json
{
"IsEncrypted": false,
"Values": {
"FUNCTIONS_WORKER_RUNTIME": "python",
"AzureWebJobsStorage": "<azure-storage-connection-string>"
}
}
# __init__.py
import logging
def main(req: func.HttpRequest,

obj: func.InputStream):
logging.info(f'Python HTTP triggered function processed: {obj.read()}')
Quando a função é invocada, a solicitação HTTP é transmitida para a função como req . Uma entrada
será recuperada do armazenamento de BLOBs do Azure com base na ID na URL de rota e
disponibilizada como obj no corpo da função. Aqui, a conta de armazenamento especificada é a cadeia
de conexão encontrada em, que é a mesma conta de armazenamento usada pelo aplicativo de funções.
outputs
A saída pode ser expressa em parâmetros de saída e em valores retornados. Se houver apenas uma
saída, recomendamos usar o valor retornado. Para múltiplas saídas, você precisará usar parâmetros de
saída.
Para usar o valor retornado de uma função como o valor de uma associação de saída, a propriedade
name da associação deve ser definida como $return em function.json .
Para produzir várias saídas, use o método set() fornecido pela interface azure.functions.Out para
atribuir um valor à associação. Por exemplo, a função a seguir pode enviar uma mensagem para uma
fila e também retornar uma resposta HTTP.
{
"bindings": [
{
"name": "req",
"direction": "in",
},
{
"name": "msg",
"direction": "out",
"type": "queue",
},
{
"name": "$return",
"direction": "out",
"type": "http"
}
]
}
def main(req: func.HttpRequest,

msg: func.Out[func.QueueMessage]) -> str:
message = req.params.get('body')
msg.set(message)
return message
Registro em log
O acesso ao agente de tempo de execução do Azure Functions está disponível por meio de um
manipulador logging raiz no seu aplicativo de funções. Esse agente é vinculado ao Application Insights
e permite sinalizar avisos e erros encontrados durante a execução da função.
O exemplo a seguir registra uma mensagem de informações quando a função é invocada por meio de
um gatilho HTTP.
import logging
def main(req):
logging.info('Python HTTP trigger function processed a request.')
Há outros métodos de registro em log disponíveis que permitem a gravação no console em níveis de
rastreamento diferentes:
MÉTODO DESCRIÇÃO
critical(_message_) Grava uma mensagem com nível CRÍTICO no agente

raiz.
error(_message_) Grava uma mensagem com nível ERRO no agente raiz.
warning(_message_) Grava uma mensagem com nível AVISO no agente raiz.
info(_message_) Grava uma mensagem com nível INFORMAÇÕES no

agente raiz.
debug(_message_) Grava uma mensagem com nível DEPURAR no agente

raiz.
Para saber mais sobre registro em log, consulte monitorar Azure Functions.

O gatilho HTTP é definido no arquivo function. Jon. O name da associação deve corresponder ao
parâmetro nomeado na função. Nos exemplos anteriores, um nome de associação req é usado. Esse
parâmetro é um objeto HttpRequest e um objeto HttpResponse é retornado.
No objeto HttpRequest , você pode obter cabeçalhos de solicitação, parâmetros de consulta,
parâmetros de rota e o corpo da mensagem.
O exemplo a seguir é do modelo de gatilho http para Python.

headers = {"my-http-header": "some-value"}
if not name:
try:
except ValueError:
pass
else:
if name:
return func.HttpResponse(f"Hello {name}!", headers=headers)
else:
headers=headers, status_code=400
)
Nessa função, o valor do parâmetro de consulta name é obtido do parâmetro params do objeto
HttpRequest . O corpo da mensagem codificada em JSON é lido usando o método get_json .
Da mesma forma, você pode definir o status_code e headers para a mensagem de resposta no objeto
HttpResponse retornado.
Simultaneidade
Por padrão, as funções de tempo de execução do Python só podem processar uma invocação de uma
função por vez. Esse nível de simultaneidade pode não ser suficiente em uma ou mais das seguintes
condições:
Você está tentando lidar com várias invocações sendo feitas ao mesmo tempo.
Você está processando um grande número de eventos de e/s.
Seu aplicativo está associado à e/s.
Nessas situações, você pode melhorar o desempenho executando de forma assíncrona e usando vários
processos de trabalho de linguagem.
Assíncrono
Recomendamos que você use a instrução async def para fazer com que sua função seja executada
como uma corrotina assíncrona.
# Runs with asyncio directly
async def main():

await some_nonblocking_socket_io_op()
Quando a função main() é síncrona (sem o qualificador de async ), a função é executada

automaticamente em um pool de threads asyncio .
# Runs in an asyncio thread-pool
def main():
some_blocking_socket_io()
Usar vários processos de trabalho de idioma

Por padrão, cada instância de host do Functions tem um processo de trabalho de idioma único. No
entanto, há suporte para ter vários processos de trabalho de idioma por instância de host. As
invocações de função podem ser distribuídas uniformemente entre esses processos de trabalho de
linguagem. Use a configuração FUNCTIONS_WORKER_PROCESS_COUNT aplicativo para alterar
esse valor.
Contexto
Para obter o contexto de invocação de uma função durante a execução, inclua o argumento context
em sua assinatura.
Por exemplo:
import azure.functions
def main(req: azure.functions.HttpRequest,

context: azure.functions.Context) -> str:
return f'{context.invocation_id}'
A classe de contexto tem os seguintes atributos de cadeia de caracteres:

function_directory
O diretório no qual a função está em execução.
function_name
Nome da função.
invocation_id
ID da invocação de função atual.
Variáveis globais
Não há garantia de que o estado do seu aplicativo será preservado para execuções futuras. No entanto,
o tempo de execução de Azure Functions geralmente reutiliza o mesmo processo para várias execuções
do mesmo aplicativo. Para armazenar em cache os resultados de uma computação cara, declare-o
como uma variável global.
CACHED_DATA = None
def main(req):
global CACHED_DATA
if CACHED_DATA is None:
CACHED_DATA = load_json()
# ... use CACHED_DATA in code
Em funções, as configurações de aplicativo, como cadeias de conexão de serviço, são expostas como
variáveis de ambiente durante a execução. Você pode acessar essas configurações declarando
import os e, em seguida, usando, setting = os.environ["setting-name"] .
O exemplo a seguir obtém a configuração do aplicativo, com a chave chamada myAppSetting :
import logging
import os
# Get the setting named 'myAppSetting'

my_app_setting_value = os.environ["myAppSetting"]
logging.info(f'My app setting value:{my_app_setting_value}')
Para o desenvolvimento local, as configurações do aplicativo são mantidas no arquivo local. Settings.
JSON.
Versão do Python e gerenciamento de pacote

Atualmente, o Azure Functions dá suporte apenas a Python 3.6.x (distribuição oficial do CPython).
Ao desenvolver localmente usando o Azure Functions Core Tools ou o Visual Studio Code, adicione os
nomes e as versões dos pacotes necessários para os arquivos requirements.txt e instale-os usando
pip .
Por exemplo, o arquivo de requisitos e comando pip a seguir podem ser usados para instalar o pacote
requests do PyPI.
requests==2.19.1
pip install -r requirements.txt

Publicando no Azure
Quando você estiver pronto para publicar, verifique se todas as suas dependências estão listadas no
arquivo requirements. txt , que está localizado na raiz do diretório do projeto. Azure Functions pode
criar essas dependências remotamente.
Arquivos de projeto e pastas que são excluídos da publicação, incluindo a pasta de ambiente virtual, são
listados no arquivo. funcignore.
O Azure Functions Core Tools e a extensão de Azure Functions para vs Code executarão uma
compilação remota por padrão. Por exemplo, use o seguinte comando:
func azure functionapp publish <app name>
Se você quiser criar seu aplicativo localmente, em vez de no Azure, Instale o Docker no computador
local e execute o comando a seguir para publicar usando o Azure Functions Core Tools (Func). Lembre-
se de substituir <app name> pelo nome do aplicativo de funções no Azure.
func azure functionapp publish <app name> --build-native-deps
Nos bastidores, o Core Tools usará Docker para executar a imagem mcr.microsoft.com/azure-
functions/python como um contêiner em seu computador local. Usando esse ambiente, ele criará e
instalará os módulos necessários da distribuição de origem, antes de compactá-los para implantação
final no Azure.
Para criar suas dependências e publicar usando um sistema de entrega contínua (CD ), use Azure
pipelines.
Testes de unidade
As funções escritas em Python podem ser testadas como outros códigos Python usando estruturas de
teste padrão. Para a maioria das associações, é possível criar um objeto de entrada fictício criando uma
instância de uma classe apropriada do pacote azure.functions . Como o pacote de azure.functions
não está disponível imediatamente, certifique-se de instalá-lo por meio do arquivo requirements.txt ,
conforme descrito na seção versão e gerenciamento de pacotes do Python acima.
Por exemplo, a seguir está um teste fictício de uma função disparada por HTTP:
{
"scriptFile": "httpfunc.py",
"entryPoint": "my_function",
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
}
]
}
# myapp/httpfunc.py
import logging
def my_function(req: func.HttpRequest) -> func.HttpResponse:

logging.info('Python HTTP trigger function processed a request.')
if not name:
try:
except ValueError:
pass
else:
if name:
return func.HttpResponse(f"Hello {name}")
else:
status_code=400
)
# myapp/test_httpfunc.py
import unittest

from httpfunc import my_function
class TestFunction(unittest.TestCase):
def test_my_function(self):
# Construct a mock HTTP request.
req = func.HttpRequest(
method='GET',
body=None,
url='/api/HttpTrigger',
params={'name': 'Test'})
# Call the function.

resp = my_function(req)
# Check the output.

self.assertEqual(
resp.get_body(),
b'Hello Test',
)
Aqui está outro exemplo, com uma função disparada por fila:
# myapp/__init__.py
def my_function(msg: func.QueueMessage) -> str:

return f'msg body: {msg.get_body().decode()}'
# myapp/test_func.py
import unittest

from . import my_function
class TestFunction(unittest.TestCase):
def test_my_function(self):
# Construct a mock Queue message.
req = func.QueueMessage(
body=b'test')
# Call the function.

resp = my_function(req)
# Check the output.

self.assertEqual(
resp,
'msg body: test',
)
Arquivos temporários
O método tempfile.gettempdir() retorna uma pasta temporária, que no Linux é /tmp . Seu aplicativo
pode usar esse diretório para armazenar arquivos temporários gerados e usados por suas funções
durante a execução.
IMPORTANT
Os arquivos gravados no diretório temporário não têm garantia de persistir entre invocações. Durante o scale
out, os arquivos temporários não são compartilhados entre instâncias.
O exemplo a seguir cria um arquivo temporário nomeado no diretório temporário ( /tmp ):
import logging
import tempfile
from os import listdir
#---
tempFilePath = tempfile.gettempdir()
fp = tempfile.NamedTemporaryFile()
fp.write(b'Hello world!')
filesDirListInTemp = listdir(tempFilePath)
Problemas conhecidos e perguntas frequentes

Todos os problemas conhecidos e solicitações de recursos são controlados usando a lista Problemas do
GitHub. Se você tiver um problema e não for possível localizá-lo no GitHub, abra um novo problema e
inclua uma descrição detalhada dele.
Compartilhamento de recursos entre origens
O Azure Functions dá suporte ao compartilhamento de recursos entre origens (CORS ). O CORS é
configurado no portal e por meio do CLI do Azure. A lista de origens permitidas pelo CORS aplica-se
ao nível do aplicativo de funções. Com o CORS habilitado, as respostas incluem o cabeçalho
Access-Control-Allow-Origin . Para obter mais informações, consulte Compartilhamento de recursos
entre origens.
Atualmente, a lista de origens permitidas não tem suporte para aplicativos de funções do Python.
Devido a essa limitação, você deve definir expressamente o cabeçalho Access-Control-Allow-Origin em
suas funções HTTP, conforme mostrado no exemplo a seguir:
# Define the allow origin headers.

headers = {"Access-Control-Allow-Origin": "https://contoso.com"}
# Set the headers in the response.

f"Allowed origin '{headers}'.",
headers=headers, status_code=200
)
Certifique-se de também atualizar seu function. JSON para dar suporte ao método HTTP OPTIONS:
...
"methods": [
"get",
"post",
"options"
]
...
Esse método é usado pelo navegador Chrome para negociar a lista de origens permitidas.
Próximas etapas
Documentação da API do pacote Azure Functions
Gatilhos e de associações do Azure Functions
Associações do armazenamento de blobs
Associações HTTP e webhook
Associações de Armazenamento de Filas
Gatilho de temporizador
Guia do desenvolvedor de JavaScript do
Azure Functions
Este guia contém informações sobre as complexidades de escrever Azure Functions com
JavaScript.
Uma função JavaScript é um function exportado que é executado quando acionado ( acionadores
são configurados em function.json). O primeiro argumento passado para cada função é um objeto
context , que é usado para receber e enviar dados de associação, registro em log e comunicação
com o tempo de execução.
Este artigo pressupõe que você já tenha lido a Referência do desenvolvedor do Azure Functions.
Conclua o início rápido do Functions para criar sua primeira função, usando Visual Studio Code ou
no portal.
Este artigo também dá suporte ao desenvolvimento de aplicativos TypeScript.
Estrutura de pastas
A estrutura de pastas necessárias para um projeto JavaScript é semelhante à seguinte. Este padrão
pode ser alterado. Para mais informações, consulte a seção scriptArquivo abaixo.
FunctionsProject
| - MyFirstFunction
| | - index.js
| | - function.json
| | - index.js
| | - function.json
| - SharedCode
| | - myFirstHelperFunction.js
| | - mySecondHelperFunction.js
| - node_modules
| - host.json
| - package.json
Na raiz do projeto, há um arquivo host.json compartilhado que pode ser usado para configurar o
aplicativo de funções. Cada função tem uma pasta com seu próprio arquivo de código (.js) e o
arquivo de configuração de associação (function.json). O nome do diretório pai de function.json é
sempre o nome da sua função.
As extensões de associação necessárias na versão 2.x do tempo de execução do Functions são
definidas no arquivo extensions.csproj , com os arquivos de biblioteca reais na pasta bin . Ao
desenvolver localmente, você precisa registrar as extensões de associação. Ao desenvolver funções
no portal do Azure, esse registro é feito para você.
Exportando uma função

As funções JavaScript precisam ser exportadas por meio de module.exports (ou exports ). Sua
função exportada deve ser uma função JavaScript que é executada quando acionada.
Por padrão, o tempo de execução de Funções procura sua função em index.js , onde index.js
compartilha o mesmo diretório pai que o function.json correspondente. No caso padrão, sua
função exportada deve ser a única exportação de seu arquivo ou a exportação denominada run
ou index . Para configurar o local do arquivo e o nome de exportação da função, leia Configurando
o ponto de entrada da função abaixo.
Sua função exportada é passada um número de argumentos na execução. O primeiro argumento é
sempre um objeto context . Se sua função for síncrona (não retorna uma promessa), você deve
passar o objeto context , já que a chamada context.done é necessária para uso correto.
// You should include context, other arguments are optional

module.exports = function(context, myTrigger, myInput, myOtherInput) {
context.done();
};
Exportando uma função assíncrona

Ao usar a declaração async function ou o JavaScript simples Promises na versão 2.x do tempo de
execução Functions, não é necessário chamar explicitamente o context.done retorno de chamada
para sinalizar que sua função foi concluída. Sua função é concluída quando a função assíncrona
exportada / Promise é concluída. Para funções que visam o tempo de execução da versão 1.x, você
ainda deve chamar context.done quando seu código terminar de ser executado.
O exemplo a seguir é uma função simples que registra que foi acionada e imediatamente conclui a
execução.

context.log('JavaScript trigger function processed a request.');
};
Ao exportar uma função assíncrona, você também pode configurar uma ligação de saída para
obter o valor return . Isso é recomendado se você tiver apenas uma associação de saída.
Para atribuir uma saída usando return , altere o name propriedade a ser $return em
function.json .
{
"type": "http",
"direction": "out",
"name": "$return"
}
Nesse caso, sua função deve se parecer com o seguinte exemplo:

// You can call and await an async method here
return {
body: "Hello, world!"
};
}
Associações
Em JavaScript, ligações são configuradas e definidas na função function.json. As funções interagem
com as ligações de várias maneiras.
Entradas
As entradas são divididas em duas categorias no Azure Functions: uma é a entrada de gatilho e a
outra é a entrada adicional. Trigger e outras ligações de entrada (ligações de direction === "in" )
podem ser lidas por uma função de três maneiras:
[Recomendado] Como parâmetros passados para sua função. Eles são passados para a
função na mesma ordem em que são definidos function.json. A propriedade name definida
em Function. JSON não precisa corresponder ao nome do parâmetro, embora deva ser.
module.exports = async function(context, myTrigger, myInput, myOtherInput) { ... };
Como os membros de context.bindings objeto. Observe que a propriedade name

definida em function.json não precisa corresponder ao nome do seu parâmetro, embora
deva....

context.log("This is myTrigger: " + context.bindings.myTrigger);
context.log("This is myInput: " + context.bindings.myInput);
context.log("This is myOtherInput: " + context.bindings.myOtherInput);
};
Como entradas usando o arguments objeto JavaScript. Isso é essencialmente o mesmo

que passar entradas como parâmetros, mas permite que você manipule dinamicamente
entradas.

context.log("This is myTrigger: " + arguments[1]);
context.log("This is myInput: " + arguments[2]);
context.log("This is myOtherInput: " + arguments[3]);
};
outputs
As saídas (ligações de direction === "out" ) podem ser gravadas por uma função de várias
maneiras. Em todos os casos, a propriedade name da ligação, conforme definido em function.json,
corresponde ao nome do membro do objeto gravado na sua função.
Você pode atribuir dados a associações de saída de uma das seguintes maneiras (não Combine
esses métodos):
[Recomendado para várias saídas] Retornando um objeto. Se você estiver usando uma
função de retorno de Async/Promise, poderá retornar um objeto com os dados de saída
atribuídos. No exemplo abaixo, as ligações de saída são nomeadas "httpResponse" e
"queueOutput" em function.json.
return {
httpResponse: {
body: retMsg
},
queueOutput: retMsg
};
};
Se você estiver usando uma função síncrona, você pode retornar este objeto usando
context.done (veja o exemplo).
[Recomendado para saída única] Retornando um valor diretamente e usando o nome

de ligação $ return. Isso funciona apenas para as funções de retorno assíncrono /
Promessa. Veja o exemplo em exportando uma função assíncrona.
Atribuindo valores a serem context.bindings você pode atribuir valores diretamente
para Context. Bindings.

context.bindings.httpResponse = {
body: retMsg
};
context.bindings.queueOutput = retMsg;
return;
};
Tipo de dados de associações

Para definir o tipo de dados para uma associação de entrada, use a propriedade dataType na
definição de associação. Por exemplo, para ler o conteúdo de uma solicitação HTTP em formato
binário, use o tipo binary :
{
"name": "req",
"direction": "in",
"dataType": "binary"
}
As opções para dataType são: binary , stream e string .
objeto de contexto
O tempo de execução usa um objeto context para passar dados de/para sua função e permitir
que você se comunique com o tempo de execução. O objeto de contexto pode ser usado para ler e
definir os dados de associações, gravar logs e usando o context.done retorno de chamada quando
a função exportada é síncrona.
O context objeto é sempre o primeiro parâmetro para uma função. Deve ser incluído porque tem
métodos importantes, como context.done e context.log . Você pode nomear o objeto de acordo
com a sua preferência (por exemplo, ctx ou c ).
// You must include a context, but other arguments are optional
module.exports = function(ctx) {
ctx.done();
};
Propriedade context.bindings
context.bindings
Retorna um objeto nomeado que é usado para ler ou atribuir dados de associação. Dados de
associação de entrada e gatilho podem ser acessados pela leitura de propriedades em
context.bindings . Os dados de associação de saída podem ser atribuídos adicionando dados a
context.bindings
Por exemplo, as seguintes definições de ligação em sua função.json permitem acessar o conteúdo
de uma fila de context.bindings.myInput e atribuir saídas a uma fila usando
context.bindings.myOutput .
{
"type":"queue",
"direction":"in",
"name":"myInput"
...
},
{
"type":"queue",
"direction":"out",
"name":"myOutput"
...
}
// myInput contains the input data, which may have properties such as "name"
var author = context.bindings.myInput.name;
// Similarly, you can set your output data
context.bindings.myOutput = {
some_text: 'hello world',
a_number: 1 };
Você pode optar por definir os dados de ligação de saída usando o método context.done em vez
do objeto context.binding (veja abaixo).
Propriedade context.bindingData
context.bindingData
Retorna um objeto nomeado que contém dados de invocação de função e os metadados do gatilho
( invocationId , sys.methodName , sys.utcNow , sys.randGuid ). Para obter um exemplo de metadados
de gatilho, confira este exemplo de hubs de eventos.
Método context.done
context.done([err],[propertyBag])
Permite que o runtime saiba que seu código foi concluído. Quando sua função usa a declaração
async function , você não precisa usar context.done() . O context.done retorno de chamada é
chamado implicitamente. As funções assíncronas estão disponíveis no Nó 8 ou em uma versão
posterior, que requer a versão 2.x do runtime de Funções.
Se a função não é uma função assíncrona, você precisa chamar context.done para informar ao
tempo de execução que a função está concluída. Os tempos de execução se está ausente.
O método context.done permite que você retorne um erro definido pelo usuário ao tempo de
execução e um objeto JSON que contém dados de associação de saída. As propriedades
transmitidas para context.done sobrescrevem qualquer coisa definida no objeto context.bindings .
// Even though we set myOutput to have:

// -> text: 'hello world', number: 123
context.bindings.myOutput = { text: 'hello world', number: 123 };
// If we pass an object to the done function...
context.done(null, { myOutput: { text: 'hello there, world', noNumber: true }});
// the done method overwrites the myOutput binding to be:
// -> text: 'hello there, world', noNumber: true
Método context.log
context.log(message)
Permite que você grave em logs de função de streaming no nível de rastreamento padrão. No
context.log , há métodos de registro adicionais disponíveis para permitir que você grave logs de
função em outros níveis de rastreamento:
MÉTODO DESCRIÇÃO
error(message) Grava no registro em log no nível do erro, ou em um

nível inferior.
warn(message) Grava no registro em log no nível do aviso, ou em

um nível inferior.
info(message) Grava no registro em log no nível da informação, ou

em um nível inferior.
verbose(message) Grava no registro em log no nível detalhado.
O exemplo a seguir grava um log no nível de rastreamento de aviso:
context.log.warn("Something has happened.");
Você pode configurar o limite do nível de rastreamento para registro em log no arquivo host.json.
Para obter mais informações sobre como gravar logs, confira Gravando saídas de rastreamento
abaixo.
Leia Monitorado o Azure Functions para saber mais sobre como exibir e consultar logs de função.
Gravar a saída de rastreamento no console

No Functions, use os métodos context.log para gravar a saída de rastreamento no console. No
Functions v2.x, as saídas de rastreio usando console.log são capturadas no nível do Aplicativo
Function. Isso significa que as saídas de console.log não estão vinculadas a uma invocação de
função específica e não são exibidas em logs de uma função específica. Eles, no entanto, se
propagam para o Application Insights. No Functions v1.x, não é possível usar console.log para
gravar no console.
Quando você chama context.log() , sua mensagem é gravada no console no nível de
rastreamento padrão, que é o nível de rastreamento de informações. O código a seguir grava no
console no nível de rastreamento de informações:
context.log({hello: 'world'});
Esse código é equivalente ao código acima:
context.log.info({hello: 'world'});
Esse código grava no console no nível de erro:
context.log.error("An error has occurred.");
Como erro é o nível de rastreamento mais alto, esse rastreamento é gravado na saída em todos os
níveis de rastreamento enquanto o registro em log estiver habilitado.
Todos os métodos context.log dão suporte ao mesmo formato de parâmetro que o método
util.format de Node.js. Considere o código a seguir, que grava logs de função usando o nível de
rastreamento padrão:
context.log('Node.js HTTP trigger function processed a request. RequestUri=' +

req.originalUrl);
context.log('Request Headers = ' + JSON.stringify(req.headers));
Você também pode escrever o mesmo código no formato a seguir:
context.log('Node.js HTTP trigger function processed a request. RequestUri=%s',

req.originalUrl);
context.log('Request Headers = ', JSON.stringify(req.headers));
Configurar o nível de rastreamento para o registro em log no console

O Functions 1.x permite a definição do nível de rastreamento de limite para gravar no console, o
que facilita o controle do modo de gravação dos rastreamentos no console da sua função. Para
definir o limite para todos os rastreamentos gravados no console, use a propriedade
tracing.consoleLevel no arquivo host.json. Essa configuração se aplica a todas as funções em seu
aplicativo de função. O exemplo a seguir define o limite de rastreamento para habilitar o registro
em log detalhado:
{
"tracing": {
"consoleLevel": "verbose"
}
}
Os valores de consoleLevel correspondem aos nomes dos métodos context.log . Para desabilitar
todo o registro em log do rastreamento no console, defina consoleLevel como off. Para obter
mais informações, consulte a referência para host.json.

HTTP e gatilhos de webhook e associações de saída HTTP usam objetos de solicitação e resposta
para representar as mensagens HTTP.
Objeto da solicitação
O objeto context.req (solicitação) tem as seguintes propriedades:
body Um objeto que contém o corpo da solicitação.
headers Um objeto que contém os cabeçalhos da solicitação.
method O método HTTP da solicitação.
originalUrl A URL da solicitação.
params Um objeto que contém os parâmetros de

roteamento da solicitação.
query Um objeto que contém os parâmetros da consulta.
rawBody O corpo da mensagem como uma cadeia de

caracteres.
Objeto de resposta
O objeto context.res (resposta) tem as seguintes propriedades:
body Um objeto que contém o corpo da resposta.
headers Um objeto que contém os cabeçalhos da resposta.
isRaw Indica que a formatação foi ignorada para a resposta.
status O código de status HTTP da resposta.
Acessar a solicitação e a resposta

Ao trabalhar com gatilhos HTTP, há várias maneiras de acessar os objetos de solicitação e resposta
HTTP:
Partir req e res propriedades no context objeto. Dessa forma, você pode usar o
padrão convencional para acessar os dados HTTP a partir do objeto de contexto, em vez de
usar o padrão context.bindings.name completo. O exemplo a seguir mostra como acessar
os objetos req e res no context :
// You can access your http request off the context ...
if(context.req.body.emoji === ':pizza:') context.log('Yay!');
// and also set your http response
context.res = { status: 202, body: 'You successfully ordered more coffee!' };
Na entrada nomeada e associações de saída. Dessa forma, o gatilho e as associações de

HTTP funcionam da mesma forma que qualquer outra associação. O exemplo a seguir
define o objeto de resposta usando uma associação chamada response :
{
"type": "http",
"direction": "out",
"name": "response"
}
context.bindings.response = { status: 201, body: "Insert succeeded." };
[Somente Resposta] Chamando context.res.send(body?: any) . Uma resposta HTTP é

criada com a entrada body como o corpo da resposta. context.done() é chamado
implicitamente.
[Somente Resposta] Chamando context.done() . Um tipo especial de associação HTTP
retorna a resposta que é passada para o método context.done() . A seguinte associação de
saída HTTP define um parâmetro de saída $return :
{
"type": "http",
"direction": "out",
"name": "$return"
}
// Define a valid response object.

res = { status: 201, body: "Insert succeeded." };
context.done(null, res);
Versão do nó
A tabela a seguir mostra a versão do Node.js usada por cada versão principal do runtime do
Functions:
VERSÃO DO FUNCTIONS VERSÃO DO NODE.JS
1.x 6.11.2 (bloqueada pelo runtime)
2. x Active LTS e Maintenance LTS versões do node. js

(aproximadamente, 10 recomendado). Direcione a
versão no Azure definindo a configuração do
aplicativo WEBSITE_NODE_DEFAULT_VERSION como
~10 .
Veja versão atual que o tempo de execução está usando verificando a configuração de aplicativo
acima ou imprimindo process.version de qualquer função.
Gerenciamento de dependências
Para usar as bibliotecas da comunidade no código JavaScript, como é mostrado no exemplo
abaixo, você precisa garantir que todas as dependências sejam instaladas no aplicativo de funções
no Azure.
// Import the underscore.js library

var _ = require('underscore');
var version = process.version; // version === 'v6.5.0'
// Using our imported underscore.js library
var matched_names = _
.where(context.bindings.myInput.names, {first: 'Carla'});
NOTE
Você deve definir um arquivo package.json na raiz do seu aplicativo de função. A definição de arquivo
permite que todas as funções no aplicativo compartilhem os mesmos pacotes armazenados em cache, o
que oferece o melhor desempenho. Se houver conflitos de versão, você poderá resolver o conflito
adicionando um arquivo package.json na pasta de uma função específica.
Ao implantar os aplicativos de função do controle de origem, qualquer arquivo package.json

presente em seu repositório acionará um npm install em sua pasta durante a implantação. Mas
ao implantar via Portal ou CLI, você terá que instalar manualmente os pacotes.
Há duas maneiras de instalar pacotes no aplicativo de funções:
Implantando com dependências
1. Instale todos os pacotes necessários localmente executando npm install .
2. Implante o código e verifique se a pasta node_modules está incluída na implantação.
Usando o Kudu
1. Vá para https://<function_app_name>.scm.azurewebsites.net .
2. Clique em Console de Depuração > CMD.
3. Acesse D:\home\site\wwwroot e arraste o arquivo package.json para a pasta wwwroot na
metade superior da página.
Também há outras maneiras de carregar arquivos em seu aplicativo de função. Para saber
mais, confira Como atualizar os arquivos do aplicativo de função.
4. Depois que o arquivo package.json é carregado, execute o comando npm install no
console de execução remota do Kudu.
Essa ação baixa os pacotes indicados no arquivo package.json e reinicia o aplicativo de
função.
Em funções, configurações do aplicativo, como conexão de serviço cadeias de caracteres, são
expostas como variáveis de ambiente durante a execução. Você pode acessar essas configurações
usando process.env , conforme mostrado aqui na segunda e terceira chamadas para
context.log() em que registramos as variáveis de ambiente AzureWebJobsStorage e
WEBSITE_SITE_NAME :
module.exports = async function (context, myTimer) {

context.log("AzureWebJobsStorage: " + process.env["AzureWebJobsStorage"]);
context.log("WEBSITE_SITE_NAME: " + process.env["WEBSITE_SITE_NAME"]);
};

No portal do Azure.
Ao executar localmente, as configurações do aplicativo são lidos a partir de Settings arquivo de
projeto.
Configurar o ponto de entrada de função

As propriedades scriptFile e entryPoint do function.json podem ser usadas para configurar o
local e o nome da função exportada. Essas propriedades podem ser importantes quando seu
JavaScript é transferido.
Usando o scriptFile
Por padrão, uma função JavaScript é executada do index.js , um arquivo que compartilha o
mesmo diretório pai que seu function.json correspondente.
scriptFile pode ser usado para obter uma estrutura de pastas semelhante ao exemplo a seguir:
FunctionApp
| - host.json
| - myNodeFunction
| | - function.json
| - lib
| | - sayHello.js
| - node_modules
| | - ... packages ...
| - package.json
O function.json da myNodeFunction deve incluir uma propriedade scriptFile que aponte para o
arquivo com a função exportada a ser executada.
{
"scriptFile": "../lib/sayHello.js",
"bindings": [
...
]
}
Usando o entryPoint
No scriptFile (ou index.js ), uma função precisa ser exportada usando module.exports para ser
localizada e executada. Por padrão, a função que é executada quando disparada é a única
exportação desse arquivo, a exportação denominada run ou a exportação denominada index .
Isso pode ser configurado usando entryPoint em function.json , como no exemplo a seguir:
{
"entryPoint": "logFoo",
"bindings": [
...
]
}
No Functions v2.x, que suporta o parâmetro this nas funções do usuário, o código da função
poderia ser como no seguinte exemplo:
class MyObj {
constructor() {
this.foo = 1;
};
logFoo(context) {
context.log("Foo is " + this.foo);
context.done();
}
}
const myObj = new MyObj();

module.exports = myObj;
Neste exemplo, é importante observar que, embora um objeto esteja sendo exportado, não há
nenhuma garantia para preservar o estado entre as execuções.
Depuração local
Quando iniciado com o parâmetro --inspect , um processo node. js escuta um cliente de
depuração na porta especificada. No Azure Functions 2. x, você pode especificar argumentos para
passar para o processo node. js que executa seu código adicionando a variável de ambiente ou
configuração de aplicativo languageWorkers:node:arguments = <args> .
Para depurar localmente, adicione "languageWorkers:node:arguments": "--inspect=5858" em Values
no arquivo local. Settings. JSON e anexe um depurador à porta 5858.
Ao depurar usando VS Code, o parâmetro --inspect é adicionado automaticamente usando o
valor port no arquivo launch. JSON do projeto.
Na versão 1. x, a configuração languageWorkers:node:arguments não funcionará. A porta de
depuração pode ser selecionada com o parâmetro --nodeDebugPort no Azure Functions Core
Tools.
TypeScript
Quando você visa a versão 2. x do tempo de execução do functions, ambos Azure Functions para
Visual Studio Code e o Azure Functions Core Tools permitem criar aplicativos de funções usando
um modelo que ofereça suporte a projetos de aplicativo de função TypeScript. O modelo gera
package.json e tsconfig.json arquivos de projeto que facilitam a transcompile, a execução e a
publicação de funções JavaScript a partir do código TypeScript com essas ferramentas.
Um arquivo de .funcignore gerado é usado para indicar quais arquivos são excluídos quando um
projeto é publicado no Azure.
Os arquivos TypeScript (. TS ) são transcompilados em arquivos JavaScript (. js) no diretório de
saída dist . Os modelos do TypeScript usam o parâmetro scriptFile no function.json para
indicar o local do arquivo. js correspondente na pasta dist . O local de saída é definido pelo
modelo usando outDir parâmetro no arquivo de tsconfig.json . Se você alterar essa
configuração ou o nome da pasta, o tempo de execução não será capaz de localizar o código a ser
executado.
NOTE
O suporte experimental para TypeScript existe na versão 1. x do tempo de execução do functions. A versão
experimental compila os arquivos TypeScript em arquivos JavaScript quando a função é invocada. Na
versão 2. x, esse suporte experimental foi substituído pelo método controlado por ferramentas que faz
transpilação antes do host ser inicializado e durante o processo de implantação.
A maneira como você desenvolve e implanta localmente a partir de um projeto TypeScript

depende de sua ferramenta de desenvolvimento.
O Azure Functions para Visual Studio Code extensão permite desenvolver suas funções usando o
TypeScript. As ferramentas principais são um requisito da extensão de Azure Functions.
Para criar um aplicativo de função TypeScript no Visual Studio Code, escolha TypeScript como
seu idioma ao criar um aplicativo de funções.
Quando você pressiona F5 para executar o aplicativo localmente, o transpilação é feito antes que o
host (Func. exe) seja inicializado.
Quando você implanta seu aplicativo de funções no Azure usando o botão implantar no
aplicativo de funções... , a extensão Azure Functions primeiro gera uma compilação pronta para
produção de arquivos JavaScript dos arquivos de origem do TypeScript.
Azure Functions Core Tools
Há várias maneiras pelas quais um projeto TypeScript difere de um projeto JavaScript ao usar as
ferramentas principais.
Criar projeto
Para criar um projeto de aplicativo de função TypeScript usando ferramentas básicas, você deve
especificar a opção de linguagem TypeScript ao criar seu aplicativo de funções. Você pode fazer
isso de uma das seguintes maneiras:
Execute o comando func init , selecione node como sua pilha de idiomas e, em seguida,
selecione typescript .
Execute o comando func init --worker-runtime typescript .
Executar local
Para executar o código do aplicativo de funções localmente usando as ferramentas básicas, use os
seguintes comandos em vez de func host start :
npm install
npm start
O comando npm start é equivalente aos seguintes comandos:

npm run build
tsc
func start
Publicar no Azure
Antes de usar o comando func azure functionapp publish para implantar no Azure, você cria uma
compilação de arquivos JavaScript pronta para produção a partir dos arquivos de origem do
TypeScript.
Os comandos a seguir preparam e publicam seu projeto TypeScript usando ferramentas básicas:

Neste comando, substitua <APP_NAME> pelo nome do seu aplicativo de funções.
Considerações para funções em JavaScript

Ao trabalhar com funções JavaScript, lembre-se das considerações nas seções a seguir.
Escolher Planos do Serviço de Aplicativo de vCPU único
Ao criar um aplicativo de funções que usa o Plano do Serviço de Aplicativo, recomendamos que
você selecione um plano de vCPU único em vez de um plano com vários vCPUs. Atualmente, o
Functions executa funções em JavaScript com mais eficiência em VMs de vCPU único, e o uso de
VMs maiores não produz os aprimoramentos de desempenho esperados. Quando necessário, você
pode escalar horizontalmente manualmente Adicionando mais instâncias de VM de vCPU único
ou pode habilitar o dimensionamento automático. Para obter mais informações, consulte
Dimensionar a contagem de instâncias manual ou automaticamente.
Inicialização a frio
No desenvolvimento de Azure Functions no modelo de hospedagem sem servidor, as inicializações
a frio são uma realidade. Partida a frio refere-se ao fato de que, quando seu aplicativo de função é
iniciado pela primeira vez após um período de inatividade, leva mais tempo para inicializar. Para
funções JavaScript com árvores de dependência grandes em particular, o cold start pode ser
significativo. Para acelerar o processo de inicialização a frio, execute suas funções como um arquivo
de pacote quando possível. Muitos métodos de implantação usam a execução do modelo de pacote
por padrão, mas se você estiver experimentando grandes reinicializações a frio e não estiver sendo
executado dessa maneira, essa alteração poderá oferecer uma melhoria significativa.
Limites de conexão
Quando você usa um cliente específico do serviço em um aplicativo Azure Functions, não crie um
novo cliente com cada invocação de função. Em vez disso, crie um único cliente estático no escopo
global. Para obter mais informações, consulte Managing Connections in Azure Functions.
Usar async e await
Ao escrever Azure Functions em JavaScript, você deve escrever código usando as palavras-chave
async e await . Escrever código usando async e await em vez de retornos de chamada ou
.then e .catch com promessas ajuda a evitar dois problemas comuns:
Lançar exceções não capturadas que falham no processo node. js, potencialmente afetando a
execução de outras funções.
Comportamento inesperado, como logs ausentes de Context. log, causados por chamadas
assíncronas que não estão aguardando corretamente.
No exemplo a seguir, o método assíncrono fs.readFile é invocado com uma função de retorno de
chamada de erro-primeiro como seu segundo parâmetro. Esse código causa os dois problemas
mencionados acima. Uma exceção que não é detectada explicitamente no escopo correto falha em
todo o processo (problema #1). Chamar context.done() fora do escopo da função de retorno de
chamada significa que a invocação de função pode terminar antes da leitura do arquivo (problema
#2). Neste exemplo, a chamada a context.done() muito mais cedo resulta em entradas de log
ausentes começando com Data from file: .
// NOT RECOMMENDED PATTERN


fs.readFile('./hello.txt', (err, data) => {
if (err) {
// BUG #1: This will result in an uncaught exception that crashes the entire
process
throw err;
}
// context.done() should be called here
});
// BUG #2: Data is not guaranteed to be read before the Azure Function's invocation ends
context.done();
}
Usar as palavras-chave async e await ajuda a evitar esses dois erros. Você deve usar a função
utilitário node. js util.promisify para ativar as funções de estilo de retorno de chamada de erro
primeiro em funções awaitable.
No exemplo a seguir, todas as exceções não tratadas lançadas durante a execução da função falham
apenas na invocação individual que gerou uma exceção. A palavra-chave await significa que as
etapas a seguir readFileAsync executadas somente após a readFile ser concluída. Com async e
await , você também não precisa chamar o retorno de chamada do context.done() .
// Recommended pattern
const util = require('util');
const readFileAsync = util.promisify(fs.readFile);

let data;
try {
data = await readFileAsync('./hello.txt');
} catch (err) {
// This rethrown exception will be handled by the Functions Runtime and will only fail
the individual invocation
throw err;
}
}
Próximos passos
Visão geral do diagnóstico de Azure Functions
Quando você estiver executando um aplicativo de funções, você deseja estar preparado para quaisquer problemas
que possam surgir, de erros de 4xx para disparar falhas. O diagnóstico de Azure Functions é uma experiência
inteligente e interativa para ajudá-lo a solucionar problemas do seu aplicativo de funções sem nenhuma
configuração ou custo adicional. Quando você tiver problemas com seu aplicativo de funções, o diagnóstico de
Azure Functions indicará o que há de errado para orientá-lo sobre as informações corretas para solucionar
problemas e resolver o problema com mais facilidade e rapidez. Este artigo mostra as noções básicas de como usar
o diagnóstico de Azure Functions para diagnosticar e resolver mais rapidamente problemas comuns do aplicativo
de funções.
Iniciar o diagnóstico de Azure Functions

Para acessar o diagnóstico de Azure Functions:
1. Navegue até seu aplicativo de funções no portal do Azure.
2. Selecione a guia recursos da plataforma .
3. Selecione diagnosticar e solucionar problemas no Gerenciamento de recursos, que abre o diagnóstico de
Azure functions.
4. Escolha uma categoria que melhor descreva o problema do seu aplicativo de funções usando as palavras-chave
no bloco Home Page. Você também pode digitar uma palavra-chave que melhor descreva seu problema na
barra de pesquisa. Por exemplo, você pode digitar execution para ver uma lista de relatórios de diagnóstico
relacionados à sua execução de aplicativo de funções e abri-los diretamente da Home Page.
Usar a interface interativa
Depois de selecionar uma categoria de Home Page que melhor se alinha com o problema do seu aplicativo de
funções, a interface interativa do Azure Functions Diagnostics, o gênio, pode orientá-lo no diagnóstico e na
resolução do problema de seu aplicativo. Você pode usar os atalhos de bloco fornecidos pelo gênio para exibir o
relatório de diagnóstico completo da categoria do problema que você está interessado. Os atalhos de bloco
fornecem uma maneira direta de acessar suas métricas de diagnóstico.
Depois de selecionar um bloco, você poderá ver uma lista de tópicos relacionados ao problema descrito no bloco.
Esses tópicos fornecem trechos de informações notáveis do relatório completo. Você pode selecionar qualquer um
desses tópicos para investigar ainda mais os problemas. Além disso, você pode selecionar Exibir relatório
completo para explorar todos os tópicos em uma única página.
Exibir um relatório de diagnóstico

Depois de escolher um tópico, você pode exibir um relatório de diagnóstico específico para seu aplicativo de
funções. Os relatórios de diagnóstico usam ícones de status para indicar se há problemas específicos com seu
aplicativo. Você verá uma descrição detalhada do problema, as ações recomendadas, as métricas relacionadas e os
documentos úteis. Relatórios de diagnóstico personalizados são gerados de uma série de verificações executadas
em seu aplicativo de funções. Os relatórios de diagnóstico podem ser uma ferramenta útil para identificar
problemas em seu aplicativo de funções e orientá-lo para resolver o problema.
Localizar o código do problema

Para funções baseadas em script, você pode usar a execução de função e erros em aplicativo de funções ou
relatar erros para restringir a linha de código causando exceções ou erros. Esse recurso pode ser uma ferramenta
útil para chegar à causa raiz e corrigir problemas de uma linha de código específica. Essa opção não está disponível
para funções pré-compiladas C# e Java.
Próximas etapas
Você pode fazer perguntas ou fornecer comentários sobre o diagnóstico de Azure Functions no UserVoice. Inclua
[Diag] no título de seus comentários.
Monitorar seus aplicativos de funções

Estimando os custos do plano de consumo
Atualmente, há três tipos de planos de hospedagem para um aplicativo executado no Azure Functions, com cada
plano com seu próprio modelo de preços:
PLANO DESCRIÇÃO
Utilização Você é cobrado apenas pelo tempo em que seu aplicativo de

funções é executado. Esse plano inclui umapágina de preços
de [concessão gratuita]em uma base por assinatura.
Especiais Fornece os mesmos recursos e mecanismo de

dimensionamento que o plano de consumo, mas com o
desempenho aprimorado e o acesso à VNET. O custo é
baseado no tipo de preço escolhido. Para saber mais, confira
Azure Functions plano Premium.
Dedicado (serviço de aplicativo) Quando você precisa executar em VMs dedicadas ou

(camada básica ou superior) isoladamente, use imagens personalizadas ou deseja usar o
excesso de capacidade do plano do serviço de aplicativo. Usa
a cobrança regular do plano do serviço de aplicativo. O custo
é baseado no tipo de preço escolhido.
Você escolheu o plano que melhor dá suporte aos requisitos de desempenho e custo de sua função. Para saber
mais, confira Escala e hospedagem do Azure Functions.
Este artigo lida apenas com o plano de consumo, pois esse plano resulta em custos variáveis.
Durable Functions também pode ser executado em um plano de consumo. Para saber mais sobre as
considerações de custo ao usar Durable Functions, consulte Durable Functions cobrança.
Custos de plano de consumo

O custo de execução de uma única execução de função é medido em GB -segundos. O custo de execução é
calculado pela combinação de seu uso de memória com o tempo de execução. Uma função que é executada por
mais custa mais, como uma função que consome mais memória.
Considere um caso em que a quantidade de memória usada pela função permaneça constante. Nesse caso, o
cálculo do custo é uma multiplicação simples. Por exemplo, digamos que sua função consumiu 0,5 GB por 3
segundos. Em seguida, o custo de execução é 0.5GB * 3s = 1.5 GB-seconds .
Como o uso de memória muda ao longo do tempo, o cálculo é basicamente o integral do uso de memória ao
longo do tempo. O sistema faz esse cálculo por meio da amostragem do uso de memória do processo (juntamente
com processos filho) em intervalos regulares. Conforme mencionado na página de preços, o uso de memória é
arredondado para o bucket de 128 MB mais próximo. Quando seu processo estiver usando 160 MB, você será
cobrado por 256 MB. O cálculo leva em conta a simultaneidade, que é várias execuções de função simultâneas no
mesmo processo.
NOTE
Embora o uso da CPU não seja considerado diretamente no custo de execução, ele pode ter um impacto no custo quando
ele afeta o tempo de execução da função.
Outros custos relacionados

Ao estimar o custo geral da execução de suas funções em qualquer plano, lembre-se de que o tempo de execução
do Functions usa vários outros serviços do Azure, que são cobrados separadamente. Ao calcular os preços dos
aplicativos de funções, os gatilhos e associações que você tem que se integram a outros serviços do Azure exigem
que você crie e pague por esses serviços adicionais.
Para funções em execução em um plano de consumo, o custo total é o custo de execução de suas funções, além do
custo da largura de banda e de serviços adicionais.
Ao estimar os custos gerais do seu aplicativo de funções e dos serviços relacionados, use a calculadora de preços
do Azure.
CUSTO RELACIONADO DESCRIÇÃO
Conta de armazenamento Cada aplicativo de funções requer que você tenha um

associado Uso Geral conta de armazenamento do Azure, que
é cobrado separadamente. Essa conta é usada internamente
pelo tempo de execução do functions, mas você também
pode usá-la para gatilhos e associações de armazenamento.
Se você não tiver uma conta de armazenamento, uma será
criada para você quando o aplicativo de funções for criado.
Para saber mais, consulte requisitos da conta de
armazenamento.
Application Insights As funções dependem de Application insights para fornecer

uma experiência de monitoramento de alto desempenho para
seus aplicativos de funções. Embora não seja necessário, você
deve habilitar a integração de Application insights. Uma
concessão gratuita de dados de telemetria é incluída todos os
meses. Para saber mais, consulte a página de preços do Azure
monitor.
Largura de banda da rede Você não paga pela transferência de dados entre os serviços
do Azure na mesma região. No entanto, você pode incorrer
em custos para transferências de dados de saída para outra
região ou fora do Azure. Para saber mais, consulte detalhes de
preços de largura de banda.
Comportamentos que afetam o tempo de execução

Os seguintes comportamentos de suas funções podem afetar o tempo de execução:
Gatilhos e associações: O tempo necessário para ler a entrada e gravar a saída em suas associações de
função é contado como tempo de execução. Por exemplo, quando sua função usa uma associação de saída
para gravar uma mensagem em uma fila de armazenamento do Azure, o tempo de execução inclui o tempo
necessário para gravar a mensagem na fila, que está incluída no cálculo do custo da função.
Execução assíncrona: O tempo que sua função aguarda para os resultados de uma solicitação assíncrona
( await em C#) é contado como tempo de execução. O cálculo de GB por segundo é baseado na hora de
início e de término da função e no uso de memória nesse período. O que está acontecendo nesse tempo
em termos de atividade de CPU não é acrescentado ao cálculo. Talvez seja possível reduzir os custos
durante operações assíncronas usando Durable Functions. Você não é cobrado pelo tempo gasto em
Awaits em funções de orquestrador.
Exibir dados de execução

Em sua fatura, você pode exibir os dados relacionados ao custo das funções de execuções totais e funções de
tempo de execução, juntamente com os custos de cobrança reais. No entanto, esses dados da fatura são uma
agregação mensal para um período de nota fiscal passada.
Para entender melhor o impacto de custos de suas funções, você pode usar Azure Monitor para exibir as métricas
de custo que estão sendo geradas atualmente por seus aplicativos de funções. Você pode usar o Azure monitor
métricas Explorer no portal do Azure ou APIs REST para obter esses dados.
Monitorar métricas Explorer
Use Azure monitor métricas Explorer para exibir dados relacionados ao custo para seus aplicativos de função de
plano de consumo em um formato gráfico.
1. Na parte superior da portal do Azure em Pesquisar serviços, recursos e pesquisa de documentos para
monitor e selecione monitorar em Serviços.
2. À esquerda, selecione métricas > Selecione um recursoe, em seguida, use as configurações abaixo da
imagem para escolher seu aplicativo de funções.
Assinatura Sua assinatura A assinatura com seu aplicativo de

funções.
Grupo de recursos Seu grupo de recursos O grupo de recursos que contém seu
Tipo de recurso Serviços de Aplicativos Os aplicativos de funções são

mostrados como instâncias de
serviços de aplicativos no monitor.
Resource Seu aplicativo de funções O aplicativo de funções a ser

monitorado.
3. Selecione aplicar para escolher o aplicativo de funções como o recurso a ser monitorado.
4. Em métrica, escolha contagem de execução de função e soma para agregação. Isso adiciona a soma
das contagens de execução durante o período escolhido ao gráfico.
5. Selecione Adicionar métrica e repita as etapas 2-4 para adicionar unidades de execução de função ao
gráfico.
O gráfico resultante contém os totais para ambas as métricas de execução no intervalo de tempo escolhido, que
nesse caso é de duas horas.
Como o número de unidades de execução é muito maior do que a contagem de execução, o gráfico apenas
mostra as unidades de execução.
Este gráfico mostra um total de 1.110.000.000 Function Execution Units consumidos em um período de duas
horas, medido em MB -milissegundos. Para converter em GB -segundos, divida por 1024000. Neste exemplo, o
aplicativo de funções consumiu 1110000000 / 1024000 = 1083.98 GB -segundos. Você pode usar esse valor e
multiplicar pelo preço atual do tempo de execução napágina de preçosda [página de preços do Functions], que
oferece o custo dessas duas horas, supondo que você já tenha usado qualquer concessão gratuita de tempo de
execução.
CLI do Azure
O CLI do Azure tem comandos para recuperar métricas. Você pode usar a CLI de um ambiente de comando local
ou diretamente do portal usando Azure cloud Shell. Por exemplo, o seguinte comando AZ monitor de lista de
métricas retorna dados por hora no mesmo período de tempo usado antes.
Certifique-se de substituir <AZURE_SUBSCRIPTON_ID> pela sua ID de assinatura do Azure que executa o comando.
az monitor metrics list --resource /subscriptions/<AZURE_SUBSCRIPTION_ID>/resourceGroups/metrics-testing-

consumption/providers/Microsoft.Web/sites/metrics-testing-consumption --metric
FunctionExecutionUnits,FunctionExecutionCount --aggregation Total --interval PT1H --start-time 2019-09-
11T21:46:00Z --end-time 2019-09-11T23:18:00Z
Esse comando retorna uma carga JSON semelhante ao exemplo a seguir:
{
"cost": 0.0,
"interval": "1:00:00",
"namespace": "Microsoft.Web/sites",
"resourceregion": "centralus",
"timespan": "2019-09-11T21:46:00Z/2019-09-11T23:18:00Z",
"value": [
{
"id": "/subscriptions/XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX/resourceGroups/metrics-testing-
consumption/providers/Microsoft.Web/sites/metrics-testing-
consumption/providers/Microsoft.Insights/metrics/FunctionExecutionUnits",
"name": {
"localizedValue": "Function Execution Units",
"value": "FunctionExecutionUnits"
},
"resourceGroup": "metrics-testing-consumption",
"timeseries": [
{
"data": [
{
"average": null,
"count": null,
"maximum": null,
"minimum": null,
"timeStamp": "2019-09-11T21:46:00+00:00",
"total": 793294592.0
},
{
"average": null,
"count": null,
"maximum": null,
"minimum": null,
"timeStamp": "2019-09-11T22:46:00+00:00",
"total": 316576256.0
}
],
"metadatavalues": []
}
],
],
"type": "Microsoft.Insights/metrics",
"unit": "Count"
},
{
"id": "/subscriptions/XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX/resourceGroups/metrics-testing-
consumption/providers/Microsoft.Web/sites/metrics-testing-
consumption/providers/Microsoft.Insights/metrics/FunctionExecutionCount",
"name": {
"localizedValue": "Function Execution Count",
"value": "FunctionExecutionCount"
},
"resourceGroup": "metrics-testing-consumption",
"timeseries": [
{
"data": [
{
"average": null,
"count": null,
"maximum": null,
"minimum": null,
"timeStamp": "2019-09-11T21:46:00+00:00",
"total": 33538.0
},
{
"average": null,
"count": null,
"maximum": null,
"minimum": null,
"timeStamp": "2019-09-11T22:46:00+00:00",
"total": 13040.0
}
],
"metadatavalues": []
}
],
"type": "Microsoft.Insights/metrics",
"unit": "Count"
}
]
}
Essa resposta específica mostra que de 2019-09-11T21:46 a 2019-09-11T23:18 , durante o qual o aplicativo
consumiu 1110000000 MB -milissegundos (1083,98 GB -segundos).
Determinar o uso de memória

As unidades de execução de função são uma combinação de tempo de execução e seu uso de memória, o que
torna uma métrica difícil para entender o uso de memória. Os dados de memória não são uma métrica
atualmente disponível por meio de Azure Monitor. No entanto, se você quiser otimizar o uso de memória do seu
aplicativo, o poderá usar os dados do contador de desempenho coletados pelo Application Insights.
Se você ainda não tiver feito isso, habilite Application insights em seu aplicativo de funções. Com essa integração
habilitada, você pode consultar esses dados de telemetria no portal.
Em monitoramento, selecione logs (análise) , em seguida, copie a seguinte consulta de telemetria e cole-a na
janela de consulta e selecione executar. Essa consulta retorna o uso de memória total em cada tempo de amostra.
performanceCounters
| where name == "Private Bytes"
| project timestamp, name, value
Os resultados são semelhantes ao exemplo a seguir:

CARIMBO DE DATA/HORA [UTC @ NO__T-1 NAME VALUE
9/12/2019, 1:05:14 @ NO__T-0947 AM Bytes Particulares 209.932.288
Métricas de nível de função

Azure Monitor acompanha as métricas no nível de recurso, que para funções é o aplicativo de funções. A
integração do Application Insights emite métricas de acordo com a função. Aqui está um exemplo de consulta de
análise para obter a duração média de uma função:
customMetrics
| where name contains "Duration"
| extend averageDuration = valueSum / valueCount
| summarize averageDurationMilliseconds=avg(averageDuration) by name
NAME AVERAGEDURATIONMILLISECONDS
QueueTrigger AvgDurationMs 16 @ no__t-0087
QueueTrigger MaxDurationMs 90 @ no__t-0249
QueueTrigger MinDurationMs 8 @ no__t-0522
Próximas etapas
Saiba mais sobre como monitorar aplicativos de funções
Melhore o desempenho e a confiabilidade do Azure
Functions
Este artigo fornece orientações para melhorar o desempenho e confiabilidade de seus aplicativos de funções
sem servidor.
Práticas recomendadas gerais

A seguir, estão as melhores práticas para criar e projetar soluções sem servidor usando o Azure Functions.
Evite funções grandes de longa duração
As funções grandes de longa duração podem causar problemas de tempo limite inesperados. Para saber mais
sobre os tempos limite de um determinado plano de hospedagem, confira duração do tempo limite do aplicativo
de funções.
Uma função pode se tornar grande devido a muitas dependências de Node. js. A importação dessas
dependências pode causar aumento no tempo de carregamento resultando em tempos limite inesperados. As
dependências são carregadas explícita e implicitamente. Um único módulo carregado pelo seu código pode
carregar seus próprios módulos adicionais.
Sempre que possível, refatore funções grandes em conjuntos menores de funções que funcionem juntos e
retornem respostas rápidas. Por exemplo, um webhook ou uma função de gatilho HTTP pode exigir uma
resposta de confirmação dentro de um determinado limite de tempo; é comum que WebHooks exijam uma
resposta imediata. Você pode passar o conteúdo do gatilho HTTP para uma fila para ser processado por uma
função de gatilho de fila. Essa abordagem permite que você adie o trabalho real e retorne uma resposta
imediata.
Comunicação entre funções
As Durable Functions e os Aplicativos Lógicos do Azure são projetados para gerenciar transições de estado e
comunicação entre diversas funções.
Se não estiver usando Durable Functions ou aplicativos lógicos para integrar com várias funções, é melhor usar
filas de armazenamento para comunicação entre funções. O principal motivo é que as filas de armazenamento
são mais baratas e muito mais fáceis de provisionar do que outras opções de armazenamento.
Mensagens individuais em uma fila de armazenamento estão limitadas ao tamanho de 64 KB. Se você precisar
passar mensagens maiores entre as funções, uma fila do Barramento de Serviço do Azure poderá ser usada
para dar suporte a mensagens com tamanhos de até 256 KB na camada Standard e até 1 MB na camada
Premium.
Tópicos de barramento de serviço são úteis se você precisar de filtragem de mensagens antes do
processamento.
Hubs de eventos são úteis para oferecer suporte a comunicações de alto volume.
Grave funções para serem sem estado
As funções devem ser sem estado e idempotentes se possível. Associe quaisquer informações de estado
necessárias a seus dados. Por exemplo, um pedido sendo processado provavelmente teria um membro state
associado. Uma função pode processar um pedido com base no estado enquanto a função em si permanece
sem estado.
Funções de idempotentes são recomendadas especialmente com gatilhos de timer. Por exemplo, se você tiver
algo que absolutamente deve ser executado uma vez por dia, grave-o para que ele possa ser executado a
qualquer momento durante o dia com os mesmos resultados. A função pode sair quando não há trabalho para
um dia específico. Também se uma execução anterior tiver falhado ao concluir, a próxima execução deve
continuar de onde a anterior parou.
Grave funções defensivas
Suponha que sua função pode encontrar uma exceção a qualquer momento. Projete suas funções com a
capacidade de continuar de um ponto de falha anterior durante a próxima execução. Considere um cenário que
requeira as seguintes ações:
1. Consulta de 10.000 linhas em um banco de dados.
2. Crie uma mensagem de fila para cada uma das linhas para processar ainda mais adiante na linha.
Dependendo de quão complexo for o seu sistema, você pode ter: serviços de downstream envolvidos com
problemas incorretos, interrupções de rede ou limites de cota atingidos, etc. Todos eles podem afetar sua função
a qualquer momento. Você precisa para projetar suas funções para estarem preparadas para isso.
Como o seu código reage se ocorrer uma falha após a inserção de 5.000 desses itens em uma fila para
processamento? Controle itens em um conjunto concluído. Caso contrário, você pode inseri-los de novo
posteriormente. Essa inserção dupla pode ter um impacto sério em seu fluxo de trabalho, portanto, torne suas
funções idempotentes.
Se um item da fila já tiver sido processado, permita que sua função seja no-op.
Tire proveito de medidas defensivas já fornecidas para componentes usados na plataforma Azure Functions. Por
exemplo, consulte Tratamento de mensagens suspeitas na fila na documentação de gatilhos e associações
de fila de Armazenamento do Microsoft Azure.
Melhores práticas de escalabilidade

Há vários fatores que afetam a escala de instâncias do seu aplicativo de funções. Os detalhes são fornecidos na
documentação de dimensionamento de função. A seguir, estão algumas das melhores práticas para garantir a
escalabilidade ideal para um aplicativo de funções.
Gerenciar e compartilhar conexões
Reutilize conexões a recursos externos sempre que possível. Veja como gerenciar conexões no Azure Functions.
Não misture códigos de teste e de produção no mesmo aplicativo de funções
As funções em um aplicativo de funções compartilham recursos. Por exemplo, a memória é compartilhada. Se
você estiver usando um aplicativo de funções em produção, não adicione recursos e funções de teste nele. Ele
pode causar sobrecarga inesperada durante a execução de código de produção.
Cuidado com o que você carrega em seus aplicativos de funções de produção. A memória é dividida igualmente
entre cada função no aplicativo.
Se você tiver um assembly compartilhado referenciado em várias funções .NET, coloque-o em uma pasta
compartilhada comum. Caso contrário, você pode implantar acidentalmente várias versões do mesmo binário
que se comportam de forma diferente entre as funções.
Não use o log detalhado no código de produção, que tem um impacto negativo no desempenho.
Usar o código assíncrono, mas evitar chamadas de bloqueio
A programação assíncrona é uma prática recomendada. No entanto, sempre evite fazer referência à propriedade
Result ou chamar o método Wait em um instância Task . Essa abordagem pode levar ao esgotamento de
thread.
TIP
Se você planeja usar as ligações HTTP ou WebHook, planeje evitar o esgotamento de porta que pode ser causado pela
instanciação incorreta do HttpClient . Para saber mais, confira Como gerenciar conexões no Azure Functions.
Receber mensagens em lote sempre que possível

Alguns gatilhos, como o Hub de Eventos, habilitam o recebimento de um lote de mensagens em uma única
invocação. As mensagens em lote têm um desempenho melhor. É possível configurar o tamanho máximo do lote
no arquivo host.json , conforme detalhado na documentação de referência do host.json
Para C# funções, você pode alterar o tipo para uma matriz fortemente tipada. Por exemplo, em vez de
EventData sensorEvent , a assinatura do método pode ser EventData[] sensorEvent . Para outros idiomas, você
precisará definir explicitamente a propriedade cardinalidade em seu function.json como many para habilitar o
envio em lote , conforme mostrado aqui.
Configurar comportamentos de host para lidar melhor com a simultaneidade
O arquivo host.json no aplicativo de funções permite configurar os comportamentos do tempo de execução e
do gatilho do host. Além do envio em lote de comportamentos, é possível gerenciar a simultaneidade de
diversos gatilhos. Geralmente, ajustar os valores nessas opções pode ajudar a escalar cada instância
adequadamente para as demandas das funções invocadas.
As configurações no arquivo host. JSON se aplicam a todas as funções dentro do aplicativo, dentro de uma
única instância da função. Por exemplo, se você tivesse um aplicativo de funções com duas funções HTTP e
maxConcurrentRequests solicitações definidas como 25, uma solicitação para o gatilho http contaria para as 25
solicitações simultâneas compartilhadas. Quando esse aplicativo de funções é dimensionado para 10 instâncias,
as duas funções permitem efetivamente 250 solicitações simultâneas (10 instâncias * 25 solicitações
simultâneas por instância).
Outras opções de configuração de host são encontradas no artigo de configuração host. JSON.
Próximas etapas
Como gerenciar conexões no Azure Functions
Práticas recomendadas do Serviço de Aplicativo do Azure
Trabalhe com Proxies do Azure Functions
Este artigo explica como configurar e trabalhar com proxies do Azure Functions. Com esse recurso, você pode
especificar os pontos de extremidade em seu aplicativo de funções que são implementados por outro recurso.
Você pode usar esses proxies para dividir uma API grande em vários aplicativos de função (como uma arquitetura
de microsserviços), enquanto ainda apresenta uma única superfície de API para clientes.
Essas são as informações de referência para desenvolvedores do Azure Functions. Se for novo no Azure
Functions, comece com os seguintes recursos:
Crie sua primeira função: C#, JavaScript, Java ou Python.
Referência do desenvolvedor do Azure Functions.
Referência específica a uma linguagem: C#, C# script, F#, Java, JavaScript ou Python.
Conceitos de associações e gatilhos do Azure Functions.
Codificar e testar o Azure Functions localmente.
NOTE
A cobrança do Standard Functions se aplica para execuções de proxy. Para saber mais, confira Preços do Azure Functions.
Criar um proxy
Esta seção mostra como criar um proxy no portal do Functions.
1. Abra o Portal do Azure e navegue até seu aplicativo de funções.
2. No painel esquerdo, selecione Novo proxy.
3. Forneça um nome para seu proxy.
4. Configurar o ponto de extremidade exposto no aplicativo de função especificando o modelo de rota e
Métodos HTTP. Esses parâmetros se comportam de acordo com as regras de gatilhos HTTP.
5. Defina a URL de back-end para outro ponto de extremidade. Esse ponto de extremidade pode ser uma função
em outro aplicativo de funções, ou pode ser qualquer outra API. O valor não precisa ser estático e pode fazer
referência as configurações do aplicativo e os parâmetros da solicitação original do cliente.
6. Clique em Criar.
Seu proxy agora existe como um novo ponto de extremidade em seu aplicativo de funções. Da perspectiva do
cliente, é equivalente a um HttpTrigger no Azure Functions. Você pode testar seu novo proxy copiando a URL do
Proxy e testá-lo com seu cliente HTTP favorito.
Modificar solicitações e respostas

Com Proxies do Azure Functions, você pode modificar solicitações e respostas do back-end. Essas transformações
podem usar variáveis, conforme definido em Usar variáveis.
Modificar a solicitação de back-end
Por padrão, a solicitação de back-end é inicializada como uma cópia da solicitação original. Além de definir a URL
de back-end, é possível fazer alterações no método HTTP, cabeçalhos e parâmetros de cadeia de consulta. Os
valores modificados podem referenciar as configurações do aplicativo e os parâmetros da solicitação original do
cliente.
As solicitações de back-end podem ser modificadas no portal expandindo a seção substituição da solicitação na
página de detalhes do proxy.
Modificar a resposta
Por padrão, a resposta do cliente é inicializada como uma cópia da resposta de back-end. Você pode fazer
alterações no código de status, na frase de motivo, nos cabeçalhos e no corpo da resposta. Os valores modificados
podem referenciar as configurações do aplicativo, os parâmetros da solicitação original do cliente e os parâmetros
da resposta de back-end.
As solicitações de back-end podem ser modificadas no portal expandindo a seção substituição da resposta na
página de detalhes do proxy.
Usar variáveis
A configuração de um proxy não precisa ser estática. Você pode condicioná-la para usar variáveis da solicitação do
cliente original, da resposta de back-end ou das configurações do aplicativo.
Funções de local de referência
Você pode usar localhost para fazer referência a uma função diretamente dentro do mesmo aplicativo de função,
sem uma solicitação de proxy de ida e volta.
"backendurl": "https://localhost/api/httptriggerC#1" fará referência a uma função disparada do HTTP local na
rota /api/httptriggerC#1
NOTE
Se sua função usar os níveis de autorização função, administrador ou sys, você precisará fornecer o código e o clientId, de
acordo com a URL da função original. Nesse caso, a referência ficaria assim:
"backendurl": "https://localhost/api/httptriggerC#1?code=<keyvalue>&clientId=<keyname>" É recomendável
armazenar essas chaves nas configurações do aplicativo e fazer referência a elas em seus proxies. Isso evita o
armazenamento de segredos em seu código-fonte.
Parâmetros de solicitação de referência

Use os parâmetros de solicitação como entradas para a propriedade de URL de back-end ou como parte da
modificação de solicitações e respostas. Alguns parâmetros podem ser limitados ao modelo de rota especificado
na configuração do proxy base, enquanto outros são obtidos de propriedades da solicitação de entrada.
Parâmetros de modelo de rota
Os parâmetros usados no modelo de rota estão disponíveis para serem referenciados pelo nome. Os nomes de
parâmetro são colocados entre chaves ({}).
Por exemplo, se um proxy tem um modelo de rota como /pets/{petId} , a URL do back-end pode incluir o valor
de {petId} , como em https://<AnotherApp>.azurewebsites.net/api/pets/{petId} . Se o modelo de rota termina em
um caractere curinga, como /api/{*restOfPath} , o valor {restOfPath} será uma representação de cadeia de
caracteres dos segmentos de caminho restantes da solicitação de entrada.
Parâmetros de solicitação adicionais
Além dos parâmetros do modelo de rota, os seguintes valores podem ser usados em valores de configuração:
{request.method} : O método HTTP usado na solicitação original.
{request.headers.<HeaderName>} : Um cabeçalho que pode ser lido por meio da solicitação original.
Substitua <HeaderName> pelo nome do cabeçalho que você deseja ler. Se o cabeçalho não estiver incluído na
solicitação, o valor será a cadeia de caracteres vazia.
{request.querystring.<ParameterName>} : Um parâmetro de cadeia de caracteres de consulta que pode ser
lido na solicitação original. Substitua <ParameterName> pelo nome do parâmetro que você deseja ler. Se o
parâmetro não estiver incluído na solicitação, o valor será a cadeia de caracteres vazia.
Parâmetros de resposta de back-end de referência
Parâmetros de resposta podem ser usados como parte da modificação da resposta ao cliente. Os seguintes
valores podem ser usados em valores de configuração:
{backend.response.statusCode} : O código de status HTTP retornado na resposta de back-end.
{backend.response.statusReason} : A frase de motivo HTTP retornada na resposta de back-end.
{backend.response.headers.<HeaderName>} : Um cabeçalho que pode ser lido por meio da resposta de
back-end. Substitua <HeaderName> pelo nome do cabeçalho que você deseja ler. Se o cabeçalho não estiver
incluído na solicitação, o valor será a cadeia de caracteres vazia.
Configurações do aplicativo de referência
Você também referenciar as configurações do aplicativo definidas para o aplicativo de funções envolvendo o
nome da configuração entre sinais de percentual (%).
Por exemplo, uma URL de back-end de https://%ORDER_PROCESSING_HOST%/api/orders teria
"%ORDER_PROCESSING_HOST%" substituído pelo valor da configuração ORDER_PROCESSING_HOST.
TIP
Usar configurações do aplicativo para hosts de back-end quando você tem várias implantações ou ambientes de teste.
Dessa forma, você pode garantir que está sempre se comunicando com o back-end correto para aquele ambiente.
Solucionar problemas de Proxies

Ao adicionar o sinalizador "debug":true em qualquer proxy em seu proxies.json , você habilitará o log de
depuração. Os logs são armazenados em D:\home\LogFiles\Application\Proxies\DetailedTrace e ficam acessíveis
pelas ferramentas avançadas (kudu). As respostas HTTP também conterão um cabeçalho Proxy-Trace-Location
com uma URL para acessar o arquivo de log.
Você pode depurar um proxy do lado do cliente adicionando um cabeçalho Proxy-Trace-Enabled definido como
true . Isso também registrará um rastreamento no sistema de arquivos e retornará a URL de rastreamento como
um cabeçalho na resposta.
Bloquear rastreamentos de proxy
Por motivos de segurança, você pode não desejar permitir que qualquer pessoa chame o seu serviço para gerar
um rastreamento. Essas pessoas não poderão acessar o conteúdo de rastreamento sem suas credenciais de logon,
mas gerar o rastreamento consome recursos e expõe o seu uso dos Proxies de Função.
Desabilite totalmente os rastreamentos adicionando "debug":false a qualquer proxy específico em proxies.json .
Configuração avançada
Os proxies que você configura são armazenados em um arquivo proxies.json, que está localizado na raiz de um
diretório de aplicativo de função. Você pode editar esse arquivo manualmente e implantá-lo como parte do seu
aplicativo ao usar qualquer um dos métodos de implantação que ofereça suporte a funções.
TIP
Se você não configurou um dos métodos de implantação, também poderá trabalhar com o arquivo proxies.json no portal.
Vá até o aplicativo de funções e selecione Recursos da plataforma e,depois, selecione Editor do Serviço de Aplicativo.
Isso permitirá que você veja toda a estrutura de arquivo do aplicativo de funções e faça alterações.
Proxies.json é definido por um objeto de proxies, composto de proxies nomeados e suas definições.
Opcionalmente, você pode referenciar um esquema JSON para o preenchimento do código, caso seu editor dê
suporte a isso. Um arquivo de exemplo pode parecer com o seguinte:
{
"$schema": "http://json.schemastore.org/proxies",
"proxies": {
"proxy1": {
"matchCondition": {
"methods": [ "GET" ],
"route": "/api/{test}"
},
"backendUri": "https://<AnotherApp>.azurewebsites.net/api/<FunctionName>"
}
}
}
Cada proxy tem um nome amigável, como proxy1, no exemplo acima. O objeto de definição de proxy
correspondente é definido pelas seguintes propriedades:
matchCondition: Obrigatório – um objeto que define as solicitações que disparam a execução desse proxy.
Ele contém duas propriedades compartilhadas com Gatilhos HTTP:
methods: Uma matriz dos métodos HTTP aos quais o proxy responde. Se não for especificado, o proxy
responderá a todos os métodos HTTP na rota.
route: Obrigatório – define o modelo da rota, controlando para quais URLs de solicitação seu proxy
responde. Ao contrário de disparadores HTTP, não há nenhum valor padrão.
backendUri: A URL do recurso de back-end ao qual a solicitação deve ser transmitida por proxy. Esse valor
pode referenciar as configurações do aplicativo e os parâmetros da solicitação original do cliente. Se esta
propriedade não for incluída, o Azure Functions responderá com um HTTP 200 OK.
requestOverrides: Um objeto que define as transformações para a solicitação de back-end. Confira Definir
um objeto requestOverrides.
responseOverrides: Um objeto que define as transformações para a resposta do cliente. Confira Definir um
objeto responseOverrides.
NOTE
A propriedade de rota dos proxies de funções do Azure não honra a propriedade routePrefix da configuração de host do
Aplicativo de funções. Se você quiser incluir um prefixo, como /api , ele deve ser incluído na propriedade de rota.
Desabilitar proxies individuais

Você pode desabilitar proxies individuais adicionando "disabled": true ao proxy no arquivo proxies.json . Isso
fará com que as solicitações atendam a matchCondition para retornar 404.
{
"proxies": {
"Root": {
"disabled":true,
"matchCondition": {
"route": "/example"
},
"backendUri": "https://<AnotherApp>.azurewebsites.net/api/<FunctionName>"
}
}
}
Configurações de aplicativo
O comportamento do proxy pode ser controlado por várias configurações de aplicativo. Todas elas são descritas
na referência de Configurações do Aplicativo de Funções
AZURE_FUNCTION_PROXY_DISABLE_LOCAL_CALL
AZURE_FUNCTION_PROXY_BACKEND_URL_DECODE_SLASHES
Caracteres reservados (formatação de cadeia de caracteres)
Os proxies leem todas as cadeias de caracteres de um arquivo JSON, usando \ como símbolo de escape. Os
proxies também interpretam chaves. Veja a seguir um conjunto completo de exemplos.
CHARACTER CARACTERE DE ESCAPE EXEMPLO
{ ou } {{ ou }} {{ example }} --> { example }
\ \\ example.com\\text.html -->
example.com\text.html
" \" \"example\" --> "example"
Definir um objeto requestOverrides

O objeto requestOverrides define as alterações feitas à solicitação quando o recurso de back-end é chamado. O
objeto é definido pelas seguintes propriedades:
backend.request.method: O método HTTP usado para chamar o back-end.
backend.request.querystring.<ParameterName> : Um parâmetro de cadeia de caracteres de consulta que
pode ser definido para a chamada ao back-end. Substitua <ParameterName> pelo nome do parâmetro que
você deseja definir. Se a cadeia de caracteres vazia for fornecida, o parâmetro não será incluído na solicitação
de back-end.
backend.request.headers.<HeaderName> : Um cabeçalho que pode ser definido para a chamada ao back-
end. Substitua <HeaderName> pelo nome do cabeçalho que você deseja definir. Se você fornecer a cadeia de
caracteres vazia, o cabeçalho não será incluído na solicitação de back-end.
Os valores podem referenciar as configurações do aplicativo e os parâmetros da solicitação original do cliente.
Uma configuração de exemplo pode ser parecida com a seguinte:
{
"proxies": {
"proxy1": {
"matchCondition": {
},
"backendUri": "https://<AnotherApp>.azurewebsites.net/api/<FunctionName>",
"requestOverrides": {
"backend.request.headers.Accept": "application/xml",
"backend.request.headers.x-functions-key": "%ANOTHERAPP_API_KEY%"
}
}
}
}
Definir um objeto responseOverrides

O objeto requestOverrides define as alterações feitas à resposta passada novamente ao cliente. O objeto é
definido pelas seguintes propriedades:
response.statusCode: O código de status HTTP a ser retornado ao cliente.
response.statusReason: A frase de motivo do HTTP a ser retornada ao cliente.
response.body: A representação de cadeia de caracteres do corpo a ser retornada ao cliente.
response.headers.<HeaderName> : Um cabeçalho que pode ser definido para a resposta ao cliente.
Substitua <HeaderName> pelo nome do cabeçalho que você deseja definir. Se você fornecer a cadeia de
caracteres vazia, o cabeçalho não será incluído na resposta.
Os valores podem referenciar as configurações do aplicativo, os parâmetros da solicitação original do cliente e os
parâmetros da resposta de back-end.
Uma configuração de exemplo pode ser parecida com a seguinte:
{
"proxies": {
"proxy1": {
"matchCondition": {
},
"responseOverrides": {
"response.body": "Hello, {test}",
"response.headers.Content-Type": "text/plain"
}
}
}
}
NOTE
Neste exemplo, o corpo da resposta é definido diretamente e, portanto, nenhuma propriedade backendUri é necessária. O
exemplo mostra como você pode usar os Proxies do Azure Functions para simular APIs.
Opções de rede Azure Functions
Este artigo descreve os recursos de rede disponíveis nas opções de hospedagem para Azure Functions. Todas as
seguintes opções de rede oferecem a você uma capacidade de acessar recursos sem usar endereços roteáveis pela
Internet ou para restringir o acesso à Internet a um aplicativo de funções.
Os modelos de hospedagem têm níveis diferentes de isolamento de rede disponíveis. Escolher a correta ajudará
você a atender aos seus requisitos de isolamento de rede.
Você pode hospedar aplicativos de funções de duas maneiras:
Há um conjunto de opções de plano que são executadas em uma infraestrutura multilocatário, com vários
níveis de conectividade de rede virtual e opções de dimensionamento:
O plano de consumo, que é dimensionado dinamicamente em resposta à carga e oferece opções de
isolamento de rede mínimas.
O plano Premium, que também é dimensionado dinamicamente, ao mesmo tempo que oferece
isolamento de rede mais abrangente.
O plano do serviço de aplicativodo Azure, que opera em uma escala fixa e oferece isolamento de rede
semelhante ao plano Premium.
Você pode executar funções em um ambiente do serviço de aplicativo. Esse método implanta sua função em
sua rede virtual e oferece controle e isolamento de rede total.
Matriz de recursos de rede

PLANO DO SERVIÇO DE AMBIENTE DO SERVIÇO
PLANO DE CONSUMO PLANO PREMIUM APLICATIVO DE APLICATIVO
Restrições de IP de Sim Sim Sim Sim

entrada & acesso ao
site privado
Integração de rede não Sim (regional) Sim (regional e Sim

virtual gateway)
Gatilhos de rede não não Sim Sim

virtual (não HTTP)
Conexões híbridas não Sim Sim Sim
Restrições de IP de não não não Sim

saída
Restrições de IP de entrada
Você pode usar restrições de IP para definir uma lista ordenada de prioridade de endereços IP que têm acesso
permitido ou negado ao seu aplicativo. A lista pode incluir endereços IPv4 e IPv6. Quando há uma ou mais
entradas, um "negar tudo" implícito existe no final da lista. As restrições de IP funcionam com todas as opções de
Hospedagem de função.
NOTE
Com as restrições de rede em vigor, você pode usar o editor do portal somente de dentro de sua rede virtual ou quando
você colocou o endereço IP do computador que está usando para acessar o portal do Azure na lista de destinatários
seguros. No entanto, você ainda pode acessar quaisquer recursos na guia recursos da plataforma de qualquer
computador.
Para saber mais, consulte Azure app restrições de acesso estático do serviço.
Acesso a site particular

Acesso ao site privado refere-se a tornar seu aplicativo acessível somente de uma rede privada, como uma rede
virtual do Azure.
O acesso ao site privado está disponível nos planos Premium, consumoe serviço de aplicativo quando os
pontos de extremidade de serviço são configurados.
Os pontos de extremidade de serviço podem ser configurados por aplicativo em recursos da
plataforma > rede > Configurar restrições de acesso > Adicionar regra. As redes virtuais agora
podem ser selecionadas como um tipo de regra.
Para obter mais informações, consulte pontos de extremidade de serviço de rede virtual.
Tenha em mente que, com os pontos de extremidade de serviço, sua função ainda tem acesso total de
saída à Internet, mesmo com a integração de rede virtual configurada.
O acesso ao site privado também está disponível em um Ambiente do Serviço de Aplicativo configurado com
um balanceador de carga interno (ILB ). Para obter mais informações, consulte criar e usar um balanceador de
carga interno com um ambiente do serviço de aplicativo.
Integração de rede virtual

A integração de rede virtual permite que seu aplicativo de funções acesse recursos dentro de uma rede virtual.
Esse recurso está disponível no plano Premium e no plano do serviço de aplicativo. Se seu aplicativo estiver em
um Ambiente do Serviço de Aplicativo, ele já estará em uma rede virtual e não exigirá integração de rede virtual
para alcançar recursos na mesma rede virtual.
Você pode usar a integração de rede virtual para habilitar o acesso de aplicativos a bancos de dados e serviços
Web em execução em sua rede virtual. Com a integração de rede virtual, você não precisa expor um ponto de
extremidade público para aplicativos em sua VM. Em vez disso, você pode usar endereços não roteáveis privados
da Internet.
Há duas formas de integração de rede virtual:
Integração de rede virtual regional (versão prévia) : habilita a integração com redes virtuais na mesma
região. Esse tipo de integração requer uma sub-rede em uma rede virtual na mesma região. Este recurso ainda
está em visualização, mas tem suporte para aplicativos de funções em execução no Windows, com as
advertências descritas após a seguinte tabela de problema/solução.
Integração de rede virtual necessária do gateway: habilita a integração com redes virtuais em regiões
remotas ou com redes virtuais clássicas. Esse tipo de integração requer a implantação de um gateway de rede
virtual em sua VNet. Esse é um recurso baseado em VPN ponto a site, que tem suporte apenas para
aplicativos de funções em execução no Windows.
Um aplicativo pode usar apenas um tipo de recurso de integração de rede virtual de cada vez. Embora ambos
sejam úteis para muitos cenários, a tabela a seguir indica onde cada um deve ser usado:
PROBLEMA SOLUÇÃO
Deseja alcançar um endereço RFC 1918 (10.0.0.0/8, Integração de rede virtual regional
172.16.0.0/12, 192.168.0.0/16) na mesma região
Deseja acessar recursos em uma rede virtual clássica ou em Integração de rede virtual do gateway necessária
uma rede virtual em outra região
Deseja alcançar os pontos de extremidade RFC 1918 no Azure Integração de rede virtual regional
ExpressRoute
Deseja acessar recursos entre pontos de extremidade de Integração de rede virtual regional
serviço
Nenhum recurso permite que você alcance endereços não RFC 1918 no ExpressRoute. Para fazer isso, no
momento, você precisa usar um Ambiente do Serviço de Aplicativo.
O uso da integração de rede virtual regional não conecta sua rede virtual a pontos de extremidade locais ou
configura pontos de extremidade de serviço. Essa é uma configuração de rede separada. A integração de rede
virtual regional apenas permite que seu aplicativo faça chamadas entre esses tipos de conexão.
Independentemente da versão usada, a integração de rede virtual dá ao seu aplicativo de funções acesso aos
recursos em sua rede virtual, mas não concede acesso de site privado ao seu aplicativo de funções da rede virtual.
Acesso ao site privado significa tornar seu aplicativo acessível somente de uma rede privada como uma rede
virtual do Azure. a integração de rede virtual é apenas para fazer chamadas de saída de seu aplicativo para sua
rede virtual.
O recurso de integração de rede virtual:
Requer um plano do serviço de aplicativo Standard, Premium ou PremiumV2
dá suporte a TCP e UDP
Funciona com aplicativos do serviço de aplicativo e aplicativos de funções
Há algumas coisas para as quais a integração de rede virtual não dá suporte, incluindo:
A montagem de uma unidade
Integração do Active Directory
Output
A integração de rede virtual no Azure Functions usa a infraestrutura compartilhada com aplicativos Web do
serviço de aplicativo. Para saber mais sobre os dois tipos de integração de rede virtual, consulte:
Integração de rede virtual regional
Integração de rede virtual do gateway necessária
Para saber mais sobre como usar a integração de rede virtual, consulte integrar um aplicativo de funções a uma
rede virtual do Azure.
Conectando a recursos protegidos do ponto de extremidade de serviço

NOTE
Por enquanto, pode levar até 12 horas para que novos pontos de extremidade de serviço fiquem disponíveis para seu
aplicativo de funções depois de configurar as restrições de acesso no recurso de downstream. Durante esse tempo, o recurso
ficará completamente indisponível para seu aplicativo.
Para fornecer um nível mais alto de segurança, você pode restringir vários serviços do Azure a uma rede virtual
usando pontos de extremidade de serviço. Em seguida, você deve integrar seu aplicativo de funções com essa
rede virtual para acessar o recurso. Essa configuração tem suporte em todos os planos que dão suporte à
integração de rede virtual.
Saiba mais sobre pontos de extremidade de serviço de rede virtual.
Restringindo sua conta de armazenamento a uma rede virtual
Ao criar um aplicativo de funções, você deve criar ou vincular a uma conta de armazenamento do Azure de uso
geral que dá suporte ao armazenamento de BLOBs, filas e tabelas. No momento, não é possível usar nenhuma
restrição de rede virtual nesta conta. Se você configurar um ponto de extremidade de serviço de rede virtual na
conta de armazenamento que você está usando para seu aplicativo de funções, isso interromperá seu aplicativo.
Saiba mais sobre os requisitos da conta de armazenamento.
Gatilhos de rede virtual (não HTTP)

Atualmente, para usar gatilhos de função diferentes de HTTP de dentro de uma rede virtual, você deve executar
seu aplicativo de funções em um plano do serviço de aplicativo ou em um Ambiente do Serviço de Aplicativo.
Por exemplo, suponha que você deseja configurar Azure Cosmos DB para aceitar o tráfego somente de uma rede
virtual. Você precisaria implantar seu aplicativo de funções em um plano do serviço de aplicativo que fornece
integração de rede virtual com essa rede virtual para configurar Azure Cosmos DB gatilhos desse recurso.
Durante a visualização, a configuração da integração de rede virtual não permite que o plano Premium dispare
que Azure Cosmos DB recurso.
Consulte esta lista para todos os gatilhos não-http para verificar o que tem suporte.
Conexões Híbridas
Conexões híbridas é um recurso da retransmissão do Azure que você pode usar para acessar recursos do
aplicativo em outras redes. Ele fornece acesso de seu aplicativo para um ponto de extremidade do aplicativo. Você
não pode usá-lo para acessar seu aplicativo. Conexões Híbridas está disponível para funções em execução em
todos, exceto no plano de consumo.
Conforme usado em Azure Functions, cada conexão híbrida se correlaciona com uma única combinação de host e
porta de TCP. Isso significa que o ponto de extremidade da conexão híbrida pode estar em qualquer sistema
operacional e qualquer aplicativo, desde que você esteja acessando uma porta de escuta TCP. O recurso Conexões
Híbridas não conhece ou se preocupa com o que é o protocolo de aplicativo ou o que você está acessando. Ele
apenas fornece acesso à rede.
Para saber mais, confira a documentação do serviço de aplicativo para conexões híbridas. Essas mesmas etapas de
configuração oferecem suporte a Azure Functions.
Restrições de IP de saída
As restrições de IP de saída estão disponíveis somente para funções implantadas em um Ambiente do Serviço de
Aplicativo. Você pode configurar as restrições de saída para a rede virtual em que sua Ambiente do Serviço de
Aplicativo está implantada.
Quando você integra um aplicativo de funções em um plano Premium ou um plano do serviço de aplicativo com
uma rede virtual, o aplicativo ainda pode fazer chamadas de saída para a Internet.
Próximas etapas
Para saber mais sobre rede e Azure Functions:
Siga o tutorial sobre como começar com a integração de rede virtual
Leia as perguntas frequentes sobre rede de funções
Saiba mais sobre a integração de rede virtual com o serviço de aplicativo/funções
Saiba mais sobre as redes virtuais no Azure
Habilitar mais recursos de rede e controle com ambientes de serviço de aplicativo
Conectar-se a recursos locais individuais sem alterações de firewall usando Conexões Híbridas
Endereços IP no Azure
Este artigo explica os seguintes tópicos relacionados a endereços IP de aplicativos de função:

Como encontrar os endereços IP atualmente em uso por um aplicativo de função.
O que faz com que os endereços IP de um aplicativo de função sejam alterados.
Como restringir os endereços IP que podem acessar um aplicativo de função.
Como obter endereços IP dedicados para um aplicativo de função.
Os endereços IP estão associados a aplicativos de função, não a funções individuais. Solicitações HTTP de entrada
não podem usar o endereço IP de entrada para chamar funções individuais; eles devem usar o nome de domínio
padrão (functionappname.azurewebsites.net) ou um nome de domínio personalizado.
Endereço IP de entrada do aplicativo de função

Cada aplicativo de função possui um único endereço IP de entrada. Para encontrar esse endereço IP:
2. Navegue até o aplicativo de função.
3. Selecione recursos da plataforma.
4. Selecione Propriedades e o endereço IP de entrada será exibido em Endereço IP virtual.
Endereços IP de saída do aplicativo de funções

Cada aplicativo de função tem um conjunto de endereços IP de saída disponíveis. Qualquer conexão de saída de
uma função, como um banco de dados back-end, usa um dos endereços IP de saída disponíveis como o endereço
IP de origem. Você não pode saber de antemão qual endereço IP uma determinada conexão usará. Por esse
motivo, seu serviço de back-end deve abrir seu firewall para todos os endereços IP de saída do aplicativo de
função.
Para encontrar os endereços IP de saída disponíveis para um aplicativo de função:
1. Faça login no Azure Resource Explorer.
2. Selecione assinaturas> {sua assinatura}> provedores> Microsoft.Web> sites.
3. No painel JSON, encontre o site com uma propriedade id que termine no nome do seu aplicativo de função.
4. Veja outboundIpAddresses e possibleOutboundIpAddresses .
O conjunto de outboundIpAddresses está atualmente disponível para o aplicativo de função. O conjunto de
possibleOutboundIpAddresses inclui endereços IP que estarão disponíveis somente se o aplicativo de função for
dimensionado para outras camadas de preços.
Uma maneira alternativa de encontrar os endereços IP de saída disponíveis é usando o Cloud Shell:
az webapp show --resource-group <group_name> --name <app_name> --query outboundIpAddresses --output tsv
az webapp show --resource-group <group_name> --name <app_name> --query possibleOutboundIpAddresses --output tsv
NOTE
Quando um aplicativo de função que é executado no Plano de consumo é dimensionado, um novo intervalo de endereços IP
de saída pode ser atribuído. Quando executado no plano de consumo, talvez seja necessário colocar na lista de permissões
todo o data center.
Endereços IP de saída do data center

Se você precisar colocar na lista de permissões os endereços IP de saída usados pelos seus aplicativos de função,
outra opção é colocar na lista de permissões o data center dos aplicativos de função (região do Azure). Você pode
fazer o download de um arquivo JSON que lista endereços IP para todos os datacenters do Azure. Em seguida,
localize o elemento JSON que se aplica à região em que seu aplicativo de função é executado.
Por exemplo, este é o que o fragmento JSON da Europa Ocidental pode parecer com:
{
"name": "AzureCloud.westeurope",
"id": "AzureCloud.westeurope",
"properties": {
"changeNumber": 9,
"region": "westeurope",
"platform": "Azure",
"systemService": "",
"addressPrefixes": [
"13.69.0.0/17",
"13.73.128.0/18",
... Some IP addresses not shown here
"213.199.180.192/27",
"213.199.183.0/24"
]
}
}
Para obter informações sobre quando este arquivo é atualizado e quando os endereços IP são alterados, expanda a
seção Detalhes da página do Centro de Download.
Mudanças no endereço IP de entrada

O endereço IP de entrada pode mudar quando você:
Exclua um aplicativo de função e recrie-o em um grupo de recursos diferente.
Exclua o último aplicativo de função em uma combinação de grupo de recursos e região e recrie-o.
Exclua uma ligação SSL, como durante a renovação do certificado).
Quando seu aplicativo de funções é executado um Plano de consumo, o endereço IP de entrada também pode
alterar quando você ainda não tiver feito quaisquer ações, como aquelas listadas.
Mudanças no endereço IP de saída

O conjunto de endereços IP de saída disponíveis para um aplicativo de função pode mudar quando você:
Execute qualquer ação que possa alterar o endereço IP de entrada.
Altere a camada de preços do seu plano de serviço do aplicativo. A lista de todos os possíveis endereços IP de
saída que seu aplicativo pode usar, para todas as camadas de preços, está na possibleOutboundIPAddresses
propriedade. Consulte Localizar IPs de saída.
Quando seu aplicativo de funções é executado em um Plano de consumo, o endereço IP de entrada também pode
alterar quando você ainda não tiver feito quaisquer ações, como aquelas listadas.
Para forçar deliberadamente uma alteração de endereço IP de saída:
1. Expanda seu plano de serviço de aplicativos para cima ou para baixo entre os níveis de preços Padrão e
Premium v2.
2. Esperar 10 minutos.
3. Volte para onde você começou.
Restrições de endereço IP
Você pode configurar uma lista de endereços IP que você deseja permitir ou negar acesso a um aplicativo de
função. Para obter mais informações, consulte Restrições de IP estático do Serviço de Aplicativo do Azure.
Endereços IP dedicados
Se você precisar de endereços IP dedicados e estáticos, recomendamos Ambientes do Serviço de Aplicativo (o
Nível isolado dos planos do Serviço de Aplicativo). Para obter mais informações, consulte Endereços IP do
Ambiente de Serviço de Aplicativo e Como controlar o tráfego de entrada para um Ambiente de Serviço de
Aplicativo.
Para descobrir se seu aplicativo de função é executado em um Ambiente de Serviço de Aplicativo:
2. Navegue até o aplicativo de função.
3. Selecione o guia Visão geral.
4. A camada do plano de Serviço de Aplicativo aparece em Plano de serviço de aplicativo / camada de preço.
A camada de preços do Ambiente de Serviço de Aplicativo é Isolado.
Como alternativa, você pode usar o Cloud Shell:
az webapp show --resource-group <group_name> --name <app_name> --query sku --output tsv
O Ambiente do Serviço de Aplicativo sku é Isolated .
Próximas etapas
Uma causa comum de alterações de IP é a função de escala de aplicativos. Saiba mais sobre o dimensionamento
do aplicativo de função.
Azure Functions em kubernetes com KEDA
O tempo de execução de Azure Functions fornece flexibilidade na Hospedagem de onde e como você deseja. Os
pares de Keda (dimensionamento automático controlado por eventos baseados em kubernetes) diretamente com
o tempo de execução Azure Functions e ferramentas para fornecer escala controlada por evento em kubernetes.
Como funcionam as funções baseadas em kubernetes

O serviço de Azure Functions é composto por dois componentes principais: um tempo de execução e um
controlador de escala. O tempo de execução do Functions é executado e executa seu código. O tempo de execução
inclui a lógica sobre como disparar, registrar e gerenciar execuções de função. O outro componente é um
controlador de escala. O controlador de escala monitora a taxa de eventos que estão direcionando sua função e
dimensiona de forma proativa o número de instâncias que executam seu aplicativo. Para saber mais, confira Escala
e hospedagem do Azure Functions.
As funções baseadas em kubernetes fornecem o tempo de execução de funções em um contêiner do Docker com
dimensionamento controlado por eventos por meio de Keda. KEDA pode reduzir verticalmente para 0 instâncias
(quando nenhum evento está ocorrendo) e até n instâncias. Ele faz isso expondo métricas personalizadas para o
kubernetes AutoScaler (dimensionamento de escala horizontal). O uso de contêineres de funções com KEDA torna
possível replicar recursos de função sem servidor em qualquer cluster kubernetes. Essas funções também podem
ser implantadas usando o recurso de nós virtuais do AKS (serviços Kubernetess do Azure) para a infraestrutura
sem servidor.
Gerenciando KEDA e funções no kubernetes

Para executar funções em seu cluster do kubernetes, você deve instalar o componente KEDA. Você pode instalar
esse componente usando Azure Functions Core Tools.
Instalando com o Azure Functions Core Tools
Por padrão, as ferramentas principais instalam os componentes KEDA e Osiris, que dão suporte ao
dimensionamento de HTTP e orientado a eventos, respectivamente. A instalação usa kubectl em execução no
contexto atual.
Instale o KEDA no cluster executando o seguinte comando de instalação:
func kubernetes install --namespace keda
Implantando um aplicativo de funções no kubernetes

Você pode implantar qualquer aplicativo de funções em um cluster kubernetes que executa o KEDA. Como suas
funções são executadas em um contêiner do Docker, seu projeto precisa de um Dockerfile . Se ele ainda não tiver
um, você poderá adicionar um Dockerfile executando o seguinte comando na raiz do seu projeto do Functions:
func init --docker-only
Para criar uma imagem e implantar suas funções no kubernetes, execute o seguinte comando:
NOTE
As ferramentas principais aproveitarão a CLI do Docker para criar e publicar a imagem. Certifique-se de que o Docker já
esteja instalado e conectado à sua conta com docker login .
func kubernetes deploy --name <name-of-function-deployment> --registry <container-registry-username>
Substitua <name-of-function-deployment> pelo nome do aplicativo de funções.
Isso cria um recurso de Deployment kubernetes, um recurso de ScaledObject e Secrets , que inclui as variáveis de
ambiente importadas de seu arquivo de local.settings.json .
Implantando um aplicativo de funções de um registro particular
O fluxo acima funciona para registros privados também. Se você estiver extraindo a imagem de contêiner de um
registro privado, inclua o sinalizador --pull-secret que faz referência ao segredo kubernetes que contém as
credenciais de registro particular ao executar func kubernetes deploy .
Removendo um aplicativo de funções do kubernetes

Depois de implantar, você pode remover uma função removendo o Deployment associado, ScaledObject , um
Secrets criado.
kubectl delete deploy <name-of-function-deployment>

kubectl delete ScaledObject <name-of-function-deployment>
kubectl delete secret <name-of-function-deployment>
Desinstalando o KEDA do kubernetes

Você pode executar o seguinte comando de ferramentas principais para remover o KEDA de um cluster
kubernetes:
func kubernetes remove --namespace keda
Gatilhos com suporte no KEDA

O KEDA está atualmente em beta com suporte para os seguintes gatilhos de função do Azure:
Filas do armazenamento do Azure
Filas do barramento de serviço do Azure
HTTP
Apache Kafka
Próximas etapas
Criar uma função usando uma imagem personalizada
Codificar e testar o Azure Functions localmente
Como funciona o plano de consumo da função do Azure
No Azure Functions, funções específicas compartilham alguns componentes e conceitos técnicos,

independentemente da linguagem ou da associação usada. Antes de aprender detalhes específicos de
uma determinada linguagem ou binding, leia esta visão geral que se aplica a todos eles.
Este artigo pressupõe que você já tenha lido a Visão geral do Azure Functions.
Código de função
Uma função é o principal conceito no Azure Functions. Uma função contém duas partes importantes:
seu código, que pode estar escrito em várias linguagens e ter alguma configuração, e o arquivo
function.json. Para linguagens compiladas, o arquivo de configuração é gerado automaticamente com
base nas anotações no código. Para linguagens de script, você deve fornecer seu próprio arquivo de
configuração.
O arquivo function.json define o gatilho, as associações e outras definições de configuração da função.
Cada função tem apenas um gatilho. O tempo de execução usa o arquivo de configuração para
determinar os eventos a serem monitorados, bem como para passar e retornar dados de uma execução
da função. Veja a seguir um arquivo function.json de exemplo.
{
"disabled":false,
"bindings":[
// ... bindings here
{
"type": "bindingType",
"direction": "in",
"name": "myParamName",
// ... more depending on binding
}
]
}
Para obter mais informações, consulte Gatilhos e conceitos de associações do Azure Functions.
A propriedade bindings é onde você configura gatilhos e associações. Cada binding compartilha
algumas configurações comuns e outras que são específicas para um determinado tipo de binding.
Todas as associações exigem as seguintes configurações:
PROPRIEDADE VALORES/TIPOS COMENTÁRIOS
type cadeia de caracteres Tipo de binding. Por exemplo:

queueTrigger .
direction 'in', 'out' Indica se a associação é para

receber dados na função ou enviar
dados a partir da função.
PROPRIEDADE VALORES/TIPOS COMENTÁRIOS
name cadeia de caracteres O nome que é usado para os dados

associados na função. Em C#, esse é
um nome de um argumento. Em
JavaScript, é a chave em uma lista
de chaves/valores.
Aplicativo de função
O aplicativo de funções fornece um contexto de execução no Azure no qual suas funções são
executadas. Como tal, é a unidade de implantação e gerenciamento para suas funções. Um aplicativo de
funções é composto por uma ou mais funções individuais que são gerenciadas, implantadas e
dimensionadas em conjunto. Todas as funções em um aplicativo de funções compartilham o mesmo
plano de preços, método de implantação e versão de tempo de execução. Pense em um aplicativo de
funções como uma forma de organizar e gerenciar coletivamente suas funções. Para saber mais,
consulte como gerenciar um aplicativo de funções.
NOTE
Todas as funções em um aplicativo de funções devem ser criadas na mesma linguagem. Em versões anteriores do
Azure Functions Runtime, isso não era obrigatório.
Estrutura de pastas
O código para todas as funções em um aplicativo de funções específico está localizado em uma pasta do
projeto raiz que contém um arquivo de configuração do host e uma ou mais subpastas. Cada subpasta
contém o código para uma função distinta. A estrutura de pastas é mostrada no seguinte representação:
FunctionApp
| - host.json
| - Myfirstfunction
| | - function.json
| | - ...
| - mysecondfunction
| | - function.json
| | - ...
| - SharedCode
| - bin
Na versão 2.x do tempo de execução de funções, todas as funções no aplicativo de funções devem
compartilhar a mesma pilha de linguagem.
O host. JSON arquivo contém configurações específicas de tempo de execução e está na pasta raiz do
aplicativo de funções. Um bin pasta contém pacotes e outros arquivos de biblioteca que requer que o
aplicativo de funções. Consulte os requisitos específicos a um idioma para um projeto de aplicativo de
função:
Biblioteca de classes C# (.csproj)
Script do C# (.csx)
Script em F#
Java
JavaScript
A estrutura de pastas acima é a estrutura padrão (e recomendada) de um aplicativo de funções. Se você
quiser alterar o local do arquivo do código de uma função, modifique a seção scriptFile do arquivo
function.json. Também recomendamos usar a implantação de pacote para implantar seu projeto em seu
aplicativo de funções no Azure. Você também pode usar ferramentas existentes, como integração
contínua e implantação e Azure DevOps.
NOTE
Ao implantar um pacote manualmente, implante seu arquivo host.json e pastas da função diretamente na pasta
wwwroot . Não inclua a pasta wwwroot nas implantações. Caso contrário, você acabará com pastas
wwwroot\wwwroot .
Usar ferramentas locais e publicação

Os aplicativos de funções podem ser criados e publicados com várias ferramentas, incluindo o Visual
Studio, o Visual Studio Code, o IntelliJ, o Eclipse e o Azure Functions Core Tools. Para mais informações,
confira Codificar e testar o Azure Functions localmente.
Como editar funções no portal do Azure

O editor do Functions interno do portal do Azure permite que você atualize o código e o arquivo
function.json diretamente em linha. Isso é recomendado apenas para pequenas alterações ou provas de
conceito. A melhor prática é usar uma ferramenta de desenvolvimento local, como o VS Code.
Execução paralela
Quando vários eventos de gatilho ocorrem mais rápido do que um tempo de execução single-threaded
de função pode processar, o tempo de execução pode invocar a função várias vezes em paralelo. Se um
aplicativo de funções estiver usando o Plano de hospedagem de consumo, ele poderá escalar
horizontalmente de maneira automática. Cada instância do aplicativo de funções, quer seja executada no
Plano de hospedagem de consumo, quer em um Plano de hospedagem do Serviço de Aplicativo
comum, pode processar invocações de função simultâneas em paralelo usando vários threads. O
número máximo de invocações de função simultâneas em cada instância do aplicativo de funções varia
com base no tipo de gatilho que está sendo usado, bem como nos recursos usados por outras funções
no aplicativo de funções.
Controle de versão de tempo de execução de funções

Você pode configurar a versão do tempo de execução de Funções usando a configuração de aplicativo
FUNCTIONS_EXTENSION_VERSION . Por exemplo, o valor "~2" indica que seu Aplicativo de Funções usará 2.x
como sua versão principal. Aplicativos de funções são atualizados para cada nova versão secundária à
medida que elas são lançadas. Para saber mais, incluindo como exibir a versão exata do aplicativo de
funções, consulte Como direcionar versões de tempo de execução do Azure Functions.
Repositórios
O código para o Azure Functions é software livre e é armazenado em repositórios do GitHub:
Funções do Azure
Host do Azure Functions
Portal do Azure Functions
Modelos do Azure Functions
SDK WebJobs do Azure
Extensões do SDK WebJobs do Azure
Associações
Veja uma tabela de todas as associações com suporte.
Esta tabela mostra as associações com suporte nas duas versões principais do tempo de execução de
Azure Functions:
Armazenament ✔ ✔ ✔ ✔ ✔
o de Blobs
eventos
Eventos
WebHooks de ✔ ✔ ✔ ✔
& de HTTP
Graph
Excel tabelas
OneDrive
Microsoft
Graph
Microsoft ✔ ✔
Graph
Outlook email
Graph
events
Tokens de ✔ ✔
Auth Microsoft
Graph
Móveis
Hubs de ✔ ✔
Notificação
Armazenament ✔ ✔ ✔ ✔
o de filas
Serviço
SignalR ✔ ✔ ✔
Armazenament ✔ ✔ ✔ ✔
o de tabelas
Timer ✔ ✔ ✔
Twilio ✔ ✔ ✔
Consulte registrar extensões de associação. Todas as associações 2. x com suporte também têm suporte
na versão 3. x, salvo indicação em contrário.
Está tendo problemas com erros provenientes de associações? Examine a documentação de códigos de
erro de associação do Azure Functions.
Problemas de relatórios
ITEM DESCRIÇÃO LINK
Tempo de execução Host de Script, Gatilhos e Registrar um Problema

Associações, Suporte ao Idioma
Modelos Problemas de Código com o Registrar um Problema

Modelo de Criação
Portal Interface do Usuário ou Problema Registrar um Problema

de Experiência
Próximas etapas
Referência do desenvolvedor de C# do Azure Functions
Referência do desenvolvedor de NodeJS do Azure Functions
Enquanto você é capaz de desenvolver e testar o Azure Functions no Portal do Azure, muitos
desenvolvedores preferem uma experiência de desenvolvimento local. O Functions facilita a utilização do seu
editor de códigos favorito e das ferramentas de desenvolvimento para criar e testar as funções em seu
computador local. Suas funções locais podem se conectar a serviços do Azure em tempo real e você pode
depurá-las em seu computador local usando o tempo de execução total do Functions.
Ambientes de desenvolvimento locais

A maneira como você desenvolve funções em seu computador local depende de seu idioma e preferências de
ferramentas. Os ambientes na tabela a seguir dão suporte a desenvolvimento local:
AMBIENTE IDIOMAS DESCRIÇÃO
Visual Studio Code C# (biblioteca de classes), script (. A extensão do Azure Functions para
CSX), JavaScript C#, PowerShell, VS Code adiciona suporte ao
Python Functions para o VS Code. Requer as
Ferramentas Essenciais. Oferece
suporte ao desenvolvimento em
Linux, MacOS e Windows ao usar a
versão 2.x das Ferramentas Essenciais.
Para saber mais, confira Criar sua
primeira função usando o Visual
Studio Code.
Prompt de comando ou terminal C# (biblioteca de classes), script (. Ferramentas básicas do Azure

CSX), JavaScript C#, PowerShell, Functions fornece o tempo de
Python execução principal e os modelos para
a criação de funções, que habilitam o
desenvolvimento local. A versão 2.x
oferece suporte a desenvolvimento
em Linux, MacOS e Windows. Todos
os ambientes contam com
ferramentas essenciais para o tempo
de execução local do Functions.
Visual Studio 2019 C# (biblioteca de classes) As ferramentas de Azure Functions

estão incluídas na carga de trabalho
de desenvolvimento do Azure do
Visual Studio 2019 e versões
posteriores. Permite que você compile
funções em uma biblioteca de classes
e publique o arquivo .dll no Azure.
Inclui as Ferramentas Essenciais para
teste local. Para saber mais, consulte
Desenvolver Azure Functions usando
o Visual Studio.
AMBIENTE IDIOMAS DESCRIÇÃO
Maven (diversos) Java Integra-se com as Ferramentas

Essenciais para habilitar o
desenvolvimento de funções Java. A
versão 2.x oferece suporte a
desenvolvimento em Linux, MacOS e
Windows. Para saber mais, consulte
Criar sua primeira função com Java e
Maven. Também dá suporte ao uso
de desenvolvimento Eclipse e IntelliJ
IDEA
IMPORTANT
Não combine o desenvolvimento local com o desenvolvimento do portal no mesmo aplicativo de funções. Ao criar e
publicar funções de um projeto local, não tente manter ou modificar o código do projeto no portal.
Cada um desses ambientes de desenvolvimento local permite criar projetos de aplicativo de funções e usar
modelos predefinidos do Functions para criar novas funções. Cada um usa as Ferramentas Essenciais para
que você possa testar e depurar suas funções com relação ao tempo de execução do Functions em seu
próprio computador, assim como faria com qualquer outro aplicativo. Você também pode publicar seu projeto
de aplicativo de funções de qualquer um desses ambientes para o Azure.
Próximas etapas
Para saber mais sobre o desenvolvimento local de C# funções compiladas usando o visual Studio 2019,
consulte desenvolver Azure Functions usando o Visual Studio.
Para saber mais sobre o desenvolvimento local de funções usando o VS Code em um computador Mac,
Linux ou Windows, consulte implantar Azure Functions de vs Code.
Para saber mais sobre como desenvolver funções do prompt de comando ou do terminal, consulte
Trabalhar com as Ferramentas Essenciais do Azure Functions.
Desenvolva Azure Functions usando Visual Studio
Code
A extensão Azure Functions para Visual Studio Code permite que você desenvolva localmente funções e as
implante no Azure. Se esta for sua primeira experiência com o Azure Functions, você pode aprender mais em
Uma introdução ao Azure Functions.
A extensão Azure Functions fornece estes benefícios:
Editar, criar e executar funções em seu computador de desenvolvimento local.
Publicar seu projeto do Azure Functions diretamente no Azure.
Escreva suas funções em várias linguagens, aproveitando os benefícios de Visual Studio Code.
A extensão pode ser usada com os seguintes idiomas, que têm suporte do tempo de execução do Azure Functions
versão 2. x:
C#Compile
C#prescritiva*
JavaScript
Java
PowerShell
Python
* Requer que você defina C# script como seu idioma de projeto padrão.
Neste artigo, os exemplos estão disponíveis atualmente apenas para as funções JavaScript (Node. js C# ) e
biblioteca de classes.
Este artigo fornece detalhes sobre como usar a extensão Azure Functions para desenvolver funções e publicá-las
no Azure. Antes de ler este artigo, você deve criar sua primeira função usando Visual Studio Code.
IMPORTANT
Não combine desenvolvimento local e desenvolvimento de portal para um único aplicativo de funções. Ao publicar a partir
de um projeto local para um aplicativo de funções, o processo de implantação substitui quaisquer funções que você
desenvolveu o portal.
Pré-requisitos
Antes de instalar e executar a extensão de Azure Functions de extensão de Azure Functions, você deve atender a
esses requisitos:
Visual Studio Code instalado em uma das plataformas com suporte.
Outros recursos de que você precisa, como uma conta de armazenamento do Azure, são criados em sua
assinatura quando você publica usando Visual Studio Code.
IMPORTANT
Você pode desenvolver funções localmente e publicá-las no Azure sem precisar iniciá-las e executá-las localmente. Para
executar suas funções localmente, você precisará atender a alguns requisitos adicionais, incluindo um download automático
de Azure Functions Core Tools. Para saber mais, confira requisitos adicionais para executar um projeto localmente.

Studio Code.
3. Reinicie o Visual Studio Code e selecione o ícone do Azure na barra Atividade. Você deve ver uma área do
Azure Functions na barra lateral.
A extensão Functions permite criar um projeto de aplicativo de funções, juntamente com sua primeira função. As
etapas a seguir mostram como criar uma função disparada por HTTP em um novo projeto do functions. O gatilho
http é o modelo de gatilho de função mais simples para demonstrar.
1. Do Azure: Funções, selecione o ícone criar função :
2. Selecione a pasta para seu projeto de aplicativo de funções e, em seguida, Selecione um idioma para seu
projeto de função.
3. Selecione o modelo de função de gatilho http ou selecione ignorar agora para criar um projeto sem uma
função. Você sempre pode Adicionar uma função ao seu projeto posteriormente.
4. Digite HTTPTrigger para o nome da função e selecione Enter e, em seguida, selecione autorização de
função . Esse nível de autorização exige que você forneça uma chave de função ao chamar o ponto de
Uma função é criada no idioma escolhido e no modelo para uma função disparada por HTTP.
O modelo de projeto cria um projeto no idioma escolhido e instala as dependências necessárias. Para qualquer
idioma, o novo projeto tem estes arquivos:
host.json: Permite configurar o host do Functions. Essas configurações se aplicam quando você estiver
executando o Functions localmente e quando estiver executando-os no Azure. Para obter mais
informações, consulte a referência para host.json.
local.settings.json: Mantém as configurações usadas quando você está executando funções localmente.
Essas configurações são usadas somente quando você está executando funções localmente. Para obter
mais informações, consulte Local Settings File.
IMPORTANT
Como o arquivo local. Settings. JSON pode conter segredos, você precisa excluí-lo do seu controle de origem do
projeto.
Neste ponto, você pode adicionar associações de entrada e saída à sua função modificando o arquivo function.
JSON ou adicionando um parâmetro a uma C# função de biblioteca de classes.
Você também pode Adicionar uma nova função ao seu projeto.
Instalar extensões de associação

Exceto para gatilhos HTTP e de temporizador, as associações são implementadas em pacotes de extensão. Você
deve instalar os pacotes de extensão para os gatilhos e as associações que precisam deles. O processo de
instalação de extensões de associação depende do idioma do seu projeto.
JavaScript
C#
seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}
Adicionar uma função ao projeto

Você pode adicionar uma nova função a um projeto existente usando um dos modelos de gatilho de funções
predefinidos. Para adicionar um novo gatilho de função, selecione F1 para abrir a paleta de comandos e, em
seguida, pesquise e execute o comando Azure Functions: Criar função. Siga os prompts para escolher o tipo
de disparador e definir os atributos necessários do gatilho. Se o gatilho exigir uma chave de acesso ou uma cadeia
de conexão para se conectar a um serviço, prepare-o antes de criar o gatilho de função.
Os resultados dessa ação dependem do idioma do seu projeto:
JavaScript
C#
Uma nova pasta é criada no projeto. A pasta contém um novo arquivo function. JSON e o novo arquivo de código
JavaScript.
Adicionar associações de entrada e saída

Você pode expandir sua função adicionando associações de entrada e saída. O processo para adicionar
associações depende do idioma do seu projeto. Para saber mais sobre associações, confira Azure Functions os
conceitos de gatilhos e associações.
Os exemplos a seguir se conectam a uma outqueue fila de armazenamento chamada, em que a cadeia de conexão
para a MyStorageConnection conta de armazenamento é definida na configuração do aplicativo em local. Settings.
JSON.
JavaScript
C#
Visual Studio Code permite que você adicione associações ao seu arquivo function. JSON seguindo um conjunto
conveniente de prompts. Para criar uma associação, clique com o botão direito do mouse (Ctrl + clique em
macOS ) o arquivo Function. JSON em sua pasta de funções e selecione Adicionar Associação:
Veja a seguir exemplos de prompts para definir uma nova associação de saída de armazenamento:
Selecionar associação com direção Azure Queue Storage A associação é uma associação de fila
do Armazenamento do Azure.

uso.
Selecione a configuração de MyStorageConnection O nome de uma configuração de

conexão para a conta de
armazenamento. A
AzureWebJobsStorage configuração
conta de armazenamento que você
criou com o aplicativo de funções.
Neste exemplo, a seguinte associação é adicionada à bindings matriz em seu arquivo function. JSON:
{
"type": "queue",
"direction": "out",
"name": "msg",
}
Você também pode adicionar a mesma definição de ligação diretamente ao seu function. JSON.
No seu código de função, msg a associação é acessada context do, como neste exemplo:
context.bindings.msg = "Name passed to the function: " req.query.name;
Para saber mais, consulte a referência de Associação de saída de armazenamento de filas .

O parâmetro msg é um tipo ICollector<T> , que representa uma coleção de mensagens que são gravadas em
uma associação de saída quando a função é concluída. Você adiciona uma ou mais mensagens à coleção. Essas
mensagens são enviadas para a fila quando a função é concluída.
Para saber mais, consulte a documentação de Associação de saída de armazenamento de filas .
Functions:
de Blobs
eventos
Hubs de Eventos ✔ ✔ ✔ ✔
de HTTP
Excel tabelas
OneDrive
Microsoft Graph
Outlook email
events
Tokens de ✔ ✔
Auth Microsoft
Graph
Móveis
Hubs de ✔ ✔
Notificação
de filas
Serviço
SignalR ✔ ✔ ✔
de tabelas
Timer ✔ ✔ ✔
Twilio ✔ ✔ ✔
1 no tempo de execução da versão 2. x, todas as associações, exceto http e Timer, devem

ser registradas. Consulte
registrar extensões de associação. Todas as associações 2. x com suporte também têm suporte na versão 3. x,
salvo indicação em contrário.
Publicar no Azure
Visual Studio Code permite publicar seu projeto do Functions diretamente no Azure. No processo, você criará um
aplicativo de funções e recursos relacionados em sua assinatura do Azure. O aplicativo de funções fornece um
contexto de execução para suas funções. O projeto é empacotado e implantado para o novo aplicativo de função
em sua assinatura do Azure.
Quando você publica de Visual Studio Code em um novo aplicativo de funções no Azure, é oferecido um caminho
de criação de aplicativo de função rápida e um caminho avançado.
Ao publicar do Visual Studio Code, você tira proveito da tecnologia de implantação de zip .
Criação rápida de aplicativos de funções
Quando você escolhe + criar novo aplicativo de funções no Azure... , a extensão gera automaticamente
valores para os recursos do Azure necessários para seu aplicativo de funções. Esses valores se baseiam no nome
do aplicativo de funções que você escolher. Para obter um exemplo de como usar os padrões para publicar seu
projeto em um novo aplicativo de funções no Azure, consulte o artigo Visual Studio Code início rápido.
Se você quiser fornecer nomes explícitos para os recursos criados, deverá escolher o caminho avançado de
criação.
Publicar um projeto em um novo aplicativo de funções no Azure usando opções avançadas
As etapas a seguir publicam seu projeto em um novo aplicativo de funções criado com opções de criação
avançadas:
1. Na área Azure: Na área de funções, selecione o ícone implantar em aplicativo de funções .
2. Se você não estiver conectado, você será solicitado a entrar no Azure. Você também pode Criar uma
conta gratuita do Azure. Depois de entrar no navegador, volte para Visual Studio Code.
3. Se você tiver várias assinaturas, Selecione uma assinatura para o aplicativo de funções e, em seguida,
selecione + criar novo aplicativo de funções no Azure... Avançado . Essa opção avançada oferece
mais controle sobre os recursos que você cria no Azure.
4. Seguindo os prompts, forneça estas informações:

Selecionar aplicativo de funções no Criar novos Aplicativo de funções no No prompt seguinte, digite um nome
Azure Azure globalmente exclusivo que
identifique o novo aplicativo de
funções e selecione Enter. Caracteres
válidos para um nome de aplicativo
de funções são a-z , 0-9 e - .
Selecionar um sistema operacional Windows O aplicativo de funções é executado

no Windows.
Selecionar um plano de hospedagem Plano de consumo Uma hospedagem de plano de

consumo sem servidor é usada.
Selecione um tempo de execução A linguagem do projeto O tempo de execução deve

para seu novo aplicativo corresponder ao projeto que você
está publicando.
Selecionar um grupo de recursos Criar novo grupo de recursos No prompt seguinte, digite um nome
para novos recursos de grupo de recursos,
myResourceGroup como e, em
seguida, selecione Enter. Você
também pode selecionar um grupo
de recursos existente.
Selecione uma conta de Criar nova conta de armazenamento No prompt seguinte, digite um nome
armazenamento. globalmente exclusivo para a nova
conta de armazenamento usada pelo
seu aplicativo de funções e selecione
Enter. Os nomes de conta de
Você também pode selecionar uma
conta existente.
Selecione um local para novos Região Selecione um local em uma região

recursos perto de você ou perto de outros
serviços que suas funções acessam.
Republicar arquivos de projeto

Quando você configura a implantação contínua, seu aplicativo de funções no Azure é atualizado sempre que os
arquivos de origem são atualizados no local de origem conectado. Recomendamos a implantação contínua, mas
você também pode republicar as atualizações do arquivo de projeto de Visual Studio Code.
IMPORTANT
1. Em Visual Studio Code, selecione F1 para abrir a paleta de comandos. Na paleta de comandos, procure e
selecione Azure Functions: Implante no aplicativode funções.
2. Se você não estiver conectado, você será solicitado a entrar no Azure. Depois de entrar no navegador, volte
para Visual Studio Code. Se você tiver várias assinaturas, Selecione uma assinatura que contenha seu
3. Selecione seu aplicativo de funções existente no Azure. Quando você for avisado sobre a substituição de
todos os arquivos no aplicativo de funções, selecione implantar para confirmar o aviso e continuar.
O projeto é recriado, reempacotado e carregado no Azure. O projeto existente é substituído pelo novo pacote e o
aplicativo de funções é reiniciado.
Obter a URL da função implantada

Para chamar uma função disparada por HTTP, você precisa da URL da função quando ela é implantada em seu
aplicativo de funções. Essa URL inclui quaisquer chaves de funçãonecessárias. Você pode usar a extensão para
obter essas URLs para suas funções implantadas.
1. Selecione F1 para abrir a paleta de comandos e, em seguida, pesquise e execute o comando Azure
Functions: Copiar URLda função.
2. Siga os prompts para selecionar seu aplicativo de funções no Azure e, em seguida, o gatilho HTTP
específico que você deseja invocar.
A URL da função é copiada para a área de transferência, juntamente com as chaves code necessárias passadas
pelo parâmetro de consulta. Use uma ferramenta HTTP para enviar solicitações POST ou um navegador para
solicitações GET para a função remota.
Executar funções localmente

A extensão Azure Functions permite executar um projeto do Functions em seu computador de desenvolvimento
local. O tempo de execução local é o mesmo tempo de execução que hospeda seu aplicativo de funções no Azure.
As configurações locais são lidas no arquivo local. Settings. JSON.
Requisitos adicionais para executar um projeto localmente
Para executar o projeto do Functions localmente, você deve atender a estes requisitos adicionais:
Instale a versão 2. x de Azure Functions Core Tools. O pacote de ferramentas principais é baixado e
instalado automaticamente quando você inicia o projeto localmente. As ferramentas principais incluem
todo o tempo de execução de Azure Functions, portanto, o download e a instalação podem levar algum
tempo.
Instale os requisitos específicos para a linguagem de programação escolhida:
IDIOMA REQUISITO
C# Extensão C#
Ferramentas de CLI do .NET Core
Java Depurador para extensão Java

Java 8
Maven 3 ou posterior
JavaScript Node.js*
Python Extensão do Python

Python 3,6 ou posterior
* Active LTS e versões LTS de manutenção (8.11.1 e 10.14.1 recomendadas).

Configurar o projeto para ser executado localmente
O tempo de execução do Functions usa uma conta de armazenamento do Azure internamente para todos os tipos
de gatilho diferentes de HTTP e WebHooks. Portanto, você precisa definir a chave Values.
AzureWebJobsStorage para uma cadeia de conexão válida da conta de armazenamento do Azure.
Esta seção usa a extensão de armazenamento do Azure para Visual Studio Code com Gerenciador de
armazenamento do Azure para se conectar e recuperar a cadeia de conexão de armazenamento.
Para definir a cadeia de conexão da conta de armazenamento:
1. No Visual Studio, abra o Cloud Explorer, expanda conta > de armazenamentosua conta de
armazenamentoe selecione Propriedades e copie o valor da cadeia de conexão primária .
2. Em seu projeto, abra o arquivo local.settings.json e defina o valor da chave AzureWebJobsStorage na
cadeia de conexão que você copiou.
3. Repita a etapa anterior para adicionar as chaves exclusivas para a matriz de Valores para todas as outras
conexões necessárias para as suas funções.
Para obter mais informações, consulte Local Settings File.
Depuração de funções localmente
Para depurar suas funções, selecione F5. Se você ainda não tiver baixado as ferramentas principais, você será
solicitado a fazê-lo. Quando as ferramentas principais estão instaladas e em execução, a saída é mostrada no
terminal. Isso é o mesmo que executar o func host start comando de ferramentas principais do terminal, mas
com tarefas de compilação adicionais e um depurador anexado.
Quando o projeto estiver em execução, você poderá disparar suas funções como faria quando o projeto for
implantado no Azure. Quando o projeto está sendo executado no modo de depuração, os pontos de interrupção
são atingidos em Visual Studio Code, conforme esperado.
A URL de solicitação para gatilhos HTTP é exibida na saída no terminal. As teclas de função para gatilhos HTTP
não são usadas quando um projeto é executado localmente. Para saber mais informações, consulte Estratégias
para testar seu código no Azure Functions.
Para saber mais, confira trabalhar com Azure Functions Core Tools.
Arquivo de configurações local

O arquivo local. Settings. JSON armazena as configurações do aplicativo, cadeias de conexão e configurações
usadas pelas ferramentas de desenvolvimento local. As configurações no arquivo local. Settings. JSON são
usadas somente quando você está executando projetos localmente. O arquivo de configurações local tem esta
estrutura:
{
"Values": {
"FUNCTIONS_WORKER_RUNTIME": "<language worker>",
"AzureWebJobsStorage": "<connection-string>",
"AzureWebJobsDashboard": "<connection-string>",
"MyBindingConnection": "<binding-connection-string>"
},
"Host": {
"LocalHttpPort": 7071,
"CORS": "*",
"CORSCredentials": false
},
"ConnectionStrings": {
"SQLConnectionString": "<sqlclient-connection-string>"
}
}
Essas configurações têm suporte quando você executa projetos localmente:
CONFIGURAÇÃO DESCRIÇÃO
IsEncrypted Quando essa configuração é definida como true , todos os

valores são criptografados com uma chave do computador
local. Usado com func settings comandos. O valor padrão
é false .
Values Matriz de configurações de aplicativo e cadeias de conexão

usadas quando um projeto é executado localmente. Esses
pares de chave-valor (cadeia de caracteres de cadeia de
caracteres) correspondem às configurações do aplicativo em
seu AzureWebJobsStorage aplicativo de funções no Azure,
como. Muitos gatilhos e associações têm uma propriedade
que se refere a uma configuração de aplicativo de cadeia
Connection de conexão, como para o gatilho do
armazenamentode BLOBs. Para essas propriedades, você
precisa de uma configuração de aplicativo definida Values
na matriz.
AzureWebJobsStorage é uma configuração de aplicativo
necessária para gatilhos diferentes de HTTP.
A versão 2. x do tempo de execução do Functions requer a
configuração [ FUNCTIONS_WORKER_RUNTIME ], que é gerada
para seu projeto por ferramentas principais.
Quando você tiver o emulador de armazenamento do Azure
instalado localmente AzureWebJobsStorage e
UseDevelopmentStorage=true definido como, as ferramentas
principais usarão o emulador. O emulador é útil durante o
desenvolvimento, mas você deve testar com uma conexão de
armazenamento real antes da implantação.
Os valores devem ser cadeias de caracteres e não objetos
JSON ou matrizes. Os nomes de configuração não podem
incluir : dois-pontos () ou __ um sublinhado duplo (). Esses
caracteres são reservados pelo tempo de execução.
Host As configurações nesta seção personalizam o processo de

host do Functions quando você executa projetos localmente.
Essas configurações são separadas das configurações de host.
JSON, que também se aplicam quando você executa projetos
no Azure.
LocalHttpPort Define a porta padrão usada ao executar o host local do

Functions ( func host start e func run ). A --port
opção de linha de comando tem precedência sobre essa
configuração.
CORS Define as origens permitidas para CORS (Compartilhamento

de recurso entre origens). As origens são fornecidas como
uma lista separada por vírgulas, sem espaços. Há suporte
para o valor do caractere curinga (*), que permite solicitações
de qualquer origem.
CORSCredentials Quando definido como true , permite withCredentials

solicitações.
ConnectionStrings Uma coleção. Não use essa coleção para as cadeias de

conexão usadas por suas associações de função. Essa coleção
é usada somente por estruturas que normalmente recebem
cadeias de conexão da ConnectionStrings seção de um
arquivo de configuração, como Entity Framework. As cadeias
de caracteres de conexão neste objeto são adicionadas ao
ambiente com o tipo de provedor de System.Data.SqlClient.
Os itens nesta coleção não são publicados no Azure com
outras configurações de aplicativo. Você deve adicionar esses
valores explicitamente à Connection strings coleção de
suas configurações do aplicativo de funções. Se você estiver
criando um SqlConnection no seu código de função, deverá
armazenar o valor da cadeia de conexão com suas outras
conexões nas configurações do aplicativo no Portal.
Por padrão, essas configurações não são migradas automaticamente quando o projeto é publicado no Azure.
Depois que a publicação for concluída, você terá a opção de publicar configurações de local. Settings. JSON em
seu aplicativo de funções no Azure. Para saber mais, consulte Publicar configurações do aplicativo.
Os valores em ConnectionStrings nunca são publicados.
Os valores das configurações do aplicativo de funções também podem ser lidos em seu código como variáveis de
ambiente. Para obter mais informações, consulte as seções de variáveis de ambiente desses artigos de referência
específicos a um idioma:
C# pré-compilado
Script do C# (.csx)
Java
JavaScript
Configurações do aplicativo no Azure

As configurações no arquivo local. Settings. JSON em seu projeto devem ser as mesmas que as configurações do
aplicativo no aplicativo de funções no Azure. Todas as configurações adicionadas a local. Settings. JSON também
devem ser adicionadas ao aplicativo de funções no Azure. Essas configurações não são carregadas
automaticamente quando você publica o projeto. Da mesma forma, todas as configurações que você cria em seu
aplicativo de funções no portal devem ser baixadas em seu projeto local.
Publicar configurações do aplicativo
A maneira mais fácil de publicar as configurações necessárias para seu aplicativo de funções no Azure é usar o
link carregar configurações que aparece depois de publicar o projeto:
Você também pode publicar as configurações usando o Azure Functions: Carregue o comando de
configuração local na paleta de comandos. Você pode adicionar configurações individuais às configurações do
aplicativo no Azure usando o Azure Functions: Adicionar novo comando de configuração.
TIP
Certifique-se de salvar seu arquivo local. Settings. JSON antes de publicá-lo.
Se o arquivo local for criptografado, ele será descriptografado, publicado e criptografado novamente. Se houver
configurações com valores conflitantes nos dois locais, você será solicitado a escolher como proceder.
Exibir configurações de aplicativo existentes no Azure: Área de funções expandindo sua assinatura, seu aplicativo
de funções e as configurações do aplicativo.
Baixar configurações do Azure

Se você tiver criado as configurações do aplicativo no Azure, poderá baixá-las no arquivo local. Settings. JSON
usando o Azure Functions: Comando baixar configurações remotas.
Assim como acontece com o carregamento, se o arquivo local for criptografado, ele será descriptografado,
atualizado e criptografado novamente. Se houver configurações com valores conflitantes nos dois locais, você
será solicitado a escolher como proceder.
Quando você executa funções localmente, os dados de log são transmitidos para o console do terminal. Você
também pode obter dados de log quando seu projeto do Functions está em execução em um aplicativo de
funções no Azure. Você pode se conectar aos logs de streaming no Azure para ver os dados de log quase em
tempo real, ou pode habilitar Application Insights para um entendimento mais completo de como seu aplicativo
de funções está se comportando.
Logs de streaming
Quando você está desenvolvendo um aplicativo, muitas vezes é útil ver informações de log em tempo quase real.
Você pode exibir um fluxo de arquivos de log que estão sendo gerados por suas funções. Essa saída é um exemplo
de logs de streaming para uma solicitação para uma função disparada por HTTP:
Para saber mais, confira logs de streaming.

Para ativar os logs de streaming para seu aplicativo de funções no Azure:
1. Selecione F1 para abrir a paleta de comandos e, em seguida, pesquise e execute o comando Azure
Functions: Inicie os logsde streaming.
2. Selecione seu aplicativo de funções no Azure e, em seguida, selecione Sim para habilitar o log de aplicativo
para o aplicativo de funções.
3. Dispare suas funções no Azure. Observe que os dados de log são exibidos na janela saída no Visual Studio
Code.
4. Quando terminar, lembre-se de executar o comando Azure Functions: Interrompa os logs de streaming
para desabilitar o registro em log para o aplicativo de funções.
NOTE
Os logs de streaming dão suporte a apenas uma única instância do host do functions. Quando a função é dimensionada
para várias instâncias, os dados de outras instâncias não são mostrados no fluxo de log. Live Metrics Stream no Application
insights oferece suporte a várias instâncias. Embora também esteja quase em tempo real, o Stream Analytics é baseado em
dados de amostra.
Application Insights
Recomendamos que você monitore a execução de suas funções integrando seu aplicativo de funções com
Application Insights. Quando você cria um aplicativo de funções no portal do Azure, essa integração ocorre por
padrão. Ao criar seu aplicativo de funções durante a publicação do Visual Studio, você precisa integrar Application
Insights você mesmo.
As funções facilitam a adição da integração do Application Insights a um aplicativo de funções do portal do Azure.
1. No portal, selecione Todos os serviços > Aplicativos de Funções, selecione o aplicativo de funções e,
em seguida, selecione a faixa do Application Insights na parte superior da janela
2. Crie um recurso do Application Insights usando as configurações especificadas na tabela abaixo da

imagem.
Nome Nome de aplicativo exclusivo É mais fácil usar o mesmo nome que
seu aplicativo de funções, que deve
ser exclusivo em sua assinatura.
Localidade Europa Ocidental Se possível, use a mesma região que

seu aplicativo de funções ou uma
região próxima dela.
3. Selecione OK. O recurso do Application Insights é criado no mesmo grupo de recursos e assinatura que
seu aplicativo de funções. Depois que o recurso for criado, feche a janela do Application Insights.
4. No aplicativo de funções, selecione Configurações do aplicativo e role para baixo até Configurações
do aplicativo. Se você vir uma configuração chamada APPINSIGHTS_INSTRUMENTATIONKEY , isso significa que a
integração do Application Insights está habilitada para seu aplicativo de funções em execução no Azure.
Para saber mais, consulte Monitorar Azure Functions.
Projetos# de script C
Por padrão, todos C# os projetos são criados como C# projetos de biblioteca de classes compilados. Se você
preferir trabalhar com C# projetos de script em vez disso, deverá C# selecionar script como o idioma padrão nas
configurações de extensão de Azure Functions:
1. Selecione arquivo > preferênciasconfigurações > .
2. Vá para configurações > de usuárioextensões > Azure Functions.
3. Selecione o script C # do Azure Function: Linguagemdo projeto.
Depois de concluir essas etapas, as chamadas feitas às ferramentas básicas subjacentes incluem --csx a opção,
que gera e publica C# arquivos de projeto de script (. CSX). Quando você tem esse idioma padrão especificado,
todos os projetos que você cria são C# padrão para criar scripts de projetos. Não será solicitado que você escolha
uma linguagem de projeto quando um padrão for definido. Para criar projetos em outros idiomas, você deve
alterar essa configuração ou removê-la do arquivo Settings. JSON do usuário. Depois de remover essa
configuração, você será solicitado a escolher o idioma novamente quando criar um projeto.
Referência da paleta de comandos
A extensão Azure Functions fornece uma interface gráfica útil na área para interagir com seus aplicativos de
funções no Azure. A mesma funcionalidade também está disponível como comandos na paleta de comandos (F1).
Estes Azure Functions comandos estão disponíveis:
AZURE FUNCTIONS COMANDO DESCRIÇÃO
Adicionar novas configurações Cria uma nova configuração de aplicativo no Azure. Para
saber mais, consulte Publicar configurações do aplicativo.
Talvez você também precise baixar essa configuração para
suas configurações locais.
Configurar a origem da implantação Conecta seu aplicativo de funções no Azure a um repositório

git local. Para saber mais, consulte implantação contínua para
Azure Functions.
Conectar ao repositório GitHub Conecta seu aplicativo de funções a um repositório GitHub.
Copiar URL da função Obtém a URL remota de uma função disparada por HTTP que
está sendo executada no Azure. Para saber mais, veja obter a
URL da função implantada.
Criar aplicativo de funções no Azure Cria um novo aplicativo de funções em sua assinatura no
Azure. Para saber mais, consulte a seção sobre como publicar
em um novo aplicativo de funções no Azure.
Descriptografar configurações Descriptografa as configurações locais que foram

criptografadas pelo Azure Functions: Configuraçõesde
criptografia.
Excluir Aplicativo de funções Remove um aplicativo de funções de sua assinatura no Azure.

Quando não há outros aplicativos no plano do serviço de
aplicativo, você tem a opção de excluí-lo também. Outros
recursos, como contas de armazenamento e grupos de
recursos, não são excluídos. Para remover todos os recursos,
você deve, em vez disso, excluir o grupo de recursos. Seu
projeto local não é afetado.
Excluir função Remove uma função existente de um aplicativo de funções no

Azure. Como essa exclusão não afeta seu projeto local,
considere remover a função localmente e, em seguida,
republicar seu projeto.
Excluir proxy Remove um proxy Azure Functions do seu aplicativo de

funções no Azure. Para saber mais sobre proxies, confira
trabalhar com proxies do Azure Functions.
Excluir configuração Exclui uma configuração de aplicativo de funções no Azure.

Essa exclusão não afeta as configurações no arquivo local.
Settings. JSON.
Desconectar do repositório Remove a conexão de implantação contínua entre um

aplicativo de funções no Azure e um repositório de controle
do código-fonte.
Baixar configurações remotas Baixa as configurações do aplicativo de funções escolhido no

Azure no arquivo local. Settings. JSON. Se o arquivo local for
criptografado, ele será descriptografado, atualizado e
criptografado novamente. Se houver configurações com
valores conflitantes nos dois locais, você será solicitado a
escolher como proceder. Lembre-se de salvar as alterações no
arquivo local. Settings. JSON antes de executar esse comando.
Editar configurações Altera o valor de uma configuração de aplicativo de funções

existente no Azure. Esse comando não afeta as configurações
no arquivo local. Settings. JSON.
Configurações de criptografia Criptografa itens individuais na Values matriz nas

configurações locais. Nesse arquivo, IsEncrypted também é
definido como true , que especifica que o tempo de
execução local descriptografará as configurações antes de
usá-las. Criptografe as configurações locais para reduzir o
risco de vazar informações valiosas. No Azure, as
configurações do aplicativo sempre são armazenadas
criptografadas.
Executar função agora Inicia manualmente uma função disparada por temporizador
no Azure. Esse comando é usado para teste. Para saber mais
sobre como disparar funções não HTTP no Azure, consulte
executar manualmente uma função não disparada por http.
Inicializar o projeto para uso com VS Code Adiciona os arquivos de projeto de Visual Studio Code
necessários a um projeto de funções existente. Use esse
comando para trabalhar com um projeto que você criou
usando as ferramentas básicas.
Instalar ou atualizar Azure Functions Core Tools Instala ou atualiza Ferramentas básicas do Azure Functions,
que é usado para executar funções localmente.
Reimplantar Permite reimplantar arquivos de projeto de um repositório git

conectado para uma implantação específica no Azure. Para
republicar as atualizações locais do Visual Studio Code,
Republique o projeto.
Renomear configurações Altera o nome da chave de uma configuração de aplicativo de

funções existente no Azure. Esse comando não afeta as
configurações no arquivo local. Settings. JSON. Depois de
renomear as configurações no Azure, você deve baixar essas
alterações no projeto local.
Reiniciar Reinicia o aplicativo de funções no Azure. A implantação de

atualizações também reinicia o aplicativo de funções.
Definir AzureWebJobsStorage Define o valor da AzureWebJobsStorage configuração do

aplicativo. Essa configuração é exigida pelo Azure Functions.
Ele é definido quando um aplicativo de funções é criado no
Azure.
Iniciar Inicia um aplicativo de função parado no Azure.

Iniciar logs de streaming Inicia os logs de streaming para o aplicativo de funções no

Azure. Use logs de streaming durante a solução de problemas
remota no Azure se você precisar ver informações de log em
tempo quase real. Para saber mais, confira logs de streaming.
Parar Interrompe um aplicativo de funções que está sendo

executado no Azure.
Parar logs de streaming Interrompe os logs de streaming para o aplicativo de funções

no Azure.
Alternar como configuração de slot Quando habilitado, o garante que uma configuração de
aplicativo persista para um determinado slot de implantação.
Desinstalar o Azure Functions Core Tools Remove Azure Functions Core Tools, que é exigido pela
extensão.
Carregar configurações locais Carrega as configurações do arquivo local. Settings. JSON

para o aplicativo de funções escolhido no Azure. Se o arquivo
local for criptografado, ele será descriptografado, carregado e
criptografado novamente. Se houver configurações com
valores conflitantes nos dois locais, você será solicitado a
escolher como proceder. Lembre-se de salvar as alterações no
arquivo local. Settings. JSON antes de executar esse comando.
Exibir confirmação no GitHub Mostra a confirmação mais recente em uma implantação

específica quando seu aplicativo de funções está conectado a
um repositório.
Exibir logs de implantação Mostra os logs de uma implantação específica para o

aplicativo de funções no Azure.
Próximas etapas
Para saber mais sobre Azure Functions Core Tools, confira trabalhar com Azure Functions Core Tools.
Para saber mais sobre como desenvolver funções como bibliotecas de classes do .NET, consulte Referência do
desenvolvedor de C# do Azure Functions. Este artigo também fornece links para exemplos de como usar
atributos para declarar os vários tipos de associações com suporte pelo Azure Functions.
Desenvolver o Azure Functions usando o Visual
Studio
O Visual Studio permite que você desenvolva, teste C# e implante funções de biblioteca de classes no Azure. Se
esta for sua primeira experiência com o Azure Functions, você pode aprender mais em Uma introdução ao
Azure Functions.
O Visual Studio oferece os seguintes benefícios ao desenvolver suas funções:
Editar, criar e executar funções em seu computador de desenvolvimento local.
Publique seu projeto de Azure Functions diretamente no Azure e crie recursos do Azure conforme
necessário.
Use C# atributos para declarar associações de função diretamente no C# código.
Desenvolver e implantar funções de pré-compiladas C#. Funções pré-compiladas fornecem um
desempenho de inicialização a frio melhor que funções baseadas em script C#.
Codificar suas funções em C# tendo todos os benefícios de desenvolvimento do Visual Studio.
Este artigo fornece detalhes sobre como usar o Visual Studio para desenvolver C# funções de biblioteca de
classes e publicá-las no Azure. Antes de ler este artigo, você deve concluir o início rápido das Funções para o
Visual Studio.
Salvo indicação em contrário, os procedimentos e exemplos mostrados são para o Visual Studio 2019.
Pré-requisitos
Azure Functions ferramentas estão incluídas na carga de trabalho de desenvolvimento do Azure do Visual
Studio, começando com o Visual Studio 2017. Certifique-se de incluir a carga de trabalho de
desenvolvimento do Azure em sua instalação do Visual Studio.
Outros recursos necessários, como uma conta de armazenamento do Azure, são criados em sua assinatura
durante o processo de publicação.
NOTE
No Visual Studio 2017, a carga de trabalho de desenvolvimento do Azure instala as ferramentas de Azure Functions
como uma extensão separada. Ao atualizar o Visual Studio 2017, verifique também se você está usando a versão mais
recente das ferramentas de Azure functions. As seções a seguir mostram como verificar e (se necessário) atualizar sua
extensão de ferramentas de Azure Functions no Visual Studio 2017.
Ignore esta seção ao usar o Visual Studio 2019.
Verifique a versão das ferramentas no Visual Studio 2017

1. No menu Ferramentas, clique em Extensões e Atualizações. Expanda as Ferramentas > Instaladas
e escolha Azure Functions e Ferramentas de Trabalhos da Web .
2. Observe a Versão instalada. Você pode comparar esta versão com a versão mais recente listada nas
notas de versão.
3. Se a sua versão for mais antiga, atualize suas ferramentas no Visual Studio conforme mostrado na seção
a seguir.
Atualize suas ferramentas no Visual Studio 2017
1. Na caixa de diálogo Extensões e Atualizações, expanda Atualizações > Visual Studio Marketplace,
escolha Azure Functions e Ferramentas de Trabalhos da Web e selecione Atualizar.
2. Depois de fazer o download da atualização das ferramentas, feche o Visual Studio para disparar a
atualização das ferramentas usando o instalador VSIX.
3. No instalador, escolha OK para iniciar e depois Modificar para atualizar as ferramentas.
4. Depois que a atualização for concluída, escolha Fechar e reinicie o Visual Studio.
NOTE
No Visual Studio 2019 e posterior, a extensão de ferramentas de Azure Functions é atualizada como parte do
Visual Studio.

O modelo de projeto do Azure Functions no Visual Studio cria um projeto que pode ser publicado em um
aplicativo de funções no Azure. Você pode usar um aplicativo de funções para as funções do grupo como uma
unidade lógica para gerenciamento, implantação e compartilhamento de recursos.
1. No Visual Studio, no menu Arquivo, selecione Novo > Projeto.
2. Na caixa de diálogo Criar um projeto, pesquise functions , escolha o modelo do Azure Functions e
selecione Avançar.
3. Insira um nome para seu projeto e selecione Criar. O nome do aplicativo de funções deve ser válido
como um namespace do C# e, portanto, não use outros caracteres não alfanuméricos, hífens ou
sublinhados.
4. Em Criar um aplicativo Azure Functions, use as opções a seguir:
Azure Functions v2 (.NET Core) 1
Gatilho HTTP
Conta de Armazenamento: Emulador de armazenamento
Nível de autorização: Anônimo
OPÇÃO VALOR SUGERIDO DESCRIÇÃO
Tempo de execução do Functions Azure Functions 2.x Essa configuração cria um projeto
(.NET Core) de função que usa o tempo de
execução versão 2.x do Azure
Functions, o qual dá suporte a .NET
Core. O Azure Functions 1.x dá
suporte ao .NET Framework. Para
obter mais informações, consulte
Direcionar o tempo de execução do
Azure Functions.
Modelo de função Gatilho HTTP Essa configuração cria uma função

acionada por uma solicitação HTTP.
Conta de armazenamento Emulador de armazenamento Um gatilho HTTP não usa a conexão

da conta de Armazenamento do
Microsoft Azure. Todos os outros
tipos de gatilho exigem uma cadeia
de conexão de conta de
armazenamento válida. Como o
Functions requer uma conta de
armazenamento, uma é atribuída ou
criada quando você publica seu
projeto no Azure.
Nível de autorização Anônimo A função criada pode ser acionada

por qualquer cliente sem fornecer
uma chave. Essa configuração de
autorização torna fácil testar a nova
função. Para obter mais informações
sobre chaves e autorização, consulte
Chaves de autorização no
associações HTTP e webhook.
NOTE
Verifique se você definiu o Nível de autorização como Anonymous . Se você escolher o nível padrão de
Function , é necessário que você apresente a chave da função em solicitações para acessar seu ponto de
5. Selecione Criar para criar o projeto de função e a função disparada por HTTP.
O modelo de projeto cria um projeto C#, instala o pacote NuGet Microsoft.NET.Sdk.Functions e define a
estrutura de destino. O novo projeto contém os seguintes arquivos:
host.json: Permite configurar o host do Functions. Essas configurações se aplicam para execução local e
no Azure. Para obter mais informações, consulte a referência para host.json.
local.settings.json: Mantém as configurações usadas ao executar as funções localmente. Essas
configurações não são usadas durante a execução no Azure. Para obter mais informações, consulte Local
Settings File.
IMPORTANT
Como o arquivo Settings pode conter segredos, ele devem ser excluídos do seu controle de origem do projeto. A
configuração Cópia para o diretório de saída desse arquivo deve ser sempre Copiar se for mais recente.
Para saber mais, confira Projeto de biblioteca de classe de funções.

O arquivo local. Settings. JSON armazena as configurações do aplicativo, cadeias de conexão e configurações
usadas pelas ferramentas de desenvolvimento local. As configurações no arquivo local. Settings. JSON são
usadas somente quando você está executando projetos localmente. O arquivo de configurações local tem esta
estrutura:
{
"Values": {
},
"Host": {
"CORS": "*",
},
}
}
IsEncrypted Quando essa configuração é definida como true , todos os

valores são criptografados com uma chave do computador
local. Usado com func settings comandos. O valor
padrão é false .
Values Matriz de configurações de aplicativo e cadeias de conexão

usadas quando um projeto é executado localmente. Esses
pares de chave-valor (cadeia de caracteres de cadeia de
caracteres) correspondem às configurações do aplicativo em
seu AzureWebJobsStorage aplicativo de funções no Azure,
como. Muitos gatilhos e associações têm uma propriedade
que se refere a uma configuração de aplicativo de cadeia
Connection de conexão, como para o gatilho do
armazenamentode BLOBs. Para essas propriedades, você
precisa de uma configuração de aplicativo definida Values
na matriz.
A versão 2. x do tempo de execução do Functions requer a
configuração [ FUNCTIONS_WORKER_RUNTIME ], que é gerada
para seu projeto por ferramentas principais.
Quando você tiver o emulador de armazenamento do Azure
instalado localmente AzureWebJobsStorage e
UseDevelopmentStorage=true definido como, as
ferramentas principais usarão o emulador. O emulador é útil
durante o desenvolvimento, mas você deve testar com uma
conexão de armazenamento real antes da implantação.
Os valores devem ser cadeias de caracteres e não objetos
JSON ou matrizes. Os nomes de configuração não podem
incluir : dois-pontos () ou __ um sublinhado duplo (). Esses
caracteres são reservados pelo tempo de execução.
Host As configurações nesta seção personalizam o processo de

host do Functions quando você executa projetos localmente.
Essas configurações são separadas das configurações de
host. JSON, que também se aplicam quando você executa
projetos no Azure.

configuração.
CORS Define as origens permitidas para CORS (Compartilhamento

de recurso entre origens). As origens são fornecidas como
uma lista separada por vírgulas, sem espaços. Há suporte
para o valor do caractere curinga (*), que permite
solicitações de qualquer origem.
CORSCredentials Quando definido como true , permite withCredentials

solicitações.

conexão usadas por suas associações de função. Essa
coleção é usada somente por estruturas que normalmente
recebem cadeias de conexão da ConnectionStrings seção
de um arquivo de configuração, como Entity Framework. As
cadeias de caracteres de conexão neste objeto são
adicionadas ao ambiente com o tipo de provedor de
System.Data.SqlClient. Os itens nesta coleção não são
publicados no Azure com outras configurações de aplicativo.
Você deve adicionar esses valores explicitamente à
Connection strings coleção de suas configurações do
aplicativo de funções. Se você estiver criando um
SqlConnection no seu código de função, deverá
armazenar o valor da cadeia de conexão com suas outras
conexões nas configurações do aplicativo no Portal.
As configurações em local. Settings. JSON não são carregadas automaticamente quando você publica o
projeto. Para certificar-se de que essas configurações também existam em seu aplicativo de funções no Azure,
você deve carregá-las depois de publicar o projeto. Para saber mais, confira configurações do aplicativo de
funções.
Os valores em ConnectionStrings nunca são publicados.
Os valores de configuração do aplicativo de funções também podem ser lidos em seu código como variáveis de
ambiente. Para obter mais informações, consulte variáveis de ambiente.
Configurar seu projeto para desenvolvimento local

O tempo de execução do Functions usa internamente uma conta de Armazenamento do Azure. Para todos os
tipos de gatilhos diferentes de HTTP e webhooks, você deve definir a chave Values.AzureWebJobsStorage
para uma cadeia de conexão de conta de Armazenamento do Azure válida. O aplicativo de funções também
pode usar o Emulador de Armazenamento do Microsoft Azure para a configuração de conexão
AzureWebJobsStorage exigida pelo projeto. Para usar o emulador, defina o valor de AzureWebJobsStorage
para UseDevelopmentStorage=true . Altere essa configuração para uma cadeia de conexão de conta de
armazenamento real antes da implantação.
Para definir a cadeia de conexão da conta de armazenamento:
1. No Visual Studio, abra o Cloud Explorer, expanda conta > de armazenamentosua conta de
armazenamentoe, na guia Propriedades , copie o valor da cadeia de conexão primária .
2. Em seu projeto, abra o arquivo local.settings.json e defina o valor da chave AzureWebJobsStorage na
cadeia de conexão que você copiou.
3. Repita a etapa anterior para adicionar as chaves exclusivas para a matriz de Valores para todas as outras
conexões necessárias para as suas funções.
Adicionar uma função ao projeto

Em C# funções de biblioteca de classes, as associações usadas pela função são definidas pela aplicação de
atributos no código. Quando você cria seus gatilhos de função a partir dos modelos fornecidos, os atributos de
gatilho são aplicados para você.
1. No Gerenciador de Soluções, clique com o botão direito do mouse no nó do projeto e selecione
Adicionar > Novo Item. Selecione Azure Function, digite um Nome para a classe e clique em
Adicionar.
2. Escolha o gatilho, defina as propriedades de associação e clique em Criar. O exemplo a seguir mostra as
configurações ao criar uma função disparada por armazenamento de filas.
Este exemplo de gatilho usa uma cadeia de conexão com uma chave chamada QueueStorage. Essa
configuração de cadeia de conexão deve ser definida no arquivo local.settings.json.
3. Examine a classe recém-adicionada. Você verá um método estático Run, que é atribuído ao atributo
FunctionName. Esse atributo indica que o método é o ponto de entrada para a função.
Por exemplo, a classe C# a seguir representa uma função básica disparada pelo armazenamento de filas:
using System;
namespace FunctionApp1
{
public static class Function1
{
[FunctionName("QueueTriggerCSharp")]
public static void Run([QueueTrigger("myqueue-items",
Connection = "QueueStorage")]string myQueueItem, ILogger log)
{
}
}
}
Um atributo específico de associação é aplicado a cada parâmetro de associação fornecido ao método do

ponto de entrada. O atributo utiliza as informações de associação como parâmetros. No exemplo
anterior, o primeiro parâmetro tem um atributo QueueTrigger aplicado, que indica a função disparada
por fila. O nome da fila e o nome de configuração da cadeia de conexão são passadas como parâmetros
ao atributo QueueTrigger. Para obter mais informações, veja Associações do armazenamento de Fila do
Azure para o Azure Functions.
Você pode usar o procedimento acima para adicionar mais funções a seu projeto de aplicativo de funções. Cada
função no projeto pode ter um gatilho diferente, mas uma função deve ter apenas um gatilho. Para obter mais
informações, consulte Gatilhos e conceitos de associações do Azure Functions.
Assim como acontece com gatilhos, as associações de entrada e saída são adicionadas à sua função como
atributos de associação. Adicione associações a uma função da seguinte maneira:
1. Verifique se você configurou o projeto para o desenvolvimento local.
2. Adicione o pacote de extensão do NuGet pertinente para a associação. Para saber mais, confira
Desenvolvimento Local em C# usando o Visual Studio no artigo Gatilhos e associações. Os requisitos de
pacote NuGet específicos da associação estão no artigo de referência da associação. Por exemplo,
encontre os requisitos do pacote para o gatilho dos Hubs de Eventos no artigo de referência da
associação dos Hubs de Eventos.
3. Se houver configurações de aplicativo exigidas pela associação, adicione-as à coleção Valores no
arquivo de configuração local. Esses valores são usados quando a função é executada localmente.
Quando a função é executada no aplicativo de funções no Azure, as configurações do aplicativo de
funções são usadas.
4. Adicione o atributo de associação apropriado para a assinatura do método. No exemplo a seguir, uma
mensagem da fila dispara a função e a associação de saída cria uma nova mensagem de fila com o
mesmo texto em uma fila diferente.
public static class SimpleExampleWithOutput

{
[FunctionName("CopyQueueMessage")]
[QueueTrigger("myqueue-items-source", Connection = "AzureWebJobsStorage")] string
myQueueItem,
[Queue("myqueue-items-destination", Connection = "AzureWebJobsStorage")] out string
myQueueItemCopy,
ILogger log)
{
log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
myQueueItemCopy = myQueueItem;
}
}
A conexão com o Armazenamento de filas é obtida na configuração AzureWebJobsStorage . Para saber

mais, confira o artigo de referência da associação específica.
Functions:
de Blobs
eventos
Hubs de Eventos ✔ ✔ ✔ ✔
de HTTP
Excel tabelas
OneDrive
Microsoft Graph
Outlook email
events
Tokens de ✔ ✔
Auth Microsoft
Graph
Móveis
Hubs de ✔ ✔
Notificação
de filas
Serviço
SignalR ✔ ✔ ✔
de tabelas
Timer ✔ ✔ ✔
Twilio ✔ ✔ ✔
Consulte registrar extensões de associação. Todas as associações 2. x com suporte também têm suporte na
versão 3. x, salvo indicação em contrário.
Funções de teste
As Ferramentas Principais do Azure Functions permitem executar o projeto do Azure Functions no seu
computador de desenvolvimento local. Você precisa instalar essas ferramentas na primeira vez em que inicia
uma função no Visual Studio.
Para testar sua função, pressione F5. Se solicitado, aceite a solicitação do Visual Studio para baixar e instalar as
ferramentas principais (CLI) do Azure Functions. Você também precisará habilitar a exceção de firewall de
forma que as ferramentas possam lidar com solicitações HTTP.
Com o projeto em execução, você pode testar seu código da mesma forma que você testaria a função
implantada. Para saber mais informações, consulte Estratégias para testar seu código no Azure Functions.
Quando em execução no modo de depuração, os pontos de interrupção são atingidos no Visual Studio,
conforme o esperado.
Para saber mais sobre o uso das Ferramentas Básicas do Azure Functions, consulte Codificar e testar o Azure
Functions localmente.
Publicar no Azure
Ao publicar do Visual Studio, um dos dois métodos de implantação é usado:
Implantação da Web: empacota e implanta aplicativos do Windows em qualquer servidor IIS.
Implantação de zip com execução do pacote habilitada: recomendado para implantações de Azure functions.
Use as etapas a seguir para publicar seu projeto em um aplicativo de funções no Azure.
Publicar.
2. Na caixa de diálogo Selecione um destino de publicação, use as opções publicar, conforme
especificado na tabela embaixo da imagem:
OPÇÃO DESCRIÇÃO
Plano de consumo do Azure Functions Quando você publica seu projeto em um aplicativo de
funções executado em um Plano de consumo, você paga
apenas pelas execuções do seu aplicativo de funções.
Outros planos de hospedagem incorrem em custos mais
altos. Para saber mais, confira Escala e hospedagem do
Azure Functions.
OPÇÃO DESCRIÇÃO
Criar novo Um novo aplicativo de funções com recursos

relacionados é criado no Azure. Quando você escolhe
selecionar existente, todos os arquivos no aplicativo de
funções existente no Azure são substituídos pelos
arquivos do projeto local. Use essa opção somente
quando republicar atualizações para um aplicativo de
funções existente.
Executar com base no arquivo de pacote Seu aplicativo de funções é implantado usando a
Implantação de Zip com o modo Run-From-Package
habilitado. Essa é a maneira recomendada de executar
suas funções, que resulta em um melhor desempenho.
Quando não estiver usando essa opção, verifique se
você interrompeu a execução local do projeto de
aplicativo de funções antes de publicar no Azure.
3. Selecione Publicar. Se você ainda não entrou em sua conta do Azure do Visual Studio, selecione Entrar.
Também é possível criar uma conta gratuita do Azure.
4. No Serviço de Aplicativo: Criar, use as configurações de Hospedagem conforme especificadas na
tabela embaixo da imagem:
Nome Nome globalmente exclusivo Nome que identifica seu novo

aplicativo de funções de forma
exclusiva. Os caracteres válidos são
a-z , 0-9 e - .
Assinatura Escolha sua assinatura A assinatura do Azure a utilizar.

Grupo de Recursos myResourceGroup Nome do grupo de recursos no qual

criar o seu aplicativo de funções.
Escolha Novo para criar um novo
grupo de recursos.
Plano de hospedagem Plano de consumo Escolha o Consumo em Tamanho

após selecionar Novo para criar um
plano sem servidor. Também,
escolha um Local em uma região
perto de você ou perto de outros
serviços que suas funções acessam.
Quando você executa em um plano
diferente de Consumo, deve
gerenciar o dimensionamento de
Armazenamento do Azure Conta de armazenamento para uso Uma conta de armazenamento do

geral Azure é necessária para o tempo de
execução de funções. Selecione
Novo para criar uma conta de
armazenamento para uso geral.
existente que atenda aos requisitos
5. Selecione Criar para criar um aplicativo de funções e recursos relacionados no Azure com essas
configurações e implantar seu código de projeto de função.
6. Após a conclusão da implantação, anote o valor da URL do Site, que é o endereço do seu aplicativo de
funções no Azure.
Configurações do aplicativo de funções

As configurações que você adicionou no local.settings.json também devem ser adicionadas ao aplicativo de
funções no Azure. Essas configurações não são carregadas automaticamente quando você publica o projeto.
A maneira mais fácil para carregar as configurações necessárias para o seu aplicativo de função no Azure é usar
o link Gerenciar configurações de aplicativo... que é exibido depois que você publica seu projeto com êxito.
Isso exibe a caixa de diálogo Configurações de aplicativo para o aplicativo de função, onde você pode
adicionar novas configurações do aplicativo ou modificar as existentes.
Local representa um valor de configuração no arquivo local.settings.json e Remoto é a configuração atual no

aplicativo de funções no Azure. Escolha Adicionar configuração para criar uma nova configuração de
aplicativo. Use o link Inserir valor do local para copiar um valor de configuração para o campo Remoto. As
alterações pendentes serão gravadas no arquivo de configurações local e no aplicativo de funções quando você
selecionar OK.
NOTE
Por padrão, o arquivo local. Settings. JSON não é verificado no controle do código-fonte. Isso significa que, quando você
clona um projeto de funções locais do controle do código-fonte, o projeto não tem um arquivo local. Settings. JSON.
Nesse caso, você precisa criar manualmente o arquivo local. Settings. JSON na raiz do projeto para que a caixa de diálogo
configurações do aplicativo funcione conforme o esperado.
Você também pode gerenciar as configurações de aplicativo em um desses outros modos:

Usando o Portal do Azure.
Usando a opção de publicação --publish-local-settings nas ferramentas básicas do Azure Functions.
A maneira recomendada de monitorar a execução de suas funções é a integração do aplicativo de funções com
o Azure Application Insights. Ao criar um aplicativo de funções no portal do Azure, essa integração é realizada
por padrão. No entanto, ao criar o aplicativo de funções durante a publicação do Visual Studio, a integração no
aplicativo de funções no Azure não é realizada.
Para habilitar o Application Insights no aplicativo de funções:
As funções facilitam a adição da integração do Application Insights a um aplicativo de funções do portal do
Azure.
1. No portal, selecione Todos os serviços > Aplicativos de Funções, selecione o aplicativo de funções e,
em seguida, selecione a faixa do Application Insights na parte superior da janela
2. Crie um recurso do Application Insights usando as configurações especificadas na tabela abaixo da

imagem.
Nome Nome de aplicativo exclusivo É mais fácil usar o mesmo nome que
seu aplicativo de funções, que deve
ser exclusivo em sua assinatura.
Localidade Europa Ocidental Se possível, use a mesma região que

seu aplicativo de funções ou uma
região próxima dela.
3. Selecione OK. O recurso do Application Insights é criado no mesmo grupo de recursos e assinatura que
seu aplicativo de funções. Depois que o recurso for criado, feche a janela do Application Insights.
4. No aplicativo de funções, selecione Configurações do aplicativo e role para baixo até Configurações
do aplicativo. Se você vir uma configuração chamada APPINSIGHTS_INSTRUMENTATIONKEY , isso significa
que a integração do Application Insights está habilitada para seu aplicativo de funções em execução no
Azure.
Para saber mais, consulte Monitorar Azure Functions.
Próximas etapas
Para saber mais sobre as Ferramentas Básicas do Azure Functions, consulte Codificar e testar o Azure
Functions localmente.
Para saber mais sobre como desenvolver funções como bibliotecas de classes do .NET, consulte Referência do
desenvolvedor de C# do Azure Functions. Este tópico também fornece links para exemplos de como usar
atributos para declarar os vários tipos de associações com suporte pelo Azure Functions.
Trabalhar com o Azure Functions Core Tools
Azure Functions Core Tools permite desenvolver e testar as funções em seu computador local a partir
do prompt de comando ou terminal. Suas funções locais podem se conectar a serviços do Azure em
tempo real e você pode depurar as suas funções em seu computador local usando o tempo de execução
total do Functions. Você ainda pode implantar um aplicativo de funções para sua assinatura do Azure.
IMPORTANT
Não combine o desenvolvimento local com o desenvolvimento do portal no mesmo aplicativo de funções. Ao
criar e publicar funções de um projeto local, não tente manter ou modificar o código do projeto no portal.
Desenvolver funções em seu computador local e publicá-las no Azure usando ferramentas básicas
segue estas etapas básicas:
Instale as principais ferramentas e dependências.
Crie um projeto de aplicativo de funções de um modelo específico de idioma.
Registrar extensões de gatilho e de associação.
Defina o armazenamento e outras conexões.
Crie uma função de um gatilho e de um modelo específico ao idioma.
Versões de Core Tools

Há duas versões do Azure Functions Core Tools. A versão que você usa depende do ambiente de
desenvolvimento local, da escolha da linguagem e do nível de suporte necessário:
Versão 1.x: oferece suporte à versão 1.x do tempo de execução. Esta versão das ferramentas só
tem suporte em computadores Windows e é instalada por meio de um pacote npm. Com esta
versão, você pode criar funções em linguagens experimentais que não são suportadas
oficialmente. Para obter mais informações, consulte línguas suportadas no Azure Functions
Versão 2.x: oferece suporte à versão 2.x do tempo de execução. Esta versão oferece suporte a
Windows, macOS, e Linux. Usa gerenciadores de pacotes específicos da plataforma ou npm para
instalação.
A menos que indicado o contrário, os exemplos neste artigo são para a versão 2.x.
Instalação das ferramentas básicas do Azure Functions

O Ferramentas básicas do Azure Functions é uma versão local do tempo de execução do Azure
Functions que pode ser executada no computador local de desenvolvimento. Ele também fornece
comandos para criar funções, se conectar ao Azure e implantar projetos de função.
Versão 2.x
A versão 2.x das ferramentas usa o tempo de execução 2.x do Azure Functions que se baseia em .NET
Core. Esta versão tem suporte em todas as plataformas que o .NET Core 2.x oferece suporte, incluindo
Windows, macOS, e Linux.
IMPORTANT
Você pode ignorar o requisito de instalação do SDK do .NET Core 2. x usando extensão.
Windows
As etapas a seguir usam npm para instalar ferramentas principais no Windows. Você também pode usar
Chocolatey. Para obter mais informações, confira o arquivo Leiame das Ferramentas Principais.
1. Instale o Node.js, que inclui npm. Para a versão 2.x das ferramentas, somente Node.js 8.5 e
versões posteriores têm suporte.
2. Instale o pacote de ferramentas principais:
npm install -g azure-functions-core-tools
Pode levar alguns minutos para que o NPM Baixe e instale o pacote de ferramentas principais.
3. Se você não planeja usar pacotes de extensão, instale o SDK do .NET Core 2. x para Windows.
MacOS com o Homebrew
As etapas a seguir usam o Homebrew para instalar as ferramentas principais em macOS.
1. Instale o Homebrew, se ele ainda não estiver instalado.
brew tap azure/functions

brew install azure-functions-core-tools
3. Se você não planeja usar pacotes de extensão, instale o SDK do .NET Core 2. x para MacOS.
Linux (Ubuntu/Debian ) com APT
As etapas a seguir usma APT para instalar as ferramentas principais em sua distribuição
Ubuntu/Debian Linux. Para outras distribuições do Linux, confira o arquivo Leiame das ferramentas
principais.
1. Instale a chave GPG do repositório de pacotes da Microsoft para validar a integridade do pacote:
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg

sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
2. Configure a lista de origem de desenvolvimento do .NET antes de fazer uma atualização de APT.
Para configurar a lista de origem APT para o Ubuntu, execute este comando:
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-

$(lsb_release -cs)-prod $(lsb_release -cs) main" > /etc/apt/sources.list.d/dotnetdev.list'
Para configurar a lista de origem APT para Debian, execute este comando:
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/debian/$(lsb_release -

rs)/prod $(lsb_release -cs) main" > /etc/apt/sources.list.d/dotnetdev.list'
3. Verifique o arquivo de /etc/apt/sources.list.d/dotnetdev.list para uma das cadeias de

caracteres de versão do Linux apropriadas listadas abaixo:
DISTRIBUIÇÃO LINUX VERSÃO
Debian 10 buster
Debian 9 stretch
Debian 8 jessie
Ubuntu 18,10 cosmic
Ubuntu 18.04 bionic
Ubuntu 17.04 zesty
Ubuntu 16.04/Linux Mint 18 xenial
4. Inicie a atualização da fonte APT:
sudo apt-get update
sudo apt-get install azure-functions-core-tools
6. Se você não planeja usar pacotes de extensão, instale o SDK do .NET Core 2. x para Linux.
Criar um projeto de funções local

Um diretório de projeto de funções contém os arquivos host. JSON e local.settings.json, ao longo de
subpastas que contêm o código para funções individuais. Esse diretório é o equivalente ao de um
aplicativo de funções no Azure. Para saber mais sobre a estrutura de pastas do Functions, consulte o
guia de desenvolvedores do Azure Functions.
Versão 2.x exige que você selecione um idioma padrão para seu projeto quando ele é inicializado, e
todas as funções adicionadas usam modelos de idioma padrão. Na versão 1.x, você especifica a
linguagem cada vez que você criar uma função.
Na janela do terminal ou em um prompt de comando, execute o seguinte comando para criar o projeto
e o repositório Git local:
Quando você fornece um nome de projeto, uma nova pasta com esse nome é criada e inicializada. Caso
contrário, a pasta atual é inicializada.
Na versão 2.x, quando você executar o comando você deve escolher um tempo de execução para o seu
projeto.
Select a worker runtime:
dotnet
node
python
powershell
Use cima/para baixo de teclas de direção para escolher um idioma, em seguida, pressione Enter. Se você
planeja desenvolver funções JavaScript ou TypeScript, escolha nóe, em seguida, selecione o idioma. O
TypeScript tem alguns requisitos adicionais.
A saída se parece com o seguinte exemplo para um projeto JavaScript:
Select a worker runtime: node

Writing .gitignore
Writing host.json
Writing local.settings.json
Writing C:\myfunctions\myMyFunctionProj\.vscode\extensions.json
Initialized empty Git repository in C:/myfunctions/myMyFunctionProj/.git/
func init dá suporte às seguintes opções, que são somente da versão 2.x, a menos que haja outro tipo
de orientação:
OPÇÃO DESCRIÇÃO
--csx Inicializa um projeto de script (.csx) C#. Você precisam

especificar --csx nos próximos comandos.
--docker Crie um Dockerfile para um contêiner usando uma

imagem base que se baseia no --worker-runtime
escolhido. Use esta opção quando planejar publicar em
um contêiner do Linux personalizado.
--force Inicializa o projeto mesmo quando há arquivos

existentes no projeto. Essa configuração substitui os
arquivos existentes pelo mesmo nome. Os outros
arquivos na pasta do projeto não serão afetados.
--no-source-control -n Impede a criação padrão de um repositório Git na

versão 1.x. Na versão 2.x, o repositório git não será
criado por padrão.
--source-control Controla se um repositório git é criado. Por padrão, não

é criado um repositório. Quando true , um repositório
é criado.
--worker-runtime Define o tempo de execução de linguagem para o

projeto. Os valores com suporte são dotnet , node
(JavaScript) java e python . Quando não estiver
definido, será solicitado que você escolha seu tempo de
execução durante a inicialização.
IMPORTANT
Por padrão, a versão 2.x das ferramentas do Core cria a função de projetos de aplicativo para o tempo de
execução do .NET como projetos de classes C# (. csproj). Esses projetos C#, que podem ser usados com o Visual
Studio ou com Visual Studio Code, são compilados durante o teste e ao publicar no Azure. Se você deseja criar e
trabalhar com o os mesmos arquivos de script C# (. CSx) criados na versão 1. x e no portal, você deve incluir o
--csx parâmetro ao criar e implantar funções.
Extensões de registro
Com exceção dos gatilhos HTTP e o timer, associações de funções na versão de tempo de execução 2.x
são implementados como pacotes de extensão. Na versão 2.x do tempo de execução do Azure
Functions, você deve registrar explicitamente as extensões para os tipos de associação usados em suas
funções. As exceções a isso são as associações HTTP e gatilhos de temporizador, que não exigem
extensões.
Você pode optar por instalar as extensões de associação individualmente, ou você pode adicionar uma
referência de pacote de extensão para o arquivo de projeto do host. JSON. Pacotes de extensão remove
a possibilidade de ter problemas de compatibilidade de pacote ao usar vários tipos de associação. É a
abordagem recomendada para registrar as extensões de associação. Pacotes de extensão também
elimina a necessidade de instalar o .NET Core 2.x do SDK.
pacotes de extensão
A maneira mais fácil de instalar as extensões de associação é habilitar pacotes de extensão. Quando
você habilita os pacotes, um conjunto predefinido de pacotes de extensão é instalado automaticamente.
Para habilitar pacotes de extensão, abra o arquivo host.json e atualize seu conteúdo de acordo com o
código a seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}
Para obter mais informações, consulte as extensões de associação de funções do Azure registrar. Você
deve adicionar pacotes de extensão para o host. JSON antes de adicionar associações para o arquivo do
Functions.
Registrar extensões individuais
Se você precisar instalar extensões que não estão em um pacote, você poderá registrar manualmente os
pacotes de extensão individuais para associações específicas.
NOTE
Para registrar manualmente extensões usando func extensions install , você deve ter o .NET Core 2.x SDK
instalado.
Depois de atualizar o arquivo function.json para incluir todas as associações que a função precisa,
execute o comando a seguir na pasta do projeto.
O comando lê o arquivo function.json para saber quais são os pacotes necessários, instala-os e recria o
projeto de extensão. Ele adiciona as novas associações na versão atual, mas não atualiza as associações
existentes. Use a opção --force para atualizar as associações existentes para a versão mais recente nas
novas instalações.

O arquivo local. Settings. JSON armazena as configurações do aplicativo, cadeias de conexão e
configurações usadas pelas ferramentas de desenvolvimento local. As configurações no arquivo local.
Settings. JSON são usadas somente quando você está executando projetos localmente. O arquivo de
configurações local tem esta estrutura:
{
"Values": {
},
"Host": {
"CORS": "*",
},
}
}
IsEncrypted Quando essa configuração é definida como true ,

todos os valores são criptografados com uma chave do
computador local. Usado com func settings
comandos. O valor padrão é false .
Values Matriz de configurações de aplicativo e cadeias de

conexão usadas quando um projeto é executado
localmente. Esses pares de chave-valor (cadeia de
caracteres de cadeia de caracteres) correspondem às
configurações do aplicativo em seu
AzureWebJobsStorage aplicativo de funções no Azure,
como. Muitos gatilhos e associações têm uma
propriedade que se refere a uma configuração de
aplicativo de cadeia Connection de conexão, como
para o gatilho do armazenamentode BLOBs. Para essas
propriedades, você precisa de uma configuração de
aplicativo definida Values na matriz.
A versão 2. x do tempo de execução do Functions
requer a configuração [ FUNCTIONS_WORKER_RUNTIME ],
que é gerada para seu projeto por ferramentas
principais.
Quando você tiver o emulador de armazenamento do
Azure instalado localmente AzureWebJobsStorage e
UseDevelopmentStorage=true definido como, as
ferramentas principais usarão o emulador. O emulador é
útil durante o desenvolvimento, mas você deve testar
com uma conexão de armazenamento real antes da
implantação.
Os valores devem ser cadeias de caracteres e não
objetos JSON ou matrizes. Os nomes de configuração
não podem incluir : dois-pontos () ou __ um
sublinhado duplo (). Esses caracteres são reservados
pelo tempo de execução.
Host As configurações nesta seção personalizam o processo

de host do Functions quando você executa projetos
localmente. Essas configurações são separadas das
configurações de host. JSON, que também se aplicam
quando você executa projetos no Azure.

configuração.
CORS Define as origens permitidas para CORS

(Compartilhamento de recurso entre origens). As
origens são fornecidas como uma lista separada por
vírgulas, sem espaços. Há suporte para o valor do
caractere curinga (*), que permite solicitações de
qualquer origem.
CORSCredentials Quando definido como true , permite

withCredentials solicitações.

conexão usadas por suas associações de função. Essa
coleção é usada somente por estruturas que
normalmente recebem cadeias de conexão da
ConnectionStrings seção de um arquivo de
configuração, como Entity Framework. As cadeias de
caracteres de conexão neste objeto são adicionadas ao
ambiente com o tipo de provedor de
System.Data.SqlClient. Os itens nesta coleção não são
publicados no Azure com outras configurações de
aplicativo. Você deve adicionar esses valores
explicitamente à Connection strings coleção de suas
configurações do aplicativo de funções. Se você estiver
criando um SqlConnection no seu código de função,
deverá armazenar o valor da cadeia de conexão com
suas outras conexões nas configurações do aplicativo
no Portal.
Por padrão, essas configurações não são migradas automaticamente quando o projeto é publicado no
Azure. Use a opção --publish-local-settings quando publicar para se certificar de que essas
configurações serão adicionadas ao aplicativo de funções no Azure. Observe que os valores em
ConnectionStrings nunca são publicados.
Os valores de configuração do aplicativo de funções também podem ser lidos em seu código como
variáveis de ambiente. Para obter mais informações, confira a seção de variáveis de Ambiente desses
tópicos de referência específicos de linguagem:
C# pré-compilado
Script do C# (. CSx)
Java
JavaScript
Quando nenhuma cadeia de conexão de armazenamento válida é definida para AzureWebJobsStorage eo
emulador não está sendo usado, a seguinte mensagem de erro é mostrada:
Valor ausente para AzureWebJobsStorage em local.settings.json. Isso é necessário para todos os

gatilhos diferentes de HTTP. É possível executar o func azure functionapp fetch-app-settings
<functionAppName>' ou especificar uma cadeia de conexão em local.settings.json.
Obter suas cadeias de conexão de armazenamento

Mesmo usando o emulador de armazenamento para desenvolvimento, convém testar com uma
conexão de armazenamento real. Supondo que você já tenha criado uma conta de armazenamento, será
possível obter uma cadeia de conexão de armazenamento válida de uma destas maneiras:
No portal do Azure, procure e selecione contas de armazenamento.
Selecione sua conta de armazenamento, selecione chaves de acesso em configuraçõese, em
seguida, copie um dos valores da cadeia de conexão .
Use o Gerenciador de Armazenamento do Azure para conectar-se à sua conta do Azure. No

Gerenciador, expanda sua assinatura, selecione sua conta de armazenamento e copie a cadeia
de conexão primária ou secundária.
Use as Ferramentas Básicas para baixar a cadeia de conexão do Azure com um dos seguintes
comandos:
Baixe todas as configurações de um aplicativo de funções existente:
func azure functionapp fetch-app-settings <FunctionAppName>
Obtenha a cadeia de conexão para uma conta de armazenamento específica:
func azure storage fetch-connection-string <StorageAccountName>
Enquanto ainda não tiver se conectado ao Azure, será solicitado que você faça isso.
Criar uma função

Para criar uma função, execute o seguinte comando:
func new
Na versão 2.x, quando você executa func new você é solicitado a escolher um modelo no idioma padrão
do seu aplicativo de funções, em seguida, você também precisará escolher um nome para sua função.
Na versão 1.x, você também precisará escolher o idioma.
Select a language: Select a template:
Blob trigger
Cosmos DB trigger
Event Grid trigger
HTTP trigger
Queue trigger
SendGrid
Service Bus Queue trigger
Service Bus Topic trigger
Timer trigger
Código de função é gerado em uma subpasta com o nome da função fornecido, como você pode ver na
seguinte saída do gatilho de fila:
Select a language: Select a template: Queue trigger

Function name: [QueueTriggerJS] MyQueueTrigger
Writing C:\myfunctions\myMyFunctionProj\MyQueueTrigger\index.js
Writing C:\myfunctions\myMyFunctionProj\MyQueueTrigger\readme.md
Writing C:\myfunctions\myMyFunctionProj\MyQueueTrigger\sample.dat
Writing C:\myfunctions\myMyFunctionProj\MyQueueTrigger\function.json
Você também pode especificar essas opções no comando usando os seguintes argumentos:
ARGUMENTO DESCRIÇÃO
--csx (Versão 2. x) Gera os mesmos modelos C# (. CSx) de

script usados na versão 1. x e no portal.
--language -l A linguagem de programação modelo, como C#, F# ou

JavaScript. Essa opção é necessária na versão 1.x. Na
versão 2.x, não use essa opção nem escolha uma
linguagem que corresponda ao tempo de execução do
trabalho.
--name -n O nome da função.
--template -t Use o func templates list comando para ver a lista

completa de modelos disponíveis para cada idioma com
suporte.
Por exemplo, para criar um gatilho de HTTP de JavaScript em um único comando, execute:
func new --template "Http Trigger" --name MyHttpTrigger
Para criar uma função ativada por fila em um único comando, execute:
func new --template "Queue Trigger" --name QueueTriggerJS
Executar funções localmente

Para executar um projeto de funções, execute o host de funções. O host habilita gatilhos para todas as
funções no projeto.
Versão 2.x
Na versão 2. x do tempo de execução, o comando Start varia, dependendo da linguagem do seu projeto.
C#
func start --build
JavaScript
func start
TypeScript
npm install
npm start
Versão 1.x
A versão 1. x do tempo de execução do Functions requer o comando host , como no exemplo a seguir:
func host start
func start dá suporte para as seguintes opções:
OPÇÃO DESCRIÇÃO
--no-build Não compile o projeto atual antes da execução.

Somente para projetos dotnet. O padrão é definido
como false. Versão 2.x somente.
--cert O caminho para um arquivo .pfx que contém uma chave

privada. Usado somente com --useHttps . Versão 2.x
somente.
--cors-credentials Permita solicitações autenticadas de origem cruzada (ou

seja, cookies e cabeçalho de autenticação) somente na
versão 2.x.
--cors Uma lista separada por vírgulas de origens CORS, sem

espaços.
--language-worker Argumentos para configurar o trabalhador de idioma.

Versão 2.x somente.
--nodeDebugPort -n A porta para usar o depurador de nós. Padrão: um valor

de launch.json ou 5858. Versão 1.x somente.
--password A senha ou um arquivo que contém a senha para um

arquivo .pfx. Usado somente com --cert . Versão 2.x
somente.
--port -p A porta local na qual escutar. Valor Padrão: 7071.
--pause-on-error Pausar para entrada adicional antes de encerrar o

processo. Usado apenas ao iniciar as Core Tools de um
IDE (ambiente de desenvolvimento integrado).
OPÇÃO DESCRIÇÃO
--script-root --prefix Usado para especificar o caminho para a raiz do

aplicativo de funções que deve ser executado ou
implantado. Usado para projetos compilados que geram
arquivos de projeto para uma subpasta. Por exemplo,
quando você cria um projeto de biblioteca de classes C#,
os arquivos host.json, local.settings.json e function.json
são gerados em uma subpasta raiz com um caminho
como MyProject/bin/Debug/netstandard2.0 . Nesse
caso, defina o prefixo como
--script-root
MyProject/bin/Debug/netstandard2.0
. Essa é a raiz do aplicativo de funções durante a
execução no Azure.
--timeout -t O tempo limite para o host de funções ser iniciado, em

segundos. Padrão: 20 segundos.
--useHttps Associar a https://localhost:{port} em vez de

http://localhost:{port} . Por padrão, essa opção
cria um certificado confiável no computador.
Quando o host de funções é iniciado, ele gera as funções acionadas por URL de HTTP:
Found the following functions:

Host.Functions.MyHttpTrigger
Job host started

Http Function MyHttpTrigger: http://localhost:7071/api/MyHttpTrigger
IMPORTANT
Ao executar localmente, a autenticação não é imposta para pontos de extremidade HTTP. Isso significa que todas
as solicitações HTTP locais são tratadas como authLevel = "anonymous" . Para obter mais informações, confira
o artigo de associação HTTP.
Transferência dos dados de teste para uma função

Para testar as funções localmente, inicie o host do Functions e chame os pontos de extremidade no
servidor local usando solicitações HTTP. O ponto de extremidade que você chama depende do tipo de
função.
NOTE
Os exemplos neste tópico usam a ferramenta cURL para enviar solicitações HTTP do terminal ou de um prompt
de comando. Você pode usar uma ferramenta de sua escolha para enviar solicitações HTTP para o servidor local.
A ferramenta de rotação está disponível por padrão em sistemas baseados em Linux e no Windows 10 Build
17063 e posterior. No Windows mais antigo, você deve primeiro baixar e instalar a ferramenta de rotação.
Para ter informações mais gerais sobre o teste de funções, confira Estratégias para testar seu código no
Azure Functions.
Funções disparadas por HTTP e webhook
Chame o seguinte ponto de extremidade para executar localmente funções disparadas por HTTP e
webhook:
http://localhost:{port}/api/{function_name}
Use o mesmo nome de servidor e porta no qual o host do Functions está escutando. Veja isso na saída
gerada ao iniciar o host do Function. Chame essa URL usando qualquer método HTTP com suporte do
disparador.
O seguinte comando cURL dispara a função de início rápido MyHttpTrigger de uma solicitação GET
com o parâmetro name transmitido na cadeia de consulta.
curl --get http://localhost:7071/api/MyHttpTrigger?name=Azure%20Rocks
O exemplo a seguir é a mesma função chamada a partir de uma solicitação POST passando name no
corpo da solicitação:
curl --request POST http://localhost:7071/api/MyHttpTrigger --data '{"name":"Azure Rocks"}'
Você pode fazer solicitações GET de um navegador passando dados na cadeia de consulta. Para todos
os outros métodos HTTP, você deve usar cURL, Fiddler, Postman ou uma ferramenta de teste HTTP
semelhante.
Funções disparadas por algo diferente de HTTP
Para todos os tipos de funções que não sejam gatilhos HTTP e webhooks, você pode testar suas funções
localmente chamando um ponto de extremidade de administração. Chamar esse ponto de extremidade
com uma solicitação HTTP POST no servidor local dispara a função. Como alternativa, é possível passar
dados de teste para a execução no corpo da solicitação POST. Essa funcionalidade é semelhante á guia
Teste no Portal do Azure.
Chame o seguinte ponto de extremidade de administrador para disparar funções que não são HTTP:
http://localhost:{port}/admin/functions/{function_name}
Para passar dados de teste para o ponto de extremidade administrador de uma função, é necessário
fornecer os dados no corpo de uma mensagem de solicitação POST. O corpo da mensagem deve ter o
seguinte formato JSON:
{
"input": "<trigger_input>"
}
O valor <trigger_input> contém dados em um formato esperado pela função. O exemplo de cURL a
seguir é um POST para uma função QueueTriggerJS . Nesse caso, a entrada é uma cadeia de caracteres
equivalente à mensagem esperada na fila.
curl --request POST -H "Content-Type:application/json" --data '{"input":"sample queue data"}'

http://localhost:7071/admin/functions/QueueTriggerJS
Usar o comando func run na versão 1.x

IMPORTANT
O comando func run não tem suporte na versão 2.x das ferramentas. Para saber mais, consulte o tópico
Como direcionar para versões de tempo de execução do Azure Functions.
Você também pode invocar uma função diretamente usando func run <FunctionName> e fornecer dados
de entrada para a função. Esse comando é semelhante à execução de uma função usando a guia Testar
no Portal do Azure.
func run dá suporte para as seguintes opções:
OPÇÃO DESCRIÇÃO
--content -c Conteúdo embutido.
--debug -d Anexe um depurador ao processo de host antes de

executar a função.
--timeout -t Tempo de espera (em segundos) até que o host local de

funções esteja pronto.
--file -f O nome do arquivo a ser usado como conteúdo.
--no-interactive Não solicitará a entrada. Útil para cenários de

automação.
Por exemplo, para chamar uma função ativada por HTTP e passar o corpo do conteúdo, execute o
seguinte comando:
func run MyHttpTrigger -c '{\"name\": \"Azure\"}'
Publicar no Azure
O Azure Functions Core Tools dá suporte a dois tipos de implantação: Implantando arquivos de projeto
de função diretamente em seu aplicativo de funções por meio da implantação de zip e implantando um
contêiner do Docker personalizado. Você já deve ter criado um aplicativo de funções em sua assinatura
do Azure, no qual você implantará seu código. Os projetos que exigem build devem ser compilados
para que os binários possam ser implantados.
Uma pasta de projeto pode conter arquivos e diretórios específicos do idioma que não devem ser
publicados. Itens excluídos são listados em um arquivo. funcignore na pasta raiz do projeto.
Implantação (arquivos de projeto )
Para publicar seu código local em um aplicativo de funções no Azure, use o comando publish :
func azure functionapp publish <FunctionAppName>
Esse comando publica a um aplicativo de funções existente no Azure. Você receberá um erro se tentar
publicar em um <FunctionAppName> que não existe em sua assinatura. Para saber como criar um
aplicativo de funções pelo prompt de comando ou pela janela do terminal usando a CLI do Azure,
consulte Criar um aplicativo de funções para execução sem servidor. Por padrão, esse comando usa a
compilação remota e implanta seu aplicativo para ser executado a partir do pacote de implantação. Para
desabilitar esse modo de implantação recomendado, use a opção --nozip .
IMPORTANT
Quando você cria um aplicativo de funções no portal do Azure, ele usa a versão 2.x do tempo de execução do
Core Tools por padrão. Para que o aplicativo de funções use a versão 1.x do tempo de execução, siga as
instruções em Executar na versão 1.x. Você não pode alterar a versão do tempo de execução de um aplicativo de
funções que tenha funções existentes.
As opções de publicação a seguir se aplicam a ambas as versões, 1. x e 2. x:
OPÇÃO DESCRIÇÃO
--publish-local-settings -i Configurações de publicação em local.settings.json do

Azure, a solicitação para substituir se a configuração já
existe. Se você estiver usando o emulador de
armazenamento, primeiro altere a configuração do
aplicativo para uma conexão de armazenamento real.
--overwrite-settings -y Suprima o prompt para substituir as configurações do

aplicativo quando --publish-local-settings -i for
usado.
Somente há suporte para as seguintes opções de publicação na versão 2.x:
OPÇÃO DESCRIÇÃO
--publish-settings-only -o Somente publicar as configurações e ignorar o

conteúdo. O padrão é solicitado.
--list-ignored-files Exibe uma lista de arquivos que são ignorados durante a

publicação, que é baseada no arquivo .funcignore.
--list-included-files Exibe uma lista de arquivos que são publicados, que é

baseada no arquivo .funcignore.
--nozip Transforma o padrão de Run-From-Package modo

desativado.
--build-native-deps Ignora a geração da pasta .wheels durante a publicação

de python de aplicativos de funções.
--build [-b] Executa a ação de compilação ao implantar em um

aplicativo de funções do Linux. (aceita: remoto, local)
--additional-packages Lista de pacotes para instalar ao compilar dependências

nativas. Por exemplo: python3-dev libevent-dev .
--force Ignorar a verificação de pré-publicação em

determinados cenários.
--csx Publicar um projeto de script (.csx) C#.
--no-build Ignorar a criação de funções do dotnet.

OPÇÃO DESCRIÇÃO
--dotnet-cli-params Durante a publicação de funções C# (.csproj), o Core

Tools chama 'dotnet build --output bin/publish'. Todos
os parâmetros passados para isso serão acrescentados à
linha de comando.
Implantação (contêiner personalizado )

Azure Functions permite que você implante seu projeto de função em um contêiner do Docker
personalizado. Para obter mais informações, confira Criar uma função no Linux usando uma imagem
personalizada. Os contêineres personalizados precisam ter um Dockerfile. Para criar um aplicativo com
um Dockerfile, use a opção--Dockerfile em func init .
func deploy
As seguintes opções de implantação de contêiner personalizado estão disponíveis:
OPÇÃO DESCRIÇÃO
--registry O nome de um Registro do Docker ao qual o usuário

atual está conectado.
--platform A plataforma de hospedagem do aplicativo de funções.

As opções válidas são kubernetes
--name Nome do aplicativo de funções.
--max Opcionalmente, define o número máximo de instâncias

do aplicativo de funções a serem implantadas.
--min Opcionalmente, define o número mínimo de instâncias

do aplicativo de funções a serem implantadas.
--config Define um arquivo de configuração de implantação

opcional.
A maneira recomendada para monitorar a execução de suas funções é integrar-se com o Aplicativo
Azure insights. Você também pode transmitir logs de execução para o computador local. Para saber
mais, consulte Monitorar Azure Functions.
Quando você cria um aplicativo de funções no portal do Azure, a integração Application Insights é feita
para você por padrão. No entanto, quando você cria seu aplicativo de funções usando a CLI do Azure,
não é feita a integração em seu aplicativo de funções no Azure.
As funções facilitam a adição da integração do Application Insights a um aplicativo de funções do portal
do Azure.
1. No portal, selecione Todos os serviços > Aplicativos de Funções, selecione o aplicativo de
funções e, em seguida, selecione a faixa do Application Insights na parte superior da janela
2. Crie um recurso do Application Insights usando as configurações especificadas na tabela abaixo
da imagem.
Nome Nome de aplicativo exclusivo É mais fácil usar o mesmo nome

que seu aplicativo de funções,
que deve ser exclusivo em sua
assinatura.
Localidade Europa Ocidental Se possível, use a mesma região

que seu aplicativo de funções ou
uma região próxima dela.
3. Selecione OK. O recurso do Application Insights é criado no mesmo grupo de recursos e

assinatura que seu aplicativo de funções. Depois que o recurso for criado, feche a janela do
Application Insights.
4. No aplicativo de funções, selecione Configurações do aplicativo e role para baixo até
Configurações do aplicativo. Se você vir uma configuração chamada
APPINSIGHTS_INSTRUMENTATIONKEY , isso significa que a integração do Application Insights está
habilitada para seu aplicativo de funções em execução no Azure.
Habilitar logs de streaming
Você pode exibir um fluxo de arquivos de log que estão sendo gerados por suas funções em uma sessão
de linha de comando em seu computador local.
Logs de streaming nativos
Streaming de log interno
Use a logstream opção para começar a receber logs de streaming de um aplicativo de funções
específico em execução no Azure, como no exemplo a seguir:
func azure functionapp logstream <FunctionAppName>
Live Metrics Stream

Você também pode exibir o Live Metrics Stream para seu aplicativo de funções em uma nova janela do
navegador, --browser incluindo a opção, como no exemplo a seguir:
func azure functionapp logstream <FunctionAppName> --browser
Esse tipo de logs de streaming requer que você habilite a integração de Application insights para seu
Próximas etapas
As principais ferramentas do Azure Functions são Código-fonte aberto e hospedado no GitHub.
Para arquivar uma solicitação de bug ou recurso, abra um problema do GitHub.
Criar sua primeira função no portal do
Azure
O Azure Functions lhe permite executar seu código em um ambiente sem servidor sem que seja
preciso primeiro criar uma VM ou publicar um aplicativo Web. Neste artigo, aprenda a usar o
Functions para criar a função "Olá, Mundo" no portal do Azure.
NOTE
Os desenvolvedores de C# devem considerar criar sua primeira função no Visual Studio 2019 em vez de
usar o portal.
Fazer logon no Azure

Entre no portal do Azure em https://portal.azure.com com sua conta do Azure.

Você deve ter um aplicativo de funções para hospedar a execução de suas funções. Um aplicativo
de funções permite a você agrupar funções como uma unidade lógica para facilitar o
gerenciamento, implantação e compartilhamento de recursos.

aplicativo de funções será
criado.
Grupo de Recursos myResourceGroup Nome do novo grupo de

recursos no qual criar o seu
Nome do aplicativo de Nome globalmente exclusivo Nome que identifica seu novo
funções aplicativo de funções. Os
caracteres válidos são a-z
(não diferencia maiúsculas de
minúsculas), 0-9 e - .
Publicar Código Opção para publicar arquivos

de código ou um contêiner do
Docker.
Pilha de runtime Linguagem preferencial Escolha um runtime

compatível com sua linguagem
de programação de funções
favorita. Escolha .NET para
funções C# e F#.
Região Região preferencial Escolha uma região perto de

você ou perto de outros
serviços que suas funções
acessam.

Conta de armazenamento Nome globalmente exclusivo Crie uma conta de

armazenamento usada pelo
seu aplicativo de funções. Os
nomes da conta de
armazenamento devem ter
entre 3 e 24 caracteres e
podem conter apenas
números e letras minúsculas.
Use também uma conta
existente, que precisará
atender aos requisitos da
Sistema operacional Sistema operacional Um sistema operacional é pré-

preferencial selecionado para você com
base na seleção da pilha de
runtime, mas você pode alterar
a configuração, se necessário.
Plano Plano de consumo Plano de hospedagem que

define como os recursos são
alocados para seu aplicativo de
funções. No Plano de
Consumo padrão, os recursos
são adicionados
dinamicamente conforme
exigido por suas funções.
Nesta hospedagem sem
servidor, você só paga pelo
tempo durante o qual suas
funções são executadas.
Quando você executa em um
Plano do Serviço de Aplicativo,
deve gerenciar o
dimensionamento do


aplicativo na região com
suporte mais próxima. Ao
expandir essa configuração,
você pode alterar o Novo
nome do recurso ou escolher
geografia do Azure onde
deseja armazenar seus dados.

7. Selecione o ícone da Notificação no canto superior direito do portal e veja se a mensagem
Implantação concluída com êxito é exibida.
8. Selecione Ir para recursos para exibir o novo aplicativo de funções. Você também pode
selecionar Fixar no painel. A fixação torna mais fácil retornar a esse recurso de aplicativo
de função no seu painel.
Em seguida, crie uma nova função no novo aplicativo de funções.
Criar uma função disparada por HTTP

1. Expanda seu novo aplicativo de funções e selecione o botão + ao lado de Functions,
escolha No portal e selecione Continuar.
2. Escolha WebHook + API e, em seguida, selecione Criar.

Uma função é criada usando um modelo específico a um idioma para uma função disparada por
HTTP.
Agora você pode executar a nova função enviando uma solicitação HTTP.
Testar a função
1. Em sua nova função, clique em </> Obter URL da função na parte superior direita,
selecione padrão (Tecla de função) e depois clique em Copiar.
2. Cole a URL de função na barra de endereços do navegador. Adicione o valor da cadeia de

caracteres de consulta &name=<yourname> ao final desta URL e pressione Enter em seu
teclado para executar a solicitação. Você deverá ver a resposta retornada pela função
exibida no navegador.
A URL da solicitação inclui uma chave que é necessária, por padrão, para acessar sua
função via HTTP.
3. Quando a função é executada, informações de rastreamento são gravadas nos logs. Para
ver a saída do rastreamento da execução anterior, volte para sua função no portal e clique
na seta na parte inferior da tela para expandir os Logs.
Limpar recursos
Outros inícios rápidos nessa coleção aproveitam esse início rápido. Se você planeja trabalhar com
inícios rápidos subsequentes, tutoriais ou com qualquer serviço criado por você nesse início
rápido, não limpe os recursos.
Os Recursos no Azure se referem a aplicativos de funções, funções, contas de armazenamento e
assim por diante. Eles são agrupados em grupos de recursos, e você pode excluir tudo junto ao
excluir o grupo.
Você criou recursos para concluir esses guias de início rápido. Você pode ser cobrado por esses
recursos, dependendo do status de conta e preços do serviço. Caso não precise mais dos
recursos, é possível excluí-los desta maneira:
Para ir até essa página a partir da página de aplicativo de funções, selecione a guia Visão
geral e depois selecione o link em Grupo de recursos.
Para ir até essa página a partir do painel, selecione Grupos de recursos e depois selecione
o grupo de recursos que você usou para esse guia de início rápido.
2. Na página Grupo de recursos, examine a lista de recursos incluídos e verifique se eles são
aqueles que deseja excluir.
A exclusão poderá levar alguns minutos. Ao ser concluída, uma notificação será exibida por
alguns segundos. Também é possível selecionar o ícone de sino na parte superior da
página para exibir a notificação.
Próximas etapas
Você criou um aplicativo de funções com uma função simples disparada por HTTP.
Agora que você criou sua primeira função, vamos adicionar uma associação de saída à função
que grava uma mensagem na fila Armazenamento.
Adicionar mensagens a uma fila do Armazenamento do Azure usando o Functions
Para obter mais informações, veja Associações HTTP do Azure Functions.
Início Rápido: Criar sua primeira função por meio da
linha de comando usando a CLI do Azure
Este tópico de início rápido explica como criar sua primeira função na linha de comando ou no terminal. É possível
usar a CLI do Azure para criar um aplicativo de funções, que é a infraestrutura sem servidor que hospeda sua
função. O projeto de código de função é gerado de um modelo usando o Azure Functions Core Tools, que também
é usado para implantar o projeto de aplicativo de funções no Azure.
Você pode seguir as etapas abaixo usando um computador Mac, Windows ou Linux.
Pré-requisitos
Instale a CLI do Azure. Este artigo exige a CLI do Azure versão 2.0 ou posterior. Execute az --version
descobrir a versão que você tem. Você também pode usar o Azure Cloud Shell.
Criar o projeto de aplicativo de funções local

MyFunctionProj do diretório local atual. Um repositório GitHub também é criado em MyFunctionProj .
Quando solicitado, selecione um tempo de execução de trabalho entre as seguintes opções de linguagem:
dotnet : cria um projeto de biblioteca de classes do .NET (.csproj).
node : cria um projeto baseado em Node.js. Escolha javascript ou typescript .
python : para um projeto Python, conclua Criar uma função disparada por HTTP n Azure.
powershell : para um projeto PowerShell, conclua Criar sua primeira função do PowerShell no Azure.
Depois que o projeto é criado, use o seguinte comando para navegar até a nova pasta do projeto MyFunctionProj .
cd MyFunctionProj

seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}
Criar uma função


C#
func start --build
JavaScript
func start
TypeScript
npm install
npm start
%%%%%%
%%%%%%
@ %%%%%% @
@@ %%%%%% @@
@@@ %%%%%%%%%%% @@@
@@ %%%%%%%%%% @@
@@ %%%% @@
@@ %%% @@
@@ %% @@
%%
%
...

...
Http Functions:

no Azure.

lógico no qual os recursos do Azure, como os aplicativos de funções, bancos de dados e contas de armazenamento,
são implantados e gerenciados.


Standard_LRS

Você deve ter um aplicativo de funções para hospedar a execução de suas funções. O aplicativo de funções fornece
um ambiente para execução sem servidor do seu código de função. Ele permite que você agrupe funções como
uma unidade lógica para facilitar o gerenciamento, a implantação e o compartilhamento de recursos. Crie um
aplicativo de funções ao usar o comando az functionapp create.
No comando a seguir, substitua um nome de aplicativo de funções exclusivo quando você vir o espaço reservado
<APP_NAME> e o nome da conta de armazenamento por <STORAGE_NAME> . O <APP_NAME> é usado como domínio
DNS padrão para o aplicativo de funções, portanto, o nome deve ser exclusivo entre todos os aplicativos no Azure.
É possível definir o tempo de execução de <language> para seu aplicativo de funções, do dotnet (C#) ou node
(JavaScript).
az functionapp create --resource-group myResourceGroup --consumption-plan-location westeurope \

--name <APP_NAME> --storage-account <STORAGE_NAME> --runtime <language>
Definir o parâmetro local do plano de consumo significa que o aplicativo da função é hospedado em um plano de
hospedagem de consumo. Nesse plano sem servidor, os recursos são adicionados dinamicamente conforme
exigido pelas funções, e você paga apenas quando as funções estão em execução. Para obter mais informações,
consulte Escolher o plano de hospedagem correto.
Depois que o aplicativo de funções for criado, a CLI do Azure mostrará informações semelhantes ao exemplo a
seguir:
{
"availabilityState": "Normal",
"clientAffinityEnabled": true,
"clientCertEnabled": false,
"containerSize": 1536,
"dailyMemoryTimeQuota": 0,
"defaultHostName": "quickstart.azurewebsites.net",
"enabled": true,
"enabledHostNames": [
"quickstart.azurewebsites.net",
"quickstart.scm.azurewebsites.net"
],
....
// Remaining output has been truncated for readability.
}
Depois que o aplicativo de funções for criado no Azure, você poderá usar o comando do Core Tools
func azure functionapp publish para implantar o código do projeto no Azure. Nestes exemplos, substitua
<APP_NAME> pelo nome do seu aplicativo da etapa anterior.
C# / JavaScript
Python
TypeScript

Você verá a saída semelhante à seguinte, que foi truncada para facilitar a leitura:

...
Syncing triggers...
Invoke url: https://myfunctionapp.azurewebsites.net/api/httptrigger?code=cCr8sAxfBiow548FBDLS1....
Copie o valor Invoke url para seu HttpTrigger , que você agora poderá usar para testar sua função no Azure. A
URL contém um valor da cadeia de caracteres de consulta code que é sua chave de função. Essa chave dificulta

Use o cURL para verificar a função implantada. Usando a URL, incluindo a chave de função, que você copiou da
etapa anterior, acrescente a cadeia de consulta &name=<yourname> à URL.
Limpar recursos
Próximas etapas
Saiba mais sobre como desenvolver localmente Azure Functions usando as Ferramentas Básicas do Azure
Functions.
2 minutes to read
2 minutes to read
Criar sua primeira função com Java e Eclipse
Este artigo mostra como criar um projeto de função sem servidor com o Eclipse IDE e o Apache Maven, testá-lo
e depurá-lo e implantá-lo nas Funções do Azure.
Configurar seu ambiente de desenvolvimento

Para desenvolver um aplicativo de funções com Java e Eclipse, você deve ter o seguinte instalado:
Java Developer Kit, versão 8.
Apache Maven, versão 3.0 ou posterior.
Eclipse, com suporte a Java e Maven.
CLI do Azure
IMPORTANT
A variável de ambiente JAVA_HOME deve ser definida como o local de instalação do JDK para concluir este guia de início
rápido.
É altamente recomendável também instalar as Ferramentas Principais do Azure Functions, versão 2, que
fornecem um ambiente local para executar e depurar as Funções do Azure.
Criar um projeto do Functions

1. No Eclipse, selecione o menu arquivo e, em seguida, selecione novo-> projeto Maven.
2. Aceite os padrões de novo projeto Maven de caixa de diálogo e selecione próxima.
3. Selecione adicionar arquétipo e adicione as entradas para o azure-functions-arquétipo.
ID do grupo arquétipo: com.microsoft.azure
Archetype Artifact ID: azure-functions-archetype
Versão: Use a versão mais recente 1,22 do repositório central
4. Clique em OK e em Avançar. Certifique-se de preencher valores para todos os campos, incluindo
resourceGroup , appName e appRegion (use um appName diferente de Fabrikam -function -
20170920120101928) e, eventualmente, concluir.
O Maven cria os arquivos de projeto em uma nova pasta com um nome de artifactId. O código gerado no
projeto é uma função disparada por HTTP simples que ecoa o corpo da solicitação HTTP disparando.
Executar funções localmente no IDE

NOTE
As Ferramentas Principais do Azure Functions, versão 2 devem ser instaladas para executar e depurar funções localmente.
1. Clique com botão direito no projeto gerado e, em seguida, escolha executar como e build do Maven.
2. Em Editar configuração caixa de diálogo, insira package no metas e nome campos, em seguida, selecione
executar. Isso irá compilar e empacotar o código de função.
3. Quando a construção estiver concluída, crie outra configuração de execução, como acima, usando
azure-functions:run como meta e nome. Selecione Executar para executar a função no IDE.
Encerrar o runtime na janela do console, quando você terminar de testar sua função. Apenas um host de função
pode estar ativo e em execução localmente de cada vez.
Depurar a função no Eclipse
Em sua configuração Executar como configurada na etapa anterior, altere azure-functions:run para
azure-functions:run -DenableDebug e execute a configuração atualizada para iniciar o aplicativo de função no
modo de depuração.
Selecione o executados menu e open configurações de depuração. Escolher aplicativo Java remoto e crie
um novo. Dê um nome à sua configuração e preencha as configurações. A porta deve ser consistente com a
porta de depuração aberta pelo host de função, que por padrão é 5005 . Após a instalação, clique em Debug para
iniciar a depuração.
Defina pontos de interrupção e inspecione objetos em sua função usando o IDE. Quando terminar, pare o
depurador e o host da função de execução. Apenas um host de função pode estar ativo e em execução localmente
de cada vez.
O processo de implantação no Azure Functions usa credenciais de conta da CLI do Azure. Faça logon com a CLI
do Azure antes de continuar usando o prompt de comando do computador.
az login
Implante seu código em um novo aplicativo de funções usando o azure-functions:deploy meta Maven em uma
nova executar como configuração.
Quando a implantação for concluída, você verá a URL que pode usar para acessar seu aplicativo de funções do
Azure:
[INFO] Successfully deployed Function App with package.

[INFO] Deleting deployment package from Azure Storage...
[INFO] Successfully deleted deployment package fabrikam-function-20170920120101928.20170920143621915.zip
[INFO] Successfully deployed Function App at https://fabrikam-function-20170920120101928.azurewebsites.net
[INFO] ------------------------------------------------------------------------
Próximos passos
Examine o Guia do desenvolvedor de funções Java para saber mais sobre o desenvolvimento de funções Java.
Adicione outras funções com gatilhos diferentes ao seu projeto usando o destino Maven azure-functions:add
.
Criar sua primeira função do Azure com Java e
IntelliJ
Este artigo mostra:

Como criar um projeto de função sem servidor com IntelliJ IDEA e Apache Maven
Etapas para testar e depurar a função no IDE (ambiente de desenvolvimento integrado) em seu próprio
computador
Instruções para implantar o projeto de função para o Azure Functions
Configurar seu ambiente de desenvolvimento

Para desenvolver uma função com Java e IntelliJ, instale o software a seguir:
JDK (Java Developer Kit), versão 8
Apache Maven, versão 3.0 ou superior
IntelliJ IDEA, versões Community ou Ultimate com Maven
CLI do Azure
IMPORTANT
A variável de ambiente JAVA_HOME deve ser definida como o local de instalação do JDK para concluir as etapas neste
artigo.
É recomendável que você instale o Azure Functions Core Tools, versão 2. Ele fornece um ambiente de
desenvolvimento local para escrever, executar e depurar o Azure Functions.
Criar um projeto do Functions

1. No IntelliJ IDEA, selecione Criar Novo Projeto.
2. Na janela Novo Projeto, selecione Maven no painel esquerdo.
3. Marque a caixa de seleção Criar do arquétipo e, em seguida, selecione Adicionar Arquétipo para azure-
functions-archetype.
4. Na janela Adicionar Arquétipo, preencha os campos da seguinte maneira:
GroupId: com.microsoft.azure
ArtifactId: azure-functions-archetype
Versão: Use a versão mais recente 1,22 do repositório
5. Selecione OK e, em seguida, selecione Avançar.
6. Insira os detalhes do projeto atual e selecione Concluir.
Maven cria os arquivos de projeto em uma nova pasta com o mesmo nome que o valor ArtifactId. O código
gerado no projeto é uma função Disparada por HTTP simples que ecoa o corpo da solicitação HTTP que está
sendo disparada.
Executar funções localmente no IDE

NOTE
Para executar e depurar funções localmente, verifique se você instalou o Azure Functions Core Tools, versão 2.
1. Importe as alterações manualmente ou habilite a importação automática.

2. Abra a barra de ferramentas Projetos Maven.
3. Expanda Ciclo de Vida e, em seguida, abra o pacote. A solução é compilada e empacotada em um
diretório de destino criado recentemente.
4. Expanda Plug-ins > azure-functions e abra azure-functions:run para iniciar o tempo de execução local
do Azure Functions.
5. Feche a caixa de diálogo de execução quando terminar de testar a função. Apenas um host de função pode
estar ativo e em execução localmente de cada vez.
Depurar a função no IntelliJ

1. Para iniciar o host de função no modo de depuração, adicione -DenableDebug como argumento quando
ao executar sua função. Você pode alterar a configuração em metas do maven ou execute o seguinte
comando em uma janela de terminal:
mvn azure-functions:run -DenableDebug
Esse comando faz com que o host de função abra uma porta de depuração em 5005.
2. No menu Executar, selecione Editar Configurações.
3. Selecione (+) para adicionar um Remoto.
4. Preencha os campos Nome e Configurações e, em seguida, selecione OK para salvar a configuração.
5. Após a instalação, selecione Depurar < Nome da Configuração Remota > ou pressione Shift+F9 em
seu teclado para iniciar a depuração.
6. Ao terminar, pare o depurador e o processo em execução. Apenas um host de função pode estar ativo e
em execução localmente de cada vez.

1. Para poder implantar sua função no Azure, você deve entrar usando o CLI do Azure.
az login
2. Implante seu código em uma nova função usando o destino do Maven azure-functions:deploy . Você
também pode selecionar a opção azure-functions:deploy na janela de projetos do Maven.
3. Encontre a URL para sua função na saída da CLI do Azure depois que a função tiver sido implantada com
êxito.
[INFO] Successfully deployed Function App with package.

[INFO] Deleting deployment package from Azure Storage...
[INFO] Successfully deleted deployment package fabrikam-function-
20170920120101928.20170920143621915.zip
[INFO] Successfully deployed Function App at https://fabrikam-function-
20170920120101928.azurewebsites.net
[INFO] ------------------------------------------------------------------------
Próximas etapas
Examine o Guia do desenvolvedor de funções Java para saber mais sobre o desenvolvimento de funções Java.
Adicione outras funções com gatilhos diferentes ao seu projeto usando o destino do Maven
azure-functions:add .
Criar um aplicativo de funções em um Plano do
Serviço de Aplicativo do Azure
Azure Functions permite hospedar funções no Linux em um contêiner de Serviço de Aplicativo do Azure padrão.
Este artigo explica como usar a CLI do Azure para criar o portal do Azure para criar um aplicativo de funções
hospedado em Linux que é executado em um Plano do Serviço de Aplicativo. Você também pode usar seu próprio
contêiner.
Entrar no Azure

Você deve ter um aplicativo de funções para hospedar a execução de suas funções no Linux. O aplicativo de
funções fornece um ambiente para execução do seu código de função. Ele permite que você agrupe funções como
uma unidade lógica para facilitar o gerenciamento, a implantação e o compartilhamento de recursos. Neste artigo,
você criará um plano do serviço de aplicativo quando criar seu aplicativo de funções.
1. Selecione o botão Criar um recurso no canto superior esquerdo do portal do Azure e selecione
Computação > Aplicativo de funções.
Nome do aplicativo Nome globalmente exclusivo Nome que identifica seu novo
válidos são a-z , 0-9 e - .


SO Linux O aplicativo de funções é executado

no Linux.
Publicar Código O contêiner do Linux padrão para sua

pilha de runtime foi usado. Tudo o
que você precisa fornecer é o código
de projeto de aplicativo de função.
Outra opção é publicar uma imagem
do Docker personalizada.
Plano de hospedagem Plano do Serviço de Aplicativo Plano de hospedagem que define

seu aplicativo de funções. Quando
funções.
Plano/localização de serviço de Criar plano Escolha Criar novo e dê um nome

aplicativo ao Plano de Serviço de Aplicativo.
Escolha um local em uma região
perto de você ou perto de outros
serviços acessados pelas suas
funções. Escolha o tipo de preço
desejado.
É possível executar aplicativos de
funções do Windows e Linux no
mesmo plano do serviço de
aplicativo.

funções C# e F#.
Armazenamento Nome globalmente exclusivo Crie uma conta de armazenamento

números e letras minúsculas. Você
também pode usar uma conta
existente, mas ela precisa atender aos
armazenamento.
Application Insights habilitado O Application Insights está

desabilitado por padrão. É
recomendável habilitar a integração
do Application Insights agora e
escolher um local de hospedagem
perto da localização do plano de
serviço de aplicativo. Se você quiser
fazer isso mais tarde, consulte
Monitorar o Azure Functions.

5. Selecione Ir para recursos para exibir o novo aplicativo de funções.
Em seguida, crie uma nova função no novo aplicativo de funções. Mesmo depois que seu aplicativo de funções
estiver disponível, ele poderá levar alguns minutos para ser totalmente inicializado.

Esta seção mostra como criar uma função no novo aplicativo de funções no portal.
NOTE
A experiência de desenvolvimento do portal pode ser útil para experimentar o Azure Functions. Na maioria dos cenários,
considere desenvolver suas funções localmente e publicar o projeto de seu aplicativo de funções usando um Visual Studio
Code ou Azure Functions Core Tools.
1. Em seu novo aplicativo de função, escolha a guia Visão geral e, em seguida, depois que ele carregar
completamente, escolha + Nova função.
2. Na guia de Início Rápido, escolha No portale selecione Continuar.

Uma função é criada usando um modelo específico a um idioma para uma função disparada por HTTP.
Testar a função
1. Em sua nova função, clique em </> Obter URL da função na parte superior direita, selecione padrão
(Tecla de função) e depois clique em Copiar.
2. Cole a URL de função na barra de endereços do navegador. Adicione o valor da cadeia de caracteres de
consulta &name=<yourname> ao final desta URL e pressione Enter em seu teclado para executar a solicitação.
Você deverá ver a resposta retornada pela função exibida no navegador.
3. Quando a função é executada, informações de rastreamento são gravadas nos logs. Para ver a saída do
rastreamento da execução anterior, volte para sua função no portal e clique na seta na parte inferior da tela
para expandir os Logs.
Limpar recursos
maneira:
deseja excluir.
notificação.
Próximas etapas
Você criou um aplicativo de funções com uma função simples disparada por HTTP.
Agora que você criou sua primeira função, vamos adicionar uma associação de saída à função que grava uma
mensagem na fila Armazenamento.
Para obter mais informações, veja Associações HTTP do Azure Functions.
Início Rápido: Criar sua primeira função hospedada
no Linux usando ferramentas de linha de comando
O Azure Functions permite executar seu código em um ambiente Linux sem servidor sem que seja preciso
primeiro criar uma VM ou publicar um aplicativo Web. A hospedagem no Linux exige o Functions 2.x Runtime. As
funções sem servidor são executadas no plano de Consumo.
Este artigo de início rápido explica como usar a CLI do Azure para criar seu primeiro aplicativo de funções em
execução no Linux. O código da função é criado localmente e implantado no Azure usando o Azure Functions
Core Tools.
As etapas a seguir têm suporte em um computador Mac, Windows ou Linux. Este artigo mostra como criar
funções em JavaScript ou C#. Para saber como criar funções do Python, confira Criar sua primeira função do
Python usando o Core Tools e a CLI do Azure.
Pré-requisitos
Instale a CLI do Azure. Este artigo requer a CLI do Azure versão 2.0 ou posterior. Execute az --version
descobrir a versão que você tem. Você também pode usar o Azure Cloud Shell.
Criar o projeto de aplicativo de funções local

MyFunctionProj do diretório local atual. Um repositório GitHub também é criado em MyFunctionProj .
Quando solicitado, selecione um tempo de execução de trabalho entre as seguintes opções de linguagem:
dotnet : cria um projeto de biblioteca de classes do .NET (.csproj).
node : cria um projeto baseado em Node.js. Escolha javascript ou typescript .
python : para um projeto Python, conclua Criar uma função disparada por HTTP n Azure.
powershell : para um projeto PowerShell, conclua Criar sua primeira função do PowerShell no Azure.
Depois que o projeto é criado, use o seguinte comando para navegar até a nova pasta do projeto MyFunctionProj .
cd MyFunctionProj

seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}
Criar uma função


C#
func start --build
JavaScript
func start
TypeScript
npm install
npm start
%%%%%%
%%%%%%
@ %%%%%% @
@@ %%%%%% @@
@@@ %%%%%%%%%%% @@@
@@ %%%%%%%%%% @@
@@ %%%% @@
@@ %%% @@
@@ %% @@
%%
%
...

...
Http Functions:

no Azure.

lógico no qual os recursos do Azure, como os aplicativos de funções, bancos de dados e contas de


Standard_LRS
Criar um aplicativo de funções Linux no Azure

Você deve ter um aplicativo de funções para hospedar a execução de suas funções no Linux. O aplicativo de
funções fornece um ambiente sem servidor para a execução do código da função. Ele permite que você agrupe
funções como uma unidade lógica para facilitar o gerenciamento, a implantação e o compartilhamento de
recursos. Crie um aplicativo de funções em execução no Linux usando o comando az functionapp create.
No comando a seguir, use um nome de aplicativo de funções exclusivo quando vir o espaço reservado <app_name>
e o nome da conta de armazenamento de <storage_name> . O <app_name> também é o domínio do DNS padrão
para o aplicativo de funções. O nome precisa ser exclusivo em todos os aplicativos no Azure. É possível definir o
tempo de execução de <language> para seu aplicativo de funções, de dotnet (C#), node (JavaScript/TypeScript)
ou python .
az functionapp create --resource-group myResourceGroup --consumption-plan-location westus --os-type Linux \

--name <app_name> --storage-account <storage_name> --runtime <language>
Depois que o aplicativo de função for criado, você verá a seguinte mensagem:
Your serverless Linux function app 'myfunctionapp' has been successfully created.
To active this function app, publish your app content using Azure Functions Core Tools or the Azure portal.
Agora é possível publicar seu projeto no novo aplicativo de funções no Azure.

Depois que o aplicativo de funções for criado no Azure, você poderá usar o comando do Core Tools
func azure functionapp publish para implantar o código do projeto no Azure. Nestes exemplos, substitua
<APP_NAME> pelo nome do seu aplicativo da etapa anterior.
C# / JavaScript
Python

TypeScript

Você verá a saída semelhante à seguinte, que foi truncada para facilitar a leitura:

...
Syncing triggers...
Invoke url: https://myfunctionapp.azurewebsites.net/api/httptrigger?code=cCr8sAxfBiow548FBDLS1....
Copie o valor Invoke url para seu HttpTrigger , que você agora poderá usar para testar sua função no Azure. A
URL contém um valor da cadeia de caracteres de consulta code que é sua chave de função. Essa chave dificulta

Use o cURL para verificar a função implantada. Usando a URL, incluindo a chave de função, que você copiou da
etapa anterior, acrescente a cadeia de consulta &name=<yourname> à URL.
Limpar recursos
Próximas etapas
Saiba mais sobre como desenvolver localmente Azure Functions usando as Ferramentas Básicas do Azure
Functions.
Criar uma função usando o Microsoft Azure for
Students Starter
Neste tutorial, criaremos uma função HTTP Olá, Mundo em uma assinatura do Microsoft Azure for Students
Starter. Também examinaremos o que está disponível no Azure Functions nesse tipo de assinatura.
O Microsoft Azure for Students Starter oferece uma introdução aos produtos do Azure necessários para
desenvolver na nuvem sem nenhum custo para você. Saiba mais sobre essa oferta aqui.
O Azure Functions lhe permite executar seu código em um ambiente sem servidor sem que seja preciso primeiro
criar uma VM ou publicar um aplicativo Web. Saiba mais sobre o Functions aqui.
Criar uma função

Neste tópico, aprenda a usar o Functions para criar uma função "Olá, Mundo" disparada por HTTP no portal do
Microsoft Azure.
Entrar no Azure

Você deve ter um aplicativo de funções para hospedar a execução de suas funções. Um aplicativo de funções
permite a você agrupar funções como uma unidade lógica para facilitar o gerenciamento, implantação e
compartilhamento de recursos.
1. Selecione o botão Novo no canto superior esquerdo do portal do Azure, e selecione Computação >
Aplicativo de funções.



Plano de Serviço de Novo O plano de hospedagem que

Aplicativo/localização controla em qual região o aplicativo
de funções é implantado e a
densidade de seus recursos. Vários
aplicativos de funções implantados
no mesmo plano compartilharão a
mesma instância única livre. Trata-se
de uma restrição do plano Students
Starter. As opções de hospedagem
completas são explicadas aqui.
Pilha de tempo de execução Linguagem preferencial Escolha um tempo de execução

compatível com sua linguagem de
programação de funções favorita.
Escolha .NET para funções C# e F#.
Application Insights habilitado O Application Insights é usado para

armazenar e analisar logs do
aplicativo de funções. Ele será
habilitado por padrão se você
escolher uma localização que dá
suporte ao Application Insights. O
Application Insights pode ser
habilitado para qualquer função.
Basta escolher manualmente uma
região próxima para implantar o
Application Insights. Sem o
Application Insights, você só poderá
exibir os logs de transmissão ao vivo.
3. Selecione Localização/Plano de Serviço de Aplicativo acima para escolher uma localização diferente
4. Selecione Criar novo e, em seguida, dê um nome exclusivo para o plano.
5. Selecione a localização mais próxima de você. Veja um mapa completo de regiões do Azure aqui.

8. Selecione Ir para recursos para exibir o novo aplicativo de funções.


1. Expanda seu novo aplicativo de funções e selecione o botão + ao lado de Functions, escolha No portal e
selecione Continuar.
Uma função é criada usando um modelo específico a um idioma para uma função disparada por HTTP.
Testar a função
1. Em sua nova função, clique em </> Obter URL da função na parte superior direita, selecione padrão
(Tecla de função) e depois clique em Copiar.
2. Cole a URL de função na barra de endereços do navegador. Adicione o valor da cadeia de caracteres de
consulta &name=<yourname> ao final desta URL e pressione Enter em seu teclado para executar a solicitação.
Você deverá ver a resposta retornada pela função exibida no navegador.
3. Quando a função é executada, informações de rastreamento são gravadas nos logs. Para ver a saída do
rastreamento da execução anterior, volte para sua função no portal e clique na seta na parte inferior da tela
para expandir os Logs.
Limpar recursos
maneira:
deseja excluir.
notificação.
Recursos com suporte no Microsoft Azure for Students Starter

No Microsoft Azure for Students Starter, você tem acesso à maioria dos recursos do Azure Functions Runtime,
com várias limitações importantes listadas abaixo:
O gatilho HTTP é o único tipo de gatilho com suporte.
Há suporte para todas as associações de entrada e saída! Veja a lista completa aqui.
Linguagens com suporte:
C# (.NET Core 2)
Javascript (Node.js 8 e 10)
F# (.NET Core 2)
Veja as linguagens com suporte em planos superiores aqui
O Windows é o único sistema operacional com suporte.
A escala é restrita aos uma instância de camada gratuita em execução por até 60 minutos por dia. Haverá uma
escala sem servidor de 0 para 1 instância automaticamente à medida que o tráfego HTTP é recebido, mas
somente isso.
Há suporte apenas para o tempo de execução 2.x.
Todas as ferramentas de desenvolvedor têm suporte para as funções de edição e publicação. Isso inclui VS
Code, Visual Studio, CLI do Azure e portal do Azure. Se quiser usar algo diferente do portal, você precisará
primeiro criar um aplicativo no portal e, em seguida, escolher esse aplicativo como um destino de implantação
em sua ferramenta preferencial.
Próximas etapas
Você criou um aplicativo de funções com uma função simples disparada por HTTP! Agora, você pode explorar as
ferramentas locais, mais linguagens, monitoramento e integrações.
Criar sua primeira função usando o Visual Studio Code
Guia do desenvolvedor de JavaScript do Azure Functions
Usar o Azure Functions para conectar a um Banco de Dados SQL do Azure
Saiba mais sobre as associações HTTP do Azure Functions.
Monitorar o Azure Functions
Criar uma função disparada pelo Azure Cosmos DB
Saiba como criar uma função disparada quando dados são adicionados ou alterados no Azure Cosmos DB. Para
saber mais sobre o Azure Cosmos DB, confira Azure Cosmos DB: computação de banco de dados sem servidor
usando o Azure Functions.
Pré-requisitos
NOTE
As associações do Azure Cosmos DB têm suporte apenas para usar com a API do SQL. Para todas as outras APIs do Azure
Cosmos DB, você deve acessar o banco de dados por meio da sua função usando o cliente estático da API, incluindo a API do
Azure Cosmos DB para MongoDB, a API do Cassandra, a API do Gremlin e a API de Tabela.
Criar uma conta do Azure Cosmos DB

Antes de criar o gatilho, você precisa ter uma conta do Azure Cosmos DB que use a API de SQL.
1. Vá para o portal do Azure para criar uma conta do Azure Cosmos DB. Pesquise pelo Azure Cosmos DB e
selecione-o.
2. Selecione Adicionar.
3. Na página Criar Conta do Azure Cosmos DB, insira as configurações básicas da nova conta do Azure
Cosmos.
CONFIGURAÇÃO VALOR DESCRIÇÃO
Subscription Nome da assinatura Selecione a assinatura do Azure que

você deseja usar para essa conta do
Azure Cosmos.
Grupo de recursos Nome do grupo de recursos Selecione um grupo de recursos ou

selecione Criar novo, então insira
um nome exclusivo para o novo
grupo de recursos.
Nome da conta Um nome exclusivo Insira um nome para identificar a

conta do Azure Cosmos. Como
documents.Azure.com é acrescentado
à ID que você fornece para criar o
URI, use uma ID exclusiva.
A ID pode conter apenas letras

minúsculas, números e o caractere de
hífen (-). Ela deve ter entre 3 e 31
caracteres.
API O tipo de conta a ser criada Selecione Núcleo (SQL) para criar
uma consulta e um banco de dados
de documento usando a sintaxe SQL.
A API determina o tipo de conta a ser

criada. O Azure Cosmos DB fornece
cinco APIs: Núcleo (SQL) e MongoDB
para dados de documento, Gremlin
para dados de grafo, Tabela do Azure
e Cassandra. No momento, você deve
criar uma conta separada para cada
API.
Saiba mais sobre a API do SQL.
Location A região mais próxima dos usuários Selecione uma localização geográfica
para hospedar a sua conta do Azure
Cosmos DB. Use a localização mais
próxima dos usuários para fornecer a
eles acesso mais rápido aos dados.
4. Selecione Examinar + criar. Você pode ignorar as seções Rede e Marcas.
5. Examine as configurações da conta e selecione Criar. São necessários alguns minutos para criar a conta.
Aguarde até que a página do portal exiba Sua implantação está concluída.
6. Selecione Ir para recurso para ir para a página da conta do Azure Cosmos DB.
Criar um Aplicativo de funções do Azure



- .


funções C# e F#.

funções acessam.



necessário.

funções.



Criar gatilho do Azure Cosmos DB

em seu aplicativo de funções, selecione No portal e depois Continuar. Caso contrário, vá para a etapa três.
2. Escolha Mais modelos e, em seguida, Concluir e exibir modelos.

3. No campo de pesquisa, digite cosmos e escolha o modelo Gatilho do Azure Cosmos DB.
4. Se solicitado, selecione Instalar para instalar a extensão do Azure Cosmos DB no aplicativo de funções.
Após a instalação ser bem-sucedida, selecione Continuar.
5. Configure o novo gatilho com as configurações conforme especificado na tabela abaixo da imagem.
Nome Padrão Use o nome da função padrão

sugerido pelo modelo.
Conexão de conta do Azure Nova configuração Selecione Novo e depois escolha sua
Cosmos DB Assinatura, a Conta de banco de
dados criada anteriormente e
Selecionar. Isso cria uma
configuração de aplicativo para sua
conexão de conta. Essa configuração
é usada pela associação para conexão
com o banco de dados.
Nome da coleção Itens Nome da coleção a ser monitorada.
Crie a coleção de concessão, se Verificado A coleção ainda não existe, então crie
ela não existir uma.
Nome do banco de dados Tarefas Nome do banco de dados com a

coleção a ser monitorada.
6. Clique em Criar para criar o banco de dados da função disparada do Azure Cosmos DB. Depois que a
função for criada, o código de função baseado em modelo será exibido.
Esse modelo de função grava o número de documentos e a primeira ID de documento para os logs.
Em seguida, você conecta-se à sua conta do Azure Cosmos DB e cria a coleção Items no banco de dados Tasks .
Criar a coleção de itens

1. Abra uma segunda instância do portal do Azure em uma nova guia no navegador.
2. No lado esquerdo do portal, expanda a barra de ícones, digite cosmos no campo de pesquisa e selecione
Azure Cosmos DB.
3. Escolha sua conta do Azure Cosmos DB e selecione o Data Explorer.

4. Em Coleções, escolha taskDatabase e selecione Nova Coleção.
5. Em Adicionar Coleção, use as configurações mostradas na tabela abaixo da imagem.
ID do banco de dados Tarefas O nome do novo banco de dados.

Isso deve corresponder ao nome
definido na sua associação de função.
ID da coleção Itens O nome da nova coleção. Isso deve

corresponder ao nome definido na
sua associação de função.
Capacidade de armazenamento Fixo (10 GB) Use o valor padrão. Esse valor é a
capacidade de armazenamento do
banco de dados.
Taxa de transferência 400 RU Use o valor padrão. Se quiser reduzir

a latência, você poderá escalar
verticalmente a taxa de transferência
mais tarde.
Chave de partição /category Uma chave de partição que distribui

dados uniformemente para cada
partição. É importante selecionar a
chave de partição correta ao criar
uma coleção de alto desempenho.
6. Clique em OK para criar a coleção Itens. Pode levar alguns instantes para a coleção ser criada.
Depois que a coleção especificada na associação de função existir, você poderá testar a função adicionando
documentos a essa nova coleção.
Testar a função
1. Expanda a nova coleção taskCollection no Data Explorer, escolha Documentos e, em seguida, selecione
Novo Documento.
2. Substitua o conteúdo do novo documento pelo conteúdo a seguir e então escolha Salvar.
{
"id": "task1",
"category": "general",
"description": "some task"
}
3. Mude para a primeira guia do navegador que contém a função no portal. Expanda os logs de função e
verifique se o novo documento disparou a função. Veja se o valor de ID do documento task1 é gravado
nos logs.
4. (Opcional) Volte para o seu documento, faça uma alteração e, em seguida, clique em Atualizar. Em seguida,
volte para os logs de função e verifique se a atualização também disparou a função.
Limpar recursos
maneira:
deseja excluir.
notificação.
Próximas etapas
Você criou uma função que é executada quando um documento é adicionado ou modificado no Azure Cosmos DB.
Para obter mais informações sobre gatilhos do Azure Cosmos DB, consulte Associações do Azure Cosmos DB para
Azure Functions.
Criar uma função disparada pelo Armazenamento de
Blobs do Azure
Saiba como criar uma função disparada quando arquivos são carregados ou atualizados no Armazenamento de
Blobs do Azure.
Pré-requisitos
Baixe e instale o Gerenciador de Armazenamento do Microsoft Azure.
Uma assinatura do Azure. Se você não tiver uma, crie uma conta gratuita antes de começar.



- .


funções C# e F#.

funções acessam.



necessário.




Criar uma função disparada pelo Armazenamento de Blobs

3. No campo de pesquisa, digite blob e escolha o modelo Gatilho de blob.

4. Se solicitado, selecione Instalar para instalar a extensão de Armazenamento do Azure em todas as
dependências no aplicativo de funções. Após a instalação ser bem-sucedida, selecione Continuar.
5. Use as configurações conforme especificado na tabela abaixo da imagem.
Nome Exclusivo no aplicativo de funções O nome dessa função disparada pelo

blob.
Caminho samples-workitems/{name} Local no Armazenamento de Blobs

que está sendo monitorada. O nome
do arquivo do blob é passado na
associação como o parâmetro name.
Conexão da conta de AzureWebJobsStorage Você pode usar a conexão da conta

armazenamento de armazenamento que já está sendo
usada por seu aplicativo de funções
ou criar uma nova.
6. Clique em Criar para criar a função.

Em seguida, você pode se conectar à sua conta de armazenamento do Azure e criar o contêiner samples-
workitems.
Criar o contêiner
1. Em sua função, clique em Integrar, expanda Documentaçãoe copie Nome da conta e Chave de conta.
Você usa essas credenciais para conectar-se à conta de armazenamento. Se você já tiver se conectado à
conta de armazenamento, vá para a etapa 4.
2. Execute a ferramenta Gerenciador de Armazenamento do Microsoft Azure, clique no ícone conectar-se à

esquerda, escolha Usar um nome e chave de conta de armazenamento e clique em Avançar.
3. Insira o Nome da conta e Chave de conta da etapa 1, clique em Avançar e em Conectar.
4. Expanda a conta de armazenamento anexada, clique com o botão direito do mouse em Contêineres de
blob, clique em Criar contêiner de blob, digite samples-workitems e pressione enter.
Agora que você tem um contêiner de blob, você pode testar a função carregando um arquivo para o contêiner.
Testar a função
1. De volta ao Portal do Azure, navegue até sua função, expanda os Logs na parte inferior da página e
verifique se o streaming de log não está em pausa.
2. No Gerenciador de Armazenamento, expanda sua conta de armazenamento, Contêineres de blob e
samples-workitems. Clique em Carregar e depois em Carregar arquivos... .
3. Na caixa de diálogo Carregar arquivos, clique no campo Arquivos. Navegue até um arquivo em seu
computador local, por exemplo, um arquivo de imagem, selecione-o e clique em Abrir e depois em
Carregar.
4. Volte para os logs de função e verifique se o blob foi lido.
NOTE
Quando seu aplicativo de funções é executado no plano de consumo padrão, pode haver um atraso de até vários
minutos entre o blob que está sendo adicionado ou atualizado e a função sendo disparada. Se você precisar de baixa
latência em suas funções disparadas por blob, considere executar seu aplicativo de funções em um Plano do Serviço
de Aplicativo.
Limpar recursos
maneira:
deseja excluir.
notificação.
Próximas etapas
Você criou uma função que é executada quando um blob é adicionado a um Armazenamento de Blobs ou
atualizado nele. Para obter mais informações sobre gatilhos de armazenamento de blobs, consulte Associações de
Armazenamento de Blobs do Azure Functions.
Criar uma função disparada pelo Armazenamento de
Filas do Azure
Saiba como criar uma função que é disparada quando as mensagens são enviadas para uma fila do
Pré-requisitos
Baixe e instale o Gerenciador de Armazenamento do Microsoft Azure.
Uma assinatura do Azure. Se você não tiver uma, crie uma conta gratuita antes de começar.



- .


funções C# e F#.

funções acessam.



necessário.

funções.



Criar uma função disparada por Filas

3. No campo de pesquisa, digite queue e escolha o modelo Gatilho de fila.

4. Se solicitado, selecione Instalar para instalar a extensão de Armazenamento do Azure em todas as
dependências no aplicativo de funções. Após a instalação ser bem-sucedida, selecione Continuar.
5. Use as configurações conforme especificado na tabela abaixo da imagem.
Nome Exclusivo no aplicativo de funções O nome dessa função disparada por

filas.
Nome da fila myqueue-items Nome da fila à qual se conectar em

sua conta de armazenamento.
Conexão da conta de AzureWebJobStorage Você pode usar a conexão da conta

ou criar uma nova.
6. Clique em Criar para criar a função.

Em seguida, você pode se conectar à sua conta de armazenamento do Azure e criar a fila de armazenamento
myqueue-items.
Criar a fila
1. Em sua função, clique em Integrar, expanda Documentaçãoe copie Nome da conta e Chave de conta.
Você usa essas credenciais para conectar-se à conta de armazenamento no Gerenciador de Armazenamento
do Microsoft Azure. Se você já tiver se conectado à conta de armazenamento, vá para a etapa 4.
2. Execute a ferramenta Gerenciador de Armazenamento do Microsoft Azure, clique no ícone conectar-se à

esquerda, escolha Usar um nome e chave de conta de armazenamento e clique em Avançar.
3. Insira o Nome da conta e Chave de conta da etapa 1, clique em Avançar e em Conectar.
4. Expanda a conta de armazenamento anexada, clique com o botão direito do mouse em Filas, clique em
Criar Fila, digite myqueue-items e pressione enter.
Agora que você tem uma fila de armazenamento, você pode testar a função adicionando uma mensagem à fila.
Testar a função
1. De volta ao Portal do Azure, navegue até sua função, expanda os Logs na parte inferior da página e
verifique se o streaming de log não está em pausa.
2. No Gerenciador de Armazenamento, expanda sua conta de armazenamento, Filas e myqueue-items; em
seguida, clique em Adicionar mensagem.
3. Digite sua mensagem "Olá, Mundo!" em Texto da mensagem e clique em OK.
4. Aguarde alguns segundos, depois volte para seus logs de função e verifique se a nova mensagem foi lida da
fila.
5. No Gerenciador de Armazenamento, clique em Atualizar e verifique se a mensagem foi processada e se

não está mais na fila.
Limpar recursos
maneira:
deseja excluir.
notificação.
Próximas etapas
Você criou uma função que é executada quando uma mensagem é adicionada a uma fila de armazenamento. Para
obter mais informações sobre gatilhos de Armazenamento de Filas, consulte Associações de fila do
Armazenamento do Azure Functions.
mensagem de volta em outra fila.
Criar uma função no Azure que é disparada por um
temporizador
Saiba como usar o Azure Functions para criar uma função sem servidor que é executada com base em um
agendamento definido por você.
Pré-requisitos



- .


funções C# e F#.

funções acessam.


Use também uma conta existente,
que precisará atender aos requisitos

necessário.




8. Selecione Ir para recursos para exibir o novo aplicativo de funções. Você também pode selecionar Fixar
no painel. A fixação torna mais fácil retornar a esse recurso de aplicativo de função no seu painel.
Criar uma função disparada por temporizador

em seu aplicativo de funções, selecione No portal e depois Continuar. Caso contrário, vá para a etapa 3.
3. No campo de pesquisa, digite timer e defina o novo gatilho com as configurações especificadas na tabela
abaixo da imagem.
Nome Padrão Define o nome da sua função

disparada por temporizador.
Agenda 0 */1 * * * * Uma expressão CRON de seis

campos que agenda sua função para
ser executada a cada minuto.
4. Clique em Criar. Uma nova função na linguagem de programação escolhida por você e que é executada a
cada minuto é criada.
5. Verifique a execução, exibindo informações de rastreamento gravadas nos logs.
Agora você altera o agendamento da função para que ela seja executada uma vez por hora em vez de uma vez
por minuto.
Atualizar o agendamento do temporizador

1. Expanda sua função e clique em Integrar. É aqui que você define as associações de entrada e saída de sua
função e também define o agendamento.
2. Insira um novo valor de Agendamento por hora de 0 0 */1 * * * e depois clique em Salvar.
Agora você tem uma função que é executada uma vez a cada hora.
Limpar recursos
dependendo do status de conta e preços do serviço. Caso não precise mais dos recursos, é possível excluí-los
desta maneira:
deseja excluir.
notificação.
Próximas etapas
Você criou uma função que é executada segundo um agendamento. Para obter mais informações sobre gatilhos
de temporizador, confira Agendar a execução de código com o Azure Functions.
Armazenar dados não estruturados usando o Azure
Functions e o Azure Cosmos DB
O Azure Cosmos DB é uma ótima maneira de armazenar dados não estruturados e JSON. Combinado com o
Azure Functions, o Cosmos DB torna o armazenamento de dados rápido e fácil com muito menos código do que o
necessário para armazenar dados em um banco de dados relacional.
NOTE
Neste momento, o gatilho, as associações de entrada e as associações de saída do Azure Cosmos DB funcionam apenas com
contas da API do Graph e a API do SQL.
No Azure Functions, associações de entrada e saída fornecem uma maneira declarativa para se conectar a dados de
serviço externo de sua função. Neste artigo, saiba como atualizar uma função existente a fim de adicionar uma
associação de saída que armazena dados não estruturados em um documento do Azure Cosmos DB.
Pré-requisitos
Este tópico usa como ponto de partida os recursos criados em Criar sua primeira função no portal do Azure. Se
você ainda não fez isso, conclua estas etapas agora para criar seu aplicativo de funções.

Antes de criar a associação de saída, você precisa ter uma conta do Azure Cosmos DB que use a API de SQL.
selecione-o.
Cosmos.

Azure Cosmos.

grupo de recursos.


caracteres.

e Cassandra. No momento, você deve
criar uma conta separada para cada
API.
1. No portal, navegue até o aplicativo de funções que você criou anteriormente e expanda o aplicativo de
funções e a função.
2. Selecione Integrar e +Nova Saída, que está na parte superior direita da página. Escolha Azure Cosmos
DB e clique em Selecionar.
3. Se você receber uma mensagem de Extensões não instaladas, escolha Instalar para instalar a extensão de
associações do Azure Cosmos DB no aplicativo de funções. A instalação pode levar alguns minutos.
4. Use a configuração Saída do Azure Cosmos DB conforme especificado na tabela:
Nome do parâmetro do taskDocument Nome que se refere ao objeto do

documento Cosmos DB no código.
Nome do banco de dados taskDatabase Nome do banco de dados para salvar

os documentos.
Nome da coleção TaskCollection Nome da coleção de banco de dados.
Se for true, cria o banco de dados Verificado A coleção ainda não existe, então crie
e a coleção do Cosmos DB uma.
Taxa de transferência de coleção 400 RU Se quiser reduzir a latência, você

poderá escalar verticalmente a taxa
de transferência mais tarde.
5. Selecione Salvar para criar a associação.

Atualizar o código de função
Substitua o código existente da função pelo código a seguir na linguagem que você escolheu:
C#
JavaScript
Substitua função de C# existente por este código:
using Microsoft.AspNetCore.Http;
public static IActionResult Run(HttpRequest req, out object taskDocument, ILogger log)
{
string task = req.Query["task"];
string duedate = req.Query["duedate"];
// We need both name and task parameters.

if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(task))
{
taskDocument = new
{
name,
duedate,
task
};
return (ActionResult)new OkResult();

}
else
{
taskDocument = null;
return (ActionResult)new BadRequestResult();
}
}
Esse exemplo de código lê as cadeias de consulta da Solicitação HTTP e as atribui a campos no objeto
taskDocument . A associação taskDocument envia os dados do objeto desse parâmetro de associação para
armazenamento no banco de dados de documento associado. O banco de dados é criado na primeira execução da
função.
Testar a função e o banco de dados

1. Expanda a janela direita e selecione Testar. Em Consulta, clique em + Adicionar parâmetro e adicione os
seguintes parâmetros à cadeia de consulta:
name
task
duedate
2. Clique em Executar e verifique se um status 200 retorna.
3. No lado esquerdo do Portal do Azure, expanda a barra de ícones, digite cosmos no campo de pesquisa e
selecione Azure Cosmos DB.

5. Expanda os nós Coleções, selecione o novo documento e confirme se o documento contém os valores de
cadeia de consulta, juntamente com alguns metadados adicionais.
Você adicionou com êxito uma associação ao gatilho HTTP para armazenar dados não estruturados em um Azure
Cosmos DB.
Limpar recursos
Próximas etapas
Para saber mais sobre a associação a um banco de dados Cosmos DB, veja Associações do Azure Functions
Cosmos DB.
Conceitos de gatilhos e de associações do Azure Functions
Saiba como Functions se integra a outros serviços.
Fornece informações mais técnicas sobre o tempo de execução do Functions e uma referência para funções de
codificação e definição de associações e gatilhos.
Descreve as opções para desenvolver suas funções localmente.
2 minutes to read
Adicionar mensagens a uma fila do Armazenamento
do Azure usando o Functions
No Azure Functions, as associações de entrada e saída fornecem uma maneira declarativa para criar dados a partir
de serviços externos disponíveis ao seu código. Neste guia de início rápido, é possível usar uma associação de saída
para criar uma mensagem em uma fila quando uma função é disparada por uma solicitação HTTP. Use o
Gerenciador de Armazenamento do Azure para exibir as mensagens em fila que sua função cria:
Pré-requisitos
Siga as instruções em Criar sua primeira função no portal do Azure e não realize a etapa Limpar recursos.
Este início rápido cria o aplicativo de funções e a função que você usa aqui.
Instale o Gerenciador de Armazenamento do Microsoft Azure. Esta é uma ferramenta que você usará para
examinar a fila de mensagens cuja sua associação de saída cria.

Nesta seção, você usa a interface do usuário do portal para adicionar uma associação de saída de armazenamento
de filas para a função criada anteriormente. Essa associação tornará possível gravar com o mínimo de código para
criar uma mensagem em uma fila. Você não precisa escrever códigos para tarefas como abrir uma conexão de
armazenamento, criar uma fila ou obter uma referência a uma fila. O tempo de execução do Azure Functions e a
associação de saída da fila cuidam dessas tarefas para você.
1. No portal do Azure, abra a página de aplicativo de funções do aplicativo de funções criado por você em
Criar sua primeira função no portal do Azure. Para fazer isso, selecione Todos os serviços > Aplicativo de
funções e depois selecione seu aplicativo de funções.
2. Selecione a função que você criou no guia de início rápido anterior.
3. Selecione Integrar > Nova saída > Armazenamento de fila do Azure.
4. Clique em Selecionar.
5. Se você receber uma mensagem de Extensões não instaladas, escolha Instalar para instalar a extensão
Associações de armazenamento no aplicativo de funções. Isso pode levar alguns minutos.
6. Em Saída de armazenamento de filas do Azure, use as configurações conforme especificado na tabela

após esta captura de tela:
Nome do parâmetro de outputQueueItem O nome do parâmetro de associação

mensagem de saída.

ou criar uma nova.
Nome da fila outqueue Nome da fila à qual se conectar em

7. Clique em Salvar para adicionar a associação.

Agora que você tem uma associação de saída definida, você precisa atualizar o código para usar a associação para
adicionar mensagens a uma fila.

Nesta seção, você adiciona o código que grava uma mensagem na fila de saída. A mensagem inclui o valor que é
passado para o gatilho HTTP na cadeia de consulta. Por exemplo, se a cadeia de consulta incluir name=Azure , a
mensagem da fila será Nome transmitido para a função: Azure.
1. Selecione sua função para exibir o código de função no editor.
2. Atualize o código de função, dependendo da linguagem de programação de sua função:
C#
JavaScript
Adicione um parâmetro outputQueueItem à assinatura do método, conforme mostrado no exemplo a
seguir.
public static async Task<IActionResult> Run(HttpRequest req,

ICollector<string> outputQueueItem, ILogger log)
{
...
}
No corpo da função, imediatamente antes da instrução return , adicione o código que usa o parâmetro para
criar uma mensagem da fila.
outputQueueItem.Add("Name passed to the function: " + name);
3. Selecione Salvar para salvar as alterações.
Testar a função
1. Depois que as alterações de código forem salvas, selecione Executar.
Observe que o Corpo da solicitação contém o valor de name Azure. Esse valor aparece na mensagem da
fila que é criada quando a função é invocada.
Como uma alternativa para selecionar Executar aqui, você pode chamar a função inserindo uma URL em
um navegador e especificando o valor name na cadeia de consulta. O método de navegador é mostrado no
guia de início rápido anterior.
2. Confira os logs para verificar se a função foi bem-sucedida.
para verificar se a fila e uma mensagem nela foram criadas.
Ignore esta seção caso já tenha instalado o Gerenciador de Armazenamento e o conectado à conta de
armazenamento sendo usada neste guia de início rápido.
1. Execute a ferramenta Gerenciador de Armazenamento do Microsoft Azure, selecione o ícone conectar-se à
esquerda, escolha Usar um nome e chave de conta de armazenamento e selecione Avançar.
2. No portal do Azure, na página de aplicativo de funções, selecione a função e depois Integrar.
3. Selecione a associação de saída do Armazenamento de fila do Azure que você adicionou em uma etapa
anterior.
4. Expanda a seção Documentação na parte inferior da página.
O portal mostra as credenciais que você pode usar no Gerenciador de Armazenamento para se conectar à
5. Copie o valor Nome da Conta do portal e cole-o na caixa Nome da conta no Gerenciador de
Armazenamento.
6. Clique no ícone mostrar/ocultar ao lado da Chave de Conta para exibir o valor e depois copie o valor
Chave de Conta e cole-o na caixa Chave de conta no Gerenciador de Armazenamento.
7. Selecione Próximo > Conectar.
1. No Gerenciador de Armazenamento, selecione a conta de armazenamento sendo usada para este guia de
início rápido.
3. Execute a função novamente e você verá uma nova mensagem exibida na fila.
Limpar recursos
maneira:
deseja excluir.
notificação.
Próximas etapas
Neste guia de início rápido, você adicionou uma associação de saída a uma função existente. Para obter mais
informações sobre associação a Armazenamento de Filas, consulte Associações de fila do Armazenamento do
Azure Functions.
2 minutes to read
2 minutes to read
Estratégias para testar seu código no Azure
Functions
Este artigo demonstra como criar testes automatizados para o Azure Functions.
É recomendável testar todo o código; no entanto, talvez você obtenha resultados melhores ao encapsular uma
lógica da função e criar testes fora dela. Abstrair a lógica limita as linhas de código da função e permite que ela
seja a única responsável por chamar outras classes ou módulos. No entanto, este artigo demonstra como criar
testes automatizados em um HTTP e uma função disparada por temporizador.
O conteúdo a seguir é dividido em duas seções diferentes direcionadas a linguagens e ambientes distintos. Você
pode aprender a criar testes:
C# no Visual Studio com xUnit
JavaScript no VS Code com Jest
O repositório de exemplo está disponível no GitHub.
C# no Visual Studio
O exemplo a seguir descreve como criar um aplicativo de funções C# no Visual Studio e executar testes com
xUnit.
Configuração
Para configurar o ambiente, crie uma função e teste o aplicativo. As etapas a seguir ajudam você a criar os
aplicativos e as funções necessários para os testes:
1. Crie um aplicativo de funções e nomeie-o como Functions
2. Crie uma função HTTP do modelo e nomeie-a HttpTrigger.
3. Crie uma função temporizadora do modelo e nomeie-a TimerTrigger.
4. Crie um aplicativo de teste xUnit no Visual Studio, clicando em Arquivo > Novo > Projeto > Visual C# >
.NET Core > Projeto de teste xUnit e nomeie-o Functions.Test.
5. Use o NuGet para adicionar uma referência do aplicativo de teste Microsoft. AspNetCore. Mvc
6. Referencie o aplicativo Functions no aplicativo Functions.Test.
Criar classes de teste
Agora que os aplicativos foram criados, será possível criar as classes usadas para executar os testes
automatizados.
Cada função usa uma instância do ILogger para manipular o log de mensagens. Alguns testes não registram
mensagens ou não se preocupam com como log é implementado. Outros testes precisam avaliar as mensagens
registradas para determinar se foram aprovadas.
A classe ListLogger deve implementar a interface ILogger e manter uma lista interna de mensagens para
avaliação durante um teste.
Clique com o botão direito do mouse no aplicativo functions. Test e selecione Adicionar > classe, nomeie-o
NullScope.cs e insira o código a seguir:
using System;
namespace Functions.Tests
{
public class NullScope : IDisposable
{
public static NullScope Instance { get; } = new NullScope();
private NullScope() { }
public void Dispose() { }

}
}
Em seguida, clique com o botão direito do mouse no aplicativo functions. Test e selecione Adicionar > classe,
nomeie-o ListLogger.cs e insira o código a seguir:
using System;
using System.Text;
{
public class ListLogger : ILogger
{
public IList<string> Logs;
public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;
public bool IsEnabled(LogLevel logLevel) => false;
public ListLogger()
{
this.Logs = new List<string>();
}
public void Log<TState>(LogLevel logLevel,

EventId eventId,
TState state,
Exception exception,
Func<TState, Exception, string> formatter)
{
string message = formatter(state, exception);
this.Logs.Add(message);
}
}
}
A classe ListLogger implementará os seguintes membros, conforme contratado pela interface ILogger :
BeginScope: os escopos adicionam contexto ao seu registro em log. Nesse caso, o teste apenas aponta
para a instância estática na classe NullScope para permitir que o teste funcione.
IsEnabled: um valor padrão de false é fornecido.
Log: esse método usa a função de formatter fornecida para formatar a mensagem e, em seguida,
adiciona o texto resultante à coleção de Logs .
A coleção Logs é uma instância de List<string> e é inicializada no construtor.
Em seguida, clique com o botão direito do mouse no aplicativo Functions.Test e selecione Adicionar >
Classe. Nomeie como LoggerTypes.cs e insira este código:
{
public enum LoggerTypes
{
Null,
List
}
}
Esta enumeração especifica o tipo de agente usado pelos testes.

Classe. Nomeie como TestFactory.cs e insira este código:
using Microsoft.AspNetCore.Http.Internal;
using Microsoft.Extensions.Logging.Abstractions;
{
public class TestFactory
{
public static IEnumerable<object[]> Data()
{
return new List<object[]>
{
new object[] { "name", "Bill" },
new object[] { "name", "Paul" },
new object[] { "name", "Steve" }
};
}
private static Dictionary<string, StringValues> CreateDictionary(string key, string value)

{
var qs = new Dictionary<string, StringValues>
{
{ key, value }
};
return qs;
}
public static DefaultHttpRequest CreateHttpRequest(string queryStringKey, string queryStringValue)

{
var request = new DefaultHttpRequest(new DefaultHttpContext())
{
Query = new QueryCollection(CreateDictionary(queryStringKey, queryStringValue))
};
return request;
}
public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)

{
ILogger logger;
if (type == LoggerTypes.List)
{
logger = new ListLogger();
}
else
{
logger = NullLoggerFactory.Instance.CreateLogger("Null Logger");
}
return logger;
}
}
}
A classe TestFactory implementa os seguintes membros:

Dados: essa propriedade retorna uma coleção IEnumerable de dados de exemplo. Os pares chave-valor
representam valores que são passados para uma cadeia de caracteres de consulta.
CreateDictionary: esse método aceita um par de chave/valor como argumentos e retorna um novo
Dictionary usado para criar QueryCollection para representar valores de cadeia de caracteres de
consulta.
Createhttprequest: esse método cria uma solicitação HTTP inicializada com os parâmetros de cadeia de
caracteres de consulta fornecidos.
Createlogger: com base no tipo de agente, esse método retorna uma classe de agente usada para teste.
O ListLogger controla as mensagens registradas disponíveis para avaliação em testes.
Classe. Nomeie como FunctionsTests.cs e insira este código:
using Xunit;
{
public class FunctionsTests
{
private readonly ILogger logger = TestFactory.CreateLogger();
[Fact]
public async void Http_trigger_should_return_known_string()
{
var request = TestFactory.CreateHttpRequest("name", "Bill");
var response = (OkObjectResult)await HttpFunction.Run(request, logger);
Assert.Equal("Hello, Bill", response.Value);
}
[Theory]
[MemberData(nameof(TestFactory.Data), MemberType = typeof(TestFactory))]
public async void Http_trigger_should_return_known_string_from_member_data(string queryStringKey,
string queryStringValue)
{
var request = TestFactory.CreateHttpRequest(queryStringKey, queryStringValue);
var response = (OkObjectResult)await HttpFunction.Run(request, logger);
Assert.Equal($"Hello, {queryStringValue}", response.Value);
}
[Fact]
public void Timer_should_log_message()
{
var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
TimerTrigger.Run(null, logger);
var msg = logger.Logs[0];
Assert.Contains("C# Timer trigger function executed at", msg);
}
}
}
Os membros implementados nesta classe são:

Http_trigger_should_return_known_string: esse teste cria uma solicitação com os valores de cadeia de
caracteres de consulta de name=Bill para uma função http e verifica se a resposta esperada é retornada.
Http_trigger_should_return_string_from_member_data: esse teste usa atributos xUnit para fornecer
dados de exemplo para a função http.
Timer_should_log_message: esse teste cria uma instância de ListLogger e passa-a para uma função de
temporizador. Depois que a função é executada, o log é verificado para garantir que a mensagem
esperada está presente.
Se você quiser acessar as configurações do aplicativo em seus testes, você pode usar System. Environment.
GetEnvironmentVariable.
Executar testes
Para executar os testes, navegue até a Gerenciador de Testes e clique em Executar todos.
Depurar testes
Para depurar os testes, defina um ponto de interrupção em um teste, navegue até o Gerenciador de Testes e
clique em Executar > Depurar última execução.
JavaScript no VS Code
O exemplo a seguir descreve como criar um aplicativo de funções JavaScript no VS Code e executar testes com
Jest. Este procedimento usa a extensão de funções do VS Code para criar no Azure Functions.
Configuração
Para configurar o ambiente, inicialize um novo aplicativo Node.js em uma pasta vazia executando npm init .
npm init -y
Em seguida, instale o Jest executando o seguinte comando:
npm i jest
Agora, atualize package.json para substituir o comando de teste existente com o seguinte comando:
"scripts": {
"test": "jest"
}
Criar módulos de teste

Com o projeto inicializado, você poderá criar os módulos usados para executar os testes automatizados. Comece
criando uma pasta chamada testing para manter os módulos de suporte.
Na pasta testing, adicione um novo arquivo, nomeie-o como defaultContext.js e adicione o seguinte código:
module.exports = {
log: jest.fn()
};
Esse módulo simula a função log para representar o contexto de execução padrão.
Em seguida, adicione um novo arquivo, nomeie- defaultTimer.js e adicione o seguinte código:
module.exports = {
IsPastDue: false
};
Esse módulo implementa a propriedade IsPastDue como uma instância de temporizador falsa. Configurações
de temporizador como expressões NCRONTAB não são necessárias aqui, pois o equipamento de teste está
simplesmente chamando a função diretamente para testar o resultado.
Em seguida, use a extensão de funções do VS Code para criar uma função HTTP do JavaScript e nomeie-a
HttpTrigger. Após a criação da função, adicione um novo arquivo à mesma pasta de nome index.test.js e
adicione o seguinte código:
const httpFunction = require('./index');

const context = require('../testing/defaultContext')
test('Http trigger should return known text', async () => {
const request = {
query: { name: 'Bill' }
};
await httpFunction(context, request);
expect(context.log.mock.calls.length).toBe(1);
expect(context.res.body).toEqual('Hello Bill');
});
A função HTTP do modelo retornará uma cadeia de caracteres "Hello" concatenada com o nome fornecido na
cadeia de caracteres de consulta. Esse teste cria uma instância falsa de uma solicitação e passa-a para a função
HTTP. O teste verifica se o método log é chamado uma vez e se o texto retornado é igual a "Hello Bill".
Em seguida, use a extensão de funções do VS Code para criar uma função de temporizador do JavaScript e
nomeie-a TimerTrigger. Após a criação da função, adicione um novo arquivo à mesma pasta de nome
index.test.js e adicione o seguinte código:
const timerFunction = require('./index');

const context = require('../testing/defaultContext');
const timer = require('../testing/defaultTimer');
test('Timer trigger should log message', () => {

timerFunction(context, timer);
expect(context.log.mock.calls.length).toBe(1);
});
A função de temporizador do modelo registra uma mensagem no final do corpo da função. Esse teste assegura
que a função log será chamada uma vez.
Executar testes
Para executar os testes, pressione CTRL + ~ para abrir a janela de comando e execute npm test :
npm test
Depurar testes
Para depurar seus testes, adicione a seguinte configuração ao arquivo launch.json:
{
"type": "node",
"request": "launch",
"name": "Jest Tests",
"disableOptimisticBPs": true,
"program": "${workspaceRoot}/node_modules/jest/bin/jest.js",
"args": [
"-i"
],
"internalConsoleOptions": "openOnSessionStart"
}
Em seguida, defina um ponto de interrupção no teste e pressione F5.
Próximos passos
Agora que você aprendeu a gravar testes automatizados das funções, continue com estes recursos:
Depuração local do gatilho da Grade de Eventos do Azure Functions
Depurar Azure Functions do PowerShell localmente
Azure Functions permite desenvolver suas funções como scripts do PowerShell.
NOTE
O PowerShell para o Azure Functions está atualmente em versão prévia. Para receber atualizações importantes, assine o
repositório Anúncios do Serviço de Aplicativo do Azure no GitHub.
Você pode depurar suas funções do PowerShell localmente como faria com qualquer script do PowerShell usando
as seguintes ferramentas de desenvolvimento padrão:
Visual Studio Code: Editor de texto gratuito, leve e de software livre da Microsoft com a extensão do
PowerShell que oferece uma experiência de desenvolvimento completa do PowerShell.
Um console do PowerShell: Depurar usando os mesmos comandos que você usaria para depurar qualquer
outro processo do PowerShell.
O Azure Functions Core Tools dá suporte à depuração local de Azure functions, incluindo o PowerShell functions.
Exemplo de aplicativo de funções

O aplicativo de funções usado neste artigo tem uma única função disparada por HTTP e tem os seguintes
arquivos:
PSFunctionApp
| - HttpTriggerFunction
| | - run.ps1
| | - function.json
| - host.json
| - profile.ps1
Esse aplicativo de funções é semelhante ao que você obtém quando conclui o início rápido do PowerShell.
O código de função em run.ps1 é semelhante ao seguinte script:
param($Request)
$name = $Request.Query.Name
if($name) {
$status = 200
$body = "Hello $name"
}
else {
$status = 400
$body = "Please pass a name on the query string or in the request body."
}
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{

StatusCode = $status
Body = $body
})
Definir o ponto de anexo

Para depurar qualquer função do PowerShell, a função precisa parar para que o depurador seja anexado. O cmdlet
Wait-Debugger interrompe a execução e aguarda o depurador.
Tudo o que você precisa fazer é adicionar uma chamada ao cmdlet Wait-Debugger logo acima da instrução if , da
seguinte maneira:
param($Request)
$name = $Request.Query.Name
# This is where we will wait for the debugger to attach

Wait-Debugger
if($name) {
$status = 200
$body = "Hello $name"
}
# ...
A depuração começa na instrução if .

Com Wait-Debugger em vigor, agora você pode depurar as funções usando o Visual Studio Code ou um console
do PowerShell.
Depurar no Visual Studio Code

Para depurar as funções do PowerShell no Visual Studio Code, você deve ter o seguinte instalado:
Extensão do PowerShell para Visual Studio Code
Extensão Azure Functions para Visual Studio Code
PowerShell Core 6,2 ou superior
Depois de instalar essas dependências, carregue um projeto de funções do PowerShell existente ou crie seu
primeiro projeto de funções do PowerShell.
NOTE
Se o seu projeto não tiver os arquivos de configuração necessários, você será solicitado a adicioná-los.
Definir a versão do PowerShell
O PowerShell Core é instalado lado a lado com o Windows PowerShell. Defina o PowerShell Core como a versão
do PowerShell a ser usada com a extensão do PowerShell para Visual Studio Code.
1. Pressione F1 para exibir o palete de comandos e, em seguida, procure Session .
2. Escolha **PowerShell: Mostrar menu de sessão @ no__t-0.
3. Se a sessão atual não for o PowerShell Core 6, escolha **Switch para: PowerShell Core 6 @ no__t-0.
Quando você tiver um arquivo do PowerShell aberto, verá a versão exibida em verde na parte inferior direita da
janela. A seleção desse texto também exibe o menu sessão. Para saber mais, consulte escolhendo uma versão do
PowerShell para usar com a extensão.
Iniciar o aplicativo de funções
Verifique se Wait-Debugger está definido na função em que você deseja anexar o depurador. Com Wait-Debugger
adicionado, você pode depurar seu aplicativo de funções usando Visual Studio Code.
Escolha o painel depurar e anexe à função do PowerShell.
Você também pode pressionar a tecla F5 para iniciar a depuração.

A operação iniciar depuração realiza as seguintes tarefas:
Executa func extensions install no terminal para instalar qualquer extensão de Azure Functions exigida pelo
Executa func host start no terminal para iniciar o aplicativo de funções no host do functions.
Anexe o depurador do PowerShell ao runspace do PowerShell dentro do tempo de execução do functions.
NOTE
Você precisa garantir que PSWorkerInProcConcurrencyUpperBound esteja definido como 1 para garantir a experiência de
depuração correta em Visual Studio Code. Esse é o padrão.
Com seu aplicativo de funções em execução, você precisa de um console do PowerShell separado para chamar a
função disparada por HTTP.
Nesse caso, o console do PowerShell é o cliente do. O Invoke-RestMethod é usado para disparar a função.
Em um console do PowerShell, execute o seguinte comando:
Invoke-RestMethod "http://localhost:7071/api/HttpTrigger?Name=Functions"
Você observará que uma resposta não é retornada imediatamente. Isso ocorre porque Wait-Debugger anexou o
depurador e a execução do PowerShell entrou no modo de interrupção assim que possível. Isso ocorre devido ao
conceito de BreakAll, que é explicado posteriormente. Depois de pressionar o botão continue , o depurador agora
será interrompido na linha logo após Wait-Debugger .
Neste ponto, o depurador é anexado e você pode fazer todas as operações normais do depurador. Para obter mais
informações sobre como usar o depurador no Visual Studio Code, consulte a documentação oficial.
Depois de continuar e chamar totalmente o script, você observará que:
O console do PowerShell que fez o Invoke-RestMethod retornou um resultado
O console integrado do PowerShell no Visual Studio Code está aguardando a execução de um script
Posteriormente, quando você invoca a mesma função, o depurador na extensão do PowerShell é interrompido
logo após o Wait-Debugger .
Depuração em um console do PowerShell

NOTE
Esta seção pressupõe que você leu o Azure Functions Core Tools docs e saberá como usar o comando func host start
para iniciar seu aplicativo de funções.
Abra um console do, cd no diretório do seu aplicativo de funções e execute o seguinte comando:
func host start
Com o aplicativo de funções em execução e o Wait-Debugger em vigor, você pode anexar ao processo. Você
precisa de mais dois consoles do PowerShell.
Um dos consoles atua como o cliente. A partir disso, você chama Invoke-RestMethod para disparar a função. Por
exemplo, você pode executar o seguinte comando:
Invoke-RestMethod "http://localhost:7071/api/HttpTrigger?Name=Functions"
Você observará que ele não retorna uma resposta, que é um resultado do Wait-Debugger . O runspace do
PowerShell agora está aguardando a anexação de um depurador. Vamos colocar isso em anexo.
No outro console do PowerShell, execute o seguinte comando:
Get-PSHostProcessInfo
Esse cmdlet retorna uma tabela parecida com a seguinte saída:
ProcessName ProcessId AppDomainName

----------- --------- -------------
dotnet 49988 None
pwsh 43796 None
pwsh 49970 None
pwsh 3533 None
pwsh 79544 None
pwsh 34881 None
pwsh 32071 None
pwsh 88785 None
Anote o ProcessId para o item na tabela com o ProcessName como dotnet . Esse processo é seu aplicativo de
funções.
Em seguida, execute o seguinte trecho:
# This enters into the Azure Functions PowerShell process.

# Put your value of `ProcessId` here.
Enter-PSHostProcess -Id $ProcessId
# This triggers the debugger.

Debug-Runspace 1
Depois de iniciado, o depurador é interrompido e mostra algo semelhante à seguinte saída:
Debugging Runspace: Runspace1
To end the debugging session type the 'Detach' command at the debugger prompt, or type 'Ctrl+C' otherwise.
At /Path/To/PSFunctionApp/HttpTriggerFunction/run.ps1:13 char:1
+ if($name) { ...
+ ~~~~~~~~~~~
[DBG]: [Process:49988]: [Runspace1]: PS /Path/To/PSFunctionApp>>
Neste ponto, você está parado em um pontos de interrupção no depurador do PowerShell. A partir daqui, você
pode fazer todas as operações de depuração usuais, depurar, entrar, continuar, encerrar e outras. Para ver o
conjunto completo de comandos de depuração disponíveis no console do, execute os comandos h ou ? .
Você também pode definir pontos de interrupção nesse nível com o cmdlet Set-PSBreakpoint .
Depois de continuar e chamar totalmente o script, você observará que:
O console do PowerShell em que você executou Invoke-RestMethod agora retornou um resultado.
O console do PowerShell em que você executou Debug-Runspace está aguardando a execução de um script.
Você pode invocar a mesma função novamente (usando Invoke-RestMethod , por exemplo) e o depurador é
interrompido logo após o comando Wait-Debugger .
Considerações sobre depuração

Tenha em mente os seguintes problemas ao depurar seu código de funções.
BreakAll pode fazer com que o depurador quebre em um local inesperado
A extensão do PowerShell usa Debug-Runspace , que por sua vez depende do recurso de BreakAll do PowerShell.
Esse recurso informa ao PowerShell para parar no primeiro comando que é executado. Esse comportamento
oferece a oportunidade de definir pontos de interrupção dentro do runspace depurado.
O tempo de execução de Azure Functions executa alguns comandos antes de realmente invocar o script de
run.ps1 , portanto, é possível que o depurador acabe a interrupção dentro do
Microsoft.Azure.Functions.PowerShellWorker.psm1 ou Microsoft.Azure.Functions.PowerShellWorker.psd1 .
Se essa interrupção ocorrer, execute o comando continue ou c para ignorar esse ponto de interrupção. Em
seguida, você pára no ponto de interrupção esperado.
Próximas etapas
Para saber mais sobre como desenvolver funções usando o PowerShell, confira Azure Functions guia do
desenvolvedor do PowerShell.
Depuração local do gatilho da Grade de Eventos do
Azure Functions
Este artigo demonstra como depurar uma função local que manipula um evento de grade de eventos do Azure
gerado por uma conta de armazenamento.
Pré-requisitos
Criar ou usar um aplicativo de função existente
Criar ou usar uma conta de armazenamento existente
Realizar o download do ngrok para permitir que o Azure chame sua função local
Criar uma nova função

Abra seu aplicativo de funções no Visual Studio e, com o botão direito no nome do projeto no Gerenciador de
Soluções e clique em Adicionar > Nova função do Azure.
Na janela Nova função do Azure, selecione gatilho da Grade de Eventos e clique em OK.
Depois que a função é criada, abra o arquivo de código e o copie a URL comentada na parte superior do arquivo.
Esse local é usado ao configurar o gatilho de Grade de Eventos.
Em seguida, defina um ponto de interrupção na linha que começa com log.LogInformation .
Em seguida, pressione F5 para iniciar uma sessão de depuração.
Permitir que o Azure chame sua função local

Para interromper uma função que está sendo depurada em seu computador, você deve habilitar uma maneira para
o Azure se comunicar com sua função local da nuvem.
O utilitário ngrok oferece uma maneira para o Azure chamar a função em execução no computador. Inicie ngrok
usando o seguinte comando:
ngrok http -host-header=localhost 7071
Como o utilitário de configuração, a janela de comando deve ser semelhante à seguinte captura de tela:
Cópia de HTTPS URL gerada quando ngrok é executado. Esse local é usado ao configurar o gatilho de Grade de
Eventos.
Adicionar uma chave de armazenamento

Abra o portal do Azure, navegue até uma conta de armazenamento e clique na opção Eventos.
Na janela Eventos, clique no botão Assinatura de Evento. Na janela Até Assinatura, clique na lista suspensa Tipo
de ponto de extremidade e selecione Web hook.
Depois que o tipo de ponto de extremidade é configurado, clique em Selecionar um ponto de extremidade
para configurar o valor de ponto de extremidade.
O valor do Ponto de extremidade do assinante é composto de três valores diferentes. O prefixo é a URL HTTPS
gerada pelo ngrok. O restante da URL vem da URL encontrada no arquivo de código de função, com o nome da
função adicionado ao final. Começando com a URL do arquivo de código de função, o ngrok URL substitui
http://localhost:7071 e a função nome substitui {functionname} .
Captura de tela a seguir mostra como a URL final deve ser:
Depois de inserir o valor apropriado, clique em Confirmar seleção.
IMPORTANT
Sempre que você iniciar o ngrok, a URL HTTPS é gerada novamente e o valor é alterado. Portanto você deve criar uma nova
assinatura de evento cada vez que expor sua função no Azure por meio do ngrok.
Carregar um arquivo
Agora você pode carregar um arquivo para sua conta de armazenamento para disparar um Evento de Grade de
Eventos para sua função local para tratar.
Abra o Gerenciador de Armazenamento e conecte-se à sua conta de armazenamento.
Expanda Contêineres de Blob
Clique com botão direito e selecione Criar contêiner de Blob.
Nomeie o contêiner teste
Selecione o contêiner testar
Clique no botão Carregar
Clique em Carregar arquivos
Selecione um arquivo e carregá-o para o contêiner de blob
Depurar a função
Depois que a Grade de Eventos reconhece que um novo arquivo for carregado para o contêiner de
armazenamento, o ponto de interrupção é atingido em sua função local.
Limpar recursos
Para limpar os recursos criados neste artigo, exclua o contêiner Testar em sua conta de armazenamento.
Próximas etapas
Automatizar o redimensionamento de imagens carregadas usando a Grade de Eventos
Gatilho de Grade de Eventos para o Azure Functions
Usar injeção de dependência no .NET Azure
Functions
Azure Functions dá suporte ao padrão de design de software injeção de dependência (DI), que é uma técnica para
obter inversão de controle (IOC ) entre classes e suas dependências.
A injeção de dependência no Azure Functions é criada sobre os recursos de injeção de dependência do .NET
Core. É recomendável ter familiaridade com a injeção de dependência do .NET Core . No entanto, há
diferenças em como você substitui dependências e como os valores de configuração são lidos com Azure
Functions no plano de consumo.
O suporte para injeção de dependência começa com Azure Functions 2. x.
Pré-requisitos
Antes de poder usar a injeção de dependência, você deve instalar os seguintes pacotes NuGet:
Microsoft. Azure. Functions. Extensions
Pacote Microsoft. net. Sdk. Functions versão 1.0.28 ou posterior
Serviços de registro
Para registrar serviços, crie um método para configurar e adicionar componentes a uma instância de
IFunctionsHostBuilder . O host Azure Functions cria uma instância de IFunctionsHostBuilder e a transmite
diretamente para o seu método.
Para registrar o método, adicione o atributo FunctionsStartup assembly que especifica o nome de tipo usado
durante a inicialização.
using System;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Http;
[assembly: FunctionsStartup(typeof(MyNamespace.Startup))]
namespace MyNamespace
{
public class Startup : FunctionsStartup
{
public override void Configure(IFunctionsHostBuilder builder)
{
builder.Services.AddHttpClient();
builder.Services.AddSingleton((s) => {
return new MyService();
});
builder.Services.AddSingleton<ILoggerProvider, MyLoggerProvider>();
}
}
}
Limitações
Uma série de etapas de registro executada antes e depois que o tempo de execução processa a classe de
inicialização. Portanto, tenha em mente os seguintes itens:
A classe de inicialização destina -se apenas à instalação e ao registro. Evite usar serviços registrados na
inicialização durante o processo de inicialização. Por exemplo, não tente registrar uma mensagem em um
agente que está sendo registrado durante a inicialização. Esse ponto do processo de registro é muito cedo
para que os serviços estejam disponíveis para uso. Depois que o método de Configure é executado, o
tempo de execução do Functions continua registrando dependências adicionais, o que pode afetar o
funcionamento dos serviços.
O contêiner de injeção de dependência só mantém tipos explicitamente registrados. Os únicos serviços
disponíveis como tipos que podem ser injetados são os que são configurados no método Configure . Como
resultado, tipos específicos de funções como BindingContext e ExecutionContext não estão disponíveis
durante a instalação ou como tipos injetados.
Usar dependências injetadas

A injeção de construtor é usada para disponibilizar suas dependências em uma função. O uso de injeção de
construtor requer que você não use classes estáticas.
O exemplo a seguir demonstra como as dependências de IMyService e HttpClient são injetadas em uma função
disparada por HTTP. Este exemplo usa o pacote Microsoft. Extensions. http necessário para registrar um
HttpClient na inicialização.
using System;
using System.IO;
using Microsoft.Azure.WebJobs.Extensions.Http;
namespace MyNamespace
{
public class HttpTrigger
{
private readonly IMyService _service;
private readonly HttpClient _client;
public HttpTrigger(IMyService service, IHttpClientFactory httpClientFactory)

{
_service = service;
_client = httpClientFactory.CreateClient();
}
[FunctionName("GetPosts")]
public async Task<IActionResult> Get(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "posts")] HttpRequest req,
ILogger log)
{
var res = await _client.GetAsync("https://microsoft.com");
await _service.AddResponse(res);
return new OkResult();

}
}
}
Tempos de vida do serviço
Azure Functions aplicativos fornecem os mesmos tempos de vida de serviço como injeção de dependência
ASP.net. Para um aplicativo do functions, os tempos de vida de serviço diferentes se comportam da seguinte
maneira:
Transitório: os serviços transitórios são criados após cada solicitação do serviço.
Com escopo: o tempo de vida do serviço com escopo corresponde a um tempo de vida de execução da função.
Os serviços com escopo são criados uma vez por execução. Solicitações posteriores para esse serviço durante a
execução reutilizam a instância de serviço existente.
Singleton: o tempo de vida do serviço singleton corresponde ao tempo de vida do host e é reutilizado nas
execuções de função nessa instância. Os serviços de vida útil singleton são recomendados para conexões e
clientes, por exemplo SqlConnection ou instâncias de HttpClient .
Exiba ou baixe uma amostra de tempos de vida de serviço diferentes no github.
Serviços de log
Se você precisar de seu próprio provedor de log, registre um tipo personalizado como uma instância de
ILoggerProvider . Application Insights é adicionado por Azure Functions automaticamente.
WARNING
Não adicione AddApplicationInsightsTelemetry() à coleção de serviços, pois ela registra os serviços que entram em
conflito com os serviços fornecidos pelo ambiente.
Não Registre seu próprio TelemetryConfiguration ou TelemetryClient se você estiver usando a funcionalidade
interna do Application Insights.
Serviços fornecidos pelo aplicativo de funções

O host de função registra vários serviços. Os seguintes serviços são seguros para serem adotados como uma
dependência em seu aplicativo:
TIPO DE SERVIÇO TEMPO DE VIDA DESCRIÇÃO
único
Microsoft.Extensions.Configuration.IConfiguration Configuração de tempo de execução
único
Microsoft.Azure.WebJobs.Host.Executors.IHostIdProvider Responsável por fornecer a ID da
instância do host
Se houver outros serviços nos quais você deseja assumir uma dependência, crie um problema e proponha-os no
GitHub.
Substituindo serviços de host
Atualmente, não há suporte para a substituição de serviços fornecidos pelo host. Se houver serviços que você
deseja substituir, crie um problema e proponha-os no GitHub.
Trabalhando com opções e configurações

Os valores definidos nas configurações do aplicativo estão disponíveis em uma instância do IConfiguration , que
permite que você leia os valores das configurações do aplicativo na classe de inicialização.
Você pode extrair valores da instância de IConfiguration para um tipo personalizado. Copiar os valores das
configurações do aplicativo para um tipo personalizado torna fácil testar seus serviços, tornando esses valores
injetados. As configurações lidas na instância de configuração devem ser pares de chave/valor simples.
Considere a seguinte classe que inclui uma propriedade chamada consistente com uma configuração de aplicativo.
public class MyOptions

{
public string MyCustomSetting { get; set; }
}
De dentro do método Startup.Configure , você pode extrair valores da instância IConfiguration para seu tipo
personalizado usando o seguinte código:
builder.Services.AddOptions<MyOptions>()
.Configure<IConfiguration>((settings, configuration) =>
{
configuration.Bind(settings);
});
Chamar Bind copia os valores que têm nomes de propriedade correspondentes da configuração na instância
personalizada. A instância de opções agora está disponível no contêiner IoC para injetar em uma função.
O objeto options é injetado na função como uma instância da interface de IOptions genérica. Use a propriedade
Value para acessar os valores encontrados em sua configuração.
using System;
using Microsoft.Extensions.Options;
public class HttpTrigger

{
private readonly MyOptions _settings;
public HttpTrigger(IOptions<MyOptions> options)

{
_settings = options.Value;
}
}
Consulte o padrão de opções em ASP.NET Core para obter mais detalhes sobre como trabalhar com opções.
WARNING
Evite tentar ler valores de arquivos como local. Settings. JSON ou appSettings. { Environment }. JSON no plano de consumo.
Os valores lidos desses arquivos relacionados a conexões de gatilho não estão disponíveis conforme o aplicativo é
dimensionado porque a infraestrutura de hospedagem não tem acesso às informações de configuração.
Próximos passos
Como monitorar seu aplicativo de funções
Práticas recomendadas para funções
Gerenciar conexões no Azure Functions
Funções em um aplicativo de funções compartilham recursos. Entre esses recursos compartilhados estão as
conexões: Conexões HTTP, conexões de banco de dados e conexões com serviços como o armazenamento do
Azure. Quando muitas funções estão em execução simultaneamente, é possível ficar sem conexões
disponíveis. Este artigo explica como codificar suas funções para evitar o uso de mais conexões do que
precisam.
Limite de conexão
O número de conexões disponíveis é limitado parcialmente porque um aplicativo de funções é executado em
um ambiente de área restrita. Uma das restrições que a área de proteção impõe em seu código é um limite no
número de conexões de saída, que são atualmente 600 conexões ativas (total de 1.200) por instância. Quando
você atinge esse limite, o tempo de execução do Functions grava a seguinte mensagem
Host thresholds exceeded: Connections nos logs:. Para obter mais informações, consulte os limites de serviço
do Functions.
Esse limite é por instância. Quando o controlador de escala adiciona instâncias do aplicativo de funções para
lidar com mais solicitações, cada instância tem um limite de conexão independente. Isso significa que não há
nenhum limite de conexão global e você pode ter muito mais do que 600 conexões ativas em todas as
instâncias ativas.
Ao solucionar problemas, certifique-se de ter habilitado Application Insights para seu aplicativo de funções.
Application Insights permite exibir métricas para seus aplicativos de funções, como execuções. Para obter mais
informações, consulte Exibir telemetria no Application insights.
Clientes estáticos
Para evitar manter mais conexões que o necessário, reutilize as instâncias do cliente em vez de criar novas com
cada invocação de função. É recomendável reutilizar conexões de cliente para qualquer idioma em que você
possa escrever sua função. Por exemplo, clientes .net como o HttpClient, oDocumentClient e os clientes de
armazenamento do Azure podem gerenciar conexões se você usar um único cliente estático.
Aqui estão algumas diretrizes a serem seguidas quando você estiver usando um cliente específico do serviço
em um aplicativo Azure Functions:
Não crie um novo cliente com cada invocação de função.
Crie um único cliente estático que cada invocação de função possa usar.
Considere a criação de um único cliente estático em uma classe auxiliar compartilhada se funções
diferentes usarem o mesmo serviço.
Exemplos de código do cliente

Esta seção demonstra as melhores práticas para criar e usar clientes de seu código de função.
Exemplo do HttpClient (C#)
Aqui está um exemplo de C# código de função que cria uma instância HttpClient estática:
// Create a single, static HttpClient
private static HttpClient httpClient = new HttpClient();
public static async Task Run(string input)

{
var response = await httpClient.GetAsync("https://example.com");
// Rest of function
}
Uma pergunta comum sobre o HttpClient no .net é "Devo descartar meu cliente?" Em geral, você descartar
objetos que IDisposable implementam quando você terminar de usá-los. Mas você não descartar um cliente
estático porque não está pronto usando-o quando a função termina. Você quer que o cliente estático
permaneça durante a duração do aplicativo.
Exemplos de agente HTTP (JavaScript)
Como ele fornece melhores opções de gerenciamento de conexão, você deve usar a classe http.agent nativa
em vez de métodos não nativos, como o módulo node-fetch . Os parâmetros de conexão são configurados
http.agent por meio de opções na classe. Para obter opções detalhadas disponíveis com o agente http,
consulte novo agente[(]opções).
A classe http.globalAgent global usada pelo http.request() tem todos esses valores definidos para seus
respectivos padrões. A maneira recomendada de configurar limites de conexão em Funções é definir um
número máximo globalmente. O exemplo a seguir define o número máximo de soquetes para o aplicativo de
função:
http.globalAgent.maxSockets = 200;
O exemplo a seguir cria uma nova solicitação HTTP com um agente HTTP personalizado somente para essa
solicitação:
var http = require('http');

var httpAgent = new http.Agent();
httpAgent.maxSockets = 200;
options.agent = httpAgent;
http.request(options, onResponseCallback);
Exemplo de código DocumentClient (C#)

O DocumentClient conecta uma instância do Azure Cosmos DB. A documentação do Azure Cosmos DB
recomenda que você use um cliente singleton do Azure Cosmos DB pelo tempo de vida do aplicativo. O
exemplo a seguir mostra um padrão para fazer isso em uma função:
#r "Microsoft.Azure.Documents.Client"
using Microsoft.Azure.Documents.Client;
private static Lazy<DocumentClient> lazyClient = new Lazy<DocumentClient>(InitializeDocumentClient);

private static DocumentClient documentClient => lazyClient.Value;
private static DocumentClient InitializeDocumentClient()

{
// Perform any initialization here
var uri = new Uri("example");
var authKey = "authKey";
return new DocumentClient(uri, authKey);

}
public static async Task Run(string input)

{
Uri collectionUri = UriFactory.CreateDocumentCollectionUri("database", "collection");
object document = new { Data = "example" };
await documentClient.UpsertDocumentAsync(collectionUri, document);
// Rest of function
}
Exemplo de código CosmosClient (JavaScript)

CosmosClient conecta-se a uma instância de Azure Cosmos DB. A documentação do Azure Cosmos DB
recomenda que você use um cliente singleton do Azure Cosmos DB pelo tempo de vida do aplicativo. O
exemplo a seguir mostra um padrão para fazer isso em uma função:
const cosmos = require('@azure/cosmos');

const endpoint = process.env.COSMOS_API_URL;
const key = process.env.COSMOS_API_KEY;
const { CosmosClient } = cosmos;
const client = new CosmosClient({ endpoint, key });

// All function invocations also reference the same database and container.
const container = client.database("MyDatabaseName").container("MyContainerName");

const { resources: itemArray } = await container.items.readAll().fetchAll();
context.log(itemArray);
}
Conexões SqlClient
Seu código de função pode usar o .NET Framework Provedor de Dados para SQL Server (SqlClient) para
fazer conexões com um banco de dados relacional do SQL. Esse também é o provedor subjacente para
estruturas de dados que dependem de ADO.NET, como Entity Framework. Ao contrário das conexões
HttpClient e DocumentClient, o ADO.NET implementa o pool de conexões por padrão. Mas como você ainda
pode ficar sem conexões, você deve otimizar as conexões com o banco de dados. Para obter mais informações,
consulte Pool de Conexões do SQL Server (ADO.NET).
TIP
Algumas estruturas de dados, como Entity Framework, normalmente recebem cadeias de conexão da seção
connectionStrings de um arquivo de configuração. Nesse caso, é necessário adicionar explicitamente as cadeias de
conexão de banco de dados SQL à coleção Cadeias de conexão das configurações de aplicativo de funções e no
local.settings.json file no projeto local. Se você estiver criando uma instância de SqlConnection em seu código de função,
deverá armazenar o valor da cadeia de conexão nas configurações do aplicativo com suas outras conexões.
Próximas etapas
Para obter mais informações sobre por que recomendamos clientes estáticos, consulte antipadrão de
instanciação impróprio.
Para obter mais dicas de desempenho do Azure Functions, consulte Melhore o desempenho e a confiabilidade
do Azure Functions.
O tratamento de erros no Azure Functions é importante para evitar perda de dados, eventos perdidos e para
monitorar a integridade do aplicativo.
Este artigo descreve estratégias gerais para tratamento de erros junto com links para erros específicos de
associação.
Tratamento de erros
Os erros gerados em um Azure Functions podem vir de qualquer uma das seguintes origens:
Uso de gatilhos e associações de Azure Functions internos
Chamadas para APIs de serviços subjacentes do Azure
Chamadas para pontos de extremidade REST
Chamadas para bibliotecas de cliente, pacotes ou APIs de terceiros
Seguir as práticas sólidas de tratamento de erros é importante para evitar a perda de dados ou mensagens
perdidas. As práticas recomendadas de tratamento de erros incluem as seguintes ações:
Habilitar Application Insights
Design para Idempotência
Implementar políticas de repetição (quando apropriado)
Capturar e publicar erros é essencial para monitorar a integridade do seu aplicativo. O nível mais alto de
qualquer código de função deve incluir um bloco try/catch. No bloco catch, você pode capturar e publicar erros.
Tentar suporte novamente
Os seguintes gatilhos têm suporte interno de repetição:
Armazenamento de Blobs do Azure
Armazenamento de Filas do Azure
Barramento de Serviço do Azure (fila/tópico)
Por padrão, esses gatilhos retentam solicitações até cinco vezes. Após a quinta repetição, os dois gatilhos gravam
uma mensagem em uma fila suspeita.
Você precisa implementar manualmente as políticas de repetição para quaisquer outros tipos de associações ou
disparadores. Implementações manuais podem incluir a gravação de informações de erro em uma fila de
mensagens suspeitas. Ao gravar em uma fila suspeita, você tem a oportunidade de tentar novamente as
operações mais tarde. Essa abordagem é a mesma usada pelo gatilho do armazenamento de BLOBs.
Códigos de erro de associação

Ao integrar com os serviços do Azure, os erros podem se originar das APIs dos serviços subjacentes.
Informações relacionadas a erros específicos de associação estão disponíveis na seção exceções e códigos de
retorno dos seguintes artigos:
Azure Cosmos DB
Armazenamento de Blobs
Hubs de Evento
Hubs de Notificação
Armazenamento de filas
Barramento de Serviço
Armazenamento de tabelas
Executar manualmente uma função não disparada
por HTTP
Este artigo demonstra como executar manualmente uma função não disparada por HTTP por meio de solicitação
HTTP especialmente formatada.
Em alguns contextos, talvez seja necessário executar "sob demanda" uma Função do Azure disparada
indiretamente. Exemplos de gatilhos indiretos incluem funções em um agendamento ou funções que são
executadas como resultado da ação do outro recurso.
Postman é usado no exemplo a seguir, mas você pode usar cURL, Fiddler ou qualquer outro como a ferramenta
para enviar solicitações HTTP.
Definir a localização da solicitação

Para executar uma função não disparada por HTTP, você precisa de uma forma de enviar uma solicitação ao
Azure para executar a função. A URL usada para fazer essa solicitação usa um formulário específico.
Nome de host: A localização pública do aplicativo de funções que é composta pelo nome do aplicativo de
funções mais azurewebsites.net ou seu domínio personalizado.
Caminho da pasta: Para acessar as funções não disparadas por HTTP por meio de uma solicitação HTTP,
você precisa enviar a solicitação por meio das pastas admin/funções.
Nome da função: O nome da função que você deseja executar.
Você pode usar esta localização de solicitação no Postman, juntamente com a chave mestra da função da
solicitação para o Azure para executar a função.
NOTE
Ao executar localmente, a chave mestra da função não é necessária. É possível chamar a função diretamente omitindo o
cabeçalho x-functions-key .
Obter a chave mestra da função

Navegue até sua função no portal do Azure e clique em Gerenciar e localize a seção Chaves de Host. Clique no
botão Copiar na _master para copiar a chave mestra para a área de transferência.
Depois de copiar a chave mestra, clique no nome da função para retornar à janela de arquivo de código. Em
seguida, clique na guia Logs. Você verá mensagens da função registrada aqui quando executar manualmente a
função do Postman.
Cau t i on
Devido às permissões elevadas no aplicativo de funções concedidas pela chave mestra, você não deve
compartilhar essa chave com terceiros nem distribuí-la em um aplicativo.
Chamar a função
Abra Postman e siga estas etapas:
1. Insira a localização de solicitação na caixa de texto URL.
2. Garanta que o método HTTP seja definido como POST.
3. Clique na guia Cabeçalhos.
4. Insira x-functions-key como a primeira chave e cole a chave mestra (da área de transferência) na caixa
valor.
5. Insira Content-Type como a segunda chave e insira application/json como o valor.
6. Clique na guia Corpo.
7. Insira { "input": "test" } como o corpo da solicitação.
8. Clique em Enviar.
O Postman então relata um status 202 Aceito.
Em seguida, volte à sua função no portal do Azure. Localize a janela Logs e verá mensagens provenientes da
chamada manual para a função.
Próximas etapas
Estratégias para testar seu código no Azure Functions
Depuração local do gatilho da Grade de Eventos do Azure Functions
Você pode usar Azure Functions para implantar o código continuamente usando a integração de controle do
código-fonte. A integração de controle do código-fonte habilita um fluxo de trabalho no qual uma atualização
de código dispara a implantação no Azure. Se você for novo no Azure Functions, comece analisando o Azure
Functions visão geral.
A implantação contínua é uma boa opção para projetos em que você integra contribuições múltiplas e
frequentes. Ao usar a implantação contínua, você mantém uma única fonte de verdade para seu código, o que
permite que as equipes colaborem facilmente. Você pode configurar a implantação contínua no Azure
Functions dos seguintes locais de código-fonte:
Azure Repos
GitHub
Bitbucket
A unidade de implantação para funções no Azure é o aplicativo de funções. Todas as funções em um aplicativo
de funções são implantadas ao mesmo tempo. Depois de habilitar a implantação contínua, o acesso ao código
de função no portal do Azure é configurado como somente leitura porque a fonte de verdade está definida
como em outro lugar.
Requisitos para implantação contínua

Para que a implantação contínua seja realizada com sucesso, sua estrutura de diretório deve ser compatível
com a estrutura de pasta básica que Azure Functions espera.
O código para todas as funções em um aplicativo de funções específico está localizado em uma pasta do
projeto raiz que contém um arquivo de configuração do host e uma ou mais subpastas. Cada subpasta contém
o código para uma função distinta. A estrutura de pastas é mostrada no seguinte representação:
FunctionApp
| - host.json
| - Myfirstfunction
| | - function.json
| | - ...
| | - function.json
| | - ...
| - SharedCode
| - bin
Na versão 2.x do tempo de execução de funções, todas as funções no aplicativo de funções devem
compartilhar a mesma pilha de linguagem.
O host. JSON arquivo contém configurações específicas de tempo de execução e está na pasta raiz do
aplicativo de funções. Um bin pasta contém pacotes e outros arquivos de biblioteca que requer que o
aplicativo de funções. Consulte os requisitos específicos a um idioma para um projeto de aplicativo de função:
Script do C# (.csx)
Script em F#
Java
JavaScript
Configurar a implantação contínua

Para configurar a implantação contínua para um aplicativo de funções existente, conclua estas etapas. As
etapas demonstram a integração com um repositório GitHub, mas etapas semelhantes se aplicam para Azure
Repos ou outros repositórios de código-fonte.
1. Em seu aplicativo de funções no portal do Azure, selecionecentro de implantaçãode recursos > de
plataforma.
2. Na central de implantação, selecione GitHube, em seguida, selecione autorizar. Se você já tiver

autorizado o GitHub, selecione continuar.
3. No GitHub, selecione o botão autorizar AzureAppService .

Na central de implantação no portal do Azure, selecione continuar.
4. Selecione um dos seguintes provedores de compilação:
Serviço de compilação do serviço de aplicativo: Melhor quando você não precisa de uma
compilação ou se precisa de uma compilação genérica.
Azure pipelines (versão prévia) : Melhor quando você precisa de mais controle sobre a
compilação. Este provedor está em visualização no momento.
5. Configure informações específicas para a opção de controle do código-fonte que você especificou. Para
o GitHub, você deve inserir ou selecionar valores para organização, repositórioe ramificação. Os
valores se baseiam no local do seu código. Em seguida, selecione Continuar.
6. Examine todos os detalhes e, em seguida, selecione concluir para concluir a configuração da

implantação.
Quando o processo for concluído, todo o código da origem especificada será implantado em seu aplicativo.
Nesse ponto, as alterações na origem da implantação disparam uma implantação dessas alterações em seu
aplicativo de funções no Azure.
Cenários de implantação
Mover as funções existentes para implantação contínua
Se você já escreveu funções no portal do Azure e deseja baixar o conteúdo do seu aplicativo antes de alternar
para a implantação contínua, vá para a guia visão geral do seu aplicativo de funções. Selecione o botão
baixar conteúdo do aplicativo .
NOTE
Depois de configurar a integração contínua, você não poderá mais editar seus arquivos de origem no portal do
functions.
Próximas etapas
Azure Functions slots de implantação
Azure Functions slots de implantação permitem que seu aplicativo de funções execute diferentes instâncias
chamadas "Slots". Os slots são ambientes diferentes expostos por meio de um ponto de extremidade disponível
publicamente. Uma instância de aplicativo sempre é mapeada para o slot de produção e você pode trocar
instâncias atribuídas a um slot sob demanda. Os aplicativos de funções em execução no plano de serviço de
aplicativos podem ter vários slots, enquanto em consumo apenas um slot é permitido.
O seguinte reflete como as funções são afetadas por slots de permuta:
O redirecionamento de tráfego é contínuo; nenhuma solicitação foi descartada devido a uma troca.
Se uma função estiver em execução durante uma permuta, a execução continuará e os gatilhos subsequentes
serão roteados para a instância do aplicativo trocado.
NOTE
No momento, os slots não estão disponíveis para o plano de consumo do Linux.
Por que usar Slots?

Há várias vantagens em usar slots de implantação. Os cenários a seguir descrevem usos comuns para Slots:
Ambientes diferentes para finalidades diferentes: usar Slots diferentes oferece a oportunidade de
diferenciar instâncias de aplicativo antes de alternar para a produção ou para um slot de preparo.
Preaquecimento: a implantação em um slot em vez de diretamente na produção permite que o aplicativo
fique quente antes de entrar no ar. Além disso, o uso de Slots reduz a latência para cargas de trabalho
disparadas por HTTP. As instâncias são ativadas antes da implantação, o que reduz a inicialização a frio para
funções implantadas recentemente.
Fallbacks fáceis: após uma troca com produção, o slot com um aplicativo previamente preparado agora tem o
aplicativo de produção anterior. Se as alterações trocadas no slot de produção não forem as esperadas, você
poderá reverter a troca imediatamente para obter a "última instância boa conhecida" de volta.
Operações de permuta
Durante uma troca, um slot é considerado a origem e o outro destino. O slot de origem tem a instância do
aplicativo que é aplicada ao slot de destino. As etapas a seguir garantem que o slot de destino não experimente
tempo de inatividade durante uma troca:
1. Aplicar configurações: As configurações do slot de destino são aplicadas a todas as instâncias do slot de
origem. Por exemplo, as configurações de produção são aplicadas à instância de preparo. As configurações
aplicadas incluem as seguintes categorias:
Configurações do aplicativo e cadeias de conexão específicas do slot (se aplicável)
Configurações de implantação contínua (se habilitada)
Configurações de autenticação do serviço de aplicativo (se habilitado)
2. Aguarde as reinicializações e a disponibilidade: A permuta espera que cada instância no slot de origem
conclua sua reinicialização e esteja disponível para solicitações. Se alguma instância não for reiniciada, a
operação de permuta reverterá todas as alterações no slot de origem e interromperá a operação.
3. Roteamento de atualização: Se todas as instâncias no slot de origem forem ativadas com êxito, os dois
slots concluirão a permuta alternando as regras de roteamento. Após essa etapa, o slot de destino (por
exemplo, o slot de produção) tem o aplicativo que foi anteriormente ativado no slot de origem.
4. Repetir operação: Agora que o slot de origem tem o aplicativo de pré-permuta anteriormente no slot de
destino, execute a mesma operação aplicando todas as configurações e reiniciando as instâncias do slot de
origem.
Tenha em mente os seguintes pontos:
Em qualquer ponto da operação de permuta, a inicialização dos aplicativos trocados ocorre no slot de
origem. O slot de destino permanece online enquanto o slot de origem está sendo preparado, se a troca é
bem-sucedida ou falha.
Para trocar um slot de preparo pelo slot de produção, verifique se o slot de produção é sempre o slot de
destino. Dessa forma, a operação de permuta não afeta seu aplicativo de produção.
As configurações relacionadas a origens e associações de eventos precisam ser definidas como
configurações de slot de implantação antes de iniciar uma troca. Marcá-los como "adesivos"
antecipadamente garante que os eventos e as saídas sejam direcionados para a instância apropriada.
Gerenciar configurações
Quando você clona a configuração de outro slot de implantação, a configuração clonada é editável. Alguns
elementos de configuração seguem o conteúdo em uma permuta (não específico do slot), enquanto outros
elementos de configuração permanecem no mesmo slot após uma permuta (específica do slot). As listas a seguir
mostram as configurações que são alteradas quando você permuta os slots.
Configurações que são permutadas:
Configurações gerais, como versão do Framework, 32/64 bits, Web Sockets
Configurações do aplicativo (podem ser configuradas para serem transfixadas em um slot)
Cadeias de conexão (podem ser configuradas para aderir a um slot)
Mapeamentos de manipulador
Certificados públicos
Conteúdo de trabalhos Web
Conexões híbridas *
Integração de rede virtual *
Pontos de extremidade de serviço *
Rede de distribuição de conteúdo do Azure *
Os recursos marcados com um asterisco (*) estão planejados para serem desalternados.
Configurações que não são trocadas:
Pontos de extremidade de publicação
Nomes de domínio personalizados
Certificados não públicos e configurações de TLS/SSL
Configurações de escala
Agendadores de trabalhos Web
Restrições de IP
Sempre Ativo
Configurações do log de diagnóstico
CORS (compartilhamento de recursos entre origens)
NOTE
Determinadas configurações de aplicativo que se aplicam a configurações não alternadas também são trocadas. Por exemplo,
como as configurações de log de diagnóstico não são trocadas, as configurações de aplicativo relacionadas, como
WEBSITE_HTTPLOGGING_RETENTION_DAYS e DIAGNOSTICS_AZUREBLOBRETENTIONDAYS , também não são trocadas, mesmo que
elas não apareçam como configurações de slot.
Criar uma configuração de implantação

Você pode marcar configurações como uma configuração de implantação que o torna "adesivo". Uma
configuração adesiva não alterna com a instância do aplicativo.
Se você criar uma configuração de implantação em um slot, certifique-se de criar a mesma configuração com um
valor exclusivo em qualquer outro slot envolvido em uma troca. Dessa forma, embora o valor de uma configuração
não mude, os nomes de configuração permanecem consistentes entre os slots. Essa consistência de nome garante
que seu código não tente acessar uma configuração definida em um slot, mas não em outra.
Use as etapas a seguir para criar uma configuração de implantação:
Navegue até os Slots no aplicativo de funções
Clique no nome do slot
Em recursos da plataforma > configurações gerais, clique em configuração
Clique no nome da configuração que você deseja colocar com o slot atual
Clique na caixa de seleção configuração do slot de implantação
Clique em OK
Após a definição da folha desaparecer, clique em salvar para manter as alterações
Implantação
Os slots ficam vazios quando você cria um slot. Você pode usar qualquer uma das tecnologias de implantação com
suporte para implantar seu aplicativo em um slot.
Dimensionamento
Todos os slots são dimensionados para o mesmo número de trabalhadores que o slot de produção.
Para planos de consumo, o slot é dimensionado conforme o aplicativo de funções é dimensionado.
Para planos do serviço de aplicativo, o aplicativo é dimensionado para um número fixo de trabalhadores. Os
slots são executados no mesmo número de trabalhadores que o plano do aplicativo.
Adicionar um slot
Você pode adicionar um slot por meio da CLI ou por meio do Portal. As etapas a seguir demonstram como criar
um novo slot no Portal:
1. Navegue até seu aplicativo de funções e clique no sinal de adição ao lado de Slots.
2. Insira um nome na caixa de texto e pressione o botão criar .
Slots de permuta
Você pode trocar os slots por meio da CLI ou por meio do Portal. As etapas a seguir demonstram como trocar
slots no Portal:
1. Navegue até o aplicativo de funções
2. Clique no nome do slot de origem que você deseja alternar
3. Na guia visão geral , clique no botão alternar
4. Verifique os parâmetros de configuração para sua permuta e clique em trocar

A operação pode demorar um pouco enquanto a operação de permuta está em execução.
Reverter uma permuta

Se uma troca resultar em um erro ou se você simplesmente quiser "desfazer" uma troca, poderá reverter para o
estado inicial. Para retornar ao estado de pré-atualização, faça outra troca para reverter a troca.
Remover um slot
Você pode remover um slot por meio da CLI ou por meio do Portal. As etapas a seguir demonstram como
remover um slot no Portal:
1. Navegue até o aplicativo de funções visão geral
2. Clique no botão excluir
Automatizar o gerenciamento de Slots

Usando o CLI do Azure, você pode automatizar as seguintes ações para um slot:
create
delete
list
swap
troca automática
Alterar plano do serviço de aplicativo

Com um aplicativo de funções que está sendo executado em um plano do serviço de aplicativo, você tem a opção
de alterar o plano do serviço de aplicativo subjacente para um slot.
NOTE
Não é possível alterar o plano do serviço de aplicativo de um slot no plano de consumo.
Use as etapas a seguir para alterar o plano do serviço de aplicativo de um slot:

1. Navegar até um slot
2. Em recursos da plataforma, clique em todas as configurações
3. Clique no plano do serviço de aplicativo

4. Selecione um novo plano do serviço de aplicativo ou crie um novo plano
5. Clique em OK
Limitações
Azure Functions slots de implantação têm as seguintes limitações:
O número de slots disponíveis para um aplicativo depende do plano. O plano de consumo só é permitido para
um slot de implantação. Slots adicionais estão disponíveis para aplicativos em execução no plano do serviço de
aplicativo.
A troca de um slot redefine chaves para aplicativos que têm uma configuração de aplicativo
AzureWebJobsSecretStorageType igual a files .
Os slots não estão disponíveis para o plano de consumo do Linux.
Níveis de suporte
Há dois níveis de suporte para slots de implantação:
Versão prévia: ainda não tem suporte, mas é esperado para alcançar o status de GA no futuro.
SISTEMA OPERACIONAL/PLANO DE HOSPEDAGEM NÍVEL DE SUPORTE
Consumo do Windows Disponibilidade Geral
Windows Premium Disponibilidade Geral
Windows dedicado Disponibilidade Geral
Consumo do Linux Sem suporte
Linux Premium Disponibilidade Geral
Linux dedicado Disponibilidade Geral
Próximas etapas
Tecnologias de implantação no Azure Functions
Entrega contínua usando o Azure DevOps
Você pode implantar automaticamente sua função em um aplicativo Azure Functions usando Azure pipelines.
Você tem duas opções para definir seu pipeline:
Arquivo YAML: um arquivo YAML descreve o pipeline. O arquivo pode ter uma seção de etapas de
compilação e uma seção de versão. O arquivo YAML deve estar no mesmo repositório que o aplicativo.
Modelo: modelos são tarefas prontas que criam ou implantam seu aplicativo.
Pipeline baseado em YAML

Para criar um pipeline baseado em YAML, primeiro crie seu aplicativo e, em seguida, implante o aplicativo.
Crie seu aplicativo
A forma como você cria seu aplicativo no Azure Pipelines depende da linguagem de programação do seu
aplicativo. Cada idioma tem etapas de Build específicas que criam um artefato de implantação. Um artefato de
implantação é usado para implantar seu aplicativo de funções no Azure.
.NET
Você pode usar o exemplo a seguir para criar um arquivo YAML para compilar um aplicativo .NET:
pool:
vmImage: 'VS2017-Win2016'
steps:
- script: |
dotnet restore
dotnet build --configuration Release
- task: DotNetCoreCLI@2
inputs:
command: publish
arguments: '--configuration Release --output publish_output'
projects: '*.csproj'
publishWebProjects: false
modifyOutputPath: true
zipAfterPublish: false
- task: ArchiveFiles@2
displayName: "Archive files"
inputs:
rootFolderOrFile: "$(System.DefaultWorkingDirectory)/publish_output"
includeRootFolder: false
archiveFile: "$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip"
- task: PublishBuildArtifacts@1
inputs:
PathtoPublish: '$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip'
name: 'drop'
JavaScript
Você pode usar o exemplo a seguir para criar um arquivo YAML para criar um aplicativo JavaScript:
pool:
vmImage: ubuntu-16.04 # Use 'VS2017-Win2016' if you have Windows native +Node modules
steps:
- bash: |
if [ -f extensions.csproj ]
then
dotnet build extensions.csproj --output ./bin
fi
npm install
npm run build --if-present
npm prune --production
inputs:
rootFolderOrFile: "$(System.DefaultWorkingDirectory)"
inputs:
name: 'drop'
Python
Você pode usar o exemplo a seguir para criar um arquivo YAML para criar um aplicativo Python. O Python tem
suporte apenas para Azure Functions Linux. O YAML para Python 3,7 pode ser criado substituindo todas as
instâncias de 3,6 por 3,7 neste YAML.
pool:
vmImage: ubuntu-16.04
steps:
- task: UsePythonVersion@0
displayName: "Setting python version to 3.6 as required by functions"
inputs:
versionSpec: '3.6'
architecture: 'x64'
- bash: |
if [ -f extensions.csproj ]
then
dotnet build extensions.csproj --output ./bin
fi
python3.6 -m venv worker_venv
source worker_venv/bin/activate
pip3.6 install setuptools
pip3.6 install -r requirements.txt
inputs:
inputs:
name: 'drop'
PowerShell
Você pode usar o exemplo a seguir para criar um arquivo YAML para empacotar um aplicativo PowerShell. O
PowerShell só tem suporte para o Windows Azure Functions.
pool:
vmImage: 'VS2017-Win2016'
steps:
inputs:
inputs:
name: 'drop'
Implantar seu aplicativo

Você deve incluir um dos exemplos de YAML a seguir no arquivo YAML, dependendo do sistema operacional de
hospedagem.
Aplicativo de funções do Windows
Você pode usar o trecho a seguir para implantar um aplicativo de funções do Windows:
steps:
- task: AzureFunctionApp@1
inputs:
azureSubscription: '<Azure service connection>'
appType: functionApp
appName: '<Name of function app>'
#Uncomment the next lines to deploy to a deployment slot
#deployToSlotOrASE: true
#resourceGroupName: '<Resource Group Name>'
#slotName: '<Slot name>'
Aplicativo de funções do Linux

Você pode usar o trecho a seguir para implantar um aplicativo de funções do Linux:
steps:
- task: AzureFunctionApp@1
inputs:
azureSubscription: '<Azure service connection>'
appType: functionAppLinux
appName: '<Name of function app>'
#Uncomment the next lines to deploy to a deployment slot
#Note that deployment slots is not supported for Linux Dynamic SKU
#deployToSlotOrASE: true
#resourceGroupName: '<Resource Group Name>'
#slotName: '<Slot name>'
Pipeline baseado em modelo

Os modelos no Azure DevOps são grupos predefinidos de tarefas que criam ou implantam um aplicativo.
Crie seu aplicativo
A forma como você cria seu aplicativo no Azure Pipelines depende da linguagem de programação do seu
aplicativo. Cada idioma tem etapas de Build específicas que criam um artefato de implantação. Um artefato de
implantação é usado para atualizar seu aplicativo de funções no Azure.
Para usar modelos de compilação internos, ao criar um novo pipeline de compilação, selecione usar o editor
clássico para criar um pipeline usando modelos de designer.
Depois de configurar a origem do seu código, pesquise Azure Functions modelos de compilação. Selecione o
modelo que corresponde ao idioma do aplicativo.
Em alguns casos, os artefatos de compilação têm uma estrutura de pastas específica. Talvez seja necessário
selecionar a caixa de seleção nome da pasta raiz para caminhos de arquivo .
Aplicativos JavaScript
Se seu aplicativo JavaScript tiver uma dependência em módulos nativos do Windows, você deverá atualizar a
versão do pool do agente para o VS2017 hospedado.
Implantar seu aplicativo

Ao criar um novo pipeline de lançamento, pesquise o modelo de versão Azure Functions.
Não há suporte para a implantação em um slot de implantação no modelo de versão.
Criar um pipeline de compilação usando o CLI do Azure

Para criar um pipeline de compilação no Azure, use o comando az functionapp devops-pipeline create . O pipeline
de compilação é criado para compilar e liberar quaisquer alterações de código feitas em seu repositório. O
comando gera um novo arquivo YAML que define o pipeline de compilação e versão e, em seguida, o confirma
para seu repositório. Os pré-requisitos para esse comando dependem do local do seu código.
Se o seu código estiver no GitHub:
Você deve ter permissões de gravação para sua assinatura.
Você deve ser o administrador do projeto no Azure DevOps.
Você deve ter permissões para criar um PAT (token de acesso pessoal) do GitHub que tenha
permissões suficientes. Para obter mais informações, consulte requisitos de permissão do GITHUB
Pat.
Você deve ter permissões para confirmar o Branch mestre em seu repositório do GitHub, para que
você possa confirmar o arquivo YAML gerado automaticamente.
Se seu código estiver em Azure Repos:
Você deve ter permissões de gravação para sua assinatura.
Você deve ser o administrador do projeto no Azure DevOps.
Próximos passos
Examine a Azure Functions visão geral.
Examine a visão geral do Azure DevOps.
Entrega contínua usando a ação do GitHub
As ações do GitHub permitem definir um fluxo de trabalho para criar e implantar automaticamente o código de
funções no aplicativo de funções no Azure.
IMPORTANT
No momento, as ações do GitHub estão em beta. Primeiro, você deve se inscrever para ingressar na versão prévia usando
sua conta do github.
Em ações do GitHub, um fluxo de trabalho é um processo automatizado que você define em seu repositório github.
Esse processo informa ao GitHub como criar e implantar seu projeto de aplicativo do Functions no GitHub.
Um fluxo de trabalho é definido por um arquivo YAML (. yml) no caminho /.github/workflows/ em seu
repositório. Essa definição contém as várias etapas e parâmetros que compõem o fluxo de trabalho.
Para um fluxo de trabalho Azure Functions, o arquivo tem três seções:
SECTION TAREFAS
Autenticação 1. Defina uma entidade de serviço.

2. Baixar o perfil de publicação.
3. Crie um segredo do GitHub.
Compilar 1. Configure o ambiente.

2. Compile o aplicativo de funções.
Implantar 1. Implante o aplicativo de funções.
Criar uma entidade de serviço

Você pode criar uma entidade de serviço usando o comando AZ ad SP Create-for-RBAC na CLI do Azure. Você
pode executar esse comando usando Azure cloud Shell na portal do Azure ou selecionando o botão experimentar
.
az ad sp create-for-rbac --name "myApp" --role contributor --scopes

/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Web/sites/<APP_NAME> --
sdk-auth
Neste exemplo, substitua os espaços reservados no recurso por sua ID de assinatura, grupo de recursos e nome do
aplicativo de funções. A saída são as credenciais de atribuição de função que fornecem acesso ao seu aplicativo de
funções. Copie esse objeto JSON, que você pode usar para autenticar do GitHub.
NOTE
Você não precisará criar uma entidade de serviço se decidir usar o perfil de publicação para autenticação.
IMPORTANT
É sempre uma boa prática conceder acesso mínimo. É por isso que o escopo no exemplo anterior é limitado ao aplicativo de
funções específico e não ao grupo de recursos inteiro.
Baixar o perfil de publicação

Você pode baixar o perfil de publicação de seu functionapp, acessando a página visão geral do seu aplicativo e
clicando em obter perfil de publicação.
Copie o conteúdo do arquivo.
Configurar o segredo do GitHub

1. No GitHub, procure seu repositório, selecione configurações > segredos > Adicionar um novo segredo.
2. Use AZURE_CREDENTIALS para o nome e a saída do comando copiado para valor, se você selecionar
Adicionar segredo. Se você estiver usando o perfil de publicação, use SCM_CREDENTIALS para o nome e o
conteúdo do arquivo para valor.
O GitHub agora pode se autenticar no seu aplicativo de funções no Azure.
Configurar o ambiente
A configuração do ambiente pode ser feita usando uma das ações de instalação de publicação.
IDIOMA AÇÃO DE INSTALAÇÃO
.NET actions/setup-dotnet
Java actions/setup-java
JavaScript actions/setup-node
Python actions/setup-python
Os exemplos a seguir mostram a parte do fluxo de trabalho que configura o ambiente para os vários idiomas com
suporte:
JavaScript
- name: 'Login via Azure CLI'

uses: Azure/actions/login@master
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Setup Node 10.x
uses: actions/setup-node@v1
with:
node-version: '10.x'
Python

with:
- name: Setup Python 3.6
uses: actions/setup-python@v1
with:
python-version: 3.6
.NET

with:
- name: Setup Dotnet 2.2.300
uses: actions/setup-dotnet@v1
with:
dotnet-version: '2.2.300'
Java
with:
- name: Setup Java 1.8.x
uses: actions/setup-java@v1
with:
# If your pom.xml <maven.compiler.source> version is not in 1.8.x
# Please change the Java version to match the version in pom.xml <maven.compiler.source>
java-version: '1.8.x'
Compilar o aplicativo de funções

Isso depende do idioma e dos idiomas com suporte pelo Azure Functions, esta seção deve ser as etapas de
compilação padrão de cada idioma.
Os exemplos a seguir mostram a parte do fluxo de trabalho que cria o aplicativo de funções em vários idiomas
com suporte.:
JavaScript
- name: 'Run npm'

shell: bash
run: |
# If your function app project is not located in your repository's root
# Please change your directory for npm in pushd
pushd .
npm install
npm run build --if-present
npm run test --if-present
popd
Python
- name: 'Run pip'

shell: bash
run: |
# Please change your directory for pip in pushd
pushd .
python -m pip install --upgrade pip
pip install -r requirements.txt --target=".python_packages/lib/python3.6/site-packages"
popd
.NET
- name: 'Run dotnet build'

shell: bash
run: |
# Please consider using pushd to change your path
pushd .
dotnet build --configuration Release --output ./output
popd
Java
- name: 'Run mvn'
shell: bash
run: |
# Please change your directory for maven build in pushd
pushd . ./POM_ARTIFACT_ID
mvn clean package
mvn azure-functions:package
popd
Implantar o aplicativo de funções

Para implantar seu código em um aplicativo de funções, será necessário usar a ação Azure/functions-action . Esta
ação tem dois parâmetros:
PARÂMETRO EXPLICAÇÃO
nome do aplicativo Obrigatório O nome do seu aplicativo de funções.
nome do slot Adicional O nome do slot de implantação no qual você deseja

implantar. O slot já deve estar definido em seu aplicativo de
funções.
O exemplo a seguir usa a versão 1 do functions-action :
- name: 'Run Azure Functions Action'

uses: Azure/functions-action@v1
id: fa
with:
app-name: PLEASE_REPLACE_THIS_WITH_YOUR_FUNCTION_APP_NAME
Próximas etapas
Para exibir um Workflow. YAML completo, consulte um dos arquivos no repositório de exemplos de fluxo de
trabalho de ações do Azure GitHub que têm functionapp no nome. Você pode usar esses exemplos em um ponto
de partida para seu fluxo de trabalho.
Saiba mais sobre as ações do GitHub
Implantação de zip para o Azure Functions
Este artigo descreve como implantar seus arquivos de projeto de aplicativo de função para o Azure de um
arquivo .zip (compactado). Você aprenderá a realizar uma implantação de envio por push, usando a CLI do Azure
e usando as APIs REST. As Ferramentas básicas do Azure Functions também usam essas APIs de implantação
ao publicar um projeto local no Azure.
O Azure Functions tem a gama completa de opções de implantação e integração contínuas que são fornecidas
pelo Serviço de Aplicativo do Azure. Para saber mais, confira Implantação contínua do Azure Functions.
Para acelerar o desenvolvimento, talvez você ache mais fácil implantar seus arquivos de projeto do aplicativo de
funções diretamente de um arquivo .zip. A API de implantação do .zip extrai o conteúdo de um arquivo .zip para a
pasta wwwroot do seu aplicativo de funções. Essa implantação de arquivo .zip usa o mesmo serviço Kudu que
alimenta implementações baseadas em integração contínua, incluindo:
Exclusão de arquivos que foram mantidos de implantações anteriores.
Personalização da implantação, incluindo execução de scripts de implantação.
Logs de implantação.
Gatilhos de função de sincronização em um aplicativo de funções de Plano de consumo.
Para obter mais informações, consulte a referência de implantação do .zip.
Requisitos de implantação de arquivo .zip

O arquivo .zip que você usa para a implantação de push precisa conter todos os arquivos necessários para
executar sua função.
IMPORTANT
Quando você usa a implantação de .zip, todos os arquivos de uma implantação existente que não são encontrados no
arquivo .zip são excluídos do seu aplicativo de funções.
O código para todas as funções em um aplicativo de funções específico está localizado em uma pasta do projeto
raiz que contém um arquivo de configuração do host e uma ou mais subpastas. Cada subpasta contém o código
para uma função distinta. A estrutura de pastas é mostrada no seguinte representação:
FunctionApp
| - host.json
| - Myfirstfunction
| | - function.json
| | - ...
| | - function.json
| | - ...
| - SharedCode
| - bin
Na versão 2.x do tempo de execução de funções, todas as funções no aplicativo de funções devem compartilhar a
mesma pilha de linguagem.
O host. JSON arquivo contém configurações específicas de tempo de execução e está na pasta raiz do aplicativo
de funções. Um bin pasta contém pacotes e outros arquivos de biblioteca que requer que o aplicativo de funções.
Consulte os requisitos específicos a um idioma para um projeto de aplicativo de função:
Script do C# (.csx)
Script em F#
Java
JavaScript
Um aplicativo de funções contém todos os arquivos e pastas no diretório wwwroot . Uma implantação de arquivo.
zip inclui o conteúdo do diretório wwwroot , mas não o diretório em si. Ao implantar um projeto de biblioteca de
classes C#, você deve incluir os arquivos de biblioteca compilados e as dependências em uma subpasta bin em
seu pacote .zip.
Baixe seus arquivos de aplicativo de funções

Quando você estiver desenvolvendo em um computador local, é fácil criar um arquivo .zip da pasta do projeto de
aplicativo de funções no computador de desenvolvimento.
No entanto, você pode ter criado as suas funções usando o editor no Portal do Azure. Você pode baixar um
projeto de aplicativo de funções existente de uma das seguintes maneiras:
No Portal do Azure:
1. Conecte-se no Portal do Azure e, em seguida, vá para o seu aplicativo de funções.
2. Na guia Visão Geral, selecione Baixar conteúdo do aplicativo. Selecione as opções de
download e, em seguida, selecione Baixar.
O arquivo .zip baixado está no formato correto para ser republicado no seu aplicativo de funções
usando a implantação por push do .zip. O download do portal também pode adicionar os arquivos
necessários para abrir o aplicativo de funções diretamente no Visual Studio.
Usando APIs REST:
Use a seguinte API GET de implantação para baixar os arquivos de seu projeto <function_app> :
https://<function_app>.scm.azurewebsites.net/api/zip/site/wwwroot/
Incluir /site/wwwroot/ assegura que o arquivo zip inclua somente os arquivos de projeto do aplicativo de
funções e não todo o site. Se ainda não tiver se conectado ao Azure, será solicitado que você faça isso.
Você também pode baixar um arquivo .zip de um repositório do GitHub. Quando você baixa um repositório
GitHub como um arquivo .zip, o GitHub adiciona um nível extra de pasta para o branch. Esse nível extra de pasta
significa que você não pode implantar o arquivo .zip diretamente como baixou do GitHub. Se você estiver usando
um repositório GitHub para manter seu aplicativo de funções, você deve usar a integração contínua para
implantar seu aplicativo.
Implantar usando a CLI do Azure

Você pode usar a CLI do Azure para disparar uma implantação de envio por push. Implante o arquivo .zip em seu
aplicativo de funções usando o comando az functionapp deployment source config-zip. Para usar esse comando,
você deve usar a CLI do Azure versão 2.0.21 ou posterior. Para ver qual versão do CLI do Azure que você está
usando, use o comando az --version .
No comando a seguir, substitua o espaço reservado <zip_file_path> pelo caminho para o local do seu arquivo
.zip. Além disso, substitua <app_name> com o nome exclusivo do seu aplicativo de funções.
az functionapp deployment source config-zip -g myResourceGroup -n \

<app_name> --src <zip_file_path>
Esse comando implanta os arquivos de projeto do arquivo .zip baixado para seu aplicativo de funções no Azure.
Em seguida, ele reinicia o aplicativo. Para visualizar a lista de implantações para o aplicativo, é necessário usar as
APIs REST.
Quando você estiver usando a CLI do Azure em seu computador local, <zip_file_path> é o caminho para o
arquivo .zip em seu computador. Você também pode executar a CLI do Azure no Azure Cloud Shell. Quando
você usa o Cloud Shell, você deve primeiro carregar seu arquivo .zip de implantação para a conta do Azure Files
associada com o seu Cloud Shell. Nesse caso, <zip_file_path> é o local de armazenamento que a sua conta do
Cloud Shell usa. Para obter mais informações, consulte Persistir arquivos no Azure Cloud Shell.
Implantar o arquivo ZIP com APIs REST

Você pode usar as APIs REST do serviço de implantação para implantar o arquivo .zip ao seu aplicativo no Azure.
Para implantá-lo, envie uma solicitação POST para https://<app_name>.scm.azurewebsites.net/api/zipdeploy. A
solicitação POST deve conter o arquivo .zip no corpo da mensagem. As credenciais de implantação para seu
aplicativo são fornecidas na solicitação usando a autenticação BÁSICA HTTP. Para obter mais informações,
consulte a referência de implantação por push do .zip.
Para a autenticação HTTP BÁSICA, você precisa das credenciais de implantação do Serviço de Aplicativo. Para
ver como definir as credenciais de implantação, consulte Definir e redefinir as credenciais de usuário.
Com o cURL
O exemplo a seguir usa a ferramenta cURL para implantar um arquivo .zip. Substitua os espaços reservados
<username> , <password> , <zip_file_path> e <app_name> . Quando solicitado pelo cURL, digite a senha.
curl -X POST -u <deployment_user> --data-binary @"<zip_file_path>"

https://<app_name>.scm.azurewebsites.net/api/zipdeploy
Essa solicitação dispara a implantação de envio do arquivo .zip carregado. Você pode examinar as implantações
atuais e anteriores, usando o ponto de extremidade https://<app_name>.scm.azurewebsites.net/api/deployments ,
conforme mostrado no exemplo de cURL a seguir. Novamente, substitua <app_name> com o nome do seu
aplicativo e <deployment_user> com o nome de usuário de suas credenciais de implantação.
curl -u <deployment_user> https://<app_name>.scm.azurewebsites.net/api/deployments

Com o PowerShell
O exemplo a seguir usa Publish-AzWebapp para carregar o arquivo. zip. Substitua os espaços reservados
<group-name> , <app-name> e <zip-file-path> .
Publish-AzWebapp -ResourceGroupName <group-name> -Name <app-name> -ArchivePath <zip-file-path>
Essa solicitação dispara a implantação de envio do arquivo .zip carregado.

Para examinar as implantações atuais e anteriores, execute os comandos a seguir. Novamente, substitua os
<deployment-user> espaços <deployment-password> reservados, <app-name> e.
$username = "<deployment-user>"
$password = "<deployment-password>"
$apiUrl = "https://<app-name>.scm.azurewebsites.net/api/deployments"
$base64AuthInfo = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1}" -f $username,
$password)))
$userAgent = "powershell/1.0"
Invoke-RestMethod -Uri $apiUrl -Headers @{Authorization=("Basic {0}" -f $base64AuthInfo)} -UserAgent
$userAgent -Method GET
Executar funções do pacote de implantação

Você também pode optar por executar suas funções diretamente do arquivo do pacote de implantação. Este
método ignora a etapa de implantação de copiar os arquivos do pacote para o diretório wwwroot de seu
aplicativo de funções. Em vez disso, o arquivo de pacote é montado pelo tempo de execução do Azure Functions
e o conteúdo do diretório wwwroot se torna somente leitura.
A implantação de zip integra-se com esse recurso, que você pode habilitar definindo a configuração do aplicativo
de funções WEBSITE_RUN_FROM_PACKAGE com um valor de 1 . Para obter mais informações, veja Executar suas
funções de um arquivo de pacote de implantação.
Personalização da implantação
O processo de implantação presume que o arquivo .zip em que você efetua push contém um aplicativo pronto
para execução. Por padrão, nenhuma personalização é executada. Para habilitar os mesmos processos de
compilação que você obtém com a integração contínua, adicione o seguinte para as configurações do aplicativo:
SCM_DO_BUILD_DURING_DEPLOYMENT=true
Quando você usar a implantação por push do .zip, essa configuração é falsa por padrão. O padrão é verdadeiro
para implantações de integração contínua. Quando definido como verdadeiras, as configurações de implantação
são usadas durante a implantação. Você pode configurar essas configurações como configurações de aplicativo
ou em um arquivo de configuração de .deployment localizado na raiz do seu arquivo .zip. Para obter mais
informações, consulte Repositório e configurações relacionadas à implantação na referência de implantação.
Próximas etapas
Executar o Azure Functions de um arquivo de
pacote
No Azure, você pode executar suas funções diretamente de um arquivo de pacote de implantação no
aplicativo de funções. A outra opção é implantar os arquivos no diretório d:\home\site\wwwroot do
Este artigo descreve os benefícios de executar suas funções de um pacote. Ele também mostra como
habilitar essa funcionalidade em seu aplicativo de funções.
IMPORTANT
Ao implantar suas funções em um aplicativo de funções do Linux em um plano Premium, você deve sempre executar
a partir do arquivo de pacote e publicar seu aplicativo usando o Azure Functions Core Tools.
Benefícios da execução de um arquivo de pacote

Há vários benefícios na execução de um arquivo de pacote:
Reduz o risco de problemas de bloqueio de cópia de arquivo.
Pode ser implantado em um aplicativo de produção (com reinicialização).
Você pode ter certeza dos arquivos que estão em execução no seu aplicativo.
Melhora o desempenho das implantações do Azure Resource Manager.
Pode reduzir os tempos de inicialização a frio, particularmente para as funções de JavaScript com
árvores de pacote npm grandes.
Para saber mais, veja este comunicado.
Habilitando as funções para execução de um pacote

Para habilitar seu aplicativo de funções para execução de um pacote, basta adicionar a configuração
WEBSITE_RUN_FROM_PACKAGE às configurações do aplicativo de funções. A configuração
WEBSITE_RUN_FROM_PACKAGE pode ter um dos seguintes valores:
VALUE DESCRIÇÃO
1 Recomendado para aplicativos de funções em execução no

Windows. Execute de um arquivo de pacote na pasta
d:\home\data\SitePackages do seu aplicativo de
funções. Se não estiver implantando com a implantação de
zip, essa opção exigirá que a pasta também tenha um
arquivo chamado packagename.txt . Esse arquivo
contém apenas o nome do arquivo de pacote na pasta,
sem espaços em branco.
VALUE DESCRIÇÃO
<URL> Localização de um arquivo de pacote específico que você

deseja executar. Ao usar o armazenamento de Blobs, você
deve usar um contêiner privado com uma SAS (Assinatura
de Acesso Compartilhado) para habilitar o tempo de
execução do Functions para acessar o pacote. Você pode
usar o Gerenciador de Armazenamento do Azure para
carregar arquivos de pacote para sua conta de
armazenamento de Blobs. Ao especificar uma URL, você
também deve sincronizar gatilhos depois de publicar um
pacote atualizado.
Cau t i on
Ao executar um aplicativo de funções no Windows, a opção de URL externa gera um pior desempenho de
inicialização a frio. Ao implantar seu aplicativo de funções no Windows, você deve definir
WEBSITE_RUN_FROM_PACKAGE para 1 e publicar com a implantação do zip.
O exemplo a seguir mostra um aplicativo de funções configurado para ser executado de um arquivo .zip
hospedado no armazenamento de Blobs do Azure:
NOTE
No momento, apenas arquivos de pacote .zip têm suporte.
Integração com a implantação do zip

A implantação de zip é um recurso do serviço de Azure app que permite que você implante seu projeto de
aplicativo de funções no diretório wwwroot . O projeto é empacotado como um arquivo de implantação .zip.
As mesmas APIs podem ser usadas para implantar seu pacote na pasta d:\home\data\SitePackages . Com o
valor de configuração de aplicativo WEBSITE_RUN_FROM_PACKAGE de 1 , as APIs de implantação zip copiam seu
pacote para a pasta d:\home\data\SitePackages em vez de extrair os arquivos para d:\home\site\wwwroot .
Ele também cria o arquivo packagename.txt . Após uma reinicialização, o pacote é montado em wwwroot
como um sistema de arquivos somente leitura. Para obter mais informações sobre a implantação do zip,
consulte Implantação de zip para o Azure Functions.
Adicionando a configuração WEBSITE_RUN_FROM_PACKAGE

No portal do Azure.
Solução de Problemas
Executar do pacote torna wwwroot somente leitura, portanto, você receberá um erro ao gravar arquivos
nesse diretório.
Não há suporte para formatos tar e gzip.
Esse recurso não compõe o cache local.
Para obter um desempenho de inicialização a frio aprimorado, use a opção de zip local (
WEBSITE_RUN_FROM_PACKAGE = 1 ).
Próximos passos
Automatizar a implantação de recursos para seu
aplicativo de funções do Azure Functions
Você pode usar um modelo do Azure Resource Manager para implantar um aplicativo de funções. Este artigo
descreve os recursos e os parâmetros necessários para fazer isso. Talvez seja necessário implantar recursos
adicionais, dependendo dos gatilhos e associações em seu aplicativo de funções.
Para saber mais sobre a criação de modelos, consulte Criação de modelos do Azure Resource Manager.
Para modelos de exemplo, consulte:
Aplicativo de funções no Plano de Consumo
Aplicativo de funções no Plano do Serviço de Aplicativo do Azure
Recursos necessários
Uma implantação Azure Functions normalmente consiste nesses recursos:
REFERÊNCIA DE SINTAXE E
RECURSO REQUISITO PROPRIEDADES
Um aplicativo de funções Obrigatório Microsoft.Web/sites
Uma conta de Obrigatório Microsoft.Storage/storageAc

Armazenamento do Azure counts
Um componente Application Opcional Microsoft.

insights insights/Components
Um plano de hospedagem Opcional1 Microsoft.Web/serverfarms
1 Um plano de hospedagem só é necessário quando você opta por executar seu aplicativo de funções em um
plano Premium (em versão prévia) ou em um plano do serviço de aplicativo.
TIP
Embora não seja necessário, é altamente recomendável que você configure Application Insights para seu aplicativo.
Conta de armazenamento
Uma conta de armazenamento do Azure é necessária para um aplicativo de funções. Você precisa de uma conta
de finalidade geral que dá suporte a blobs, tabelas, consultas e arquivos. Para saber mais, confira Requisitos da
conta de armazenamento do Azure Functions.
{
"type": "Microsoft.Storage/storageAccounts",
"name": "[variables('storageAccountName')]",
"apiVersion": "2019-04-01",
"location": "[resourceGroup().location]",
"kind": "StorageV2",
"sku": {
"name": "[parameters('storageAccountType')]"
}
}
Além disso, a propriedade AzureWebJobsStorage deve ser especificada como uma configuração de aplicativo na
configuração do site. Se o aplicativo de função não usar o Application Insights para monitoramento, também
deverá especificar AzureWebJobsDashboard como uma configuração de aplicativo.
O tempo de execução do Azure Functions usa a cadeia de conexão AzureWebJobsStorage para criar filas internas.
Quando o Application Insights não estiver habilitado, o tempo de execução usará a cadeia de conexão
AzureWebJobsDashboard para fazer logon no armazenamento de Tabela do Azure e capacitar a guia Monitor no
portal.
Essas propriedades são especificadas na coleção appSettings no objeto siteConfig :
"appSettings": [
{
"name": "AzureWebJobsStorage",
"value": "[concat('DefaultEndpointsProtocol=https;AccountName=', variables('storageAccountName'),
';AccountKey=', listKeys(variables('storageAccountid'),'2015-05-01-preview').key1)]"
},
{
"name": "AzureWebJobsDashboard",
"value": "[concat('DefaultEndpointsProtocol=https;AccountName=', variables('storageAccountName'),
';AccountKey=', listKeys(variables('storageAccountid'),'2015-05-01-preview').key1)]"
}
]
Application Insights é recomendado para monitorar seus aplicativos de funções. O recurso Application Insights é
definido com o tipo Microsoft. insights/Components e o tipo Web:
{
"apiVersion": "2015-05-01",
"name": "[variables('appInsightsName')]",
"type": "Microsoft.Insights/components",
"kind": "web",
"tags": {
"[concat('hidden-link:', resourceGroup().id, '/providers/Microsoft.Web/sites/',
variables('functionAppName'))]": "Resource"
},
"properties": {
"Application_Type": "web",
"ApplicationId": "[variables('functionAppName')]"
}
},
Além disso, a chave de instrumentação precisa ser fornecida ao aplicativo de funções usando a configuração de
aplicativo APPINSIGHTS_INSTRUMENTATIONKEY . Essa propriedade é especificada na coleção appSettings no objeto
siteConfig :
"appSettings": [
{
"name": "APPINSIGHTS_INSTRUMENTATIONKEY",
"value": "[reference(resourceId('microsoft.insights/components/', variables('appInsightsName')),
'2015-05-01').InstrumentationKey]"
}
]
Plano de hospedagem
A definição do plano de hospedagem varia e pode ser uma das seguintes:
Plano de consumo (padrão)
Plano Premium (em versão prévia)
Plano do Serviço de Aplicativo
Aplicativo de funções
O recurso de aplicativo de funções é definido usando um recurso do tipo Microsoft. Web/sites e o tipo
functionapp:
{
"apiVersion": "2015-08-01",
"type": "Microsoft.Web/sites",
"name": "[variables('functionAppName')]",
"kind": "functionapp",
"dependsOn": [
"[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]",
"[resourceId('Microsoft.Insights/components', variables('appInsightsName'))]"
]
IMPORTANT
Se você estiver definindo explicitamente um plano de hospedagem, um item adicional será necessário na matriz de
dependências: "[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]"
Um aplicativo de funções deve incluir estas configurações de aplicativo:
NOME DA CONFIGURAÇÃO DESCRIÇÃO VALORES DE EXEMPLO
AzureWebJobsStorage Uma cadeia de conexão para uma conta Consulte a conta de armazenamento
de armazenamento que o tempo de
execução do Functions para a fila
interna
FUNCTIONS_EXTENSION_VERSION A versão do Azure Functions Runtime ~2
FUNCTIONS_WORKER_RUNTIME A pilha de idiomas a ser usada para dotnet , node , java ou python
funções neste aplicativo
WEBSITE_NODE_DEFAULT_VERSION Necessário apenas se estiver usando a 10.14.1

pilha de idiomas node , especifica a
versão a ser usada
Essas propriedades são especificadas na coleção appSettings na propriedade siteConfig :

"properties": {
"siteConfig": {
"appSettings": [
{
"value": "[concat('DefaultEndpointsProtocol=https;AccountName=',
variables('storageAccountName'), ';AccountKey=', listKeys(variables('storageAccountid'),'2015-05-01-
preview').key1)]"
},
{
"name": "FUNCTIONS_WORKER_RUNTIME",
"value": "node"
},
{
"name": "WEBSITE_NODE_DEFAULT_VERSION",
"value": "10.14.1"
},
{
"name": "FUNCTIONS_EXTENSION_VERSION",
"value": "~2"
}
]
}
}
Implantar no plano de consumo

O plano de Consumo automaticamente aloca potência de computação quando seu código está em execução,
escala horizontalmente conforme a necessidade para tratar da carga e reduz verticalmente quando o código não
está em execução. Você não precisa pagar por VMs ociosas e não precisa reservar a capacidade com antecedência.
Para saber mais, confira Escala e hospedagem do Azure Functions.
Para um exemplo de modelo do Azure Resource Manager, consulte Aplicativo de funções no Plano de Consumo.
Criar um Plano de Consumo
Um plano de consumo não precisa ser definido. Uma será criada automaticamente ou selecionada em uma base
por região quando você criar o recurso do aplicativo de funções em si.
O plano de consumo é um tipo especial de recurso "ServerFarm". Para o Windows, você pode especificá-lo
usando o valor Dynamic para as propriedades computeMode e sku :
{
"type":"Microsoft.Web/serverfarms",
"apiVersion":"2016-09-01",
"name":"[variables('hostingPlanName')]",
"location":"[resourceGroup().location]",
"properties":{
"name":"[variables('hostingPlanName')]",
"computeMode":"Dynamic"
},
"sku":{
"name":"Y1",
"tier":"Dynamic",
"size":"Y1",
"family":"Y",
"capacity":0
}
}
NOTE
O plano de consumo não pode ser explicitamente definido para Linux. Ele será criado automaticamente.
Se você definir explicitamente seu plano de consumo, será necessário definir a propriedade serverFarmId no
aplicativo para que ele aponte para a ID de recurso do plano. Você deve garantir que o aplicativo de funções
também tenha uma configuração dependsOn para o plano.
Windows
No Windows, um plano de consumo requer duas configurações adicionais na configuração do site:
WEBSITE_CONTENTAZUREFILECONNECTIONSTRING e WEBSITE_CONTENTSHARE . Essas propriedades configuram a conta de
armazenamento e o caminho do arquivo em que o código e as configurações do aplicativo de funções estão
armazenados.
{
"apiVersion": "2016-03-01",
"dependsOn": [
"[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]"
],
"properties": {
"siteConfig": {
"appSettings": [
{
preview').key1)]"
},
{
"name": "WEBSITE_CONTENTAZUREFILECONNECTIONSTRING",
preview').key1)]"
},
{
"name": "WEBSITE_CONTENTSHARE",
"value": "[toLower(variables('functionAppName'))]"
},
{
"value": "node"
},
{
"value": "10.14.1"
},
{
"value": "~2"
}
]
}
}
}
Linux
No Linux, o aplicativo de funções deve ter seu kind definido como functionapp,linux e deve ter a propriedade
reserved definida como true :
{
"apiVersion": "2016-03-01",
"kind": "functionapp,linux",
"dependsOn": [
],
"properties": {
"siteConfig": {
"appSettings": [
{
variables('storageAccountName'), ';AccountKey=', listKeys(variables('storageAccountName'),'2015-05-01-
preview').key1)]"
},
{
"value": "node"
},
{
"value": "10.14.1"
},
{
"value": "~2"
}
]
},
"reserved": true
}
}
Implantar no plano Premium

O plano Premium oferece o mesmo dimensionamento do plano de consumo, mas inclui recursos dedicados e
recursos adicionais. Para saber mais, confira Azure Functions plano Premium.
Um plano Premium é um tipo especial de recurso "ServerFarm". Você pode especificá-lo usando EP1 , EP2 ou
EP3 para o valor da propriedade sku .
{
"type": "Microsoft.Web/serverfarms",
"apiVersion": "2015-04-01",
"name": "[variables('hostingPlanName')]",
"properties": {
"sku": "EP1"
}
}

Um aplicativo de funções em um plano Premium deve ter a propriedade serverFarmId definida como a ID de
recurso do plano criado anteriormente. Além disso, um plano Premium requer duas configurações adicionais na
configuração do site: WEBSITE_CONTENTAZUREFILECONNECTIONSTRING e WEBSITE_CONTENTSHARE . Essas propriedades
configuram a conta de armazenamento e o caminho do arquivo em que o código e as configurações do aplicativo
de funções estão armazenados.
{
"apiVersion": "2016-03-01",
"dependsOn": [
"[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]",
],
"properties": {
"serverFarmId": "[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]",
"siteConfig": {
"appSettings": [
{
preview').key1)]"
},
{
"name": "WEBSITE_CONTENTAZUREFILECONNECTIONSTRING",
preview').key1)]"
},
{
"name": "WEBSITE_CONTENTSHARE",
"value": "[toLower(variables('functionAppName'))]"
},
{
"value": "node"
},
{
"value": "10.14.1"
},
{
"value": "~2"
}
]
}
}
}
Implantar no plano do serviço de aplicativo

No Plano do Serviço de Aplicativo, seus aplicativos de funções são executados em VMs dedicadas, em SKUs
Basic, Standard e Premium, assim como os aplicativos Web. Para obter detalhes sobre como o plano do Serviço
de Aplicativo funciona, consulte Visão geral detalhada de planos de Serviço de Aplicativo do Azure.
Para um exemplo de modelo do Azure Resource Manager, consulte Aplicativo de funções no Plano do Serviço de
Aplicativo do Azure.
Criar um plano de Serviço de Aplicativo
Um plano do serviço de aplicativo é definido por um recurso "ServerFarm".
{
"apiVersion": "2018-02-01",
"sku": {
"name": "S1",
"tier": "Standard",
"size": "S1",
"family": "S",
"capacity": 1
}
}
Para executar seu aplicativo no Linux, você também deve definir o kind como Linux :
{
"apiVersion": "2018-02-01",
"kind": "Linux",
"sku": {
"name": "S1",
"tier": "Standard",
"size": "S1",
"family": "S",
"capacity": 1
}
}

Um aplicativo de funções em um plano do serviço de aplicativo deve ter a propriedade serverFarmId definida
como a ID de recurso do plano criado anteriormente.
{
"apiVersion": "2016-03-01",
"dependsOn": [
],
"properties": {
"siteConfig": {
"appSettings": [
{
preview').key1)]"
},
{
"value": "node"
},
{
"value": "10.14.1"
},
{
"value": "~2"
}
]
}
}
}
Os aplicativos do Linux também devem incluir uma propriedade linuxFxVersion em siteConfig . Se você estiver
apenas implantando o código, o valor para isso será determinado pela pilha de tempo de execução desejada:
SOBREPOSTA VALOR DE EXEMPLO
Python DOCKER|microsoft/azure-functions-python3.6:2.0
JavaScript DOCKER|microsoft/azure-functions-node8:2.0
.NET DOCKER|microsoft/azure-functions-dotnet-core2.0:2.0
{
"apiVersion": "2016-03-01",
"dependsOn": [
],
"properties": {
"siteConfig": {
"appSettings": [
{
preview').key1)]"
},
{
"value": "node"
},
{
"value": "10.14.1"
},
{
"value": "~2"
}
],
"linuxFxVersion": "DOCKER|microsoft/azure-functions-node8:2.0"
}
}
}
Se você estiver implantando uma imagem de contêiner personalizada, deverá especificá-la com linuxFxVersion e
incluir a configuração que permite que a imagem seja puxada, como em aplicativo Web para contêineres. Além
disso, defina WEBSITES_ENABLE_APP_SERVICE_STORAGE como false , já que o conteúdo do aplicativo é fornecido no
próprio contêiner:
{
"apiVersion": "2016-03-01",
"dependsOn": [
],
"properties": {
"siteConfig": {
"appSettings": [
{
preview').key1)]"
},
{
"value": "node"
},
{
"value": "10.14.1"
},
{
"value": "~2"
},
{
"name": "DOCKER_REGISTRY_SERVER_URL",
"value": "[parameters('dockerRegistryUrl')]"
},
{
"name": "DOCKER_REGISTRY_SERVER_USERNAME",
"value": "[parameters('dockerRegistryUsername')]"
},
{
"name": "DOCKER_REGISTRY_SERVER_PASSWORD",
"value": "[parameters('dockerRegistryPassword')]"
},
{
"name": "WEBSITES_ENABLE_APP_SERVICE_STORAGE",
"value": "false"
}
],
"linuxFxVersion": "DOCKER|myacr.azurecr.io/myimage:mytag"
}
}
}
Personalizando uma implantação

Um aplicativo de funções tem muitos recursos filho que podem ser usados na sua implantação, incluindo
configurações do aplicativo e opções de controle do código-fonte. Você também pode optar por remover o
recurso filho sourcecontrols e usar uma outra opção de implantação.
IMPORTANT
Para implantar seu aplicativo com êxito usando o Azure Resource Manager, é importante entender como os recursos são
implantados no Azure. No exemplo a seguir, as configurações de nível superior são aplicadas usando siteConfig. É
importante definir essas configurações em um nível superior porque transmitem informações para o mecanismo de
implantação e de tempo de execução do Functions. Informações de nível superior são necessárias antes do recurso filho
sourcecontrols/web ser aplicado. Embora seja possível definir essas configurações no nível de recurso filho
config/appSettings, em alguns casos, o aplicativo de funções deve ser implantado antes de config/appSettings ser
aplicado. Por exemplo, quando você está usado funções com aplicativos lógicos, as funções são uma dependência de outro
recurso.
{
"apiVersion": "2015-08-01",
"name": "[parameters('appName')]",
"location": "[parameters('location')]",
"dependsOn": [
"[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]",
"[resourceId('Microsoft.Web/serverfarms', parameters('appName'))]"
],
"properties": {
"serverFarmId": "[variables('appServicePlanName')]",
"siteConfig": {
"alwaysOn": true,
"appSettings": [
{
"value": "~2"
},
{
"name": "Project",
"value": "src"
}
]
}
},
"resources": [
{
"apiVersion": "2015-08-01",
"name": "appsettings",
"type": "config",
"dependsOn": [
"[resourceId('Microsoft.Web/Sites', parameters('appName'))]",
"[resourceId('Microsoft.Web/Sites/sourcecontrols', parameters('appName'), 'web')]",
],
"properties": {
"AzureWebJobsStorage": "[concat('DefaultEndpointsProtocol=https;AccountName=',
preview').key1)]",
"AzureWebJobsDashboard": "[concat('DefaultEndpointsProtocol=https;AccountName=',
preview').key1)]",
"FUNCTIONS_EXTENSION_VERSION": "~2",
"FUNCTIONS_WORKER_RUNTIME": "dotnet",
"Project": "src"
}
},
{
"apiVersion": "2015-08-01",
"name": "web",
"type": "sourcecontrols",
"dependsOn": [
"[resourceId('Microsoft.Web/sites/', parameters('appName'))]"
],
"properties": {
"RepoUrl": "[parameters('sourceCodeRepositoryURL')]",
"branch": "[parameters('sourceCodeBranch')]",
"IsManualIntegration": "[parameters('sourceCodeManualIntegration')]"
}
}
]
}
TIP
Este modelo usa o valor das configurações do aplicativo Projeto, que determina o diretório-base cujo mecanismo de
implantação de funções (Kudu) procura o código implantável. Em nosso repositório, nossas funções estão em uma subpasta
da pasta src. Assim, no exemplo anterior, definimos o valor de configurações do aplicativo para src . Se as funções estão na
raiz do seu repositório, ou se não está implantando do controle de origem, você pode remover esse valor de configurações
do aplicativo.
Implantar o modelo
Você pode usar qualquer uma das seguintes maneiras para implantar o modelo:
PowerShell
CLI do Azure
Portal do Azure
API REST
Botão Implantar no Azure
Substitua <url-encoded-path-to-azuredeploy-json> por uma versão codificada de URL do caminho bruto de seu
azuredeploy.json arquivo no GitHub.
Este é um exemplo que usa markdown:
[![Deploy to Azure](https://azuredeploy.net/deploybutton.png)]
(https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>)
Este é um exemplo que usa HTML:
<a href="https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>"
target="_blank"><img src="https://azuredeploy.net/deploybutton.png"></a>
Implantar usando o PowerShell

Os comandos do PowerShell a seguir criam um grupo de recursos e implantam um modelo que cria um aplicativo
de funções com seus recursos necessários. Para executar localmente, você deve ter o Azure PowerShell instalado.
Execute Connect-AzAccount para entrar.
# Register Resource Providers if they're not already registered

Register-AzResourceProvider -ProviderNamespace "microsoft.web"
Register-AzResourceProvider -ProviderNamespace "microsoft.storage"
# Create a resource group for the function app

New-AzResourceGroup -Name "MyResourceGroup" -Location 'West Europe'
# Create the parameters for the file, which for this template is the function app name.
$TemplateParams = @{"appName" = "<function-app-name>"}
# Deploy the template

New-AzResourceGroupDeployment -ResourceGroupName "MyResourceGroup" -TemplateFile template.json -
TemplateParameterObject $TemplateParams -Verbose
Para testar essa implantação, você pode usar um modelo como este que cria um aplicativo de funções no
Windows em um plano de consumo. Substitua <function-app-name> por um nome exclusivo para seu aplicativo
de funções.
Próximas etapas
Saiba mais sobre como desenvolver e configurar o Azure Functions.
Como definir configurações do aplicativo de funções do Azure
Como criar a sua primeira função do Azure
Instale a versão prévia 2 do Azure Functions Runtime
IMPORTANT
O Azure Functions Runtime preview 2 oferece suporte somente a versão 1.x do tempo de execução do Azure Functions. Esse
recurso de visualização não está sendo atualizado para dar suporte à versão 2.x do tempo de execução e nenhuma
atualização futura planejados. Se você precisa para hospedar o tempo de execução de funções do Azure fora do Azure,
considere usando o Azure Functions no Kubernetes com KEDA
Se você quiser instalar a versão prévia 2 do Azure Functions Runtime, execute estas etapas:
1. Certifique-se de que sua máquina atenda aos requisitos mínimos.
2. Baixe o Instalador da visualização do Azure Functions Runtime.
3. Desinstale a versão prévia 1 do Azure Functions Runtime.
4. Instale a versão prévia 2 do Azure Functions Runtime.
5. Conclua a configuração da versão prévia 2 do Azure Functions Runtime.
6. Criar sua primeira função na versão prévia do Azure Functions Runtime
Pré-requisitos
Antes de instalar a visualização do Azure Functions Runtime, você deve ter os seguintes recursos disponíveis:
1. Um computador executando o Microsoft Windows Server 2016 ou a Atualização do Microsoft Windows 10
para Criadores (Professional ou Enterprise Edition).
2. Uma instância do SQL Server em execução em sua rede. O requisito mínimo de edição é o SQL Server Express.
Desinstalar a versão anterior

Se você instalou anteriormente a versão prévia de Azure Functions Runtime, deverá desinstalá-la antes de instalar
a versão mais recente. Desinstale a versão prévia do Azure Functions Runtime removendo o programa em
Adicionar/Remover Programas no Windows.
Instalar a visualização do Azure Functions Runtime

O instalador da versão prévia do Azure Functions Runtime orienta você durante a instalação das Funções de
Gerenciamento e de Trabalho da versão prévia do Azure Functions Runtime. É possível instalar as Funções de
Gerenciamento e de Trabalho no mesmo computador. No entanto, à medida que você adiciona mais aplicativos de
funções, é necessário implantar mais funções de trabalho em computadores adicionais para poder escalar suas
funções para vários trabalhadores.
Instalar as Funções de Gerenciamento e de Trabalho no mesmo

computador
1. Execute o Instalador da visualização do Azure Functions Runtime.
2. Clique em Avançar.
3. Depois de ler os termos do EULA, marque a caixa para aceitar os termos e clique em Avançar para
avançar.
4. Selecione as funções que você deseja instalar no computador Função de Gerenciamento do Functions
e/ou Função de Trabalho do Functions e clique em Avançar.
NOTE
Você pode instalar a Função de trabalho do Functions em muitos outros computadores. Para fazer isso, siga estas
instruções e só selecione a Função de trabalho do Functions no instalador.
5. Clique em Avançar para que o Assistente de instalação do Tempo de Execução do Azure Functions
comece o processo de instalação no seu computador.
6. Após a conclusão, o assistente de instalação inicia a ferramenta de configuração do Azure Functions
Runtime.
NOTE
Se você estiver instalando no Windows 10 e o recurso Contêiner não tiver sido habilitado, a Configuração do
Azure Functions Runtime solicitará a reinicialização do computador para concluir a instalação.
Configurar o Azure Functions Runtime

Para concluir a instalação do Azure Functions Runtime, você deverá concluir a configuração.
1. A ferramenta de Configuração do Azure Functions Runtime mostra quais funções estão instaladas em
seu computador.
2. Clique na guia Banco de Dados, insira os detalhes de conexão para a instância do SQL Server, incluindo a
especificação de uma chave mestra de banco de dadose clique em Aplicar. A conectividade com uma
instância do SQL Server é necessária para que o Azure Functions Runtime crie um banco de dados a fim de
dar suporte ao Runtime.
3. Clique na guia Credenciais. Aqui, você deve criar duas novas credenciais para uso com um
compartilhamento de arquivos para hospedar todos os seus aplicativos de funções. Especifique combinações
de Nome de usuário e Senha para o proprietário do compartilhamento de arquivo e para o usuário
do compartilhamento de arquivo e clique em Aplicar.
4. Clique na guia Compartilhamento de Arquivos. Aqui, você deve especificar os detalhes do local do
compartilhamento de arquivos. O compartilhamento de arquivos pode ser criado para você, ou você pode
usar um Compartilhamento de Arquivo existente e clicar em Aplicar. Se você selecionar um novo local de
Compartilhamento de Arquivos, especifique um diretório para ser usado pelo Azure Functions Runtime.
5. Clique na guia IIS. Essa guia mostra os detalhes dos sites no IIS que serão criados pela ferramenta de
configuração do Azure Functions Runtime. Você pode especificar um nome DNS personalizado aqui para o
portal da versão prévia do Azure Functions Runtime. Clique em Aplicar para concluir.
6. Clique na guia Serviços. Essa guia mostra o status dos serviços em sua instalação do Tempo de Execução
do Azure Functions. Se o Serviço de Ativação de Host do Azure Functions não estiver em execução após
a configuração inicial, clique em Iniciar Serviço.
7. Navegue até o Portal do Azure Functions Runtime como https://<machinename>.<domain>/ .
Criar sua primeira função na versão prévia do Azure Functions Runtime

Para criar sua primeira função na versão prévia do Azure Functions Runtime
1. Navegue até o portal de Azure Functions Runtime https://<machinename>.<domain> como por
https://mycomputer.mydomain.com exemplo.
2. Você será solicitado a Entrar; se implantado em um domínio, use seu nome de usuário da conta do domínio
e a senha. Caso contrário, use seu nome de usuário de conta local e a senha para fazer logon no portal.
3. Para criar aplicativos de funções, você deve criar uma assinatura. No canto superior esquerdo do portal,
clique na + opção ao lado das assinaturas.
4. Escolha DefaultPlan, insira um nome para sua assinatura e clique em Criar.
5. Todos os seus aplicativos de funções estão listados no painel esquerdo do portal. Para criar um novo
aplicativo de funções, selecione o título Aplicativo de Funções e clique na opção + .
6. Insira um nome para seu aplicativo de funções, selecione a assinatura correta, escolha a versão do Azure
Functions Runtime que deseja programar e clique em Criar
7. Seu novo aplicativo de funções está listado no painel esquerdo do portal. Selecione Functions e clique em
Nova Função na parte superior do painel central no portal.
8. Selecione a função Gatilho de Temporizador, no submenu direito, nomeie sua função e altere o
Agendamento para */5 * * * * * (essa expressão cron faz com que a função de temporizador seja
executada a cada cinco segundos) e clique em Criar
9. A função foi criada. Você pode exibir o log de execução do seu aplicativo de funções expandindo o painel log
na parte inferior do portal.
Gerenciar seu aplicativo de funções
No Azure Functions, um aplicativo de funções fornece o contexto de execução para suas funções individuais. Os
comportamentos do aplicativo de funções se aplicam a todas as funções hospedadas por um aplicativo função de
determinada. Todas as funções em um aplicativo de funções devem ser do mesmo idioma.
As funções individuais em um aplicativo de funções são implantadas juntas e dimensionadas juntas. Todas as
funções no mesmo aplicativo de funções compartilham recursos, por instância, à medida que o aplicativo de
funções é dimensionado.
Cadeias de conexão, variáveis de ambiente e outras configurações de aplicativo são definidas separadamente para
cada aplicativo de funções. Todos os dados que devem ser compartilhados entre os aplicativos de funções devem
ser armazenados externamente em um repositório persistente.
Este artigo descreve como configurar e gerenciar seus aplicativos de funções.
TIP
Muitas opções de configuração também podem ser gerenciadas usando o CLI do Azure.
Comece no portal do Azure

Acesse o portal do Azure e entre usando sua conta do Azure. Na barra de pesquisa na parte superior do portal,
digite o nome de seu aplicativo de funções e selecione-o na lista. Depois de selecionar o aplicativo de funções,
você deverá ver esta página:
Você pode navegar até tudo o que precisa para gerenciar seu aplicativo de funções na página Visão geral, em
particular as configurações do aplicativo e os recursos da plataforma .
Configurações do aplicativo
A guia configurações do aplicativo mantém as configurações que são usadas pelo seu aplicativo de funções.
Essas configurações são armazenadas criptografadas e você deve selecionar Mostrar valores para ver os valores
no Portal. Você também pode acessar as configurações do aplicativo usando o CLI do Azure.
Portal
Para adicionar uma configuração no portal, selecione nova configuração de aplicativo e adicione o novo par
chave-valor.
CLI do Azure
O az functionapp config appsettings list comando retorna as configurações de aplicativo existentes, como no
exemplo a seguir:
az functionapp config appsettings list --name <FUNCTION_APP_NAME> \

--resource-group <RESOURCE_GROUP_NAME>
O az functionapp config appsettings set comando adiciona ou atualiza uma configuração de aplicativo. O
exemplo a seguir cria uma configuração com uma chave CUSTOM_FUNCTION_APP_SETTING chamada e um valor 12345
de:
az functionapp config appsettings set --name <FUNCTION_APP_NAME> \

--resource-group <RESOURCE_GROUP_NAME> \
--settings CUSTOM_FUNCTION_APP_SETTING=12345
Usar configurações do aplicativo

Os valores de configuração do aplicativo de funções também podem ser lidos em seu código como variáveis de
ambiente. Para obter mais informações, confira a seção de variáveis de Ambiente desses tópicos de referência
específicos de linguagem:
C# pré-compilado
Script do C# (.csx)
Script F# (.fsx)
Java
JavaScript
PowerShell
Python
Ao desenvolver um aplicativo de funções localmente, você deve manter cópias locais desses valores no arquivo de
projeto local. Settings. JSON. Para obter mais informações, consulte Local Settings File.
Recursos da plataforma
Aplicativos de funções executados e mantidos pela plataforma de Serviço de Aplicativo do Azure. Dessa forma,
seus aplicativos de funções têm acesso à maioria dos recursos da principal plataforma de hospedagem na Web do
Azure. Na guia Recursos da plataforma você acessa vários recursos da plataforma de Serviço de Aplicativo para
uso em seus aplicativos de funções.
NOTE
Nem todos os recursos do Serviço de Aplicativo estão disponíveis quando um aplicativo de funções é executado no plano de
hospedagem de Consumo.
O restante deste artigo se concentra nos seguintes recursos do serviço de aplicativo no portal do Azure que são
úteis para as funções do:
Editor do Serviço de Aplicativo
Console
Ferramentas avançadas (Kudu)
Opções de implantação
CORS
Autenticação
Para saber mais sobre como trabalhar com configurações da Serviço de Aplicativo, confira Definir configurações
do Serviço de Aplicativo do Azure.
Editor de Serviço de Aplicativo
O Editor do Serviço de Aplicativo é um editor avançado dentro do portal que você pode usar para modificar
arquivos de configuração JSON e arquivos de código. Escolher essa opção inicia uma nova guia do navegador
com um editor básico. Isso permite que você se integre ao repositório do Git, execute e depure código, além de
modificar as configurações do aplicativos de funções. Esse editor fornece um ambiente de desenvolvimento
aprimorado para suas funções comparadas com o editor de funções interno.
Recomendamos que você considere o desenvolvimento de suas funções no computador local. Quando você
desenvolve localmente e publica no Azure, seus arquivos de projeto são somente leitura no Portal. Para saber
mais, confira código e teste Azure Functions localmente.
Console
O console no portal é uma ferramenta ideal de desenvolvimento quando você preferir interagir com seu aplicativo
de funções na linha de comando. Os comandos comuns incluem criação e navegação de diretório e arquivo, bem
como execução scripts e arquivos em lote.
Ao desenvolver localmente, é recomendável usar o Azure Functions Core Tools e o CLI do Azure.
Ferramentas avançadas (Kudu)
As ferramentas avançadas para o Serviço de Aplicativo (também conhecidas como Kudu) fornecem acesso a
recursos administrativos avançados de seu aplicativo de funções. No Kudu, você pode gerenciar informações do
sistema, configurações do aplicativo, variáveis de ambiente, extensões do site, cabeçalhos HTTP e variáveis de
servidor. Você também pode iniciar o Kudu navegando até o ponto de extremidade SCM de seu aplicativo de
funções, como https://<myfunctionapp>.scm.azurewebsites.net/
Centro de implantação
Quando você usa uma solução de controle do código-fonte para desenvolver e manter seu código de funções, a
central de implantação permite criar e implantar a partir do controle do código-fonte. Seu projeto é compilado e
implantado no Azure quando você faz atualizações. Para obter mais informações, consulte tecnologias de
implantação no Azure Functions.
Compartilhamento de recursos entre origens
Para evitar a execução de código mal-intencionado no cliente, os navegadores modernos bloqueiam solicitações
de aplicativos Web para recursos em execução em um domínio separado. O CORS (compartilhamento de
recursos entre origens) permite Access-Control-Allow-Origin que um cabeçalho declare quais origens têm
permissão para chamar pontos de extremidade em seu aplicativo de funções.
Portal
Quando você configura a lista de origens permitidas para seu aplicativo de Access-Control-Allow-Origin
funções, o cabeçalho é automaticamente adicionado a todas as respostas de pontos de extremidade http em seu
Quando o curinga ( * ) é usado, todos os outros domínios são ignorados.
Use o az functionapp cors add comando para adicionar um domínio à lista de origens permitidas. O exemplo a
seguir adiciona o domínio contoso.com:
az functionapp cors add --name <FUNCTION_APP_NAME> \

--resource-group <RESOURCE_GROUP_NAME> \
--allowed-origins https://contoso.com
Use o az functionapp cors show comando para listar as origens permitidas atualmente.
Autenticação
Quando as funções usam um gatilho HTTP, você pode exigir que as chamadas sejam autenticadas primeiro. O
serviço de aplicativo dá suporte à autenticação Azure Active Directory e a entrar com provedores sociais, como
Facebook, Microsoft e Twitter. Para obter detalhes sobre como configurar provedores de autenticação específicos,
consulte Visão geral de autenticação do serviço de aplicativo do Azure.
Próximas etapas
Definir configurações do Serviço de Aplicativo do Azure
Como direcionar Azure Functions versões de tempo
de execução
Um aplicativo de funções é executado em uma versão específica do tempo de execução de Azure Functions. Há
duas versões principais: 1. x e 2. x, com a versão 3. x na visualização. Por padrão, os aplicativos de funções que
são criados versão 2. x do tempo de execução. Este artigo explica como configurar um aplicativo de funções no
Azure para ser executado na versão que você escolher. Para obter informações sobre como configurar um
ambiente de desenvolvimento local para uma versão específica, consulte código e teste Azure Functions
localmente.
Atualizações automáticas e manuais de versão

Azure Functions permite que você direcione uma versão específica do tempo de execução usando a configuração
de aplicativo FUNCTIONS_EXTENSION_VERSION em um aplicativo de funções. O aplicativo de funções é mantido na
versão principal especificada até que você escolha explicitamente mover para uma nova versão.
Se você especificar apenas a versão principal, o aplicativo de funções será atualizado automaticamente para
novas versões secundárias do tempo de execução quando eles forem disponibilizados. As novas versões
secundárias não introduzem alterações significativas. Se você especificar uma versão secundária (por exemplo,
"2.0.12345"), o aplicativo de funções será fixado nessa versão específica até que você a altere explicitamente.
NOTE
Se você fixar em uma versão específica do Azure Functions e tentar publicar no Azure usando o Visual Studio, uma janela
de diálogo será exibida solicitando que você atualize para a versão mais recente ou cancele a publicação. Para evitar isso,
adicione a propriedade <DisableFunctionExtensionVersionUpdate>true</DisableFunctionExtensionVersionUpdate>
em seu arquivo de .csproj .
Quando uma nova versão estiver disponível publicamente, um prompt no portal lhe dará a chance de se mover
para essa versão. Depois de mover para uma nova versão, você sempre pode usar a configuração
FUNCTIONS_EXTENSION_VERSION aplicativo para voltar para uma versão anterior.
A tabela a seguir mostra os valores de FUNCTIONS_EXTENSION_VERSION para cada versão principal para habilitar as
atualizações automáticas:
VERSÃO PRINCIPAL VALOR FUNCTIONS_EXTENSION_VERSION
3. x (visualização) ~3
2. x ~2
1.x ~1
Uma alteração na versão de tempo de execução faz com que um aplicativo de funções seja reiniciado.
Exibir e atualizar a versão de runtime atual

Você pode alterar a versão de tempo de execução usada pelo seu aplicativo de funções. Devido ao potencial de
alterações significativas, você só pode alterar a versão de tempo de execução antes de criar qualquer função em
IMPORTANT
Embora a versão de tempo de execução seja determinada pela configuração de FUNCTIONS_EXTENSION_VERSION , você
deve fazer essa alteração na portal do Azure e não alterando a configuração diretamente. Isso ocorre porque o portal
valida as alterações e faz outras alterações relacionadas, conforme necessário.
da portal do Azure
Use o procedimento a seguir para exibir e atualizar a versão de tempo de execução usada no momento por um
1. No portal do Azure, navegue até o aplicativo de funções.
2. Em Recursos Configurados, escolha Configurações do aplicativo de funções.
3. Na guia Configurações do aplicativo de funções, localize a Versão de tempo de execução. Observe

a versão de tempo de execução específica e a versão principal solicitada. No exemplo a seguir, a versão é
definida como ~2 .
4. Para fixar o aplicativo de funções no tempo de execução de versão 1.x, escolha ~1 em Versão de tempo
de execução. Essa opção estará desabilitada quando houver funções no aplicativo.
5. Ao alterar a versão de tempo de execução, retorne à guia Visão geral e escolha Reiniciar para reiniciar o
aplicativo. O aplicativo de funções reinicia a execução no tempo de execução de versão 1.x e os modelos de
versão 1.x são usados quando você cria funções.
NOTE
Usando o portal do Azure, você não pode alterar a versão de tempo de execução de um aplicativo de funções que já
contém funções.
Da CLI do Azure
Você também pode exibir e definir o FUNCTIONS_EXTENSION_VERSION do CLI do Azure.
NOTE
Como outras configurações podem ser afetadas pela versão de tempo de execução, você deve alterar a versão no Portal. O
portal automaticamente faz as outras atualizações necessárias, como a versão do node. js e a pilha de tempo de execução,
quando você altera as versões de tempo de execução.
Usando o CLI do Azure, exiba a versão de tempo de execução atual com o comando AZ functionapp config
appSettings Set .
az functionapp config appsettings list --name <function_app> \

--resource-group <my_resource_group>
Nesse código, substitua <function_app> pelo nome do seu aplicativo de funções. Substitua também
<my_resource_group> pelo nome do grupo de recursos para seu aplicativo de funções.
Você verá a FUNCTIONS_EXTENSION_VERSION na seguinte saída, que foi truncada para maior clareza:
[
{
"slotSetting": false,
"value": "~2"
},
{
"value": "dotnet"
},
...
{
"value": "8.11.1"
}
]
Você pode atualizar a configuração de FUNCTIONS_EXTENSION_VERSION no aplicativo de funções com o comando AZ

functionapp config appSettings Set .
az functionapp config appsettings set --name <function_app> \
--resource-group <my_resource_group> \
--settings FUNCTIONS_EXTENSION_VERSION=<version>
Substitua <function_app> pelo nome do seu aplicativo de funções. Substitua também <my_resource_group> pelo
nome do grupo de recursos para seu aplicativo de funções. Além disso, substitua <version> por uma versão
válida do tempo de execução 1. x ou ~2 para a versão 2. x.
Você pode executar esse comando no Azure cloud Shell escolhendo experimentar no exemplo de código
anterior. Você também pode usar o CLI do Azure localmente para executar esse comando depois de executar AZ
login para entrar.
Próximos passos
Direcione o tempo de execução de 2,0 em seu ambiente de desenvolvimento local
Consulte notas de versão para versões de tempo de execução
Instalar ou atualizar manualmente as extensões de
associação do Azure Functions no portal
O tempo de execução do Azure Functions versão 2.x usa extensões de associação para implementar código a
gatilhos e associações. As extensões de associação são fornecidas nos pacotes NuGet. Registrar uma extensão é
basicamente instalar um pacote. Ao desenvolver funções, a maneira de instalar as extensões de associação
depende do ambiente de desenvolvimento. Para obter mais informações, consulte Registrar extensões de
associação no artigo de gatilhos e associações.
Às vezes, é necessário instalar ou atualizar manualmente as extensões de associação no portal do Azure. Por
exemplo, talvez seja necessário atualizar uma associação registrada para uma versão mais recente. Também
pode ser necessário registrar uma associação com suporte que não pode ser instalada na guia Integrar no
portal.
Instalar uma extensão de associação

Siga as etapas abaixo para instalar ou atualizar manualmente as extensões do portal.
1. No portal do Azure, localize o aplicativo de funções e selecione-o. Escolha a guia Visão geral e selecione
Parar. Parar o aplicativo de funções desbloqueia arquivos para que as alterações possam ser efetivadas.
2. Escolha a guia Recursos da plataforma e em Ferramentas de Desenvolvimento selecione
Ferramentas Avançadas (Kudu) . O ponto de extremidade do Kudu (
https://<APP_NAME>.scm.azurewebsites.net/ ) abre em uma nova janela.
3. Na janela do Kudu, selecione Console de depuração > CMD.

4. Na janela de comando, navegue até D:\home\site\wwwroot e escolha o ícone de exclusão próximo a bin
para excluir a pasta. Selecione OK para confirmar a exclusão.
5. Escolha o ícone de edição próximo ao arquivo extensions.csproj , que define as extensões de associação
para o aplicativo de funções. O arquivo de projeto é aberto no editor online.
6. Faça as adições e atualizações necessárias dos itens PackageReference em ItemGroup, e, em seguida,
selecione Salvar. A lista atua de versões de pacotes com suporte pode ser encontrada no artigo do wiki
Quais pacotes eu preciso?. Todas as três associações de Armazenamento do Azure exigem o pacote
Microsoft.Azure.WebJobs.Extensions.Storage.
7. Na pasta wwwroot execute o seguinte comando para reconstruir os assemblies referenciados na pasta
bin .
dotnet build extensions.csproj -o bin --no-incremental --packages D:\home\.nuget
8. Retorne à guia Visão geral no portal, escolha Iniciar para iniciar o aplicativo de funções.
Próximas etapas
Aprenda mais sobre gatilhos e de associações do Azure Functions
Como desabilitar funções no Azure Functions
Este artigo explica como desabilitar uma função no Azure Functions. Desabilitar significa fazer com que o tempo
de execução igore o gatilho automático que está definido para a função. A maneira de fazer isso depende da
versão de tempo de execução e a linguagem de programação:
Funções 2. x:
Uma maneira para todos os idiomas
Modo opcional para bibliotecas de classes do C#
Funções 1. x:
Linguagens de script
Biblioteca de Classes C#
Funtions 2.x - todos os idiomas

No functions 2. x, você desabilita uma função usando uma configuração de aplicativo no formato
AzureWebJobs.<FUNCTION_NAME>.Disabled . Você pode criar e modificar essa configuração de aplicativo de várias
maneiras, incluindo usando o CLI do Azure e da guia gerenciar da função na portal do Azure.
CLI do Azure
No CLI do Azure, você usa o az functionapp config appsettings set comando para criar e modificar a
configuração do aplicativo. O comando a seguir desabilita uma função denominada QueueTrigger criando uma
configuração de aplicativo chamada AzureWebJobs.QueueTrigger.Disabled set to true .
az functionapp config appsettings set --name <myFunctionApp> \

--resource-group <myResourceGroup> \
--settings AzureWebJobs.QueueTrigger.Disabled=true
Para reabilitar a função, execute novamente o mesmo comando com um valor de false .
az functionapp config appsettings set --name <myFunctionApp> \

--resource-group <myResourceGroup> \
--settings AzureWebJobs.QueueTrigger.Disabled=false
Portal
Você também pode usar o Estado da Função ativar a guia Gerenciar da função. A opção funciona criando e
excluindo o AzureWebJobs.<FUNCTION_NAME>.Disabled configuração de aplicativo.
Functions 2.x - bibliotecas de classes do C#
Em uma biblioteca de classes do Functions 2.x, é recomendável que você use o método que funciona para todos os
idiomas. Mas se você preferir, você pode usar o atributo desabilitar como no Functions 1.x.
Functions 1.x - linguagens de script

Para linguagens de script, como o script do C# e JavaScript, você deve usar a disabled propriedade do arquivo
Function. JSON para informar para o tempo de execução não disparar uma função. Essa propriedade pode ser
definida como true ou o nome de uma configuração de aplicativo:
{
"bindings": [
{
"direction": "in",
}
],
"disabled": true
}
ou
"bindings": [
...
],
"disabled": "IS_DISABLED"
No segundo exemplo, a função está desabilitada quando há uma configuração de aplicativo chamada
IS_DISABLED e é definida como true ou 1.
Você pode editar o arquivo no portal do Azure ou usar o Estado da Função ative a função da guia Gerenciar. A
opção portal funciona, alterando o arquivo function.json.
Functions 1.x - bibliotecas de classes do C#

Em uma biblioteca de classes das Functions 1.x, você deve usar um Disable atributo para impedir que uma
função que está sendo disparado. Você pode usar o atributo sem um parâmetro de construtor, conforme mostrado
no exemplo a seguir:
public static class QueueFunctions

{
[Disable]
public static void QueueTrigger(
TraceWriter log)
{
log.Info($"C# function processed: {myQueueItem}");
}
}
O atributo sem parâmetro de construtor exige que você recompilar e reimplanta o projeto para alterar o estado de
desabilitado da função. Uma maneira mais flexível para usar o atributo deve incluir um parâmetro de construtor
que se refere a uma configuração de aplicativo booliano, conforme mostrado no exemplo a seguir:

{
[Disable("MY_TIMER_DISABLED")]
TraceWriter log)
{
log.Info($"C# function processed: {myQueueItem}");
}
}
Esse método permite habilitar e desabilitar a função, alterando a configuração de aplicativo, sem recompilar ou
reinstalar. Alterar uma configuração de aplicativo faz com que o aplicativo de funções seja reiniciado, portanto, a
alteração de estado desabilitado é reconhecida imediatamente.
IMPORTANT
O Disabled atributo é a única maneira de desabilitar uma função de biblioteca de classe. Gerado o arquivo function. JSON
para uma função de biblioteca de classe não se destina a ser editado diretamente. Se você editar esse arquivo, tudo o que
faria para a disabled propriedade não terá efeito.
O mesmo vale para o estado de função ative a guia Gerenciar, assim que funcionar, alterando o arquivo Function. JSON.
Além disso, observe que o portal pode indicar que a função está desabilitada quando não estiver.
Próximas etapas
Este artigo trata-se como desabilitar disparadores automáticos. Para obter mais informações, consulte Gatilhos e
associações de armazenamento de Blobs.
Azure Functions recuperação de desastres
geograficamente
Quando todas as regiões ou datacenters do Azure têm experiência com tempo de inatividade, é fundamental para a
computação continuar o processamento em uma região diferente. Este artigo explicará algumas das estratégias que
você pode usar para implantar funções para permitir a recuperação de desastres.
Conceitos básicos
Azure Functions executado em uma região específica. Para obter maior disponibilidade, você pode implantar as
mesmas funções em várias regiões. Quando em várias regiões, você pode ter suas funções em execução no padrão
ativo/ativo ou no padrão ativo/passivo .
Ativa/ativa. Ambas as regiões estão ativas e recebendo eventos (duplicados ou rotacionalmente). Ativo/ativo é
recomendado para funções HTTPS em combinação com a porta frontal do Azure.
Ativo/passivo. Uma região está ativa e recebendo eventos, enquanto um secundário está ocioso. Quando o
failover é necessário, a região secundária é ativada e assume o processamento. Isso é recomendado para
funções não HTTP, como barramento de serviço e hubs de eventos.
Leia como executar aplicativos em várias regiões para obter mais informações sobre implantações de várias
regiões.
Ativo/ativo para funções HTTPS

Para obter implantações ativas/ativas de funções, é necessário um componente que possa coordenar os eventos
entre ambas as regiões. Para funções HTTPS, essa coordenação é realizada usando a porta frontal do Azure. A porta
frontal do Azure pode rotear e redirecionar solicitações HTTPS entre várias funções regionais. Ele também verifica
periodicamente a integridade de cada ponto de extremidade. Se uma função regional parar de responder às
verificações de integridade, a porta frontal do Azure a retirará da rotação e apenas encaminhará o tráfego para as
funções íntegras.
Ativo/ativo para funções não-HTTPS
Você ainda pode obter implantações ativas/ativas para funções não-HTTPS. No entanto, você precisa considerar
como as duas regiões interagirão ou serão coordenadas umas com as outras. Se você implantou o mesmo
aplicativo de funções em duas regiões, cada um disparando na mesma fila do barramento de serviço, ele atuaria
como consumidores concorrentes na remoção da fila dessa fila. Embora isso signifique que cada mensagem está
sendo processada apenas por uma das instâncias, isso também significa que ainda há um único ponto de falha no
barramento de serviço único. Se você implantar duas filas do barramento de serviço (uma em uma região primária,
uma em uma região secundária) e os dois aplicativos de função apontados para sua fila de região, o desafio agora
é o modo como as mensagens de fila são distribuídas entre as duas regiões. Geralmente, isso significa que cada
publicador tenta publicar uma mensagem em ambas as regiões e cada mensagem é processada por ambos os
aplicativos de funções ativas. Embora isso crie um padrão ativo/ativo, ele cria outros desafios em relação à
duplicação de computação e quando ou como os dados são consolidados. Por esses motivos, é recomendável que
gatilhos não-HTTPS usem o padrão ativo/passivo.
Ativo/passivo para funções não HTTPS

Ativo/passivo fornece uma maneira para apenas uma única função processar cada mensagem, mas fornece um
mecanismo para fazer failover para uma região secundária em caso de desastre. Azure Functions funciona junto
com a recuperação geográfica do barramento de serviço do Azure e com a recuperação geográfica dos hubs de
eventos do Azure.
Usando gatilhos de hubs de eventos do Azure como exemplo, o padrão ativo/passivo envolveria o seguinte:
Hub de eventos do Azure implantado em uma região primária e secundária.
Desastre geográfico habilitado para emparelhar o Hub de eventos primário e secundário. Isso também cria um
"alias" que você pode usar para se conectar aos hubs de eventos e alternar de primário para secundário sem
alterar as informações de conexão.
Aplicativos de funções implantados em uma região primária e secundária.
Os aplicativos de funções estão sendo disparados na cadeia de conexão direta (sem alias) para seu respectivo
Hub de eventos.
Os editores para o Hub de eventos devem publicar na cadeia de conexão do alias.
Antes do failover, os editores que enviarem para o alias compartilhado rotearão para o Hub de eventos primário. O
aplicativo de funções primário está ouvindo exclusivamente o Hub de eventos primário. O aplicativo de funções
secundário será passivo e ocioso. Assim que o failover for iniciado, os Publicadores que enviarem para o alias
compartilhado agora serão roteados para o Hub de eventos secundário. O aplicativo de função secundário agora
ficará ativo e começará a disparar automaticamente. O failover efetivo para uma região secundária pode ser
totalmente controlado do hub de eventos, com as funções se tornando ativas somente quando o respectivo Hub de
eventos estiver ativo.
Leia mais sobre informações e considerações sobre failover com o barramento de serviço e os hubs de eventos.
Próximas etapas
Criar porta frontal do Azure
Considerações sobre failover de hubs de eventos
Monitorar Azure Functions
O Azure Functions oferece integração interna com informações de aplicativo Azure para monitorar
funções. Este artigo mostra como configurar Azure Functions para enviar arquivos de log gerados
pelo sistema para Application Insights.
É recomendável usar Application Insights porque coleta dados de log, desempenho e erro. Ele detecta
automaticamente anomalias de desempenho e inclui poderosas ferramentas de análise para ajudá-lo
a diagnosticar problemas e a entender como suas funções são usadas. Ele foi projetado para ajudar
você a aprimorar continuamente o desempenho e a usabilidade do seu aplicativo. Você pode até
mesmo usar Application Insights durante o desenvolvimento do projeto de aplicativo de função local.
Para obter mais informações, consulte o que é Application insights?.
Como a instrumentação de Application Insights necessária é incorporada ao Azure Functions, tudo o
que você precisa é de uma chave de instrumentação válida para conectar seu aplicativo de funções a
um recurso de Application Insights.
Preços e limites do Application Insights

Você pode testar a integração do Application Insights aos Aplicativos de Funções gratuitamente. Há
um limite diário para a quantidade de dados que pode ser processada gratuitamente. Você pode
atingir esse limite durante o teste. O Azure fornece o portal e notificações por email quando está se
aproximando do limite diário. Se você perder esses alertas e atingir o limite, novos logs não
aparecerão em Application Insights consultas. Esteja ciente do limite para evitar o tempo de solução
de problemas desnecessário. Para obter mais informações, consulte Gerenciar o preço e o volume de
dados no Application Insights.
A lista completa de recursos de Application Insights disponíveis para seu aplicativo de funções é
detalhada em Application insights para Azure Functions recursos com suporte.

Para um aplicativo de funções enviar dados ao Application Insights, ele precisa saber a chave de
instrumentação de um recurso do Application Insights. A chave deve estar em uma configuração de
aplicativo chamada APPINSIGHTS_INSTRUMENTATIONKEY.
Novo aplicativo de funções no portal
Quando você cria seu aplicativo de funções no portal do Azure, aintegração Application insights é
habilitada por padrão. O recurso Application Insights tem o mesmo nome que seu aplicativo de
funções e é criado na mesma região ou na região mais próxima.
Para examinar a Application Insights recurso que está sendo criado, selecione-o para expandir a
janela Application insights . Você pode alterar o nome do novo recurso ou escolher um local
diferente em uma Geografia do Azure onde você deseja armazenar seus dados.
Quando você escolhe criar, um recurso de Application insights é criado com seu aplicativo de
funções, que tem o APPINSIGHTS_INSTRUMENTATIONKEY definido nas configurações do aplicativo. Tudo
está pronto para começar.
Adicionar a um aplicativo de funções existente
Ao criar um aplicativo de funções usando o CLI do Azure, o Visual Studioou o Visual Studio Code,
você deve criar o recurso de Application insights. Em seguida, você pode adicionar a chave de
instrumentação a partir desse recurso como uma configuração de aplicativo em seu aplicativo de
funções.
As funções facilitam a adição da integração do Application Insights a um aplicativo de funções do
portal do Azure.
1. No portal, selecione Todos os serviços > Aplicativos de Funções, selecione o aplicativo de
funções e, em seguida, selecione a faixa do Application Insights na parte superior da janela
2. Crie um recurso do Application Insights usando as configurações especificadas na tabela
abaixo da imagem.
Nome Nome de aplicativo exclusivo É mais fácil usar o mesmo nome

que seu aplicativo de funções,
que deve ser exclusivo em sua
assinatura.
Localidade Europa Ocidental Se possível, use a mesma região

que seu aplicativo de funções ou
uma região próxima dela.
3. Selecione OK. O recurso do Application Insights é criado no mesmo grupo de recursos e

assinatura que seu aplicativo de funções. Depois que o recurso for criado, feche a janela do
4. No aplicativo de funções, selecione Configurações do aplicativo e role para baixo até
Configurações do aplicativo. Se você vir uma configuração chamada
APPINSIGHTS_INSTRUMENTATIONKEY , isso significa que a integração do Application Insights está
habilitada para seu aplicativo de funções em execução no Azure.
As versões anteriores das funções usavam o monitoramento interno, o que não é mais recomendado.
Ao habilitar a integração de Application Insights para esse aplicativo de funções, você também deve
desabilitar o registro em log interno.
Exibir telemetria na guia Monitor

Com a integração do Application insights habilitada, você pode exibir dados de telemetria na guia
monitorar .
1. Na página do aplicativo de funções, selecione uma função que tenha sido executada pelo
menos uma vez depois que Application Insights foi configurada. Em seguida, selecione a guia
Monitor .
2. Selecione Atualizar periodicamente, até que a lista de invocações de função seja exibida.
Pode levar até cinco minutos para que a lista seja exibida enquanto o cliente de telemetria
batche dados para transmissão para o servidor. (O atraso não se aplica ao Live Metrics Stream.
Esse serviço se conecta ao host de Funções quando você carrega a página, logo os logs são
transmitidos diretamente para a página.)
3. Para ver os logs de uma invocação de função específica, selecione o link da coluna Data para a
invocação.
A saída de logs para essa invocação aparece em uma nova página.
Você pode ver que ambas as páginas têm uma execução no Application insights link para a
consulta Application insights Analytics que recupera os dados.
A consulta a seguir é exibida. Você pode ver que a lista de invocação está limitada aos últimos 30 dias.
A lista mostra no máximo 20 linhas ( where timestamp > ago(30d) | take 20 ). A lista de detalhes de
invocação é para os últimos 30 dias sem nenhum limite.
Para obter mais informações, consulte Dados de telemetria da consulta a seguir neste artigo.
Exibir a telemetria no Application Insights

Para abrir Application Insights de um aplicativo de funções no portal do Azure, vá para a página
visão geral do aplicativo de funções. Em recursos configurados, selecione Application insights.
Para obter informações sobre como usar o Application Insights, consulte a documentação do o
Application Insights. Esta seção mostra alguns exemplos de como exibir dados no Application
Insights. Se você já estiver familiarizado com o Application Insights, poderá ir diretamente para as
seções sobre como configurar e personalizar os dados de telemetria.
As áreas de Application Insights a seguir podem ser úteis ao avaliar o comportamento, o
desempenho e os erros em suas funções:
TAB DESCRIÇÃO
Sucedi Crie gráficos e alertas com base em falhas de função e

exceções de servidor. O Nome da Operação é o
nome da função. Falhas em dependências não são
mostradas a menos que você implemente telemetria
personalizada para dependências.
Desempenho Analisar problemas de desempenho.
Servidores Exibir a utilização de recursos e a taxa de transferência

por servidor. Esses dados podem ser úteis para
cenários de depuração em que as funções estão
travando seus recursos subjacentes. Servidores são
chamados de Instâncias de função de nuvem.
Métrica Crie gráficos e alertas baseados em métricas. As

métricas incluem o número de invocações de função,
tempo de execução e taxas de sucesso.
Live Metrics Stream Exiba os dados de métricas conforme eles são criados
em tempo real.
Dados de telemetria da consulta

Application insights Analytics fornece acesso a todos os dados de telemetria na forma de tabelas em
um banco de dados. A Análise fornece uma linguagem de consulta para extrair, manipular e visualizar
os dados.
Veja um exemplo de consulta que mostra a distribuição de solicitações por trabalhador nos últimos
30 minutos.
requests
| where timestamp > ago(30m)
| summarize count() by cloud_RoleInstance, bin(timestamp, 1m)
| render timechart
As tabelas disponíveis são mostradas na guia esquema à esquerda. Você pode encontrar os dados
gerados por invocações de função nas tabelas a seguir:
TABELA DESCRIÇÃO
TABELA DESCRIÇÃO
rastreamentos Logs criados pelo tempo de execução e por código de

função.
requests Uma solicitação para cada invocação de função.
exceptions Todas as exceções geradas pelo tempo de execução.
customMetrics A contagem de invocações bem-sucedidas e com falha,

taxa de êxito e duração.
customEvents Eventos rastreados pelo tempo de execução, por

exemplo: solicitações HTTP que disparam uma função.
performanceCounters Informações sobre o desempenho dos servidores em

que as funções estão sendo executadas.
As outras tabelas são para testes de disponibilidade e telemetria de cliente e navegador. Você pode
implementar a telemetria personalizada para adicionar dados a ela.
Dentro de cada tabela, alguns dos dados específicos do Functions estão em um campo
customDimensions . Por exemplo, a consulta a seguir recupera todos os rastreamentos que têm o nível
de log Error .
traces
| where customDimensions.LogLevel == "Error"
O tempo de execução fornece os campos customDimensions.LogLevel e customDimensions.Category .

Você pode fornecer campos adicionais nos logs que você escreve em seu código de função. Consulte
Registro em log estruturado mais adiante neste artigo.
Configurar categorias e níveis de log

Você pode usar Application Insights sem nenhuma configuração personalizada. A configuração
padrão pode resultar em grandes volumes de dados. Se você estiver usando uma assinatura do Azure
do Visual Studio, poderá ter atingido o limite de dados para o Application Insights. Posteriormente
neste artigo, você aprenderá a configurar e personalizar os dados que suas funções enviam para
Application Insights. Para um aplicativo de funções, o registro em log é configurado no arquivo host.
JSON .
Categorias
O agente do Azure Functions inclui uma categoria para cada log. A categoria indica qual parte do
código de runtime ou do seu código de função gravou o log.
O tempo de execução do Functions cria logs com uma categoria que começa com "host". Na versão 1.
x, os logs function started , function executed e function completed têm a categoria Host.Executor .
A partir da versão 2. x, esses logs têm a categoria Function.<YOUR_FUNCTION_NAME> .
Se você gravar logs em seu código de função, a categoria será Function na versão 1. x do tempo de
execução do functions. Na versão 2. x, a categoria é Function.<YOUR_FUNCTION_NAME>.User .
Níveis de log
O agente de Azure Functions também inclui um nível de log com cada log. LogLevel é uma
enumeração e o código inteiro indica a importância relativa:
LOGLEVEL CODIFICAR
Rastreamento 0
Depuração 1
Informações 2
Aviso 3
Erro 4
Crítico 5
Nenhum 6
Nível de log None é explicado na próxima seção.

Configuração de log em host. JSON
O arquivo host. JSON configura quanto registro em log um aplicativo de função envia ao Application
Insights. Para cada categoria, você deve indicar o nível de log mínimo para enviar. Há dois exemplos: o
primeiro exemplo tem como alvo o tempo de execução das funções versão 2. x (.NET Core) e o
segundo exemplo é para o tempo de execução da versão 1. x.
Versão 2.x
O tempo de execução v2.x usa a hierarquia de filtros de registro da .NET Core.
{
"logging": {
"fileLoggingMode": "always",
"logLevel": {
"default": "Information",
"Host.Results": "Error",
"Function": "Error",
"Host.Aggregator": "Trace"
}
}
}
Versão 1.x
{
"logger": {
"categoryFilter": {
"defaultLevel": "Information",
"categoryLevels": {
"Host.Results": "Error",
"Host.Aggregator": "Trace"
}
}
}
}
Este exemplo configura as seguintes regras:

Para logs com a categoria Host.Results ou Function , envie somente o nível Error e superior
para Application Insights. Os logs para o nível Warning e abaixo são ignorados.
Para logs com a categoria Host.Aggregator , enviar todos os logs para o Application Insights. O
Trace nível de log é o mesmo que o que chamo de alguns agentes Verbose , mas usar Trace no
host. JSON arquivo.
Para todos os outros logs, envie somente o nível Information e acima ao Application Insights.
O valor de categoria em host. JSON controla o registro em log para todas as categorias que
começam com o mesmo valor. Host no host. JSON controla o registro em log para Host.General ,
Host.Executor , Host.Results e assim por diante.
Se host. JSON incluir várias categorias que comecem com a mesma cadeia de caracteres, será feito
primeiro a correspondência com as mais longas. Suponha que você queira tudo do tempo de
execução, exceto Host.Aggregator para fazer logon no nível Error , mas deseja que Host.Aggregator
Faça logon no nível Information :
Versão 2.x
{
"logging": {
"fileLoggingMode": "always",
"logLevel": {
"default": "Information",
"Host": "Error",
"Host.Aggregator": "Information"
}
}
}
Versão 1.x
{
"logger": {
"categoryFilter": {
"categoryLevels": {
"Host": "Error",
}
}
}
}
Para suprimir todos os logs para uma categoria, você pode usar o nível de log None . Nenhum log é
gravado com essa categoria e não há nenhum nível de registro acima dele.
As seções a seguir descrevem as principais categorias de logs que o runtime cria.
Categoria Host.Results
Esses logs aparecem como "solicitações" no Application Insights. Elas indicam o sucesso ou a falha de
uma função.
Todos esses logs são gravados no nível Information . Se você filtrar em Warning ou acima, não verá
nenhum desses dados.
Categoria Host.Aggregator
Esses logs fornecem contagens e médias de chamadas de função sobre um período configurável. O
período padrão é de 30 segundos ou 1.000 resultados, o que ocorrer primeiro.
Os logs estão disponíveis na tabela customMetrics no Application Insights. Os exemplos são o
número de execuções, a taxa de sucesso e a duração.
Todos esses logs são gravados no nível Information . Se você filtrar em Warning ou acima, não verá
nenhum desses dados.
Outras categorias
Todos os logs para categorias diferentes daquelas já listadas estão disponíveis na tabela traces no
Todos os logs com categorias que começam com Host são gravados pelo tempo de execução do
functions. Os logs "função iniciada" e "função concluída" têm a categoria Host.Executor . Para
execuções bem-sucedidas, esses logs são do nível Information . As exceções são registradas no nível
Error . O tempo de execução também cria logs de nível Warning , por exemplo: mensagens de fila
enviadas para a fila de suspeita.
Os logs gravados pelo seu código de função têm a categoria Function e podem ser qualquer nível de
log.
Configurar o agregador
Conforme observado na seção anterior, o runtime agrega dados sobre as execuções de função em um
período. O período padrão é de 30 segundos ou 1.000 execuções, o que ocorrer primeiro. Você pode
definir essa configuração no arquivo host. JSON. Aqui está um exemplo:
{
"aggregator": {
"batchSize": 1000,
"flushTimeout": "00:00:30"
}
}
Configurar a amostragem
O Application Insights tem um recurso de amostragem que pode protegê-lo de produzir dados de
telemetria demais em execuções concluídas em momentos de pico de carga. Quando a taxa de
execuções de entrada excede um limite especificado, Application Insights começa a ignorar
aleatoriamente algumas das execuções de entrada. A configuração padrão para o número máximo de
execuções por segundo é 20 (cinco na versão 1. x). Você pode configurar a amostragem em host.
JSON. Aqui está um exemplo:
Versão 2.x
{
"logging": {
"applicationInsights": {
"samplingSettings": {
"isEnabled": true,
"maxTelemetryItemsPerSecond" : 20
}
}
}
}
Versão 1.x
{
"sampling": {
"isEnabled": true,
}
}
}
NOTE
Amostragem é habilitado por padrão. Se parecer que faltam dados, talvez seja necessário ajustar as
configurações de amostragem para que se ajustem ao seu cenário de monitoramento específico.
Gravar logs em funções C#

Você pode gravar logs no seu código de função que apareçam como rastreamentos no Application
Insights.
ILogger
Use um parâmetro ILogger em funções, em vez de um parâmetro TraceWriter . Os logs criados
usando TraceWriter vão para Application Insights, mas ILogger permite que você faça o registro em
log estruturado.
Com um objeto ILogger , você chama os Log<level> métodos de extensão no ILogger para criar
logs. O código a seguir grava os logs Information com a categoria "função".
public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger logger)

{
logger.LogInformation("Request for item with key={itemKey}.", id);
Registro em log estruturado

A ordem dos espaços reservados, não seus nomes, determina quais parâmetros são usados na
mensagem de log. Suponha que você tenha o seguinte código:
string partitionKey = "partitionKey";

string rowKey = "rowKey";
logger.LogInformation("partitionKey={partitionKey}, rowKey={rowKey}", partitionKey, rowKey);
Se você mantiver a mesma cadeia de caracteres de mensagem e inverter a ordem dos parâmetros, o
texto da mensagem resultante terá os valores nos locais errados.
Os espaços reservados são tratados dessa forma para que você possa fazer registro em log
estruturado. Application Insights armazena os pares nome-valor do parâmetro e a cadeia de
caracteres da mensagem. O resultado é que os argumentos da mensagem tornam-se campos que
você pode consultar.
Se a chamada do método de agente for semelhante ao exemplo anterior, você poderá consultar o
campo customDimensions.prop__rowKey . O prefixo prop__ é adicionado para garantir que não haja
colisões entre os campos que o tempo de execução adiciona e os campos que o código de função
adiciona.
Você também pode consultar a cadeia de caracteres da mensagem original referenciando o campo
customDimensions.prop__{OriginalFormat} .
Aqui está uma representação JSON de exemplo de dados customDimensions :
{
customDimensions: {
"prop__{OriginalFormat}":"C# Queue trigger function processed: {message}",
"Category":"Function",
"LogLevel":"Information",
"prop__message":"c9519cbf-b1e6-4b9b-bf24-cb7d10b1bb89"
}
}
Log de métricas personalizadas

Em funções de script C#, você pode usar o método de extensão LogMetric em ILogger para criar
métricas personalizadas no Application Insights. Aqui está um exemplo de chamada de método:
logger.LogMetric("TestMetric", 1234);
Esse código é uma alternativa para chamar TrackMetric usando a API Application Insights para .NET.
Gravar logs em funções de JavaScript

Em funções do Node.js, use context.log para gravar logs. O log estruturado não está habilitado.
context.log('JavaScript HTTP trigger function processed a request.' + context.invocationId);
Log de métricas personalizadas

Quando você está executando na versão 1. x do tempo de execução do functions, as funções do node.
js podem usar o método context.log.metric para criar métricas personalizadas no Application
insights. Atualmente, não há suporte para esse método na versão 2. x. Aqui está um exemplo de
chamada de método:
context.log.metric("TestMetric", 1234);
Esse código é uma alternativa para chamar trackMetric usando o SDK do node. js para Application
Insights.
Registrar telemetria personalizada C# em funções

Você pode usar o pacote do NuGet Microsoft.ApplicationInsights para enviar dados de telemetria
personalizados ao Application Insights. O exemplo C# a seguir usa a API de telemetria personalizada.
O exemplo é para uma biblioteca de classes do .NET, mas o código do Application Insights é o
mesmo para o script C#.
Versão 2.x
A versão de runtime 2.x usa recursos mais recentes no Application Insights para correlacionar
automaticamente a telemetria com a operação atual. Não é necessário definir manualmente a
operação Id , ParentId ou Name campos.
using System;
using System.Linq;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
namespace functionapp0915
{
public class HttpTrigger2
{
private readonly TelemetryClient telemetryClient;
/// Using dependency injection will guarantee that you use the same configuration for
telemetry collected automatically and manually.
public HttpTrigger2(TelemetryConfiguration telemetryConfiguration)
{
this.telemetryClient = new TelemetryClient(telemetryConfiguration);
}
[FunctionName("HttpTrigger2")]
public Task<IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)]
HttpRequest req, ExecutionContext context, ILogger log)
{
DateTime start = DateTime.UtcNow;

string name = req.Query
.FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
.Value;
// Track an Event
var evt = new EventTelemetry("Function called");
evt.Context.User.Id = name;
this.telemetryClient.TrackEvent(evt);
// Track a Metric
var metric = new MetricTelemetry("Test Metric", DateTime.Now.Millisecond);
metric.Context.User.Id = name;
this.telemetryClient.TrackMetric(metric);
// Track a Dependency
var dependency = new DependencyTelemetry
{
Name = "GET api/planets/1/",
Target = "swapi.co",
Data = "https://swapi.co/api/planets/1/",
Timestamp = start,
Duration = DateTime.UtcNow - start,
Success = true
};
dependency.Context.User.Id = name;
this.telemetryClient.TrackDependency(dependency);
return Task.FromResult<IActionResult>(new OkResult());

}
}
}
Versão 1.x
using System;
using System.Net;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;
using System.Linq;
namespace functionapp0915
{
public static class HttpTrigger2
{
private static string key = TelemetryConfiguration.Active.InstrumentationKey =
System.Environment.GetEnvironmentVariable(
"APPINSIGHTS_INSTRUMENTATIONKEY", EnvironmentVariableTarget.Process);
private static TelemetryClient telemetryClient =

new TelemetryClient() { InstrumentationKey = key };
[FunctionName("HttpTrigger2")]
public static async Task<HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]
HttpRequestMessage req, ExecutionContext context, ILogger log)
{
DateTime start = DateTime.UtcNow;

string name = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
.Value;
// Get request body

dynamic data = await req.Content.ReadAsAsync<object>();
// Set name to query string or body data

// Track an Event
var evt = new EventTelemetry("Function called");
UpdateTelemetryContext(evt.Context, context, name);
telemetryClient.TrackEvent(evt);
// Track a Metric
var metric = new MetricTelemetry("Test Metric", DateTime.Now.Millisecond);
UpdateTelemetryContext(metric.Context, context, name);
telemetryClient.TrackMetric(metric);
// Track a Dependency
var dependency = new DependencyTelemetry
{
Name = "GET api/planets/1/",
Target = "swapi.co",
Data = "https://swapi.co/api/planets/1/",
Timestamp = start,
Duration = DateTime.UtcNow - start,
Success = true
};
UpdateTelemetryContext(dependency.Context, context, name);
telemetryClient.TrackDependency(dependency);
}
// Correlate all telemetry with the current Function invocation

private static void UpdateTelemetryContext(TelemetryContext context, ExecutionContext
functionContext, string userName)
{
context.Operation.Id = functionContext.InvocationId.ToString();
context.Operation.ParentId = functionContext.InvocationId.ToString();
context.Operation.Name = functionContext.FunctionName;
context.User.Id = userName;
}
}
}
Não chame TrackRequest ou StartOperation<RequestTelemetry> , pois você verá solicitações

duplicadas para uma invocação de função. O runtime do Functions controla automaticamente as
solicitações.
Não definir telemetryClient.Context.Operation.Id . Essa configuração global causa correlação
incorreta quando muitas funções são executadas simultaneamente. Em vez disso, crie uma nova
instância de telemetria ( DependencyTelemetry , EventTelemetry ) e modifique a propriedade Context .
Em seguida, passe a instância de telemetria para o método Track correspondente em
TelemetryClient ( TrackDependency() , TrackEvent() ). Esse método garante que a telemetria tenha os
detalhes de correlação corretos para a invocação de função atual.
Registrar telemetria personalizada em funções JavaScript

Aqui está um trecho de código de exemplo que envia telemetria personalizada com o Application
insights SDK do node. js:
const appInsights = require("applicationinsights");

appInsights.setup();
const client = appInsights.defaultClient;
module.exports = function (context, req) {

client.trackEvent({name: "my custom event", tagOverrides:{"ai.operation.id":

context.invocationId}, properties: {customProperty2: "custom property value"}});
client.trackException({exception: new Error("handled exceptions can be logged with this
method"), tagOverrides:{"ai.operation.id": context.invocationId}});
client.trackMetric({name: "custom metric", value: 3, tagOverrides:{"ai.operation.id":
context.invocationId}});
client.trackTrace({message: "trace message", tagOverrides:{"ai.operation.id":
context.invocationId}});
client.trackDependency({target:"http://dbname", name:"select customers proc", data:"SELECT *
FROM Customers", duration:231, resultCode:0, success: true, dependencyTypeName: "ZSQL",
tagOverrides:{"ai.operation.id": context.invocationId}});
client.trackRequest({name:"GET /customers", url:"http://myserver/customers", duration:309,
resultCode:200, success:true, tagOverrides:{"ai.operation.id": context.invocationId}});
context.done();
};
O parâmetro tagOverrides define o operation_Id para a ID de invocação da função. Essa

configuração permite que você correlacione toda a telemetria gerada automaticamente e a telemetria
personalizada para uma dada invocação de função.
Dependências
As funções v2 coletam automaticamente as dependências para solicitações HTTP, ServiceBus e SQL.
Você pode escrever código personalizado para mostrar as dependências. Para obter exemplos,
consulte o código de exemplo na C# seção telemetria personalizada. O código de exemplo resulta em
um mapa de aplicativo em Application insights semelhante à imagem a seguir:
Relatar problemas
Para relatar um problema com a integração do Application Insights em Functions ou para fazer
sugestões ou uma solicitação, crie um problema no GitHub.
Logs de streaming
Ao desenvolver um aplicativo, muitas vezes você deseja ver o que está sendo gravado nos logs em
tempo quase real durante a execução no Azure.
Há duas maneiras de exibir um fluxo de arquivos de log que está sendo gerado por suas execuções de
função.
Streaming de log interno: a plataforma do serviço de aplicativo permite que você exiba um
fluxo dos arquivos de log do aplicativo. Isso é equivalente à saída vista quando você depura
suas funções durante o desenvolvimento local e quando você usa a guia teste no Portal. Todas
as informações baseadas em log são exibidas. Para obter mais informações, consulte Stream
logs. Esse método de streaming dá suporte a apenas uma única instância e não pode ser usado
com um aplicativo em execução no Linux em um plano de consumo.
Live Metrics Stream: quando seu aplicativo de funções está conectado ao Application
insights, você pode exibir dados de log e outras métricas quase em tempo real no portal do
Azure usando Live Metrics Stream. Use esse método ao monitorar funções em execução em
várias instâncias ou no Linux em um plano de consumo. Esse método usa dados de amostra.
Os fluxos de log podem ser exibidos no portal e na maioria dos ambientes de desenvolvimento locais.
Portal
Você pode exibir os dois tipos de fluxos de log no Portal.
Para exibir os logs de streaming no portal, selecione a guia recursos da plataforma em seu
aplicativo de funções. Em seguida, em monitoramento, escolha streaming de log.
Isso conecta seu aplicativo ao serviço de streaming de log e os logs de aplicativo são exibidos na
janela. Você pode alternar entre logs do aplicativo e logs do servidor Web.
Live Metrics Stream
Para exibir o Live Metrics Stream para seu aplicativo, selecione a guia visão geral do seu aplicativo
de funções. Quando Application Insights habilita, você verá um link de Application insights em
recursos configurados. Esse link leva você até a página de Application Insights para seu aplicativo.
Em Application Insights, selecione Live Metrics Stream. As entradas de log de amostra são exibidas
em telemetria de exemplo.
Para ativar os logs de streaming para seu aplicativo de funções no Azure:
1. Selecione F1 para abrir a paleta de comandos e, em seguida, pesquise e execute o comando
Azure Functions: Inicie os logsde streaming.
2. Selecione seu aplicativo de funções no Azure e, em seguida, selecione Sim para habilitar o log
de aplicativo para o aplicativo de funções.
3. Dispare suas funções no Azure. Observe que os dados de log são exibidos na janela saída no
Visual Studio Code.
4. Quando terminar, lembre-se de executar o comando Azure Functions: Interrompa os logs
de streaming para desabilitar o registro em log para o aplicativo de funções.
Ferramentas principais
Use a logstream opção para começar a receber logs de streaming de um aplicativo de funções
específico em execução no Azure, como no exemplo a seguir:
func azure functionapp logstream <FunctionAppName>
Live Metrics Stream

Você também pode exibir o Live Metrics Stream para seu aplicativo de funções em uma nova janela
do navegador, --browser incluindo a opção, como no exemplo a seguir:
func azure functionapp logstream <FunctionAppName> --browser
Azure CLI
Você pode habilitar os logs de streaming usando o CLI do Azure. Use os comandos a seguir para
entrar, escolher sua assinatura e transmitir arquivos de log:
az login
az account list
az account set --subscription <subscriptionNameOrId>
az webapp log tail --resource-group <RESOURCE_GROUP_NAME> --name <FUNCTION_APP_NAME>
Azure PowerShell
Você pode habilitar os logs de streaming usando Azure PowerShell. Para o PowerShell, use os
seguintes comandos para adicionar sua conta do Azure, escolha sua assinatura e transmita os
arquivos de log:
Add-AzAccount
Get-AzSubscription
Get-AzSubscription -SubscriptionName "<subscription name>" | Select-AzSubscription
Get-AzWebSiteLog -Name <FUNCTION_APP_NAME> -Tail
Desabilitar o registro em log interno

Ao habilitar Application Insights, desabilite o log interno que usa o armazenamento do Azure. O
registro em log interno é útil para testes com cargas de trabalho leves, mas não se destina ao uso de
produção de alta carga. Para o monitoramento de produção, recomendamos Application Insights. Se
o registro em log interno for usado na produção, o registro de log poderá estar incompleto devido à
limitação no armazenamento do Azure.
Para desabilitar o registro em log interno, exclua a configuração de aplicativo AzureWebJobsDashboard .
Para obter informações sobre como excluir configurações do aplicativo no portal do Azure, consulte a
seção Configurações do aplicativo em Como gerenciar um aplicativo de funções. Antes de excluir a
configuração do aplicativo, certifique-se de que nenhuma função existente no mesmo aplicativo de
funções use a configuração para gatilhos ou associações do armazenamento do Azure.
Próximos passos
Registro em log de ASP.NET Core
Azure Functions de monitoramento com logs de
Azure Monitor
O Azure Functions oferece uma integração com Azure monitor logs para monitorar funções. Este artigo mostra
como configurar Azure Functions para enviar logs gerados pelo sistema e pelo usuário a logs do Azure Monitor.
Os logs de Azure Monitor fornecem a capacidade de consolidar logs de diferentes recursos no mesmo espaço de
trabalho, onde podem ser analisados com consultas para recuperar, consolidar e analisar rapidamente os dados
coletados. É possível criar e testar consultas usando o Log Analytics no portal do Azure e, em seguida, analisar
diretamente os dados usando essas ferramentas ou salvar consultas para uso com visualizações ou regras de
alerta.
O Azure Monitor usa uma versão da linguagem de consulta Kusto usada pelo Azure Data Explorer que é adequada
para consultas de log simples, mas também inclui funcionalidades avançadas como agregações, junções e análises
inteligentes. É possível aprender a linguagem de consulta rapidamente por meio de várias lições.
NOTE
A integração com os logs de Azure Monitor está atualmente em visualização pública para aplicativos de funções em execução
no consumo do Windows, Premium e planos de hospedagem dedicados.
Configurando
Na seção monitoramento, selecione configurações de diagnóstico e clique em Adicionar.
Na página configuração, escolha Enviar para log Analyticse, em log , escolha FunctionAppLogs, essa tabela
contém os logs desejados.
Logs gerados pelo usuário

Para gerar logs personalizados, você pode usar a instrução de log específica, dependendo do seu idioma, aqui estão
os trechos de código de exemplo:
JavaScript
context.log('My app logs here.');
Python
logging.info('My app logs here.')
.NET
log.LogInformation("My app logs here.");
Java
context.getLogger().info("My app logs here.");
PowerShell
Write-Host "My app logs here."
Consultando os logs
Para consultar os logs gerados, vá para o espaço de trabalho do log Analytics e clique em logs.
Azure Functions grava todos os logs na tabela FunctionAppLogs , aqui estão algumas consultas de exemplo.
Todos os logs
FunctionAppLogs
| order by TimeGenerated desc
Logs de função específicos

FunctionAppLogs
| where FunctionName == "<Function name>"
Exceções
FunctionAppLogs
| where ExceptionDetails != ""
| order by TimeGenerated asc
Próximos passos
Examinar a visão geral de Azure Functions
Saiba mais sobre os logs de Azure monitor
Saiba mais sobre a linguagem de consulta.
Adicionar um certificado SSL no Serviço de
Aplicativo do Azure
O Serviço de Aplicativo do Azure fornece um serviço de hospedagem na Web altamente escalonável e com
aplicação automática de patches. Este artigo mostra como criar, carregar ou importar um certificado privado ou
público no Serviço de Aplicativo.
Depois que o certificado for adicionado ao aplicativo Serviço de Aplicativo ou aplicativo de funções, você poderá
proteger um nome DNS personalizado com ele ou usá-lo em seu código do aplicativo.
A tabela a seguir lista as opções disponíveis para adição de certificados no Serviço de Aplicativo:
OPÇÃO DESCRIÇÃO
Criar um Certificado gratuito gerenciado pelo Serviço de Um certificado privado fácil de usar se você só precisa
Aplicativo (versão prévia) proteger seu domínio personalizado www ou qualquer
domínio não raiz no Serviço de Aplicativo.
Comprar um certificado do Serviço de Aplicativo Um certificado privado gerenciado pelo Azure. Ele combina a
simplicidade do gerenciamento automatizado de certificado e
a flexibilidade das opções de renovação e exportação.
Importar um certificado do Key Vault Útil se você usar o Azure Key Vault para gerenciar seus
certificados PKCS12. Consulte Requisitos do certificado
privado.
Carregar um certificado privado Se você já tiver um certificado privado de um provedor de

terceiros, poderá carregá-lo. Consulte Requisitos do certificado
privado.
Carregar um certificado público Os certificados públicos não são usados para proteger
domínios personalizados, mas você pode carregá-los em seu
código se precisar que eles acessem recursos remotos.
Pré-requisitos
Para seguir este guia de instruções, é necessário ter:
Crie um aplicativo do Serviço de Aplicativo.
Somente para certificado gratuito: mapeie um subdomínio (por exemplo, www.contoso.com ) para o Serviço de
Aplicativo com um registro CNAME.
Requisitos do certificado privado

O Certificado gratuito gerenciado pelo Serviço de Aplicativo ou o certificado do Serviço de Aplicativo já atende aos
requisitos do Serviço de Aplicativo. Se você optar por carregar ou importar um certificado privado no Serviço de
Aplicativo, o certificado deverá atender aos seguintes requisitos:
Deverá ser exportado como um arquivo PFX protegido por senha
Conter chave privada com pelo menos 2.048 bits de extensão
Conter todos os certificados intermediários na cadeia de certificados
Para proteger um domínio personalizado em uma associação SSL, o certificado tem requisitos adicionais:
Contém um Uso estendido de chave para autenticação do servidor (OID = 1.3.6.1.5.5.7.3.1)
Assinado por uma autoridade de certificado confiável
NOTE
Os certificados ECC (Criptografia de Curva Elíptica) podem funcionar com o Serviço de Aplicativo, mas não são
abordados neste artigo. Trabalhe com sua autoridade de certificação seguindo exatamente estas etapas para criar certificados
ECC.
Preparar o aplicativo Web

Para associar um certificado SSL personalizado (um certificado de terceiros ou certificado de Serviço de
Aplicativo) ao aplicativo Web, o Plano do Serviço de Aplicativo deve estar na camada Básico, Standard, Premium
ou Isolado. Nesta etapa, você precisa ter certeza de que seu aplicativo Web está no tipo de preço com suporte.
Entrar no Azure
Abra o Portal do Azure.
Navegue até seu aplicativo Web
Pesquise e selecione Serviços de Aplicativos.
Na página Serviços de Aplicativos, selecione o nome do seu aplicativo do Azure.

Você aterrissou na página de gerenciamento do aplicativo Web.
Verifique o tipo de preço
No painel de navegação à esquerda da página do aplicativo Web, role até a seção Configurações e selecione
Escalar verticalmente (plano do Serviço de Aplicativo) .
Certifique-se de que o aplicativo Web não esteja na camada F1 ou D1. A camada atual do seu aplicativo Web é
realçada por uma caixa azul escuro.
Não há suporte para SSL personalizado na camada F1 ou D1. Se precisar escalar verticalmente, siga as etapas da
próxima seção. Caso contrário, feche a página Aumentar e ignore a seção Aumentar seu plano do Serviço de
Aplicativo.
Escalar verticalmente seu Plano do Serviço de Aplicativo
Selecione qualquer uma das camadas não gratuitas (B1, B2, B3 ou qualquer camada na categoria Produção). Para
obter opções adicionais, clique em Ver opções adicionais.
Clique em Aplicar.
Quando você receber a notificação a seguir, a operação de escala terá sido concluída.
Criar um certificado gratuito (versão prévia)

O Certificado gratuito gerenciado pelo Serviço de Aplicativo é uma solução imediata para proteção de seu nome
DNS personalizado no Serviço de Aplicativo. É um certificado SSL totalmente funcional gerenciado pelo Serviço
de Aplicativo e renovado automaticamente. O certificado gratuito apresenta as seguintes limitações:
Não oferece suporte a domínios raiz.
Não pode ser exportado.
Para criar um Certificado gratuito gerenciado pelo Serviço de Aplicativo:
No portal do Azure, no menu à esquerda, selecione Serviços de Aplicativos > <nome_do_aplicativo> .
No painel de navegação à esquerda em seu aplicativo, selecione Configurações de TLS/SSL > Certificados de
Chave Privada (.pfx) > Criar Certificado Gerenciado do Serviço de Aplicativo.
Qualquer domínio não raiz que esteja adequadamente mapeado para seu aplicativo com um registro CNAME
estará listado na caixa de diálogo. Selecione o domínio personalizado para criar um certificado gratuito e selecione
Criar. Só é possível criar apenas um certificado para cada domínio personalizado compatível.
Quando a operação for concluída, você verá o certificado na lista Certificados de Chave Privada.
IMPORTANT
Para proteger um domínio personalizado com esse certificado, ainda é necessário criar uma associação de certificado. Execute
as etapas em Criar associação.
Importar um Certificado do Serviço de Aplicativo

Se você comprar um Certificado do Serviço de Aplicativo no Azure, o Azure será responsável por:
Cuidar do processo de compra no GoDaddy.
Executar a verificação de domínio do certificado.
Manter o certificado no Azure Key Vault.
Gerenciar a renovação do certificado (consulte Renovar certificado ).
Sincronizar automaticamente o certificado com as cópias importadas nos aplicativos do Serviço de Aplicativo.
Para comprar um certificado do Serviço de Aplicativo, acesse Iniciar o pedido de certificado.
Se você já tiver um certificado funcional do Serviço de Aplicativo, poderá:
Importar o certificado no Serviço de Aplicativo.
Gerenciar o certificado, por exemplo, renovar, rechavear e exportá-lo.
Iniciar o pedido de certificado
Inicie um pedido de certificado de Serviço de Aplicativo na página de criação de Certificado do Serviço de
Aplicativo.
Use a tabela a seguir para ajudá-lo a configurar o certificado. Ao terminar, clique em Criar.
NOME Um nome amigável para o seu certificado de Serviço de

Aplicativo.
Nome do Host do Domínio Raiz Especifique o domínio raiz aqui. O certificado emitido protege
ambos, o domínio raiz e o subdomínio www . No certificado
emitido, o campo Nome Comum contém o domínio raiz, e o
campo Nome Alternativo da Entidade contém o domínio www
. Para proteger apenas um subdomínio qualquer, especifique
aqui o nome de domínio totalmente qualificado do
subdomínio (por exemplo, mysubdomain.contoso.com ).
Subscription O datacenter onde o aplicativo Web está hospedado.
Resource group O grupo de recursos que contém o certificado. Você pode

usar um novo grupo de recursos ou selecionar o mesmo
grupo de recursos que seu aplicativo de Serviço de Aplicativo,
por exemplo.
Certificado SKU Determina o tipo de certificado para criar, se um certificado

padrão ou uma certificado curinga.
Termos legais Clique para confirmar que você concorda com os termos
legais. Os certificados são obtidos no GoDaddy.
Armazenar no Azure Key Vault

Quando o processo de compra do certificado tiver sido concluído, haverá mais algumas etapas a serem concluídas
antes de começar a usar esse certificado.
Selecione o certificado na página Certificados do Serviço de Aplicativo e, em seguida, clique em Configuração do
Certificado > Etapa 1: armazenar.
O Cofre da Chave do Azure ajuda a proteger chaves criptográficas e segredos usados por aplicativos e serviços em
nuvem. É o armazenamento de escolha para certificados de Serviço de Aplicativo.
Na página Status do Key Vault, clique em Repositório do Key Vault para criar um novo cofre ou escolher um
cofre existente. Se você optar por criar um novo cofre, use a tabela a seguir para ajudá-lo a configurar o cofre e
clique em Criar. veja para criar novo Key Vault no mesmo grupo de recursos e assinatura.
NOME Um nome exclusivo que consiste em caracteres alfanuméricos

e traços.
Resource group Como recomendação, selecione o mesmo grupo de recursos

do seu certificado de Serviço de Aplicativo.
Location Selecione o mesmo local que o aplicativo de Serviço de

Aplicativo.
Tipo de preço Para obter mais informações, confira Detalhes de preços do

Azure Key Vault.
Políticas de acesso Define os aplicativos e o acesso permitido aos recursos do

cofre. Você pode configurá-lo mais tarde seguindo as etapas
em Conceder acesso de vários aplicativos a um cofre de
chaves.
Acesso à Rede Virtual Restringir o acesso do cofre a determinadas redes virtuais do

Azure. Você pode configurá-lo mais tarde seguindo as etapas
em Configurar o Redes Virtuais e Firewall do Azure Key Vault
Depois de selecionar o cofre, feche a página Repositório do Key Vault. A opção Armazenar deve mostrar uma
marca de seleção verde para sucesso. Mantenha a página aberta para a próxima etapa.
Verificar a propriedade de domínio
Na mesma página Configuração do Certificado usada na última etapa, clique em Etapa 2: verificar.
Selecione Verificação do Serviço de Aplicativo. Uma vez que você já mapeou o domínio ao seu aplicativo Web
(veja Pré-requisitos), ele já foi verificado. Basta clicar em Verificar para concluir esta etapa. Clique no botão
Atualizar até que a mensagem O Certificado tem Domínio Verificado seja exibida.
NOTE
Há suporte para quatro tipos de métodos de verificação de domínio:
Serviço de Aplicativo – a opção mais conveniente quando o domínio já está mapeado para um aplicativo do Serviço de
Aplicativo na mesma assinatura. Ela tira proveito do fato de que o aplicativo de Serviço de Aplicativo já verificou a
propriedade de domínio.
Domínio – verifique um domínio do Serviço de Aplicativo que você adquiriu do Azure. O Azure adiciona automaticamente
a verificação do registro TXT para você e conclui o processo.
Email – verifique o domínio enviando um email para o administrador de domínio. As instruções são fornecidas quando
você seleciona a opção.
Manual – verifique o domínio usando uma página HTML (apenas certificado Standard) ou um registro TXT do DNS. As
instruções são fornecidas quando você seleciona a opção.
Importar o certificado para o Serviço de Aplicativo

No painel de navegação à esquerda de seu aplicativo, selecione Configurações de TLS/SSL > Certificados de
Chave Privada (.pfx) > Importar Certificado do Serviço de Aplicativo.
Selecione o certificado que você acabou de comprar e selecione OK.

IMPORTANT
Importar um certificado do Key Vault

Se você usa o Azure Key Vault para gerenciar seus certificados, pode importar um certificado PKCS12 do Key Vault
para o Serviço de Aplicativo, contanto que ele atenda aos requisitos.
Chave Privada (.pfx) > Importar Certificado do Key Vault.
)
Use a tabela a seguir para selecionar o certificado.
Subscription A assinatura à qual o Key Vault pertence.
Key Vault O cofre com o certificado que você quer importar.
Certificado Selecione na lista de certificados PKCS12 no cofre. Todos os

certificados PKCS12 no cofre são listados com suas impressões
digitais, mas nem todos têm suporte no Serviço de Aplicativo.
Quando a operação for concluída, você verá o certificado na lista Certificados de Chave Privada. Se a
importação falhar com um erro, o certificado não atenderá aos requisitos do Serviço de Aplicativo.
IMPORTANT
Carregar um certificado privado

Depois de obter um certificado do provedor de certificados, siga as etapas desta seção para prepará-lo para o
Serviço de Aplicativo.
Mesclar certificados intermediários
Se a autoridade de certificação fornecer vários certificados na cadeia de certificados, você precisará mesclar os
certificados na ordem.
Para fazer isso, abra cada certificado recebido em um editor de texto.
Crie um arquivo para o certificado mesclado, chamado mergedcertificate.crt. Em um editor de texto, copie o
conteúdo de cada certificado para esse arquivo. A ordem de seus certificados deve seguir a ordem na cadeia de
certificados, começando com o seu certificado e terminando com o certificado raiz. Ela se parece com o seguinte
exemplo:
-----BEGIN CERTIFICATE-----
<your entire Base64 encoded SSL certificate>
-----END CERTIFICATE-----
<The entire Base64 encoded intermediate certificate 1>
<The entire Base64 encoded intermediate certificate 2>
<The entire Base64 encoded root certificate>
Exportar o certificado para PFX

Exporte o certificado SSL mesclado com a chave privada com a qual a solicitação de certificado foi gerada.
Se você gerou a solicitação de certificado usando o OpenSSL, isso significa que você criou um arquivo de chave
privada. Para exportar o certificado para PFX, execute o comando a seguir. Substitua os espaços reservados
<private-key-file> e <merged -certificate-file> pelos caminhos para a sua chave privada e o arquivo de certificado
mesclado.
openssl pkcs12 -export -out myserver.pfx -inkey <private-key-file> -in <merged-certificate-file>
Quando solicitado, defina uma senha de exportação. Você usará essa senha quando carregar o certificado SSL
para o Serviço de Aplicativo posteriormente.
Se você usou o IIS ou o Certreq.exe para gerar a solicitação de certificado, instale o certificado no computador
local e, em seguida, exporte o certificado para PFX .
Carregar certificado no Serviço de Aplicativo
Agora você está pronto para carregar o certificado no Serviço de Aplicativo.
Chave Privada (.pfx) > Carregar Certificado.
Em Arquivo de Certificado PFX, selecione o arquivo PFX. Em Senha do certificado, digite a senha que você
criou ao exportar o arquivo PFX. Ao terminar, clique em Carregar.
IMPORTANT
Carregar um certificado público

Há suporte para certificados públicos no formato .cer.
No painel de navegação à esquerda de seu aplicativo, clique em Configurações de TLS/SSL > Certificados
Públicos (.cer) > Carregar o Certificado de Chave Pública.
Em Nome, digite um nome para o certificado. Em Arquivo de Certificado CER, selecione o arquivo CER.
Clique em Carregar.
Após o carregamento do certificado, copie a impressão digital do certificado e consulte Tornar o certificado
acessível.
Gerenciar certificados do Serviço de Aplicativo

Esta seção mostra como gerenciar um certificado do Serviço de Aplicativo comprado em Importar um certificado
do Serviço de Aplicativo.
Rechavear o certificado
Renovar o certificado
Exportar o certificado
Excluir o certificado
Rechavear o certificado
Se você acha que a chave privada do seu certificado está comprometida, pode rechaveá-lo. Selecione o certificado
na página Certificados do Serviço de Aplicativo e, em seguida, selecione Rechaveamento e Sincronização na
navegação à esquerda.
Clique em Rechavear para iniciar o processo. Esse processo pode demorar de um a 10 minutos para ser
concluído.
A criação de uma nova chave para o certificado causará a emissão de um novo certificado pela autoridade de
certificação.
Após a conclusão da operação de rechaveamento, clique em Sincronizar. A operação de sincronização atualiza
automaticamente as associações de nome de host do certificado no Serviço de Aplicativo sem causar tempo de
inatividade em seus aplicativos.
NOTE
Se você não clicar em Sincronizar, o Serviço de Aplicativo sincronizará automaticamente seu certificado dentro de 48 horas.
Renovar certificado
Para ativar a renovação automática do seu certificado a qualquer momento, selecione o certificado na página
Certificados do Serviço de Aplicativo e clique em Configurações de Renovação Automática no painel de
navegação à esquerda. Por padrão, os certificados do Serviço de Aplicativo têm um período de validade de um ano.
Selecione Ativado e clique em Salvar. Os certificados poderão iniciar automaticamente renovação 60 dias antes
do término se você tiver ativado a renovação automática.
Para renovar manualmente o certificado, clique em Renovação Manual. Você pode solicitar renovar
manualmente o certificado de 60 dias antes da expiração.
Após a conclusão da operação de renovação, clique em Sincronizar. A operação de sincronização atualiza
automaticamente as associações de nome de host do certificado no Serviço de Aplicativo sem causar tempo de
inatividade em seus aplicativos.
NOTE
Se você não clicar em Sincronizar, o Serviço de Aplicativo sincronizará automaticamente seu certificado dentro de 48 horas.
Exportar o certificado
Como o certificado do Serviço de Aplicativo é um segredo do Key Vault, você pode exportar uma cópia em PFX
dele e usá-lo para outros serviços do Azure ou fora do Azure.
Para exportar o Certificado do Serviço de Aplicativo como um arquivo PFX, execute os seguintes comandos no
Cloud Shell. Você também poderá executá-lo localmente se tiver instalado a CLI do Azure. Substitua os espaços
reservados pelos nomes que você usou ao criar o certificado do Serviço de Aplicativo.
secretname=$(az resource show \

--resource-group <group-name> \
--resource-type "Microsoft.CertificateRegistration/certificateOrders" \
--name <app-service-cert-name> \
--query "properties.certificates.<app-service-cert-name>.keyVaultSecretName" \
--output tsv)
az keyvault secret download \

--file appservicecertificate.pfx \
--vault-name <key-vault-name> \
--name $secretname \
--encoding base64
O arquivo appservicecertificate.pfx baixado é um arquivo PKCS12 bruto que contém os certificados públicos e
privados. Sempre que receber a solicitação, a senha de importação e a frase secreta de PEM serão a cadeia de
caracteres vazia.
Excluir Certificado
A exclusão de um certificado do Serviço de Aplicativo é final e irreversível. Qualquer associação no Serviço de
Aplicativo com esse certificado ficará inválida. Para evitar a exclusão acidental, o Azure coloca um bloqueio no
certificado. Para excluir um certificado do Serviço de Aplicativo, primeiro remova o bloqueio de exclusão no
certificado.
Selecione o certificado na página Certificados do Serviço de Aplicativo e, em seguida, selecione Bloqueios na
navegação à esquerda.
Localize o bloqueio em seu certificado com o tipo de bloqueio Exclusão. À direita, selecione Excluir.
Agora você pode excluir o certificado do Serviço de Aplicativo. Na navegação à esquerda, selecione Visão Geral >
Excluir. Na caixa de diálogo de confirmação, digite o nome do certificado e selecione OK.
Automatizar com scripts
CLI do Azure
#!/bin/bash
fqdn=<replace-with-www.{yourdomain}>
pfxPath=<replace-with-path-to-your-.PFX-file>
pfxPassword=<replace-with-your=.PFX-password>
resourceGroup=myResourceGroup
webappname=mywebapp$RANDOM
# Create a resource group.

az group create --location westeurope --name $resourceGroup
# Create an App Service plan in Basic tier (minimum required by custom domains).
az appservice plan create --name $webappname --resource-group $resourceGroup --sku B1
# Create a web app.

az webapp create --name $webappname --resource-group $resourceGroup \
--plan $webappname
echo "Configure a CNAME record that maps $fqdn to $webappname.azurewebsites.net"

read -p "Press [Enter] key when ready ..."
# Before continuing, go to your DNS configuration UI for your custom domain and follow the
# instructions at https://aka.ms/appservicecustomdns to configure a CNAME record for the
# hostname "www" and point it your web app's default domain name.
# Map your prepared custom domain name to the web app.

az webapp config hostname add --webapp-name $webappname --resource-group $resourceGroup \
--hostname $fqdn
# Upload the SSL certificate and get the thumbprint.

thumbprint=$(az webapp config ssl upload --certificate-file $pfxPath \
--certificate-password $pfxPassword --name $webappname --resource-group $resourceGroup \
--query thumbprint --output tsv)
# Binds the uploaded SSL certificate to the web app.

az webapp config ssl bind --certificate-thumbprint $thumbprint --ssl-type SNI \
--name $webappname --resource-group $resourceGroup
echo "You can now browse to https://$fqdn"
PowerShell
$fqdn="<Replace with your custom domain name>"
$pfxPath="<Replace with path to your .PFX file>"
$pfxPassword="<Replace with your .PFX password>"
$webappname="mywebapp$(Get-Random)"
$location="West Europe"

New-AzResourceGroup -Name $webappname -Location $location
# Create an App Service plan in Free tier.

New-AzAppServicePlan -Name $webappname -Location $location `
-ResourceGroupName $webappname -Tier Free
# Create a web app.

New-AzWebApp -Name $webappname -Location $location -AppServicePlan $webappname `
-ResourceGroupName $webappname
Write-Host "Configure a CNAME record that maps $fqdn to $webappname.azurewebsites.net"

Read-Host "Press [Enter] key when ready ..."
# Before continuing, go to your DNS configuration UI for your custom domain and follow the
# instructions at https://aka.ms/appservicecustomdns to configure a CNAME record for the
# hostname "www" and point it your web app's default domain name.
# Upgrade App Service plan to Basic tier (minimum required by custom SSL certificates)
Set-AzAppServicePlan -Name $webappname -ResourceGroupName $webappname `
-Tier Basic
# Add a custom domain name to the web app.

Set-AzWebApp -Name $webappname -ResourceGroupName $webappname `
-HostNames @($fqdn,"$webappname.azurewebsites.net")
# Upload and bind the SSL certificate to the web app.

New-AzWebAppSSLBinding -WebAppName $webappname -ResourceGroupName $webappname -Name $fqdn `
-CertificateFilePath $pfxPath -CertificatePassword $pfxPassword -SslState SniEnabled
Mais recursos
Proteger um nome DNS personalizado com uma associação SSL
Impor HTTPS
Impor o TLS 1.1/1.2
Usar um certificado SSL no código do aplicativo
Perguntas frequentes: Certificados do Serviço de Aplicativo
Configurar seu aplicativo do serviço de aplicativo
para usar o logon do Azure AD
Este artigo mostra como configurar Azure App serviço para usar o Azure Active Directory (AD do Azure) como
um provedor de autenticação.
NOTE
Neste momento, Azure App serviço e Azure Functions só têm suporte do Azure AD v 1.0. Eles não têm suporte da
plataforma Microsoft Identity v 2.0, que inclui MSAL (bibliotecas de autenticação da Microsoft).
Siga estas práticas recomendadas ao configurar seu aplicativo e a autenticação:

Dê a cada aplicativo do serviço de aplicativo suas próprias permissões e consentimento.
Configure cada aplicativo do serviço de aplicativo com seu próprio registro.
Evite o compartilhamento de permissão entre ambientes usando registros de aplicativo separados para slots
de implantação separados. Ao testar o novo código, essa prática pode ajudar a evitar problemas de afetar o
aplicativo de produção.
Configurar com configurações expressas

1. Na portal do Azure, vá para o aplicativo do serviço de aplicativo.
2. Selecione configurações > autenticação/autorização no painel esquerdo e verifique se a autenticação
do serviço de aplicativo está ativada.
3. Selecione Azure Active Directorye, em seguida, selecione Expresso no Modo de Gerenciamento.
4. Selecione OK para registrar o aplicativo do Serviço de Aplicativo no Azure Active Directory. Um novo
registro de aplicativo é criado.
Se você quiser escolher um registro de aplicativo existente, em vez disso:
a. Escolha selecionar um aplicativo existente e procure o nome de um registro de aplicativo criado
anteriormente em seu locatário.
b. Selecione o registro do aplicativo e, em seguida, selecione OK.
c. Em seguida, selecione OK na página configurações de Azure Active Directory.
Por padrão, o serviço de aplicativo fornece autenticação, mas não restringe o acesso autorizado ao
conteúdo e às APIs do site. Você deve autorizar os usuários no código do aplicativo.
5. Adicional Para restringir o acesso do aplicativo somente aos usuários autenticados pelo Azure Active
Directory, defina a ação a ser tomada quando a solicitação não for autenticada para fazer logon
com Azure Active Directory. Quando você define essa funcionalidade, seu aplicativo requer que todas as
solicitações sejam autenticadas. Ele também redireciona todas as Azure Active Directory não autenticadas
para autenticação.
Cau t i on
Restringir o acesso dessa maneira se aplica a todas as chamadas para seu aplicativo, o que pode não ser
desejável para aplicativos que têm um home page publicamente disponível, como em muitos aplicativos de
página única. Para tais aplicativos, Permitir solicitações anônimas (nenhuma ação) pode ser preferível,
com o aplicativo iniciando o logon manualmente. Para obter mais informações, consulte fluxo de
autenticação.
6. Clique em Salvar.
Configurar com configurações avançadas

Você pode definir as configurações do aplicativo manualmente se quiser usar um locatário do AD do Azure que
seja diferente daquele usado para entrar no Azure. Para concluir essa configuração personalizada, você precisará:
1. Crie um registro no Azure AD.
2. Forneça alguns dos detalhes de registro para o serviço de aplicativo.
Criar um registro de aplicativo no Azure ad para seu aplicativo do serviço de aplicativo
Você precisará das seguintes informações ao configurar seu aplicativo do serviço de aplicativo:
ID do cliente
ID do locatário
Segredo do cliente (opcional)
URI da ID do aplicativo
Execute as seguintes etapas:
1. Entre no portal do Azure e vá para o aplicativo do serviço de aplicativo. Anote a URLdo seu aplicativo.
Você o usará para configurar o registro do aplicativo Azure Active Directory.
2. Selecione Azure Active Directory > Registros de aplicativo novo registro > .
3. Na página registrar um aplicativo , insira um nome para o registro do aplicativo.
4. Em URI de redirecionamento, selecione Web e insira a URL do seu aplicativo do serviço de aplicativo e
acrescente o caminho /.auth/login/aad/callback . Por exemplo:
https://contoso.azurewebsites.net/.auth/login/aad/callback .
5. Selecione Criar.
6. Depois que o registro do aplicativo for criado, copie a ID do aplicativo (cliente) e a ID do diretório
(locatário) para mais tarde.
7. Selecione identidade visual. Na URL da Home Page, insira a URL do seu aplicativo do serviço de
aplicativo e selecione salvar.
8. Selecione expor uma API > conjunto. Cole a URL do aplicativo do serviço de aplicativo e selecione
salvar.
NOTE
Esse valor é o URI de ID do aplicativo do registro do aplicativo. Se seu aplicativo Web exigir acesso a uma API na
nuvem, você precisará do URI de ID de aplicativo do aplicativo Web ao configurar o recurso de serviço de
aplicativo de nuvem. Você pode usar isso, por exemplo, se desejar que o serviço de nuvem Conceda explicitamente
acesso ao aplicativo Web.
9. Selecione Adicionar um escopo.

a. Em nome do escopo, insira user_impersonation.
b. Nas caixas de texto, insira o nome do escopo de consentimento e a descrição que você deseja que os
usuários vejam na página de consentimento. Por exemplo, digite acessar meu aplicativo.
c. Selecione Adicionar escopo.
10. Adicional Para criar um segredo do cliente, selecione certificados & segredos > novo segredo do
cliente > Adicionar. Copie o valor do segredo do cliente mostrado na página. Não será mostrado
novamente.
11. Adicional Para adicionar várias URLs de resposta, selecione autenticação.
Adicionar informações do Azure Active Directory ao aplicativo do Serviço de Aplicativo
2. Selecione configurações > autenticação/autorização no painel esquerdo e verifique se a autenticação
do serviço de aplicativo está ativada.
3. Adicional Por padrão, a autenticação do serviço de aplicativo permite o acesso não autenticado ao seu
aplicativo. Para impor a autenticação de usuário, defina a ação a ser tomada quando a solicitação não
for autenticada para fazer logon com Azure Active Directory.
4. Em provedores de autenticação, selecione Azure Active Directory.
5. Em modo de gerenciamento, selecione avançado e configure a autenticação do serviço de aplicativo de
acordo com a tabela a seguir:
CAMPO DESCRIÇÃO
ID do cliente Use a ID do aplicativo (cliente) do registro do

aplicativo.
ID do emissor Use https://login.microsoftonline.com/<tenant-id>

e substitua <tenant-id > com a ID do diretório
(locatário) do registro do aplicativo.
Segredo do cliente (opcional) Use o segredo do cliente gerado no registro do aplicativo.
Públicos de token permitidos Se este for um aplicativo de nuvem ou de servidor e você

quiser permitir tokens de autenticação de um aplicativo
Web, adicione o URI de ID de aplicativo do aplicativo
Web aqui.
NOTE
A ID do cliente configurada sempre é considerada implicitamente como um público permitido, independentemente
de como você configurou os públicos de token permitidos.
6. Selecione OK e, em seguida, Salvar.

Agora você está pronto para usar Azure Active Directory para autenticação em seu aplicativo do serviço de
aplicativo.
Configurar um aplicativo de cliente nativo

Você pode registrar clientes nativos para permitir a autenticação usando uma biblioteca de cliente, como o
biblioteca de autenticação do Active Directory.
1. Na portal do Azure, selecione Active Directory > registros de aplicativo > novo registro.
2. Na página registrar um aplicativo , insira um nome para o registro do aplicativo.
3. Em URI de redirecionamento, selecione cliente público (Mobile & Desktop) e insira a URL do seu
aplicativo do serviço de aplicativo e acrescente o caminho /.auth/login/aad/callback . Por exemplo:
https://contoso.azurewebsites.net/.auth/login/aad/callback .
4. Selecione Criar.
NOTE
Para um aplicativo do Windows, use o SID do pacote como o URI em vez disso.
5. Depois que o registro do aplicativo for criado, copie o valor da ID do aplicativo (cliente) .
6. Selecione permissões de API > adicionar uma permissão > minhas APIs.
7. Selecione o registro de aplicativo que você criou anteriormente para seu aplicativo do serviço de aplicativo.
Se você não vir o registro do aplicativo, certifique-se de ter adicionado o escopo user_impersonation em
criar um registro de aplicativo no Azure ad para seu aplicativo do serviço de aplicativo.
8. Selecione user_impersonatione, em seguida, selecione adicionar permissões.
Você já configurou um aplicativo de cliente nativo que pode acessar seu aplicativo do Serviço de aplicativo.
Próximas etapas
Visão geral de autenticação/autorização do serviço de aplicativo.
Uso avançado de autenticação e autorização no serviço Azure App
Adicione autenticação ao seu aplicativo móvel: Ios, Android, Windows universal, xamarin. Android, xamarin.
Ios, xamarin. Forms, Cordova.
para usar o logon do Facebook
Este artigo mostra como configurar Azure App serviço para usar o Facebook como um provedor de autenticação.
Para concluir o procedimento neste artigo, você precisa de uma conta do Facebook que tenha um endereço de
email verificado e um número de telefone celular. Para criar uma nova conta do Facebook, vá para facebook.com.
Registrar seu aplicativo com o Facebook

1. Vá para o site de desenvolvedores do Facebook e entre com suas credenciais de conta do Facebook.
Se você não tiver uma conta do Facebook para desenvolvedores, selecione introdução e siga as etapas de
registro.
2. Selecione meus aplicativos > Adicionar novo aplicativo.
3. No campo nome de exibição :
a. Digite um nome exclusivo para seu aplicativo.
b. Forneça seu email de contato.
c. Selecione criar ID do aplicativo.
d. Conclua a verificação de segurança.
O painel do desenvolvedor para seu novo aplicativo do Facebook é aberto.
4. Selecione painel > logon do Facebook > Configuraro > Web.
5. No painel de navegação esquerdo, em logon do Facebook, selecione configurações.
6. No campo URIs de redirecionamento OAuth válidos , insira
https://<app-name>.azurewebsites.net/.auth/login/facebook/callback . Lembre-se de substituir <app-name>
pelo nome do seu aplicativo de serviço de Azure App.
7. Selecione Salvar alterações.
8. No painel esquerdo, selecione configurações > básico.
9. No campo segredo do aplicativo , selecione Mostrar. Copie os valores da ID do aplicativo e do
segredo do aplicativo. Você os usará posteriormente para configurar seu aplicativo do serviço de
aplicativo no Azure.
IMPORTANT
O segredo do aplicativo é uma credencial de segurança importante. Não compartilhe essa senha com ninguém nem
distribua-a em um aplicativo cliente.
10. A conta do Facebook que você usou para registrar o aplicativo é um administrador do aplicativo. Neste
ponto, somente os administradores podem entrar neste aplicativo.
Para autenticar outras contas do Facebook, selecione revisão do aplicativo e habilite Make <your-App-
Name > público para permitir que o público geral acesse o aplicativo usando a autenticação do Facebook.
Adicionar informações do Facebook ao seu aplicativo
1. Entre no portal do Azure e navegue até o aplicativo do serviço de aplicativo.
2. Selecione configurações > autenticação/autorizaçãoe verifique se a autenticação do serviço de
aplicativo está ativada.
3. Selecione Facebooke cole os valores de ID do aplicativo e segredo do aplicativo que você obteve
anteriormente. Habilite todos os escopos necessários para seu aplicativo.
4. Selecione OK.
conteúdo e às APIs do site. Você precisa autorizar usuários em seu código de aplicativo.
5. Adicional Para restringir o acesso somente aos usuários autenticados pelo Facebook, defina a ação a ser
tomada quando a solicitação não for autenticada no Facebook. Quando você define essa
funcionalidade, seu aplicativo requer que todas as solicitações sejam autenticadas. Ele também redireciona
todas as solicitações não autenticadas para o Facebook para autenticação.
Cau t i on
página única. Para tais aplicativos, Permitir solicitações anônimas (nenhuma ação) pode ser preferível
para que o aplicativo inicie manualmente a autenticação em si. Para obter mais informações, consulte fluxo
de autenticação.
Agora você está pronto para usar o Facebook para autenticação em seu aplicativo.
Próximas etapas
para usar o logon do Google
Este tópico mostra como configurar o Serviço de Aplicativo do Azure para usar o Google como um provedor de
autenticação.
Para concluir o procedimento neste tópico, você deve ter uma conta do Google com um endereço de email
verificado. Para criar uma nova conta do Google, vá para accounts.google.com.
Registre seu aplicativo com o Google

1. Siga a documentação do Google na entrada do Google para aplicativos do lado do servidor para criar uma
ID do cliente e um segredo do cliente. Não há necessidade de fazer nenhuma alteração de código. Basta
usar as seguintes informações:
Para origens JavaScript autorizadas, use https://<app-name>.azurewebsites.net com o nome do seu
aplicativo no > <app.
Para URI de redirecionamento autorizado, use
https://<app-name>.azurewebsites.net/.auth/login/google/callback .
2. Copie a ID do aplicativo e os valores de segredo do aplicativo.
IMPORTANT
O segredo do aplicativo é uma credencial de segurança importante. Não compartilhe essa senha com ninguém nem
distribua-a em um aplicativo cliente.
Adicionar informações do Google ao seu aplicativo

3. Selecione Googlee cole os valores de ID do aplicativo e segredo do aplicativo que você obteve
anteriormente. Habilite todos os escopos necessários para seu aplicativo.
4. Selecione OK.
O serviço de aplicativo fornece autenticação, mas não restringe o acesso autorizado ao conteúdo e às APIs
do site. Para obter mais informações, consulte autorizar ou negar usuários.
5. Adicional Para restringir o acesso ao site somente para usuários autenticados pelo Google, defina a ação a
ser tomada quando a solicitação não for autenticada para o Google. Quando você define essa
funcionalidade, seu aplicativo requer que todas as solicitações sejam autenticadas. Ele também redireciona
todas as solicitações não autenticadas para o Google para autenticação.
Cau t i on
de autenticação.
Agora você está pronto para usar o Google para autenticação em seu aplicativo.
Próximas etapas
para usar o logon da conta da Microsoft
Este tópico mostra como configurar o Serviço de Aplicativo do Azure para usar a conta da Microsoft como um
provedor de autenticação.
Registrar seu aplicativo na conta da Microsoft

1. Vá para registros de aplicativo na portal do Azure. Se necessário, entre com seu conta Microsoft.
2. Selecione novo registroe insira um nome de aplicativo.
3. Em URIs de redirecionamento, selecione Webe, em seguida, insira
https://<app-domain-name>/.auth/login/microsoftaccount/callback supply the endpoint for your application
. Substitua <app -domain-name > pelo nome de domínio do seu aplicativo. Por exemplo:
https://contoso.azurewebsites.net/.auth/login/microsoftaccount/callback . Certifique-se de usar o
esquema HTTPS na URL.
4. Selecione Registrar.
5. Copie a ID do aplicativo (cliente) . Você precisará dela mais tarde.
6. No painel esquerdo, selecione certificados & segredos > novo segredo do cliente. Insira uma
descrição, selecione a duração da validade e selecione Adicionar.
7. Copie o valor que aparece na página certificados & segredos . Depois de sair da página, ela não será
exibida novamente.
IMPORTANT
A senha é uma credencial de segurança importante. Não compartilhe a senha com ninguém nem distribua-a em um
aplicativo cliente.
Adicionar informações da conta da Microsoft ao seu aplicativo de

Serviço de Aplicativo
1. Vá para seu aplicativo no portal do Azure.
3. Em provedores de autenticação, selecione conta da Microsoft. Cole a ID do aplicativo (cliente) e o
segredo do cliente obtidos anteriormente. Habilite todos os escopos necessários para seu aplicativo.
4. Selecione OK.
O serviço de aplicativo fornece autenticação, mas não restringe o acesso autorizado ao conteúdo e às APIs
do site. Você deve autorizar os usuários no código do aplicativo.
5. Adicional Para restringir o acesso a conta Microsoft usuários, defina a ação a ser tomada quando a
solicitação não for autenticada para fazer logon com a conta da Microsoft. Quando você define
essa funcionalidade, seu aplicativo requer que todas as solicitações sejam autenticadas. Ele também
redireciona todas as solicitações não autenticadas para conta Microsoft para autenticação.
Cau t i on
desejável para aplicativos que têm um home page publicamente disponível, como em muitos aplicativos
de página única. Para tais aplicativos, Permitir solicitações anônimas (nenhuma ação) pode ser
preferível para que o aplicativo inicie manualmente a autenticação em si. Para obter mais informações,
consulte fluxo de autenticação.
Agora você está pronto para usar uma conta da Microsoft para autenticação em seu aplicativo.
Próximas etapas
para usar o logon do Twitter
Este artigo mostra como configurar Azure App serviço para usar o Twitter como um provedor de autenticação.
Para concluir o procedimento neste artigo, você precisa de uma conta do Twitter que tenha um endereço de email
e número de telefone verificados. Para criar uma nova conta do Twitter, vá para twitter.com.
Registre seu aplicativo com o Twitter

1. Entre no portal do Azure e vá para seu aplicativo. Copie a URL. Você o usará para configurar seu aplicativo
do Twitter.
2. Vá para o site de Desenvolvedores do Twitter, , entre com suas credenciais de conta do Twitter e selecione
criar novo aplicativo.
3. Insira um nome e uma Descrição para o novo aplicativo. Cole a URL do aplicativo no campo site . No
campo URL de retorno de chamada , insira a URL do seu aplicativo do serviço de aplicativo e acrescente
o caminho /.auth/login/aad/callback . Por exemplo:
https://contoso.azurewebsites.net/.auth/login/twitter/callback . Certifique-se de usar o esquema HTTPS.
4. Na parte inferior da página, leia e aceite os termos. Selecione criar seu aplicativo do Twitter. Os
detalhes do aplicativo são exibidos.
5. Selecione a guia configurações , marque permitir que este aplicativo seja usado para entrar com o
Twittere, em seguida, selecione Atualizar configurações.
6. Selecione a guia Chaves e Tokens de Acesso .
Anote esses valores:
Chave do consumidor (chave de API)
Segredo do consumidor (segredo da API)
NOTE
O segredo do consumidor é uma credencial de segurança importante. Não compartilhe esse segredo com ninguém
nem o distribua com seu aplicativo.
Adicione informações do Twitter ao seu aplicativo

1. Vá para seu aplicativo no portal do Azure.
3. Selecione Twitter.
4. Cole os valores API Key e API Secret que você obteve anteriormente.
5. Selecione OK.
conteúdo e às APIs do site. Você deve autorizar os usuários no código do aplicativo.
6. (Opcional) Para restringir o acesso ao seu site somente para usuários autenticados pelo Twitter, defina
Ação a ser executada quando a solicitação não for autenticada como Twitter. Quando você define
essa funcionalidade, seu aplicativo requer que todas as solicitações sejam autenticadas. Ele também
redireciona todas as solicitações não autenticadas para o Twitter para autenticação.
Cau t i on
de autenticação.
Agora você está pronto para usar o Twitter para autenticação em seu aplicativo.
Próximas etapas
Uso avançado de autenticação e autorização no
Serviço de Aplicativo do Azure
Este artigo mostra como personalizar a autenticação e a autorização integradas no Serviço de Aplicativo e
gerenciar a identidade do seu aplicativo.
Para começar rapidamente, veja um dos seguintes tutoriais:
Tutorial: Autenticar e autorizar usuários de ponta a ponta no Serviço de Aplicativo do Azure (Windows)
Tutorial: Autenticar e autorizar usuários de ponta a ponta no Serviço de Aplicativo do Azure para Linux
Como configurar seu aplicativo para usar o logon do Active Directory do Azure
Como configurar seu aplicativo para usar o logon do Facebook
Como configurar seu aplicativo para usar o logon do Google
Como configurar seu aplicativo para usar o logon da Conta da Microsoft
Como configurar seu aplicativo para usar o logon do Twitter
Usar vários provedores de entrada

A configuração do portal não oferece uma maneira prática turnkey para apresentar vários provedores de entrada
aos usuários (como o Facebook e o Twitter). No entanto, não é difícil adicionar a funcionalidade ao aplicativo. As
etapas são destacadas como a seguir:
Primeiro, na página Autenticação/Autorização no Portal do Azure, configure cada provedor de identidade que
você deseja habilitar.
Em Ação a tomar quando a solicitação não está autenticada, selecione Permitir solicitações anônimas
(nenhuma ação) .
Na página de entrada, na barra de navegação, ou em qualquer outro local do aplicativo, adicione um link de
entrada a cada um dos provedores que você habilitou ( /.auth/login/<provider> ). Por exemplo:
<a href="/.auth/login/aad">Log in with Azure AD</a>

<a href="/.auth/login/microsoftaccount">Log in with Microsoft Account</a>
<a href="/.auth/login/facebook">Log in with Facebook</a>
<a href="/.auth/login/google">Log in with Google</a>
<a href="/.auth/login/twitter">Log in with Twitter</a>
Quando o usuário clica em um dos links, a respectiva página de entrada é aberta para que ele entre.
Para redirecionar o usuário pós-entada para uma URL personalizada, use o parâmetro de cadeia de caracteres de
consulta post_login_redirect_url (não deve ser confundido com o URI de redirecionamento na configuração do
provedor de identidade). Por exemplo, para orientar o usuário para /Home/Index após entrar, use o seguinte código
HTML:
<a href="/.auth/login/<provider>?post_login_redirect_url=/Home/Index">Log in</a>
Validar os tokens de provedores

Em um login direcionado ao cliente, o aplicativo faz login manual do usuário no provedor e, em seguida, envia o
token de autenticação para o Serviço de Aplicativo para validação (consulte Fluxo de Autenticação). Essa validação
em si não concede a você acesso aos recursos desejados do aplicativo, mas uma validação bem-sucedida fornecerá
um token de sessão que você pode usar para acessar os recursos do aplicativo.
Para validar o token do provedor, o aplicativo Serviço de Aplicativo deve ser configurado primeiro com o provedor
desejado. Em tempo de execução, depois de recuperar o token de autenticação do seu provedor, poste o token em
/.auth/login/<provider> para validação. Por exemplo:
POST https://<appname>.azurewebsites.net/.auth/login/aad HTTP/1.1

{"id_token":"<token>","access_token":"<token>"}
O formato do token varia ligeiramente de acordo com o provedor. Consulte a tabela a seguir para obter detalhes:
VALOR DO PROVEDOR NECESSÁRIO NO CORPO DA SOLICITAÇÃO COMENTÁRIOS
aad {"access_token":"<access_token>"}
microsoftaccount {"access_token":"<token>"} A propriedade expires_in é opcional.

Ao solicitar o token de serviços em
tempo real, sempre solicitar o
wl.basic escopo.
google {"id_token":"<id_token>"} A propriedade authorization_code é

opcional. Quando especificado, ele
também pode ser acompanhado pelo
redirect_uri propriedade.
facebook {"access_token":" Use um válido token de acesso do

<user_access_token>"} usuário do Facebook.
twitter {"access_token":"<access_token>",
"access_token_secret":"
<acces_token_secret>"}
Se o token do provedor for validado com êxito, a API retorna com um authenticationToken no corpo da resposta,
que é seu token de sessão.
{
"authenticationToken": "...",
"user": {
"userId": "sid:..."
}
}
Uma vez que esse token de sessão, você pode acessar os recursos de aplicativo protegido, adicionando o
X-ZUMO-AUTH cabeçalho às solicitações HTTP. Por exemplo:
GET https://<appname>.azurewebsites.net/api/products/1
X-ZUMO-AUTH: <authenticationToken_value>
Sair de uma sessão
Os usuários podem iniciar uma saída, enviando uma GET solicitação ao ponto de extremidade /.auth/logout do
aplicativo. A solicitação GET faz o seguinte:
Limpa os cookies de autenticação da sessão atual.
Exclui os tokens do usuário atual do Token Store.
Para o Azure Active Directory e o Google, executa uma saída do servidor no provedor de identidade.
Aqui está um link de saída simples em uma página da Web:
<a href="/.auth/logout">Sign out</a>
Por padrão, uma saída com êxito redireciona o cliente para a URL /.auth/logout/done . É possível alterar a página
de redirecionamento pós-saída, adicionando o parâmetro de consulta post_logout_redirect_uri . Por exemplo:
GET /.auth/logout?post_logout_redirect_uri=/index.html
É recomendável codificar o valor de post_logout_redirect_uri .

Ao usar URLs totalmente qualificadas, a URL deve ser hospedada no mesmo domínio ou configurada como uma
URL de redirecionamento externo permitido para o aplicativo. No exemplo a seguir, para redirecionar para
https://myexternalurl.com que não está hospedado no mesmo domínio:
GET /.auth/logout?post_logout_redirect_uri=https%3A%2F%2Fmyexternalurl.com
Execute o seguinte comando no Azure cloud Shell:
az webapp auth update --name <app_name> --resource-group <group_name> --allowed-external-redirect-urls

"https://myexternalurl.com"
Preservar fragmentos de URL

Depois que os usuários entram no aplicativo, geralmente querem ser redirecionados para a mesma seção da
mesma página, como /wiki/Main_Page#SectionZ . No entanto, como os fragmentos de URL (por exemplo,
#SectionZ ) nunca são enviados ao servidor, consequentemente não são preservados por padrão depois que a
assinatura OAuth é concluída e redirecionada de volta ao aplicativo. Portanto, os usuários obtêm uma experiência
abaixo do ideal quando precisam navegar novamente para a âncora desejada. Essa limitação aplica-se a todas as
soluções de autenticação do lado do servidor.
Na autenticação do Serviço de Aplicativo, é possível preservar os fragmentos de URL na assinatura OAuth. Para
fazer isso, defina uma configuração de aplicativo chamada WEBSITE_AUTH_PRESERVE_URL_FRAGMENT para true . Você
pode fazer isso no portal do Azure ou simplesmente executar o comando a seguir no Azure Cloud Shell:
az webapp config appsettings set --name <app_name> --resource-group <group_name> --settings

WEBSITE_AUTH_PRESERVE_URL_FRAGMENT="true"
Acessar declarações de usuários

O Serviço de Aplicativo transmite declarações do usuário para seu aplicativo usando cabeçalhos especiais.
Solicitações externas não são permitidas para definir esses cabeçalhos, portanto são apresentadas somente se
definido pelo Serviço de Aplicativo. Alguns cabeçalhos de exemplo incluem:
X-MS -CLIENT-PRINCIPAL -NAME
X-MS -CLIENT-PRINCIPAL -ID
Um código escrito em qualquer linguagem ou estrutura pode obter as informações necessárias desses cabeçalhos.
Para aplicativos ASP.NET 4.6, ClaimsPrincipal é definido automaticamente com os valores apropriados. O
ASP.NET Core, no entanto, não fornece um middleware de autenticação que se integra às declarações de usuário
do serviço de aplicativo. Para obter uma solução alternativa, consulte MaximeRouiller. Azure. AppService.
EasyAuth.
Seu aplicativo também pode obter detalhes adicionais sobre o usuário autenticado chamando /.auth/me . Os SDKs
do servidor dos Aplicativos Móveis fornecem métodos auxiliares para trabalhar com esses dados. Para saber mais,
confira Como usar o SDK do Node.js dos Aplicativos Móveis do Azure e Trabalhar com o SDK do servidor de
back-end .NET para Aplicativos Móveis do Azure.
Recuperar tokens no código do aplicativo

No seu código de servidor, os tokens específicos do provedor são injetados no cabeçalho da solicitação, para que
você possa acessá-los facilmente. A tabela a seguir mostra os possíveis nomes de cabeçalho do token:
PROVEDOR NOMES DO CABEÇALHO
Azure Active Directory X-MS-TOKEN-AAD-ID-TOKEN

X-MS-TOKEN-AAD-ACCESS-TOKEN
X-MS-TOKEN-AAD-EXPIRES-ON
X-MS-TOKEN-AAD-REFRESH-TOKEN
Token do Facebook X-MS-TOKEN-FACEBOOK-ACCESS-TOKEN

X-MS-TOKEN-FACEBOOK-EXPIRES-ON
Google X-MS-TOKEN-GOOGLE-ID-TOKEN
X-MS-TOKEN-GOOGLE-ACCESS-TOKEN
X-MS-TOKEN-GOOGLE-EXPIRES-ON
X-MS-TOKEN-GOOGLE-REFRESH-TOKEN
Conta da Microsoft X-MS-TOKEN-MICROSOFTACCOUNT-ACCESS-TOKEN

X-MS-TOKEN-MICROSOFTACCOUNT-EXPIRES-ON
X-MS-TOKEN-MICROSOFTACCOUNT-AUTHENTICATION-TOKEN
X-MS-TOKEN-MICROSOFTACCOUNT-REFRESH-TOKEN
Twitter X-MS-TOKEN-TWITTER-ACCESS-TOKEN
X-MS-TOKEN-TWITTER-ACCESS-TOKEN-SECRET
Do seu código do cliente (por exemplo, um aplicativo móvel ou JavaScript no navegador), envie uma solicitação
HTTP GET para /.auth/me . O JSON retornado tem os tokens específicos do provedor.
NOTE
Tokens de acesso são para acessar recursos do provedor, para que eles fiquem presentes somente se você configurar o
provedor com um segredo do cliente. Para saber como obter tokens de atualização, confira Tokens de acesso de atualização.
Atualizar tokens do provedor de identidade

Quando o token de acesso do seu provedor (não o token de sessão) expirar, você precisará autenticar novamente o
usuário antes de usar esse token novamente. Você pode evitar a expiração do token fazendo uma GET chamada
para o /.auth/refresh ponto de extremidade de seu aplicativo. Quando chamado, o Serviço de Aplicativo atualiza
automaticamente tokens de acesso no repositório de token para o usuário autenticado. As solicitações
subsequentes de tokens do seu código do aplicativo obtêm tokens atualizados. No entanto, para que a atualização
do token funcione, o repositório de token deve conter tokens de atualização para o seu provedor. A forma de obter
tokens de atualização é documentada por cada provedor, mas a lista a seguir traz um breve resumo:
Google: anexe um access_type=offline parâmetro de cadeia de caracteres para consulta a sua
/.auth/login/google chamada à API. Se usar o SDK de Aplicativos Móveis, você pode adicionar o parâmetro a
uma das LogicAsync sobrecargas (consulte Tokens de atualização do Google).
Facebook: não fornece tokens de atualização. Tokens de vida útil longa expiram em 60 dias (consulte Expiração
e extensão de tokens de acesso do Facebook).
Twitter: tokens de acesso não expiram (consulte Perguntas frequentes sobre o OAuth do Twitter).
Microsoft Account: quando definir configurações de autenticação de conta Microsoft, selecione o escopo
wl.offline_access .
Azure Active Directory: em https://resources.azure.com, execute as seguintes etapas:
1. Na parte superior da página, selecione Ler/Gravar.
2. No navegador à esquerda, navegue até assinaturas > <assinatura_nome > resourceGroups >
<recurso_grupo_nome > > provedores > Microsoft.web > sites > <aplicativo _nome > >
config > authsettings.
3. Clique em Editar.
4. Modifique a propriedade a seguir. Substitua <aplicativo_id> pela ID do aplicativo do Azure Active
Directory do serviço que você deseja acessar.
"additionalLoginParams": ["response_type=code id_token", "resource=<app_id>"]
5. Clique em Put.
Depois que seu provedor estiver configurado, você poderá encontrar o token de atualização e o tempo de
expiração do token de acesso na loja do token.
Para atualizar o token de acesso a qualquer momento, basta chamar /.auth/refresh em qualquer idioma. O
snippet a seguir usa o jQuery para atualizar seus tokens de acesso de um cliente JavaScript.
function refreshTokens() {
let refreshUrl = "/.auth/refresh";
$.ajax(refreshUrl) .done(function() {
console.log("Token refresh completed successfully.");
}) .fail(function() {
console.log("Token refresh failed. See application logs for details.");
});
}
Se um usuário revoga as permissões concedidas ao seu aplicativo, a chamada para /.auth/me pode falhar com um
resposta 403 Forbidden . Para diagnosticar erros, verifique os logs de aplicativo para obter detalhes.
Estender o período de cortesia de término do token da sessão

A sessão autenticada expira após 8 horas. Depois que uma sessão autenticada expira, há um período de cortesia de
72 horas por padrão. Dentro desse período, você pode atualizar o token de sessão com o Serviço de Aplicativo sem
reautenticar o usuário. Você pode simplesmente chamar /.auth/refresh quando o token de sessão se torna
inválido e não é necessário rastrear o término do token por conta própria. Após o período de cortesia de 72 horas,
o usuário deverá entrar novamente para obter um token de sessão válido.
Se 72 horas não for tempo suficiente, você pode estender essa janela de expiração. Estender a expiração por um
longo período pode ter implicações significativas de segurança (por exemplo, quando um token de autenticação é
perdido ou roubado). Portanto, você deve deixar o padrão de 72 horas ou definir o período de extensão para o
menor valor.
Para estender a janela de validade padrão, execute o seguinte comando no Cloud Shell.
az webapp auth update --resource-group <group_name> --name <app_name> --token-refresh-extension-hours <hours>
NOTE
O período de cortesia se aplica somente à sessão autenticada do Serviço de Aplicativo, não aos tokens de provedores de
identidade. Não há um período de cortesia para os tokens de provedor expirados.
Limite do domínio de contas de entrada

A Conta da Microsoft e o Microsoft Azure Active Directory permitem a entrada de vários domínios. Por exemplo, a
Conta da Microsoft permite contas de outlook.com, live.com e hotmail.com. O Azure AD permite qualquer número
de domínios personalizados para as contas de entrada. No entanto, talvez você queira acelerar seus usuários
diretamente para sua própria página de entrada do Azure AD com marca (como contoso.com ). Para sugerir o
nome de domínio das contas de entrada, siga estas etapas.
Em https://resources.azure.com, navegue até assinaturas > < assinatura_ nome > resourceGroups > < recurso_
grupo_ nome> > provedores > Microsoft.Web > sites > < aplicativo_ nome> > config > authsettings.
Clique em Editar, modifique a propriedade a seguir e, em seguida, clique em Put. Certifique-se de substituir
<domínio_nome > pelo domínio que você deseja.
"additionalLoginParams": ["domain_hint=<domain_name>"]
Essa configuração acrescenta o parâmetro de cadeia de caracteres de consulta domain_hint à URL de

redirecionamento de logon.
IMPORTANT
É possível que o cliente remova o parâmetro domain_hint depois de receber a URL de redirecionamento e, em seguida, faça
logon com um domínio diferente. Portanto, embora essa função seja conveniente, ela não é um recurso de segurança.
Autorizar ou negar usuários

Embora o serviço de aplicativo se encarrega do caso de autorização mais simples (ou seja, rejeitar solicitações não
autenticadas), seu aplicativo pode exigir um comportamento de autorização mais refinado, como limitar o acesso a
apenas um grupo específico de usuários. Em determinados casos, você precisa escrever código de aplicativo
personalizado para permitir ou negar acesso ao usuário conectado. Em outros casos, o serviço de aplicativo ou o
provedor de identidade pode ser capaz de ajudar sem a necessidade de alterações de código.
Nível do servidor
Nível do provedor de identidade
Nível do aplicativo
Nível do servidor (somente aplicativos do Windows)
Para qualquer aplicativo do Windows, você pode definir o comportamento de autorização do servidor Web do IIS,
editando o arquivo Web. config . Os aplicativos do Linux não usam o IIS e não podem ser configurados por meio
do Web. config.
1. Navegue até https://<app-name>.scm.azurewebsites.net/DebugConsole
2. No Gerenciador de navegador de seus arquivos do serviço de aplicativo, navegue até site/wwwroot. Se um

Web. config não existir, crie-o selecionando + > novo arquivo.
3. Selecione o lápis para Web. config para editá-lo. Adicione o código de configuração a seguir e clique em
salvar. Se o Web. config já existir, basta adicionar o elemento <authorization> com tudo o que está nele.
Adicione as contas que você deseja permitir no elemento <allow> .
<?xml version="1.0" encoding="utf-8"?>

<configuration>
<system.web>
<authorization>
<allow users="user1@contoso.com,user2@contoso.com"/>
<deny users="*"/>
</authorization>
</system.web>
</configuration>
Nível do provedor de identidade

O provedor de identidade pode fornecer determinada autorização de chave. Por exemplo:
Para Azure app serviço, você pode gerenciar o acesso de nível corporativo diretamente no Azure AD. Para obter
instruções, consulte como remover o acesso de um usuário a um aplicativo.
Para o Google, os projetos de API do Google que pertencem a uma organização podem ser configurados para
permitir acesso somente aos usuários em sua organização (consulte a página de suporte do OAuth 2,0
Configurando o Google).
Nível de aplicativo
Se qualquer um dos outros níveis não fornecer a autorização de que você precisa, ou se sua plataforma ou
provedor de identidade não tiver suporte, você deverá escrever um código personalizado para autorizar usuários
com base nas declarações do usuário.
Próximos passos
Tutorial: Autenticar e autorizar usuários ponta a ponta (Windows) Tutorial: Autenticar e autorizar usuários de ponta
a ponta (Linux)
Azure App restrições de acesso de serviço
As restrições de acesso permitem que você defina uma lista de permissão/negação ordenada de prioridade que
controla o acesso à rede para seu aplicativo. A lista pode incluir endereços IP ou sub-redes de rede virtual do
Azure. Quando há uma ou mais entradas, há então um "negar tudo" implícito que existe no final da lista.
A funcionalidade de restrições de acesso funciona com todas as cargas de trabalho hospedadas do serviço de
aplicativo, incluindo; aplicativos Web, aplicativos de API, aplicativos do Linux, aplicativos de contêiner do Linux e
funções.
Quando uma solicitação é feita ao seu aplicativo, o endereço de é avaliado em relação às regras de endereço IP
em sua lista de restrições de acesso. Se o endereço de estiver em uma sub-rede configurada com pontos de
extremidade de serviço para Microsoft. Web, a sub-rede de origem será comparada com as regras de rede virtual
em sua lista de restrições de acesso. Se o endereço não é permitido o acesso com base nas regras na lista, o
serviço responderá com um código de status HTTP 403.
O recurso de restrições de acesso é implementado nas funções de front-end do serviço de aplicativo, que são
upstream dos hosts de trabalho em que seu código é executado. Portanto, as restrições de acesso são
efetivamente ACLs de rede.
A capacidade de restringir o acesso ao seu aplicativo Web de uma VNet (rede virtual) do Azure é chamada de
pontos de extremidade de serviço. Os pontos de extremidade de serviço permitem restringir o acesso a um
serviço multilocatário de sub-redes selecionadas. Ele deve ser habilitado tanto no lado da rede quanto no serviço
com o qual está sendo habilitado. Ele não funciona para restringir o tráfego para aplicativos hospedados em um
Ambiente do Serviço de Aplicativo. Se você estiver em um Ambiente do Serviço de Aplicativo, poderá controlar o
acesso ao seu aplicativo com regras de endereço IP.
Adicionando e editando regras de restrição de acesso no portal

Para adicionar uma regra de restrição de acesso ao seu aplicativo, use o menu para abrirrestrições de acesso à
rede>e clique em Configurar restrições de acesso
Na interface do usuário de restrições de acesso, você pode examinar a lista de regras de restrição de acesso
definidas para seu aplicativo.
A lista mostrará todas as restrições atuais que estão em seu aplicativo. Se você tiver uma restrição de VNet em
seu aplicativo, a tabela mostrará se os pontos de extremidade de serviço estão habilitados para Microsoft. Web.
Quando não houver nenhuma restrição definida em seu aplicativo, seu aplicativo poderá ser acessado de
qualquer lugar.
Adicionando regras de endereço IP

Você pode clicar em [+] Adicionar para adicionar uma nova regra de restrição de acesso. Depois de adicionar
uma regra, entrará em vigor imediatamente. As regras são impostas em ordem de prioridade a partir do número
mais baixo e para cima. Há uma negação implícita tudo o que está em vigor depois que você adicionar até mesmo
uma única regra.
Ao criar uma regra, você deve selecionar permitir/negar e também o tipo de regra. Também é necessário fornecer
o valor de prioridade e o que você está restringindo o acesso ao. Opcionalmente, você pode adicionar um nome e
uma descrição à regra.
Para definir uma regra baseada em endereço IP, selecione um tipo de IPv4 ou IPv6. Notação de endereço IP deve
ser especificada na notação de CIDR de endereços IPv4 e IPv6. Para especificar um endereço exato, você pode
usar algo como 1.2.3.4/32 onde os quatro primeiros octetos representam o endereço IP e /32 é a máscara. A
notação de CIDR de IPv4 para todos os endereços é 0.0.0.0/0. Para saber mais sobre a notação CIDR, leia
Roteamento entre domínios sem classe.
Pontos de extremidade de serviço

Os pontos de extremidade de serviço permitem restringir o acesso às sub-redes selecionadas da rede virtual do
Azure. Para restringir o acesso a uma sub-rede específica, crie uma regra de restrição com um tipo de rede virtual.
Você pode escolher a assinatura, a VNet e a sub-rede que deseja permitir ou negar acesso. Se os pontos de
extremidade de serviço ainda não estiverem habilitados com o Microsoft. Web para a sub-rede que você
selecionou, ele será habilitado automaticamente para você, a menos que você marque a caixa pedindo para não
fazer isso. A situação em que você deseja habilitá-la no aplicativo, mas não a sub-rede está amplamente
relacionada a se você tiver as permissões para habilitar os pontos de extremidade de serviço na sub-rede ou não.
Se você precisar fazer com que outra pessoa habilite os pontos de extremidade de serviço na sub-rede, marque a
caixa e faça com que seu aplicativo seja configurado para pontos de extremidade de serviço na previsão de que
ele está sendo habilitado posteriormente na sub-rede.
Os pontos de extremidade de serviço não podem ser usados para restringir o acesso a aplicativos executados em
um Ambiente do Serviço de Aplicativo. Quando seu aplicativo estiver em um Ambiente do Serviço de Aplicativo,
você poderá controlar o acesso ao seu aplicativo com as regras de acesso de IP.
Com os pontos de extremidade de serviço, você pode configurar seu aplicativo com gateways de aplicativo ou
outros dispositivos WAF. Você também pode configurar aplicativos de várias camadas com back-ends seguros.
Para obter mais detalhes sobre algumas das possibilidades, leia recursos de rede e serviço de aplicativo.
Gerenciando regras de restrição de acesso

Você pode clicar em qualquer linha para editar uma regra de restrição de acesso existente. As edições são eficazes
imediatamente, incluindo as alterações na ordem de prioridade.
Quando você edita uma regra, não pode alterar o tipo entre uma regra de endereço IP e uma regra de rede
virtual.
Para excluir uma regra, clique em ... em sua regra e clique em remover.
Bloqueando um único endereço IP
Ao adicionar sua primeira regra de restrição de IP, o serviço adicionará uma regra negar tudo explícita com uma
prioridade de 2147483647. Na prática, a regra negar tudo explícita será executada pela última vez e bloqueará o
acesso a qualquer endereço IP que não seja explicitamente permitido usando uma regra de permissão .
Para o cenário em que os usuários desejam bloquear explicitamente um único endereço IP ou bloco de endereço
IP, mas permitir que todas as outras pessoas acessem, é necessário adicionar uma regra permitir tudo explícito.
Site do SCM
Além de poder controlar o acesso ao seu aplicativo, você também pode restringir o acesso ao site do SCM usado
pelo seu aplicativo. O site do SCM é o ponto de extremidade de implantação da Web e também o console do
kudu. Você pode atribuir separadamente restrições de acesso ao site do SCM do aplicativo ou usar o mesmo
conjunto para o aplicativo e o site do SCM. Quando você marca a caixa para ter as mesmas restrições que seu
aplicativo, tudo fica em branco. Se você desmarcar a caixa, quaisquer configurações que você tenha anteriormente
no site do SCM serão aplicadas.
Manipulação programática de regras de restrição de acesso
Atualmente, não há uma CLI ou o PowerShell para o novo recurso de restrições de acesso, mas os valores podem
ser definidos manualmente com uma operação Put da API REST do Azure na configuração do aplicativo no
Gerenciador de recursos. Por exemplo, você pode usar resources.azure.com e editar o bloco ipSecurityRestrictions
para adicionar o JSON necessário.
O local para obter essas informações no Gerenciador de Recursos é:
management.azure.com/subscriptions/subscription ID/resourceGroups/resource
groups/providers/Microsoft.Web/sites/web app name/config/web?api-version=2018-02-01
A sintaxe JSON para o exemplo anterior é:
{
"properties": {
"ipSecurityRestrictions": [
{
"ipAddress": "122.133.144.0/24",
"action": "Allow",
"tag": "Default",
"priority": 100,
"name": "IP example rule"
}
]
}
}
Aplicativo de funções restrições de IP

As restrições de IP estão disponíveis para ambos os aplicativos de funções com a mesma funcionalidade que os
planos do serviço de aplicativo. Habilitar restrições de IP desabilitará o editor de código do portal para qualquer
IPs não permitido.
Saiba mais aqui
Como usar identidades gerenciadas para o Serviço
de Aplicativo e o Azure Functions
IMPORTANT
Identidades gerenciadas para Serviço de Aplicativo e Azure Functions não se comportarão conforme o esperado se seu
aplicativo for migrado entre assinaturas/locatários. O aplicativo precisará obter uma nova identidade, que pode ser feita ao
desabilitar e reabilitar o recurso. Consulte removendo uma identidade abaixo. Recursos de downstream também precisará ter
políticas de acesso atualizadas para usar a nova identidade.
Este tópico mostra como criar uma identidade gerenciada para aplicativos do Serviço de Aplicativo e do Azure
Functions e como usá-la para acessar outros recursos. Uma identidade gerenciada do Azure Active Directory
permite que seu aplicativo acesse com facilidade outros recursos protegidos pelo AAD, como o Azure Key Vault. A
identidade é gerenciada pela plataforma do Azure e não exige provisionamento ou giro de nenhum segredo. Para
obter mais informações sobre identidades gerenciadas no AAD, veja Identidades gerenciadas para recursos do
Azure.
Seu aplicativo pode receber dois tipos de identidades:
Uma identidade atribuída pelo sistema é vinculada ao seu aplicativo e é excluída se o seu aplicativo for
excluído. Um aplicativo só pode ter uma identidade atribuída pelo sistema.
Uma identidade atribuída pelo usuário é um recurso do Azure independente que pode ser atribuído ao seu
aplicativo. Um aplicativo pode ter várias identidades atribuídas pelo usuário.
Adicionando uma identidade designada pelo sistema

Criar um aplicativo com uma identidade designada pelo sistema requer uma propriedade adicional a ser definida
no aplicativo.
Usando o portal do Azure
Para configurar uma identidade gerenciada no portal, primeiro, crie um aplicativo como normal e, em seguida,
habilite o recurso.
1. Crie um aplicativo no portal, como você faria normalmente. Navegue até ele no portal.
2. Se você estiver usando um aplicativo de funções, navegue até os recursos da Plataforma. Para outros tipos
de aplicativo, role para baixo até o grupo Configurações no painel de navegação à esquerda.
3. Selecione Identidade gerenciada.
4. Na guia Sistema atribuído, alterne o Status para Ligado. Clique em Save (Salvar).
Usando a CLI do Azure
Para configurar uma identidade gerenciada usando a CLI do Azure, será preciso usar o comando
az webapp identity assign em um aplicativo existente. Você tem três opções para executar os exemplos nesta
seção:
Usar o Azure Cloud Shell do portal do Azure.
Usar o Azure Cloud Shell inserido por meio do botão "Experimentar", localizado no canto superior direito de
cada bloco de código abaixo.
Instale a versão mais recente da CLI do Azure (2.0.31 ou mais recente) se você preferir usar um console da CLI
local.
As etapas a seguir o guiarão na criação de um aplicativo Web e na atribuição de uma identidade a ele usando a CLI:
1. Se você estiver usando a CLI do Azure em um console local, primeiro entre no Azure usando o logon az. Use
uma conta que esteja associada à assinatura do Azure sob a qual você deseja implantar o aplicativo:
az login
2. Crie um aplicativo Web usando a CLI. Para ver mais exemplos de como usar a CLI com o Serviço de
Aplicativo, consulte Exemplos de CLI do Serviço de Aplicativo:
az group create --name myResourceGroup --location westus

az appservice plan create --name myPlan --resource-group myResourceGroup --sku S1
az webapp create --name myApp --resource-group myResourceGroup --plan myPlan
3. Execute o comando identity assign para criar a identidade para este aplicativo:
az webapp identity assign --name myApp --resource-group myResourceGroup
Usando o PowerShell do Azure

NOTE
As etapas a seguir guiarão você pela criação de um aplicativo da Web e pela atribuição de uma identidade usando o
Azure PowerShell:
1. Se necessário, instale o Azure PowerShell usando a instrução encontrada no guia do Azure PowerShell e, em
seguida, execute Login-AzAccount para criar uma conexão com o Azure.
2. Crie um aplicativo da Web usando o Azure PowerShell. Para obter mais exemplos de como usar o Azure
PowerShell com o Serviço de Aplicativo, consulte Amostras do PowerShell do Serviço de Aplicativo :

New-AzResourceGroup -Name myResourceGroup -Location $location

New-AzAppServicePlan -Name $webappname -Location $location -ResourceGroupName myResourceGroup -Tier Free
# Create a web app.

New-AzWebApp -Name $webappname -Location $location -AppServicePlan $webappname -ResourceGroupName
myResourceGroup
3. Execute o comando Set-AzWebApp -AssignIdentity para criar a identidade para este aplicativo:
Set-AzWebApp -AssignIdentity $true -Name $webappname -ResourceGroupName myResourceGroup
Usando um modelo do Azure Resource Manager

Um modelo do Azure Resource Manager pode ser usado para automatizar a implantação de recursos do Azure.
Para saber mais sobre a implantação do Serviço de Aplicativo e do Azure Functions, consulte Automatizar a
implantação de recursos no Serviço de Aplicativo e Automatizar a implantação de recursos no Azure Functions.
Qualquer recurso do tipo Microsoft.Web/sites pode ser criado com uma identidade, incluindo a propriedade a
seguir na definição de recurso:
"identity": {
"type": "SystemAssigned"
}
NOTE
Um aplicativo pode ter identidades atribuídas pelo sistema e atribuídas pelo usuário ao mesmo tempo. Nesse caso, a type
propriedade seria SystemAssigned,UserAssigned
Adicionar o tipo atribuído pelo sistema diz ao Azure para criar e gerenciar a identidade do seu aplicativo.
Por exemplo, um aplicativo Web pode ser semelhante ao seguinte:
{
"apiVersion": "2016-08-01",
"name": "[variables('appName')]",
"identity": {
},
"properties": {
"hostingEnvironment": "",
"clientAffinityEnabled": false,
"alwaysOn": true
},
"dependsOn": [
"[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]"
]
}
Quando o site é criado, ele tem as seguintes propriedades adicionais:
"identity": {
"type": "SystemAssigned",
"tenantId": "<TENANTID>",
"principalId": "<PRINCIPALID>"
}
No qual <TENANTID> e <PRINCIPALID> são substituídos por GUIDs. A propriedade tenantId identifica a qual
locatário do AAD a identidade pertence. O principalId é um identificador exclusivo para a nova identidade do
aplicativo. No AAD, a entidade de serviço tem o mesmo nome que você deu à sua instância do Serviço de
Aplicativo ou das Funções do Azure.
Adicionando uma identidade atribuída pelo usuário

Criar um aplicativo com uma identidade atribuída pelo usuário exige que você crie a identidade e, em seguida,
adicione seu identificador de recursos à configuração do aplicativo.
Primeiro, você precisará criar um recurso de identidade atribuído pelo usuário.
1. Crie um recurso de identidade gerenciado atribuído pelo usuário de acordo com estas instruções.
3. Se você estiver usando um aplicativo de funções, navegue até os recursos da Plataforma. Para outros tipos
de aplicativo, role para baixo até o grupo Configurações no painel de navegação à esquerda.
5. Na guia atribuído pelo usuário , clique em Adicionar.
6. Procure a identidade que você criou anteriormente e selecione-a. Clique em Adicionar.
Qualquer recurso do tipo Microsoft.Web/sites pode ser criado com uma identidade incluindo o seguinte bloco na
definição do recurso, substituindo <RESOURCEID> pelo ID do recurso da identidade desejada:
"identity": {
"type": "UserAssigned",
"userAssignedIdentities": {
"<RESOURCEID>": {}
}
}
NOTE
Adicionando o tipo atribuído pelo usuário e um cotells do Azure para criar e gerenciar a identidade do seu
aplicativo.
{
"apiVersion": "2016-08-01",
"identity": {
"[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', variables('identityName'))]": {}
}
},
"properties": {
"alwaysOn": true
},
"dependsOn": [
"[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', variables('identityName'))]"
]
}
"identity": {
"<RESOURCEID>": {
"principalId": "<PRINCIPALID>",
"clientId": "<CLIENTID>"
}
}
}
No qual <PRINCIPALID> e <CLIENTID> são substituídos por GUIDs. O principalId é um identificador exclusivo para a
identidade que é usada para a administração do AAD. O clientId é um identificador exclusivo para a nova
identidade do aplicativo que é usado para especificar qual identidade usar durante as chamadas de runtime.
Obter tokens para recursos do Azure

Um aplicativo pode usar sua identidade para obter tokens para outros recursos protegidos pelo AAD, como o
Azure Key Vault. Esses tokens representam o acesso do aplicativo ao recurso e não um usuário específico do
aplicativo.
IMPORTANT
Talvez seja necessário configurar o recurso de destino para permitir o acesso do aplicativo. Por exemplo, se você solicitar um
token para o Key Vault, será necessário se certificar de que uma política de acesso que inclui a identidade do aplicativo foi
adicionada. Caso contrário, as chamadas para o Key Vault serão rejeitadas, mesmo se elas incluírem o token. Para saber mais
sobre os recursos que oferecem suporte a tokens do Azure Active Directory, veja Serviços do Azure que dão suporte à
autenticação do Azure AD.
Há um protocolo REST simples para obter um token no Serviço de Aplicativo e no Azure Functions. Isso pode ser
usado para todos os aplicativos e linguagens. Para alguns .NET e Java, o SDK do Azure fornece uma abstração
sobre esse protocolo e facilita uma experiência de desenvolvimento local.
Usar o protocolo REST
Um aplicativo com uma identidade gerenciada tem duas variáveis de ambiente definidas:
MSI_ENDPOINT: a URL para o serviço de token local.
MSI_SECRET: um cabeçalho usado para ajudar a reduzir os ataques de falsificação da solicitação do lado do
servidor (SSRF ). O valor é trocado pela plataforma.
A MSI_ENDPOINT é uma URL local da qual o aplicativo pode solicitar tokens. Para obter um token para um
recurso, solicite uma HTTP GET para esse ponto de extremidade, incluindo os seguintes parâmetros:
NOME DO PARÂMETRO NO DESCRIÇÃO
recurso Consulta O URI do recurso do AAD do recurso

para o qual um token deve ser obtido.
Pode ser um dos serviços do Azure
que dão suporte à autenticação do
Azure AD ou a qualquer outro URI de
recurso.
api-version Consulta A versão da API do token a ser usada.

Atualmente, a única versão com
suporte é 2017-09-01.
segredo Cabeçalho O valor da variável de ambiente

MSI_SECRET. Esse cabeçalho é usado
para ajudar a reduzir os ataques de
falsificação da solicitação do lado do
servidor (SSRF).
clientid Consulta (Opcional, a menos que seja atribuído

pelo usuário) A ID da identidade
atribuída pelo usuário a ser usada. Se
omitido, a identidade atribuída pelo
sistema é usada.
IMPORTANT
Se você estiver tentando obter tokens para identidades atribuídas pelo usuário, deverá incluir a propriedade clientid . Caso
contrário, o serviço de token tentará obter um token para uma identidade atribuída pelo sistema, que pode ou não existir.
Uma resposta bem-sucedida de 200 OK inclui um corpo JSON com as seguintes propriedades:
NOME DA PROPRIEDADE DESCRIÇÃO
access_token O token de acesso solicitado. O serviço Web de chamada

pode usar esse token para se autenticar no serviço Web de
recebimento.
expires_on A hora de expiração do token de acesso. A data é

representada como o número de segundos de 1970-01-
01T0:0:0Z UTC até a hora de expiração. Esse valor é usado
para determinar o tempo de vida de tokens em cache.
recurso O URI da ID de aplicativo do serviço Web de recebimento.

token_type Indica o valor do tipo de token. O único tipo com suporte

do Azure AD é Portador Para saber mais sobre os tokens de
portador, consulte Estrutura de Autorização do OAuth 2.0:
Uso do Token de Portador (RFC 6750).
Essa resposta é igual a resposta à solicitação do AAD de token de acesso de serviço para serviço.
NOTE
Variáveis de ambiente são configuradas quando o processo é iniciado pela primeira vez, então após habilitar a identidade
gerenciada para o seu aplicativo, você pode precisar reiniciar o aplicativo ou reimplantar o código dele antes que
MSI_ENDPOINT e MSI_SECRET estejam disponíveis para seu código.
Exemplos de protocolo REST

Uma solicitação de exemplo pode ser semelhante ao seguinte:
GET /MSI/token?resource=https://vault.azure.net&api-version=2017-09-01 HTTP/1.1

Host: localhost:4141
Secret: 853b9a84-5bfa-4b22-a3f3-0b9a43d9ad8a
Uma resposta de exemplo pode ser semelhante ao seguinte:
HTTP/1.1 200 OK
{
"access_token": "eyJ0eXAi…",
"expires_on": "09/14/2017 00:00:00 PM +00:00",
"resource": "https://vault.azure.net",
"token_type": "Bearer"
}
Exemplos de código
.NET
JavaScript
Python
PowerShell
TIP
Para as linguagens .NET, também é possível usar Microsoft.Azure.Services.AppAuthentication em vez de criar essa solicitação
por conta própria.
// ...
public async Task<HttpResponseMessage> GetToken(string resource) {
var request = new HttpRequestMessage(HttpMethod.Get,
String.Format("{0}/?resource={1}&api-version=2017-09-01",
Environment.GetEnvironmentVariable("MSI_ENDPOINT"), resource));
request.Headers.Add("Secret", Environment.GetEnvironmentVariable("MSI_SECRET"));
return await _client.SendAsync(request);
}
Usar a biblioteca de Microsoft.Azure.Services.AppAuthentication do .NET

Para aplicativos e funções .NET, a maneira mais simples de trabalhar com uma identidade gerenciada é por meio
do pacote Microsoft.Azure.Services.AppAuthentication. Essa biblioteca também permitirá que você teste seu código
localmente em sua máquina de desenvolvimento, usando sua conta de usuário do Visual Studio, a Azure CLI ou a
Autenticação Integrada do Active Directory. Para obter mais informações sobre as opções de desenvolvimento
local com essa biblioteca, consulte a Referência Microsoft.Azure.Services.AppAuthentication. Esta seção mostra a
você como começar a usar a biblioteca no seu código.
1. Adicione referências a Microsoft.Azure.Services.AppAuthentication e a qualquer outro pacote NuGet
necessário para seu aplicativo. O exemplo abaixo também usa Microsoft.Azure.KeyVault.
2. Adicione o seguinte código ao seu aplicativo, modificando-o para ter como destino o recurso correto. Este
exemplo mostra duas maneiras de trabalhar com o Azure Key Vault:
using Microsoft.Azure.Services.AppAuthentication;
using Microsoft.Azure.KeyVault;
// ...
var azureServiceTokenProvider = new AzureServiceTokenProvider();
string accessToken = await azureServiceTokenProvider.GetAccessTokenAsync("https://vault.azure.net");
// OR
var kv = new KeyVaultClient(new
KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
Para saber mais sobre o Microsoft.Azure.Services.AppAuthentication e as operações que ele expõe, consulte a
Referência Microsoft.Azure.Services.AppAuthentication e Serviço de Aplicativo e KeyVault com a amostra MSI
.NET.
Usando o SDK do Azure para Java
Para aplicativos e funções Java, a maneira mais simples de trabalhar com uma identidade gerenciada é por meio do
SDK do Azure para Java. Esta seção mostra a você como começar a usar a biblioteca no seu código.
1. Adicione uma referência à biblioteca do SDK do Azure. Para projetos Maven, você pode adicionar esse
trecho à seção dependencies do arquivo POM do projeto:
<dependency>
<groupId>com.microsoft.azure</groupId>
<artifactId>azure</artifactId>
<version>1.23.0</version>
</dependency>
2. Use o objeto AppServiceMSICredentials para autenticação. Este exemplo mostra como esse mecanismo pode
ser usado para trabalhar com Azure Key Vault:
import com.microsoft.azure.AzureEnvironment;
import com.microsoft.azure.management.Azure;
import com.microsoft.azure.management.keyvault.Vault
//...
Azure azure = Azure.authenticate(new AppServiceMSICredentials(AzureEnvironment.AZURE))
.withSubscription(subscriptionId);
Vault myKeyVault = azure.vaults().getByResourceGroup(resourceGroup, keyvaultName);
Removendo uma identidade

Uma identidade atribuída pelo sistema pode ser removida desabilitando o recurso usando o portal, PowerShell ou
CLI da mesma forma que foi criado. As identidades atribuídas pelo usuário podem ser removidas individualmente.
Para remover todas as identidades, no protocolo de modelo REST / ARM, isso é feito definindo o tipo como
"Nenhum":
"identity": {
"type": "None"
}
Remover uma identidade atribuída pelo sistema dessa maneira também a excluirá do AAD. As identidades
atribuídas pelo sistema também são automaticamente removidas do AAD quando o recurso do aplicativo é
excluído.
NOTE
Há também uma configuração de aplicativo que pode ser definida, WEBSITE_DISABLE_MSI, que apenas desativa o serviço de
token local. No entanto, ele deixa a identidade no local e ferramentas ainda mostrará a identidade gerenciada como "ligada"
ou "habilitada". Como resultado, o uso dessa configuração não é recomendado.
Próximos passos
Acesse o Banco de Dados SQL com segurança usando uma identidade gerenciada
Usar referências de Key Vault para o serviço de
aplicativo e Azure Functions
NOTE
Key Vault referências não estão disponíveis atualmente nos planos de consumo do Linux.
Este tópico mostra como trabalhar com segredos do Cofre de Chaves do Azure no seu aplicativo Serviço de
Aplicativo ou no Aplicativo de Funções do Azure sem exigir alterações de código. Azure Key Vault é um serviço que
fornece gerenciamento centralizado de segredos, com controle total sobre políticas de acesso e histórico de
auditoria.
Concedendo o seu acesso ao aplicativo para o Google Key Vault

Para ler os segredos do Key Vault, você precisa criar um vault e conceder permissão ao aplicativo para acessá-lo.
1. Crie um cofre de chaves seguindo o início rápido do Key Vault .
2. Crie uma Identidade gerenciada designada pelo sistema para seu aplicativo.
NOTE
No momento, as referências do Key Vault suportam apenas identidades gerenciadas atribuídas pelo sistema.
Identidades atribuídas pelo usuário não podem ser usadas.
3. Crie uma política de acesso no Key Vault para a identidade do aplicativo que você criou anteriormente. Ative
a permissão secreta "Obter" nesta política. Não defina o "aplicativo autorizado" ou as configurações
applicationId , pois isso não é compatível com uma identidade gerenciada.
NOTE
Key Vault referências não estão atualmente capazes de resolver segredos armazenados em um cofre de chaves com
restrições de rede.
Sintaxe de referência
Uma referência do Key Vault é da forma @Microsoft.KeyVault({referenceString}) , em que {referenceString} é
substituído por uma das seguintes opções:
CADEIA DE CARACTERES DE REFERÊNCIA DESCRIÇÃO
SecretUri = secretUri O SegredoUri deve ser o URI do plano de dados completo de

um segredo no Key Vault, incluindo uma versão, por exemplo,
https://myvault.vault.azure.net/secrets/mysecret/ec96f020802
54f109c51a1f14cdb1931
CADEIA DE CARACTERES DE REFERÊNCIA DESCRIÇÃO
VaultName = vaultName; SecretName = secretName; O VaultName deve ser o nome do seu recurso Key Vault. O
SecretVersion = secretVersion SecretName deve ser o nome do segredo de destino. O
SecretVersion deve ser a versão do segredo a ser usado.
Por exemplo, uma referência completa com a versão seria parecida com a seguinte:
@Microsoft.KeyVault(SecretUri=https://myvault.vault.azure.net/secrets/mysecret/ec96f02080254f109c51a1f14cdb1931
)
Como alternativa:
@Microsoft.KeyVault(VaultName=myvault;SecretName=mysecret;SecretVersion=ec96f02080254f109c51a1f14cdb1931)
Configurações de aplicativos de origem do cofre de chaves

Key Vault referências podem ser usadas como valores para configurações do aplicativo, permitindo que você
mantenha os segredos em Key Vault em vez da configuração do site. As configurações do aplicativo são
criptografadas com segurança em repouso, mas se você precisar de recursos de gerenciamento secreto, elas
deverão entrar em Key Vault.
Para usar uma referência do Key Vault para uma configuração de aplicativo, defina a referência como o valor da
configuração. Seu aplicativo pode fazer referência ao segredo por meio de sua chave normalmente. Nenhuma
alteração de código é necessária.
TIP
A maioria das configurações de aplicativos que usam referências do Key Vault deve ser marcada como configurações de slot,
pois você deve ter cofres separados para cada ambiente.
Implantação do Azure Resource Manager

Ao automatizar implantações de recursos por meio dos modelos do Azure Resource Manager, talvez seja
necessário sequenciar suas dependências em uma ordem específica para que esse recurso funcione. Observe que
você precisará definir as configurações do aplicativo como seu próprio recurso, em vez de usar uma propriedade
siteConfig na definição do site. Isso ocorre porque o site precisa ser definido primeiro para que a identidade
atribuída pelo sistema seja criada com ele e possa ser usada na política de acesso.
Um exemplo de psuedo-template para um aplicativo de função pode ser semelhante ao seguinte:
{
//...
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"name": "[variables('storageAccountName')]",
//...
},
{
"type": "Microsoft.Insights/components",
"name": "[variables('appInsightsName')]",
//...
},
{
"identity": {
},
//...
"resources": [
{
"type": "config",
"name": "appsettings",
//...
"dependsOn": [
"[resourceId('Microsoft.Web/sites', variables('functionAppName'))]",
"[resourceId('Microsoft.KeyVault/vaults/', variables('keyVaultName'))]",
"[resourceId('Microsoft.KeyVault/vaults/secrets', variables('keyVaultName'),
variables('storageConnectionStringName'))]",
"[resourceId('Microsoft.KeyVault/vaults/secrets', variables('keyVaultName'),
variables('appInsightsKeyName'))]"
],
"properties": {
"AzureWebJobsStorage": "[concat('@Microsoft.KeyVault(SecretUri=',
reference(variables('storageConnectionStringResourceId')).secretUriWithVersion, ')')]",
"WEBSITE_CONTENTAZUREFILECONNECTIONSTRING": "[concat('@Microsoft.KeyVault(SecretUri=',
reference(variables('storageConnectionStringResourceId')).secretUriWithVersion, ')')]",
"APPINSIGHTS_INSTRUMENTATIONKEY": "[concat('@Microsoft.KeyVault(SecretUri=',
reference(variables('appInsightsKeyResourceId')).secretUriWithVersion, ')')]",
"WEBSITE_ENABLE_SYNC_UPDATE_SITE": "true"
//...
}
},
{
"type": "sourcecontrols",
"name": "web",
//...
"dependsOn": [
"[resourceId('Microsoft.Web/sites', variables('functionAppName'))]",
"[resourceId('Microsoft.Web/sites/config', variables('functionAppName'),
'appsettings')]"
],
}
]
},
{
"type": "Microsoft.KeyVault/vaults",
"name": "[variables('keyVaultName')]",
//...
"dependsOn": [
"[resourceId('Microsoft.Web/sites', variables('functionAppName'))]"
],
"properties": {
//...
"accessPolicies": [
{
"tenantId": "[reference(concat('Microsoft.Web/sites/', variables('functionAppName'),
'/providers/Microsoft.ManagedIdentity/Identities/default'), '2015-08-31-PREVIEW').tenantId]",
"objectId": "[reference(concat('Microsoft.Web/sites/', variables('functionAppName'),
'/providers/Microsoft.ManagedIdentity/Identities/default'), '2015-08-31-PREVIEW').principalId]",
"permissions": {
"secrets": [ "get" ]
}
}
]
},
"resources": [
{
"type": "secrets",
"name": "[variables('storageConnectionStringName')]",
//...
"dependsOn": [
],
"properties": {
variables('storageAccountName'), ';AccountKey=', listKeys(variables('storageAccountResourceId'),'2015-05-01-
preview').key1)]"
}
},
{
"type": "secrets",
"name": "[variables('appInsightsKeyName')]",
//...
"dependsOn": [
"[resourceId('Microsoft.Insights/components', variables('appInsightsName'))]"
],
"properties": {
"value": "[reference(resourceId('microsoft.insights/components/',
variables('appInsightsName')), '2015-05-01').InstrumentationKey]"
}
}
]
}
]
}
NOTE
Neste exemplo, a implantação do controle de origem depende das configurações do aplicativo. Esse comportamento
normalmente é inseguro, pois a atualização da configuração do aplicativo se comporta de maneira assíncrona. No entanto,
como incluímos a configuração do aplicativo WEBSITE_ENABLE_SYNC_UPDATE_SITE , a atualização é síncrona. Isso significa que
a implantação do controle de origem só será iniciada quando as configurações do aplicativo tiverem sido totalmente
atualizadas.
Solucionando problemas de referências de Key Vault

Se uma referência não for resolvida corretamente, o valor de referência será usado em seu lugar. Isso significa que,
para as configurações do aplicativo, uma variável de ambiente seria criada cujo valor tem a sintaxe
@Microsoft.KeyVault(...) . Isso pode fazer com que o aplicativo gere erros, pois estava esperando um segredo de
uma determinada estrutura.
Normalmente, isso se deve a uma configuração incorreta da política de acesso de Key Vault. No entanto, também
pode ser devido a um segredo não mais existente ou a um erro de sintaxe na própria referência.
Se a sintaxe estiver correta, você poderá exibir outras causas de erro verificando o status atual da resolução no
Portal. Navegue até configurações do aplicativo e selecione "Editar" para a referência em questão. Abaixo da
configuração de configuração, você deve ver informações de status, incluindo quaisquer erros. A ausência deles
implica que a sintaxe de referência é inválida.
Você também pode usar um dos detectores internos para obter informações adicionais.
Usando o detector para o serviço de aplicativo
1. No portal, navegue até seu aplicativo.
2. Selecione diagnosticar e resolver problemas.
3. Escolha disponibilidade e desempenho e selecione aplicativo Web inativo.
4. Encontre Key Vault diagnóstico de configurações do aplicativo e clique em mais informações.
Usando o detector para Azure Functions
1. No portal, navegue até seu aplicativo.
2. Navegue até recursos da plataforma.
3. Selecione diagnosticar e resolver problemas.
4. Escolha disponibilidade e desempenho e selecione aplicativo de funções ou relatando erros.
5. Clique em Key Vault configurações do aplicativo diagnósticos.
Armazenar dados não estruturados usando o Azure
Functions e o Azure Cosmos DB
O Azure Cosmos DB é uma ótima maneira de armazenar dados não estruturados e JSON. Combinado com o
Azure Functions, o Cosmos DB torna o armazenamento de dados rápido e fácil com muito menos código do que o
necessário para armazenar dados em um banco de dados relacional.
NOTE
Neste momento, o gatilho, as associações de entrada e as associações de saída do Azure Cosmos DB funcionam apenas com
contas da API do Graph e a API do SQL.
No Azure Functions, associações de entrada e saída fornecem uma maneira declarativa para se conectar a dados
de serviço externo de sua função. Neste artigo, saiba como atualizar uma função existente a fim de adicionar uma
associação de saída que armazena dados não estruturados em um documento do Azure Cosmos DB.
Pré-requisitos

Antes de criar a associação de saída, você precisa ter uma conta do Azure Cosmos DB que use a API de SQL.
selecione-o.
Cosmos.

Azure Cosmos.

grupo de recursos.


caracteres.

e Cassandra. No momento, você
deve criar uma conta separada para
cada API.
1. No portal, navegue até o aplicativo de funções que você criou anteriormente e expanda o aplicativo de
funções e a função.
2. Selecione Integrar e +Nova Saída, que está na parte superior direita da página. Escolha Azure Cosmos
DB e clique em Selecionar.
de associações do Azure Cosmos DB no aplicativo de funções. A instalação pode levar alguns minutos.
4. Use a configuração Saída do Azure Cosmos DB conforme especificado na tabela:
Nome do parâmetro do taskDocument Nome que se refere ao objeto do

documento Cosmos DB no código.
Nome do banco de dados taskDatabase Nome do banco de dados para salvar

os documentos.
Nome da coleção TaskCollection Nome da coleção de banco de dados.
Se for true, cria o banco de dados Verificado A coleção ainda não existe, então crie
e a coleção do Cosmos DB uma.
Taxa de transferência de coleção 400 RU Se quiser reduzir a latência, você

poderá escalar verticalmente a taxa
de transferência mais tarde.
5. Selecione Salvar para criar a associação.

Atualizar o código de função
Substitua o código existente da função pelo código a seguir na linguagem que você escolheu:
C#
JavaScript
Substitua função de C# existente por este código:
public static IActionResult Run(HttpRequest req, out object taskDocument, ILogger log)
{
string task = req.Query["task"];
string duedate = req.Query["duedate"];
// We need both name and task parameters.

if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(task))
{
taskDocument = new
{
name,
duedate,
task
};
return (ActionResult)new OkResult();

}
else
{
taskDocument = null;
return (ActionResult)new BadRequestResult();
}
}
Esse exemplo de código lê as cadeias de consulta da Solicitação HTTP e as atribui a campos no objeto
taskDocument . A associação taskDocument envia os dados do objeto desse parâmetro de associação para
armazenamento no banco de dados de documento associado. O banco de dados é criado na primeira execução da
função.
Testar a função e o banco de dados

1. Expanda a janela direita e selecione Testar. Em Consulta, clique em + Adicionar parâmetro e adicione os
seguintes parâmetros à cadeia de consulta:
name
task
duedate
2. Clique em Executar e verifique se um status 200 retorna.
3. No lado esquerdo do Portal do Azure, expanda a barra de ícones, digite cosmos no campo de pesquisa e
selecione Azure Cosmos DB.

5. Expanda os nós Coleções, selecione o novo documento e confirme se o documento contém os valores de
cadeia de consulta, juntamente com alguns metadados adicionais.
Você adicionou com êxito uma associação ao gatilho HTTP para armazenar dados não estruturados em um Azure
Cosmos DB.
Limpar recursos
Próximas etapas
Para saber mais sobre a associação a um banco de dados Cosmos DB, veja Associações do Azure Functions
Cosmos DB.
Adicionar uma associação de fila do Armazenamento
do Azure à sua função do Python
Armazenamento do Azure. A associação de saída que você adiciona a essa função escreve dados de uma
solicitação HTTP em uma mensagem na fila.
Pré-requisitos
Antes de iniciar este artigo, conclua as etapas na parte 1 do início rápido do Python.
NOTE

de conexão dessa conta é armazenada com segurança nas configurações do aplicativo no Azure. Neste artigo,
você escreverá mensagens em uma Fila de armazenamento na mesma conta. Para se conectar à sua Conta de
armazenamento ao executar a função localmente, é necessário baixar as configurações do aplicativo para o
IMPORTANT

seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}

funções.
function.json.
function.json na pasta HttpTrigger e escolha Adicionar associação... . Siga os prompts para definir as
seguintes propriedades de associação para a nova associação:

uso.

seguinte exemplo:
{
...
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
},
{
"type": "queue",
"direction": "out",
"name": "msg",
}
]
}

Depois que o name estiver configurado, será possível começar a usá-lo para acessar a associação como um
atributo de método na assinatura de função. No exemplo a seguir, msg é uma instância do
azure.functions.InputStream class .
import logging
def main(req: func.HttpRequest, msg: func.Out[func.QueueMessage]) -> str:
if not name:
try:
except ValueError:
pass
else:
if name:
msg.set(name)
return func.HttpResponse(f"Hello {name}!")
else:
status_code=400
)

Como anteriormente, use o seguinte comando para iniciar o tempo de execução do Functions localmente:
func host start
NOTE
navegador. Acrescente o valor de cadeia de consulta ?name=<yourname> a essa URL e execute a solicitação. Você
deve ver a mesma resposta no navegador como você viu no artigo anterior.
exemplo a seguir:
executada.
seguir:
decode`
NOTE
Para atualizar o aplicativo publicado, use o comando func azure functionapp publish do Core Tools para
implantar o código do projeto no Azure. Nesse exemplo, substitua <APP_NAME> pelo nome de seu aplicativo.
Novamente, é possível usar cURL ou um navegador para testar a função implantada. Como antes, acrescente a
cadeia de caracteres de consulta &name=<yourname> à URL, como mostrado no exemplo a seguir:
curl https://myfunctionapp.azurewebsites.net/api/httptrigger?code=cCr8sAxfBiow548FBDLS1....&name=<yourname>
Examine a mensagem da Fila de armazenamento novamente para verificar se a associação de saída gera uma
nova mensagem na fila, conforme esperado.
Limpar recursos
Próximas etapas
sobre como desenvolver o Azure Functions usando o Python, confira o Guia do desenvolvedor de Python para o
Azure Functions e Gatilhos e associações do Azure Functions. Para obter exemplos de projetos de funções
completos no Python, confira os Exemplos de funções de Python.
Adicionar mensagens a uma fila do Armazenamento
do Azure usando o Functions
No Azure Functions, as associações de entrada e saída fornecem uma maneira declarativa para criar dados a
partir de serviços externos disponíveis ao seu código. Neste guia de início rápido, é possível usar uma associação
de saída para criar uma mensagem em uma fila quando uma função é disparada por uma solicitação HTTP. Use
o Gerenciador de Armazenamento do Azure para exibir as mensagens em fila que sua função cria:
Pré-requisitos
Siga as instruções em Criar sua primeira função no portal do Azure e não realize a etapa Limpar
recursos. Este início rápido cria o aplicativo de funções e a função que você usa aqui.
Instale o Gerenciador de Armazenamento do Microsoft Azure. Esta é uma ferramenta que você usará para
examinar a fila de mensagens cuja sua associação de saída cria.

Nesta seção, você usa a interface do usuário do portal para adicionar uma associação de saída de
armazenamento de filas para a função criada anteriormente. Essa associação tornará possível gravar com o
mínimo de código para criar uma mensagem em uma fila. Você não precisa escrever códigos para tarefas como
abrir uma conexão de armazenamento, criar uma fila ou obter uma referência a uma fila. O tempo de execução
do Azure Functions e a associação de saída da fila cuidam dessas tarefas para você.
1. No portal do Azure, abra a página de aplicativo de funções do aplicativo de funções criado por você em
Criar sua primeira função no portal do Azure. Para fazer isso, selecione Todos os serviços > Aplicativo
de funções e depois selecione seu aplicativo de funções.
2. Selecione a função que você criou no guia de início rápido anterior.
3. Selecione Integrar > Nova saída > Armazenamento de fila do Azure.
4. Clique em Selecionar.
Associações de armazenamento no aplicativo de funções. Isso pode levar alguns minutos.
6. Em Saída de armazenamento de filas do Azure, use as configurações conforme especificado na tabela

após esta captura de tela:
Nome do parâmetro de outputQueueItem O nome do parâmetro de associação

mensagem de saída.

armazenamento de armazenamento que já está
sendo usada por seu aplicativo de
funções ou criar uma nova.
Nome da fila outqueue Nome da fila à qual se conectar em

7. Clique em Salvar para adicionar a associação.

Agora que você tem uma associação de saída definida, você precisa atualizar o código para usar a associação
para adicionar mensagens a uma fila.

Nesta seção, você adiciona o código que grava uma mensagem na fila de saída. A mensagem inclui o valor que é
passado para o gatilho HTTP na cadeia de consulta. Por exemplo, se a cadeia de consulta incluir name=Azure , a
mensagem da fila será Nome transmitido para a função: Azure.
1. Selecione sua função para exibir o código de função no editor.
2. Atualize o código de função, dependendo da linguagem de programação de sua função:
C#
JavaScript
Adicione um parâmetro outputQueueItem à assinatura do método, conforme mostrado no exemplo a
seguir.
public static async Task<IActionResult> Run(HttpRequest req,

ICollector<string> outputQueueItem, ILogger log)
{
...
}
No corpo da função, imediatamente antes da instrução return , adicione o código que usa o parâmetro
para criar uma mensagem da fila.
outputQueueItem.Add("Name passed to the function: " + name);
3. Selecione Salvar para salvar as alterações.
Testar a função
1. Depois que as alterações de código forem salvas, selecione Executar.
Observe que o Corpo da solicitação contém o valor de name Azure. Esse valor aparece na mensagem
da fila que é criada quando a função é invocada.
Como uma alternativa para selecionar Executar aqui, você pode chamar a função inserindo uma URL em
um navegador e especificando o valor name na cadeia de consulta. O método de navegador é mostrado
no guia de início rápido anterior.
2. Confira os logs para verificar se a função foi bem-sucedida.
para verificar se a fila e uma mensagem nela foram criadas.
Ignore esta seção caso já tenha instalado o Gerenciador de Armazenamento e o conectado à conta de
armazenamento sendo usada neste guia de início rápido.
1. Execute a ferramenta Gerenciador de Armazenamento do Microsoft Azure, selecione o ícone conectar-se à
esquerda, escolha Usar um nome e chave de conta de armazenamento e selecione Avançar.
2. No portal do Azure, na página de aplicativo de funções, selecione a função e depois Integrar.
3. Selecione a associação de saída do Armazenamento de fila do Azure que você adicionou em uma
etapa anterior.
4. Expanda a seção Documentação na parte inferior da página.
O portal mostra as credenciais que você pode usar no Gerenciador de Armazenamento para se conectar à
5. Copie o valor Nome da Conta do portal e cole-o na caixa Nome da conta no Gerenciador de
Armazenamento.
6. Clique no ícone mostrar/ocultar ao lado da Chave de Conta para exibir o valor e depois copie o valor
Chave de Conta e cole-o na caixa Chave de conta no Gerenciador de Armazenamento.
7. Selecione Próximo > Conectar.
1. No Gerenciador de Armazenamento, selecione a conta de armazenamento sendo usada para este guia de
início rápido.
A fila contém a mensagem que a associação de saída de fila criou quando você executou a função
disparada por HTTP. Se você tiver invocado a função com o valor name padrão do Azure, a mensagem da
fila será Nome transmitido à função: Azure.
3. Execute a função novamente e você verá uma nova mensagem exibida na fila.
Limpar recursos
desta maneira:
deseja excluir.
notificação.
Próximas etapas
Neste guia de início rápido, você adicionou uma associação de saída a uma função existente. Para obter mais
informações sobre associação a Armazenamento de Filas, consulte Associações de fila do Armazenamento do
Azure Functions.
Fornece informações mais técnicas sobre o tempo de execução do Functions e uma referência para funções
de codificação e definição de associações e gatilhos.
usando o Visual Studio Code
Este artigo mostra como usar Visual Studio Code para conectar a função criada no artigo de início rápido anterior
ao Armazenamento do Azure. A associação de saída que você adiciona a essa função escreve dados da solicitação
Pré-requisitos
Antes de iniciar este artigo, você deve atender aos seguintes requisitos:
Instale a extensão de Armazenamento do Azure para o Visual Studio Code.
Instale o Gerenciador de Armazenamento do Azure. O Gerenciador de Armazenamento é uma ferramenta que
você usará para examinar as mensagens da fila geradas pela associação de saída. O Gerenciador de
Armazenamento tem suporte em sistemas operacionais baseados em macOS, Windows e Linux.
Instale ferramentas de CLI do .NET Core (somente projetos C#).
Conclua as etapas na parte 1 do início rápido do Visual Studio Code.
Este artigo pressupõe que você já esteja conectado à sua assinatura do Azure do Visual Studio Code. Você pode
entrar executando Azure: Sign In na paleta de comandos.

Para se conectar à sua Conta de armazenamento ao executar a função localmente, é necessário baixar as
configurações do aplicativo para o arquivo local.settings.json.
1. Pressione a tecla F1 para abrir a paleta de comandos, pesquise e execute o comando
Azure Functions: Download Remote Settings.... .
2. Escolha o aplicativo de função que você criou no artigo anterior. Selecione Sim para todos para substituir
as configurações locais existentes.
IMPORTANT
Como ela contém segredos, o arquivo local.settings.json nunca é publicado e é excluído do controle do código-fonte.
3. Copie o valor AzureWebJobsStorage , que é a chave do valor da cadeia de conexão da Conta de
armazenamento. Use esta conexão para verificar se a associação de saída funciona conforme o esperado.

JavaScript
C#
seguir:
{
"version": "2.0",
"version": "[1.*, 2.0.0)"
}
}

funções.
JavaScript
C#
function.json.
function.json na pasta HttpTrigger e escolha Adicionar associação... . Siga os prompts para definir as seguintes
propriedades de associação para a nova associação:

uso.

seguinte exemplo:
{
...
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
},
{
"type": "queue",
"direction": "out",
"name": "msg",
}
]
}

JavaScript
C#
Adicione um código que usa o objeto de associação de saída msg em context.bindings para criar uma
mensagem da fila. Adicione esse código antes da instrução context.res .


context.res = {
};
}
else {
context.res = {
status: 400,
};
}
};

1. Para testar sua função, defina um ponto de interrupção no código da função e pressione F5 para iniciar o
projeto de aplicativo de funções. A saída do Core Tools é exibida no painel Terminal.
consulta ?name=<yourname> a essa URL e execute a solicitação. A execução é pausada quando o ponto de
interrupção é atingido.
4. Quando você continua a execução, o exemplo a seguir mostra a resposta no navegador à solicitação GET:
para verificar se a fila foi criada junto com a nova mensagem.
Ignore esta seção se você já instalou o Gerenciador de Armazenamento do Azure e o conectou à sua conta do
Azure.
1. Execute a ferramenta Gerenciador de Armazenamento do Azure, selecione o ícone de conexão à esquerda e
selecione Adicionar uma conta.
2. Na caixa de diálogo Conectar, escolha Adicionar uma conta do Azure, escolha seu Ambiente do Azure
e selecione Entrar... .
Depois de entrar na sua conta, você verá todas as assinaturas do Azure associadas à ela.
1. No Visual Studio Code, pressione a tecla F1 para abrir a paleta de comandos, em seguida, procure e execute
o comando Azure Storage: Open in Storage Explorer e escolha o nome da sua conta de armazenamento.
Sua conta de armazenamento é aberta no Gerenciador de Armazenamento do Azure.

selecione Azure Functions: Deploy to function app... .
2. Escolha o aplicativo de funções que você criou no primeiro artigo. Como você está reimplementando seu
projeto para o mesmo aplicativo, selecione Implantar para descartar o aviso de substituição de arquivos.
3. Após a conclusão da implantação, você poderá usar novamente o cURL ou um navegador para testar a
função reimplementada. Como antes, acrescente a cadeia de consulta &name=<yourname> à URL, como no
seguinte exemplo:
curl https://myfunctionapp.azurewebsites.net/api/httptrigger?code=cCr8sAxfBiow548FBDLS1....&name=
<yourname>
Limpar recursos
desta maneira:
selecione Azure Functions: Open in portal .
2. Escolha seu aplicativo de funções e pressione Enter. A página do aplicativo de funções é aberta no portal do
Azure.
3. Na guia Visão geral, selecione o link nomeado em Grupo de Recursos.
deseja excluir.
notificação.
Próximas etapas
Você atualizou sua função disparada por HTTP para gravar dados em uma Fila de armazenamento. Para saber
mais sobre o desenvolvimento de funções, confira Desenvolver Funções do Azure usando o Visual Studio Code.
usando o Visual Studio
Este artigo mostra como usar Visual Studio para conectar a função criada no artigo de Início Rápido anterior do
Armazenamento do Azure. A associação de saída que você adiciona a essa função escreve dados da solicitação
Pré-requisitos
Antes de iniciar este artigo, você deve:
Concluir a [parte 1 do Início Rápido do Visual Studio][./functions-create-first-function-vs-code.md].
Entrar em sua assinatura do Azure por meio do Visual Studio.

Para se conectar à Conta de armazenamento ao executar a função localmente, é necessário baixar as configurações
do aplicativo para o arquivo local.settings.json.
Publicar.
2. Em Ações, selecione Editar Configurações do Serviço de Aplicativo do Azure.
3. Em AzureWebJobsStorage, copie o valor da cadeia de caracteres Remote para Local e, em seguida,
selecione OK.
A associação de armazenamento, que usa a configuração AzureWebJobsStorage para a conexão, agora pode se
conectar ao armazenamento de filas ao executar localmente.

de armazenamento instalada antes de executar o projeto. Com exceção dos gatilhos de timer e HTTP, as
associações são implementadas como pacotes de extensão.
1. No menu Ferramentas selecione Gerenciador de Pacotes NuGet > Console do Gerenciador de
Pacotes.
2. No console, execute o comando Install-Package a seguir para instalar as extensões de armazenamento:
Install-Package Microsoft.Azure.WebJobs.Extensions.Storage -Version 3.0.6

Em um projeto de biblioteca de classes C#, as associações são definidas como atributos de associação no método
de função. O arquivo function.json é gerado automaticamente com base nesses atributos.
Abra o arquivo de projeto HttpTrigger.cs e adicione a seguinte instrução using :
using Microsoft.Azure.WebJobs.Extensions.Storage;
Adicione o seguinte parâmetro à definição do método Run :
[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg
O parâmetro msg é um tipo ICollector<T> , que representa uma coleção de mensagens que são gravadas em
uma associação de saída quando a função é concluída. Nesse caso, a saída é uma fila de armazenamento
denominada outqueue . A cadeia de conexão para a Conta de armazenamento é definida pelo
StorageAccountAttribute . Esse atributo indica a configuração que contém a cadeia de conexão da Conta de
armazenamento e pode ser aplicada no nível de classe, método ou parâmetro. Nesse caso, você poderia omitir
StorageAccountAttribute porque já está usando a conta de armazenamento padrão.
A definição do método Executar deve agora se parecer com o seguinte:

Adicione um código que usa o objeto de associação de saída de msg para criar uma mensagem da fila. Adicione
esse código antes do método retornar.
{
}
{

{
}
return name != null
: new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}


Uma nova fila denominada outqueue é criada na conta de armazenamento pelo tempo de execução do Functions
quando a associação de saída é usada pela primeira vez. Você usará o Cloud Explorer para verificar se a fila foi
criada junto com a nova mensagem.

1. No menu Exibir no Visual Studio, selecione Cloud Explorer.
2. No Cloud Explorer, expanda sua assinatura do Azure e Contas de Armazenamento e, em seguida,
expanda a conta de armazenamento usada pela função. Se você não conseguir se lembrar do nome da
conta de armazenamento, verifique a configuração da cadeia de conexão AzureWebJobsStorage no arquivo
3. Expanda o nó Filas e clique duas vezes na fila chamada subfila para exibir o conteúdo dela no Visual
Studio.

1. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto, selecione Publicar e, em
seguida, escolha Publicar para republicar o projeto no Azure.
2. Após a conclusão da implantação, você poderá usar o navegador novamente para testar a função
reimplementada. Assim como antes, acrescente a cadeia de caracteres de consulta &name=<yourname> à URL.
Limpar recursos
desta maneira:
deseja excluir.
notificação.
Próximas etapas
Você atualizou sua função disparada por HTTP para gravar dados em uma Fila de armazenamento. Para saber
mais sobre o desenvolvimento do Functions, confira Desenvolver o Azure Functions usando o Visual Studio.
Usar o Azure Functions para conectar a um banco de
dados SQL do Azure
Este artigo mostra como usar Azure Functions para criar um trabalho agendado que se conecta a um banco de
dados SQL do Azure ou Instância Gerenciada SQL do Azure. O código de função limpa as linhas em uma tabela
no banco de dados. A nova C# função é criada com base em um modelo de gatilho de temporizador predefinido
no Visual Studio 2019. Para dar suporte a esse cenário, você também precisa definir uma cadeia de conexão de
banco de dados como uma configuração de aplicativo no aplicativo de funções. Para o Azure SQL Instância
Gerenciada você precisa habilitar o ponto de extremidade público para poder se conectar de Azure functions. Esse
cenário usa uma operação em massa no banco de dados.
Se esta for sua primeira experiência trabalhando com funções C#, você deverá ler a Referência do desenvolvedor
de C# do Azure Functions.
Pré-requisitos
Conclua as etapas no artigo Criar sua primeira função usando o Visual Studio para criar um aplicativo de
funções local destinado ao tempo de execução versão 2.x. Você também precisa ter publicado seu projeto
em um aplicativo de funções no Azure.
Este artigo demonstra um comando Transact-SQL que executa uma operação de limpeza em massa na
tabela SalesOrderHeader no banco de dados de amostra AdventureWorksLT. Para criar o banco de dados
de amostra AdventureWorksLT, conclua as etapas no artigo Criar um Banco de Dados SQL do Azure no
portal do Azure.
Você precisa adicionar uma regra de firewall no nível do servidor para o endereço IP público do
computador que usou para este início rápido. Essa regra é necessária para que seja possível acessar a
instância do Banco de Dados SQL do seu computador local.
Obter informações de conexão

Você precisa obter a cadeia de conexão para o banco de dados que você criou quando concluiu Criar um Banco de
Dados SQL do Azure no Portal do Azure.
2. Selecione Bancos de Dados SQL no menu à esquerda e selecione seu banco de dados na página Bancos
de Dados SQL.
3. Selecione Cadeias de conexão em Configurações e copie a cadeia de conexão completa do ADO.NET.
Para Azure SQL Instância Gerenciada copiar cadeia de conexão para o ponto de extremidade público.
Definir a cadeia de conexão
Um aplicativo de funções hospeda a execução de suas funções no Azure. Como uma prática de segurança
recomendada, armazene cadeias de conexão e outros segredos nas configurações do seu aplicativo de funções.
Usar as configurações do aplicativo impede a divulgação acidental da cadeia de conexão com seu código. Você
pode acessar as configurações do aplicativo para seu aplicativo de funções diretamente do Visual Studio.
Você precisa ter publicado o aplicativo anteriormente no Azure. Se você ainda não fez isso, publique o aplicativo de
funções no Azure.
1. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto do aplicativo de funções e
escolha Publicar > Gerenciar configurações do aplicativo... . Selecione Adicionar configuração, em
Novo nome de configuração do aplicativo, digite sqldb_connection e selecione OK.
2. Na configuração sqldb_connection, cole a cadeia de conexão que você copiou na seção anterior no campo
Local e substitua os espaços reservados {your_username} e {your_password} por valores reais. Selecione
Inserir o valor do local para copiar o valor atualizado para o campo remoto e, em seguida, selecione OK.
As cadeias de conexão são armazenadas criptografadas no Azure (Remoto). Para evitar o vazamento de
segredos, o arquivo de projeto local.settings.json (Local) deve ser excluídos do controle do código-fonte,
por exemplo, por meio de um arquivo .gitignore.
Adicione o pacote do SqlClient ao projeto

Você precisa adicionar o pacote do NuGet que contém a biblioteca do SqlClient. Essa biblioteca de acesso a dados
é necessária para se conectar a um banco de dados SQL.
1. Abra seu projeto de aplicativo de função local no Visual Studio 2019.
escolha Gerenciar Pacotes NuGet.
3. Na guia Procurar, pesquise System.Data.SqlClient e quando encontrar, selecione.
4. Na página System.Data.SqlClient, selecione a versão 4.5.1 e clique em Instalar.
5. Quando a instalação for concluída, revise as alterações e então clique em OK para fechar a janela
Visualização.
6. Se uma janela Aceitação da Licença for exibida, clique em Aceito.
Agora, você pode adicionar o código de função C# que conecta ao Banco de Dados SQL.
Adicionar uma função disparada por temporizador

escolha Adicionar > Nova função do Azure.
2. Com o modelo do Azure Functions selecionado, nomeie o novo item algo semelhante a
DatabaseCleanup.cs e selecione Adicionar.
3. Na caixa de diálogo Nova função do Azure, escolha Gatilho de temporizador e, em seguida, OK. Essa
caixa de diálogo cria um arquivo de código para a função disparada por temporizador.
4. Abra o novo arquivo de código e adicione o seguinte, usando as instruções na parte superior do arquivo:
using System.Data.SqlClient;
5. Substitua a função Run existente por este código:

[FunctionName("DatabaseCleanup")]
public static async Task Run([TimerTrigger("*/15 * * * * *")]TimerInfo myTimer, ILogger log)
{
// Get the connection string from app settings and use it to create a connection.
var str = Environment.GetEnvironmentVariable("sqldb_connection");
using (SqlConnection conn = new SqlConnection(str))
{
conn.Open();
var text = "UPDATE SalesLT.SalesOrderHeader " +
"SET [Status] = 5 WHERE ShipDate < GetDate();";
using (SqlCommand cmd = new SqlCommand(text, conn))

{
// Execute the command and log the # rows affected.
var rows = await cmd.ExecuteNonQueryAsync();
log.LogInformation($"{rows} rows were updated");
}
}
}
Esta função é executada a cada 15 segundos para atualizar a coluna Status com base na data de envio.
Para saber mais sobre o Gatilho de temporizador, veja Gatilho de temporizador para o Azure Functions.
6. Pressione F5 para iniciar o aplicativo de funções. A janela de execução das Azure Functions Core Tools é
aberta atrás do Visual Studio.
7. Passados 15 segundos da inicialização, a função é executada. Inspecione a saída e anote o número de linhas
atualizadas na tabela SalesOrderHeader.
Na primeira execução, você deve atualizar 32 linhas de dados. As execuções seguintes não atualizam
nenhuma linha de dados, a menos que você faça alterações aos dados da tabela SalesOrderHeader para
que mais linhas sejam selecionadas pela instrução UPDATE .
Se você planeja publicar essa função, lembre-se de alterar o atributo TimerTrigger para uma agenda de Cron mais
razoável do que a cada 15 segundos.
Próximas etapas
Em seguida, aprenda como usar. Functions com Aplicativos Lógicos para integração com outros serviços.
Criar uma função que se integra nos Aplicativos Lógicos
Para obter mais informações sobre o Functions, veja os seguintes artigos:
Referência do programador para codificação de funções e definição de gatilhos e de associações.
2 minutes to read
2 minutes to read
Exportando uma API hospedada no Azure para o
PowerApps e o Microsoft Flow
O PowerApps é um serviço para a criação e utilização de aplicativos comerciais personalizados que se conectam
aos seus dados e trabalham entre plataformas. O Microsoft Flow facilita a automação de fluxos de trabalho e
processos de negócios entre seus aplicativos e serviços favoritos. O PowerApps e o Microsoft Flow vêm com uma
variedade de conectores integrados para fontes de dados como Office 365, Dynamics 365, Salesforce e muito
mais. Em alguns casos, construtores de aplicativo e fluxo também querem se conectar a fontes de dados e APIs
criados por sua organização.
Da mesma forma, os desenvolvedores que desejam expor suas APIs mais amplamente dentro da organização
podem querer disponibilizá-las para construtores de aplicativos e fluxos. Este tópico mostra como exportar uma
API criada com o Azure Functions ou o Serviço de Aplicativo do Azure. A API exportada torna-se um conector
personalizado, usado no PowerApps e no Microsoft Flow, assim como um conector interno.
IMPORTANT
A funcionalidade de definição de API mostrada neste artigo só tem suporte para a versão 1. x dos aplicativos de tempo de
execução de Azure Functions e serviços de aplicativos. A versão 2. x das funções integra-se ao gerenciamento de API para
criar e manter definições de OpenAPI. Para saber mais, confira criar uma definição de openapi para uma função com o
gerenciamento de API do Azure.
Criar e exportar uma definição de API

Antes de exportar uma API, é necessário descrevê-la usando uma definição OpenAPI (anteriormente conhecida
como um arquivo Swagger). Esta definição contém informações sobre as operações que estão disponíveis em uma
API e como os dados de solicitação e resposta para a API devem ser estruturados. O PowerApps e o Microsoft
Flow podem criar conectores personalizados para qualquer definição OpenAPI 2.0. O Serviço de Aplicativo do
Azure e o Azure Functions têm suporte integrado para criação, hospedagem e gerenciamento de definições
OpenAPI. Para obter mais informações, consulte Hospedar uma API RESTful com CORS no Serviço de Aplicativo
do Azure.
NOTE
Também é possível criar conectores personalizados no PowerApps e no Microsoft Flow UI, sem o uso de uma definição
OpenAPI. Para obter mais informações, consulte Registrar e usar conectores personalizados no PowerApps e Registrar e usar
conectores personalizados no Microsoft Flow.
Para exportar a definição de API, siga estas etapas:

1. No Portal do Azure, navegue até o aplicativo Azure Functions ou outro aplicativo de Serviço de Aplicativo.
Se utilizar o Azure Functions, selecione seu aplicativo de funções, escolha Recursos de plataforma e, em
seguida, Definição de API.
Se usar o Serviço de Aplicativo do Azure, selecione definição de API da lista de configurações.
2. O botão Exportar para o PowerApps e para o Microsoft Flow deve estar disponível (se não estiver, crie
uma definição de OpenAPI primeiro). Clique neste botão para iniciar o processo de exportação.
3. Selecione o Modo de Exportação:

Expresso permite que você crie o conector personalizado a partir do portal do Azure. É necessário estar
conectado ao PowerApps ou ao Microsoft Flow e ter permissão para criar conectores no ambiente de
destino. Essa é a abordagem recomendada se esses dois requisitos puderem ser atendidos. Se estiver
utilizando esse modo, siga as instruções de Exportação de expresso abaixo.
Manual permite exportar a definição de API, que depois pode ser importada utilizando os portais do
PowerApps e Microsoft Flow. Essa é a abordagem recomendada se o usuário do Azure e o usuário com
permissão para criar conectores forem pessoas diferentes ou se o conector precisar ser criado em outro
locatário do Azure. Se estiver utilizando esse modo, siga as instruções de Exportação manual abaixo.
NOTE
O conector personalizado usa uma cópia da definição de API, assim o PowerApps e o Microsoft Flow não saberão
imediatamente se o aplicativo e sua definição de API foram alterados. Se você fizer alterações, repita as etapas de exportação
na nova versão.
Use a exportação de expresso

Para concluir a exportação no modo Expresso, siga estas etapas:
1. Verifique se você está conectado ao locatário do PowerApps ou Microsoft Flow para o qual você deseja
exportar.
2. Use as configurações conforme especificado na tabela.
Ambiente Selecione o ambiente no qual o conector personalizado

deve ser salvo. Para obter mais informações, consulte
Visão geral dos ambientes.
Nome da API personalizada Insira um nome, que será exibido para os construtores do
PowerApps e do Microsoft Flow na lista de conectores.
Preparar a configuração de segurança Se necessário, forneça os detalhes de configuração de

segurança necessários para conceder aos usuários acesso à
sua API. Este exemplo mostra uma chave de API. Para
obter mais informações, consulte Especificar tipo de
autenticação abaixo.
3. Clique em OK. Agora, o conector personalizado é compilado e adicionado ao ambiente especificado.
Usar a exportação manual

Para concluir a exportação no modo Manual, siga estas etapas:
1. Clique em Baixar e salve o arquivo ou clique no botão Copiar e salve a URL. O arquivo baixado ou a URL
serão usados durante a importação.
2. Se a definição de API incluir quaisquer definições de segurança, elas serão chamadas na etapa n° 2. Durante
a importação, o PowerApps e o Microsoft Flow as detectam e solicitam informações de segurança. Reúna as
credenciais relacionadas a cada definição para uso na próxima seção. Para obter mais informações, consulte
Especificar tipo de autenticação abaixo.
Este exemplo mostra a definição de segurança da chave de API incluída na definição de OpenAPI.
Agora que você exportou a definição de API, importe-a para criar um conector personalizado no PowerApps e no
Microsoft Flow. Os conectores personalizados são compartilhados entre os dois serviços, portanto, você só precisa
importar a definição uma vez.
Para importar a definição de API para o PowerApps e o Microsoft Flow, siga estas etapas:
1. Vá para powerapps.com ou flow.microsoft.com.
2. No canto superior direito, clique no ícone de engrenagem e clique em Conectores personalizados.
3. Clique em Criar conector personalizado e clique em Importar uma definição de OpenAPI.
4. Insira um nome para o conector personalizado, navegue para a definição de OpenAPI que você exportou e
clique em Continuar.
5. Na guia Geral, revise as informações provenientes da definição de OpenAPI.
6. Na guia Segurança, se for solicitado que você forneça detalhes de autenticação, insira os valores corretos
para o tipo de autenticação. Clique em Continue.
Este exemplo mostra os campos obrigatórios para a autenticação da chave de API. Os campos são
diferentes dependendo do tipo de autenticação.
7. Na guia Definições, todas as operações definidas no arquivo OpenAPI são populadas automaticamente. Se
todas as suas operações necessárias forem definidas, você poderá ir para a próxima etapa. Caso contrário,
você pode adicionar e modificar as operações aqui.
Este exemplo tem uma operação, denominada CalculateCosts . Os metadados, como Descrição, vêm do
arquivo OpenAPI.
8. Clique em Criar conector na parte superior da página.
Agora, é possível se conectar ao conector personalizado no PowerApps e no Microsoft Flow. Para obter mais
informações sobre a criação de conectores nos portais do PowerApps e do Microsoft Flow, consulte Registrar o
conector personalizado no PowerApps e Registrar o conector personalizado no Microsoft Flow.
Especificar tipo de autenticação

O PowerApps e o Microsoft Flow oferecem suporte a uma coleção de provedores de identidade que fornecem
autenticação para conectores personalizados. Se sua API exige autenticação, certifique-se de que ela seja capturada
como uma definição de segurança no documento OpenAPI, como neste exemplo:
"securityDefinitions": {
"AAD": {
"type": "oauth2",
"flow": "accessCode",
"authorizationUrl": "https://login.windows.net/common/oauth2/authorize",
"scopes": {}
}
}
Durante a exportação, será necessário fornecer valores de configuração que permitem ao PowerApps e ao
Microsoft Flow autenticar usuários.
Esta seção aborda os tipos de autenticação com suporte no modo Expresso: Chave de API, Azure Active Directory
e OAuth 2.0 Genérico. O PowerApps e o Microsoft Flow também oferecem suporte à Autenticação Básica e ao
OAuth 2.0 para serviços específicos, como SalesForce, Facebook e Dropbox.
Chave de API
Ao utilizar uma chave de API, os usuários do conector deverão fornecer a chave ao criar uma conexão. Você
especifica um nome de chave de API para ajudá-los a reconhecer qual chave é necessária. No exemplo anterior,
usamos o nome API Key (contact meganb@contoso.com) para que as pessoas saibam onde obter informações sobre
a chave de API. No Azure Functions, a chave geralmente será uma das chaves de host que abrangem várias
funções dentro do aplicativo de funções.
Active Directory do Azure (Azure AD)
Ao usar o Azure AD, são necessários dois registros de aplicativo do Azure AD: um para a própria API e outro para
o conector personalizado:
Para configurar o registro da API, use o recurso de Autenticação/Autorização do Serviço de Aplicativo.
Para configurar o registro do conector, siga as etapas em Como adicionar um aplicativo do Azure AD. O
registro deve ter acesso delegado à sua API e um URL de resposta de
https://msmanaged-na.consent.azure-apim.net/redirect .
Para obter mais informações, consulte os exemplos de registro do Azure AD para PowerApps e Microsoft Flow.
Esses exemplos usam o Azure Resource Manager como a API. Se você seguir as etapas, substitua sua API.
Os valores de configuração a seguir são necessários:
ID do cliente – a ID do cliente do seu registro do Azure AD do conector
Segredo do cliente – o segredo do cliente do seu registro do Azure AD do conector
URL de logon – URL básica para o Azure AD. No Azure, isso é normalmente https://login.windows.net .
ID do locatário - o ID do locatário a ser usado para o logon. Isso deve ser "comum" ou a ID do locatário em
que o conector é criado.
URL de recurso – URL de recurso do seu registro do Azure AD da sua API
IMPORTANT
Caso outro indivíduo importe a definição de API para o PowerApps e o Microsoft Flow como parte do fluxo manual, será
necessário fornecer a ID do cliente e o segredo do cliente do registro do conector, assim como o URL de recurso da sua API.
Certifique-se de que esses segredos sejam gerenciados com segurança. Não compartilhe as credenciais de segurança da
API, propriamente dita.
OAuth 2.0 genérico

Ao usar o OAuth 2.0 genérico, é possível integrar com qualquer provedor de OAuth 2.0. Isso permite que você
trabalhe com provedores personalizados sem suporte nativo.
Os valores de configuração a seguir são necessários:
ID do Cliente - o ID do cliente do OAuth 2.0
Segredo do Cliente - o segredo do cliente do OAuth 2.0
URL de Autorização - a URL de autorização do OAuth 2.0
URL de Token - a URL de token do OAuth 2.0
URL de Atualização - a URL de atualização do OAuth 2.0
Como usar identidades gerenciadas para o Serviço
de Aplicativo e o Azure Functions
IMPORTANT
Identidades gerenciadas para Serviço de Aplicativo e Azure Functions não se comportarão conforme o esperado se seu
aplicativo for migrado entre assinaturas/locatários. O aplicativo precisará obter uma nova identidade, que pode ser feita ao
desabilitar e reabilitar o recurso. Consulte removendo uma identidade abaixo. Recursos de downstream também precisará
ter políticas de acesso atualizadas para usar a nova identidade.
Este tópico mostra como criar uma identidade gerenciada para aplicativos do Serviço de Aplicativo e do Azure
Functions e como usá-la para acessar outros recursos. Uma identidade gerenciada do Azure Active Directory
permite que seu aplicativo acesse com facilidade outros recursos protegidos pelo AAD, como o Azure Key Vault. A
identidade é gerenciada pela plataforma do Azure e não exige provisionamento ou giro de nenhum segredo. Para
obter mais informações sobre identidades gerenciadas no AAD, veja Identidades gerenciadas para recursos do
Azure.
Seu aplicativo pode receber dois tipos de identidades:
Uma identidade atribuída pelo sistema é vinculada ao seu aplicativo e é excluída se o seu aplicativo for
excluído. Um aplicativo só pode ter uma identidade atribuída pelo sistema.
Uma identidade atribuída pelo usuário é um recurso do Azure independente que pode ser atribuído ao seu
aplicativo. Um aplicativo pode ter várias identidades atribuídas pelo usuário.
Adicionando uma identidade designada pelo sistema

Criar um aplicativo com uma identidade designada pelo sistema requer uma propriedade adicional a ser definida
no aplicativo.
Para configurar uma identidade gerenciada no portal, primeiro, crie um aplicativo como normal e, em seguida,
habilite o recurso.
2. Se você estiver usando um aplicativo de funções, navegue até os recursos da Plataforma. Para outros
tipos de aplicativo, role para baixo até o grupo Configurações no painel de navegação à esquerda.
4. Na guia Sistema atribuído, alterne o Status para Ligado. Clique em Save (Salvar).
Usando a CLI do Azure
Para configurar uma identidade gerenciada usando a CLI do Azure, será preciso usar o comando
az webapp identity assign em um aplicativo existente. Você tem três opções para executar os exemplos nesta
seção:
Usar o Azure Cloud Shell do portal do Azure.
Usar o Azure Cloud Shell inserido por meio do botão "Experimentar", localizado no canto superior direito de
cada bloco de código abaixo.
Instale a versão mais recente da CLI do Azure (2.0.31 ou mais recente) se você preferir usar um console da CLI
local.
As etapas a seguir o guiarão na criação de um aplicativo Web e na atribuição de uma identidade a ele usando a
CLI:
1. Se você estiver usando a CLI do Azure em um console local, primeiro entre no Azure usando o logon az.
Use uma conta que esteja associada à assinatura do Azure sob a qual você deseja implantar o aplicativo:
az login
2. Crie um aplicativo Web usando a CLI. Para ver mais exemplos de como usar a CLI com o Serviço de
Aplicativo, consulte Exemplos de CLI do Serviço de Aplicativo:
az group create --name myResourceGroup --location westus

az appservice plan create --name myPlan --resource-group myResourceGroup --sku S1
az webapp create --name myApp --resource-group myResourceGroup --plan myPlan
3. Execute o comando identity assign para criar a identidade para este aplicativo:
az webapp identity assign --name myApp --resource-group myResourceGroup
Usando o PowerShell do Azure

NOTE
As etapas a seguir guiarão você pela criação de um aplicativo da Web e pela atribuição de uma identidade usando
o Azure PowerShell:
1. Se necessário, instale o Azure PowerShell usando a instrução encontrada no guia do Azure PowerShell e,
em seguida, execute Login-AzAccount para criar uma conexão com o Azure.
2. Crie um aplicativo da Web usando o Azure PowerShell. Para obter mais exemplos de como usar o Azure
PowerShell com o Serviço de Aplicativo, consulte Amostras do PowerShell do Serviço de Aplicativo :

New-AzResourceGroup -Name myResourceGroup -Location $location

New-AzAppServicePlan -Name $webappname -Location $location -ResourceGroupName myResourceGroup -Tier
Free
# Create a web app.

New-AzWebApp -Name $webappname -Location $location -AppServicePlan $webappname -ResourceGroupName
myResourceGroup
3. Execute o comando Set-AzWebApp -AssignIdentity para criar a identidade para este aplicativo:
Set-AzWebApp -AssignIdentity $true -Name $webappname -ResourceGroupName myResourceGroup

Qualquer recurso do tipo Microsoft.Web/sites pode ser criado com uma identidade, incluindo a propriedade a
seguir na definição de recurso:
"identity": {
}
NOTE
Adicionar o tipo atribuído pelo sistema diz ao Azure para criar e gerenciar a identidade do seu aplicativo.
{
"apiVersion": "2016-08-01",
"identity": {
},
"properties": {
"alwaysOn": true
},
"dependsOn": [
"[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]"
]
}
"identity": {
"type": "SystemAssigned",
"tenantId": "<TENANTID>",
"principalId": "<PRINCIPALID>"
}
No qual <TENANTID> e <PRINCIPALID> são substituídos por GUIDs. A propriedade tenantId identifica a qual
locatário do AAD a identidade pertence. O principalId é um identificador exclusivo para a nova identidade do
aplicativo. No AAD, a entidade de serviço tem o mesmo nome que você deu à sua instância do Serviço de
Aplicativo ou das Funções do Azure.
Adicionando uma identidade atribuída pelo usuário

Criar um aplicativo com uma identidade atribuída pelo usuário exige que você crie a identidade e, em seguida,
adicione seu identificador de recursos à configuração do aplicativo.
Primeiro, você precisará criar um recurso de identidade atribuído pelo usuário.
1. Crie um recurso de identidade gerenciado atribuído pelo usuário de acordo com estas instruções.
3. Se você estiver usando um aplicativo de funções, navegue até os recursos da Plataforma. Para outros
tipos de aplicativo, role para baixo até o grupo Configurações no painel de navegação à esquerda.
5. Na guia atribuído pelo usuário , clique em Adicionar.
6. Procure a identidade que você criou anteriormente e selecione-a. Clique em Adicionar.
Qualquer recurso do tipo Microsoft.Web/sites pode ser criado com uma identidade incluindo o seguinte bloco na
definição do recurso, substituindo <RESOURCEID> pelo ID do recurso da identidade desejada:
"identity": {
"<RESOURCEID>": {}
}
}
NOTE
Adicionando o tipo atribuído pelo usuário e um cotells do Azure para criar e gerenciar a identidade do seu
aplicativo.
{
"apiVersion": "2016-08-01",
"identity": {
"[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', variables('identityName'))]": {}
}
},
"properties": {
"alwaysOn": true
},
"dependsOn": [
"[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', variables('identityName'))]"
]
}
"identity": {
"<RESOURCEID>": {
"principalId": "<PRINCIPALID>",
"clientId": "<CLIENTID>"
}
}
}
No qual <PRINCIPALID> e <CLIENTID> são substituídos por GUIDs. O principalId é um identificador exclusivo para
a identidade que é usada para a administração do AAD. O clientId é um identificador exclusivo para a nova
identidade do aplicativo que é usado para especificar qual identidade usar durante as chamadas de runtime.
Obter tokens para recursos do Azure

Um aplicativo pode usar sua identidade para obter tokens para outros recursos protegidos pelo AAD, como o
Azure Key Vault. Esses tokens representam o acesso do aplicativo ao recurso e não um usuário específico do
aplicativo.
IMPORTANT
Talvez seja necessário configurar o recurso de destino para permitir o acesso do aplicativo. Por exemplo, se você solicitar um
token para o Key Vault, será necessário se certificar de que uma política de acesso que inclui a identidade do aplicativo foi
adicionada. Caso contrário, as chamadas para o Key Vault serão rejeitadas, mesmo se elas incluírem o token. Para saber mais
sobre os recursos que oferecem suporte a tokens do Azure Active Directory, veja Serviços do Azure que dão suporte à
autenticação do Azure AD.
Há um protocolo REST simples para obter um token no Serviço de Aplicativo e no Azure Functions. Isso pode ser
usado para todos os aplicativos e linguagens. Para alguns .NET e Java, o SDK do Azure fornece uma abstração
sobre esse protocolo e facilita uma experiência de desenvolvimento local.
Usar o protocolo REST
Um aplicativo com uma identidade gerenciada tem duas variáveis de ambiente definidas:
MSI_ENDPOINT: a URL para o serviço de token local.
MSI_SECRET: um cabeçalho usado para ajudar a reduzir os ataques de falsificação da solicitação do lado do
servidor (SSRF ). O valor é trocado pela plataforma.
A MSI_ENDPOINT é uma URL local da qual o aplicativo pode solicitar tokens. Para obter um token para um
recurso, solicite uma HTTP GET para esse ponto de extremidade, incluindo os seguintes parâmetros:
NOME DO PARÂMETRO NO DESCRIÇÃO
recurso Consulta O URI do recurso do AAD do recurso

para o qual um token deve ser obtido.
Pode ser um dos serviços do Azure
que dão suporte à autenticação do
Azure AD ou a qualquer outro URI de
recurso.
api-version Consulta A versão da API do token a ser usada.

Atualmente, a única versão com
suporte é 2017-09-01.
segredo Cabeçalho O valor da variável de ambiente

MSI_SECRET. Esse cabeçalho é usado
para ajudar a reduzir os ataques de
falsificação da solicitação do lado do
servidor (SSRF).
clientid Consulta (Opcional, a menos que seja atribuído

pelo usuário) A ID da identidade
atribuída pelo usuário a ser usada. Se
omitido, a identidade atribuída pelo
sistema é usada.
IMPORTANT
Se você estiver tentando obter tokens para identidades atribuídas pelo usuário, deverá incluir a propriedade clientid .
Caso contrário, o serviço de token tentará obter um token para uma identidade atribuída pelo sistema, que pode ou não
existir.
Uma resposta bem-sucedida de 200 OK inclui um corpo JSON com as seguintes propriedades:
access_token O token de acesso solicitado. O serviço Web de chamada

pode usar esse token para se autenticar no serviço Web de
recebimento.
expires_on A hora de expiração do token de acesso. A data é

representada como o número de segundos de 1970-01-
01T0:0:0Z UTC até a hora de expiração. Esse valor é usado
para determinar o tempo de vida de tokens em cache.
recurso O URI da ID de aplicativo do serviço Web de recebimento.

token_type Indica o valor do tipo de token. O único tipo com suporte

do Azure AD é Portador Para saber mais sobre os tokens de
portador, consulte Estrutura de Autorização do OAuth 2.0:
Uso do Token de Portador (RFC 6750).
Essa resposta é igual a resposta à solicitação do AAD de token de acesso de serviço para serviço.
NOTE
Variáveis de ambiente são configuradas quando o processo é iniciado pela primeira vez, então após habilitar a identidade
gerenciada para o seu aplicativo, você pode precisar reiniciar o aplicativo ou reimplantar o código dele antes que
MSI_ENDPOINT e MSI_SECRET estejam disponíveis para seu código.
Exemplos de protocolo REST

Uma solicitação de exemplo pode ser semelhante ao seguinte:
GET /MSI/token?resource=https://vault.azure.net&api-version=2017-09-01 HTTP/1.1

Host: localhost:4141
Secret: 853b9a84-5bfa-4b22-a3f3-0b9a43d9ad8a
Uma resposta de exemplo pode ser semelhante ao seguinte:
HTTP/1.1 200 OK
{
"access_token": "eyJ0eXAi…",
"expires_on": "09/14/2017 00:00:00 PM +00:00",
"resource": "https://vault.azure.net",
"token_type": "Bearer"
}
Exemplos de código
.NET
JavaScript
Python
PowerShell
TIP
Para as linguagens .NET, também é possível usar Microsoft.Azure.Services.AppAuthentication em vez de criar essa solicitação
por conta própria.
// ...
public async Task<HttpResponseMessage> GetToken(string resource) {
var request = new HttpRequestMessage(HttpMethod.Get,
String.Format("{0}/?resource={1}&api-version=2017-09-01",
Environment.GetEnvironmentVariable("MSI_ENDPOINT"), resource));
request.Headers.Add("Secret", Environment.GetEnvironmentVariable("MSI_SECRET"));
return await _client.SendAsync(request);
}
Usar a biblioteca de Microsoft.Azure.Services.AppAuthentication do .NET

Para aplicativos e funções .NET, a maneira mais simples de trabalhar com uma identidade gerenciada é por meio
do pacote Microsoft.Azure.Services.AppAuthentication. Essa biblioteca também permitirá que você teste seu
código localmente em sua máquina de desenvolvimento, usando sua conta de usuário do Visual Studio, a Azure
CLI ou a Autenticação Integrada do Active Directory. Para obter mais informações sobre as opções de
desenvolvimento local com essa biblioteca, consulte a Referência Microsoft.Azure.Services.AppAuthentication.
Esta seção mostra a você como começar a usar a biblioteca no seu código.
1. Adicione referências a Microsoft.Azure.Services.AppAuthentication e a qualquer outro pacote NuGet
necessário para seu aplicativo. O exemplo abaixo também usa Microsoft.Azure.KeyVault.
2. Adicione o seguinte código ao seu aplicativo, modificando-o para ter como destino o recurso correto. Este
exemplo mostra duas maneiras de trabalhar com o Azure Key Vault:
using Microsoft.Azure.Services.AppAuthentication;
using Microsoft.Azure.KeyVault;
// ...
var azureServiceTokenProvider = new AzureServiceTokenProvider();
string accessToken = await azureServiceTokenProvider.GetAccessTokenAsync("https://vault.azure.net");
// OR
var kv = new KeyVaultClient(new
KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
Para saber mais sobre o Microsoft.Azure.Services.AppAuthentication e as operações que ele expõe, consulte a
Referência Microsoft.Azure.Services.AppAuthentication e Serviço de Aplicativo e KeyVault com a amostra MSI
.NET.
Usando o SDK do Azure para Java
Para aplicativos e funções Java, a maneira mais simples de trabalhar com uma identidade gerenciada é por meio
do SDK do Azure para Java. Esta seção mostra a você como começar a usar a biblioteca no seu código.
1. Adicione uma referência à biblioteca do SDK do Azure. Para projetos Maven, você pode adicionar esse
trecho à seção dependencies do arquivo POM do projeto:
<dependency>
<groupId>com.microsoft.azure</groupId>
<artifactId>azure</artifactId>
</dependency>
2. Use o objeto AppServiceMSICredentials para autenticação. Este exemplo mostra como esse mecanismo
pode ser usado para trabalhar com Azure Key Vault:
import com.microsoft.azure.AzureEnvironment;
import com.microsoft.azure.management.Azure;
import com.microsoft.azure.management.keyvault.Vault
//...
Azure azure = Azure.authenticate(new AppServiceMSICredentials(AzureEnvironment.AZURE))
.withSubscription(subscriptionId);
Vault myKeyVault = azure.vaults().getByResourceGroup(resourceGroup, keyvaultName);
Removendo uma identidade

Uma identidade atribuída pelo sistema pode ser removida desabilitando o recurso usando o portal, PowerShell ou
CLI da mesma forma que foi criado. As identidades atribuídas pelo usuário podem ser removidas
individualmente. Para remover todas as identidades, no protocolo de modelo REST / ARM, isso é feito definindo o
tipo como "Nenhum":
"identity": {
"type": "None"
}
Remover uma identidade atribuída pelo sistema dessa maneira também a excluirá do AAD. As identidades
atribuídas pelo sistema também são automaticamente removidas do AAD quando o recurso do aplicativo é
excluído.
NOTE
Há também uma configuração de aplicativo que pode ser definida, WEBSITE_DISABLE_MSI, que apenas desativa o serviço de
token local. No entanto, ele deixa a identidade no local e ferramentas ainda mostrará a identidade gerenciada como "ligada"
ou "habilitada". Como resultado, o uso dessa configuração não é recomendado.
Próximos passos
Acesse o Banco de Dados SQL com segurança usando uma identidade gerenciada
Personalizar um ponto de extremidade HTTP no
Azure Functions
Neste artigo, você aprende como Azure Functions permite que você crie APIs altamente escalonáveis. O Azure
Functions vem com uma coleção interna de gatilhos e associações HTTP que facilitam a criação de um ponto de
extremidade em várias linguagens, incluindo Node.JS, C# e muito mais. Neste artigo, você personalizará um
gatilho HTTP para manipular ações específicas em seu design de API. Você também preparará a expansão de sua
API integrando-a aos Proxies do Azure Functions e configurando APIs de simulação. Tudo isso é realizado no
ambiente de computação sem servidor do Functions, portanto você não precisa se preocupar com o
dimensionamento de recursos, você pode se concentrar apenas na lógica de sua API.
Pré-requisitos
A função resultante será usada para o restante deste artigo.
Entrar no Azure
Abra o portal do Azure. Para fazer isso, entre no https://portal.azure.com com sua conta do Azure.
Personalizar sua função HTTP

Por padrão, sua função disparada por HTTP é configurada para aceitar qualquer método HTTP. Também há uma
URL padrão no formato http://<yourapp>.azurewebsites.net/api/<funcname>?code=<functionkey> . Se você seguiu o
guia de início rápido, <funcname> provavelmente se parece com algo como "HttpTriggerJS1". Nesta seção, você
modificará a função para responder apenas a solicitações GET na rota /api/hello .
1. Navegue até sua função no Portal do Azure. Selecione Integrar no painel de navegação esquerdo.
2. Use as configurações do gatilho HTTP conforme especificado na tabela.

CAMPO VALOR DE EXEMPLO DESCRIÇÃO
Métodos HTTP selecionados Métodos selecionados Determina quais métodos HTTP

podem ser usados para chamar essa
função
Métodos HTTP selecionados OBTER Permite que apenas os métodos

HTTP selecionados possam ser
usados para chamar essa função
Modelo de rota /hello Determina qual rota pode ser usada

para chamar essa função
Nível de autorização Anônimo Opcional: Torna sua função acessível

sem uma chave de API
NOTE
Observe que você não incluiu o prefixo de caminho base /api no modelo de rota, pois isso é tratado por uma
configuração global.
Você pode aprender mais sobre a personalização de funções HTTP em Associações de HTTP do Azure Functions.
Testar sua API
Em seguida, teste sua função para vê-la funcionando com a nova superfície de API.
1. Navegue de volta para a página de desenvolvimento clicando no nome da função no painel de navegação
esquerdo.
2. Clique em Obter URL de função e copie a URL. Você verá que agora ela usa a rota /api/hello .
3. Copie a URL em uma nova guia do navegador ou o cliente REST preferencial. Navegadores usarão GET por
padrão.
4. Adicione parâmetros à cadeia de consulta na URL, por exemplo, /api/hello/?name=John
5. Pressione “Enter” para confirmar se ela está funcionando. Você deverá ver a resposta “Hello John”
6. Você também pode tentar chamar o ponto de extremidade com outro método HTTP para confirmar a não
execução da função. Para isso, será necessário usar um cliente REST, como cURL, Postman ou Fiddler.
Visão geral dos proxies

Na próxima seção, você mostrará sua API através de um proxy. Os Proxies do Azure Functions permitem o
encaminhamento de solicitações para outros recursos. Defina um ponto de extremidade HTTP, como com o
gatilho HTTP, mas em vez de escrever um código para executar durante a chamada para o ponto de extremidade,
forneça uma URL para uma implementação remota. Isso permite a composição de várias fontes de API em uma
única superfície de API, o que é fácil para os clientes usarem. Isso é particularmente útil se você quiser criar sua
API como microsserviços.
Um proxy pode apontar para qualquer recurso HTTP, como:
Verificação de
Aplicativos de API no Serviço de Aplicativo do Azure
Contêineres de docker no Serviço de Aplicativo no Linux
Qualquer outra API hospedada
Para saber mais sobre proxies, confira Trabalhar com Proxies do Azure Functions.
Criar seu primeiro proxy

Nesta seção, você criará um novo proxy que servirá como um front-end para sua API geral.
Configurar o ambiente front-end
Repita as etapas para Criar um aplicativo de função a fim de criar um novo aplicativo de função no qual você criará
o proxy. A URL desse novo aplicativo funcionará como o front-end de nossa API e o aplicativo de função que você
estava editando anteriormente funcionará como um back-end.
1. Navegue até seu novo aplicativo de função front-end no portal.
2. Selecione Recursos de Plataforma e escolha Configurações de Aplicativo.
3. Role para baixo até Configurações de aplicativo, em que os pares chave/valor são armazenados e crie
uma nova configuração com a chave “HELLO_HOST”. Defina o valor dela como o host de seu aplicativo de
função de back-end, como <YourBackendApp>.azurewebsites.net . Isso faz parte da URL que você copiou
anteriormente ao testar sua função HTTP. Você fará referência a essa configuração mais adiante na
configuração.
NOTE
As configurações do aplicativo são recomendadas para a configuração do host a fim de evitar uma dependência do
ambiente embutida no código para o proxy. Usar configurações do aplicativo significa que você pode mover a
configuração do proxy entre ambientes, e as configurações de aplicativo específicas ao ambiente serão aplicadas.
Criar um proxy no front-end
1. Navegue novamente até seu aplicativo de função front-end no portal.
2. No painel de navegação esquerdo, clique no sinal '+' ao lado de "Proxies".
3. Use as configurações de proxy conforme especificado na tabela.

CAMPO VALOR DE EXEMPLO DESCRIÇÃO
Nome HelloProxy Um nome amigável usado apenas

para gerenciamento
Modelo de rota /api/remotehello Determina qual rota pode ser usada

para chamar esse proxy
URL de Back-end https://%HELLO_HOST%/api/hello Especifica o ponto de extremidade ao

qual a solicitação deve ser
transmitida por proxy
4. Observe que os Proxies não fornecem o prefixo de caminho base /api , e ele deve ser incluído no modelo
de rota.
5. A sintaxe %HELLO_HOST% fará referência a configuração do aplicativo que você criou anteriormente. A URL
resolvida apontará para sua função original.
6. Clique em Criar.
7. Você pode testar seu novo proxy copiando a URL do Proxy e o testando no navegador ou com seu cliente
HTTP favorito.
a. Para uma função anônima, use:
a. https://YOURPROXYAPP.azurewebsites.net/api/remotehello?name="Proxies"
b. Para uma função com autorização, use:
a. https://YOURPROXYAPP.azurewebsites.net/api/remotehello?code=YOURCODE&name="Proxies"
Criar uma API de simulação

Em seguida, você usará um proxy para criar uma API de simulação para sua solução. Isso permite o progresso do
desenvolvimento do cliente, sem a necessidade de implementar totalmente o back-end. Posteriormente no
desenvolvimento, você poderá criar um novo aplicativo de função que oferece suporte a essa lógica e redirecionar
seu proxy até ele.
Para criar essa API de simulação, criaremos um novo proxy, dessa vez usando o Editor do Serviço de Aplicativo.
Para começar, navegue até seu aplicativo de função no portal. Selecione Recursos de plataforma e, em
Ferramentas de Desenvolvimento, encontre Editor do Serviço de Aplicativo. Clique nele para abrir o Editor
de Serviço de Aplicativo em uma nova guia.
Selecione proxies.json no painel de navegação esquerdo. Este é o arquivo que armazena a configuração de todos
os seus proxies. Se você usar um dos métodos de implantação do Functions, esse será o arquivo mantido no
controle de origem. Para saber mais sobre esse arquivo, confira Configuração avançada de proxies.
Se você acompanhou até agora, o proxies.json deve ser semelhante ao seguinte:
{
"proxies": {
"HelloProxy": {
"matchCondition": {
"route": "/api/remotehello"
},
"backendUri": "https://%HELLO_HOST%/api/hello"
}
}
}
Em seguida, você adicionará sua API de simulação. Substitua o arquivo proxies.json pelo seguinte:
{
"proxies": {
"HelloProxy": {
"matchCondition": {
"route": "/api/remotehello"
},
"backendUri": "https://%HELLO_HOST%/api/hello"
},
"GetUserByName" : {
"matchCondition": {
"route": "/api/users/{username}"
},
"responseOverrides": {
"response.statusCode": "200",
"response.headers.Content-Type" : "application/json",
"response.body": {
"name": "{username}",
"description": "Awesome developer and master of serverless APIs",
"skills": [
"Serverless",
"APIs",
"Azure",
"Cloud"
]
}
}
}
}
}
Isso adiciona um novo proxy "GetUserByName", sem a propriedade backendUri. Em vez de chamar outro recurso,
ele modifica a resposta padrão dos Proxies usando uma substituição de resposta. Substituições de solicitação e
resposta também podem ser usadas em conjunto com uma URL de back-end. Isso é particularmente útil ao
transmitir por proxy para um sistema herdado, quando talvez você precise modificar cabeçalhos, consultar
parâmetros etc. Para saber mais sobre as substituições de solicitação e resposta, Confira Modificar solicitações e
respostas em Proxies.
Teste sua API de simulação chamando o ponto de extremidade
<YourProxyApp>.azurewebsites.net/api/users/{username} usando um navegador ou seu cliente REST favorito. Não
deixe de substituir {username} por um valor de cadeia de caracteres que represente um nome de usuário.
Próximas etapas
Neste artigo, você aprendeu como criar e personalizar uma API no Azure Functions. Você também aprendeu a
unir várias APIs, incluindo objetos fictícios, como uma superfície de API unificada. Use essas técnicas para
compilar APIs de qualquer complexidade durante a execução no modelo de computação sem servidor fornecido
pelo Azure Functions.
As referências a seguir podem ser úteis durante o desenvolvimento de sua API:
Associações de HTTP do Azure Functions
Trabalhar com Proxies do Azure Functions
Documentar uma API do Azure Functions (visualização)
Gerenciando ambientes híbridos com o PowerShell
no Azure Functions e no serviço de aplicativo
Conexões Híbridas
O recurso Conexões Híbridas do serviço de Azure App permite o acesso a recursos em outras redes. Você pode
saber mais sobre esse recurso na documentação do conexões híbridas . Este artigo descreve como usar essa
funcionalidade para executar funções do PowerShell direcionadas a um servidor local. Esse servidor pode então
ser usado para gerenciar todos os recursos no ambiente local por meio de uma função Azure PowerShell.
Configurar um servidor local para comunicação remota do PowerShell

O script a seguir habilita a comunicação remota do PowerShell e cria uma nova regra de firewall e um ouvinte
HTTPS do WinRM. Para fins de teste, é usado um certificado autoassinado. Em um ambiente de produção,
recomendamos que você use um certificado assinado.
# For configuration of WinRM, see

# https://docs.microsoft.com/windows/win32/winrm/installation-and-configuration-for-windows-remote-management.
# Enable PowerShell remoting.

Enable-PSRemoting -Force
# Create firewall rule for WinRM. The default HTTPS port is 5986.
New-NetFirewallRule -Name "WinRM HTTPS" `
-DisplayName "WinRM HTTPS" `
-Enabled True `
-Profile "Any" `
-Action "Allow" `
-Direction "Inbound" `
-LocalPort 5986 `
-Protocol "TCP"
# Create new self-signed-certificate to be used by WinRM.

$Thumbprint = (New-SelfSignedCertificate -DnsName $env:COMPUTERNAME -CertStoreLocation
Cert:\LocalMachine\My).Thumbprint
# Create WinRM HTTPS listener.

$Cmd = "winrm create winrm/config/Listener?Address=*+Transport=HTTPS @{Hostname=""$env:COMPUTERNAME "";
CertificateThumbprint=""$Thumbprint""}"
cmd.exe /C $Cmd
Criar um aplicativo de funções do PowerShell no portal

O recurso de Conexões Híbridas do serviço de aplicativo está disponível apenas nos planos de preços básico,
padrão e isolado. Ao criar o aplicativo de funções com o PowerShell, crie ou selecione um desses planos.
1. Na portal do Azure, selecione + criar um recurso no menu à esquerda e, em seguida, selecione aplicativo
de funções.
2. Para o plano de hospedagem, selecione plano do serviço de aplicativoe, em seguida, selecione
plano/local do serviço de aplicativo.
3. Selecione criar novo, digite um nome de plano do serviço de aplicativo , escolha um local em uma
região perto de você ou perto de outros serviços que suas funções acessam e selecione tipo de preço.
4. Escolha o plano padrão S1 e, em seguida, selecione aplicar.
5. Selecione OK para criar o plano e, em seguida, defina as configurações de aplicativo de funções restantes
conforme especificado na tabela imediatamente após a captura de tela a seguir:

Grupo de recursos myResourceGroup Nome do novo grupo de recursos no

Você também pode usar o valor
sugerido.
OS Sistema operacional preferencial Selecione Windows.
Pilha de tempo de execução Linguagem preferencial Escolha PowerShell Core.
Armazenamento Nome globalmente exclusivo Crie uma conta de armazenamento

Os nomes de conta de
armazenamento devem ter de 3 a 24
caracteres de comprimento e podem
conter apenas números e letras
minúsculas. Você também pode usar
uma conta existente.

nome do novo recurso ou escolher
um local diferente em uma região de
Geografia do Azure onde você deseja
6. Depois que as configurações forem validadas, selecione criar.

7. Selecione o ícone de notificação no canto superior direito do portal e aguarde a mensagem "implantação
bem-sucedida".
Criar uma conexão híbrida para o aplicativo de funções

As conexões híbridas são configuradas na seção rede do aplicativo de funções:
1. Selecione a guia recursos da plataforma no aplicativo de funções e, em seguida, selecione rede.
2. Selecione configurar seus pontos de extremidade de conexões híbridas.

3. Selecione Adicionar conexão híbrida.
4. Insira informações sobre a conexão híbrida conforme mostrado logo após a captura de tela a seguir. Você
tem a opção de fazer com que a configuração de host do ponto de extremidade corresponda ao nome do
host do servidor local para facilitar a memorização do servidor mais tarde, quando você estiver executando
comandos remotos. A porta corresponde à porta padrão do serviço de gerenciamento remoto do Windows
que foi definida no servidor anteriormente.
Nome da conexão híbrida: ContosoHybridOnPremisesServer

Host do ponto de extremidade: finance1
Porta do ponto de extremidade: 5986
Namespace de Servicebus: Criar Novo
Localização: Escolha um local disponível
Nome: contosopowershellhybrid
5. Selecione OK para criar a conexão híbrida.
Baixar e instalar a conexão híbrida

1. Selecione baixar Gerenciador de conexões para salvar o arquivo. msi localmente no seu computador.
2. Copie o arquivo. msi do seu computador local para o servidor no local.

3. Execute o instalador do Gerenciador de Conexões Híbridas para instalar o serviço no servidor local.
4. No portal, abra a conexão híbrida e copie a cadeia de conexão do gateway para a área de transferência.
5. Abra a interface do usuário do Gerenciador de Conexões Híbridas no servidor local.
6. Selecione o botão inserir manualmente e cole a cadeia de conexão da área de transferência.

7. Reinicie o Gerenciador de Conexões Híbridas do PowerShell se ele não for exibido como conectado.
Restart-Service HybridConnectionManager
Criar uma configuração de aplicativo para a senha de uma conta de

administrador
1. Selecione a guia recursos da plataforma no aplicativo de funções.
2. Em configurações gerais, selecione configuração.
3. Expanda nova configuração de aplicativo para criar uma nova configuração para a senha.
4. Nomeie a configuração _ContosoUserPassword_e insira a senha.
5. Selecione OK e, em seguida, salvar para armazenar a senha no aplicativo de funções.
Criar um gatilho http de função para teste
1. Crie uma nova função de gatilho HTTP do aplicativo de funções.
2. Substitua o código do PowerShell do modelo pelo código a seguir:

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)
# Write to the Azure Functions log stream.

Write-Output "PowerShell HTTP trigger function processed a request."
# Note that ContosoUserPassword is a function app setting, so I can access it as

$env:ContosoUserPassword.
$UserName = "ContosoUser"
$securedPassword = ConvertTo-SecureString $Env:ContosoUserPassword -AsPlainText -Force
$Credential = [System.management.automation.pscredential]::new($UserName, $SecuredPassword)
# This is the name of the hybrid connection Endpoint.

$HybridEndpoint = "finance1"
$Script = {
Param(
[Parameter(Mandatory=$True)]
[String] $Service
)
Get-Service $Service
}
Write-Output "Scenario 1: Running command via Invoke-Command"

Invoke-Command -ComputerName $HybridEndpoint `
-Credential $Credential `
-Port 5986 `
-UseSSL `
-ScriptBlock $Script `
-ArgumentList "*" `
-SessionOption (New-PSSessionOption -SkipCACheck)
3. Selecione salvar e executar para testar a função.

Gerenciando outros sistemas locais
Você pode usar o servidor local conectado para se conectar a outros servidores e sistemas de gerenciamento no
ambiente local. Isso permite que você gerencie suas operações de datacenter do Azure usando suas funções do
PowerShell. O script a seguir registra uma sessão de configuração do PowerShell que é executada sob as
credenciais fornecidas. Essas credenciais devem ser para um administrador nos servidores remotos. Você pode
usar essa configuração para acessar outros pontos de extremidade no servidor local ou Datacenter.
# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)
# Write to the Azure Functions log stream.

Write-Host "PowerShell HTTP trigger function processed a request."
# Note that ContosoUserPassword is a function app setting, so I can access it as $env:ContosoUserPassword.

$UserName = "ContosoUser"
$SecuredPassword = ConvertTo-SecureString $Env:ContosoUserPassword -AsPlainText -Force
$Credential = [System.management.automation.pscredential]::new($UserName, $SecuredPassword)
# This is the name of the hybrid connection Endpoint.

$HybridEndpoint = "finance1"
# The remote server that will be connected to run remote PowerShell commands on
$RemoteServer = "finance2".
Write-Output "Use hybrid connection server as a jump box to connect to a remote machine"
# We are registering an endpoint that runs under credentials ($Credential) that has access to the remote
server.
$SessionName = "HybridSession"
$ScriptCommand = {
param (
$SessionName)
if (-not (Get-PSSessionConfiguration -Name $SessionName -ErrorAction SilentlyContinue))

{
Register-PSSessionConfiguration -Name $SessionName -RunAsCredential $Using:Credential
}
}
Write-Output "Registering session on hybrid connection jumpbox"

-Port 5986 `
-UseSSL `
-ScriptBlock $ScriptCommand `
-ArgumentList $SessionName `
-SessionOption (New-PSSessionOption -SkipCACheck)
# Script to run on the jump box to run against the second machine.
$RemoteScriptCommand = {
param (
$ComputerName)
# Write out the hostname of the hybrid connection server.
hostname
# Write out the hostname of the remote server.
Invoke-Command -ComputerName $ComputerName -Credential $Using:Credential -ScriptBlock {hostname} `
-UseSSL -Port 5986 -SessionOption (New-PSSessionOption -SkipCACheck)
}
Write-Output "Running command against remote machine via jumpbox by connecting to the PowerShell configuration
session"
-Port 5986 `
-UseSSL `
-ScriptBlock $RemoteScriptCommand `
-ArgumentList $RemoteServer `
-SessionOption (New-PSSessionOption -SkipCACheck) `
-ConfigurationName $SessionName
Substitua as seguintes variáveis neste script pelos valores aplicáveis do seu ambiente:
$HybridEndpoint
$RemoteServer
Nos dois cenários anteriores, você pode conectar e gerenciar seus ambientes locais usando o PowerShell em Azure
Functions e Conexões Híbridas. Incentivamos você a aprender mais sobre o conexões híbridas e o PowerShell no
functions.
Você também pode usar redes virtuais do Azure para se conectar ao seu ambiente local por meio de Azure
functions.
Próximas etapas
Saiba mais sobre como trabalhar com funções do PowerShell
Como solucionar o problema "Functions Runtime
inacessível"
Texto do erro
Este documento é indicado para solucionar o erro a seguir quando exibido no portal do Functions.
Error: Azure Functions Runtime is unreachable. Click here for details on storage configuration
Resumo
Esse problema ocorre quando o Azure Functions Runtime não pode ser iniciado. O motivo mais comum para que
esse erro ocorra é quando o aplicativo de funções perde o acesso à sua conta de armazenamento. Leia mais sobre
os requisitos da conta de armazenamento aqui
Solução de problemas
Vamos percorrer os quatro casos de erro mais comuns e aprender como identificar e resolver cada caso.
1. Conta de armazenamento excluída
2. Configurações de aplicativo da conta de armazenamento excluídas
3. Credenciais da conta de armazenamento inválidas
4. Conta de armazenamento inacessível
5. Cota de execução diária total
Conta de armazenamento excluída

Cada aplicativo de funções exige uma conta de armazenamento para ser operado. Se essa conta for excluída, a
função não funcionará.
Como localizar sua conta de armazenamento
Comece procurando o nome da conta de armazenamento nas configurações de aplicativo. Tanto
AzureWebJobsStorage quanto WEBSITE_CONTENTAZUREFILECONNECTIONSTRING conterão o nome da conta de
armazenamento inserida dentro de uma cadeia de conexão. Leia informações mais específicas na referência de
configuração de aplicativo aqui
Pesquise sua conta de armazenamento no portal do Azure para ver se ela ainda existe. Se ela tiver sido excluída,
você precisará recriar a conta de armazenamento e substituir suas cadeias de conexão de armazenamento. O
código de função é perdido e será necessário reimplantá-lo novamente.
Configurações de aplicativo da conta de armazenamento excluídas

Na etapa anterior, se não havia uma cadeia de conexão da conta de armazenamento, provavelmente ela foi excluída
ou substituída. A exclusão das configurações de aplicativo geralmente ocorre quando slots de implantação ou
scripts do Azure Resource Manager são usados para definir as configurações de aplicativo.
Configurações de aplicativo obrigatórias
Necessário
AzureWebJobsStorage
Obrigatório para funções de plano de consumo
WEBSITE_CONTENTAZUREFILECONNECTIONSTRING
WEBSITE_CONTENTSHARE
Leia sobre essas configurações de aplicativo aqui

Diretrizes
Não marque "configuração de slot" para nenhuma dessas configurações. Quando você trocar os slots de
implantação, a função será interrompida.
Não modifique essas configurações como parte das implantações automatizadas.
Essas configurações precisam ser fornecidas e estarem válidas no momento da criação. Uma implantação
automatizada que não contenha essas configurações resultará em um aplicativo não funcional, mesmo se as
configurações forem adicionadas após o fato.
Credenciais da conta de armazenamento inválidas

As cadeias de conexão da conta de armazenamento acima precisarão ser atualizadas se você regenerar as chaves
de armazenamento. Leia mais sobre o gerenciamento de chaves de armazenamento aqui
Conta de armazenamento inacessível

Seu aplicativo de funções precisa ser capaz de acessar a conta de armazenamento. Os problemas comuns que
bloqueiam o acesso do Functions a uma conta de armazenamento são:
Aplicativos de funções implantados em Ambientes do Serviço de Aplicativo sem as regras de rede corretas para
permitir o tráfego de e para a conta de armazenamento
O firewall da conta de armazenamento está habilitado e não está configurado para permitir o tráfego de e para
as funções. Leia mais sobre a configuração de firewall da conta de armazenamento aqui
Cota de execução diária total

Se uma cota de execução diária estiver configurada, seu Aplicativo de funções será temporariamente desabilitado e
muitos dos controles de portal ficarão indisponíveis.
Para verificar, veja Recursos de Plataforma abertos > Configurações do Aplicativo de funções no portal. Nesse
caso, aparecerá a seguinte mensagem de erro se estiver em uma cota
The Function App has reached daily usage quota and has been stopped until the next 24 hours time
frame.
Remova a cota e reinicie o aplicativo para resolver o problema.
Próximas etapas
Agora que seu aplicativo de funções retornou e está operacional, confira nossos guias de início rápido e nossas
referências para o desenvolvedor para colocá-lo em funcionamento novamente!
Criar sua primeira Função do Azure
Crie diretamente sua primeira função usando o início rápido do Azure Functions.
Fornece informações mais técnicas sobre o tempo de execução do Azure Functions e uma referência para
funções de codificação e definição de associações e gatilhos.
Como escalar o Azure Functions
Discute os planos de serviço disponíveis com o Azure Functions, incluindo o plano de hospedagem de consumo
e como escolher o plano certo.
Saiba mais sobre o Serviço de Aplicativo do Azure
O Azure Functions aproveita o Serviço de Aplicativo do Azure para a funcionalidade básica como implantações,
variáveis de ambiente e diagnóstico.
Referência de configurações de aplicativo para
Azure Functions
As configurações de aplicativo em um aplicativo de funções contém opções de configuração global que afetam
todas as funções desse aplicativo de funções. Quando você executa localmente, essas configurações são
acessadas como variáveis de ambiente. Este artigo lista as configurações de aplicativo disponíveis nos
aplicativos de funções.
No portal do Azure.
Há outras opções de configuração global no arquivo host.json e no arquivo local.settings.json.
APPINSIGHTS_INSTRUMENTATIONKEY
Chave de instrumentação do Application Insights se você estiver usando o Application Insights. Consulte
Monitorar Azure Functions.
CHAVE VALOR DE EXEMPLO
APPINSIGHTS_INSTRUMENTATIONKEY 5dbdd5e9-af77-484b-9032-64f83bb83bb
AZURE_FUNCTIONS_ENVIRONMENT
Na versão 2. x do tempo de execução do functions, o configura o comportamento do aplicativo com base no
ambiente de tempo de execução. Esse valor é lido durante a inicialização. Você pode definir
AZURE_FUNCTIONS_ENVIRONMENT para qualquer valor, mas há suporte para três valores : desenvolvimento,
preparoe produção. Quando AZURE_FUNCTIONS_ENVIRONMENT não é definido, o padrão é Development em um
ambiente local e Production no Azure. Essa configuração deve ser usada em vez de ASPNETCORE_ENVIRONMENT
para definir o ambiente de tempo de execução.
AzureWebJobsDashboard
Cadeia de conexão da conta de armazenamento opcional para armazenar logs e exibi-los na guia Monitor do
portal. A conta de armazenamento deve ser de uso geral, com suporte para blobs, filas e tabelas. Consulte
Conta de armazenamento e Requisitos da conta de armazenamento.
AzureWebJobsDashboard DefaultEndpointsProtocol=https;AccountName=
[name];AccountKey=[key]
TIP
Para desempenho e experiência, é recomendável usar APPINSIGHTS_INSTRUMENTATIONKEY e App Insights para
monitoramento, em vez de AzureWebJobsDashboard
AzureWebJobsDisableHomepage
true significa desabilitar a página de aterrissagem padrão mostrada para a URL raiz de um aplicativo de
funções. O padrão é false .
AzureWebJobsDisableHomepage true
Quando essa configuração de aplicativo é omitida ou definida como false , uma página semelhante ao
exemplo a seguir é exibida na resposta à URL <functionappname>.azurewebsites.net .
AzureWebJobsDotNetReleaseCompilation
true significa usar o modo de versão durante a compilação do código .NET; false significa usar o modo de
depuração. O padrão é true .
AzureWebJobsDotNetReleaseCompilation true
AzureWebJobsFeatureFlags
Uma lista delimitada por vírgulas de recursos beta a habilitar. Os recursos beta habilitados por esses
sinalizadores não estão prontos para produção, mas podem ser habilitados para uso experimental antes de
serem lançados.
AzureWebJobsFeatureFlags feature1,feature2
AzureWebJobsSecretStorageType
Especifica o repositório ou o provedor a ser usado para armazenar chaves. Atualmente, os repositórios com
suporte são o armazenamento de blobs ("Blob") e o sistema de arquivos local ("Arquivos"). O padrão é blob na
versão 2 e sistema de arquivos na versão 1.
AzureWebJobsSecretStorageType Arquivos
AzureWebJobsStorage
O Azure Functions runtime usa essa cadeia de conexão da conta armazenamento para todas as funções, exceto
para as funções disparadas por HTTP. A conta de armazenamento deve ser de uso geral, com suporte para
blobs, filas e tabelas. Consulte Conta de armazenamento e Requisitos da conta de armazenamento.
AzureWebJobsStorage DefaultEndpointsProtocol=https;AccountName=
AzureWebJobs_TypeScriptPath
Caminho para o compilador usado para TypeScript. Permite substituir o padrão se necessário.
AzureWebJobs_TypeScriptPath %HOME%\typescript
FUNCTION_APP_EDIT_MODE
Determina se a edição no portal do Azure está habilitada. Os valores válidos são "readwrite" e "readonly".
FUNCTION_APP_EDIT_MODE readonly
FUNCTIONS_EXTENSION_VERSION
A versão do runtime do Functions para usar nesse aplicativo de funções. Um til com a versão principal
significa usar a versão mais recente da versão principal (por exemplo, "~2"). Quando novas versões da mesma
versão principal estão disponíveis, elas são instaladas automaticamente no aplicativo de funções. Para fixar o
aplicativo a uma versão específica, use o número de versão completo (por exemplo, "2.0.12345"). O padrão é
"~ 2". Um valor de pinos ~1 seu aplicativo para a versão 1.x do tempo de execução.
FUNCTIONS_EXTENSION_VERSION ~2
O Functions_o processo de_do trabalhador_contagem

Especifica o número máximo de processos de trabalho de idioma, com um valor padrão de 1 . O valor
máximo permitido é 10 . As invocações de função são distribuídas uniformemente entre os processos de
trabalho de linguagem. Os processos de trabalho de idioma são gerados a cada 10 segundos até que a
contagem definida por funções_o processo de_de trabalho_contagem seja atingida. O uso de vários processos
de trabalho de idioma não é o mesmo que o dimensionamento. Considere usar essa configuração quando sua
carga de trabalho tiver uma combinação de invocações associadas à CPU e de e/s. Essa configuração se aplica
a todos os idiomas do non-.NET.
O Functions_o processo de_do trabalhador_contagem 2
FUNÇÕES_TRABALHADOR_TEMPO DE EXECUÇÃO
O runtime do trabalho de linguagem deve ser carregado no aplicativo de funções. Isso irá corresponder ao
idioma que está sendo usado em seu aplicativo (por exemplo, "dotnet"). Para funções em vários idiomas, você
precisará publicá-las em vários aplicativos, cada um com um valor de runtime de trabalho correspondente. Os
valores válidos são dotnet C#(F#/), node (JavaScript/TypeScript), java (Java), powershell (PowerShell) e
python ( Python).
FUNÇÕES_TRABALHADOR_TEMPO DE EXECUÇÃO dotnet
WEBSITE_CONTENTAZUREFILECONNECTIONSTRING
Para consumo & apenas planos Premium. Cadeia de conexão para a conta de armazenamento na qual o
código do aplicativo de funções e a configuração são armazenados. Consulte Criar um aplicativo de funções.
WEBSITE_CONTENTAZUREFILECONNECTIONSTRING DefaultEndpointsProtocol=https;AccountName=
WEBSITE_CONTENTSHARE
Para consumo & apenas planos Premium. O caminho do arquivo para o código do aplicativo de funções e a
configuração. Usado com WEBSITE_CONTENTAZUREFILECONNECTIONSTRING. O padrão é uma cadeia
única que começa com o nome do aplicativo de funções. Consulte Criar um aplicativo de funções.
WEBSITE_CONTENTSHARE functionapp091999e2
WEBSITE_MAX_DYNAMIC_APPLICATION_SCALE_OUT
O número máximo de instâncias que o aplicativo de funções pode alcançar. O padrão é sem limites.
NOTE
Essa configuração é uma versão prévia do recurso - e só confiável se definido como um valor < = 5
WEBSITE_MAX_DYNAMIC_APPLICATION_SCALE_OUT 5
WEBSITE_NODE_DEFAULT_VERSION
Somente Windows.
Define a versão do node. js a ser usada ao executar seu aplicativo de funções no Windows. Você deve usar um
til (~) para que o tempo de execução use a versão mais recente disponível da versão principal de destino. Por
exemplo, quando definido como ~10 , a versão mais recente do node. js 10 é usada. Quando uma versão
principal é destinada a um til, você não precisa atualizar manualmente a versão secundária.
WEBSITE_NODE_DEFAULT_VERSION ~ 10
SITE_EXECUTAR_DO_PACOTE
Permite que seu aplicativo de funções execute de um arquivo de pacote montado.
SITE_EXECUTAR_DO_PACOTE 1
Os valores válidos são 1 ou uma URL que resolve para o local de um arquivo de pacote de implantação.
Quando definido como 1 , o pacote deve estar na pasta d:\home\data\SitePackages . Ao usar a implantação em
zip com essa configuração, o pacote é automaticamente carregado para esse local. Na versão prévia, essa
configuração foi nomeada WEBSITE_RUN_FROM_ZIP . Para obter mais informações, veja Executar suas funções de
um arquivo de pacote.
AZURE_FUNCTION_PROXY_DISABLE_LOCAL_CALL
Por padrão, os proxies de funções utilizarão um atalho para enviar chamadas à API de proxies diretamente
para funções no mesmo aplicativo de funções, em vez de criar uma nova solicitação HTTP. Essa configuração
permite que você desabilite esse comportamento.
CHAVE VALUE DESCRIÇÃO

AZURE_FUNCTION_PROXY_DISABLE_ true Chamadas com uma URL de back-end

LOCAL_CALL apontando para uma função no
Aplicativo de funções local não serão
mais enviadas diretamente à função e,
em vez disso, serão direcionadas de
volta para o front-end HTTP para o
Aplicativo de funções
AZURE_FUNCTION_PROXY_DISABLE_ falso Esse é o valor padrão. Chamadas com

LOCAL_CALL uma URL de back-end apontando
para uma função no Aplicativo de
Funções local serão encaminhadas
diretamente para essa Função
AZURE_FUNCTION_PROXY_BACKEND_URL_DECODE_SLASHES
Essa configuração controla se %2F é decodificado como barras nos parâmetros de rota quando inseridos na
URL de back-end.
AZURE_FUNCTION_PROXY_BACKEND true Os parâmetros de rota com barras

_URL_DECODE_SLASHES codificadas os terão decodificados.
example.com/api%2ftest se tornará
example.com/api/test
AZURE_FUNCTION_PROXY_BACKEND falso Esse é o comportamento padrão.

_URL_DECODE_SLASHES Todos os parâmetros de rota serão
passados inalterados
Exemplo
Aqui, está um exemplo de proxy.json em um aplicativo de funções no myfunction.com da URL
{
"proxies": {
"root": {
"matchCondition": {
"route": "/{*all}"
},
"backendUri": "example.com/{all}"
}
}
}
DECODIFICAÇÃO URL ENTRADA SAÍDA
true myfunction.com/test%2fapi example.com/test/api
falso myfunction.com/test%2fapi example.com/test%2fapi
Próximos passos
Saiba como atualizar as configurações do aplicativo
Consulte as configurações globais no arquivo host.json
Consulte outras configurações de aplicativo para aplicativos do Serviço de Aplicativo
Associações de armazenamento do Blob do Azure
para o Azure Functions
Este artigo explica como trabalhar com associações de armazenamento de blob do Azure no Azure Functions.
O Azure Functions dá suporte a associações de saída, gatilho e entrada para blobs. O artigo inclui uma seção
para cada associação:
Gatilho de blob
Associação de entrada de blob
Associação de saída de blob
NOTE
Use o gatilho de Grade de Eventos em vez do disparador do armazenamento de Blob apenas para contas de
armazenamento de blob, para alta escala ou para reduzir a latência. Para saber mais, veja a seção Gatilho a seguir.
Pacotes - Functions 1. x
As associações de armazenamento de Blob são fornecidas no Microsoft.Azure.WebJobs pacote NuGet,
versão 2. x. O código-fonte do pacote está no repositório GitHub azure-webjobs-sdk.
O suporte para essa associação é fornecido automaticamente em todos os ambientes de desenvolvimento.
Você não precisa instalar o pacote ou registrar a extensão manualmente.
Versão do SDK de Armazenamento do Microsoft Azure em Funções 1. x
Em Funções de 1. x, os gatilhos de armazenamento e associações usam a versão 7.2.1 do SDK de
Armazenamento do Microsoft Azure (windowsazure pacote NuGet). Se você referenciar uma versão
diferente do SDK do armazenamento e associar a um tipo de SDK de armazenamento na sua assinatura de
função, o tempo de execução de funções pode relatar se não é possível associar a esse tipo. A solução é
verificar as referências do projeto windowsazure 7.2.1.
As associações de armazenamento de Blobs são fornecidas no pacote NuGet
Microsoft.Azure.WebJobs.Extensions.Storage, versão 3.x. O código-fonte do pacote está no repositório
GitHub azure-webjobs-sdk.
A tabela a seguir informa como adicionar suporte para essa associação em cada ambiente de
desenvolvimento.
PARA ADICIONAR SUPORTE EM
AMBIENTE DE DESENVOLVIMENTO FUNÇÕES 2.X
Desenvolvimento local - biblioteca de classes do C# Instalar o pacote
Desenvolvimento local - script do C#, JavaScript, F#, Java e Registrar a extensão

Python
Desenvolvimento de portal Instalar ao adicionar uma associação de saída
Para saber como atualizar as extensões de associação existentes no portal sem precisar republicar o projeto
de aplicativo de funções, consulte Atualizar as extensões.
Disparador
O gatilho de armazenamento de Blob inicia uma função quando é detectado um blob novo ou atualizado. O
conteúdo do blob é fornecido como entrada para a função.
O gatilho de Grade de Eventos tem suporte interno para eventos de blob e também pode ser usado para
iniciar uma função quando um blob novo ou atualizado é detectado. Para obter um exemplo, consulte o
tutorial Redimensionamento de imagem com Grade de Eventos.
Use a Grade de Eventos em vez do disparador de armazenamento de Blobs para os seguintes cenários:
Contas de armazenamento de Blobs
Alta escala
Minimizando a latência
Contas de armazenamento de Blobs
As contas de Armazenamento de Blobs são compatíveis para associações de entrada e saída de blobs, mas
não para gatilhos de blob. Os gatilhos de armazenamento de Blobs requerem uma conta de armazenamento
de uso geral.
Alta escala
A alta escala pode ser definida vagamente como contêineres que possuem mais de 100.000 blobs ou contas
de armazenamento que têm mais de 100 atualizações de blobs por segundo.
Problemas de latência
Se seu aplicativo de funções está no plano de Consumo, pode haver um atraso de até 10 minutos no
processamento de novos blobs se um aplicativo de funções ficar ocioso. Para evitar essa latência, você pode
alternar para um plano do serviço de aplicativo com o Always On habilitado. Você também pode usar um
gatilho da Grade de Eventos com sua conta de armazenamento de Blob. Para obter um exemplo, confira o
tutorial da Grade de Eventos.
Gatilho de armazenamento de filas
Além da Grade de Eventos, outra alternativa para blobs de processamento é o gatilho de armazenamento de
Fila, mas ele não tem suporte interno para eventos de blob. Você precisaria criar mensagens de fila ao criar
ou atualizar blobs. Suponto que você fez isso, consulte o exemplo de associação de entrada de blob mais
adiante neste artigo.
Gatilho - exemplo
C#
C#Prescritiva
JavaScript
Python
Java
O exemplo a seguir mostra uma função C# que grava um log quando um blob é adicionado ou atualizado no
contêiner samples-workitems .
[FunctionName("BlobTriggerCSharp")]
public static void Run([BlobTrigger("samples-workitems/{name}")] Stream myBlob, string name, ILogger log)
{
log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length}
Bytes");
}
A cadeia de caracteres {name} no caminho do disparador de blob samples-workitems/{name} cria uma

expressão de associação que você pode usar no código de função para acessar o nome de arquivo do blob
disparando. Para obter mais informações, consulte Padrões de nome do blob a seguir neste artigo.
Para obter mais informações sobre o atributo BlobTrigger , consulte Gatilho - atributos.
Gatilho – atributos
C#
C#Prescritiva
JavaScript
Python
Java
Em bibliotecas de classe C#, use os seguintes atributos para configurar um gatilho de blob:
BlobTriggerAttribute
O construtor do atributo usa uma cadeia de caracteres de caminho que indica o contêiner para
inspecionar e, opcionalmente, um padrão de nome de blob. Veja um exemplo:
[BlobTrigger("sample-images/{name}")] Stream image,
[Blob("sample-images-md/{name}", FileAccess.Write)] Stream imageSmall)
{
....
}
Você pode definir a Connection propriedade para especificar a conta de armazenamento para usar,
conforme mostrado no exemplo a seguir:
[BlobTrigger("sample-images/{name}", Connection = "StorageConnectionAppSetting")] Stream
image,
{
....
}
Para obter um exemplo completo, consulte exemplo de gatilho.

StorageAccountAttribute
Oferece uma maneira de especificar a conta de armazenamento para usar. O construtor toma o nome
de uma configuração de aplicativo que contenha uma cadeia de conexão de armazenamento. O
atributo pode ser aplicado no nível de classe, método ou parâmetro. O exemplo a seguir mostra o nível
de classe e método:
[StorageAccount("ClassLevelStorageAppSetting")]
public static class AzureFunctions
{
[FunctionName("BlobTrigger")]
[StorageAccount("FunctionLevelStorageAppSetting")]
public static void Run( //...
{
....
}
A conta de armazenamento a ser usada é determinada na seguinte ordem:

A propriedade BlobTrigger do atributo Connection .
O StorageAccount atributo aplicado ao mesmo parâmetro do BlobTrigger atributo.
O StorageAccount atributo aplicado à função.
O StorageAccount atributo aplicado à classe.
A conta de armazenamento padrão para a função de aplicativo (configuração de aplicativo
"AzureWebJobsStorage").
Gatilho – configuração
A tabela a seguir explica as propriedades de configuração de associação que você define no arquivo
function.json e no atributo BlobTrigger .
PROPRIEDADE FUNCTION.JSON PROPRIEDADE DE ATRIBUTO DESCRIÇÃO
type n/d Deve ser definido como

blobTrigger . Essa propriedade é
definida automaticamente quando
você cria o gatilho no portal do
Azure.
direction n/d Deve ser definido como in . Essa

propriedade é definida
automaticamente quando você cria o
gatilho no portal do Azure. As
exceções são mencionadas na seção
uso.
name n/d O nome da variável que representa o

blob no código de função.
path BlobPath O contêiner para monitorar. Pode ser

um padrão de nome de blob.
conexão Conexão O nome de uma configuração de

aplicativo que contém uma cadeia de
conexão de Armazenamento para
usar para essa associação. Se o nome
de configuração do aplicativo começar
com "AzureWebJobs", você pode
especificar apenas o resto do nome
aqui. Por exemplo, se você configurar
connection para “MyStorage”, o
tempo de execução do Functions
procura por uma configuração de
aplicativo que esteja nomeada
“AzureWebJobsMyStorage." Se você
deixar connection vazio, o tempo
de execução de Functions usa a
cadeia de caracteres de conexão de
Armazenamento padrão na
configuração de aplicativo chamada
A cadeia de conexão deve ser uma

conta de armazenamento para uso
geral e não uma conta de
Armazenamento de Blobs.
Quando você estiver desenvolvendo localmente, as configurações de aplicativo serão adicionadas ao arquivo
Gatilho - uso
C#
C#Prescritiva
JavaScript
Python
Java
Você pode usar os seguintes tipos de parâmetro para o blob de gatilho:
Stream
TextReader
string
Byte[]
Um POCO serializado como JSON
ICloudBlob 1
CloudBlockBlob 1
CloudPageBlob 1
CloudAppendBlob 1
1 Requer associação "inout" direction em function.json ou FileAccess.ReadWrite em uma biblioteca de

classes C#.
Se você tentar associar a um dos tipos de SDK de armazenamento e obter uma mensagem de erro,
certifique-se de que você tem uma referência a a versão correta do SDK de armazenamento.
Associação para string , Byte[] , ou POCO só é recomendada se o tamanho do blob for pequeno, pois o
conteúdo inteiro do blob é carregado na memória. Geralmente, é preferível usar um tipo Stream ou
CloudBlockBlob . Para obter mais informações, consulte Concorrência e uso de memória mais adiante neste
artigo.
Gatilho - padrões de nome de blob

Você pode especificar um padrão de nome de blob na path propriedade em function.json ou no
BlobTrigger construtor de atributo. O nome padrão pode ser uma expressão de associação ou filtro. As
seções a seguir fornecem exemplos.
Obtenha o nome de arquivo e extensão
O exemplo a seguir mostra como associar ao nome do arquivo de blob e extensão separadamente:
"path": "input/{blobname}.{blobextension}",
Se um blob é nomeado original-Blob1.txt o valor das variáveis blobname e blobextension no código de

função é original-Blob1 e txt.
Filtre por nome de blob
O exemplo a seguir gatilha apenas em blobs no input contêiner que iniciam com a cadeia de caracteres
"original-":
"path": "input/original-{name}",
Se o nome do blob for original-Blob1.txt, o valor da name variável no código da função é Blob1 .
Filtre por tipo de arquivo
O exemplo a seguir é disparado apenas em arquivos .png:
"path": "samples/{name}.png",
Filtre em chaves em nomes de arquivos

Para procurar as chaves em nomes de arquivos, escape as chaves usando duas chaves. O exemplo a seguir
filtra por blobs que têm chaves no nome:
"path": "images/{{20140101}}-{name}",
Se o blob é nomeado {20140101 }soundfile.mp3, o valor da variável name no código da função é

soundfile.mp3.
Gatilho - metadados
C#
C#Prescritiva
JavaScript
Python
Java
O gatilho de blob fornece várias propriedades de metadados. Essas propriedades podem ser usadas como
parte de expressões de associação em outras associações ou como parâmetros em seu código. Esses valores
têm a mesma semântica que o tipo CloudBlob.
PROPRIEDADE TIPO DESCRIÇÃO
BlobTrigger string O caminho do blob de gatilho.
Uri System.Uri A URI do blob para o local principal.
Properties BlobProperties As propriedades do sistema do blob.
Metadata IDictionary<string,string> Os metadados definidos pelo usuário

para o blob.
Por exemplo, o script C# e exemplos de JavaScript a seguir registram o caminho para o blob disparando,
incluindo o contêiner:
public static void Run(string myBlob, string blobTrigger, ILogger log)

{
log.LogInformation($"Full blob path: {blobTrigger}");
}
Gatilho - recebimentos de blob

O tempo de execução do Azure Functions garante que nenhuma função de gatilho de blob seja chamada
mais de uma vez para o mesmo blob novo ou atualizado. Para determinar se uma versão de determinado
blob foi processada, ele mantém os recebimentos de blob.
O Azure Functions armazena recibos do blob em um contêiner denominado azure-webjobs-hosts na conta de
armazenamento do Azure do seu aplicativo de funções (definido na configuração do aplicativo
AzureWebJobsStorage ). Um recebimento de blob tem as seguintes informações:
A função disparada (" <nome do aplicativo de funções> .Functions. <nome da função> ", por exemplo:
"MyFunctionApp.Functions.CopyBlob")
O nome do contêiner
O tipo de blob ("BlockBlob" ou "PageBlob")
O nome do blob
O ETag (um identificador de versão de blob, por exemplo: "0x8D1DC6E70A277EF")
Para forçar o reprocessamento de um blob, exclua manualmente o recebimento desse blob do contêiner
azure-webjobs-hosts. Embora o reprocessamento possa não ocorrer imediatamente, é garantido que ocorra
em um momento posterior.
Gatilho - mensagens suspeitas

Quando uma função de gatilho de blob falhar para um determinado blob, o Azure Functions repete essa
função até cinco vezes por padrão.
Se todas as cinco tentativas falharem, o Azure Functions adiciona uma mensagem para uma fila de
armazenamento denominada webjobs-blobtrigger-poison. A mensagem da fila para blobs suspeitos é um
objeto JSON que contém as seguintes propriedades:
FunctionId (no formato <nome do aplicativo de funções> .Functions. <nome da função> )
BlobType ("BlockBlob" ou "PageBlob")
ContainerName
BlobName
ETag (um identificador de versão de blob, por exemplo: "0x8D1DC6E70A277EF")
Gatilho - concorrência e uso de memória

O gatilho de blob usa uma fila internamente, portanto, o número máximo de invocações de função
concorrente é controlado pela configuração de filas em host.json. As configurações padrão limitam a
concorrência a 24 invocações. Esse limite aplica-se separadamente a cada função que usa um gatilho de blob.
O plano de consumo limita um aplicativo de funções em uma VM (máquina virtual) a 1,5 GB de memória. A
memória é usada por cada instância de execução de execução simultânea e pelo próprio tempo de execução
de Funções. Se uma função disparada por blob carregar todo o blob na memória, a memória máxima usada
por essa função apenas para blobs será tamanho máximo de blob 24 *. Por exemplo, um aplicativo de
funções com três funções disparadas por blob e as configurações padrão teriam uma concorrência máxima
por VM de 3*24 = 72 invocações de função.
As funções de JavaScript e Java carregam todo o blob na memória, e as funções C# fazem isso se você
associar a string , Byte[] ou POCO.
Disparar - sondagem
Se o contêiner de BLOB que está sendo monitorado contiver mais de 10.000 BLOBs (em todos os
contêineres), o tempo de execução do Functions examinará os arquivos de log para ver se há BLOBs novos
ou alterados. Esse processo pode resultar em atrasos. Uma função não poderá ser disparada até que se
passem vários minutos ou mais tempo depois da criação do blob.
WARNING
Além disso, logs de armazenamento são criados da "melhor forma dentro do possível". Não há nenhuma garantia de
que todos os eventos são capturados. Sob algumas condições, logs poderão ser perdidos.
Se você precisar de um processamento de blob mais rápido ou confiável, crie uma mensagem de fila ao criar o blob. Em
seguida, use um gatilho de fila em vez de um gatilho de blob para processar o blob. Outra opção é usar a Grade de
Eventos; consulte o tutorial Automatize redimensionamento de imagens carregadas usando a Grade de Eventos.
Entrada
Use uma associação de entrada de Armazenamento de Blobs para ler blobs.
Entrada - exemplo
C#
C#Prescritiva
JavaScript
Python
Java
O exemplo a seguir é uma função C# que usa um gatilho de fila e uma associação de blob de entrada. A
mensagem da fila contém o nome do blob e a função registra o tamanho do blob.
[FunctionName("BlobInput")]
[Blob("samples-workitems/{queueTrigger}", FileAccess.Read)] Stream myBlob,
ILogger log)
{
log.LogInformation($"BlobInput processed blob\n Name:{myQueueItem} \n Size: {myBlob.Length} bytes");
}
Entrada – atributos
C#
C#Prescritiva
JavaScript
Python
Java
Em bibliotecas de classes do C#, use o BlobAttribute.
O construtor do atributo usa o caminho para o blob e um parâmetro FileAccess que indica a leitura ou
gravação, conforme mostrado no exemplo a seguir:
[Blob("samples-workitems/{queueTrigger}", FileAccess.Read)] Stream myBlob,
ILogger log)
{
}
Você pode definir a Connection propriedade para especificar a conta de armazenamento para usar, conforme
[Blob("samples-workitems/{queueTrigger}", FileAccess.Read, Connection =
"StorageConnectionAppSetting")] Stream myBlob,
ILogger log)
{
}
Você pode usar o StorageAccount atributo para especificar a conta de armazenamento no nível de classe,
método ou parâmetro. Para obter mais informações, consulte Gatilho - atributos.
Entrada - configuração
A tabela a seguir explica as propriedades de configuração de associação que você definir no arquivo
function.json e o Blob atributo.

type n/d Deve ser definido como blob .
direction n/d Deve ser definido como in . As

exceções são mencionadas na seção
uso.

blob no código de função.
path BlobPath O caminho para o blob.


conta de armazenamento de
finalidade geral e não uma conta de
armazenamento de blobs.
n/d Access Indica se você será leitura ou

gravação.
Entrada - uso
C#
C#Prescritiva
JavaScript
Python
Java
Você pode usar os seguintes tipos de parâmetro para a associação de entrada de blob:
Stream
TextReader
string
Byte[]
CloudBlobContainer
CloudBlobDirectory
ICloudBlob 1
CloudBlockBlob 1
CloudPageBlob 1
CloudAppendBlob 1

classes C#.
Associação para string ou Byte[] só é recomendada se o tamanho do blob for pequeno, pois o conteúdo
inteiro do blob é carregado na memória. Geralmente, é preferível usar um tipo Stream ou CloudBlockBlob .
Para obter mais informações, consulte Concorrência e uso de memória mais adiante neste artigo.
Saída
Usar as associações de saída do Armazenamento de Blobs para gravar os blobs.
Saída - exemplo
C#
C#Prescritiva
JavaScript
Python
Java
O exemplo a seguir é uma função C# que usa um gatilho de blob e duas associações de blob de saída. A
função é gatilhada pela criação de um blob de imagem no contêiner imagens de amostra. Isso cria cópias de
pequeno e médio tamanho de blob de imagem.
using System.IO;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
[Blob("sample-images-sm/{name}", FileAccess.Write)] Stream imageSmall,
[Blob("sample-images-md/{name}", FileAccess.Write)] Stream imageMedium)
{
IImageFormat format;
using (Image<Rgba32> input = Image.Load(image, out format))

{
ResizeImage(input, imageSmall, ImageSize.Small, format);
}
image.Position = 0;
using (Image<Rgba32> input = Image.Load(image, out format))
{
ResizeImage(input, imageMedium, ImageSize.Medium, format);
}
}
public static void ResizeImage(Image<Rgba32> input, Stream output, ImageSize size, IImageFormat format)
{
var dimensions = imageDimensionsTable[size];
input.Mutate(x => x.Resize(dimensions.Item1, dimensions.Item2));

input.Save(output, format);
}
public enum ImageSize { ExtraSmall, Small, Medium }
private static Dictionary<ImageSize, (int, int)> imageDimensionsTable = new Dictionary<ImageSize, (int,

int)>() {
{ ImageSize.ExtraSmall, (320, 200) },
{ ImageSize.Small, (640, 400) },
{ ImageSize.Medium, (800, 600) }
};
Saída - atributos
C#
C#Prescritiva
JavaScript
Python
Java
Em bibliotecas de classes do C#, use o BlobAttribute.
O construtor do atributo usa o caminho para o blob e um parâmetro FileAccess que indica a leitura ou
gravação, conforme mostrado no exemplo a seguir:
{
...
}
[Blob("sample-images-md/{name}", FileAccess.Write, Connection = "StorageConnectionAppSetting")]
Stream imageSmall)
{
...
}
Para obter um exemplo completo, consulte exemplo de saída.

método ou parâmetro. Para obter mais informações, consulte Gatilho - atributos.
Saída - configuração
function.json e no Blob atributo.
type n/d Deve ser definido como blob .
direction n/d Deve ser definido como out para

uma associação de saída. As exceções
são mencionadas na seção uso.

blob no código de função. Definido
como $return para referenciar o
valor de retorno da função.
path BlobPath O caminho para o contêiner de BLOB.



conta de armazenamento de
finalidade geral e não uma conta de
armazenamento de blobs.
n/d Access Indica se você será leitura ou

gravação.
Saída - uso
C#
C#Prescritiva
JavaScript
Python
Java
Você pode associar aos seguintes tipos para gravar BLOBs:
TextWriter
out string
out Byte[]
CloudBlobStream
Stream
CloudBlobContainer 1
CloudBlobDirectory
ICloudBlob 2
CloudBlockBlob 2
CloudPageBlob 2
CloudAppendBlob 2
1
1 Requerassociação "in" direction em function.json ou FileAccess.Read em uma biblioteca de classes C#.
No entanto, você pode usar o objeto de contêiner que o tempo de execução fornece para operações de
gravação, como carregar blobs no contêiner.
classes C#.
Em funções assíncronas, use o valor de retorno ou IAsyncCollector em vez de um parâmetro out .
Associação para string ou Byte[] só é recomendada se o tamanho do blob for pequeno, pois o conteúdo
inteiro do blob é carregado na memória. Geralmente, é preferível usar um tipo Stream ou CloudBlockBlob .
Para obter mais informações, consulte Concorrência e uso de memória mais adiante neste artigo.
Exceções e códigos de retorno

ASSOCIAÇÃO REFERÊNCIA
Blob Códigos de erro de Blob
Blob, tabela, fila Códigos de erro de armazenamento
Blob, tabela, fila Solução de problemas
Próximas etapas
Associações do Azure Cosmos DB para Azure
Functions 1.x
Este artigo explica como trabalhar com associações do Azure Cosmos DB no Azure Functions. O Azure
Functions dá suporte a associações de gatilho, entrada e saída para o Azure Cosmos DB.
NOTE
Este artigo serve para o Azure Functions 1.x. Para obter informações sobre como usar essas associações em Functions 2.x,
veja Associações do Azure Cosmos DB para Azure Functions 2.x.
Essa associação era originalmente denominada DocumentDB. No Functions versão 1.x, apenas o gatilho foi renomeado
Cosmos DB; a associação de entrada, a associação de saída e o pacote NuGet mantêm o nome DocumentDB.
NOTE
As associações do Azure Cosmos DB têm suporte apenas para usar com a API do SQL. Para todas as outras APIs do
Azure Cosmos DB, você deve acessar o banco de dados por meio da sua função usando o cliente estático da API,
incluindo a API do Azure Cosmos DB para MongoDB, a API do Cassandra, a API do Gremlin e a API de Tabela.
As associações do Azure Cosmos DB para Functions versão 1.x são fornecidas no pacote NuGet
Microsoft.Azure.WebJobs.Extensions.DocumentDB, versão 1.x. O código-fonte para a associação está no
repositório GitHub azure-webjobs-sdk-extensions.
A tabela a seguir informa como adicionar suporte para essa associação em cada ambiente de desenvolvimento.

Desenvolvimento local - Script do C#, JavaScript, F# Automático
Desenvolvimento de portal Automático
Gatilho
O Gatilho do Azure Cosmos DB usa o Feed de Alterações do Azure Cosmos DB para escutar as inserções e
atualizações nas partições. O feed de alteração publica inserções e atualizações, não exclusões.
Gatilho - exemplo
Consulte o exemplo específico a um idioma:
C#
Script do C# (.csx)
JavaScript
Ignorar exemplos de gatilho
Gatilho - exemplo C#
O exemplo a seguir mostra uma função C# que é chamada quando há inserções ou atualizações na coleção e no
banco de dados especificados.
using Microsoft.Azure.Documents;
namespace CosmosDBSamplesV1
{
public static class CosmosTrigger
{
[FunctionName("CosmosTrigger")]
public static void Run([CosmosDBTrigger(
databaseName: "ToDoItems",
collectionName: "Items",
ConnectionStringSetting = "CosmosDBConnection",
LeaseCollectionName = "leases",
CreateLeaseCollectionIfNotExists = true)]IReadOnlyList<Document> documents,
TraceWriter log)
{
if (documents != null && documents.Count > 0)
{
log.Info($"Documents modified: {documents.Count}");
log.Info($"First document Id: {documents[0].Id}");
}
}
}
}

Gatilho - exemplo de script C#
O exemplo a seguir mostra uma associação de gatilho do Cosmos DB em um arquivo function.json e uma
função script C# que usa a associação. A função grava mensagens de log quando registros do Cosmos DB são
modificados.
Aqui estão os dados de associaçã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 do C#:
using System;
public static void Run(IReadOnlyList<Document> documents, TraceWriter log)

{
log.Info("Documents modified " + documents.Count);
log.Info("First document Id " + documents[0].Id);
}

Gatilho - exemplo de JavaScript
O exemplo a seguir mostra uma associação de gatilho do Cosmos DB em um arquivo function.json e uma
função JavaScript que usa a associação. A função grava mensagens de log quando registros do Cosmos DB são
modificados.
{
"direction": "in",
}
Aqui está o código JavaScript:
module.exports = function (context, documents) {

context.log('First document Id modified : ', documents[0].id);
context.done();
}
Em bibliotecas de classes de C#, utilize o atributo CosmosDBTrigger.
O construtor do atributo toma o nome do banco de dados e o nome da coleção. Para obter informações sobre
essas configurações e outras propriedades que podem ser configuradas, consulte Gatilho – configurações. Aqui
está um exemplo de atributo CosmosDBTrigger em uma assinatura de método:
[FunctionName("DocumentUpdates")]
[CosmosDBTrigger("database", "collection", ConnectionStringSetting = "myCosmosDB")]
IReadOnlyList<Document> documents,
TraceWriter log)
{
...
}
Para ver um exemplo completo, consulte Gatilho – exemplo de C#.
function.json e no atributo CosmosDBTrigger .
type Deve ser definido como

cosmosDBTrigger .
direction Deve ser definido como in . Esse

parâmetro é definido automaticamente
quando você cria o gatilho no portal
do Azure.
name O nome da variável usado no código

de função que representa a lista de
documentos com alterações.
connectionStringSetting ConnectionStringSetting O nome de uma configuração de

aplicativo que contém a cadeia de
conexão usada para conectar-se à
conta do Azure Cosmos DB que está
sendo monitorada.
databaseName DatabaseName O nome do banco de dados do Azure

Cosmos DB com a coleção que está
sendo monitorada.
collectionName CollectionName O nome da coleção que está sendo

monitorada.
leaseConnectionStringSetting LeaseConnectionStringSetting (Opcional) O nome de uma

configuração de aplicativo que contém
a cadeia de conexão para o serviço
com a coleção de concessão. Quando
não definido, o valor
connectionStringSetting é usado.
Esse parâmetro é definido
automaticamente quando a associação
é criada no portal. A cadeia de conexão
da coleção de concessões deve ter
permissões de gravação.
leaseDatabaseName LeaseDatabaseName (Opcional) O nome do banco de dados

que contém a coleção usada para
armazenar as concessões. Quando não
definido, o valor da configuração
databaseName é usado. Esse
quando a associação é criada no
portal.
leaseCollectionName LeaseCollectionName (Opcional) O nome da coleção usada

para armazenar as concessões.
Quando não definido, o valor leases
é usado.
createLeaseCollectionIfNotExists CreateLeaseCollectionIfNotExists (Opcional) Quando definido como

true , a coleção de concessões é
criada automaticamente quando ela
ainda não existe. O valor padrão é
false .
leasesCollectionThroughput leasesCollectionThroughput (Opcional) Define a quantidade de

Unidades de Solicitação a atribuir
quando a coleção de concessões for
criada. Essa configuração é usada
apenas quando
createLeaseCollectionIfNotExists
é definido como true . Esse
quando a associação é criada usando o
portal.
leaseCollectionPrefix LeaseCollectionPrefix (Opcional) Quando definido, ele

adiciona um prefixo às concessões
criadas na coleção de Concessão para
esta Função, permitindo efetivamente
duas funções do Azure Functions
separadas para compartilhar a mesma
coleção de Concessão usando prefixos
diferentes.
feedPollDelay FeedPollDelay (Opcional) Quando definido, ele define,

em milissegundos, o atraso entre a
sondagem de uma partição quanto a
novas alterações no feed, depois que
todas as alterações atuais forem
descarregadas. O padrão é 5000 (5
segundos).
leaseAcquireInterval LeaseAcquireInterval (Opcional) Quando definido, ele define,

em milissegundos, o intervalo para
disparar uma tarefa para computar se
as partições são distribuídas
uniformemente entre as instâncias de
host conhecidas. O padrão é 13000
(13 segundos).
leaseExpirationInterval 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 deste intervalo, ela
será expirada e a propriedade da
partição será movida para outra
instância. O padrão é 60000 (60
segundos).
leaseRenewInterval LeaseRenewInterval (Opcional) Quando definido, ele define,

em milissegundos, o intervalo de
renovação para todas as concessões
para partições atualmente mantidas
por uma instância. O padrão é 17000
(17 segundos).
checkpointFrequency CheckpointFrequency (Opcional) Quando definido, ele define,

em milissegundos, o intervalo entre os
pontos de verificação de concessão. O
padrão é sempre após cada chamada
de Função.
maxItemsPerInvocation MaxItemsPerInvocation (Opcional) Quando definido, ele

personaliza a quantidade máxima de
itens recebidos por chamada de
Função.
startFromBeginning startFromBeginning Quando definido, ele informa o gatilho

para iniciar a leitura de alterações
desde o início do histórico de coleção
em vez da hora atual. Isso funciona
apenas na primeira vez em que gatilho
inicia, como em execuções
subsequentes, os pontos de verificação
já estão armazenados. Definir isso
como true quando houver
concessões já criadas não tem nenhum
efeito.
Gatilho - uso
O gatilho requer uma segunda coleção que ele usa para armazenar concessões sobre as partições. Tanto a
coleção que está sendo monitorada quanto a coleção que contém as concessões devem estar disponíveis para o
gatilho funcionar.
IMPORTANT
Se várias funções estiverem configuradas para usar um gatilho do Cosmos DB para a mesma coleção, cada uma das
funções deverá usar uma coleção de concessões dedicada ou especificar uma diferente LeaseCollectionPrefix para
cada função. Caso contrário, apenas uma das funções será disparada. Para obter informações sobre o prefixo, veja a seção
de Configuração.
O gatilho não indica se um documento foi atualizado ou inserido, ele fornece apenas o documento em si. Se
você precisa lidar com inserções e atualizações de forma diferente, você pode fazer isso com a implementação
de campos de carimbo de hora de inserção ou atualização.
Entrada
A associação de dados de entrada do Azure Cosmos DB usa a API de SQL para recuperar um ou mais
documentos do Azure Cosmos DB e passá-los para o parâmetro de entrada da função. A ID do documento ou
os parâmetros de consulta podem ser determinados com base no gatilho que invoca a função.
Entrada – exemplos
Veja os exemplos específicos a um idioma que lê um documento especificando um valor de ID:
C#
Script do C# (.csx)
JavaScript
F#
Ignorar exemplos de entrada
Entrada – exemplos em C#
Esta seção contém os seguintes exemplos:
Gatilho da fila, pesquisar ID no JSON
Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta
Gatilho HTTP, pesquisar ID nos dados da rota
Gatilho HTTP, pesquisar ID nos dados da rota, usando SqlQuery
Gatilho HTTP, obter vários documentos, usando SqlQuery
Gatilho HTTP, obter vários documentos, usando DocumentClient
Os exemplos se referem a um tipo ToDoItem simples:
{
public class ToDoItem
{
public string Description { get; set; }
}
}

Gatilho da fila, pesquisar ID no JSON (C#)
O exemplo a seguir mostra uma função C# que recupera um único documento. A função é disparada por uma
mensagem da fila que contém um objeto JSON. O gatilho da fila analisa o JSON em um objeto chamado
ToDoItemLookup , que contém a ID a pesquisar. Essa ID é usada para recuperar um documento ToDoItem no
banco de dados e na coleção especificados.
{
public class ToDoItemLookup
{
public string ToDoItemId { get; set; }
}
}
{
public static class DocByIdFromJSON
{
[FunctionName("DocByIdFromJSON")]
[QueueTrigger("todoqueueforlookup")] ToDoItemLookup toDoItemLookup,
[DocumentDB(
Id = "{ToDoItemId}")]ToDoItem toDoItem,
TraceWriter log)
{
log.Info($"C# Queue trigger function processed Id={toDoItemLookup?.ToDoItemId}");
if (toDoItem == null)
{
log.Info($"ToDo item not found");
}
else
{
log.Info($"Found ToDo item, Description={toDoItem.Description}");
}
}
}
}

Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta (C#)
solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a pesquisar. Essa ID é usada
para recuperar um documento ToDoItem no banco de dados e na coleção especificados.
using System.Net;
{
public static class DocByIdFromQueryString
{
[FunctionName("DocByIdFromQueryString")]
public static HttpResponseMessage Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]HttpRequestMessage req,
[DocumentDB(
Id = "{Query.id}")] ToDoItem toDoItem,
TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
{
}
else
{
}
return req.CreateResponse(HttpStatusCode.OK);
}
}
}

Gatilho HTTP, pesquisar ID nos dados da rota (C#)
solicitação HTTP que usa os dados da rota para especificar a ID a pesquisar. Essa ID é usada para recuperar um
documento ToDoItem no banco de dados e na coleção especificados.
using System.Net;
{
public static class DocByIdFromRouteData
{
[FunctionName("DocByIdFromRouteData")]
[HttpTrigger(
AuthorizationLevel.Anonymous, "get", "post",
Route = "todoitems/{id}")]HttpRequestMessage req,
[DocumentDB(
Id = "{id}")] ToDoItem toDoItem,
TraceWriter log)
{
{
}
else
{
}
}
}
}

Gatilho HTTP, pesquisar ID nos dados da rota, usando SqlQuery (C#)
using System.Net;
{
public static class DocByIdFromRouteDataUsingSqlQuery
{
[FunctionName("DocByIdFromRouteDataUsingSqlQuery")]
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post",
Route = "todoitems2/{id}")]HttpRequestMessage req,
[DocumentDB(
SqlQuery = "select * from ToDoItems r where r.id = {id}")] IEnumerable<ToDoItem> toDoItems,
TraceWriter log)
{
foreach (ToDoItem toDoItem in toDoItems)
{
log.Info(toDoItem.Description);
}
}
}
}

Gatilho HTTP, obter vários documentos, usando SqlQuery (C#)
O exemplo a seguir mostra uma função C# que recupera uma lista de documentos. A função é disparada por
uma solicitação HTTP. A consulta é especificada na propriedade do atributo SqlQuery .
using System.Net;
{
public static class DocsBySqlQuery
{
[FunctionName("DocsBySqlQuery")]
HttpRequestMessage req,
[DocumentDB(
SqlQuery = "SELECT top 2 * FROM c order by c._ts desc")]
IEnumerable<ToDoItem> toDoItems,
TraceWriter log)
{
{
}
}
}
}

Gatilho HTTP, obter vários documentos, usando DocumentClient (C#)
O exemplo a seguir mostra uma função C# que recupera uma lista de documentos. A função é disparada por
uma solicitação HTTP. O código usa uma instância DocumentClient fornecida pela associação do Azure Cosmos
DB para ler uma lista de documentos. A instância DocumentClient também pode ser usada para as operações de
gravação.
using Microsoft.Azure.Documents.Linq;
using System;
using System.Linq;
using System.Net;
{
public static class DocsByUsingDocumentClient
{
[FunctionName("DocsByUsingDocumentClient")]
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]HttpRequestMessage req,
[DocumentDB(
ConnectionStringSetting = "CosmosDBConnection")] DocumentClient client,
TraceWriter log)
{
Uri collectionUri = UriFactory.CreateDocumentCollectionUri("ToDoItems", "Items");

string searchterm = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "searchterm", true) == 0)
.Value;
if (searchterm == null)
{
}
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);
}
}
}
}
}

Entrada – exemplos de script C#
Gatilho da fila, pesquisar ID na cadeia de caracteres
Gatilho da fila, obter vários documentos, usando SqlQuery
Os exemplos de gatilho HTTP se referem a um tipo ToDoItem simples:
{
{
}
}

Gatilho da fila, pesquisar ID na cadeia de caracteres (script C#)
O exemplo a seguir mostra uma associação de entrada do Cosmos DB em um arquivo function.json e uma
função script C# que usa a associação. A função lê um documento único e atualiza o valor de texto do
documento.
{
"name": "inputDocument",
"type": "documentDB",
"databaseName": "MyDatabase",
"collectionName": "MyCollection",
"id" : "{queueTrigger}",
"partitionKey": "{partition key value}",
"connection": "MyAccount_COSMOSDB",
"direction": "in"
}
A seção configuração explica essas propriedades.

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 da fila, obter vários documentos, usando SqlQuery (script C#)
O exemplo a seguir mostra uma associação de dados de entrada do Cosmos DB em um arquivo function.json e
uma função script C# que usa a associação de dados. 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 consulta fornece um parâmetro departmentId . Uma mensagem de consulta de
{ "departmentId" : "Finance" } retornará todos os registros ao departamento financeiro.

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

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, pesquisar ID na cadeia de caracteres de consulta (script C#)
O exemplo a seguir mostra uma função de script C# que recupera um único documento. A função é disparada
por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a pesquisar. Essa
ID é usada para recuperar um documento ToDoItem no banco de dados e na coleção especificados.
Aqui está o arquivo function.json:
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"name": "toDoItem",
"databaseName": "ToDoItems",
"connection": "CosmosDBConnection",
"direction": "in",
"Id": "{Query.id}"
}
],
"disabled": true
}
using System.Net;
public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, TraceWriter log)

{
{
}
else
{
}
}

Gatilho HTTP, pesquisar ID nos dados da rota (script C#)
por uma solicitação HTTP que usa os dados da rota para especificar a ID a pesquisar. Essa ID é usada para
recuperar um documento ToDoItem no banco de dados e na coleção especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
],
"route":"todoitems/{id}"
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"name": "toDoItem",
"direction": "in",
"Id": "{id}"
}
],
"disabled": false
}
using System.Net;
public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, TraceWriter log)

{
{
}
else
{
}
}

Gatilho HTTP, obter vários documentos, usando SqlQuery (script C#)
O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é
disparada por uma solicitação HTTP. A consulta é especificada na propriedade do atributo SqlQuery .
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"name": "toDoItems",
"direction": "in",
"sqlQuery": "SELECT top 2 * FROM c order by c._ts desc"
}
],
"disabled": false
}
using System.Net;
public static HttpResponseMessage Run(HttpRequestMessage req, IEnumerable<ToDoItem> toDoItems, TraceWriter

log)
{

{
}
}

Gatilho HTTP, obter vários documentos, usando DocumentClient (script C#)
O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é
disparada por uma solicitação HTTP. O código usa uma instância DocumentClient fornecida pela associação do
Azure Cosmos DB para ler uma lista de documentos. A instância DocumentClient também pode ser usada para
as operações de gravação.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"name": "client",
"direction": "inout"
}
],
"disabled": false
}

using System.Net;
public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, DocumentClient client, TraceWriter

log)
{

.Value;
{
}
log.Info($"Searching for word: {searchterm} using Uri: {collectionUri.ToString()}");

.AsDocumentQuery();
{
{
log.Info(result.Description);
}
}
}

Entrada – exemplos de JavaScript
Gatilho da fila, pesquisar ID no JSON (JavaScript)
função JavaScript que usa a associação. A função lê um documento único e atualiza o valor de texto do
documento.
{
"name": "inputDocumentIn",
"id" : "{queueTrigger_payload_property}",
"partitionKey": "{queueTrigger_payload_property}",
"direction": "in"
},
{
"name": "inputDocumentOut",
"createIfNotExists": false,
"direction": "out"
}

// Change input document contents using Azure Cosmos DB input binding, using
context.bindings.inputDocumentOut
context.bindings.inputDocumentOut = context.bindings.inputDocumentIn;
context.bindings.inputDocumentOut.text = "This was updated!";
context.done();
};

Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta (JavaScript)
O exemplo a seguir mostra uma função de script JavaScript que recupera um único documento. A função é
disparada por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a
pesquisar. Essa ID é usada para recuperar um documento ToDoItem no banco de dados e na coleção
especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"name": "toDoItem",
"direction": "in",
"Id": "{Query.id}"
}
],
"disabled": true
}
module.exports = function (context, req, toDoItem) {

context.log('JavaScript queue trigger function processed work item');
if (!toDoItem)
{
context.log("ToDo item not found");
}
else
{
context.log("Found ToDo item, Description=" + toDoItem.Description);
}
context.done();
};

Gatilho HTTP, pesquisar ID nos dados da rota (JavaScript)
especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
],
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"name": "toDoItem",
"direction": "in",
"Id": "{id}"
}
],
"disabled": false
}

if (!toDoItem)
{
}
else
{
}
context.done();
};

Gatilho da fila, obter vários documentos, usando SqlQuery (script javaScript)

{
"type": "documentdb",
"direction": "in",
"connection": "CosmosDBConnection"
}


var documents = context.bindings.documents;
for (var i = 0; i < documents.length; i++) {
var document = documents[i];
}
context.done();
};

Entrada – exemplos de F#
função F# que usa a associação. A função lê um documento único e atualiza o valor de texto do documento.
{
"direction": "in"
}

(* Change input document contents using Azure Cosmos DB input binding *)

open FSharp.Interop.Dynamic
let Run(myQueueItem: string, inputDocument: obj) =
inputDocument?text <- "This has changed."
Esse exemplo requer um arquivo project.json que especifique as dependências FSharp.Interop.Dynamic e

Dynamitey do NuGet:
{
"frameworks": {
"net46": {
"dependencies": {
"Dynamitey": "1.0.2",
"FSharp.Interop.Dynamic": "3.0.0"
}
}
}
}
Para adicionar um arquivo do project.json , veja Gerenciamento de pacotes do F#.
Em bibliotecas de classes de C#, utilize o atributo DocumentDB.
essas configurações e outras propriedades que podem ser configuradas, consulte a seção de configuração a
seguir.
function.json e o DocumentDB atributo.
type Deve ser definido como documentdb .
direction Deve ser definido como in .
name Nome do parâmetro de associação que

representa o documento na função.
databaseName DatabaseName O banco de dados que contém o

documento.
collectionName CollectionName O nome da coleção que contém o

documento.
id Id A ID do documento a ser recuperado.

Essa propriedade dá suporte a
expressões de associação. Não defina
ambas as propriedades id e sqlQuery.
Se você não definir uma ou outra, toda
a coleção é recuperada.
sqlQuery SqlQuery Uma consulta SQL do Azure Cosmos

DB usada para recuperar vários
documentos. A propriedade dá
suporte a associações de tempo de
execução, como neste exemplo:
SELECT * FROM c where
c.departmentId = {departmentId}
. Não defina ambas as propriedades id
e sqlQuery. Se você não definir uma
ou outra, toda a coleção é recuperada.
conexão ConnectionStringSetting O nome da configuração do aplicativo

que contém a cadeia de conexão do
Azure Cosmos DB.
partitionKey PartitionKey Especifica o valor da chave de partição

para a pesquisa. Pode incluir
parâmetros de associação.
Entrada - uso
Em funções C# e F#, todas as alterações feitas no documento de entrada por parâmetros de entrada nomeados
são persistidas automaticamente.
Funções de JavaScript, as atualizações não são feitas automaticamente após a saída da função. Em vez disso,
use context.bindings.<documentName>In e context.bindings.<documentName>Out para fazer atualizações. Consulte
o exemplo JavaScript.
Output
Com a associação de saída do Azure Cosmos DB, você pode gravar um novo documento para um banco de
dados do Azure Cosmos DB usando a API de SQL.
Saída – exemplos
Consulte os exemplos específicos a um idioma:
C#
Script do C# (.csx)
JavaScript
F#
Veja também o exemplo de entrada que usa DocumentClient .
Ignorar exemplos de saída
Saída - exemplos C#
Gatilho da fila, gravar um documento
Gatilho da fila, gravar documentos usando IAsyncCollector
{
{
}
}

Gatilho da fila, gravar um documento (C#)
O exemplo a seguir mostra uma função C# que adiciona um documento a um banco de dados, usando os dados
fornecidos na mensagem do armazenamento de fila.
using System;
{
public static class WriteOneDoc
{
[FunctionName("WriteOneDoc")]
[QueueTrigger("todoqueueforwrite")] string queueMessage,
[DocumentDB(
ConnectionStringSetting = "CosmosDBConnection")]out dynamic document,
TraceWriter log)
{
document = new { Description = queueMessage, id = Guid.NewGuid() };
log.Info($"C# Queue trigger function inserted one row");

log.Info($"Description={queueMessage}");
}
}
}

Gatilho da fila, gravar documentos usando IAsyncCollector (C#)
O exemplo a seguir mostra uma função C# que adiciona uma coleção de documentos a um banco de dados,
usando os dados fornecidos em um JSON de mensagem da fila.
{
public static class WriteDocsIAsyncCollector
{
[FunctionName("WriteDocsIAsyncCollector")]
[QueueTrigger("todoqueueforwritemulti")] ToDoItem[] toDoItemsIn,
[DocumentDB(
ConnectionStringSetting = "CosmosDBConnection")]
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);
}
}
}
}

Saída – exemplos de script C#
Gatilho da fila, gravar um documento (script C#)
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 associação. A função usa uma associação de entrada de fila para uma fila que
recebe o JSON no seguinte formato:
{
"name": "John Henry",
"employeeId": "123456",
"address": "A town nearby"
}
A função cria documentos do Azure Cosmos DB no formato a seguir para cada registro:
{
"id": "John Henry-123456",
}

{
"name": "employeeDocument",
"createIfNotExists": true,
"direction": "out"
}

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

Para criar vários documentos, você também pode associar a ICollector<T> ou IAsyncCollector<T> , sendo T
um dos tipos com suporte.
Este exemplo se refere a um tipo ToDoItem simples:
{
{
}
}

{
"bindings": [
{
"name": "toDoItemsIn",
"direction": "in",
"queueName": "todoqueueforwritemulti",
},
{
"name": "toDoItemsOut",
"direction": "out"
}
],
"disabled": false
}
using System;
public static async Task Run(ToDoItem[] toDoItemsIn, IAsyncCollector<ToDoItem> toDoItemsOut, TraceWriter

log)
{
log.Info($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

{
log.Info($"Description={toDoItem.Description}");
}
}

Saída – exemplos de JavaScript
{
}
{
}

{
"direction": "out"
}

context.bindings.employeeDocument = JSON.stringify({
id: context.bindings.myQueueItem.name + "-" + context.bindings.myQueueItem.employeeId,
name: context.bindings.myQueueItem.name,
employeeId: context.bindings.myQueueItem.employeeId,
address: context.bindings.myQueueItem.address
});
context.done();
};

Saída – exemplos de F#
{
}
{
}

{
"direction": "out"
}

open Newtonsoft.Json
type Employee = {
id: string
name: string
employeeId: string
address: string
}
let Run(myQueueItem: string, employeeDocument: byref<obj>, log: TraceWriter) =

log.Info(sprintf "F# Queue trigger function processed: %s" myQueueItem)
let employee = JObject.Parse(myQueueItem)
employeeDocument <-
{ id = sprintf "%s-%s" employee?name employee?employeeId
name = employee?name
employeeId = employee?employeeId
address = employee?address }

Dynamitey do NuGet:
{
"frameworks": {
"net46": {
"dependencies": {
}
}
}
}
Saída - atributos
Em bibliotecas de classes de C#, utilize o atributo DocumentDB.
essas configurações e outras propriedades que podem ser configuradas, consulte Saída – configurações. Aqui
está um exemplo de atributo DocumentDB em uma assinatura de método:
[FunctionName("QueueToDocDB")]
[QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")] string myQueueItem,
[DocumentDB("ToDoList", "Items", Id = "id", ConnectionStringSetting = "myCosmosDB")] out dynamic
document)
{
...
}
Para ver um exemplo completo, consulte Saída – exemplo de C#.
function.json e no DocumentDB atributo.
type Deve ser definido como documentdb .
direction Deve ser definido como out .

databaseName DatabaseName O banco de dados que contém a

coleção na qual o documento será
criado.
collectionName CollectionName O nome da coleção na qual o

documento será criado.
createIfNotExists CreateIfNotExists É um valor booliano para indicar se a

coleção será criada quando não existir.
O padrão é false porque as novas
coleções são criadas com a taxa de
transferência reservada, o que tem
implicações de preço. Para saber mais,
confira a página de preço.
partitionKey PartitionKey Quando CreateIfNotExists for true,

define o caminho da chave de partição
para a coleção criada.
collectionThroughput collectionThroughput Quando CreateIfNotExists for true,

define a taxa de transferência da
coleção criada.
conexão ConnectionStringSetting O nome da configuração do aplicativo

Azure Cosmos DB.
Saída - uso
Por padrão, quando você grava no parâmetro de saída em sua função, um documento é criado no banco de
dados. Este documento contém um GUID gerado automaticamente como a ID do documento. Você pode
especificar a ID do documento de saída especificando a propriedade id no objeto JSON enviado ao parâmetro
de saída.
NOTE
Ao especificar a ID de um documento existente, ela é substituída pelo novo documento de saída.

CosmosDB Códigos de erro CosmosDB
Próximas etapas
Saiba mais sobre a computação de banco de dados sem servidor com o Cosmos DB
Associações do Azure Cosmos DB para o Azure
Functions 2.x
Este artigo explica como trabalhar com associações do Azure Cosmos DB no Azure Functions 2.x. O Azure
Functions dá suporte a associações de gatilho, entrada e saída para o Azure Cosmos DB.
NOTE
Este artigo destina-se Azure Functions versão 2.x. Para obter informações sobre como usar essas associações em Functions
1. x, consulte Associações do Azure Cosmos DB para Azure Functions 1. x.
Essa associação era originalmente denominada DocumentDB. No Functions versão 2.x, o gatilho, associações e pacote são
chamados de Cosmos DB.
APIs com suporte

As associações do Azure Cosmos DB têm suporte apenas para usar com a API do SQL. Para todas as outras APIs
do Azure Cosmos DB, você deve acessar o banco de dados por meio da sua função usando o cliente estático da
API, incluindo a API do Azure Cosmos DB para MongoDB, a API do Cassandra, a API do Gremlin e a API de
Tabela.
As associações do Azure Cosmos DB para Functions versão 2.x são fornecidas no pacote NuGet
Microsoft.Azure.WebJobs.Extensions.CosmosDB, versão 3.x. O código-fonte para a associação está no repositório
GitHub azure-webjobs-sdk-extensions.


Python
Para saber como atualizar as extensões de associação existentes no portal sem precisar republicar o projeto de
aplicativo de funções, consulte Atualizar as extensões.
Gatilho
O Gatilho do Azure Cosmos DB usa o Feed de Alterações do Azure Cosmos DB para escutar as inserções e
atualizações nas partições. O feed de alteração publica inserções e atualizações, não exclusões.
Gatilho - exemplo
C#
Java
JavaScript
Python
O exemplo a seguir mostra uma função C# que é chamada quando há inserções ou atualizações na coleção e no
banco de dados especificados.
{
public static class CosmosTrigger
{
[FunctionName("CosmosTrigger")]
public static void Run([CosmosDBTrigger(
LeaseCollectionName = "leases",
CreateLeaseCollectionIfNotExists = true)]IReadOnlyList<Document> documents,
ILogger log)
{
if (documents != null && documents.Count > 0)
{
log.LogInformation($"Documents modified: {documents.Count}");
log.LogInformation($"First document Id: {documents[0].Id}");
}
}
}
}

O exemplo a seguir mostra uma associação de gatilho do Cosmos DB em um arquivo function.json e uma função
script C# que usa a associação. A função grava mensagens de log quando registros do Cosmos DB são
modificados.
{
"direction": "in",
}
#r "Microsoft.Azure.DocumentDB.Core"
using System;
public static void Run(IReadOnlyList<Document> documents, ILogger log)

{
log.LogInformation("Documents modified " + documents.Count);
log.LogInformation("First document Id " + documents[0].Id);
}

JavaScript que usa a associação. A função grava mensagens de log quando registros do Cosmos DB são
modificados.
{
"direction": "in",
}
module.exports = function (context, documents) {

context.log('First document Id modified : ', documents[0].id);
context.done();
}
Gatilho - exemplo de Java

Java que usa a associação. A função é envolvida quando há inserções ou atualizações na coleção e banco de
dados especificados.
{
"name": "items",
"direction": "in",
"connectionStringSetting": "AzureCosmosDBConnection",
"databaseName": "ToDoList",
"createLeaseCollectionIfNotExists": false
}
Aqui está o código Java:
@FunctionName("cosmosDBMonitor")
public void cosmosDbProcessor(
@CosmosDBTrigger(name = "items",
databaseName = "ToDoList",
collectionName = "Items",
leaseCollectionName = "leases",
createLeaseCollectionIfNotExists = true,
connectionStringSetting = "AzureCosmosDBConnection") String[] items,
final ExecutionContext context ) {
context.getLogger().info(items.length + "item(s) is/are changed.");
}
Na biblioteca de tempo de execução de funções Java, use a anotação @CosmosDBTrigger nos parâmetros cujo valor
seria proveniente do Cosmos DB. Esta anotação pode ser usada com tipos Java nativos, POJOs ou valores
anuláveis usando > opcional<T.
Gatilho – Exemplo do Python
Python que usa a associação. A função grava mensagens de log quando registros do Cosmos DB são
modificados.
{
"direction": "in",
}
import logging
def main(documents: func.DocumentList) -> str:

if documents:
logging.info('First document Id modified: %s', documents[0]['id'])
Gatilho – atributos de C#
Em bibliotecas de classes de C#, utilize o atributo CosmosDBTrigger.
essas configurações e outras propriedades que podem ser configuradas, consulte Gatilho – configurações. Aqui
está um exemplo de atributo CosmosDBTrigger em uma assinatura de método:
[FunctionName("DocumentUpdates")]
[CosmosDBTrigger("database", "collection", ConnectionStringSetting = "myCosmosDB")]
IReadOnlyList<Document> documents,
ILogger log)
{
...
}
A tabela a seguir explica as propriedades de configuração de associação que você definir no arquivo function.json
e o CosmosDBTrigger atributo.
tipo Deve ser definido como

cosmosDBTrigger .
direction Deve ser definido como in . Esse

quando você cria o gatilho no portal do
Azure.
name O nome da variável usado no código

de função que representa a lista de
documentos com alterações.
connectionStringSetting ConnectionStringSetting O nome de uma configuração de

conexão usada para conectar-se à
conta do Azure Cosmos DB que está
sendo monitorada.
databaseName DatabaseName O nome do banco de dados do Azure

Cosmos DB com a coleção que está
sendo monitorada.
collectionName CollectionName O nome da coleção que está sendo

monitorada.
leaseConnectionStringSetting LeaseConnectionStringSetting (Opcional) O nome de uma

configuração de aplicativo que contém
a cadeia de conexão para o serviço com
a coleção de concessão. Quando não
definido, o valor
connectionStringSetting é usado.
Esse parâmetro é definido
automaticamente quando a associação
é criada no portal. A cadeia de conexão
da coleção de concessões deve ter
permissões de gravação.
leaseDatabaseName LeaseDatabaseName (Opcional) O nome do banco de dados

que contém a coleção usada para
armazenar as concessões. Quando não
definido, o valor da configuração
databaseName é usado. Esse
quando a associação é criada no portal.
leaseCollectionName LeaseCollectionName (Opcional) O nome da coleção usada

para armazenar as concessões. Quando
não definido, o valor leases é usado.
createLeaseCollectionIfNotExists CreateLeaseCollectionIfNotExists (Opcional) Quando definido como

true , a coleção de concessões é
criada automaticamente quando ela
ainda não existe. O valor padrão é
false .
leasesCollectionThroughput leasesCollectionThroughput (Opcional) Define a quantidade de

Unidades de Solicitação a atribuir
quando a coleção de concessões for
criada. Essa configuração é usada
apenas quando
createLeaseCollectionIfNotExists
é definido como true . Esse parâmetro
é definido automaticamente quando a
associação é criada usando o portal.
leaseCollectionPrefix LeaseCollectionPrefix (Opcional) Quando definido, ele

adiciona um prefixo às concessões
criadas na coleção de Concessão para
esta Função, permitindo efetivamente
duas funções do Azure Functions
separadas para compartilhar a mesma
coleção de Concessão usando prefixos
diferentes.
feedPollDelay FeedPollDelay (Opcional) Quando definido, ele define,

em milissegundos, o atraso entre a
sondagem de uma partição quanto a
novas alterações no feed, depois que
todas as alterações atuais forem
descarregadas. O padrão é 5000 (5
segundos).
leaseAcquireInterval LeaseAcquireInterval (Opcional) Quando definido, ele define,

em milissegundos, o intervalo para
disparar uma tarefa para computar se
as partições são distribuídas
uniformemente entre as instâncias de
host conhecidas. O padrão é 13000 (13
segundos).
leaseExpirationInterval 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 deste intervalo, ela
será expirada e a propriedade da
partição será movida para outra
instância. O padrão é 60000 (60
segundos).
leaseRenewInterval LeaseRenewInterval (Opcional) Quando definido, ele define,

em milissegundos, o intervalo de
renovação para todas as concessões
para partições atualmente mantidas
por uma instância. O padrão é 17000
(17 segundos).
checkpointFrequency CheckpointFrequency (Opcional) Quando definido, ele define,

em milissegundos, o intervalo entre os
pontos de verificação de concessão. O
padrão é sempre após cada chamada
de Função.
maxItemsPerInvocation MaxItemsPerInvocation Adicional Quando definido, essa

propriedade define a quantidade
máxima de itens recebidos por
chamada de função. Se as operações na
coleção monitorada forem executadas
por meio de procedimentos
armazenados, o escopo da transação
será preservado durante a leitura de
itens do feed de alterações. Como
resultado disso, é possível que a
quantidade de itens recebidos seja
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 startFromBeginning Quando definido, ele informa o gatilho

para iniciar a leitura de alterações desde
o início do histórico de coleção em vez
da hora atual. Isso funciona apenas na
primeira vez em que gatilho inicia,
como em execuções subsequentes, os
pontos de verificação já estão
armazenados. Definir isso como true
quando houver concessões já criadas
não tem nenhum efeito.
Gatilho - uso
O gatilho requer uma segunda coleção que ele usa para armazenar concessões sobre as partições. Tanto a coleção
que está sendo monitorada quanto a coleção que contém as concessões devem estar disponíveis para o gatilho
funcionar.
IMPORTANT
Se várias funções estiverem configuradas para usar um gatilho do Cosmos DB para a mesma coleção, cada uma das funções
deverá usar uma coleção de concessões dedicada ou especificar uma diferente LeaseCollectionPrefix para cada função.
Caso contrário, apenas uma das funções será disparada. Para obter informações sobre o prefixo, veja a seção de
Configuração.
O gatilho não indica se um documento foi atualizado ou inserido, ele fornece apenas o documento em si. Se você
precisa lidar com inserções e atualizações de forma diferente, você pode fazer isso com a implementação de
campos de carimbo de hora de inserção ou atualização.
Entrada
A associação de dados de entrada do Azure Cosmos DB usa a API de SQL para recuperar um ou mais
documentos do Azure Cosmos DB e passá-los para o parâmetro de entrada da função. A ID do documento ou os
parâmetros de consulta podem ser determinados com base no gatilho que invoca a função.
Entrada – exemplos
Veja os exemplos específicos a um idioma que lê um documento especificando um valor de ID:
C#
F#
Java
JavaScript
Python
Entrada – exemplos em C#
{
{
}
}

Gatilho da fila, pesquisar ID no JSON (C#)
mensagem da fila que contém um objeto JSON. O gatilho da fila analisa o JSON em um objeto chamado
ToDoItemLookup , que contém a ID a pesquisar. Essa ID é usada para recuperar um documento ToDoItem no banco
de dados e na coleção especificados.
{
public class ToDoItemLookup
{
public string ToDoItemId { get; set; }
}
}
{
public static class DocByIdFromJSON
{
[FunctionName("DocByIdFromJSON")]
[QueueTrigger("todoqueueforlookup")] ToDoItemLookup toDoItemLookup,
[CosmosDB(
Id = "{ToDoItemId}")]ToDoItem toDoItem,
ILogger log)
{
log.LogInformation($"C# Queue trigger function processed Id={toDoItemLookup?.ToDoItemId}");
{
log.LogInformation($"ToDo item not found");
}
else
{
log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
}
}
}
}

Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta (C#)
solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a pesquisar. Essa ID é usada
para recuperar um documento ToDoItem no banco de dados e na coleção especificados.
NOTE
O parâmetro de cadeia de caracteres de consulta HTTP diferencia maiusculas de minúsculas.
{
public static class DocByIdFromQueryString
{
[FunctionName("DocByIdFromQueryString")]
public static IActionResult Run(
HttpRequest req,
[CosmosDB(
Id = "{Query.id}")] ToDoItem toDoItem,
ILogger log)
{
{
}
else
{
}
}
}
}

Gatilho HTTP, pesquisar ID nos dados da rota (C#)
{
public static class DocByIdFromRouteData
{
[FunctionName("DocByIdFromRouteData")]
Route = "todoitems/{id}")]HttpRequest req,
[CosmosDB(
Id = "{id}")] ToDoItem toDoItem,
ILogger log)
{
{
}
else
{
}
}
}
}

Gatilho HTTP, pesquisar ID nos dados da rota, usando SqlQuery (C#)
O exemplo mostra como usar uma expressão de associação no parâmetro SqlQuery . Você pode passar os dados
da rota para o parâmetro SqlQuery conforme mostrado, mas atualmente não é possível passar os valores da
cadeia de caracteres de consulta.
{
public static class DocByIdFromRouteDataUsingSqlQuery
{
[FunctionName("DocByIdFromRouteDataUsingSqlQuery")]
Route = "todoitems2/{id}")]HttpRequest req,
[CosmosDB("ToDoItems", "Items",
SqlQuery = "select * from ToDoItems r where r.id = {id}")]
ILogger log)
{

{
log.LogInformation(toDoItem.Description);
}
}
}
}

Gatilho HTTP, obter vários documentos, usando SqlQuery (C#)
O exemplo a seguir mostra uma função C# que recupera uma lista de documentos. A função é disparada por uma
solicitação HTTP. A consulta é especificada na propriedade do atributo SqlQuery .
{
public static class DocsBySqlQuery
{
[FunctionName("DocsBySqlQuery")]
HttpRequest req,
[CosmosDB(
SqlQuery = "SELECT top 2 * FROM c order by c._ts desc")]
ILogger log)
{
{
}
}
}
}

Gatilho HTTP, obter vários documentos, usando DocumentClient (C#)
O exemplo a seguir mostra uma função C# que recupera uma lista de documentos. A função é disparada por uma
solicitação HTTP. O código usa uma instância DocumentClient fornecida pela associação do Azure Cosmos DB
para ler uma lista de documentos. A instância DocumentClient também pode ser usada para as operações de
gravação.
NOTE
Você também pode usar a interface IDocumentClient para facilitar o teste.
using System;
using System.Linq;
{
public static class DocsByUsingDocumentClient
{
[FunctionName("DocsByUsingDocumentClient")]
Route = null)]HttpRequest req,
[CosmosDB(
ConnectionStringSetting = "CosmosDBConnection")] DocumentClient client,
ILogger log)
{
var searchterm = req.Query["searchterm"];

if (string.IsNullOrWhiteSpace(searchterm))
{
return (ActionResult)new NotFoundResult();
}
log.LogInformation($"Searching for: {searchterm}");

.AsDocumentQuery();
{
{
log.LogInformation(result.Description);
}
}
}
}
}

Entrada – exemplos de script C#
Gatilho da fila, pesquisar ID na cadeia de caracteres
Os exemplos de gatilho HTTP se referem a um tipo ToDoItem simples:
{
{
}
}

Gatilho da fila, pesquisar ID na cadeia de caracteres (script C#)
função script C# que usa a associação. A função lê um documento único e atualiza o valor de texto do documento.
{
"type": "cosmosDB",
"partitionKey": "{partition key value}",
"connectionStringSetting": "MyAccount_COSMOSDB",
"direction": "in"
}

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 da fila, obter vários documentos, usando SqlQuery (script C#)

{
"type": "cosmosDB",
"direction": "in",
"connectionStringSetting": "CosmosDBConnection"
}

public static void Run(QueuePayload myQueueItem, IEnumerable<dynamic> documents)

{
foreach (var doc in documents)
{
}
}
public class QueuePayload

{
public string departmentId { get; set; }
}

Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta (script C#)
por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a pesquisar. Essa ID
é usada para recuperar um documento ToDoItem no banco de dados e na coleção especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "toDoItem",
"connectionStringSetting": "CosmosDBConnection",
"direction": "in",
"Id": "{Query.id}"
}
],
"disabled": false
}
using System.Net;
public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)

{
{
}
else
{
}
}

Gatilho HTTP, pesquisar ID nos dados da rota (script C#)
por uma solicitação HTTP que usa os dados da rota para especificar a ID a pesquisar. Essa ID é usada para
recuperar um documento ToDoItem no banco de dados e na coleção especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
],
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "toDoItem",
"direction": "in",
"Id": "{id}"
}
],
"disabled": false
}
using System.Net;
public static HttpResponseMessage Run(HttpRequestMessage req, ToDoItem toDoItem, ILogger log)

{
{
}
else
{
}
}

Gatilho HTTP, obter vários documentos, usando SqlQuery (script C#)
O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é disparada
por uma solicitação HTTP. A consulta é especificada na propriedade do atributo SqlQuery .
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "toDoItems",
"direction": "in",
"sqlQuery": "SELECT top 2 * FROM c order by c._ts desc"
}
],
"disabled": false
}
using System.Net;
public static HttpResponseMessage Run(HttpRequestMessage req, IEnumerable<ToDoItem> toDoItems, ILogger log)

{

{
}
}

Gatilho HTTP, obter vários documentos, usando DocumentClient (script C#)
O exemplo a seguir mostra uma função de script C# que recupera uma lista de documentos. A função é disparada
por uma solicitação HTTP. O código usa uma instância DocumentClient fornecida pela associação do Azure
Cosmos DB para ler uma lista de documentos. A instância DocumentClient também pode ser usada para as
operações de gravação.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "client",
"direction": "inout"
}
],
"disabled": false
}

using System.Net;
public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, DocumentClient client, ILogger log)
{

.Value;
{
}
log.LogInformation($"Searching for word: {searchterm} using Uri: {collectionUri.ToString()}");

.AsDocumentQuery();
{
{
log.LogInformation(result.Description);
}
}
}

Entrada – exemplos de JavaScript
Esta seção contém os seguintes exemplos que leem um documento especificando um valor de ID de várias
fontes:
Gatilho da fila, pesquisar ID no JSON (JavaScript)
função JavaScript que usa a associação. A função lê um documento único e atualiza o valor de texto do
documento.
{
"name": "inputDocumentIn",
"type": "cosmosDB",
"direction": "in"
},
{
"name": "inputDocumentOut",
"type": "cosmosDB",
"direction": "out"
}

// Change input document contents using Azure Cosmos DB input binding, using
context.bindings.inputDocumentOut
context.bindings.inputDocumentOut = context.bindings.inputDocumentIn;
context.bindings.inputDocumentOut.text = "This was updated!";
context.done();
};

Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta (JavaScript)
especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "toDoItem",
"direction": "in",
"Id": "{Query.id}"
}
],
"disabled": false
}

if (!toDoItem)
{
}
else
{
}
context.done();
};

Gatilho HTTP, pesquisar ID nos dados da rota (JavaScript)
especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
],
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "toDoItem",
"direction": "in",
"Id": "{id}"
}
],
"disabled": false
}

if (!toDoItem)
{
}
else
{
}
context.done();
};

Gatilho da fila, obter vários documentos, usando SqlQuery (script javaScript)

{
"type": "cosmosDB",
"direction": "in",
}


var documents = context.bindings.documents;
for (var i = 0; i < documents.length; i++) {
var document = documents[i];
}
context.done();
};

Entrada – exemplos do Python
Esta seção contém os seguintes exemplos que leem um documento especificando um valor de ID de várias
fontes:
Gatilho da fila, pesquisar ID no JSON (Python )
função Python que usa a associação de dados. A função lê um documento único e atualiza o valor de texto do
documento.
{
"type": "cosmosDB",
"direction": "in"
},
{
"name": "$return",
"type": "cosmosDB",
"direction": "out"
}

def main(queuemsg: func.QueueMessage, documents: func.DocumentList) -> func.Document:

if documents:
document = documents[0]
document['text'] = 'This was updated!'
return document

Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta (Python )
O exemplo a seguir mostra uma função Python que recupera um único documento. A função é disparada por
uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a pesquisar. Essa ID é
usada para recuperar um documento ToDoItem no banco de dados e na coleção especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
]
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "todoitems",
"direction": "in",
"Id": "{Query.id}"
}
],
"disabled": true,
"scriptFile": "__init__.py"
}
import logging
def main(req: func.HttpRequest, todoitems: func.DocumentList) -> str:

if not todoitems:
logging.warning("ToDo item not found")
else:
logging.info("Found ToDo item, Description=%s",
todoitems[0]['description'])
return 'OK'

Gatilho HTTP, pesquisar ID nos dados da rota (Python )
O exemplo a seguir mostra uma função Python que recupera um único documento. A função é disparada por
uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a pesquisar. Essa ID é
usada para recuperar um documento ToDoItem no banco de dados e na coleção especificados.
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [
"get",
"post"
],
},
{
"name": "$return",
"type": "http",
"direction": "out"
},
{
"type": "cosmosDB",
"name": "todoitems",
"direction": "in",
"Id": "{id}"
}
],
"disabled": false,
}
import logging
def main(req: func.HttpRequest, todoitems: func.DocumentList) -> str:

if not todoitems:
logging.warning("ToDo item not found")
else:
logging.info("Found ToDo item, Description=%s",
todoitems[0]['description'])
return 'OK'

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

{
"type": "cosmosDB",
"direction": "in",
}

def main(queuemsg: func.QueueMessage, documents: func.DocumentList):

for document in documents:
# operate on each document

Entrada - exemplos de F#
função F# que usa a associação. A função lê um documento único e atualiza o valor de texto do documento.
{
"type": "cosmosDB",
"direction": "in"
}

(* Change input document contents using Azure Cosmos DB input binding *)

let Run(myQueueItem: string, inputDocument: obj) =
inputDocument?text <- "This has changed."

Dynamitey do NuGet:
{
"frameworks": {
"net46": {
"dependencies": {
}
}
}
}

Entrada - Exemplos Java
Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta - parâmetro cadeia de caracteres
Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta - parâmetro POJO
Gatilho HTTP, obter vários documentos dos dados da rota, usando SqlQuery
public class ToDoItem {
private String id;

private String description;
public String getId() {

return id;
}
public String getDescription() {

return description;
}
@Override
public String toString() {
return "ToDoItem={id=" + id + ",description=" + description + "}";
}
}
Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta - parâmetro cadeia de caracteres (Java)
O exemplo a seguir mostra uma função Java que recupera um único documento. A função é disparada por uma
solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a ser pesquisada. Essa ID é
usada para recuperar um documento no banco de dados e na coleção especificados, no formulário de cadeia de
caracteres.
public class DocByIdFromQueryString {
@FunctionName("DocByIdFromQueryString")
@HttpTrigger(name = "req",
methods = {HttpMethod.GET, HttpMethod.POST},
authLevel = AuthorizationLevel.ANONYMOUS)
@CosmosDBInput(name = "database",
id = "{Query.id}",
partitionKey = "{Query.id}",
connectionStringSetting = "Cosmos_DB_Connection_String")
Optional<String> item,
// Item list
context.getLogger().info("Parameters are: " + request.getQueryParameters());
context.getLogger().info("String from the database is " + (item.isPresent() ? item.get() : null));
// Convert and display

if (!item.isPresent()) {
return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
.body("Document not found.")
.build();
}
else {
// return JSON from Cosmos. Alternatively, we can parse the JSON string
// and return an enriched JSON object.
return request.createResponseBuilder(HttpStatus.OK)
.header("Content-Type", "application/json")
.body(item.get())
.build();
}
}
}
Na biblioteca de tempo de execução de funções Java, use a anotação @CosmosDBInput em parâmetros de função
cujo valor seria proveniente do Cosmos DB. Esta anotação pode ser usada com tipos Java nativos, POJOs ou
valores anuláveis usando > opcional<T.
Gatilho HTTP, pesquisar ID na cadeia de caracteres de consulta - parâmetro POJO (Java)
solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID a ser pesquisada. Essa ID é
usada para recuperar um documento no banco de dados e na coleção especificados. O documento é então
convertido em uma instância de ToDoItem POJO criado anteriormente e passada como um argumento para a
função.
public class DocByIdFromQueryStringPojo {
@FunctionName("DocByIdFromQueryStringPojo")
id = "{Query.id}",
partitionKey = "{Query.id}",
ToDoItem item,
// Item list
context.getLogger().info("Item from the database is " + item);

if (item == null) {
.build();
}
else {
.body(item)
.build();
}
}
}
Gatilho HTTP, pesquisar ID nos dados da rota (Java)

solicitação HTTP que usa um parâmetro de rota para especificar a ID a ser pesquisada. Essa ID é usada para
recuperar um documento no banco de dados e na coleção especificados, retornando-o como um
Optional<String> .
public class DocByIdFromRoute {
@FunctionName("DocByIdFromRoute")
authLevel = AuthorizationLevel.ANONYMOUS,
route = "todoitems/{id}")
id = "{id}",
partitionKey = "{id}",
Optional<String> item,
// Item list
context.getLogger().info("String from the database is " + (item.isPresent() ? item.get() : null));

if (!item.isPresent()) {
.build();
}
else {
// return JSON from Cosmos. Alternatively, we can parse the JSON string
// and return an enriched JSON object.
.body(item.get())
.build();
}
}
}
Gatilho HTTP, pesquisar ID nos dados da rota, usando SqlQuery (Java)

solicitação HTTP que usa um parâmetro de rota para especificar a ID a ser pesquisada. Essa ID é usada para
recuperar um documento da coleção e banco de dados especificado, converter o resultado definido como um
ToDoItem[] , já que muitos documentos podem ser retornados, dependendo dos critérios de consulta.
public class DocByIdFromRouteSqlQuery {
@FunctionName("DocByIdFromRouteSqlQuery")
route = "todoitems2/{id}")
sqlQuery = "select * from Items r where r.id = {id}",
ToDoItem[] item,
// Item list
context.getLogger().info("Items from the database are " + item);

if (item == null) {
.build();
}
else {
.body(item)
.build();
}
}
}
Gatilho HTTP, obter vários documentos dos dados da rota, usando SqlQuery (Java)
O exemplo a seguir mostra uma função Java para vários documentos. A função é disparada por uma solicitação
HTTP que usa um parâmetro de rota desc para especificar a cadeia de caracteres a ser pesquisada no campo
description . O termo de pesquisa é usado para recuperar uma coleção de documentos do banco de dados e
coleção especificados, convertendo o conjunto de resultados para um ToDoItem[] e passando-o como um
argumento para a função.
public class DocsFromRouteSqlQuery {
@FunctionName("DocsFromRouteSqlQuery")
methods = {HttpMethod.GET},
route = "todoitems3/{desc}")
sqlQuery = "select * from Items r where contains(r.description, {desc})",
ToDoItem[] items,
// Item list
context.getLogger().info("Number of items from the database is " + (items == null ? 0 :
items.length));

if (items == null) {
.body("No documents found.")
.build();
}
else {
.body(items)
.build();
}
}
}
Em Bibliotecas de classes C#, utilize o atributo CosmosDB.
essas configurações e outras propriedades que podem ser configuradas, consulte a seção de configuração a
seguir.
e o CosmosDB atributo.
tipo Deve ser definido como cosmosDB .

databaseName DatabaseName O banco de dados que contém o

documento.
collectionName CollectionName O nome da coleção que contém o

documento.
ID Id A ID do documento a ser recuperado.

Essa propriedade dá suporte a
expressões de associação. Não defina
ambas as propriedades id e sqlQuery.
Se você não definir uma ou outra, toda
a coleção é recuperada.
sqlQuery SqlQuery Uma consulta SQL do Azure Cosmos

DB usada para recuperar vários
documentos. A propriedade dá suporte
a associações de tempo de execução,
como neste exemplo:
SELECT * FROM c where
c.departmentId = {departmentId}
. Não defina ambas as propriedades id
e sqlQuery. Se você não definir uma
ou outra, toda a coleção é recuperada.
connectionStringSetting ConnectionStringSetting O nome da configuração do aplicativo

Azure Cosmos DB.
partitionKey PartitionKey Especifica o valor da chave de partição

para a pesquisa. Pode incluir
parâmetros de associação.
Entrada - uso
Em funções C# e F#, todas as alterações feitas no documento de entrada por parâmetros de entrada nomeados
são persistidas automaticamente.
Funções de JavaScript, as atualizações não são feitas automaticamente após a saída da função. Em vez disso, use
context.bindings.<documentName>In e context.bindings.<documentName>Out para fazer atualizações. Confira o
exemplo de JavaScript.
Saída
Com a associação de saída do Azure Cosmos DB, você pode gravar um novo documento para um banco de
dados do Azure Cosmos DB usando a API de SQL.
Saída – exemplos
Consulte os exemplos específicos a um idioma:
C#
F#
Java
JavaScript
Python
Consulte também o exemplo de entrada que usa DocumentClient .
Saída - exemplos C#
{
{
}
}

Gatilho da fila, gravar um documento (C#)
O exemplo a seguir mostra uma função C# que adiciona um documento a um banco de dados, usando os dados
fornecidos na mensagem do armazenamento de fila.
using System;
{
public static class WriteOneDoc
{
[FunctionName("WriteOneDoc")]
[QueueTrigger("todoqueueforwrite")] string queueMessage,
[CosmosDB(
ConnectionStringSetting = "CosmosDBConnection")]out dynamic document,
ILogger log)
{
document = new { Description = queueMessage, id = Guid.NewGuid() };
log.LogInformation($"C# Queue trigger function inserted one row");

log.LogInformation($"Description={queueMessage}");
}
}
}

Gatilho da fila, gravar documentos usando IAsyncCollector (C#)
O exemplo a seguir mostra uma função C# que adiciona uma coleção de documentos a um banco de dados,
usando os dados fornecidos em um JSON de mensagem da fila.
{
public static class WriteDocsIAsyncCollector
{
[FunctionName("WriteDocsIAsyncCollector")]
[QueueTrigger("todoqueueforwritemulti")] ToDoItem[] toDoItemsIn,
[CosmosDB(
ConnectionStringSetting = "CosmosDBConnection")]
IAsyncCollector<ToDoItem> toDoItemsOut,
ILogger log)
{
log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

{
log.LogInformation($"Description={toDoItem.Description}");
}
}
}
}

Saída – exemplos de script C#
Gatilho da fila, gravar um documento (script C#)
{
}
{
}
{
"type": "cosmosDB",
"direction": "out"
}

public static void Run(string myQueueItem, out object employeeDocument, ILogger log)
{
dynamic employee = JObject.Parse(myQueueItem);
employeeDocument = new {
id = employee.name + "-" + employee.employeeId,
name = employee.name,
employeeId = employee.employeeId,
address = employee.address
};
}

Para criar vários documentos, você também pode associar a ICollector<T> ou IAsyncCollector<T> , sendo T um
dos tipos com suporte.
Este exemplo se refere a um tipo ToDoItem simples:
{
{
}
}

{
"bindings": [
{
"name": "toDoItemsIn",
"direction": "in",
"queueName": "todoqueueforwritemulti",
"connectionStringSetting": "AzureWebJobsStorage"
},
{
"type": "cosmosDB",
"name": "toDoItemsOut",
"direction": "out"
}
],
"disabled": false
}
using System;
public static async Task Run(ToDoItem[] toDoItemsIn, IAsyncCollector<ToDoItem> toDoItemsOut, ILogger log)
{
log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

{
log.LogInformation($"Description={toDoItem.Description}");
}
}

Saída – exemplos de JavaScript
{
}
{
}

{
"type": "cosmosDB",
"direction": "out"
}

context.bindings.employeeDocument = JSON.stringify({
id: context.bindings.myQueueItem.name + "-" + context.bindings.myQueueItem.employeeId,
name: context.bindings.myQueueItem.name,
employeeId: context.bindings.myQueueItem.employeeId,
address: context.bindings.myQueueItem.address
});
context.done();
};

Saída – exemplos de F#
{
}
{
}

{
"type": "cosmosDB",
"direction": "out"
}

open Newtonsoft.Json
type Employee = {
id: string
name: string
employeeId: string
address: string
}
let Run(myQueueItem: string, employeeDocument: byref<obj>, log: ILogger) =

log.LogInformation(sprintf "F# Queue trigger function processed: %s" myQueueItem)
let employee = JObject.Parse(myQueueItem)
employeeDocument <-
{ id = sprintf "%s-%s" employee?name employee?employeeId
name = employee?name
employeeId = employee?employeeId
address = employee?address }

Dynamitey do NuGet:
{
"frameworks": {
"net46": {
"dependencies": {
}
}
}
}

Saída - Exemplo Java
Gatilho de fila, salva a mensagem ao banco de dados por meio do valor de retorno
Gatilho HTTP, salva um documento ao banco de dados por meio do valor de retorno
Gatilho HTTP, salva um documento ao banco de dados por meio do valor de OutputBinding
Gatilho HTTP, salva vários documentos ao banco de dados por meio do valor de OutputBinding
Gatilho de fila, salva a mensagem ao banco de dados por meio do valor de retorno (Java)
O exemplo a seguir mostra uma função Java que adiciona um documento a um banco de dados com dados de
uma mensagem no armazenamento de Filas.
@FunctionName("getItem")
@CosmosDBOutput(name = "database",
connectionStringSetting = "AzureCosmosDBConnection")
public String cosmosDbQueryById(
@QueueTrigger(name = "msg",
queueName = "myqueue-items",
connection = "AzureWebJobsStorage")
String message,
return "{ id: \"" + System.currentTimeMillis() + "\", Description: " + message + " }";
}
Gatilho HTTP, salva um documento ao banco de dados por meio do valor de retorno (Java)
O exemplo a seguir mostra uma função de Java cuja assinatura é anotada com @CosmosDBOutput e tem o valor
retornado do tipo String . O documento JSON retornado pela função será gravado automaticamente à coleção
do CosmosDB correspondente.
@FunctionName("WriteOneDoc")
public String run(
// Item list

String query = request.getQueryParameters().get("desc");
// Generate random ID
final int id = Math.abs(new Random().nextInt());
// Generate document
final String jsonDocument = "{\"id\":\"" + id + "\", " +
"\"description\": \"" + name + "\"}";
context.getLogger().info("Document to be saved: " + jsonDocument);
return jsonDocument;
}
Gatilho HTTP, salva um documento ao banco de dados por meio do valor de OutputBinding (Java)
O exemplo a seguir mostra uma função de Java que grava um documento do CosmosDB por meio de um
parâmetro de saída OutputBinding<T> . Observe que, nessa configuração, é o parâmetro outputItem que precisa
ser anotado com @CosmosDBOutput , não a assinatura de função. Usando OutputBinding<T> permite que sua função
tire proveito da associação para gravar o documento para CosmosDB, permitindo também retornar um valor
diferente para o chamador da função, como um documento XML ou JSON.
@FunctionName("WriteOneDocOutputBinding")
OutputBinding<String> outputItem,

// Item list
// Generate document
final String jsonDocument = "{\"id\":\"" + id + "\", " +
"\"description\": \"" + name + "\"}";
context.getLogger().info("Document to be saved: " + jsonDocument);
// Set outputItem's value to the JSON document to be saved

outputItem.setValue(jsonDocument);
// return a different document to the browser or calling client.

.body("Document created successfully.")
.build();
}
Gatilho HTTP, salva vários documentos ao banco de dados por meio do valor de OutputBinding (Java)
O exemplo a seguir mostra uma função de Java que grava vários documentos do CosmosDB por meio de um
parâmetro de saída OutputBinding<T> . Observe que, nessa configuração, é o parâmetro outputItem que precisa
ser anotado com @CosmosDBOutput , não a assinatura de função. O parâmetro de saída outputItem tem uma lista
de objetos ToDoItem como seu tipo de parâmetro de modelo. Usando OutputBinding<T> permite que sua função
tire proveito da associação para gravar os documentos para CosmosDB, permitindo também retornar um valor
diferente para o chamador da função, como um documento XML ou JSON.
@FunctionName("WriteMultipleDocsOutputBinding")
OutputBinding<List<ToDoItem>> outputItem,

// Item list
// Generate documents
List<ToDoItem> items = new ArrayList<>();
for (int i = 0; i < 5; i ++) {

// Create ToDoItem
ToDoItem item = new ToDoItem(String.valueOf(id), name);
items.add(item);
}
// Set outputItem's value to the list of POJOs to be saved

outputItem.setValue(items);
context.getLogger().info("Document to be saved: " + items);
// return a different document to the browser or calling client.

.body("Documents created successfully.")
.build();
}
Na biblioteca de tempo de execução das funções Java, use a anotação @CosmosDBOutput nos parâmetros que serão
gravados no Cosmos DB. O tipo de parâmetro de anotação deve ser OutputBinding<T> , em que T é um tipo Java
nativo ou um POJO.
Saída-exemplos do Python
O exemplo a seguir demonstra como gravar um documento em um banco de dados CosmosDB do Azure como a
saída de uma função.
A definição de associação é definida em Function. JSON , em que Type é definido como cosmosDB .
{
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "cosmosDB",
"direction": "out",
"name": "doc",
"databaseName": "demodb",
"collectionName": "data",
"createIfNotExists": "true",
"connectionStringSetting": "AzureCosmosDBConnectionString"
},
{
"type": "http",
"direction": "out",
"name": "$return"
}
]
}
Para gravar no banco de dados, passe um objeto Document para o método set do parâmetro Database.
def main(req: func.HttpRequest, doc: func.Out[func.Document]) -> func.HttpResponse:
request_body = req.get_body()
doc.set(func.Document.from_json(request_body))
return 'OK'
Saída - atributos
Em Bibliotecas de classes C#, utilize o atributo CosmosDB.
essas configurações e outras propriedades que podem ser configuradas, consulte Saída – configurações. Aqui
está um exemplo de atributo CosmosDB em uma assinatura de método:
[FunctionName("QueueToDocDB")]
[CosmosDB("ToDoList", "Items", Id = "id", ConnectionStringSetting = "myCosmosDB")] out dynamic
document)
{
...
}
Para ver um exemplo completo, confira Saída - exemplo de C#.

e o CosmosDB atributo.
tipo Deve ser definido como cosmosDB .

databaseName DatabaseName O banco de dados que contém a

coleção na qual o documento será
criado.
collectionName CollectionName O nome da coleção na qual o

documento será criado.
createIfNotExists CreateIfNotExists É um valor booliano para indicar se a

coleção será criada quando não existir.
O padrão é false porque as novas
coleções são criadas com a taxa de
transferência reservada, o que tem
implicações de preço. Para saber mais,
confira a página de preço.
partitionKey PartitionKey Quando CreateIfNotExists for true,

define o caminho da chave de partição
para a coleção criada.
CollectionThroughput CollectionThroughput Quando CreateIfNotExists for true,

define a taxa de transferência da
coleção criada.

Azure Cosmos DB.
Saída - uso
Por padrão, quando você grava no parâmetro de saída em sua função, um documento é criado no banco de
dados. Este documento contém um GUID gerado automaticamente como a ID do documento. Você pode
especificar a ID do documento de saída especificando a propriedade id no objeto JSON enviado ao parâmetro
de saída.
NOTE
Ao especificar a ID de um documento existente, ela é substituída pelo novo documento de saída.
CosmosDB Códigos de erro CosmosDB
configurações de host.json
Esta seção descreve as definições de configuração globais disponíveis para esta associação na versão 2.x. Para
obter mais informações sobre as configurações globais na versão 2.x, confira a referência de host.json para o
Azure Functions versão 2.x.
{
"version": "2.0",
"extensions": {
"cosmosDB": {
"connectionMode": "Gateway",
"protocol": "Https",
"leaseOptions": {
"leasePrefix": "prefix1"
}
}
}
}
PROPRIEDADE PADRÃO DESCRIÇÃO
GatewayMode Gateway O modo de conexão usado pela função

ao se conectar ao serviço do Azure
Cosmos DB. As opções são Direct e
Gateway
Protocolo Https O protocolo de conexão usado pela

função ao se conectar ao serviço do
Azure Cosmos DB. Leia aqui para obter
uma explicação de ambos os modos
leasePrefix N/D Prefixo de concessão a ser usado em

todas as funções em um aplicativo.
Próximas etapas
Saiba mais sobre a computação de banco de dados sem servidor com o Cosmos DB
Gatilho de Grade de Eventos para o Azure
Functions
Este artigo explica como manipular com eventos de Grade de Eventos no Azure Functions.
A Grade de Eventos é um serviço do Azure que envia solicitações HTTP para notificá-lo sobre eventos que
acontecem nos publicadores. Um publicador é o serviço ou recurso que origina o evento. Por exemplo, uma
conta de armazenamento de Blobs do Azure é um publicador, e uma exclusão ou upload de blob é um evento.
Alguns serviços do Azure têm suporte interno para publicar eventos na Grade de Eventos .
Os manipuladores de eventos recebem e processam eventos. O Azure Functions é um dos vários serviços
doAzure que possuem suporte interno para manipular eventos da Grande de Eventos. Neste artigo, você
aprende a usar um gatilho de Grade de Eventos para invocar uma função quando um evento é recebido da
Grade de Eventos.
Se você preferir, é possível utilizar um gatilho HTTP para manipular eventos da Grade de Eventos, consultado
Usar um gatilho HTTP como um gatilho de Grade de Eventos, posteriormente neste artigo. No momento, não é
possível usar um gatilho da Grade de Eventos para um aplicativo do Azure Functions quando o evento é
entregue no esquema CloudEvents. Em vez disso, use um gatilho HTTP.
O gatilho de grade de eventos é fornecido no Microsoft.Azure.WebJobs.Extensions.EventGrid pacote NuGet,
versão 2. x. O código-fonte do pacote está no repositório GitHub azure-functions-eventgrid-extension.


Python
Pacotes – Functions 1.x
O gatilho de grade de eventos é fornecido no Microsoft.Azure.WebJobs.Extensions.EventGrid pacote NuGet,
versão 1. x. O código-fonte do pacote está no repositório GitHub azure-functions-eventgrid-extension.

Exemplo
Consulte o exemplo específico do idioma para um gatilho de Grade de Eventos:
C#
Java
JavaScript
Python
Para um exemplo de gatilho HTTP, consulte Como usar o gatilho HTTP, posteriormente neste artigo.
C# (2.x)
O exemplo a seguir mostra um funções 2. x função C# que associa a EventGridEvent :
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
namespace Company.Function
{
public static class EventGridTriggerCSharp
{
[FunctionName("EventGridTest")]
public static void EventGridTest([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
{
log.LogInformation(eventGridEvent.Data.ToString());
}
}
}
Para obter mais informações, confira Pacotes, Atributos, Configuração e Uso.

C# (Versão 1.x)
O exemplo a seguir mostra um funções 1. x função C# que associa a JObject :
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
namespace Company.Function
{
public static class EventGridTriggerCSharp
{
[FunctionName("EventGridTriggerCSharp")]
public static void Run([EventGridTrigger]JObject eventGridEvent, ILogger log)
{
log.LogInformation(eventGridEvent.ToString(Formatting.Indented));
}
}
}
O exemplo a seguir mostra uma associação de gatilho em um arquivo function.json e uma função de script de
C# que usa a associação.
{
"bindings": [
{
"type": "eventGridTrigger",
"name": "eventGridEvent",
"direction": "in"
}
],
"disabled": false
}
Script C# (Versão 2.x )

Aqui está o código de script de 2. x C# funções que associa a EventGridEvent :
#r "Microsoft.Azure.EventGrid"
using Microsoft.Azure.EventGrid.Models;
public static void Run(EventGridEvent eventGridEvent, ILogger log)

{
log.LogInformation(eventGridEvent.Data.ToString());
}
Para obter mais informações, confira Pacotes, Atributos, Configuração e Uso.

Script C# (Versão 1.x )
Aqui está o código de script de 1. x C# funções que associa a JObject :
public static void Run(JObject eventGridEvent, TraceWriter log)

{
log.Info(eventGridEvent.ToString(Formatting.Indented));
}
O exemplo a seguir mostra uma associação de gatilho em um arquivo function.json e uma função JavaScript
que usa a associação.
{
"bindings": [
{
"direction": "in"
}
],
"disabled": false
}
module.exports = function (context, eventGridEvent) {

context.log("JavaScript Event Grid function processed a request.");
context.log("Subject: " + eventGridEvent.subject);
context.log("Time: " + eventGridEvent.eventTime);
context.log("Data: " + JSON.stringify(eventGridEvent.data));
context.done();
};
Exemplo de Python
O exemplo a seguir mostra uma associação de gatilho em um arquivo function.json e uma função Python que
usa a associação.
{
"bindings": [
{
"name": "event",
"direction": "in"
}
],
"disabled": false,
}
Confira o código Python:

import logging
def main(event: func.EventGridEvent):

logging.info("Python Event Grid function processed a request.")
logging.info(" Subject: %s", event.subject)
logging.info(" Time: %s", event.event_time)
logging.info(" Data: %s", event.get_json())
Gatilho - exemplos Java

Gatilho de grade de eventos, parâmetro de cadeia de caracteres
Gatilho de grade de eventos, parâmetro POJO
Os exemplos a seguir mostram a associação de gatilho em um arquivo function.JSON e funções Java que usam
a associação e imprimem um evento, primeiro recebendo o evento como String e o segundo como um POJO.
{
"bindings": [
{
"direction": "in"
}
]
}
Gatilho de grade de eventos, parâmetro de cadeia de caracteres (Java)
@FunctionName("eventGridMonitorString")
public void logEvent(
@EventGridTrigger(
name = "event"
)
String content,
context.getLogger().info("Event content: " + content);
}
Gatilho de grade de eventos, parâmetro POJO (Java)

Este exemplo usa o POJO a seguir, que representa as propriedades de nível superior de uma grade de eventos:
import java.util.Date;
import java.util.Map;
public class EventSchema {
public String topic;

public String subject;
public String eventType;
public Date eventTime;
public String id;
public String dataVersion;
public String metadataVersion;
public Map<String, Object> data;
}
Na chegada, o conteúdo JSON do evento fica sem serialização no POJO EventSchema para uso pela função.
Isso permite que a função acesse as propriedades do evento de forma orientada a objeto.
@FunctionName("eventGridMonitor")
public void logEvent(
@EventGridTrigger(
name = "event"
)
EventSchema event,
context.getLogger().info("Event content: ");
context.getLogger().info("Subject: " + event.subject);
context.getLogger().info("Time: " + event.eventTime); // automatically converted to Date by the
runtime
context.getLogger().info("Id: " + event.id);
context.getLogger().info("Data: " + event.data);
}
No biblioteca de tempo de execução de funções Java, use o EventGridTrigger anotação em parâmetros cujo
valor virá do EventGrid. Parâmetros com essas anotações fazem com que a função seja executada quando um
evento é recebido. Essa anotação pode ser usada com tipos nativos do Java, POJOs ou valores que permitem
valor nulos usando Optional<T> .
Atributos
Em bibliotecas de classes de C#, utilize o atributo EventGridTrigger.
Aqui está um atributo EventGridTrigger em uma assinatura de método:
[FunctionName("EventGridTest")]
public static void EventGridTest([EventGridTrigger] JObject eventGridEvent, ILogger log)
{
...
}
Para ver um exemplo completo, confira o exemplo de C#.
Configuração
function.json. Não há parâmetros ou propriedades do construtor para definir o atributo EventGridTrigger .
PROPRIEDADE FUNCTION.JSON DESCRIÇÃO
tipo Obrigatório – deve ser definido como eventGridTrigger .
direction Obrigatório – deve ser definido como in .
name Obrigatório - o nome da variável usado no código de função

para o parâmetro que recebe os dados de eventos.
Uso
Para C# e F# funções no Azure funciona 1. x, você pode usar os seguintes tipos de parâmetro para o disparador
de grade de eventos:
JObject
string
Para C# e F# funções nas funções do Azure 2. x, você também tem a opção de usar o seguinte tipo de
parâmetro para o disparador de grade de eventos:
Microsoft.Azure.EventGrid.Models.EventGridEvent - Define propriedades para os campos comuns a todos os
tipos de eventos.
NOTE
Em funções v1 se você tentar associar ao Microsoft.Azure.WebJobs.Extensions.EventGrid.EventGridEvent , o
compilador exibirá uma mensagem "substituído" e avisá-lo para usar
Microsoft.Azure.EventGrid.Models.EventGridEvent em vez disso. Para usar o tipo mais recente, fazer referência a
Microsoft.Azure.EventGrid NuGet empacotar e qualificar totalmente o EventGridEvent nome do tipo, prefixando-o com
Microsoft.Azure.EventGrid.Models . Para obter informações sobre como fazer referência a pacotes do NuGet em uma
função de script C#, consulte pacotes usando o NuGet
Para funções JavaScript, o parâmetro nomeado pela propriedade function.json name tem uma referência ao
objeto de evento.
Esquema do evento
Os dados de uma Grade de Eventos são recebidos como um objeto JSON no corpo de uma solicitação HTTP. O
JSON é semelhante ao exemplo a seguir:
[{
"topic":
"/subscriptions/{subscriptionid}/resourceGroups/eg0122/providers/Microsoft.Storage/storageAccounts/egblobsto
re",
"subject": "/blobServices/default/containers/{containername}/blobs/blobname.jpg",
"eventType": "Microsoft.Storage.BlobCreated",
"eventTime": "2018-01-23T17:02:19.6069787Z",
"id": "{guid}",
"data": {
"api": "PutBlockList",
"clientRequestId": "{guid}",
"requestId": "{guid}",
"eTag": "0x8D562831044DDD0",
"contentType": "application/octet-stream",
"contentLength": 2248,
"blobType": "BlockBlob",
"url": "https://egblobstore.blob.core.windows.net/{containername}/blobname.jpg",
"sequencer": "000000000000272D000000000003D60F",
"storageDiagnostics": {
"batchId": "{guid}"
}
},
"dataVersion": "",
"metadataVersion": "1"
}]
O exemplo mostrado é uma matriz de um elemento. A Grade de Eventos envia sempre uma matriz e pode
enviar mais de um evento na matriz. O runtime invoca sua função uma vez para cada elemento da matriz.
As propriedades de nível superior nos dados JSON de evento serão as mesmas entre todos os tipos de eventos,
enquanto os conteúdos da propriedade data estiverem especificados para cada tipo de evento. O exemplo
mostrado é para um evento de armazenamento de Blobs.
Para obter explicações sobre as propriedades comuns e específicas de evento, consulte Propriedades do evento
na documentação da Grade de Eventos.
O tipo EventGridEvent define apenas as propriedades de nível superior; a propriedade Data é um JObject .
Criar uma assinatura

Para iniciar o recebimento de solicitações HTTP de Grade de Eventos, crie uma assinatura na Grade de Eventos
que especifique a URL do ponto de extremidade que invoca a função.
Portal do Azure
Para as funções que você desenvolve no Portal do Azure com o gatilho de Grade de Eventos, selecione
Adicionar assinatura da Grade de Eventos.
Ao selecionar esse link, o portal abrirá a página Criar Assinatura de Evento com a URL do ponto de
extremidade preenchida.
Para obter mais informações sobre como criar assinaturas usando o Portal do Azure, consulte Criar evento
personalizado - Portal do Azure na documentação da Grade de Eventos.
Azure CLI
Para criar uma assinatura usando a CLI do Azure, use o comando az eventgrid event-subscription create.
O comando requer a URL do ponto de extremidade que invoca a função. O exemplo a seguir mostra o padrão
de URL específico da versão:
runtime versão 2.x
https://{functionappname}.azurewebsites.net/runtime/webhooks/eventgrid?functionName={functionname}&code=
{systemkey}
runtime versão 1.x

https://{functionappname}.azurewebsites.net/admin/extensions/EventGridExtensionConfig?functionName=
{functionname}&code={systemkey}
A chave do sistema é uma chave de autorização que deve ser incluída na URL do ponto de extremidade para
um gatilho de Grade de Eventos. A seção a seguir explica como obter a chave do sistema.
Apresentamos aqui um exemplo que assina em uma conta de armazenamento de Blobs (com um espaço
reservado para a chave do sistema):
runtime versão 2.x
az eventgrid resource event-subscription create -g myResourceGroup \

--provider-namespace Microsoft.Storage --resource-type storageAccounts \
--resource-name myblobstorage12345 --name myFuncSub \
--included-event-types Microsoft.Storage.BlobCreated \
--subject-begins-with /blobServices/default/containers/images/blobs/ \
--endpoint https://mystoragetriggeredfunction.azurewebsites.net/runtime/webhooks/eventgrid?
functionName=imageresizefunc&code=<key>
runtime versão 1.x
az eventgrid resource event-subscription create -g myResourceGroup \

--provider-namespace Microsoft.Storage --resource-type storageAccounts \
--resource-name myblobstorage12345 --name myFuncSub \
--included-event-types Microsoft.Storage.BlobCreated \
--subject-begins-with /blobServices/default/containers/images/blobs/ \
--endpoint https://mystoragetriggeredfunction.azurewebsites.net/admin/extensions/EventGridExtensionConfig?
functionName=imageresizefunc&code=<key>
Para obter mais informações sobre como criar uma assinatura, consulte o Guia de início rápido do
armazenamento de blobs ou outros guias de início rápido da Grade de Eventos.
Obter a chave do sistema
Você pode obter a chave do sistema usando a seguinte API (HTTP GET):
runtime versão 2.x
http://{functionappname}.azurewebsites.net/admin/host/systemkeys/eventgrid_extension?code={masterkey}
runtime versão 1.x
http://{functionappname}.azurewebsites.net/admin/host/systemkeys/eventgridextensionconfig_extension?code=
{masterkey}
Esta é uma API de administração, por isso, requer sua chave mestre do aplicativo. Não confunda a chave do
sistema (para invocar uma função de gatilho de grade de eventos) com a chave mestra (para executar tarefas
administrativas no aplicativo de funções). Ao assinar em um tópico da Grade de Eventos, certifique-se de usar a
chave do sistema.
Aqui, está um exemplo da resposta que fornece a chave do sistema:
{
"name": "eventgridextensionconfig_extension",
"value": "{the system key for the function}",
"links": [
{
"rel": "self",
"href": "{the URL for the function, without the system key}"
}
]
}
Você pode obter a chave mestra para seu aplicativo de função na guia Configurações do aplicativo de
função no portal.
IMPORTANT
A chave mestra fornece acesso de administrador para seu aplicativo de funções. Não compartilhe essa chave com
terceiros ou distribua-a em aplicativos clientes nativos.
Para obter mais informações, consulte Chaves de autorização no artigo de referência de gatilho HTTP.
Como alternativa, você mesmo pode enviar uma HTTP PUT para especificar o valor da chave.
Teste local com o aplicativo Web visualizador

Para testar um gatilho de Grade de Eventos localmente, você deve receber solicitações HTTP de Grade de
Eventos entre suas origens na nuvem para sua máquina local. Uma maneira de fazer isso é capturar solicitações
online e manualmente reenviá-las em sua máquina local:
1. Criar um aplicativo Web visualizador que captura as mensagens de evento.
2. Criar uma assinatura da Grade de Eventos que envia eventos para o aplicativo visualizador.
3. Gerar uma solicitação e copiar o corpo da solicitação do aplicativo visualizador.
4. Postar manualmente a solicitação para a URL localhost da sua função de gatilho da Grade de Eventos.
Quando terminar de testar, você poderá usar a mesma assinatura para a produção atualizando o ponto de
extremidade. Use o comando da CLI do Azureaz eventgrid event-subscription update.
Criar um aplicativo Web visualizador
Para simplificar as mensagens de evento de captura, implante um aplicativo Web predefinido que exibe as
mensagens de evento. A solução implantada inclui um plano do Serviço de Aplicativo, um aplicativo Web do
Aplicativo do Serviço de e o código-fonte do GitHub.
Selecione Implantar no Azure para implantar a solução na sua assinatura. No portal do Azure, forneça os
valores para os parâmetros.
A implantação pode levar alguns minutos para ser concluída. Depois que a implantação for bem-sucedida, exiba
seu aplicativo Web para garantir que ele esteja em execução. Em um navegador da Web, navegue até:
https://<your-site-name>.azurewebsites.net
Você verá o site, mas nenhum evento ainda estará publicado.

Criar uma assinatura na Grade de Eventos
Crie uma assinatura da Grade de Eventos do tipo que você deseja testar e forneça a ela a URL do aplicativo
Web como o ponto de extremidade para a notificação de eventos. O ponto de extremidade para seu aplicativo
Web deve incluir o sufixo /api/updates/ . Portanto, a URL completa é
https://<your-site-name>.azurewebsites.net/api/updates
Para obter mais informações sobre como criar assinaturas usando o portal do Azure, confira Criar um evento
personalizado – portal do Azure na documentação da Grade de Eventos.
Gerar uma solicitação
Dispare um evento que gerará tráfego HTTP para o ponto de extremidade do aplicativo Web. Por exemplo, se
você criou uma assinatura de armazenamento de Blobs, faça upload ou exclua um blob. Quando uma
solicitação for exibida no aplicativo Web, copie o corpo da solicitação.
A solicitação de validação de assinatura será recebida primeiro. Ignore quaisquer solicitações de validação e
copie a solicitação de evento.
Postar manualmente a solicitação

Execute sua função de Grade de Eventos localmente.
Use uma ferramenta como Postman ou curl para criar uma solicitação HTTP POST:
Defina um cabeçalho Content-Type: application/json .
Defina um cabeçalho aeg-event-type: Notification .
Cole os dados RequestBin no corpo da solicitação.
Poste para a URL da sua função de gatilho de grade de eventos.
Para 2. x, use o seguinte padrão:
http://localhost:7071/runtime/webhooks/eventgrid?functionName={FUNCTION_NAME}
Para uso de 1. x:
http://localhost:7071/admin/extensions/EventGridExtensionConfig?functionName={FUNCTION_NAME}
O parâmetro functionName deverá ser o nome especificado no atributo FunctionName .

As capturas de tela a seguir mostram os cabeçalhos e o corpo da solicitação em Postman:
A função de gatilho da Grade de Eventos executa e mostra logs semelhantes ao exemplo a seguir:
Teste local com ngrok
Outra maneira de testar um gatilho de Grade de Eventos localmente é automatizar a conexão HTTP entre a
Internet e o computador de desenvolvimento. Você pode fazer isso com uma ferramenta como ngrok:
1. Criar um ponto de extremidade ngrok.
2. Executar a função de gatilho de Grade de Eventos .
3. Criar uma assinatura na Grade de Eventos que envia eventos para o ponto de extremidade ngrok.
4. Disparar um evento.
Quando terminar de testar, você poderá usar a mesma assinatura para a produção atualizando o ponto de
extremidade. Use o comando da CLI do Azureaz eventgrid event-subscription update.
Criar um ponto de extremidade ngrok
Faça o download do ngrok.exe do ngrok e execute com o seguinte comando:
ngrok http -host-header=localhost 7071
O parâmetro -host-header é necessário porque o runtime das funções espera solicitações do localhost quando é
executado no localhost. 7071 é o número de porta padrão quando o runtime é executado localmente.
O comando cria saída semelhante à seguinte:
Session Status online

Version 2.2.8
Region United States (us)
Web Interface http://127.0.0.1:4040
Forwarding http://263db807.ngrok.io -> localhost:7071
Forwarding https://263db807.ngrok.io -> localhost:7071
Connections ttl opn rt1 rt5 p50 p90

0 0 0.00 0.00 0.00 0.00
Você usará o URL https://{subdomain}.ngrok.io para sua inscrição na grade de eventos.

Executar a função de gatilho de Grade de Eventos
A URL ngrok não recebe tratamento especial pela Grade de Eventos, portanto, sua função deverá ser executada
localmente quando a assinatura for criada. Caso contrário, a resposta de validação não será enviada e a criação
da assinatura falhará.
Criar uma assinatura
Crie uma assinatura de grade de eventos do tipo que você deseja testar e forneça seu ponto de extremidade
ngrok.
Use este padrão de terminal para Funções 2.x:
https://{SUBDOMAIN}.ngrok.io/runtime/webhooks/eventgrid?functionName={FUNCTION_NAME}
Use este padrão de terminal para Funções 1.x:
https://{SUBDOMAIN}.ngrok.io/admin/extensions/EventGridExtensionConfig?functionName={FUNCTION_NAME}
O parâmetro {FUNCTION_NAME} deverá ser o nome especificado no atributo FunctionName .

Aqui, está um exemplo usando a CLI do Azure:
az eventgrid event-subscription create --resource-id /subscriptions/aeb4b7cb-b7cb-b7cb-b7cb-

b7cbb6607f30/resourceGroups/eg0122/providers/Microsoft.Storage/storageAccounts/egblobstor0122 --name
egblobsub0126 --endpoint https://263db807.ngrok.io/runtime/webhooks/eventgrid?functionName=EventGridTrigger
Para obter informações sobre como criar uma assinatura, consulte Criar uma assinatura, posteriormente neste
artigo.
Disparar um evento
Dispare um evento que gerará tráfego HTTP para o ponto de extremidade ngrok. Por exemplo, se você criou
uma assinatura de armazenamento de Blobs, faça upload ou exclua um blob.
A função de gatilho da Grade de Eventos executa e mostra logs semelhantes ao exemplo a seguir:
Use um gatilho HTTP como um gatilho de Grade de Eventos

Os eventos da Grade de Eventos são recebidos como solicitações HTTP, para que você possa manipular
eventos usando um gatilho HTTP em vez de um gatilho de Grade de Eventos. Um possível motivo para isso é
obter mais controle sobre a URL do ponto de extremidade que invoca a função. Outro motivo é quando você
precisa receber eventos no esquema CloudEvents. Atualmente, o gatilho da Grade de Eventos não dá suporte
ao esquema CloudEvents. Os exemplos desta seção mostram soluções para o esquema da Grade de Eventos e
o esquema CloudEvents.
Se você usar um gatilho HTTP, será necessário gravar o código para o que o gatilho da Grade de Eventos
automaticamente:
Envie uma resposta de validação para uma solicitação de validação de assinatura.
Invoque a função uma vez por elemento da matriz de eventos contida no corpo da solicitação.
Para obter informações sobre a URL a ser utilizada para invocar a função localmente ou quando for executada
no Azure, consulte a documentação de referência de associação de gatilho HTTP
Esquema da Grade de Eventos
O código C# de exemplo a seguir para um gatilho HTTP simula o comportamento do gatilho da Grade de
Eventos. Use este exemplo para eventos entregues no esquema da Grade de Eventos.
[HttpTrigger(AuthorizationLevel.Anonymous, "post")]HttpRequestMessage req,
ILogger log)
{
var messages = await req.Content.ReadAsAsync<JArray>();
// If the request is for subscription validation, send back the validation code.
if (messages.Count > 0 && string.Equals((string)messages[0]["eventType"],
"Microsoft.EventGrid.SubscriptionValidationEvent",
System.StringComparison.OrdinalIgnoreCase))
{
log.LogInformation("Validate request received");
return req.CreateResponse<object>(new
{
validationResponse = messages[0]["data"]["validationCode"]
});
}
// The request is not for subscription validation, so it's for one or more events.
foreach (JObject message in messages)
{
// Handle one event.
EventGridEvent eventGridEvent = message.ToObject<EventGridEvent>();
log.LogInformation($"Subject: {eventGridEvent.Subject}");
log.LogInformation($"Time: {eventGridEvent.EventTime}");
log.LogInformation($"Event data: {eventGridEvent.Data.ToString()}");
}
}
O código JavaScript de exemplo a seguir para um gatilho HTTP simula o comportamento do gatilho da Grade
de Eventos. Use este exemplo para eventos entregues no esquema da Grade de Eventos.
var messages = req.body;

if (messages.length > 0 && messages[0].eventType == "Microsoft.EventGrid.SubscriptionValidationEvent") {
context.log('Validate request received');
var code = messages[0].data.validationCode;
context.res = { status: 200, body: { "ValidationResponse": code } };
}
else {
// The request is not for subscription validation, so it's for one or more events.
// Event Grid schema delivers events in an array.
for (var i = 0; i < messages.length; i++) {
// Handle one event.
var message = messages[i];
context.log('Subject: ' + message.subject);
context.log('Time: ' + message.eventTime);
context.log('Data: ' + JSON.stringify(message.data));
}
}
context.done();
};
O código de manipulação de eventos está dentro do loop através da matriz messages .

Esquema CloudEvents
O código C# de exemplo a seguir para um gatilho HTTP simula o comportamento do gatilho da Grade de
Eventos. Use este exemplo para eventos entregues no esquema CloudEvents.
public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post",
Route = null)]HttpRequestMessage req, ILogger log)
{
var requestmessage = await req.Content.ReadAsStringAsync();

var message = JToken.Parse(requestmessage);
if (message.Type == JTokenType.Array)
{
if (string.Equals((string)message[0]["eventType"],
"Microsoft.EventGrid.SubscriptionValidationEvent",
System.StringComparison.OrdinalIgnoreCase))
{
log.LogInformation("Validate request received");
return req.CreateResponse<object>(new
{
validationResponse = message[0]["data"]["validationCode"]
});
}
}
else
{
// The request is not for subscription validation, so it's for an event.
// CloudEvents schema delivers one event at a time.
log.LogInformation($"Source: {message["source"]}");
log.LogInformation($"Time: {message["eventTime"]}");
log.LogInformation($"Event data: {message["data"].ToString()}");
}
}
O código JavaScript de exemplo a seguir para um gatilho HTTP simula o comportamento do gatilho da Grade
de Eventos. Use este exemplo para eventos entregues no esquema CloudEvents.

var message = req.body;

if (message.length > 0 && message[0].eventType == "Microsoft.EventGrid.SubscriptionValidationEvent") {
context.log('Validate request received');
var code = message[0].data.validationCode;
context.res = { status: 200, body: { "ValidationResponse": code } };
}
else {
// The request is not for subscription validation, so it's for an event.
// CloudEvents schema delivers one event at a time.
var event = JSON.parse(message);
context.log('Source: ' + event.source);
context.log('Time: ' + event.eventTime);
context.log('Data: ' + JSON.stringify(event.data));
}
context.done();
};
Próximos passos
Saiba mais sobre a Grade de Eventos
Associações de Hubs de Eventos do Azure para o
Azure Functions
Este artigo explica como trabalhar com associações de Hubs de Eventos do Azure para o Azure Functions. O
Azure Functions dá suporte a associações de gatilho e de saída para os Hubs de Eventos.
Para a versão de funções do Azure 1. x, em que as associações de Hubs de eventos são fornecidas a
Microsoft.Azure.WebJobs.ServiceBus pacote NuGet, versão 2. x. O código-fonte do pacote está no repositório

Para funções 2. x, use o Microsoft.Azure.WebJobs.Extensions.EventHubs pacote, versão 3. x. O código-fonte do
pacote está no repositório GitHub azure-webjobs-sdk.


Python

Gatilho
Use o gatilho de função para responder a um evento enviado a um fluxo de eventos do hub de eventos. Você
deve ter acesso de leitura ao Hub de eventos subjacente para configurar o gatilho. Quando a função é
disparada, a mensagem passada para a função é digitada como uma cadeia de caracteres.
Gatilho - dimensionamento
Cada instância de uma função disparada por evento é apoiada por uma única instância de EventProcessorHost
. O gatilho (da plataforma de hubs de eventos) garante que apenas uma instância EventProcessorHost possa
obter uma concessão em uma determinada partição.
Por exemplo, considere um Hub de eventos da seguinte maneira:
10 partições
1.000 eventos distribuídos uniformemente em todas as partições, com 100 mensagens em cada partição
Quando sua função é habilitada pela primeira vez, há apenas uma instância da função. Vamos chamar a
primeira instância de função Function_0 . A função Function_0 tem uma única instância de
EventProcessorHost que contém uma concessão em todas as dez partições. Esta instância está lendo eventos
das partições 0 a 9. Deste ponto em diante, uma destas opções ocorre:
Novas instâncias de função não são necessárias: Function_0 é capaz de processar todos os eventos
1.000 antes que a lógica de dimensionamento de funções entre em vigor. Nesse caso, todas as
mensagens 1.000 são processadas pelo Function_0 .
Uma instância de função adicional é adicionada: se a lógica de dimensionamento de funções
determinar que Function_0 tem mais mensagens do que pode processar, uma nova instância de
aplicativo de função ( Function_1 ) será criada. Essa nova função também tem uma instância associada
de EventProcessorHost. Como os hubs de eventos subjacentes detectam que uma nova instância do
host está tentando ler mensagens, ele balanceia a carga das partições em suas instâncias de host. Por
exemplo, as partições de 0 a 4 podem ser atribuídas a Function_0 e as partições de 5 a 9 para
Function_1 .
N mais instâncias de função são adicionadas: se a lógica de dimensionamento de funções

determinar que tanto Function_0 quanto Function_1 têm mais mensagens do que podem ser
processadas, novas instâncias de aplicativo de função Functions_N são criadas. Os aplicativos são criados
para o ponto em que N é maior que o número de partições do hub de eventos. Em nosso exemplo, os
Hubs de Eventos balanceiam a carga das partições novamente e, nesse caso, entre as instâncias
Function_0 e Functions_9 .
Quando o Functions é dimensionado, N instâncias é um número maior que o número de partições do hub de
eventos. Isso é feito para garantir que as instâncias de EventProcessorHost estejam disponíveis para obter
bloqueios em partições à medida que se tornam disponíveis de outras instâncias. Você é cobrado apenas pelos
recursos usados quando a instância de função é executada. Em outras palavras, você não será cobrado por esse
excesso de provisionamento.
Quando todas as execuções de função são concluídas (com ou sem erros), os pontos de verificação são
adicionados à conta de armazenamento associada. Quando o ponto de verificação for executado com sucesso,
todas as mensagens 1.000 nunca serão recuperadas novamente.
Gatilho - exemplo
C#
F#
Java
JavaScript
Python
O exemplo a seguir mostra uma função C# que registra o corpo da mensagem do gatilho dos hub de eventos.
public static void Run([EventHubTrigger("samples-workitems", Connection = "EventHubConnectionAppSetting")]
string myEventHubMessage, ILogger log)
{
log.LogInformation($"C# function triggered to process a message: {myEventHubMessage}");
}
Para obter acesso aos metadados no código da função, associe um objeto de EventData (requer o uso de uma
instrução para Microsoft.Azure.EventHubs ). Você também pode acessar as mesmas propriedades usando
expressões de associação na assinatura do método. O exemplo a seguir mostra duas formas de obter os
mesmos dados:
[EventHubTrigger("samples-workitems", Connection = "EventHubConnectionAppSetting")] EventData
myEventHubMessage,
DateTime enqueuedTimeUtc,
Int64 sequenceNumber,
string offset,
ILogger log)
{
log.LogInformation($"Event: {Encoding.UTF8.GetString(myEventHubMessage.Body)}");
// Metadata accessed by binding to EventData
log.LogInformation($"EnqueuedTimeUtc={myEventHubMessage.SystemProperties.EnqueuedTimeUtc}");
log.LogInformation($"SequenceNumber={myEventHubMessage.SystemProperties.SequenceNumber}");
log.LogInformation($"Offset={myEventHubMessage.SystemProperties.Offset}");
// Metadata accessed by using binding expressions in method parameters
log.LogInformation($"EnqueuedTimeUtc={enqueuedTimeUtc}");
log.LogInformation($"SequenceNumber={sequenceNumber}");
log.LogInformation($"Offset={offset}");
}
Para receber eventos em um lote, faça string ou EventData uma matriz.
NOTE
Ao receber em um lote, não é possível associar aos parâmetros do método, como no exemplo acima com
DateTime enqueuedTimeUtc , e deve recebê-los de cada objeto EventData
EventData[] eventHubMessages, ILogger log)
{
foreach (var message in eventHubMessages)
{
log.LogInformation($"C# function triggered to process a message:
{Encoding.UTF8.GetString(message.Body)}");
log.LogInformation($"EnqueuedTimeUtc={message.SystemProperties.EnqueuedTimeUtc}");
}
}

O exemplo a seguir mostra uma associação de gatilho de hub de eventos em um arquivo function.json e uma
função C# script que usa a associação. A função registra em log o corpo da mensagem do gatilho de hub de
eventos.
Os exemplos a seguir mostram dados de associação de Hubs de eventos no function.json arquivo.
Versão 2.x
{
"type": "eventHubTrigger",
"name": "myEventHubMessage",
"direction": "in",
"eventHubName": "MyEventHub",
"connection": "myEventHubReadConnectionAppSetting"
}
Versão 1.x
{
"direction": "in",
"path": "MyEventHub",
}
using System;
public static void Run(string myEventHubMessage, TraceWriter log)

{
log.Info($"C# function triggered to process a message: {myEventHubMessage}");
}
expressões de associação na assinatura do método. O exemplo a seguir mostra duas formas de obter os
mesmos dados:
#r "Microsoft.Azure.EventHubs"
using System.Text;
using System;
using Microsoft.ServiceBus.Messaging;
using Microsoft.Azure.EventHubs;
public static void Run(EventData myEventHubMessage,

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, faça string ou EventData uma matriz:
public static void Run(string[] eventHubMessages, TraceWriter log)

{
{
log.Info($"C# function triggered to process a message: {message}");
}
}
Gatilho - exemplo F#
função F# que usa a associação. A função registra em log o corpo da mensagem do gatilho de hub de eventos.
Versão 2.x
{
"direction": "in",
}
Versão 1.x
{
"direction": "in",
}
let Run(myEventHubMessage: string, log: TraceWriter) =
log.Log(sprintf "F# eventhub trigger function processed work item: %s" myEventHubMessage)

função JavaScript que usa a associação. A função lê os metadados de evento e registra a mensagem.
Versão 2.x
{
"direction": "in",
}
Versão 1.x
{
"direction": "in",
}
module.exports = function (context, myEventHubMessage) {

context.log('Function triggered to process a message: ', myEventHubMessage);
context.log('EnqueuedTimeUtc =', context.bindingData.enqueuedTimeUtc);
context.log('SequenceNumber =', context.bindingData.sequenceNumber);
context.log('Offset =', context.bindingData.offset);
context.done();
};
Para receber eventos em um lote, defina cardinality para many no arquivo function.json, conforme mostrado
nos exemplos a seguir.
Versão 2.x
{
"name": "eventHubMessages",
"direction": "in",
"cardinality": "many",
}
Versão 1.x
{
"direction": "in",
}
module.exports = function (context, eventHubMessages) {

context.log(`JavaScript eventhub trigger function called for message array ${eventHubMessages}`);
eventHubMessages.forEach((message, index) => {

context.log(`Processed message ${message}`);
context.log(ÈnqueuedTimeUtc = ${context.bindingData.enqueuedTimeUtcArray[index]}`);
context.log(`SequenceNumber = ${context.bindingData.sequenceNumberArray[index]}`);
context.log(Òffset = ${context.bindingData.offsetArray[index]}`);
});
context.done();
};

O exemplo a seguir mostra uma ligação de acionador do Hub de Eventos em um arquivo function.json e uma
função Python que usa a ligação. A função lê os metadados de evento e registra a mensagem.
{
"name": "event",
"direction": "in",
}
import logging
def main(event: func.EventHubEvent):

logging.info('Function triggered to process a message: ', event.get_body())
logging.info(' EnqueuedTimeUtc =', event.enqueued_time)
logging.info(' SequenceNumber =', event.sequence_number)
logging.info(' Offset =', event.offset)

função Java que usa a ligação. A função registra o corpo da mensagem do gatilho de Hub de eventos.
{
"name": "msg",
"direction": "in",
"eventHubName": "myeventhubname",
}
@FunctionName("ehprocessor")
public void eventHubProcessor(
@EventHubTrigger(name = "msg",
eventHubName = "myeventhubname",
connection = "myconnvarname") String message,
final ExecutionContext context )
{
context.getLogger().info(message);
}
No biblioteca de tempo de execução de funções Java, use o EventHubTrigger anotação em parâmetros cujo
valor virá do Hub de eventos. Parâmetros com essas anotações fazem com que a função seja executada quando
um evento chega. Esta anotação pode ser usada com tipos Java nativos, POJOs ou valores anuláveis usando >
opcional<T.
Gatilho - atributos
Em bibliotecas de classes de C#, utilize o atributo EventHubTriggerAttribute.
O construtor do atributo usa os nomes do hub de eventos, do grupo de consumidores e de uma configuração
de aplicativo que contenham a cadeia de caracteres de conexão. Para obter mais informações sobre essas
configurações, consulte a seção sobre configuração do gatilho. Este é um EventHubTriggerAttribute exemplo de
atributo:
{
...
}
function.json e o EventHubTrigger atributo.
tipo n/d Deve ser definido como

eventHubTrigger . Essa propriedade
é definida automaticamente quando
você cria o gatilho no portal do Azure.

gatilho no portal do Azure.

item de evento no código de função.
path EventHubName Funciona apenas 1. x. O nome do hub

de eventos. Quando o nome do hub
de eventos também estiver presente
na cadeia de conexão, esse valor
substitui essa propriedade em tempo
de execução.
eventHubName EventHubName Funciona apenas 2. x. O nome do hub

de execução.
consumerGroup ConsumerGroup É uma propriedade opcional que

define o grupo de consumidores
usado para assinar eventos no hub. Se
omitido, o grupo de consumidores
$Default será usado.
cardinalidade n/d Para JavaScript. Definido como many

para habilitar o envio em lote. Se
omitido ou definido como one , uma
única mensagem será passada para a
função.
conexão Conexão É o nome de uma configuração de

conexão para o namespace do hub de
eventos. Copie essa cadeia de conexão
clicando no botão Informações de
Conexão do namespace, não no
próprio hub de eventos. Essa cadeia de
conexão deve ter, pelo menos,
permissões de leitura para ativar o
gatilho.
path EventHubName O nome do hub de eventos. Pode ser

referenciado por meio das
configurações de aplicativo
%eventHubName%
Gatilho: metadados de evento

O gatilho dos Hubs de Evento fornece várias propriedades de metadados. Essas propriedades podem ser
usadas como parte de expressões de associação em outras associações ou como parâmetros em seu código.
Essas são propriedades da classe EventData.
PartitionContext PartitionContext A instância PartitionContext .
EnqueuedTimeUtc DateTime O tempo de enfileiramento no UTC.
Offset string O deslocamento dos dados em relação

ao fluxo de partição do Hub de
Eventos. O deslocamento é um
marcador ou um identificador para um
evento dentro do fluxo do Hubs de
Eventos. O identificador é exclusivo
dentro de uma partição do fluxo de
Hubs de Eventos.
PartitionKey string A partição para os dados de evento

deve ser enviada.
Properties IDictionary<String,Object> Propriedades do usuário dos dados do

evento.
SequenceNumber Int64 O número de sequência lógica do

evento.
SystemProperties IDictionary<String,Object> Propriedades do sistema, incluindo dos

dados do evento.
Consulte exemplos de código que usam essas propriedades neste artigo.
Gatilho - propriedades de host.json

O arquivo host.json contém configurações que controlam o comportamento de gatilho dos Hubs de Eventos.
{
"eventHub": {
"maxBatchSize": 64,
"prefetchCount": 256,
"batchCheckpointFrequency": 1
}
}
maxBatchSize 64 A contagem máxima de eventos

recebidos por loop de recebimento.
prefetchCount n/d O PrefetchCount padrão que será

usado pelo EventProcessorHost
subjacente.
batchCheckpointFrequency 1 O número de lotes de eventos para

processar antes de criar um ponto de
verificação do cursor do EventHub.
Saída
Use a associação de saída dos Hubs de Eventos para gravar eventos em um fluxo de eventos. É necessário ter
permissão de envio para um hub de eventos a fim de gravar eventos nele.
Verifique se as referências de pacote necessárias estão em vigor: funções 1. x ou funções 2. x
Saída - exemplo
C#
F#
Java
JavaScript
Python
Saída - exemplo C#
O exemplo a seguir mostra uma função C# que grava uma mensagem em um hub de eventos, usando o valor
retornado do método como a saída:
[FunctionName("EventHubOutput")]
[return: EventHub("outputEventHubMessage", Connection = "EventHubConnectionAppSetting")]
public static string Run([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer, ILogger log)
{
return $"{DateTime.Now}";
}
O exemplo a seguir mostra como usar a interface IAsyncCollector para enviar um lote de mensagens. Esse
cenário é comum quando você está processando mensagens provenientes de um hub de eventos e enviando o
resultado para outro hub de eventos.
[FunctionName("EH2EH")]
[EventHubTrigger("source", Connection = "EventHubConnectionAppSetting")] EventData[] events,
[EventHub("dest", Connection = "EventHubConnectionAppSetting")]IAsyncCollector<string> outputEvents,
ILogger log)
{
foreach (EventData eventData in events)
{
// do some processing:
var myProcessedEvent = DoSomething(eventData);
// then send the message

await outputEvents.AddAsync(JsonConvert.SerializeObject(myProcessedEvent));
}
}
Saída - exemplo de script C#

função C# script que usa a associação. A função grava uma mensagem em um hub de eventos.
Os exemplos a seguir mostram dados de associação de Hubs de eventos no function.json arquivo. O primeiro
exemplo é para funções de 2.x e a segunda é para funções 1.x.
{
"type": "eventHub",
"name": "outputEventHubMessage",
"eventHubName": "myeventhub",
"connection": "MyEventHubSendAppSetting",
"direction": "out"
}
{
"type": "eventHub",
"path": "myeventhub",
"direction": "out"
}
Este é o código C# script que cria uma mensagem:
using System;
public static void Run(TimerInfo myTimer, out string outputEventHubMessage, ILogger log)
{
String msg = $"TimerTriggerCSharp1 executed at: {DateTime.Now}";
log.LogInformation(msg);
outputEventHubMessage = msg;
}
Este é 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);
}
Saída - Exemplo #F
função F# que usa a associação. A função grava uma mensagem em um hub de eventos.
{
"type": "eventHub",
"direction": "out"
}
{
"type": "eventHub",
"direction": "out"
}
let Run(myTimer: TimerInfo, outputEventHubMessage: byref<string>, log: ILogger) =

let msg = sprintf "TimerTriggerFSharp1 executed at: %s" DateTime.Now.ToString()
outputEventHubMessage <- msg;
Saída - exemplo JavaScript

função JavaScript que usa a associação. A função grava uma mensagem em um hub de eventos.
{
"type": "eventHub",
"direction": "out"
}
{
"type": "eventHub",
"direction": "out"
}
Este é o código JavaScript que envia uma mensagem única:
module.exports = function (context, myTimer) {

context.log('Message created at: ', timeStamp);
context.bindings.outputEventHubMessage = "Message created at: " + timeStamp;
context.done();
};
Este é o código JavaScript que envia várias mensagens:

var message = 'Message created at: ' + timeStamp;
context.bindings.outputEventHubMessage = [];
context.bindings.outputEventHubMessage.push("1 " + message);

context.done();
};
Saída – exemplo do Python

função Python que usa a ligação. A função grava uma mensagem em um hub de eventos.
{
"type": "eventHub",
"name": "$return",
"direction": "out"
}
Este é o código Python que envia uma mensagem única:
import datetime
import logging
def main(timer: func.TimerRequest) -> str:

timestamp = datetime.datetime.utcnow()
logging.info('Message created at: %s', timestamp)
return 'Message created at: {}'.format(timestamp)
Saída - exemplo de Java

O exemplo a seguir mostra uma função Java que grava uma mensagem contendo a hora atual em um Hub de
Eventos.
@FunctionName("sendTime")
@EventHubOutput(name = "event", eventHubName = "samples-workitems", connection = "AzureEventHubConnection")
public String sendTime(
@TimerTrigger(name = "sendTimeTrigger", schedule = "0 */5 * * * *") String timerInfo) {
return LocalDateTime.now().toString();
}
Na biblioteca de tempo de execução de funções Java, use a anotação @EventHubOutput em parâmetros cujo
valor seria publicado no Hub de Eventos. O parâmetro deve ser do tipo OutputBinding<T> , em que T é um
POJO ou qualquer tipo Java nativo.
Saída - atributos
Para bibliotecas de classes de C#, utilize o atributo EventHubAttribute.
O construtor do atributo usa os nomes do hub de eventos e de uma configuração de aplicativo que contenham
a cadeia de caracteres de conexão. Para obter mais informações sobre essas configurações, consulte Saída -
configuração. Este é um EventHub exemplo de atributo:
{
...
}
function.json e o EventHub atributo.
tipo n/d Deve ser definido como "eventHub".
direction n/d Deve ser definido como "out". Esse

parâmetro é definido
automaticamente quando você cria a
associação no portal do Azure.
name n/d É o nome da variável usada no código

da função que representa o evento.

de execução.

de execução.

conexão deve ter permissões de envio
para enviar a mensagem à transmissão
do evento.
Saída - uso
Em C# e C# script, envie mensagens usando um parâmetro de método, como out string paramName . No script
do C#, paramName é o valor especificado na propriedade name de function.json. Para gravar várias mensagens,
você pode usar ICollector<string> ou IAsyncCollector<string> no lugar de out string .
Em JavaScript, acesse o evento de saída usando context.bindings.<name> . <name> é o valor especificado na
propriedade name de function.json.

Hub de evento Log de operações
Esta seção descreve as definições de configuração globais disponíveis para esta associação na versão 2.x. O
arquivo host.json de exemplo abaixo contém apenas as configurações da versão 2.x para essa associação. Para
NOTE
Para obter uma referência de host.json no Functions 1.x, confira Referência de host.json para o Azure Functions 1.x.
{
"version": "2.0",
"extensions": {
"eventHubs": {
"batchCheckpointFrequency": 5,
"eventProcessorOptions": {
"maxBatchSize": 256,
"prefetchCount": 512
}
}
}
}


subjacente.

Próximas etapas
Associações do Hub IoT do Azure para Azure
Functions
Este artigo explica como trabalhar com associações de Azure Functions para o Hub IoT. O suporte ao Hub IoT é
baseado na Associação de hubs de eventos do Azure.
Para Azure Functions versão 1. x, as associações do Hub IoT são fornecidas no pacote NuGet Microsoft. Azure.
webjobs. ServiceBus , versão 2. x. O código-fonte do pacote está no repositório GitHub azure-webjobs-sdk.

Para funções 2. x, use o Microsoft.Azure.WebJobs.Extensions.EventHubs pacote, versão 3. x. O código-fonte do
pacote está no repositório GitHub azure-webjobs-sdk.


Python
IMPORTANT
Embora os exemplos de código a seguir usem a API do hub de eventos, a sintaxe fornecida é aplicável a funções do Hub
IoT.
Gatilho
Use o gatilho de função para responder a um evento enviado a um fluxo de eventos do hub de eventos. Você
deve ter acesso de leitura ao Hub de eventos subjacente para configurar o gatilho. Quando a função é disparada,
a mensagem passada para a função é digitada como uma cadeia de caracteres.
Gatilho - dimensionamento
Cada instância de uma função disparada por evento é apoiada por uma única instância de EventProcessorHost .
O gatilho (da plataforma de hubs de eventos) garante que apenas uma instância EventProcessorHost possa obter
uma concessão em uma determinada partição.
Por exemplo, considere um Hub de eventos da seguinte maneira:
10 partições
1.000 eventos distribuídos uniformemente em todas as partições, com 100 mensagens em cada partição
Quando sua função é habilitada pela primeira vez, há apenas uma instância da função. Vamos chamar a primeira
instância de função Function_0 . A função Function_0 tem uma única instância de EventProcessorHost que
contém uma concessão em todas as dez partições. Esta instância está lendo eventos das partições 0 a 9. Deste
ponto em diante, uma destas opções ocorre:
Novas instâncias de função não são necessárias: Function_0 é capaz de processar todos os eventos
1.000 antes que a lógica de dimensionamento de funções entre em vigor. Nesse caso, todas as mensagens
1.000 são processadas pelo Function_0 .
Uma instância de função adicional é adicionada: se a lógica de dimensionamento de funções
determinar que Function_0 tem mais mensagens do que pode processar, uma nova instância de aplicativo
de função ( Function_1 ) será criada. Essa nova função também tem uma instância associada de
EventProcessorHost. Como os hubs de eventos subjacentes detectam que uma nova instância do host está
tentando ler mensagens, ele balanceia a carga das partições em suas instâncias de host. Por exemplo, as
partições de 0 a 4 podem ser atribuídas a Function_0 e as partições de 5 a 9 para Function_1 .
N mais instâncias de função são adicionadas: se a lógica de dimensionamento de funções determinar
que tanto Function_0 quanto Function_1 têm mais mensagens do que podem ser processadas, novas
instâncias de aplicativo de função Functions_N são criadas. Os aplicativos são criados para o ponto em que
N é maior que o número de partições do hub de eventos. Em nosso exemplo, os Hubs de Eventos
balanceiam a carga das partições novamente e, nesse caso, entre as instâncias Function_0 e Functions_9 .
Quando o Functions é dimensionado, N instâncias é um número maior que o número de partições do hub de
eventos. Isso é feito para garantir que as instâncias de EventProcessorHost estejam disponíveis para obter
bloqueios em partições à medida que se tornam disponíveis de outras instâncias. Você é cobrado apenas pelos
recursos usados quando a instância de função é executada. Em outras palavras, você não será cobrado por esse
excesso de provisionamento.
Quando todas as execuções de função são concluídas (com ou sem erros), os pontos de verificação são
adicionados à conta de armazenamento associada. Quando o ponto de verificação for executado com sucesso,
todas as mensagens 1.000 nunca serão recuperadas novamente.
Gatilho - exemplo
C#
F#
Java
JavaScript
Python
O exemplo a seguir mostra uma função C# que registra o corpo da mensagem do gatilho dos hub de eventos.
{
log.LogInformation($"C# function triggered to process a message: {myEventHubMessage}");
}
expressões de associação na assinatura do método. O exemplo a seguir mostra duas formas de obter os mesmos
dados:
[EventHubTrigger("samples-workitems", Connection = "EventHubConnectionAppSetting")] EventData
myEventHubMessage,
string offset,
ILogger log)
{
log.LogInformation($"Event: {Encoding.UTF8.GetString(myEventHubMessage.Body)}");
// Metadata accessed by binding to EventData
log.LogInformation($"EnqueuedTimeUtc={myEventHubMessage.SystemProperties.EnqueuedTimeUtc}");
log.LogInformation($"SequenceNumber={myEventHubMessage.SystemProperties.SequenceNumber}");
log.LogInformation($"Offset={myEventHubMessage.SystemProperties.Offset}");
// Metadata accessed by using binding expressions in method parameters
log.LogInformation($"SequenceNumber={sequenceNumber}");
log.LogInformation($"Offset={offset}");
}
Para receber eventos em um lote, faça string ou EventData uma matriz.
NOTE
Ao receber em um lote, não é possível associar aos parâmetros do método, como no exemplo acima com
DateTime enqueuedTimeUtc , e deve recebê-los de cada objeto EventData
EventData[] eventHubMessages, ILogger log)
{
{
log.LogInformation($"C# function triggered to process a message:
{Encoding.UTF8.GetString(message.Body)}");
log.LogInformation($"EnqueuedTimeUtc={message.SystemProperties.EnqueuedTimeUtc}");
}
}

função C# script que usa a associação. A função registra em log o corpo da mensagem do gatilho de hub de
eventos.
Versão 2.x
{
"direction": "in",
}
Versão 1.x
{
"direction": "in",
}
using System;
public static void Run(string myEventHubMessage, TraceWriter log)

{
log.Info($"C# function triggered to process a message: {myEventHubMessage}");
}
expressões de associação na assinatura do método. O exemplo a seguir mostra duas formas de obter os mesmos
dados:
#r "Microsoft.Azure.EventHubs"
using System.Text;
using System;
using Microsoft.ServiceBus.Messaging;
using Microsoft.Azure.EventHubs;
public static void Run(EventData myEventHubMessage,

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($"SequenceNumber={sequenceNumber}");
log.Info($"Offset={offset}");
}
Para receber eventos em um lote, faça string ou EventData uma matriz:
public static void Run(string[] eventHubMessages, TraceWriter log)

{
{
log.Info($"C# function triggered to process a message: {message}");
}
}
função F# que usa a associação. A função registra em log o corpo da mensagem do gatilho de hub de eventos.
Versão 2.x
{
"direction": "in",
}
Versão 1.x
{
"direction": "in",
}
let Run(myEventHubMessage: string, log: TraceWriter) =
log.Log(sprintf "F# eventhub trigger function processed work item: %s" myEventHubMessage)

função JavaScript que usa a associação. A função lê os metadados de evento e registra a mensagem.
Versão 2.x
{
"direction": "in",
}
Versão 1.x
{
"direction": "in",
}
module.exports = function (context, myEventHubMessage) {

context.log('Function triggered to process a message: ', myEventHubMessage);
context.log('SequenceNumber =', context.bindingData.sequenceNumber);
context.log('Offset =', context.bindingData.offset);
context.done();
};
Para receber eventos em um lote, defina cardinality para many no arquivo function.json, conforme mostrado
nos exemplos a seguir.
Versão 2.x
{
"direction": "in",
}
Versão 1.x
{
"direction": "in",
}
module.exports = function (context, eventHubMessages) {

context.log(`JavaScript eventhub trigger function called for message array ${eventHubMessages}`);
eventHubMessages.forEach((message, index) => {

context.log(`Processed message ${message}`);
context.log(ÈnqueuedTimeUtc = ${context.bindingData.enqueuedTimeUtcArray[index]}`);
context.log(`SequenceNumber = ${context.bindingData.sequenceNumberArray[index]}`);
context.log(Òffset = ${context.bindingData.offsetArray[index]}`);
});
context.done();
};

função Python que usa a ligação. A função lê os metadados de evento e registra a mensagem.
{
"name": "event",
"direction": "in",
}
import logging
def main(event: func.EventHubEvent):

logging.info('Function triggered to process a message: ', event.get_body())
logging.info(' EnqueuedTimeUtc =', event.enqueued_time)
logging.info(' SequenceNumber =', event.sequence_number)
logging.info(' Offset =', event.offset)

função Java que usa a ligação. A função registra o corpo da mensagem do gatilho de Hub de eventos.
{
"name": "msg",
"direction": "in",
"eventHubName": "myeventhubname",
}
@FunctionName("ehprocessor")
public void eventHubProcessor(
@EventHubTrigger(name = "msg",
eventHubName = "myeventhubname",
final ExecutionContext context )
{
}
No biblioteca de tempo de execução de funções Java, use o EventHubTrigger anotação em parâmetros cujo valor
virá do Hub de eventos. Parâmetros com essas anotações fazem com que a função seja executada quando um
evento chega. Esta anotação pode ser usada com tipos Java nativos, POJOs ou valores anuláveis usando >
opcional<T.
Gatilho - atributos
Em bibliotecas de classes de C#, utilize o atributo EventHubTriggerAttribute.
O construtor do atributo usa os nomes do hub de eventos, do grupo de consumidores e de uma configuração de
aplicativo que contenham a cadeia de caracteres de conexão. Para obter mais informações sobre essas
configurações, consulte a seção sobre configuração do gatilho. Este é um EventHubTriggerAttribute exemplo de
atributo:
{
...
}
e o EventHubTrigger atributo.

eventHubTrigger . Essa propriedade é
definida automaticamente quando você
cria o gatilho no portal do Azure.


item de evento no código de função.

de eventos. Quando o nome do hub de
eventos também estiver presente na
cadeia de conexão, esse valor substitui
essa propriedade em tempo de
execução.

execução.
consumerGroup ConsumerGroup É uma propriedade opcional que define

o grupo de consumidores usado para
assinar eventos no hub. Se omitido, o
grupo de consumidores $Default
será usado.
cardinalidade n/d Para JavaScript. Definido como many

para habilitar o envio em lote. Se
omitido ou definido como one , uma
única mensagem será passada para a
função.

conexão deve ter, pelo menos,
permissões de leitura para ativar o
gatilho.
path EventHubName O nome do hub de eventos. Pode ser

referenciado por meio das
configurações de aplicativo
%eventHubName%
Gatilho: metadados de evento

O gatilho dos Hubs de Evento fornece várias propriedades de metadados. Essas propriedades podem ser usadas
como parte de expressões de associação em outras associações ou como parâmetros em seu código. Essas são
propriedades da classe EventData.
PartitionContext PartitionContext A instância PartitionContext .
Offset string O deslocamento dos dados em relação

ao fluxo de partição do Hub de
Eventos. O deslocamento é um
marcador ou um identificador para um
evento dentro do fluxo do Hubs de
Eventos. O identificador é exclusivo
dentro de uma partição do fluxo de
Hubs de Eventos.
PartitionKey string A partição para os dados de evento

deve ser enviada.
Properties IDictionary<String,Object> Propriedades do usuário dos dados do

evento.
SequenceNumber Int64 O número de sequência lógica do

evento.
SystemProperties IDictionary<String,Object> Propriedades do sistema, incluindo dos

dados do evento.

O arquivo host.json contém configurações que controlam o comportamento de gatilho dos Hubs de Eventos.
{
"eventHub": {
"maxBatchSize": 64,
}
}


subjacente.

Saída
Use a associação de saída dos Hubs de Eventos para gravar eventos em um fluxo de eventos. É necessário ter
permissão de envio para um hub de eventos a fim de gravar eventos nele.
Verifique se as referências de pacote necessárias estão em vigor: funções 1. x ou funções 2. x
Saída - exemplo
C#
F#
Java
JavaScript
Python
Saída - exemplo C#
O exemplo a seguir mostra uma função C# que grava uma mensagem em um hub de eventos, usando o valor
retornado do método como a saída:
{
return $"{DateTime.Now}";
}
O exemplo a seguir mostra como usar a interface IAsyncCollector para enviar um lote de mensagens. Esse
cenário é comum quando você está processando mensagens provenientes de um hub de eventos e enviando o
resultado para outro hub de eventos.
[FunctionName("EH2EH")]
[EventHubTrigger("source", Connection = "EventHubConnectionAppSetting")] EventData[] events,
[EventHub("dest", Connection = "EventHubConnectionAppSetting")]IAsyncCollector<string> outputEvents,
ILogger log)
{
foreach (EventData eventData in events)
{
// do some processing:
var myProcessedEvent = DoSomething(eventData);
// then send the message

await outputEvents.AddAsync(JsonConvert.SerializeObject(myProcessedEvent));
}
}

função C# script que usa a associação. A função grava uma mensagem em um hub de eventos.
{
"type": "eventHub",
"direction": "out"
}
{
"type": "eventHub",
"direction": "out"
}
Este é o código C# script que cria uma mensagem:
using System;
public static void Run(TimerInfo myTimer, out string outputEventHubMessage, ILogger log)
{
String msg = $"TimerTriggerCSharp1 executed at: {DateTime.Now}";
outputEventHubMessage = msg;
}
public static void Run(TimerInfo myTimer, ICollector<string> outputEventHubMessage, ILogger log)

{
string message = $"Message created at: {DateTime.Now}";
}
Saída - Exemplo #F
função F# que usa a associação. A função grava uma mensagem em um hub de eventos.
{
"type": "eventHub",
"direction": "out"
}
{
"type": "eventHub",
"direction": "out"
}
let Run(myTimer: TimerInfo, outputEventHubMessage: byref<string>, log: ILogger) =

let msg = sprintf "TimerTriggerFSharp1 executed at: %s" DateTime.Now.ToString()
outputEventHubMessage <- msg;

função JavaScript que usa a associação. A função grava uma mensagem em um hub de eventos.
{
"type": "eventHub",
"direction": "out"
}
{
"type": "eventHub",
"direction": "out"
}
Este é o código JavaScript que envia uma mensagem única:

context.log('Message created at: ', timeStamp);
context.bindings.outputEventHubMessage = "Message created at: " + timeStamp;
context.done();
};
Este é o código JavaScript que envia várias mensagens:

var message = 'Message created at: ' + timeStamp;
context.bindings.outputEventHubMessage = [];

context.done();
};

função Python que usa a ligação. A função grava uma mensagem em um hub de eventos.
{
"type": "eventHub",
"name": "$return",
"direction": "out"
}
Este é o código Python que envia uma mensagem única:
import datetime
import logging
def main(timer: func.TimerRequest) -> str:

timestamp = datetime.datetime.utcnow()
logging.info('Message created at: %s', timestamp)
return 'Message created at: {}'.format(timestamp)

O exemplo a seguir mostra uma função Java que grava uma mensagem contendo a hora atual em um Hub de
Eventos.
@FunctionName("sendTime")
@EventHubOutput(name = "event", eventHubName = "samples-workitems", connection = "AzureEventHubConnection")
public String sendTime(
@TimerTrigger(name = "sendTimeTrigger", schedule = "0 */5 * * * *") String timerInfo) {
return LocalDateTime.now().toString();
}
Na biblioteca de tempo de execução de funções Java, use a anotação @EventHubOutput em parâmetros cujo valor
seria publicado no Hub de Eventos. O parâmetro deve ser do tipo OutputBinding<T> , em que T é um POJO ou
qualquer tipo Java nativo.
Saída - atributos
Para bibliotecas de classes de C#, utilize o atributo EventHubAttribute.
O construtor do atributo usa os nomes do hub de eventos e de uma configuração de aplicativo que contenham a
cadeia de caracteres de conexão. Para obter mais informações sobre essas configurações, consulte Saída -
configuração. Este é um EventHub exemplo de atributo:
{
...
}
e o EventHub atributo.
tipo n/d Deve ser definido como "eventHub".
direction n/d Deve ser definido como "out". Esse

quando você cria a associação no
portal do Azure.
name n/d É o nome da variável usada no código

da função que representa o evento.

execução.

execução.

conexão deve ter permissões de envio
para enviar a mensagem à transmissão
do evento.
Saída - uso
Em C# e C# script, envie mensagens usando um parâmetro de método, como out string paramName . No script do
C#, paramName é o valor especificado na propriedade name de function.json. Para gravar várias mensagens, você
pode usar ICollector<string> ou IAsyncCollector<string> no lugar de out string .
Em JavaScript, acesse o evento de saída usando context.bindings.<name> . <name> é o valor especificado na
propriedade name de function.json.

Hub de evento Log de operações
NOTE
{
"version": "2.0",
"extensions": {
"eventHubs": {
"batchCheckpointFrequency": 5,
"eventProcessorOptions": {
"maxBatchSize": 256,
"prefetchCount": 512
}
}
}
}


subjacente.

Próximas etapas
Gatilhos e associações HTTP do Azure Functions
Este artigo explica como trabalhar com gatilhos e associações de saída HTTP no Azure Functions.
Um gatilho de HTTP pode ser personalizado para responder a webhooks.
TIP
Se você planeja usar as ligações HTTP ou WebHook, planeje evitar o esgotamento de porta que pode ser causado
pela instanciação incorreta do HttpClient . Para saber mais, confira Como gerenciar conexões no Azure
Functions.
O código nesse artigo tem como padrão a sintaxe Funções 2.x que usa o .NET Core. Para obter
informações sobre a sintaxe 1.x, consulte os modelos de funções 1.x.
As associações de HTTP são fornecidas no pacote NuGet, versão 1.x.
Microsoft.Azure.WebJobs.Extensions.Http. O código-fonte do pacote está no repositório GitHub azure-
webjobs-sdk-extensions.
O suporte para essa associação é fornecido automaticamente em todos os ambientes de
desenvolvimento. Você não precisa instalar o pacote ou registrar a extensão manualmente.
As associações de HTTP são fornecidas no pacote NuGet, versão 3.x.
Microsoft.Azure.WebJobs.Extensions.Http. O código-fonte do pacote está no repositório GitHub azure-
webjobs-sdk-extensions.
O suporte para essa associação é fornecido automaticamente em todos os ambientes de
desenvolvimento. Você não precisa instalar o pacote ou registrar a extensão manualmente.
Gatilho
Um gatilho de HTTP permite invocar uma função com uma solicitação HTTP. Você pode usar um gatilho
de HTTP para criar APIs sem servidor e responder a webhooks.
Por padrão, um gatilho HTTP retorna HTTP 200 OK com um corpo vazio em funções de 1. x ou HTTP
204 sem conteúdo com um corpo vazio em funções 2. x. Para modificar a resposta, configure uma
associação de saída de HTTP.
Gatilho - exemplo
C#
C#Prescritiva
JavaScript
Python
Java
O exemplo a seguir mostra uma função C# que procura por um parâmetro name na cadeia de caracteres
de consulta ou no corpo da solicitação HTTP. Observe que o valor de retorno é usado para a associação
de saída, mas um atributo de valor de retorno não é necessário.
[FunctionName("HttpTriggerCSharp")]
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
HttpRequest req, ILogger log)
{

return name != null

: new BadRequestObjectResult("Please pass a name on the query string or in the request
body");
}
Gatilho - atributos
Em C# bibliotecas de classes e Java, o atributo HttpTrigger está disponível para configurar a função.
Você pode definir o nível de autorização e os métodos HTTP permitidos em parâmetros de construtor de
atributo, tipo de webhook e um modelo de rota. Para saber mais informações sobre essas configurações,
consulte Gatilho - configuração.
C#
C#Prescritiva
JavaScript
Python
Java
Este exemplo demonstra como usar o atributo HttpTrigger .
[FunctionName("HttpTriggerCSharp")]
public static Task<IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous)] HttpRequest req)
{
...
}
Para obter um exemplo completo, consulte o exemplo de gatilho.

function.json e o HttpTrigger atributo.
tipo n/d Obrigatório – deve ser definido

como httpTrigger .
direction n/d Obrigatório – deve ser definido

como in .
name n/d Obrigatório – o nome da variável

usado no código da função da
solicitação ou do corpo da
solicitação.
authLevel AuthLevel Determina quais chaves, se houver,

precisam estar presentes na
solicitação para invocar a função. O
nível de autorização pode ser um
dos seguintes valores:
anonymous —Nenhuma
chave API é obrigatória.
function —Uma chave de
API específica de função é
obrigatória. Esse será o valor
padrão se nenhum for
fornecido.
admin —A chave mestra é
obrigatória.
Para saber mais informações, veja a
seção sobre chaves de autorização.
methods Métodos Uma matriz dos métodos HTTP para

a qual a função responde. Se não for
especificada, a função responderá a
todos os métodos HTTP. Consulte
personalização do ponto de
extremidade http.
route Route Define o modelo da rota,

controlando para quais URLs de
solicitação sua função responde. O
valor padrão se nenhum for
fornecido será <functionname> .
Para saber mais informações,
consulte personalização do ponto de
extremidade http.
webHookType WebHookType Com suporte apenas na versão 1.x

do tempo de execução.
Configure o gatilho HTTP para atuar

como um receptor de webhook para
o provedor especificado. Não defina
a propriedade methods se você
definir essa propriedade. O tipo de
webhook pode ser um dos
seguintes valores:
genericJson —Um ponto
de extremidade de webhook
de finalidade geral sem lógica
para um provedor específico.
Essa configuração restringe
as solicitações àquelas que
usam HTTP POST e com o
tipo de conteúdo
application/json .
github —A função
responde a webhooks do
GitHub. Não use a
propriedade authLevel com
os webhooks do GitHub.
consulte a seção sobre
webhooks do GitHub
posteriormente neste artigo.
slack —A função responde
a webhooks do Slack. Não
use a propriedade authLevel
com os webhooks do Slack.
consulte a seção sobre
webhooks do Slack
posteriormente neste artigo.
Gatilho - uso
O tipo de entrada do gatilho é declarado como HttpRequest ou um tipo personalizado. Ao escolher
HttpRequest , você obterá acesso completo ao objeto de solicitação. Para um tipo personalizado, o tempo
de execução tenta analisar o corpo da solicitação JSON para definir as propriedades do objeto.
Personalização do ponto de extremidade HTTP
Por padrão quando você cria uma função para um gatilho HTTP, a função é endereçável com uma rota do
formulário:
http://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>
Você pode personalizar essa rota usando a propriedade route opcional na associação de entrada do
gatilho HTTP. Por exemplo, o seguinte arquivo function.json define uma propriedade route para um
gatilho HTTP:
{
"bindings": [
{
"name": "req",
"direction": "in",
"methods": [ "get" ],
"route": "products/{category:alpha}/{id:int?}"
},
{
"type": "http",
"name": "res",
"direction": "out"
}
]
}
Usando esta configuração, a função é agora endereçável com a seguinte rota em vez da rota original.
http://<APP_NAME>.azurewebsites.net/api/products/electronics/357
Isso permite que o código de função dê suporte a dois parâmetros no endereço, category e id.
C#
C#Prescritiva
JavaScript
Python
Java
Você pode usar qualquer Restrição de rota de API Web com seus parâmetros. O seguinte código de
função em C# faz uso de ambos os parâmetros.
using System.Net;
public static IActionResult Run(HttpRequest req, string category, int? id, ILogger log)
{
var message = String.Format($"Category: {category}, ID: {id}");
return (ActionResult)new OkObjectResult(message);
}
Por padrão, todas as rotas de função são prefixadas com api. Você também pode personalizar ou remover
o prefixo usando a propriedade http.routePrefix em seu arquivo host.json. O exemplo a seguir remove
o prefixo de rota api usando uma cadeia de caracteres vazia para o prefixo no arquivo host.json.
{
"http": {
"routePrefix": ""
}
}
Trabalhando com identidades de clientes

Se seu aplicativo de função estiver usando Serviço de Aplicativo de Autenticação / Autorização, você
poderá visualizar informações sobre clientes autenticados a partir de seu código. Essas informações estão
disponíveis como headers de solicitação injetados pela plataforma.
Você também pode ler essas informações a partir de dados vinculados. Esse recurso está disponível
apenas para o tempo de execução do Functions 2.x. Atualmente, também está disponível apenas para
idiomas .NET.
C#
C#Prescritiva
JavaScript
Python
Java
As informações sobre clientes autenticados estão disponíveis como um ClaimsPrincipal. O
ClaimsPrincipal está disponível como parte do contexto da solicitação, conforme mostrado no exemplo a
seguir:
using System.Net;
using System.Security.Claims;
public static IActionResult Run(HttpRequest req, ILogger log)

{
ClaimsPrincipal identities = req.HttpContext.User;
// ...
return new OkObjectResult();
}
Como alternativa, o ClaimsPrincipal pode ser simplesmente incluído como um parâmetro adicional na
assinatura da função:
using System.Net;
using System.Security.Claims;
public static void Run(JObject input, ClaimsPrincipal principal, ILogger log)

{
// ...
return;
}
Chaves de autorização
As funções permitem o uso de chaves para dificultar o acesso aos pontos de extremidade de função
HTTP durante o desenvolvimento. Um gatilho HTTP padrão pode exigir que uma chave de API esteja
presente na solicitação.
IMPORTANT
Embora as chaves possam ajudar o ofuscar seus pontos de extremidade HTTP durante o desenvolvimento, elas
não foram projetadas como uma maneira de proteger um gatilho HTTP em produção. Para obter mais
informações, confira Proteger um ponto de extremidade HTTP em produção.
NOTE
No tempo de execução 1.x do Functions, os provedores de webhook podem usar chaves para autorizar solicitações
de várias maneiras, dependendo do suporte do provedor. Isso é abordado em Webhooks e chaves. A versão 2.x do
tempo de execução não inclui suporte interno para provedores de webhook.
Há dois tipos de chave:
Chaves de host: essas chaves são compartilhadas por todas as funções do aplicativo de funções.
Quando usadas como uma chave de API, elas permitem acesso a qualquer função no aplicativo de
funções.
Chaves de função: essas chaves se aplicam apenas às funções específicas sob as quais elas foram
definidas. Quando usadas como uma chave de API, elas permitem acesso apenas às funções em
questão.
Cada chave é nomeada para referência e há uma chave padrão (chamada "default") no nível de função e
de host. As chaves de função têm precedência sobre as chaves de host. Quando duas chaves forem
definidas com o mesmo nome, a chave de função sempre será usada.
Cada aplicativo de funções também tem uma chave mestra especial. Essa chave é uma chave de host
chamada _master , que fornece acesso administrativo às APIs de tempo de execução. Não é possível
revogar essa chave. Quando você define o nível de autorização como admin , as solicitações precisam
usar a chave mestra. Nesse caso, o uso de outra chave resulta em falha na autorização.
Cau t i on
Devido às permissões elevadas no aplicativo de funções concedidas pela chave mestra, você não deve
compartilhar essa chave com terceiros nem distribuí-la em aplicativos cliente nativos. Tenha cuidado ao
escolher o nível de autorização do administrador.
Obtendo chaves
As chaves são armazenadas como parte do seu aplicativo de funções no Azure e criptografadas em
repouso. Para exibir suas chaves, criar chaves ou gerar novos valores para as chaves, navegue até uma
das funções disparadas por HTTP no portal do Azure e selecione Gerenciar.
Você pode obter as chaves de função programaticamente usando APIs de gerenciamento de chaves.
Autorização da chave de API
A maioria dos modelos de gatilho HTTP exigem uma chave de API na solicitação. Portanto, a solicitação
HTTP geralmente será como a seguinte URL:
https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?code=<API_KEY>
A chave pode ser incluída em uma variável de cadeia de consulta chamada code , como acima. Ela
também pode ser incluída em um cabeçalho HTTP x-functions-key . O valor da chave pode ser qualquer
chave de função definida para a função ou qualquer chave de host.
Você pode permitir solicitações anônimas, o que não exige chaves. Você também pode exigir que a chave
mestra seja usada. Altere o nível de autorização padrão usando a propriedade authLevel no JSON de
associação. Para saber mais informações, consulte Gatilho - configuração.
NOTE
Durante a execução local de funções, a autorização fica desabilitada, independentemente da configuração de nível
de autenticação especificada. Após a publicação no Azure, a configuração authLevel no gatilho é imposta. As
chaves ainda são necessárias ao executar localmente em um contêiner.
Proteger um ponto de extremidade HTTP em produção

Para proteger totalmente os pontos de extremidade de função na produção, considere a implementação
de uma das seguintes opções de segurança no nível do aplicativo de funções:
Ativar a autenticação/autorização do Serviço de Aplicativo para o aplicativo de funções. A
plataforma do Serviço de Aplicativo permite usar o AAD (Azure Active Directory) e vários
provedores de identidade de terceiros para autenticar clientes. Você pode usar essas opções para
implementar regras de autorização personalizadas para suas funções e trabalhar com informações
de usuário por meio do código da função. Para saber mais, consulte Autenticação e autorização no
Serviço de Aplicativo do Azure e Trabalhando com identidades do cliente.
Use o APIM (Gerenciamento de API do Azure) para autenticar solicitações. O APIM fornece uma
variedade de opções de segurança de API para solicitações de entrada. Para saber mais, confira
Políticas de autenticação do Gerenciamento de API. Com o APIM em vigor, você pode configurar o
aplicativo de funções para aceitar solicitações somente do endereço IP da sua instância do APIM.
Para saber mais, confira Restrições de endereço IP.
Implante seu aplicativo de funções em um ASE (Ambiente do Serviço de Aplicativo) do Azure. O
ASE fornece um ambiente de hospedagem dedicado para que você execute suas funções. O ASE
permite configurar um único gateway de front-end que você pode usar para autenticar todas as
solicitações de entrada. Para obter mais informações, confira Configurando um WAF (firewall do
aplicativo Web) para o Ambiente do Serviço de Aplicativo.
Ao usar um dos seguintes métodos de segurança no nível do aplicativo de funções, você deve definir o
nível de autenticação da função disparada por HTTP como anonymous .
Webhooks
NOTE
O modo de webhook só está disponível para a versão 1.x do tempo de execução do Functions. Essa alteração foi
feita para melhorar o desempenho de gatilhos HTTP na versão 2.x.
Na versão 1.x, os modelos de webhook fornecem validação adicional para conteúdo de webhook. Na
versão 2.x, o gatilho HTTP base ainda funciona e é a abordagem recomendada para webhooks.
Webhooks do GitHub
Para responder a webhooks do GitHub, primeiramente crie sua função com um Gatilho HTTP e defina a
propriedade webHookType como github . Em seguida, copie a URL e a chave de API na página
Adicionar webhook do seu repositório GitHub.
Webhooks do Slack
O webhook do Slack gera um token em vez de permitir que você o especifique, de modo que é preciso
configurar uma chave específica de função com o token do Slack. Consulte Chaves de autorização.
Webhooks e chaves
A autorização de webhook é tratada pelo componente receptor do webhook, parte do gatilho HTTP e o
mecanismo varia com base no tipo de webhook. Cada mecanismo conta com uma chave. Por padrão, a
chave de função chamada "default" será usada. Para usar uma chave diferente, configure o provedor do
webhook para enviar o nome da chave com a solicitação de uma das seguintes maneiras:
Cadeia de caracteres de consulta: o provedor passa o nome da chave no parâmetro de cadeia de
caracteres de consulta clientid , como
https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME> .
Cabeçalho da solicitação: o provedor passa o nome da chave no cabeçalho x-functions-clientid .
Gatilho - limites
O tamanho da solicitação HTTP é limitado a 100 MB (104.857.600 bytes) e o tamanho da URL é limitado
a 4 KB (4.096 bytes). Esses limites são especificados pelo httpRuntime elemento do arquivo Web.config
do tempo de execução.
Se uma função que usa o gatilho HTTP não for concluída em aproximadamente 2,5 minutos, o gateway
atingirá o tempo limite e retornará o erro de HTTP 502. A função continuará em execução, mas não
poderá retornar uma resposta HTTP. Para funções de longa execução, é recomendável que você siga os
padrões async e retorna um local onde você pode executar ping do status da solicitação. Para obter
informações sobre o tempo que uma função pode executar, consulte Dimensionamento e hospedagem -
planejar o consumo.
Saída
Use a associação de saída HTTP para responder ao remetente da solicitação HTTP. Essa associação
requer um gatilho HTTP e permite que você personalize a resposta associada à solicitação do gatilho. Se
uma saída HTTP vinculada não é fornecida, um gatilho HTTP retorna HTTP 200 OK com um corpo vazio
em funções de 1. x ou HTTP 204 sem conteúdo com um corpo vazio em funções 2. x.
function.json. Para as bibliotecas de classes C#, não há propriedades de atributo que correspondem a
essas propriedades do function.json.
tipo Deve ser definido como http .
name O nome da variável usada no código de função para a

resposta, ou $return para usar o valor de retorno.
Saída - uso
Para enviar uma resposta HTTP, use os padrões de resposta padrão do idioma. Em c# ou script c#, faça o
tipo de retorno da função retorno IActionResult ou Task<IActionResult> . Em c#, um atributo de valor de
retorno não é necessário.
Por ver exemplos de respostas, confira o exemplo de gatilho.
Esta seção descreve as definições de configuração globais disponíveis para esta associação na versão 2.x.
O arquivo host.json de exemplo abaixo contém apenas as configurações da versão 2.x para essa
associação. Para obter mais informações sobre as configurações globais na versão 2.x, confira a referência
de host.json para o Azure Functions versão 2.x.
NOTE
{
"extensions": {
"http": {
"routePrefix": "api",
"maxOutstandingRequests": 200,
"maxConcurrentRequests": 100,
"dynamicThrottlesEnabled": true,
"hsts": {
"isEnabled": true,
"maxAge": "10"
},
"customHeaders": {
"X-Content-Type-Options": "nosniff"
}
}
}
}

customHeaders Nenhum Permite que você defina cabeçalhos

personalizados na resposta HTTP. O
exemplo anterior adiciona o
cabeçalho
X-Content-Type-Options à
resposta para evitar a detecção de
tipo de conteúdo.
dynamicThrottlesEnabled verdadeiro* Quando habilitada, essa

configuração faz o pipeline de
processamento de solicitação
verificar periodicamente os
contadores de desempenho do
sistema como
conexões/threads/processos/memóri
a/cpu/etc. e, se algum desses
contadores tiver excedido um alto
limite interno (80%), as solicitações
serão rejeitadas com a resposta 429
"Muito ocupado" até que os
contadores retornem aos níveis
normais.
* O padrão em um plano de
consumo é true . O padrão em um
plano dedicado é false .
hsts não habilitado Quando isEnabled é definido

como true , o comportamento de
HSTS (segurança de transporte
estrito http) do .NET Core é
imposto, conforme definido na
classe HstsOptions . O exemplo
acima também define a propriedade
maxAge como 10 dias.
maxConcurrentRequests 100* O número máximo de funções http

que são executadas em paralelo.
Isso permite controlar a
simultaneidade, o que pode ajudar a
gerenciar a utilização de recursos.
Por exemplo, talvez você tenha uma
função http que use muitos recursos
do sistema (memória/cpu/soquetes),
de modo que ela causará problemas
quando a simultaneidade for muito
alta. Ou talvez você tenha uma
função que faça solicitações de saída
a um serviço de terceiro, e essas
chamadas precisem ser limitadas por
taxa. Nesses casos, aplicar uma
limitação aqui pode ajudar.
* O padrão para um plano de
consumo é 100. O padrão para um
plano dedicado é não associado (
-1 ).
maxOutstandingRequests 200* O número máximo de solicitações

pendentes mantidas em um dado
momento. Esse limite inclui
solicitações que estão na fila, mas
não iniciaram a execução, bem como
qualquer execução em andamento.
Quaisquer solicitações recebidas
acima desse limite são rejeitadas
com uma resposta "Muito ocupado"
429. Isso permite que os
chamadores empreguem estratégias
de repetição com base em tempo e
também ajuda você a controlar as
latências máximas de solicitação.
Isso controla apenas o
enfileiramento que ocorre no
caminho de execução do host de
script. Outras filas, como a fila de
solicitação ASP.NET, ainda estarão
vigor e não serão afetadas por essa
configuração.
* padrão \The para um plano de
consumo é 200. O padrão para um
plano dedicado é não associado (
-1 ).
routePrefix api O prefixo da rota que se aplica a

todas as rotas. Use uma cadeia de
caracteres vazia para remover o
prefixo padrão.
Próximas etapas
Associações do Microsoft Graph do Azure
Functions
Este artigo explica como configurar e trabalhar com gatilhos e associações do Microsoft Graph no Azure
Functions. Com isso, você pode usar o Azure Functions para trabalhar com eventos, percepções e dados do
Microsoft Graph.
A extensão do Microsoft Graph oferece as seguintes associações:
Um associação de entrada do token de autenticação permite que você interaja com qualquer API do
Microsoft Graph.
Uma associação de entrada de tabela do Excel permite que você leia os dados do Excel.
Uma associação de saída de tabela do Excel permite que você modifique os dados do Excel.
Uma associação de entrada de arquivo do OneDrive permite que você leia arquivos no OneDrive.
Uma associação de saída de arquivo do OneDrive permite que você grave arquivos no OneDrive.
Uma associação de saída de mensagem do Outlook permite que você envie email por meio do Outlook.
Uma coleção de gatilhos e associações do Microsoft Graph webhook permite reagir a eventos do
Microsoft Graph.
NOTE
As associações do Microsoft Graph estão em versão prévia no momento para Azure Functions versão 2.x. Eles não
são suportados no Functions versão 1.x.
Pacotes
A associação de entrada de token de autenticação é fornecida no pacote NuGet
Microsoft.Azure.WebJobs.Extensions.AuthTokens. As outras associações do Microsoft Graph são
fornecidas no pacote Microsoft.Azure.WebJobs.Extensions.MicrosoftGraph. O código-fonte dos pacotes
está no repositório GitHub azure-functions-microsoftgraph-extension.
desenvolvimento.


Desenvolvimento local - script do C#, JavaScript, F#, Java Registrar a extensão

e Python
Como configurar as extensões

As associações do Microsoft Graph estão disponíveis por meio de extensões de associação. Extensões de
associação são componentes opcionais para o tempo de execução do Azure Functions. Esta seção mostra
como configurar o Microsoft Graph e as extensões de token de autenticação.
Habilitar versão prévia do Functions 2.0
Extensões de associação só estão disponíveis para versão prévia do Azure Functions 2.0.
Para obter informações sobre como configurar um aplicativo de funções para usar a versão prévia 2.0 do
tempo de execução do Functions, confira Como direcionar versões do tempo de execução do Azure
Functions.
Como instalar a extensão
Para instalar uma extensão do portal do Azure, navegue até um modelo ou associação que faça referência
a ela. Crie uma nova função e, enquanto estiver na tela de seleção de modelo, escolha o cenário "Microsoft
Graph". Selecione um dos modelos desse cenário. Como alternativa, você pode navegar até a guia
"Integração" de uma função existente e selecionar uma das associações abordadas neste artigo.
Em ambos os casos, um aviso será exibido especificando a extensão a ser instalada. Clique em Instalar
para obter a extensão. Cada extensão precisa ser instalada apenas uma vez por aplicativo de funções.
NOTE
O processo de instalação no portal pode levar até 10 minutos em um plano de consumo.
Se você estiver usando o Visual Studio, poderá obter as extensões instalando os pacotes do NuGet que
estão listados neste artigo.
Configurando a Autenticação/Autorização
As associações descritas neste artigo exigem que uma identidade seja usada. Isso permite que o Microsoft
Graph aplique permissões e interações de auditoria. A identidade pode ser um usuário acessando seu
aplicativo ou o aplicativo em si. Para configurar essa identidade, configure Autenticação/Autorização do
Serviço de Aplicativo com o Azure Active Directory. Você também precisará solicitar quaisquer permissões
de recurso que suas funções exijam.
NOTE
A extensão do Microsoft Graph tem suporte apenas para autenticação do Azure AD. Os usuários precisam fazer
logon com uma conta corporativa ou de estudante.
Se estiver usando o portal do Azure, você verá um aviso abaixo do prompt para instalar a extensão. O
aviso que solicita que você configure a Autenticação/Autorização do Serviço de Aplicativo e solicita
quaisquer permissões de que o modelo ou associação precise. Clique em Configurar Azure AD agora ou
Adicionar permissões agora conforme apropriado.
Token de autenticação
Essas associações de entrada do token de autenticação obtêm um token do Azure AD para um
determinado recurso e fornece-o ao seu código como uma cadeia de caracteres. O recurso pode ser
qualquer um para o qual o aplicativo tenha permissões.
Essa seção contém os seguintes procedimentos:
Exemplo
Atributos
Configuração
Uso
Token de autenticação - exemplo
Script do C# (.csx)
JavaScript
Token de autenticação - exemplo de script C#
O seguinte exemplo obtém informações do perfil do usuário.
O arquivo function.json define um gatilho HTTP com uma associação de entrada do token:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "token",
"direction": "in",
"name": "graphToken",
"resource": "https://graph.microsoft.com",
"identity": "userFromRequest"
},
{
"name": "$return",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do script C# usa o token para fazer uma chamada HTTP para o Microsoft Graph e retorna o
resultado:
using System.Net;
using System.Net.Http.Headers;
public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, string graphToken, ILogger

log)
{
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", graphToken);
return await client.GetAsync("https://graph.microsoft.com/v1.0/me/");
}
Token de autenticação - exemplo de JavaScript

O seguinte exemplo obtém informações do perfil do usuário.
O arquivo function.json define um gatilho HTTP com uma associação de entrada do token:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "token",
"direction": "in",
"name": "graphToken",
"resource": "https://graph.microsoft.com",
},
{
"name": "res",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do JavaScript usa o token para fazer uma chamada HTTP para o Microsoft Graph e retorna o
resultado.
const rp = require('request-promise');

let token = "Bearer " + context.bindings.graphToken;
let options = {
uri: 'https://graph.microsoft.com/v1.0/me/',
headers: {
'Authorization': token
}
};
rp(options)
.then(function(profile) {
context.res = {
body: profile
};
context.done();
})
.catch(function(err) {
context.res = {
status: 500,
body: err
};
context.done();
});
};
Token de autenticação - atributos

Em bibliotecas de classes do C#, use o atributo Token.
Token de autenticação - configuração
function.json e no atributo Token .
name Obrigatório – o nome da variável

usada no código de função para o
token de autenticação. Consulte
Como usar uma associação de
entrada do token de autenticação do
código.
type Obrigatório – deve ser definido como

token .
direction Obrigatório – deve ser definido como

in .
identidade Identidade Obrigatório – a identidade que será

usada para executar a ação. Pode ser
um dos seguintes valores:
userFromRequest – válida
apenas com gatilho HTTP.
Usa a identidade do usuário
responsável pela chamada.
userFromId – usa a
identidade de um usuário
conectado anteriormente
com a ID especificada.
Consulte a propriedade
userId .
userFromToken – usa a
identidade representada pelo
token especificado. Consulte
a propriedade userToken .
clientCredentials – usa a
identidade do aplicativo de
funções.
userId UserId Necessário se, e somente se, a

identidade estiver definida como
userFromId . Uma ID de entidade
de usuário associada a um usuário
conectado anteriormente.
userToken UserToken Necessário se, e somente se, a

userFromToken . Um token válido
para o aplicativo de função.
Recurso resource Obrigatório – uma URL de recurso

do Azure AD para a qual o token
está sendo solicitado.
Token de autenticação - uso

A associação em si não requer permissões do Azure AD, mas, dependendo de como o token é usado, talvez
seja necessário solicitar permissões adicionais. Verifique os requisitos do recurso que você pretende
acessar com o token.
O token sempre é apresentado ao código como uma cadeia de caracteres.
NOTE
Ao desenvolver localmente com qualquer opção de userFromId , userFromToken ou userFromRequest , o token
necessário pode ser obtido manualmente e especificado no cabeçalho de solicitação X-MS-TOKEN-AAD-ID-TOKEN de
um aplicativo de cliente de chamada.
Entrada do Excel
Essa associação de entrada de tabela do Excel lê o conteúdo de uma tabela do Excel armazenada no
OneDrive.
Exemplo
Atributos
Configuração
Uso
Entrada do Excel - exemplo
Script do C# (.csx)
JavaScript
Entrada do Excel - exemplo de script C#
O arquivo function.json a seguir define um gatilho HTTP com uma associação de entrada do Excel:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "excel",
"direction": "in",
"name": "excelTableData",
"path": "{query.workbook}",
"identity": "UserFromRequest",
"tableName": "{query.table}"
},
{
"name": "$return",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do script C# a seguir lê o conteúdo da tabela especificada e retorna-o ao usuário:
using System.Net;
public static IActionResult Run(HttpRequest req, string[][] excelTableData, ILogger log)

{
return new OkObjectResult(excelTableData);
}
Entrada do Excel - exemplo de JavaScript

O arquivo function.json a seguir define um gatilho HTTP com uma associação de entrada do Excel:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "excel",
"direction": "in",
"name": "excelTableData",
"identity": "UserFromRequest",
},
{
"name": "res",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do JavaScript a seguir lê o conteúdo da tabela especificada e retorna-o ao usuário.

context.res = {
body: context.bindings.excelTableData
};
context.done();
};
Entrada do Excel - atributos

Em bibliotecas de classes do C#, use o atributo Excel.
Entrada do Excel - configuração
function.json e no atributo Excel .

usada no código de função para a
tabela do Excel. Consulte Como usar
uma associação de entrada de tabela
do Excel do código.

excel .

in .

userId .
funções.


path Caminho Obrigatório – o caminho no

OneDrive para a pasta de trabalho
do Excel.
worksheetName WorksheetName A planilha em que a tabela é

encontrada.
tableName TableName O nome da tabela. Se não for

especificado, o conteúdo da planilha
será usado.
Entrada do Excel - uso

Esta associação exige as seguintes permissões do Azure AD:
RESOURCE PERMISSÃO
Microsoft Graph Ler arquivos de usuário
A associação expõe os seguintes tipos a funções .NET:

string[][]
Microsoft.Graph.WorkbookTable
Tipos de objetos personalizados (usando o model binding estrutural)
Saída do Excel
A associação de saída do Excel modifica o conteúdo de uma tabela do Excel armazenada no OneDrive.
Exemplo
Atributos
Configuração
Uso
Saída do Excel - exemplo
Script do C# (.csx)
JavaScript
Saída do Excel - exemplo de script C#
O exemplo a seguir adiciona linhas a uma tabela do Excel.
O arquivo function.json define um gatilho HTTP com uma associação de saída do Excel:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"name": "newExcelRow",
"type": "excel",
"direction": "out",
"identity": "userFromRequest",
"updateType": "append",
},
{
"name": "$return",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do script C# adiciona uma nova linha à tabela (presumidamente de uma única coluna) com base
na entrada da cadeia de caracteres de consulta:
using System.Net;
using System.Text;
public static async Task Run(HttpRequest req, IAsyncCollector<object> newExcelRow, ILogger log)
{
string input = req.Query
.FirstOrDefault(q => string.Compare(q.Key, "text", true) == 0)
.Value;
await newExcelRow.AddAsync(new {
Text = input
// Add other properties for additional columns here
});
return;
}
Saída do Excel - exemplo de JavaScript

O exemplo a seguir adiciona linhas a uma tabela do Excel.
O arquivo function.json define um gatilho HTTP com uma associação de saída do Excel:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"name": "newExcelRow",
"type": "excel",
"direction": "out",
"identity": "userFromRequest",
"updateType": "append",
},
{
"name": "res",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do JavaScript a seguir adiciona uma nova linha à tabela (presumidamente de uma única coluna)
com base na entrada da cadeia de caracteres de consulta.

context.bindings.newExcelRow = {
text: req.query.text
// Add other properties for additional columns here
}
context.done();
};
Saída do Excel - atributos

Em bibliotecas de classes do C#, use o atributo Excel.
Saída do Excel - configuração
function.json e no atributo Excel .

token de autenticação. Consulte
Como usar uma associação de saída
de tabela do Excel do código.

excel .

out .

userId .
funções.
UserId userId Necessário se, e somente se, a


path Caminho Obrigatório – o caminho no

OneDrive para a pasta de trabalho
do Excel.
worksheetName WorksheetName A planilha em que a tabela é

encontrada.
tableName TableName O nome da tabela. Se não for

especificado, o conteúdo da planilha
será usado.
updateType UpdateType Obrigatório – o tipo de alteração a

fazer na tabela. Pode ser um dos
seguintes valores:
update – substitui o
conteúdo da tabela no
OneDrive.
append – adiciona a carga
no final da tabela no
OneDrive criando novas
linhas.
Saída do Excel - uso

RESOURCE PERMISSÃO
Microsoft Graph Ter acesso completo aos arquivos do usuário

string[][]
Newtonsoft.Json.Linq.JObject
Microsoft.Graph.WorkbookTable
Entrada do arquivo
Essa associação de entrada do Arquivo do OneDrive lê o conteúdo de um arquivo armazenado no
OneDrive.
Exemplo
Atributos
Configuração
Uso
Entrada do Arquivo - exemplo
Script do C# (.csx)
JavaScript
Entrada do Arquivo - exemplo de script C#
O exemplo a seguir lê um arquivo que está armazenado no OneDrive.
O arquivo function.json define um gatilho HTTP com uma associação de entrada do arquivo do OneDrive:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"name": "myOneDriveFile",
"type": "onedrive",
"direction": "in",
"path": "{query.filename}",
},
{
"name": "$return",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do script C# lê o arquivo especificado na cadeia de caracteres de consulta e registra seu

comprimento:
using System.Net;
public static void Run(HttpRequestMessage req, Stream myOneDriveFile, ILogger log)

{
log.LogInformation(myOneDriveFile.Length.ToString());
}
Entrada do Arquivo - exemplo de JavaScript

O exemplo a seguir lê um arquivo que está armazenado no OneDrive.
O arquivo function.json define um gatilho HTTP com uma associação de entrada do arquivo do OneDrive:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "onedrive",
"direction": "in",
"path": "{query.filename}",
},
{
"name": "res",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do JavaScript a seguir lê o arquivo especificado na cadeia de caracteres de consulta e registra seu
comprimento.

context.res = {
body: context.bindings.myOneDriveFile.length
};
context.done();
};
Entrada do arquivo - atributos

Em bibliotecas de classes do C#, use o atributo OneDrive.
Entrada do arquivo - configuração
function.json e no atributo OneDrive .

arquivo. Consulte Como usar uma
associação de entrada de arquivo do
OneDrive do código.

onedrive .

in .

userId .
funções.


path Caminho Obrigatória – o caminho no

OneDrive para o arquivo.
Entrada do arquivo - uso

RESOURCE PERMISSÃO
Microsoft Graph Ler arquivos de usuário

byte[]
Fluxo
Microsoft.Graph.DriveItem
Saída do arquivo
Essa associação de saída do arquivo do OneDrive modifica o conteúdo de um arquivo armazenado no
OneDrive.
Exemplo
Atributos
Configuração
Uso
Saída do arquivo - exemplo
Script do C# (.csx)
JavaScript
Saída do arquivo - exemplo de script C#
O exemplo a seguir grava um arquivo que está armazenado no OneDrive.
O arquivo function.json define um gatilho HTTP com uma associação de saída do OneDrive:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "onedrive",
"direction": "out",
"path": "FunctionsTest.txt",
},
{
"name": "$return",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do script C# obtém o texto da cadeia de caracteres de consulta e grava-o em um arquivo de texto
(FunctionsTest.txt conforme definido na configuração acima) na raiz do OneDrive do chamador:
using System.Net;
using System.Text;
public static async Task Run(HttpRequest req, ILogger log, Stream myOneDriveFile)
{
string data = req.Query
.FirstOrDefault(q => string.Compare(q.Key, "text", true) == 0)
.Value;
await myOneDriveFile.WriteAsync(Encoding.UTF8.GetBytes(data), 0, data.Length);
myOneDriveFile.Close();
return;
}
Saída do arquivo - exemplo de JavaScript

O exemplo a seguir grava um arquivo que está armazenado no OneDrive.
O arquivo function.json define um gatilho HTTP com uma associação de saída do OneDrive:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "onedrive",
"direction": "out",
"path": "FunctionsTest.txt",
},
{
"name": "res",
"type": "http",
"direction": "out"
}
],
"disabled": false
}
O código do JavaScript obtém o texto da cadeia de caracteres de consulta e grava-o em um arquivo de

texto (FunctionsTest.txt conforme definido na configuração acima) na raiz do OneDrive do chamador.

context.bindings.myOneDriveFile = req.query.text;
context.done();
};
Saída do arquivo - atributos

Em bibliotecas de classes do C#, use o atributo OneDrive.
Saída do arquivo - configuração
function.json e no atributo OneDrive .

arquivo. Consulte Como usar uma
associação de saída de arquivo do
OneDrive do código.

onedrive .

out .

userId .
funções.
UserId userId Necessário se, e somente se, a


path Caminho Obrigatória – o caminho no

OneDrive para o arquivo.
Saída do arquivo - uso

RESOURCE PERMISSÃO
Microsoft Graph Ter acesso completo aos arquivos do usuário

byte[]
Fluxo
Microsoft.Graph.DriveItem
Saída de Outlook
A associação de saída de mensagem do Outlook envia uma mensagem de email por meio do Outlook.
Exemplo
Atributos
Configuração
Uso
Saída do Outlook - exemplo
Script do C# (.csx)
JavaScript
Saída do Outlook - exemplo de script C#
O exemplo a seguir envia um email pelo Outlook.
O arquivo function.json define um gatilho HTTP com uma associação de saída de mensagem do Outlook:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"name": "message",
"type": "outlook",
"direction": "out",
}
],
"disabled": false
}
O código do script C# envia um email do chamador para um destinatário especificado na cadeia de

caracteres de consulta:
using System.Net;
public static void Run(HttpRequest req, out Message message, ILogger log)
{
string emailAddress = req.Query["to"];
message = new Message(){
subject = "Greetings",
body = "Sent from Azure Functions",
recipient = new Recipient() {
address = emailAddress
}
};
}
public class Message {

public String subject {get; set;}
public String body {get; set;}
public Recipient recipient {get; set;}
}
public class Recipient {

public String address {get; set;}
public String name {get; set;}
}
Saída do Outlook - exemplo de JavaScript
O exemplo a seguir envia um email pelo Outlook.
O arquivo function.json define um gatilho HTTP com uma associação de saída de mensagem do Outlook:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"name": "message",
"type": "outlook",
"direction": "out",
}
],
"disabled": false
}
O código do JavaScript envia um email do chamador para um destinatário especificado na cadeia de

caracteres de consulta:

context.bindings.message = {
subject: "Greetings",
body: "Sent from Azure Functions with JavaScript",
recipient: {
address: req.query.to
}
};
context.done();
};
Saída do Outlook - atributos

Em bibliotecas de classes do C#, use o atributo Outlook.
Saída do Outlook - configuração
function.json e no atributo Outlook .
name Obrigatória – o nome da variável

mensagem de email. Consulte Como
usar uma associação de saída da
mensagem do Outlook do código.

outlook .

out .

userId .
funções.


Saída de Outlook - uso

RESOURCE PERMISSÃO
Microsoft Graph Enviar email como usuário

Microsoft.Graph.Message
Newtonsoft.Json.Linq.JObject
webhooks
Webhooks permitem reagir a eventos no Microsoft Graph. Para dar suporte a webhooks, são necessárias
funções para criar, atualizar e reagir a assinaturas de webhook. Uma solução completa de webhook exige
uma combinação das seguintes associações:
Um gatilho de webhook do Microsoft Graph permite reagir a um webhook de entrada.
Uma associação de entrada de assinatura do webhook do Microsoft Graph permite que você liste as
assinaturas existentes e, opcionalmente, atualize-as.
Uma associação de saída de assinatura de webhook do Microsoft Graph permite que você crie ou
exclua assinaturas do webhook.
As associações em si não exigem permissões do Azure AD, mas você precisa solicitar permissões
relevantes para o tipo de recurso ao qual você deseja reagir. Para obter uma lista de quais permissões são
necessárias para cada tipo de recurso, consulte permissões de assinatura.
Para obter mais informações sobre webhooks, confira Como trabalhar com webhooks no Microsoft Graph.
Gatilho de webhook
O gatilho de webhook do Microsoft Graph permite que uma função reaja a um webhook de entrada do
Microsoft Graph. Cada instância deste gatilho pode reagir a um tipo de recurso do Microsoft Graph.
Exemplo
Atributos
Configuração
Uso
Gatilho de webhook - exemplo
Script do C# (.csx)
JavaScript
Gatilho de webhook - exemplo de script C#
O exemplo a seguir manipula webhooks de mensagens de entrada do Outlook. Para usar um gatilho de
webhook, crie uma assinatura e poderá atualizar a assinatura para impedir a expiração.
O arquivo function.json define um gatilho de webhook:
{
"bindings": [
{
"name": "msg",
"type": "GraphWebhookTrigger",
"direction": "in",
"resourceType": "#Microsoft.Graph.Message"
}
],
"disabled": false
}
O código do script C# reage a mensagens de email de entrada e registra o corpo daquelas enviadas pelo
destinatário e que contêm "Azure Functions" no assunto:
#r "Microsoft.Graph"
using Microsoft.Graph;
using System.Net;
public static async Task Run(Message msg, ILogger log)

{
log.LogInformation("Microsoft Graph webhook trigger function processed a request.");
// Testable by sending oneself an email with the subject "Azure Functions" and some text body
if (msg.Subject.Contains("Azure Functions") && msg.From.Equals(msg.Sender)) {
log.LogInformation($"Processed email: {msg.BodyPreview}");
}
}
Gatilho de webhook - exemplo de JavaScript

O exemplo a seguir manipula webhooks de mensagens de entrada do Outlook. Para usar um gatilho de
webhook, crie uma assinatura e poderá atualizar a assinatura para impedir a expiração.
O arquivo function.json define um gatilho de webhook:
{
"bindings": [
{
"name": "msg",
"type": "GraphWebhookTrigger",
"direction": "in",
"resourceType": "#Microsoft.Graph.Message"
}
],
"disabled": false
}
O código do JavaScript reage a mensagens de email de entrada e registra o corpo daquelas enviadas pelo
destinatário e que contêm "Azure Functions" no assunto:

context.log("Microsoft Graph webhook trigger function processed a request.");
const msg = context.bindings.msg
// Testable by sending oneself an email with the subject "Azure Functions" and some text body
if((msg.subject.indexOf("Azure Functions") > -1) && (msg.from === msg.sender) ) {
context.log(`Processed email: ${msg.bodyPreview}`);
}
context.done();
};
Gatilho de webhook - atributos

Em C# bibliotecas de classes, use o atributo GraphWebhookTrigger .
Gatilho de webhook - configuração
function.json e no atributo GraphWebhookTrigger .



graphWebhook .

trigger .
resourceType ResourceType Obrigatório – o recurso de grafo

para o qual essa função deve
responder a webhooks. Pode ser um
dos seguintes valores:
#Microsoft.Graph.Message
– alterações feitas em
mensagens do Outlook.
#Microsoft.Graph.DriveItem
– alterações feitas aos itens
de raiz do OneDrive.
#Microsoft.Graph.Contact
- as alterações feitas nos
contatos pessoais do
Outlook.
#Microsoft.Graph.Event -
as alterações feitas em itens
de calendário do Outlook.
NOTE
Um aplicativo de funções só pode ter uma função que esteja registrada em relação a um determinado valor de
resourceType .
Gatilho de webhook - uso

Tipos de SDK do Microsoft Graph relevantes ao tipo de recurso, por exemplo, Microsoft.Graph.Message
ou Microsoft.Graph.DriveItem .
Entrada do webhook
A associação da entrada do webhook do Microsoft Graph permite recuperar a lista de assinaturas
gerenciadas por este aplicativo de funções. A associação lê do armazenamento do aplicativo de funções e,
assim, não reflete outras assinaturas criadas de fora do aplicativo.
Exemplo
Atributos
Configuração
Uso
Entrada de webhook - exemplo
Script do C# (.csx)
JavaScript
Entrada de webhook - exemplo de script C#
O exemplo a seguir obtém todas as assinaturas para o usuário que está chamando e as exclui.
O arquivo function.json define um gatilho HTTP com uma associação de entrada de assinatura e uma
associação de saída de assinatura que usa a ação de excluir:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"type": "graphWebhookSubscription",
"name": "existingSubscriptions",
"direction": "in",
"filter": "userFromRequest"
},
{
"name": "subscriptionsToDelete",
"direction": "out",
"action": "delete",
},
{
"type": "http",
"name": "res",
"direction": "out"
}
],
"disabled": false
}
O código do script C# obtém as assinaturas e as exclui:
using System.Net;
public static async Task Run(HttpRequest req, string[] existingSubscriptions, IAsyncCollector<string>

subscriptionsToDelete, ILogger log)
{
foreach (var subscription in existingSubscriptions)
{
log.LogInformation($"Deleting subscription {subscription}");
await subscriptionsToDelete.AddAsync(subscription);
}
}
Entrada de webhook - exemplo de JavaScript

O exemplo a seguir obtém todas as assinaturas para o usuário que está chamando e as exclui.
O arquivo function.json define um gatilho HTTP com uma associação de entrada de assinatura e uma
associação de saída de assinatura que usa a ação de excluir:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"direction": "in",
"filter": "userFromRequest"
},
{
"name": "subscriptionsToDelete",
"direction": "out",
"action": "delete",
},
{
"type": "http",
"name": "res",
"direction": "out"
}
],
"disabled": false
}
O código do JavaScript obtém as assinaturas e as exclui:

const existing = context.bindings.existingSubscriptions;
var toDelete = [];
for (var i = 0; i < existing.length; i++) {
context.log(`Deleting subscription ${existing[i]}`);
todelete.push(existing[i]);
}
context.bindings.subscriptionsToDelete = toDelete;
context.done();
};
Entrada de webhook - atributos

Em C# bibliotecas de classes, use o atributo GraphWebhookSubscription .
Entrada de webhook - configuração
function.json e no atributo GraphWebhookSubscription .


graphWebhookSubscription .

in .
filter Filter Se definido como userFromRequest

, a associação apenas recuperará
assinaturas pertencentes ao usuário
que está chamando (válido somente
com gatilho HTTP).
Entrada de webhook - uso

string[]
Matrizes de tipo de objeto personalizado
Newtonsoft.Json.Linq.JObject[]
Microsoft.Graph.Subscription[]
Saída de webhook
Essa associação de saída de assinatura de webhook permite que você crie, exclua e atualize as assinaturas
de webhook no Microsoft Graph.
Exemplo
Atributos
Configuração
Uso
Saída de webhook - exemplo
Script do C# (.csx)
JavaScript
Saída de webhook - exemplo de script C#
O exemplo a seguir cria uma assinatura. Você pode atualizar uma assinatura para impedir que ela expire.
O arquivo function.json define um gatilho HTTP com uma associação de saída de assinatura usando a ação
de criar:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"name": "clientState",
"direction": "out",
"action": "create",
"subscriptionResource": "me/mailFolders('Inbox')/messages",
"changeTypes": [
"created"
],
},
{
"type": "http",
"name": "$return",
"direction": "out"
}
],
"disabled": false
}
O código do script C# registra um webhook que notificará esse aplicativo de funções quando o usuário que
está chamando receber uma mensagem do Outlook:
using System;
using System.Net;
public static HttpResponseMessage run(HttpRequestMessage req, out string clientState, ILogger log)
{
clientState = Guid.NewGuid().ToString();
return new HttpResponseMessage(HttpStatusCode.OK);
}
Saída de webhook - exemplo de JavaScript

O exemplo a seguir cria uma assinatura. Você pode atualizar uma assinatura para impedir que ela expire.
O arquivo function.json define um gatilho HTTP com uma associação de saída de assinatura usando a ação
de criar:
{
"bindings": [
{
"name": "req",
"direction": "in"
},
{
"name": "clientState",
"direction": "out",
"action": "create",
"subscriptionResource": "me/mailFolders('Inbox')/messages",
"changeTypes": [
"created"
],
},
{
"type": "http",
"name": "$return",
"direction": "out"
}
],
"disabled": false
}
O código do JavaScript registra um webhook que notificará esse aplicativo de funções quando o usuário
que está chamando receber uma mensagem do Outlook:
const uuidv4 = require('uuid/v4');

context.bindings.clientState = uuidv4();
context.done();
};
Saída de webhook - atributos

Em C# bibliotecas de classes, use o atributo GraphWebhookSubscription .
Saída de webhook - configuração
function.json e no atributo GraphWebhookSubscription .


graphWebhookSubscription .

out .

userId .
funções.


action Ação Obrigatório – especifica a ação que a

associação deve executar. Pode ser
create – registrar uma
nova assinatura.
delete – exclui uma
assinatura especificada.
refresh – atualiza uma
assinatura especificada para
impedir que ela expire.
subscriptionResource SubscriptionResource Necessário se e somente se a ação

estiver definida como create .
Especifica o recurso Microsoft Graph
que será monitorado quanto a
alterações. Consulte Como trabalhar
com webhooks no Microsoft Graph.
changeType ChangeType Necessário se e somente se a ação

estiver definida como create .
Indica o tipo de alteração no recurso
assinado que gerará uma notificação.
Os valores com suporte são:
created , updated , deleted .
Você pode combinar diversos valores
usando uma lista separada por
vírgulas.
Saída de webhook - uso

Microsoft.Graph.Subscription
Atualização de assinatura de webhook

Há duas abordagens para atualizar assinaturas:
Use a identidade do aplicativo para lidar com todas as assinaturas. Isso requer o consentimento do
administrador do Azure Active Directory. Isso pode ser usado por todos os idiomas com suporte no
Azure Functions.
Use a identidade associada a cada assinatura associando manualmente cada ID de usuário. Isso exigirá
algum código personalizado para executar a associação. Isso pode ser usado somente por funções .NET.
Esta seção contém um exemplo para cada uma destas abordagens:
Exemplo de identidade de aplicativo
Exemplo de identidade de usuário
Atualização de assinatura de Webhook - exemplo de identidade de aplicativo
Script do C# (.csx)
JavaScript
Atualização de identidade de aplicativo - exemplo de script C#
O exemplo a seguir usa a identidade do aplicativo para atualizar uma assinatura.
O arquivo function.json define um gatilho de temporizador com uma associação de entrada de assinatura e
uma associação de saída de assinatura:
{
"bindings": [
{
"name": "myTimer",
"type": "timerTrigger",
"direction": "in",
"schedule": "0 * * */2 * *"
},
{
"direction": "in"
},
{
"name": "subscriptionsToRefresh",
"direction": "out",
"action": "refresh",
"identity": "clientCredentials"
}
],
"disabled": false
}
O código do script C# atualiza as assinaturas:
using System;
public static void Run(TimerInfo myTimer, string[] existingSubscriptions, ICollector<string>

subscriptionsToRefresh, ILogger log)
{
// This template uses application permissions and requires consent from an Azure Active Directory
admin.
// See https://go.microsoft.com/fwlink/?linkid=858780
{
log.LogInformation($"Refreshing subscription {subscription}");
subscriptionsToRefresh.Add(subscription);
}
}
Atualização de identidade de aplicativo - exemplo de script C#

O exemplo a seguir usa a identidade do aplicativo para atualizar uma assinatura.
O arquivo function.json define um gatilho de temporizador com uma associação de entrada de assinatura e
uma associação de saída de assinatura:
{
"bindings": [
{
"name": "myTimer",
"direction": "in",
"schedule": "0 * * */2 * *"
},
{
"direction": "in"
},
{
"name": "subscriptionsToRefresh",
"direction": "out",
"action": "refresh",
"identity": "clientCredentials"
}
],
"disabled": false
}
O código do JavaScript atualiza as assinaturas:
// This template uses application permissions and requires consent from an Azure Active Directory
admin.
// See https://go.microsoft.com/fwlink/?linkid=858780

const existing = context.bindings.existingSubscriptions;
var toRefresh = [];
for (var i = 0; i < existing.length; i++) {
context.log(`Refreshing subscription ${existing[i]}`);
toRefresh.push(existing[i]);
}
context.bindings.subscriptionsToRefresh = toRefresh;
context.done();
};
Atualização de assinatura de Webhook - exemplo de identidade de usuário

O exemplo a seguir utiliza a identidade do usuário para atualizar uma assinatura.
O arquivo function.json define um gatilho de temporizador e adia a associação de entrada de assinatura
para o código de função:
{
"bindings": [
{
"name": "myTimer",
"direction": "in",
"schedule": "0 * * */2 * *"
},
{
"direction": "in"
}
],
"disabled": false
}
O código do script C# atualiza as assinaturas e cria a associação de saída no código usando a identidade de
cada usuário:
using System;
public static async Task Run(TimerInfo myTimer, UserSubscription[] existingSubscriptions, IBinder

binder, ILogger log)
{
{
// binding in code to allow dynamic identity
using (var subscriptionsToRefresh = await binder.BindAsync<IAsyncCollector<string>>(
new GraphWebhookSubscriptionAttribute() {
Action = "refresh",
Identity = "userFromId",
UserId = subscription.UserId
}
))
{
log.LogInformation($"Refreshing subscription {subscription}");
await subscriptionsToRefresh.AddAsync(subscription);
}
}
}
public class UserSubscription {

public string UserId {get; set;}
public string Id {get; set;}
}
Próximas etapas
Associações de Aplicativos Móveis para o Azure
Functions
NOTE
Associações de aplicativos móveis do Azure só estão disponíveis para o Azure Functions 1.x. Eles não têm suporte no Azure
Functions 2.x.
Este artigo explica como trabalhar com associações dos Aplicativos Móveis do Azure no Azure Functions. O
Azure Functions dá suporte a associações de entrada e saída para os Aplicativos Móveis.
As associações dos Aplicativos Móveis permitem ler e atualizar tabelas de dados em aplicativos móveis.
As ligações de aplicativos para dispositivos móveis são fornecidas no pacote do
Microsoft.Azure.WebJobs.Extensions.MobileApps NuGet, versão 1.x. O código-fonte do pacote está no
repositório GitHub azure-webjobs-sdk-extensions.

Entrada
A associação de entrada dos Aplicativos Móveis carrega um registro de um ponto de extremidade de tabela
móvel e o passa para a função. Em funções do C# ou do F#, todas as alterações feitas no registro são enviadas
novamente de forma automática para a tabela quando a função é fechada com êxito.
Entrada - exemplo
Script do C# (.csx)
JavaScript
Entrada - exemplo de script C#
O exemplo a seguir mostra uma associação de entrada dos Aplicativos Móveis em um arquivo function.json e
uma função script C# que usa a associação. A função é disparada por uma mensagem da fila que possui um
identificador de registro. A função lê o registro especificado e modifica sua propriedade Text .
{
"bindings": [
{
"connection":"",
"direction": "in"
},
{
"name": "record",
"type": "mobileTable",
"tableName": "MyTable",
"connection": "My_MobileApp_Url",
"apiKey": "My_MobileApp_Key",
"direction": "in"
}
]
}

public static void Run(string myQueueItem, JObject record)

{
if (record != null)
{
record["Text"] = "This has changed.";
}
}
Entrada - JavaScript
O exemplo a seguir mostra uma associação de entrada dos Aplicativos Móveis em um arquivo function.json e
uma função JavaScript que usa a associação. A função é disparada por uma mensagem da fila que possui um
identificador de registro. A função lê o registro especificado e modifica sua propriedade Text .
{
"bindings": [
{
"connection":"",
"direction": "in"
},
{
"name": "record",
"direction": "in"
}
]
}

module.exports = function (context, myQueueItem) {

context.log(context.bindings.record);
context.done();
};
Em bibliotecas de classes do C#, use o atributo MobileTable.
Para saber informações sobre propriedades de atributo que podem ser configuradas, consulte a seção de
configuração a seguir.
e o MobileTable atributo.
type Deve ser definido como "mobileTable"
direction Deve ser definido como "in"
name Nome do parâmetro de entrada na

assinatura de função.
tableName TableName Nome da tabela de dados do aplicativo

móvel
id Id O identificador exclusivo do registro a

ser recuperado. Pode ser estático ou se
basear no gatilho que invoca a função.
Por exemplo, se você usar um gatilho
da fila para sua função, o
"id": "{queueTrigger}" usará o
valor de cadeia de caracteres da
mensagem da fila como a ID de
registro a ser recuperada.

aplicativo que tem a URL do aplicativo
móvel. A função usa essa URL para
construir as operações REST necessárias
no aplicativo móvel. Crie uma
configuração de aplicativo no aplicativo
de funções que contenha a URL do
aplicativo móvel e especifique o nome
da configuração do aplicativo na
propriedade connection na
associação de entrada. A URL é
semelhante a
http://<appname>.azurewebsites.net
.
apiKey ApiKey O nome de uma configuração de

aplicativo que tem a chave de API do
seu aplicativo móvel. Forneça a chave
de API se implementar uma chave de
API no aplicativo móvel do Node.js ou
se implementar uma chave de API no
aplicativo móvel do .NET. Para fornecer
a chave, crie uma configuração de
aplicativo no aplicativo de funções que
contém a chave de API e adicione a
propriedade apiKey na associação de
entrada ao nome da configuração do
aplicativo.
IMPORTANT
Não compartilhe a chave de API com seus clientes de aplicativo móvel. Ela só deve ser distribuída com segurança aos
clientes do lado do serviço, como o Azure Functions. O Azure Functions armazena suas informações de conexão e as chaves
de API como configurações de aplicativo, para que elas não sejam inseridas no repositório de controle do código-fonte. Isso
protege as informações confidenciais.
Entrada - uso
Em funções do C#, quando o registro com a ID especificada for encontrado, ele é passado para o parâmetro
chamado JObject. Quando o registro não é encontrado, o valor do parâmetro é null .
Em funções do JavaScript, o registro é passado para o objeto context.bindings.<name> . Quando o registro não é
encontrado, o valor do parâmetro é null .
Nas funções do C# ou do F#, todas as alterações feitas no registro de entrada (parâmetro de entrada) são
enviadas novamente de forma automática para a tabela quando a função é fechada com êxito. Não é possível
modificar um registro em funções do JavaScript.
Saída
Use a associação de saída dos Aplicativos Móveis para gravar um novo registro em um ponto de extremidade da
tabela dos Aplicativos Móveis.
Saída - exemplo
C#
Script do C# (.csx)
JavaScript
Saída - exemplo C#
O exemplo a seguir mostra uma função C# que é disparada por uma mensagem da fila e cria um registro em
uma tabela do aplicativo móvel.
[FunctionName("MobileAppsOutput")]
[return: MobileTable(ApiKeySetting = "MyMobileAppKey", TableName = "MyTable", MobileAppUriSetting =
"MyMobileAppUri")]
public static object Run(
TraceWriter log)
{
return new { Text = $"I'm running in a C# function! {myQueueItem}" };
}

O exemplo a seguir mostra uma associação de saída dos Aplicativos Móveis em um arquivo function.json e uma
função script C# que usa a associação. A função é disparada por uma mensagem da fila e cria um novo registro
com o valor inserido no código para a propriedade Text .
{
"bindings": [
{
"connection":"",
"direction": "in"
},
{
"name": "record",
"direction": "out"
}
]
}
public static void Run(string myQueueItem, out object record)

{
record = new {
Text = $"I'm running in a C# function! {myQueueItem}"
};
}

O exemplo a seguir mostra uma associação de saída dos Aplicativos Móveis em um arquivo function.json e uma
função do JavaScript que usa a associação. A função é disparada por uma mensagem da fila e cria um novo
registro com o valor inserido no código para a propriedade Text .
{
"bindings": [
{
"connection":"",
"direction": "in"
},
{
"name": "record",
"direction": "out"
}
],
"disabled": false
}

context.bindings.record = {
text : "I'm running in a Node function! Data: '" + myQueueItem + "'"
}
context.done();
};
Saída - atributos
Em bibliotecas de classes do C#, use o atributo MobileTable.
Para saber informações sobre propriedades de atributo que podem ser configuradas, consulte Saída -
configuração. Aqui está um exemplo de atributo MobileTable em uma assinatura de método:
[FunctionName("MobileAppsOutput")]
[return: MobileTable(ApiKeySetting = "MyMobileAppKey", TableName = "MyTable", MobileAppUriSetting =
"MyMobileAppUri")]
public static object Run(
TraceWriter log)
{
...
}
A tabela a seguir explica as propriedades de configuração de associação que você define no arquivo function.json
e no MobileTable atributo.
type Deve ser definido como "mobileTable"
direction Deve ser definido como "out"
name Nome do parâmetro de saída na

assinatura de função.
tableName TableName Nome da tabela de dados do aplicativo

móvel
conexão MobileAppUriSetting O nome de uma configuração de

aplicativo que tem a URL do aplicativo
móvel. A função usa essa URL para
construir as operações REST necessárias
no aplicativo móvel. Crie uma
configuração de aplicativo no aplicativo
de funções que contenha a URL do
aplicativo móvel e especifique o nome
da configuração do aplicativo na
propriedade connection na
associação de entrada. A URL é
semelhante a
http://<appname>.azurewebsites.net
.
apiKey ApiKeySetting O nome de uma configuração de

aplicativo que tem a chave de API do
seu aplicativo móvel. Forneça a chave
de API se implementar uma chave de
API no back-end do aplicativo móvel
do Node.js ou se implementar uma
chave de API no back-end do aplicativo
móvel do .NET. Para fornecer a chave,
crie uma configuração de aplicativo no
aplicativo de funções que contém a
chave de API e adicione a propriedade
apiKey na associação de entrada ao
nome da configuração do aplicativo.
IMPORTANT
Não compartilhe a chave de API com seus clientes de aplicativo móvel. Ela só deve ser distribuída com segurança aos
clientes do lado do serviço, como o Azure Functions. O Azure Functions armazena suas informações de conexão e as chaves
de API como configurações de aplicativo, para que elas não sejam inseridas no repositório de controle do código-fonte. Isso
protege as informações confidenciais.
Saída - uso
Nas funções do script C#, use um parâmetro de saída nomeado do tipo out object para acessar o registro de
saída. Em bibliotecas de classes C#, o atributo MobileTable pode ser usado com qualquer um dos seguintes tipos:
ICollector<T> ou IAsyncCollector<T> , onde T é JObject ou qualquer tipo com uma propriedade
public string Id .
out JObject
out T ou out T[] , onde T é qualquer Tipo com uma propriedade public string Id .
Nas funções do Node.js, use context.bindings.<name> para acessar o registro de saída.
Próximas etapas
Associação de saída dos Hubs de Notificação para
Azure Functions
Este artigo explica como enviar notificações por push usando associações de Hubs de Notificação do Azure no
Azure Functions. O Azure Functions oferece suporte a uma associação de saída para os Hubs de Notificação.
Os Hubs de Notificação do Azure devem ser configurados para os PNS (Serviços de Notificações de Plataforma)
que você deseja usar. Para saber como obter notificações por push em seu aplicativo cliente desde Hubs de
Notificação, veja Introdução aos Hubs de Notificação e selecione a plataforma de cliente de destino na lista
suspensa na parte superior da página.
IMPORTANT
O Google preteriu Google Cloud Messaging (GCM) em favor do firebase Cloud Messaging (FCM). Esta associação de saída
não dá suporte a FCM. Para enviar notificações usando o FCM, use a API do firebase diretamente em sua função ou use
notificações de modelo.
Pacotes – Functions 1.x

As associações de Hubs de notificação são fornecidas no Microsoft.Azure.WebJobs.Extensions.NotificationHubs
pacote NuGet, versão 1. x. O código-fonte do pacote está no repositório GitHub azure-webjobs-sdk-extensions.

Essa associação não está disponível em funções 2. x.
Exemplo - modelo
As notificações enviadas podem ser notificações nativas ou notificações de modelo. As notificações nativas são
destinadas a uma plataforma específica de cliente, conforme configurado na propriedade platform da associação
de saída. Uma notificação de modelo pode ser usada para ter como destino várias plataformas.
Script do C# - parâmetro out
Script do C# - assíncrono
Script do C# - JSON
Script do C# - tipos de biblioteca
F#
JavaScript
Exemplo de modelo de script do C# - parâmetro out
Este exemplo envia uma notificação para um registro de modelo que contém um espaço reservado message no
modelo.
using System;
public static void Run(string myQueueItem, out IDictionary<string, string> notification, TraceWriter log)
{
notification = GetTemplateProperties(myQueueItem);
}
private static IDictionary<string, string> GetTemplateProperties(string message)

{
Dictionary<string, string> templateProperties = new Dictionary<string, string>();
templateProperties["message"] = message;
return templateProperties;
}
Exemplo de modelo de script do C# - assíncrono

Se você estiver usando o código assíncrono, os parâmetros de saída não serão permitidos. Nesse caso, use
IAsyncCollector para retornar a notificação de modelo. O código a seguir é um exemplo de código assíncrono
acima.
using System;
public static async Task Run(string myQueueItem, IAsyncCollector<IDictionary<string,string>> notification,

TraceWriter log)
{
log.Info($"Sending Template Notification to Notification Hub");

await notification.AddAsync(GetTemplateProperties(myQueueItem));
}
private static IDictionary<string, string> GetTemplateProperties(string message)

{
templateProperties["user"] = "A new user wants to be added : " + message;
return templateProperties;
}
Exemplo de modelo de script do C# - JSON
Este exemplo envia uma notificação para um registro de modelo que contém um espaço reservado message no
modelo usando uma cadeia de caracteres JSON.
using System;
public static void Run(string myQueueItem, out string notification, TraceWriter log)
{
notification = "{\"message\":\"Hello from C#. Processed a queue item!\"}";
}
Exemplo de modelo script do C# - tipos de biblioteca

Este exemplo mostra como usar tipos definidos na Biblioteca de Hubs de Notificações do Microsoft Azure.
#r "Microsoft.Azure.NotificationHubs"
using System;
using Microsoft.Azure.NotificationHubs;
public static void Run(string myQueueItem, out Notification notification, TraceWriter log)
{
notification = GetTemplateNotification(myQueueItem);
}
private static TemplateNotification GetTemplateNotification(string message)

{
templateProperties["message"] = message;
return new TemplateNotification(templateProperties);
}
Exemplo de modelo F#
Este exemplo envia uma notificação para um registro de modelo que contém location e message .
let Run(myTimer: TimerInfo, notification: byref<IDictionary<string, string>>) =

notification = dict [("location", "Redmond"); ("message", "Hello from F#!")]
Exemplo de modelo JavaScript

Este exemplo envia uma notificação para um registro de modelo que contém location e message .

if (myTimer.IsPastDue)
{
context.log('Node.js is running late!');
}
context.bindings.notification = {
location: "Redmond",
message: "Hello from Node!"
};
context.done();
};
Exemplo - APNS nativo
Este exemplo de script C# mostra como enviar uma notificação nativa do APNS.
using System;
public static async Task Run(string myQueueItem, IAsyncCollector<Notification> notification, TraceWriter log)
{
// In this example the queue item is a new user to be processed in the form of a JSON string with
// a "name" value.
//
// The JSON format for a native APNS notification is ...
// { "aps": { "alert": "notification message" }}
log.LogInformation($"Sending APNS notification of a new user");

dynamic user = JsonConvert.DeserializeObject(myQueueItem);
string apnsNotificationPayload = "{\"aps\": {\"alert\": \"A new user wants to be added (" +
user.name + ")\" }}";
log.LogInformation($"{apnsNotificationPayload}");
await notification.AddAsync(new AppleNotification(apnsNotificationPayload));
}
Exemplo - WNS nativo

Este exemplo de script C# mostra como usar tipos definidos na Biblioteca de Hubs de Notificação do Microsoft
Azure para enviar uma notificação nativa WNS do sistema.
using System;
public static async Task Run(string myQueueItem, IAsyncCollector<Notification> notification, TraceWriter log)
{
// In this example the queue item is a new user to be processed in the form of a JSON string with
// a "name" value.
//
// The XML format for a native WNS toast notification is ...
// <?xml version="1.0" encoding="utf-8"?>
// <toast>
// <visual>
// <binding template="ToastText01">
// <text id="1">notification message</text>
// </binding>
// </visual>
// </toast>
log.Info($"Sending WNS toast notification of a new user");

dynamic user = JsonConvert.DeserializeObject(myQueueItem);
string wnsNotificationPayload = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
"<toast><visual><binding template=\"ToastText01\">" +
"<text id=\"1\">" +
"A new user wants to be added (" + user.name + ")" +
"</text>" +
"</binding></visual></toast>";
log.Info($"{wnsNotificationPayload}");
await notification.AddAsync(new WindowsNotification(wnsNotificationPayload));
}
Atributos
Em bibliotecas de classes de C#, utilize o atributo NotificationHub.
Os parâmetros e as propriedades do construtor do atributo são descritos na seção Configuração.
Configuração
e no atributo NotificationHub :
tipo N/D Deve ser definido como

notificationHub .
direction N/D Deve ser definido como out .
name N/D Nome da variável usada no código de

função para a mensagem do hub de
notificação.
tagExpression TagExpression As expressões de marca permitem que

você especifique que as notificações
sejam entregues a um conjunto de
dispositivos registrados para receber
notificações que correspondem à
expressão de marca. Para saber mais,
veja Expressões de marca e de
roteamento.
hubName HubName Nome do recurso de hub de notificação

no portal do Azure.
conexão ConnectionStringSetting O nome de uma configuração de

conexão de Hubs de Notificação. A
cadeia de caracteres de conexão deve
ser definida como o valor
DefaultFullSharedAccessSignature para
o hub de notificação. Veja Configuração
da cadeia de conexão posteriormente
neste artigo.
platform Plataforma A propriedade platform indica a

plataforma de cliente à qual sua
notificação se destina. Por padrão, se a
propriedade da plataforma é omitida da
associação de saída, as notificações de
modelo podem ser usadas para atingir
qualquer plataforma configurada no
Hub de Notificação do Azure. Para
obter mais informações sobre como
usar modelos em geral para enviar
várias notificações de plataforma com
um Hub de Notificação do Azure,
consulte Modelos. Quando definida,
platform deve ser um dos seguintes
valores:
apns —Apple Push Notification
Service. Para obter mais
informações sobre como
configurar o hub de notificação
do APNS e receber a notificação
em um aplicativo cliente,
consulte Enviar notificações por
push para iOS com os Hubs de
Notificação do Azure.
adm —Amazon Device
Messaging. Para obter mais
informações sobre como
configurar o hub de notificação
para ADM e receber a
notificação de um aplicativo
Kindle, consulte Introdução aos
Hubs de Notificação para
aplicativos Kindle.
wns —Serviços de Notificação
por Push do Windows visando
plataformas Windows. Também
há suporte para Windows
Phone 8.1 e posterior pelo
WNS. Para mais informações,
consulte Introdução aos Hubs
de Notificação para aplicativos
da Plataforma Universal do
Windows.
mpns —Serviço de Notificação
por Push da Microsoft. Essa
plataforma dá suporte a
plataformas mais antigas do
Windows Phone e Windows
Phone 8. Para mais informações,
consulte Como enviar
notificações por push com Hubs
de Notificação do Azure no
Windows Phone.
Exemplo de arquivo function.json
Aqui está um exemplo de uma associação de Hubs de Notificação em um arquivo function.json.
{
"bindings": [
{
"type": "notificationHub",
"direction": "out",
"name": "notification",
"tagExpression": "",
"hubName": "my-notification-hub",
"connection": "MyHubConnectionString",
"platform": "apns"
}
],
"disabled": false
}
Configuração de cadeia de conexão

Para usar uma associação de saída de um hub de notificação, você deve configurar a cadeia de conexão para o
hub. Você pode selecionar um hub de notificação existente ou criar um novo diretamente na guia Integrar no
portal do Azure. Você também pode configurar a cadeia de conexão manualmente.
Para configurar a cadeia de conexão em um hub de notificação existente:
1. Navegue até seu hub de notificação no portal do Azure, escolha Políticas de acesso e selecione o botão
Copiar ao lado da política DefaultFullSharedAccessSignature. Isso copia a cadeia de conexão para a
política DefaultFullSharedAccessSignature ao hub de notificação. Essa cadeia de conexão permite que a
função envie mensagens de notificação para o hub.
2. Navegue até seu aplicativo de funções no portal do Azure, escolha Configurações do aplicativo, adicione
uma chave como MyHubConnectionString, cole o DefaultFullSharedAccessSignature copiado em seu hub
de notificação como o valor e, em seguida, clique em Salvar.
O nome dessa configuração de aplicativo é o que está na configuração de conexão de associação de saída em
function.json ou mo atributo do .NET. Veja a seção Configuração anteriormente neste artigo.

Hub de notificação Guia de Operações
Próximos passos
Associações de armazenamento de filas do Azure
Functions
Este artigo explica como trabalhar com associações de armazenamento de Fila do Azure no Azure Functions.
O Azure Functions dá suporte a associações de gatilho e de saída para filas.
As associações de armazenamento Filas são fornecidas no pacote NuGet Microsoft.Azure.WebJobs, versão
2.x. O código-fonte do pacote está no repositório GitHub azure-webjobs-sdk.
Armazenamento do Microsoft Azure (windowsazure pacote NuGet). Se você referenciar uma versão
diferente do SDK do armazenamento e associar a um tipo de SDK de armazenamento na sua assinatura de
função, o tempo de execução de funções pode relatar se não é possível associar a esse tipo. A solução é
verificar as referências do projeto windowsazure 7.2.1.
As associações de Armazenamento de Filas são fornecidas no pacote NuGet
Microsoft.Azure.WebJobs.Extensions.Storage, versão 3.x. O código-fonte do pacote está no repositório
desenvolvimento.


Python

Codificando
O Functions espera uma cadeia de caracteres codificada base64. Todos os ajustes ao tipo de codificação (para
preparar os dados como uma cadeia de caracteres codificada base64) precisam ser implementados no
serviço de chamada.
Disparador
Use o gatilho de fila para iniciar uma função quando um novo item é recebido em uma fila. A mensagem da
fila é fornecida como entrada para a função.
Gatilho - exemplo
C#
Script do C# (.csx)
JavaScript
Java
Python
O exemplo a seguir mostra uma função C# que consulta a fila myqueue-items e grava um log cada vez que
um item de fila é processado.

{
ILogger log)
{
}
}

O exemplo a seguir mostra uma associação de gatilho de fila em um arquivo function.json e código script C#
(.csx) que usa a associação. A função controla a myqueue-items fila e grava um log cada vez que um item de
fila é processado.
{
"disabled": false,
"bindings": [
{
"direction": "in",
}
]
}

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}");
}
A seção uso explica myQueueItem , que é chamado pela name propriedade function.json. A seção de
metadados de mensagem explica todas as outras variáveis mostradas.
O exemplo a seguir mostra uma associação de gatilho de fila em um arquivo function.json e uma função
JavaScript que usa a associação. A função controla a myqueue-items fila e grava um log cada vez que um
item de fila é processado.
{
"disabled": false,
"bindings": [
{
"direction": "in",
}
]
}
NOTE
O parâmetro nome é refletido como context.bindings.<name> no código JavaScript que contém a carga útil do
item da fila. Essa carga útil também é passada como o segundo parâmetro para a função.
module.exports = async function (context, message) {

context.log('Node.js queue trigger function processed work item', message);
// OR access using context.bindings.<name>
// context.log('Node.js queue trigger function processed work item', context.bindings.myQueueItem);
context.log('expirationTime =', context.bindingData.expirationTime);
context.log('insertionTime =', context.bindingData.insertionTime);
context.log('nextVisibleTime =', context.bindingData.nextVisibleTime);
context.log('id =', context.bindingData.id);
context.log('popReceipt =', context.bindingData.popReceipt);
context.log('dequeueCount =', context.bindingData.dequeueCount);
context.done();
};
A seção uso explica myQueueItem , que é chamado pela name propriedade function.json. A seção de
metadados de mensagem explica todas as outras variáveis mostradas.
Gatilho - exemplo Java
O exemplo Java a seguir mostra as funções do acionador da fila de armazenamento que registra a
mensagem acionada colocada na fila myqueuename .
@FunctionName("queueprocessor")
public void run(
@QueueTrigger(name = "msg",
queueName = "myqueuename",
) {
}

O exemplo a seguir demonstra como ler uma mensagem de fila passada para uma função por meio de um
gatilho.
Um gatilho de fila de armazenamento é definido em Function. JSON , em que Type é definido como
queueTrigger .
{
"bindings": [
{
"name": "msg",
"direction": "in",
"queueName": "messages",
"connection": "AzureStorageQueuesConnectionString"
}
]
}
O código _init_.py declara um parâmetro como func.ServiceBusMessage , que permite que você leia a
mensagem da fila em sua função.
import logging
import json
def main(msg: func.QueueMessage):

logging.info('Python queue trigger function processed a queue item.')
result = json.dumps({
'id': msg.id,
'body': msg.get_body().decode('utf-8'),
'expiration_time': (msg.expiration_time.isoformat()
if msg.expiration_time else None),
'insertion_time': (msg.insertion_time.isoformat()
if msg.insertion_time else None),
'time_next_visible': (msg.time_next_visible.isoformat()
if msg.time_next_visible else None),
'pop_receipt': msg.pop_receipt,
'dequeue_count': msg.dequeue_count
})
logging.info(result)
Em bibliotecas de classes C#, use os seguintes atributos para configurar um gatilho de fila:
QueueTriggerAttribute
O construtor do atributo usa o nome da fila para monitorar, conforme mostrado no exemplo a seguir:
ILogger log)
{
...
}
[QueueTrigger("myqueue-items", Connection = "StorageConnectionAppSetting")] string
myQueueItem,
ILogger log)
{
....
}

Oferece uma maneira de especificar a conta de armazenamento para usar. O construtor toma o nome
de uma configuração de aplicativo que contenha uma cadeia de conexão de armazenamento. O
atributo pode ser aplicado no nível de classe, método ou parâmetro. O exemplo a seguir mostra o
nível de classe e método:
{
{
...
}

A propriedade QueueTrigger do atributo Connection .
O StorageAccount atributo aplicado ao mesmo parâmetro do QueueTrigger atributo.
A configuração do aplicativo "AzureWebJobsStorage".
function.json e no atributo QueueTrigger .
type n/d Deve ser definido como

queueTrigger . Essa propriedade é
você cria o gatilho no portal do
Azure.
direction n/d Apenas no arquivo function.json.

Deve ser definido como in . Essa
name n/d O nome da variável que contém o

conteúdo do item de fila no código
da função.
queueName QueueName O nome da fila a ser controlada.

de configuração do aplicativo
começar com "AzureWebJobs", você
pode especificar apenas o resto do
nome aqui. Por exemplo, se você
configurar connection para
“MyStorage”, o tempo de execução
do Functions procura por uma
configuração de aplicativo que esteja
nomeada “AzureWebJobsMyStorage."
Se você deixar connection vazio, o
tempo de execução de Functions usa
a cadeia de caracteres de conexão de
Gatilho - uso
Em C# e script C#, acesse os dados da mensagem usando um parâmetro de método, como
string paramName . No script do C#, paramName é o valor especificado na propriedade name de function.json.
É possível associar a qualquer um dos seguintes tipos:
Objeto - o tempo de execução do Functions desserializa um conteúdo JSON em uma instância de uma
classe arbitrária definida em seu código.
string
byte[]
CloudQueueMessage
Se você tentar associar CloudQueueMessage e receber uma mensagem de erro, certifique-se de ter uma
referência para a versão correta do SDK do Armazenamento.
Em JavaScript, use context.bindings.<name> para acessar o conteúdo de item de fila. Se o conteúdo for
JSON, ele é desserializado em um objeto.
Gatilho - metadados da mensagem

O gatilho de fila fornece várias propriedades de metadados. Essas propriedades podem ser usadas como
parte de expressões de associação em outras associações ou como parâmetros em seu código. Essas são
propriedades da classe CloudQueueMessage.
QueueTrigger string Conteúdo da fila (se for uma cadeia

de caracteres válida). Se o conteúdo
de mensagem de fila como uma
cadeia de caracteres QueueTrigger
tem o mesmo valor da variável
nomeada pela name propriedade em
function.json.
DequeueCount int O número de vezes que essa

mensagem foi removida da fila.
ExpirationTime DateTimeOffset A hora em que a mensagem expira.
Id string ID da mensagem da fila.
InsertionTime DateTimeOffset A hora em que a mensagem foi

adicionada à fila.
NextVisibleTime DateTimeOffset A hora em que a mensagem estará

visível.
PopReceipt string Recebimento pop da mensagem.

Quando uma função do gatilho de fila falhar, o Azure Functions repetirá essa função até cinco vezes para
uma determinada mensagem da fila, incluindo a primeira tentativa. Se todas as cinco tentativas falharem, o
tempo de execução das funções adicionará uma mensagem em uma fila chamada <originalqueuename>-
poison. Você pode gravar uma função para processar as mensagens da fila de mensagens suspeitas
registrando-as ou enviando uma notificação de que a atenção manual é necessária.
Para tratar mensagens suspeitas manualmente, verifique o dequeueCount da mensagem de fila.
Gatilho - algoritmo de sondagem

O gatilho de fila implementa um algoritmo exponencial aleatório de retirada para reduzir o efeito de
sondagem de fila ociosa nos custos das transações de armazenamento. Quando uma mensagem for
encontrada, o tempo de execução aguarda dois segundos e, em seguida, verifica outra mensagem; quando
nenhuma mensagem for encontrada, ele aguarda cerca de quatro segundos antes de tentar novamente. Após
subsequentes tentativas falhas para obter uma mensagem da fila, o tempo de espera continua a aumentar
até atingir o tempo de espera máximo, cujo padrão é um minuto. O tempo de espera máximo é configurável
por meio da propriedade maxPollingInterval no arquivo host.json.
Gatilho - simultaneidade
Quando há várias mensagens de fila aguardando, o gatilho de fila recupera um lote de mensagens e invoca
as instâncias de função ao mesmo tempo para processá-las. Por padrão, o tamanho do lote é 16. Quando o
número que está sendo processado chega até 8, o tempo de execução obtém outro lote e começa a processar
as mensagens. Portanto, o número máximo de mensagens simultâneas que estão sendo processadas por
função em uma máquina virtual (VM ) é 24. Esse limite se aplica separadamente a cada função acionada por
fila em cada VM. Se aplicativo de função for escalado horizontalmente para várias VMs, cada VM aguardará
gatilhos e tentará executar funções. Por exemplo, se um aplicativo de função for escalado horizontalmente
para 3 VMs, o número de máximo padrão de instâncias simultâneas de uma função acionada por fila será 72.
O tamanho do lote e o limite para obtenção de um novo lote são configuráveis no arquivo host.json. Se
quiser minimizar a execução paralela para funções acionadas por fila em um aplicativo de função, você poder
definir o tamanho do lote para 1. Essa configuração elimina a simultaneidade, desde que seu aplicativo de
função seja executado em uma única máquina virtual (VM ).
O gatilho de fila impede automaticamente que uma função processe uma mensagem da fila várias vezes; as
funções não precisam ser escritas para ser idempotentes.

O arquivo host.json contém configurações que controlam o comportamento de gatilho de fila. Consulte a
seção configurações do host. JSON para obter detalhes sobre as configurações disponíveis.
Saída
Use a associação de saída do armazenamento de Filas do Azure para que você grave mensagens em uma
fila.
Saída - exemplo
C#
Script do C# (.csx)
JavaScript
Java
Python
Saída - exemplo C#
O exemplo a seguir mostra uma função C# que cria uma mensagem da fila para cada solicitação HTTP
recebida.
[StorageAccount("AzureWebJobsStorage")]
{
[FunctionName("QueueOutput")]
[return: Queue("myqueue-items")]
public static string QueueOutput([HttpTrigger] dynamic input, ILogger log)
{
log.LogInformation($"C# function processed: {input.Text}");
return input.Text;
}
}

O exemplo a seguir mostra uma associação de gatilho de HTTP em um arquivo function.json e código script
C# (.csx) que usa a associação. A função cria um item de fila com um conteúdo de objeto
CustomQueueMessage para cada solicitação HTTP recebida.
{
"bindings": [
{
"direction": "in",
"name": "input"
},
{
"type": "http",
"direction": "out",
"name": "return"
},
{
"type": "queue",
"direction": "out",
"name": "$return",
"connection": "MyStorageConnectionAppSetting"
}
]
}

Aqui está o código script C# que cria uma mensagem de fila única:
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 ao mesmo tempo usando um parâmetro ICollector ou
IAsyncCollector . Aqui está o código de script C# que envia várias mensagens, uma com os dados da
solicitação HTTP e outra com valores codificados:

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

O exemplo a seguir mostra uma associação de gatilho HTTP em um arquivo function.json e uma função
JavaScript que usa a associação. A função cria um item da fila para cada solicitação HTTP recebida.
{
"bindings": [
{
"direction": "in",
"name": "input"
},
{
"type": "http",
"direction": "out",
"name": "return"
},
{
"type": "queue",
"direction": "out",
"name": "$return",
"connection": "MyStorageConnectionAppSetting"
}
]
}


context.done(null, input.body);
};
Você pode enviar várias mensagens de uma vez com a definição de uma matriz de mensagem para a
myQueueItem associação de saída. O código JavaScript a seguir envia duas mensagens de fila com valores
codificados para cada solicitação HTTP recebida.
context.bindings.myQueueItem = ["message 1","message 2"];
context.done();
};

O exemplo a seguir mostra uma função Java que cria uma mensagem de fila para quando acionada por uma
solicitação HTTP.
@FunctionName("httpToQueue")
@QueueOutput(name = "item", queueName = "myqueue-items", connection = "AzureWebJobsStorage")
public String pushToQueue(
@HttpTrigger(name = "request", methods = {HttpMethod.POST}, authLevel =
AuthorizationLevel.ANONYMOUS)
final String message,
@HttpOutput(name = "response") final OutputBinding<String> result) {
result.setValue(message + " has been added.");
return message;
}
No biblioteca de tempo de execução de funções Java, use o @QueueOutput anotação em parâmetros cujo
valor seria gravado no armazenamento de fila. O tipo de parâmetro deve ser OutputBinding<T> , onde T é
qualquer tipo Java nativo de um POJO.
O exemplo a seguir demonstra como gerar valores únicos e múltiplos para filas de armazenamento. A
configuração necessária para Function. JSON é a mesma de qualquer forma.
Uma associação de fila de armazenamento é definida em Function. JSON , em que Type é definido como
queue .
{
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
},
{
"type": "queue",
"direction": "out",
"name": "msg",
"connection": "AzureStorageQueuesConnectionString"
}
]
}
Para definir uma mensagem individual na fila, você passa um único valor para o método set .
def main(req: func.HttpRequest, msg: func.Out[str]) -> func.HttpResponse:
input_msg = req.params.get('message')
msg.set(input_msg)
return 'OK'
Para criar várias mensagens na fila, declare um parâmetro como o tipo de lista apropriado e passe uma
matriz de valores (que correspondam ao tipo de lista) para o método set .

import typing
def main(req: func.HttpRequest, msg: func.Out[typing.List[str]]) -> func.HttpResponse:
msg.set(['one', 'two'])
return 'OK'
Saída - atributos
Em bibliotecas de classes do C#, use o QueueAttribute.
O atributo se aplica a um out parâmetro ou o valor de retorno da função. O construtor do atributo usa o
nome da fila, conforme mostrado no exemplo a seguir:
[return: Queue("myqueue-items")]
public static string Run([HttpTrigger] dynamic input, ILogger log)
{
...
}
[return: Queue("myqueue-items", Connection = "StorageConnectionAppSetting")]
{
...
}

método ou parâmetro. Para obter mais informações, confira Gatilho – atributos.
function.json e no Queue atributo.
type n/d Deve ser definido como queue . Essa

direction n/d Deve ser definido como out . Essa

name n/d O nome da variável que representa a

fila no código de função. Definido
como $return para referenciar o
valor de retorno da função.
queueName QueueName O nome da fila.


de configuração do aplicativo
nome aqui. Por exemplo, se você
configurar connection para
“MyStorage”, o tempo de execução
do Functions procura por uma
configuração de aplicativo que esteja
nomeada “AzureWebJobsMyStorage."
Se você deixar connection vazio, o
tempo de execução de Functions usa
a cadeia de caracteres de conexão de
Saída - uso
Em C# e script C#, grave uma mensagem de fila única usando um parâmetro de método como o
out T paramName . No script do C#, paramName é o valor especificado na propriedade name de function.json.
Você pode usar o tipo de retorno de método em vez de um out parâmetro, e T pode ser qualquer um dos
seguintes tipos:
Um objeto serializado como JSON
string
byte[]
CloudQueueMessage
Se você tentar associar CloudQueueMessage e receber uma mensagem de erro, certifique-se de ter uma
referência para a versão correta do SDK do Armazenamento.
Em C# e script C#, grave várias mensagens de fila usando um dos seguintes tipos:
ICollector<T> ou IAsyncCollector<T>
CloudQueue
Em funções em JavaScript, use context.bindings.<name> para acessar a mensagem de fila de saída. Você
pode usar uma cadeia de caracteres ou um objeto serializável em JSON para o conteúdo de item de fila.

Fila Fila de códigos de erro

arquivo host.json de exemplo abaixo contém apenas as configurações da versão 2.x para essa associação.
Para obter mais informações sobre as configurações globais na versão 2.x, confira a referência de host.json
para o Azure Functions versão 2.x.
NOTE
{
"version": "2.0",
"extensions": {
"queues": {
"maxPollingInterval": "00:00:02",
"visibilityTimeout" : "00:00:30",
"batchSize": 16,
"maxDequeueCount": 5,
"newBatchThreshold": 8
}
}
}
maxPollingInterval 00:00:01 O intervalo máximo entre as

sondagens de fila. O mínimo é
00:00:00.100 (100 ms) e incrementa
até 00:01:00 (1 min). Em 1. x, o tipo
de dados é milissegundos e, em 2. x,
é um TimeSpan.
visibilityTimeout 00:00:00 O intervalo de tempo entre as

repetições quando o processamento
de uma mensagem falha.
batchSize 16 O número de mensagens em fila que

o tempo de execução de Funções
recupera simultaneamente e processa
em paralelo. Quando o número que
está sendo processado chega até
newBatchThreshold , o tempo de
execução obtém outro lote e começa
a processar as mensagens. Portanto,
o número máximo de mensagens
simultâneas que estão sendo
processadas por função é
batchSize mais
newBatchThreshold . Esse limite se
aplica separadamente a cada função
acionada por fila.
Se quiser evitar uma execução

paralela para mensagens recebidas
em uma fila, é possível definir
batchSize como 1. No entanto,
essa configuração elimina a
simultaneidade desde que seu
aplicativo de função seja executado
em uma única máquina virtual (VM).
Se o aplicativo de função se expande
para várias VMs, cada VM pode
executar uma instância de cada
função acionada por fila.
O máximo batchSize é 32.
maxDequeueCount 5 O número de vezes para tentar

processar uma mensagem antes de
movê-la para a fila de mensagens
suspeitas.
newBatchThreshold batchSize/2 Sempre que o número de mensagens

processadas simultaneamente chega
a esse número, o tempo de execução
recupera outro lote.
Próximas etapas
Vá para um tutorial que usa uma associação de saída de armazenamento de Fila
Associações do SendGrid no Azure Functions
Este artigo explica como enviar emails usando as associações de SendGrid no Azure Functions. O Azure
Functions suporta uma associação de saída para o SendGrid.
As associações SendGrid são fornecidas no Pacote NuGet Microsoft.Azure.WebJobs.Extensions.SendGrid, versão
2.x. O código-fonte do pacote está no repositório GitHub azure-webjobs-sdk-extensions.

As associações SendGrid são fornecidas no Pacote NuGet Microsoft.Azure.WebJobs.Extensions.SendGrid, versão
3.x. O código-fonte do pacote está no repositório GitHub azure-webjobs-sdk-extensions.
NOTE
A versão 2. x não cria o tópico ou a assinatura configurada na ServiceBusTrigger instância. A versão 2. x é baseada em
Microsoft. Azure. ServiceBus e não lida com o gerenciamento de filas.


Python
Exemplo
C#
Script do C# (.csx)
JavaScript
Java
Exemplo de C#
O exemplo a seguir mostra uma função C# que usa um gatilho de fila do Barramento de Serviço e uma
associação de saída de SendGrid.
Exemplo de C# síncrono:
[FunctionName("SendEmail")]
[ServiceBusTrigger("myqueue", Connection = "ServiceBusConnection")] Message email,
[SendGrid(ApiKey = "CustomSendGridKeyAppSettingName")] out SendGridMessage message)
{
var emailObject = JsonConvert.DeserializeObject<OutgoingEmail>(Encoding.UTF8.GetString(email.Body));
message = new SendGridMessage();

message.AddTo(emailObject.To);
message.AddContent("text/html", emailObject.Body);
message.SetFrom(new EmailAddress(emailObject.From));
message.SetSubject(emailObject.Subject);
}
public class OutgoingEmail

{
public string To { get; set; }
public string From { get; set; }
public string Subject { get; set; }
public string Body { get; set; }
}
Exemplo de C# assíncrono:
public static async void Run(
[ServiceBusTrigger("myqueue", Connection = "ServiceBusConnection")] Message email,
[SendGrid(ApiKey = "CustomSendGridKeyAppSettingName")] IAsyncCollector<SendGridMessage> messageCollector)
{
var emailObject = JsonConvert.DeserializeObject<OutgoingEmail>(Encoding.UTF8.GetString(email.Body));
var message = new SendGridMessage();

message.AddTo(emailObject.To);
message.AddContent("text/html", emailObject.Body);
message.SetFrom(new EmailAddress(emailObject.From));
message.SetSubject(emailObject.Subject);
await messageCollector.AddAsync(message);
}
public class OutgoingEmail

{
public string To { get; set; }
public string From { get; set; }
public string Body { get; set; }
}
Poderá omitir a propriedade ApiKey do atributo se você tiver sua chave de API em uma configuração de
aplicativo denominada "AzureWebJobsSendGridApiKey".
O exemplo a seguir mostra uma associação de saída de SendGrid em um arquivo function.json e uma função
script C# que usa a associação.
{
"bindings": [
{
"name": "mymsg",
"queueName": "myqueue",
"connection": "AzureWebJobsStorage",
"direction": "in"
},
{
"type": "sendGrid",
"name": "$return",
"direction": "out",
"apiKey": "SendGridAPIKeyAsAppSetting",
"from": "{FromEmail}",
"to": "{ToEmail}"
}
]
}

#r "SendGrid"
using System;
using SendGrid.Helpers.Mail;
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 Content { get; set; }
}
Exemplo do Java
O exemplo a seguir usa @SendGridOutput a anotação da biblioteca de tempo de execução de funções Java para
enviar um email usando a associação de saída SendGrid.
@FunctionName("SendEmail")
AuthorizationLevel.FUNCTION) HttpRequestMessage<Optional<String>> request,
@SendGridOutput(
name = "email", dataType = "String", apiKey = "SendGridConnection", to = "test@example.com",
from = "test@example.com",
subject= "Sending with SendGrid", text = "Hello from Azure Functions"
) OutputBinding<String> email
)
{
String name = request.getBody().orElse("World");
final String emailBody = "{\"personalizations\":" +

"[{\"to\":[{\"email\":\"test@example.com\"}]," +
"\"subject\":\"Sending with SendGrid\"}]," +
"\"from\":{\"email\":\"test@example.com\"}," +
"\"content\":[{\"type\":\"text/plain\",\"value\": \"Hello" + name +
"\"}]}";
email.setValue(emailBody);
}
O exemplo a seguir mostra uma associação de saída de SendGrid em um arquivo function.json e uma função
JavaScript que usa a associação.
{
"bindings": [
{
"name": "$return",
"type": "sendGrid",
"direction": "out",
"apiKey" : "MySendGridKey",
"to": "{ToEmail}",
"from": "{FromEmail}",
"subject": "SendGrid output bindings"
}
]
}


var message = {
"personalizations": [ { "to": [ { "email": "sample@sample.com" } ] } ],
from: { email: "sender@contoso.com" },
subject: "Azure news",
content: [{
type: 'text/plain',
value: input
}]
};
context.done(null, message);
};
Atributos
Em bibliotecas de classes do C#, use o atributo SendGrid.
Para obter informações sobre as propriedades de atributo que você pode configurar, consulte Configuração. Aqui
está um exemplo de atributo SendGrid em uma assinatura de método:
[ServiceBusTrigger("myqueue", Connection = "ServiceBusConnection")] OutgoingEmail email,
[SendGrid(ApiKey = "CustomSendGridKeyAppSettingName")] out SendGridMessage message)
{
...
}
Para ver um exemplo completo, consulte Exemplo de C#.
Configuração
e no atributo SendGrid .

sendGrid .

out .

usado no código da função da
solicitação ou do corpo da solicitação.
Esse valor é $return quando há
apenas um valor retornado.
apiKey ApiKey O nome de uma configuração de

aplicativo que contém sua chave de
API. Se não configurado, o nome da
configuração do aplicativo padrão é
"AzureWebJobsSendGridApiKey".
to To o endereço de email do destinatário.
from From o endereço de email do remetente.
subject Subject o assunto do email.
text Text o conteúdo do email.
NOTE
{
"version": "2.0",
"extensions": {
"sendGrid": {
"from": "Azure Functions <samples@functions.com>"
}
}
}
from n/d Endereço de email do remetente em

todas as funções.
Próximas etapas
Associações do Barramento de Serviço para o
Azure Functions
Este artigo explica como trabalhar com associações do Barramento de Serviço do Azure no Azure Functions. O
Azure Functions dá suporte a gatilhos e a associações de saída para filas e tópicos do Barramento de Serviço.
As associações do barramento de serviço são fornecidas no Microsoft.Azure.WebJobs.ServiceBus pacote
NuGet, versão 2. x.
desenvolvimento.

As associações do Barramento de Serviços são fornecidas no pacote NuGet
Microsoft.Azure.WebJobs.Extensions.ServiceBus, versão 3.x. O código-fonte do pacote está no repositório
GitHub Azure-Functions-ServiceBus-Extension .
NOTE
A versão 2. x não cria o tópico ou a assinatura configurada na instância de ServiceBusTrigger . A versão 2. x é baseada
em Microsoft. Azure. ServiceBus e não lida com o gerenciamento de filas.
desenvolvimento.

Python
Gatilho
Use o gatilho do Barramento de Serviço para responder às mensagens de uma fila ou tópico do Barramento
de Serviço.
Gatilho - exemplo
C#
F#
Java
JavaScript
Python
A exemplo a seguir mostra uma função C# que lê metadados de mensagem e registra uma mensagem de fila
do Barramento de Serviço:
[FunctionName("ServiceBusQueueTriggerCSharp")]
[ServiceBusTrigger("myqueue", Connection = "ServiceBusConnection")]
string myQueueItem,
Int32 deliveryCount,
string messageId,
ILogger log)
{
log.LogInformation($"C# ServiceBus queue trigger function processed message: {myQueueItem}");
log.LogInformation($"DeliveryCount={deliveryCount}");
log.LogInformation($"MessageId={messageId}");
}

O exemplo a seguir mostra uma associação de gatilho de Barramento de Serviço em um arquivo function.json
e uma função C# script que usa a associação. A função lê metadados de mensagem e registra uma mensagem
de fila do Barramento de Serviço do Microsoft Azure.
{
"bindings": [
{
"queueName": "testqueue",
"connection": "MyServiceBusConnection",
"type": "serviceBusTrigger",
"direction": "in"
}
],
"disabled": false
}
using System;
public static void Run(string myQueueItem,

Int32 deliveryCount,
string messageId,
TraceWriter log)
{
log.Info($"C# ServiceBus queue trigger function processed message: {myQueueItem}");
log.Info($"DeliveryCount={deliveryCount}");
log.Info($"MessageId={messageId}");
}
e uma função F# que usa a associação. A função registra em log uma mensagem de fila do barramento de
serviço.
{
"bindings": [
{
"direction": "in"
}
],
"disabled": false
}
Aqui está o código de script F#:
let Run(myQueueItem: string, log: ILogger) =

log.LogInformation(sprintf "F# ServiceBus queue trigger function processed message: %s" myQueueItem)

A função Java a seguir usa a anotação @ServiceBusQueueTrigger da biblioteca de tempo de execução de
funções Java para descrever a configuração de um gatilho de fila do barramento de serviço. A função captura a
mensagem colocada na fila e a adiciona aos logs.
@FunctionName("sbprocessor")
public void serviceBusProcess(
@ServiceBusQueueTrigger(name = "msg",
queueName = "myqueuename",
) {
}
As funções Java também podem ser disparadas quando uma mensagem é adicionada a um tópico do
barramento de serviço. O exemplo a seguir usa a anotação @ServiceBusTopicTrigger para descrever a
configuração do gatilho.
@FunctionName("sbtopicprocessor")
public void run(
@ServiceBusTopicTrigger(
name = "message",
topicName = "mytopicname",
subscriptionName = "mysubscription",
connection = "ServiceBusConnection"
) String message,
) {
}

e uma função JavaScript que usa a associação. A função lê metadados de mensagem e registra uma
mensagem de fila do Barramento de Serviço do Microsoft Azure.
{
"bindings": [
{
"direction": "in"
}
],
"disabled": false
}
Este é o código do script do JavaScript:
module.exports = function(context, myQueueItem) {

context.log('Node.js ServiceBus queue trigger function processed message', myQueueItem);
context.log('DeliveryCount =', context.bindingData.deliveryCount);
context.log('MessageId =', context.bindingData.messageId);
context.done();
};
O exemplo a seguir demonstra como ler uma mensagem da fila do ServiceBus por meio de um gatilho.
Uma associação de ServiceBus é definida em Function. JSON , em que Type é definido como
serviceBusTrigger .
{
"bindings": [
{
"name": "msg",
"direction": "in",
"queueName": "inputqueue",
"connection": "AzureServiceBusConnectionString"
}
]
}
O código em _init_. py declara um parâmetro como func.ServiceBusMessage , o que permite que você leia a
mensagem da fila em sua função.
import logging
import json
def main(msg: func.ServiceBusMessage):

logging.info('Python ServiceBus queue trigger processed message.')
result = json.dumps({
'message_id': msg.message_id,
'body': msg.get_body().decode('utf-8'),
'content_type': msg.content_type,
'expiration_time': msg.expiration_time,
'label': msg.label,
'partition_key': msg.partition_key,
'reply_to': msg.reply_to,
'reply_to_session_id': msg.reply_to_session_id,
'scheduled_enqueue_time': msg.scheduled_enqueue_time,
'session_id': msg.session_id,
'time_to_live': msg.time_to_live,
'to': msg.to,
'user_properties': msg.user_properties,
})
logging.info(result)
Gatilho - atributos
Em bibliotecas de classes C#, use os seguintes atributos para configurar um gatilho do Barramento de Serviço:
ServiceBusTriggerAttribute
O construtor do atributo usa o nome da fila ou o tópico e a assinatura. In Azure Functions versão 1.x,
você também pode especificar os direitos de acesso da conexão. Se você não especificar os direitos de
acesso, o padrão é Manage . Para obter mais informações, consulte a seção Gatilho - configuração.
Aqui está um exemplo que mostra o atributo usado com um parâmetro de cadeia de caracteres:
[ServiceBusTrigger("myqueue")] string myQueueItem, ILogger log)
{
...
}
Você pode definir a Connection propriedade para especificar a conta de Barramento de Serviço para
usar, conforme mostrado no exemplo a seguir:
[ServiceBusTrigger("myqueue", Connection = "ServiceBusConnection")]
string myQueueItem, ILogger log)
{
...
}

ServiceBusAccountAttribute
Oferece uma maneira de especificar a conta de Barramento de Serviço para usar. O construtor toma o
nome de uma configuração de aplicativo que contenha uma cadeia de conexão de Barramento de
Serviço. O atributo pode ser aplicado no nível de classe, método ou parâmetro. O exemplo a seguir
mostra o nível de classe e método:
[ServiceBusAccount("ClassLevelServiceBusAppSetting")]
{
[ServiceBusAccount("MethodLevelServiceBusAppSetting")]
[ServiceBusTrigger("myqueue", AccessRights.Manage)]
string myQueueItem, ILogger log)
{
...
}
A conta de Barramento de Serviço a ser usada é determinada na seguinte ordem:

A propriedade ServiceBusTrigger do atributo Connection .
O ServiceBusAccount atributo aplicado ao mesmo parâmetro do ServiceBusTrigger atributo.
O ServiceBusAccount atributo aplicado à função.
O ServiceBusAccount atributo aplicado à classe.
A configuração de aplicativo "AzureWebJobsServiceBus".
function.json e o ServiceBusTrigger atributo.


"serviceBusTrigger". Essa propriedade é
você cria o gatilho no portal do Azure.
direction n/d Deve ser definido como "in". Essa


fila ou mensagem de tópico no código
de função. Definido como "$return"
para referenciar o valor de retorno da
função.
queueName QueueName Nome da fila a ser monitorada. Defina

somente se for monitorar uma fila,
não para um tópico.
topicName TopicName Nome do tópico a ser monitorado.

Defina somente se for monitorar um
tópico, não uma fila.
subscriptionName SubscriptionName Nome da assinatura a ser monitorada.

Defina somente se for monitorar um
tópico, não uma fila.

conexão de Barramento de Serviço
para usar para essa associação. Se o
nome de configuração do aplicativo
nome. Por exemplo, se você configurar
connection para "MyServiceBus", o
"AzureWebJobsMyServiceBus." Se você
deixar connection vazio, o tempo de
execução de Functions usa a cadeia de
caracteres de conexão do Barramento
de serviço na configuração de
aplicativo chamada
"AzureWebJobsServiceBus".
Para obter uma cadeia de conexão,

siga as etapas mostradas em Obter as
credenciais de gerenciamento. A
cadeia de conexão deve ser voltada
para um namespace do Barramento
de Serviço, não limitada a uma fila ou
tópico específico.
accessRights Acessar Direitos de acesso para a cadeia de

caracteres 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 "escutar". Caso
contrário, o tempo de execução do
Functions talvez falhe ao tentar
executar operações que exigem o
gerenciamento de direitos. No Azure
Functions versão 2. x, essa
propriedade não está disponível
porque a versão mais recente do SDK
de Armazenamento não oferece
suporte para operações de
gerenciamento.
Gatilho - uso
Em C# e script C#, você pode usar os tipos de parâmetros a seguir para a mensagem de fila ou tópico:
string -Se a mensagem for de texto.
byte[] - Útil para dados binários.
Um tipo personalizado - Se a mensagem contiver JSON, funções do Azure tentará desserializar os dados
JSON.
BrokeredMessage – fornece a você a mensagem desserializada com o método BrokeredMessage. GetBody<t
> () .
Esses parâmetros são para a versão 1.x do Azure Functions; para 2.x, use Message em vez de BrokeredMessage .
No JavaScript, acesse a mensagem da fila ou do tópico usando context.bindings.<name from function.json> . A
mensagem do Barramento de Serviço é passada em uma função como uma cadeia de caracteres ou um objeto
JSON.

A manipulação de mensagens suspeitas não pode ser controlada ou configurada no Azure Functions. O
barramento de serviço ele mesmo lida com as mensagens suspeitas.
Gatilho - Comportamento de PeekLock

O tempo de execução do Functions recebe uma mensagem no Modo PeekLock. Ele chama Complete na
mensagem se a função for concluída com êxito, ou chama Abandon se a função falhar. Se a função for
executada por mais tempo que o limite PeekLock , o bloqueio é renovado automaticamente.
O maxAutoRenewDuration pode ser configurado no host.json, que mapeia para
OnMessageOptions.MaxAutoRenewDuration. O máximo permitido para essa configuração é 5 minutos de
acordo com a documentação do Barramento de Serviço do Microsoft Azure, enquanto você pode aumentar o
limite de tempo de funções do padrão de 5 minutos para 10 minutos. Para funções de Barramento de Serviço
você não irá fazer isso, porque excederia o limite de renovação do Barramento de Serviço.
Gatilho - metadados da mensagem

O gatilho Barramento de Serviço fornece várias propriedades de metadados. Essas propriedades podem ser
usadas como parte de expressões de associação em outras associações ou como parâmetros em seu código.
Essas são propriedades da classe CloudQueueMessage.
DeliveryCount Int32 Número total de entregas.
DeadLetterSource string A origem de mensagens mortas.
ExpiresAtUtc DateTime Tempo de expiração em UTC.
MessageId string Um valor definido pelo usuário que o

Barramento de Serviço pode usar para
identificar mensagens duplicadas, se
habilitado.
ContentType string Um identificador de tipo de conteúdo

utilizado pelo remetente e destinatário
específico para lógica de aplicativo.
ReplyTo string A resposta para o endereço da fila.
SequenceNumber Int64 Número exclusivo atribuído a uma

mensagem pelo Barramento de
Serviço.
To string Enviar para o endereço.
Label string Rótulo específico do aplicativo.
CorrelationId string ID de correlação.
NOTE
Atualmente, o gatilho do barramento de serviço que funciona com filas e assinaturas habilitadas para sessão está em
versão prévia. Acompanhe este item para obter atualizações adicionais sobre isso.

O arquivo host.json contém configurações que controlam o comportamento de gatilho do Barramento de
Serviço.
{
"serviceBus": {
"maxConcurrentCalls": 16,
"maxAutoRenewDuration": "00:05:00"
}
}
maxConcurrentCalls 16 O número máximo de chamadas

simultâneas para o retorno de
chamada que a bomba de mensagens
deve iniciar. Por padrão, o tempo de
execução do Functions processa várias
mensagens simultaneamente. Para
direcionar o tempo de execução para
processar uma única fila ou mensagem
de tópico de cada vez, defina
maxConcurrentCalls como 1.

usado pelo MessageReceiver
subjacente.
maxAutoRenewDuration 00:05:00 A duração máxima na qual o bloqueio

de mensagem será renovado
automaticamente.
Saída
Use a associação de saída do barramento de serviço do Azure para enviar mensagens de fila ou de tópico.
Saída - exemplo
C#
F#
Java
JavaScript
Python
Saída - exemplo C#
A exemplo a seguir mostra uma função C# que envia uma mensagem de fila do Barramento de Serviço:
[FunctionName("ServiceBusOutput")]
[return: ServiceBus("myqueue", Connection = "ServiceBusConnection")]
public static string ServiceBusOutput([HttpTrigger] dynamic input, ILogger log)
{
log.LogInformation($"C# function processed: {input.Text}");
return input.Text;
}

O exemplo a seguir mostra uma associação de saída de Barramento de Serviço em um arquivo function.json e
uma função script C# que usa a associação. A função usa um gatilho de timer para enviar uma mensagem da
fila a cada 15 segundos.
{
"bindings": [
{
"schedule": "0/15 * * * * *",
"name": "myTimer",
"runsOnStartup": true,
"direction": "in"
},
{
"name": "outputSbQueue",
"type": "serviceBus",
"direction": "out"
}
],
"disabled": false
}
Aqui está o código script C# que cria uma mensagem única:
public static void Run(TimerInfo myTimer, ILogger log, out string outputSbQueue)
{
string message = $"Service Bus queue message created at: {DateTime.Now}";
outputSbQueue = message;
}
public static async Task Run(TimerInfo myTimer, ILogger log, IAsyncCollector<string> outputSbQueue)
{
string message = $"Service Bus queue messages created at: {DateTime.Now}";
await outputSbQueue.AddAsync("1 " + message);
await outputSbQueue.AddAsync("2 " + message);
}
Saída - Exemplo #F
e uma Função script C# que usa a associação. A função usa um gatilho de timer para enviar uma mensagem
da fila a cada 15 segundos.
{
"bindings": [
{
"schedule": "0/15 * * * * *",
"name": "myTimer",
"direction": "in"
},
{
"direction": "out"
}
],
"disabled": false
}
Aqui está o código de script C# que cria uma mensagem única:
let Run(myTimer: TimerInfo, log: ILogger, outputSbQueue: byref<string>) =

let message = sprintf "Service Bus queue message created at: %s" (DateTime.Now.ToString())
log.LogInformation(message)
outputSbQueue = message

O exemplo a seguir mostra uma função Java que envia uma mensagem a uma fila myqueue do Barramento de
Serviço quando disparada por uma solicitação HTTP.
@FunctionName("httpToServiceBusQueue")
@ServiceBusQueueOutput(name = "message", queueName = "myqueue", connection = "AzureServiceBusConnection")
public String pushToQueue(
@HttpTrigger(name = "request", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS)
final String message,
@HttpOutput(name = "response") final OutputBinding<T> result ) {
result.setValue(message + " has been sent.");
return message;
}
Na biblioteca de tempo de execução das funções Java, use a anotação @QueueOutput nos parâmetros da função
cujo valor poderia ser gravado em uma fila do Barramento de Serviço. O tipo de parâmetro deve ser
OutputBinding<T> , onde T é qualquer tipo Java nativo de um POJO.
As funções Java também podem gravar em um tópico do barramento de serviço. O exemplo a seguir usa a
anotação @ServiceBusTopicOutput para descrever a configuração da Associação de saída.
@FunctionName("sbtopicsend")
AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
@ServiceBusTopicOutput(name = "message", topicName = "mytopicname", subscriptionName =
"mysubscription", connection = "ServiceBusConnection") OutputBinding<String> message,
String name = request.getBody().orElse("Azure Functions");
message.setValue(name);

O exemplo a seguir mostra uma associação de saída de Barramento de Serviço em um arquivo function.json e
uma função JavaScript C# que usa a associação. A função usa um gatilho de timer para enviar uma mensagem
da fila a cada 15 segundos.
{
"bindings": [
{
"schedule": "0/15 * * * * *",
"name": "myTimer",
"direction": "in"
},
{
"direction": "out"
}
],
"disabled": false
}
Aqui está o código de script JavaScript que cria uma mensagem única:

var message = 'Service Bus queue message created at ' + timeStamp;
context.log(message);
context.bindings.outputSbQueue = message;
context.done();
};
Aqui está o código de script JavaScript que cria várias mensagens:

var message = 'Service Bus queue message created at ' + timeStamp;
context.log(message);
context.bindings.outputSbQueue = [];
context.bindings.outputSbQueue.push("1 " + message);
context.bindings.outputSbQueue.push("2 " + message);
context.done();
};

O exemplo a seguir demonstra como gravar em uma fila do ServiceBus em Python.
Uma definição de associação ServiceBue é definida em Function. JSON , em que Type é definido como
serviceBus .
{
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
},
{
"direction": "out",
"connection": "AzureServiceBusConnectionString",
"name": "msg",
"queueName": "outqueue"
}
]
}
Em _init_. py, você pode gravar uma mensagem na fila passando um valor para o método set .
def main(req: func.HttpRequest, msg: func.Out[str]) -> func.HttpResponse:
input_msg = req.params.get('message')
msg.set(input_msg)
return 'OK'
Saída - atributos
Em bibliotecas de classes do C#, use o ServiceBusAttribute.
O construtor do atributo usa o nome da fila ou o tópico e a assinatura. Você também pode especificar os
direitos de acesso da conexão. Há uma explicação sobre como escolher as configuração de direitos de acesso
na seção Saída - Configuração. Aqui está um exemplo que mostra o atributo aplicado ao valor retornado da
função:
[return: ServiceBus("myqueue")]
{
...
}
Você pode definir a Connection propriedade para especificar a conta de Barramento de Serviço para usar,
[return: ServiceBus("myqueue", Connection = "ServiceBusConnection")]
{
...
}

Você pode usar o atributo ServiceBusAccount para especificar a conta do Barramento de Serviço ao nível da
classe, do método ou do parâmetro. Para obter mais informações, consulte Gatilho - atributos.
function.json e o ServiceBus atributo.
tipo n/d Deve ser definido como "serviceBus".

Essa propriedade é definida
direction n/d Deve ser definido como "out". Essa


fila ou tópico no código de função.
Definido como "$return" para
referenciar o valor de retorno da
função.
queueName QueueName Nome da fila. Defina somente se for

enviar mensagens da fila, não para um
tópico.
topicName TopicName Nome do tópico a ser monitorado.

Defina somente se for enviar
mensagens do tópico, não para uma
fila.

conexão de Barramento de Serviço
para usar para essa associação. Se o
nome de configuração do aplicativo
nome. Por exemplo, se você configurar
connection para "MyServiceBus", o
"AzureWebJobsMyServiceBus." Se você
caracteres de conexão do Barramento
de serviço na configuração de
aplicativo chamada
"AzureWebJobsServiceBus".
Para obter uma cadeia de conexão,

siga as etapas mostradas em Obter as
credenciais de gerenciamento. A
cadeia de conexão deve ser voltada
para um namespace do Barramento
de Serviço, não limitada a uma fila ou
tópico específico.
accessRights Acessar Direitos de acesso para a cadeia de

caracteres 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 "escutar". Caso
contrário, o tempo de execução do
Functions talvez falhe ao tentar
executar operações que exigem o
gerenciamento de direitos. No Azure
Functions versão 2. x, essa
propriedade não está disponível
porque a versão mais recente do SDK
de Armazenamento não oferece
suporte para operações de
gerenciamento.
Saída - uso
No Azure Functions 1. x, o tempo de execução criará a fila se ela não existir e você tiver definido accessRights
como manage . No Functions versão 2. x, a fila ou tópico já deverá existir; se você especificar uma fila ou um
tópico que não existe, a função falhará.
Em C# e script C#, você pode usar os tipos de parâmetros a seguir para a associação de saída:
out T paramName - T pode ser qualquer tipo serializável em JSON. Se o valor do parâmetro for nulo
quando a função existir, o Functions criará a mensagem com um objeto nulo.
out string - Se o valor de parâmetro não for nulo quando a função sair, o Functions criará uma
mensagem.
out byte[] - Se o valor de parâmetro não for nulo quando a função sair, o Functions criará uma
mensagem.
out BrokeredMessage -se o valor do parâmetro for nulo quando a função for encerrada, as funções não
criarão uma mensagem (para as funções 1. x)
out Message -se o valor do parâmetro for nulo quando a função for encerrada, as funções não criarão uma
mensagem (para as funções 2. x)
ICollector<T> ou IAsyncCollector<T> - Para a criação de várias mensagens. Uma mensagem é criada
quando você chama o método Add .
Ao trabalhar com C# funções:
As funções assíncronas precisam de um valor de retorno ou IAsyncCollector em vez de um parâmetro
out .
Para acessar a ID da sessão, associe a um tipo de Message e use a propriedade sessionId .
No JavaScript, acesse a fila ou o tópico usando context.bindings.<name from function.json> . Você pode
atribuir uma cadeia de caracteres, uma matriz de bytes ou um objeto JavaScript (desserializado em JSON )
para context.binding.<name> .
Para enviar uma mensagem para uma fila habilitada para sessão em outrosC# idiomas, use o SDK do
barramento de serviço do Azure em vez da Associação de saída interna.

BARRAMENTO DE SERVIÇO Códigos de erro do Barramento de Serviço do Microsoft

Azure
BARRAMENTO DE SERVIÇO Limites do Barramento de Serviço do Microsoft Azure
NOTE
{
"version": "2.0",
"extensions": {
"serviceBus": {
"messageHandlerOptions": {
"autoComplete": false,
"maxAutoRenewDuration": "00:55:00"
}
}
}
}
maxAutoRenewDuration 00:05:00 A duração máxima na qual o bloqueio

automaticamente.
autoComplete verdadeiro Se o gatilho deve ser marcado

imediatamente como concluído
(completar automaticamente) ou
aguardar a conclusão do
processamento da chamada.

processar uma única fila ou mensagem
de tópico de cada vez, defina
maxConcurrentCalls como 1.

subjacente.
Próximas etapas
Associações do Serviço SignalR para o Azure
Functions
Este artigo explica como autenticar e enviar mensagens em tempo real para clientes conectados ao Serviço do
Azure SignalR usando associações do Serviço SignalR no Azure Functions. O Azure Functions dá suporte a
associações de entrada e saída para o Serviço SignalR.
As associações de serviço Signalr são fornecidas no pacote NuGet Microsoft. Azure. webjobs. Extensions.
SignalRService , versão 1. *. O código-fonte do pacote está no repositório GitHub azure-functions-signalrservice-
extension.

Desenvolvimento local - Script do C#, JavaScript, F# Registrar a extensão
Desenvolvimento de portal Registrar a extensão
Anotações de Java
Para usar as anotações do serviço Signalr em funções Java, você precisa adicionar uma dependência ao artefato
do Azure-Functions-Java -library-signalr (versão 1,0 ou superior) para o pom. xml.
<dependency>
<groupId>com.microsoft.azure.functions</groupId>
<artifactId>azure-functions-java-library-signalr</artifactId>
</dependency>
NOTE
Para usar as associações do Serviço do SignalR em Java, verifique se você está usando a versão 2.4.419 ou posterior do
Azure Functions Core Tools (versão do host 2.0.12332).
Usando o serviço de sinalização com Azure Functions

Para obter detalhes sobre como configurar e usar o serviço de sinalização e Azure Functions juntos, consulte
Azure Functions desenvolvimento e configuração com o serviço de signaler do Azure.
Associação de entrada de informações da conexão do SignalR

Antes que um cliente possa se conectar ao serviço do Azure SignalR, ele deve recuperar a URL do ponto de
extremidade de serviço e um token de acesso válido. A associação de entrada SignalRConnectionInfo produz a
URL do ponto de extremidade de Serviço SignalR e um token válido que são usados para se conectar ao serviço.
Como o token é limitada pelo tempo e pode ser usado para autenticar um usuário específico para uma conexão,
você não deve armazenar em cache o token nem o compartilhar entre clientes. Um gatilho HTTP que use essa
associação pode ser usado pelos clientes para recuperar as informações de conexão.
2.x C#
2.x JavaScript
2.x Java
Para obter mais informações sobre como essa associação é usada para criar uma função "Negotiate" que pode
ser consumida por um SDK de cliente do Signalr, consulte o artigo Azure Functions desenvolvimento e
configuração na documentação conceitos do serviço signalr.
exemplos de entrada C# 2. x
O exemplo a seguir mostra uma função C# que adquire as informações de conexão do SignalR usando a
associação de entrada e retorna-a via HTTP.
[FunctionName("negotiate")]
public static SignalRConnectionInfo Negotiate(
[HttpTrigger(AuthorizationLevel.Anonymous)]HttpRequest req,
[SignalRConnectionInfo(HubName = "chat")]SignalRConnectionInfo connectionInfo)
{
return connectionInfo;
}
Tokens autenticados
Se a função for disparada por um cliente autenticado, você poderá adicionar uma declaração de ID de usuário ao
token gerado. Você pode adicionar facilmente a autenticação a um aplicativo de funções usando a autenticação
do serviço de aplicativo.
Autenticação do Serviço de Aplicativo define os cabeçalhos HTTP denominados x-ms-client-principal-id e
x-ms-client-principal-name que contêm a ID e o nome da entidade de segurança do cliente do usuário
autenticado, respectivamente. Você pode definir a propriedade UserId da associação como o valor do cabeçalho
usando uma expressão de associação: {headers.x-ms-client-principal-id} ou
{headers.x-ms-client-principal-name} .
[FunctionName("negotiate")]
public static SignalRConnectionInfo Negotiate(
[HttpTrigger(AuthorizationLevel.Anonymous)]HttpRequest req,
[SignalRConnectionInfo
(HubName = "chat", UserId = "{headers.x-ms-client-principal-id}")]
SignalRConnectionInfo connectionInfo)
{
// connectionInfo contains an access key token with a name identifier claim set to the authenticated user
}
2. x exemplos de entrada JavaScript

O exemplo a seguir mostra uma associação de entrada de informações de conexão do SignalR em um arquivo
function.json e uma função JavaScript que usa a associação para retornar as informações de conexão.
function.json de exemplo:
{
"type": "signalRConnectionInfo",
"name": "connectionInfo",
"hubName": "chat",
"connectionStringSetting": "<name of setting containing SignalR Service connection string>",
"direction": "in"
}
module.exports = async function (context, req, connectionInfo) {

context.res.body = connectionInfo;
};
Tokens autenticados
autenticado, respectivamente. Você pode definir a propriedade userId da associação como o valor do cabeçalho
{
"type": "signalRConnectionInfo",
"name": "connectionInfo",
"hubName": "chat",
"userId": "{headers.x-ms-client-principal-id}",
"direction": "in"
}

module.exports = async function (context, req, connectionInfo) {
// connectionInfo contains an access key token with a name identifier
// claim set to the authenticated user
context.res.body = connectionInfo;
};
2. x exemplos de entrada Java

O exemplo a seguir mostra uma função Java que adquire informações de conexão do signalr usando a associação
de entrada e a retorna sobre http.
@FunctionName("negotiate")
public SignalRConnectionInfo negotiate(
@HttpTrigger(
name = "req",
methods = { HttpMethod.POST },
authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> req,
@SignalRConnectionInfoInput(
name = "connectionInfo",
hubName = "chat") SignalRConnectionInfo connectionInfo) {
}
Tokens autenticados
autenticado, respectivamente. Você pode definir a propriedade UserId da associação como o valor do cabeçalho
@FunctionName("negotiate")
public SignalRConnectionInfo negotiate(
@HttpTrigger(
name = "req",
authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> req,
@SignalRConnectionInfoInput(
name = "connectionInfo",
hubName = "chat",
userId = "{headers.x-ms-client-principal-id}") SignalRConnectionInfo connectionInfo) {
}
Associação de saída do SignalR

Use a associação de saída do SignalR para enviar uma ou mais mensagens usando o Serviço Azure SignalR. Você
pode difundir uma mensagem a todos os clientes conectados, ou pode difundi-la somente para clientes
conectados que foram autenticados em um determinado usuário.
Você também pode usá-lo para gerenciar os grupos aos quais um usuário pertence.
2.x C#
2.x JavaScript
2.x Java
2. x C# exemplos de saída de mensagem de envio
Difundir para todos os clientes
A exemplo a seguir mostra uma função C# que envia uma mensagem usando a associação de saída para todos
os clientes conectados. O Target é o nome do método a ser invocado em cada cliente. A propriedade Arguments
é uma matriz de zero ou mais objetos a serem passados para o método do cliente.
[FunctionName("SendMessage")]
public static Task SendMessage(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")]object message,
[SignalR(HubName = "chat")]IAsyncCollector<SignalRMessage> signalRMessages)
{
return signalRMessages.AddAsync(
new SignalRMessage
{
Target = "newMessage",
Arguments = new [] { message }
});
}
Enviar para um usuário

Você pode enviar uma mensagem apenas para conexões autenticadas para um usuário configurando a
propriedade UserId da mensagem do SignalR.
{
new SignalRMessage
{
// the message will only be sent to this user ID
UserId = "userId1",
});
}
Enviar para um grupo

Você pode enviar uma mensagem somente para conexões que foram adicionadas a um grupo, definindo a
GroupName propriedade da mensagem do signalr.
{
new SignalRMessage
{
// the message will be sent to the group with this name
GroupName = "myGroup",
});
}
exemplos de saída C# de gerenciamento de grupo 2. x
O serviço signalr permite que os usuários sejam adicionados a grupos. As mensagens podem ser enviadas a um
grupo. Você pode usar a SignalRGroupAction classe com a SignalR Associação de saída para gerenciar a
associação de grupo de um usuário.
Adicionar usuário a um grupo
O exemplo a seguir adiciona um usuário a um grupo.
[FunctionName("addToGroup")]
public static Task AddToGroup(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")]HttpRequest req,
ClaimsPrincipal claimsPrincipal,
[SignalR(HubName = "chat")]
IAsyncCollector<SignalRGroupAction> signalRGroupActions)
{
var userIdClaim = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier);
return signalRGroupActions.AddAsync(
new SignalRGroupAction
{
UserId = userIdClaim.Value,
Action = GroupAction.Add
});
}
Remover usuário de um grupo

O exemplo a seguir remove um usuário de um grupo.
[FunctionName("removeFromGroup")]
public static Task RemoveFromGroup(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")]HttpRequest req,
ClaimsPrincipal claimsPrincipal,
[SignalR(HubName = "chat")]
IAsyncCollector<SignalRGroupAction> signalRGroupActions)
{
var userIdClaim = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier);
return signalRGroupActions.AddAsync(
new SignalRGroupAction
{
UserId = userIdClaim.Value,
Action = GroupAction.Remove
});
}
NOTE
Para obter os ClaimsPrincipal limites corretos, você deve ter definido as configurações de autenticação no Azure
functions.
2. x exemplos de saída de mensagem de envio JavaScript

O exemplo a seguir mostra uma associação de saída do SignalR em um arquivo function.json e uma função
JavaScript que usa a associação para enviar uma mensagem com o Serviço do Azure SignalR. Defina a
associação de saída para uma matriz de uma ou mais mensagens do SignalR. Uma mensagem do SignalR
consiste em uma propriedade target que especifica o nome do método a ser invocado em cada cliente, e uma
propriedade arguments que é uma matriz de objetos a serem passados para o método de cliente como
argumentos.
{
"type": "signalR",
"name": "signalRMessages",
"hubName": "<hub_name>",
"direction": "out"
}

context.bindings.signalRMessages = [{
"target": "newMessage",
"arguments": [ req.body ]
}];
};

propriedade userId da mensagem do SignalR.
function.json permanece igual. Aqui está o código JavaScript:

// message will only be sent to this user ID
"userId": "userId1",
}];
};

groupName propriedade da mensagem do signalr.
function.json permanece igual. Aqui está o código JavaScript:

// message will only be sent to this group
"groupName": "myGroup",
}];
};
2. x exemplos de saída de gerenciamento de grupo JavaScript

grupo. Você pode usar a SignalR Associação de saída para gerenciar a associação de grupo de um usuário.
function.json
{
"disabled": false,
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "res"
},
{
"type": "signalR",
"name": "signalRGroupActions",
"hubName": "chat",
"direction": "out"
}
]
}
index.js

context.bindings.signalRGroupActions = [{
"userId": req.query.userId,
"action": "add"
}];
};

function.json
{
"disabled": false,
"bindings": [
{
"direction": "in",
"name": "req",
"methods": [
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "res"
},
{
"type": "signalR",
"name": "signalRGroupActions",
"hubName": "chat",
"direction": "out"
}
]
}
index.js

context.bindings.signalRGroupActions = [{
"userId": req.query.userId,
"action": "remove"
}];
};
2. x exemplos de saída de mensagem de envio Java

O exemplo a seguir mostra uma função Java que envia uma mensagem usando a associação de saída para todos
os clientes conectados. O target é o nome do método a ser invocado em cada cliente. A propriedade arguments
é uma matriz de zero ou mais objetos a serem passados para o método do cliente.
@FunctionName("sendMessage")
@SignalROutput(name = "$return", hubName = "chat")
public SignalRMessage sendMessage(
@HttpTrigger(
name = "req",
authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req) {
SignalRMessage message = new SignalRMessage();

message.target = "newMessage";
message.arguments.add(req.getBody());
return message;
}

propriedade userId da mensagem do SignalR.
@HttpTrigger(
name = "req",

message.userId = "userId1";
return message;
}

groupName propriedade da mensagem do signalr.
@HttpTrigger(
name = "req",

message.groupName = "myGroup";
return message;
}
2. x exemplos de saída de gerenciamento de grupo Java

grupo. Você pode usar a SignalRGroupAction classe com a SignalROutput Associação de saída para gerenciar a
associação de grupo de um usuário.
@FunctionName("addToGroup")
public SignalRGroupAction addToGroup(
@HttpTrigger(
name = "req",
authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req,
@BindingName("userId") String userId) {
SignalRGroupAction groupAction = new SignalRGroupAction();

groupAction.action = "add";
groupAction.userId = userId;
groupAction.groupName = "myGroup";
return action;
}

@FunctionName("removeFromGroup")
public SignalRGroupAction removeFromGroup(
@HttpTrigger(
name = "req",
authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req,
@BindingName("userId") String userId) {
SignalRGroupAction groupAction = new SignalRGroupAction();

groupAction.action = "remove";
groupAction.userId = userId;
groupAction.groupName = "myGroup";
return action;
}
Configuração
SignalRConnectionInfo
e no atributo SignalRConnectionInfo .
type Deve ser definido como

signalRConnectionInfo .
name Nome da variável usada no código de

função para o objeto de informações de
conexão.
hubName HubName Esse valor deve ser definido como o

nome do hub SignalR para o qual as
informações de conexão são geradas.
userId UserId Opcional: O valor da declaração do

identificador de usuário a ser definida
no token de chave de acesso.

SignalR Service (o padrão é
"AzureSignalRConnectionString")
SignalR
e no atributo SignalR .
type Deve ser definido como signalR .

name Nome da variável usada no código de

função para o objeto de informações de
conexão.
hubName HubName Esse valor deve ser definido como o

nome do hub SignalR para o qual as
informações de conexão são geradas.

SignalR Service (o padrão é
"AzureSignalRConnectionString")
Próximas etapas
Desenvolvimento de funções do Azure e a configuração com o serviço do Azure SignalR
Associações de armazenamento de tabelas do Azure
Functions
Este artigo explica como trabalhar com associações de armazenamento de Tabela do Azure no Azure Functions.
O Azure Functions dá suporte a associações de entrada e saída para armazenamento de Tabelas do Azure.
As associações de armazenamento de Tabelas são fornecidas no pacote NuGet Microsoft.Azure.WebJobs, versão
2.x. O código-fonte do pacote está no repositório GitHub azure-webjobs-sdk.
O suporte para essa associação é fornecido automaticamente em todos os ambientes de desenvolvimento. Você
não precisa instalar o pacote ou registrar a extensão manualmente.
Armazenamento do Microsoft Azure (windowsazure pacote NuGet). Se você referenciar uma versão diferente do
SDK do armazenamento e associar a um tipo de SDK de armazenamento na sua assinatura de função, o tempo
de execução de funções pode relatar se não é possível associar a esse tipo. A solução é verificar as referências do
projeto windowsazure 7.2.1.
As associações de Armazenamento de Tabelas são fornecidas no pacote NuGet
Microsoft.Azure.WebJobs.Extensions.Storage, versão 3.x. O código-fonte do pacote está no repositório GitHub
azure-webjobs-sdk.


Python
Entrada
Use a associação de entrada de armazenamento de Tabela do Azure para ler uma tabela em uma conta de
Entrada - exemplo
Uma entidade de leitura de C#
Associação de C# para IQueryable
Associação de C# para CloudTable
Script de C# ler uma entidade
Associação de script de C# para IQueryable
Associação de script de C# para CloudTable
F#
JavaScript
Java
Entrada - exemplo de C# - uma entidade
O exemplo a seguir mostra uma função C# que lê uma linha da tabela.
O valor de chave de linha “{queueTrigger}” indica que a chave de linha foi obtida da cadeia de caracteres da
mensagem da fila.
public class TableStorage

{
public class MyPoco
{
public string Text { get; set; }
}
[FunctionName("TableInput")]
public static void TableInput(
[QueueTrigger("table-items")] string input,
[Table("MyTable", "MyPartition", "{queueTrigger}")] MyPoco poco,
ILogger log)
{
log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
}
}
Entrada - exemplo de C# - IQueryable

O exemplo a seguir mostra uma função C# que lê várias linhas da tabela. Observe que a MyPoco classe deriva de
TableEntity .
{
public class MyPoco : TableEntity
{
}
public static void TableInput(
[Table("MyTable", "MyPartition")] IQueryable<MyPoco> pocos,
ILogger log)
{
foreach (MyPoco poco in pocos)
{
log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
}
}
}
Entrada - exemplo de C# - CloudTable

IQueryable não tem suporte no tempo de execução do Functions v2. Uma alternativa é usar um CloudTable
parâmetro do método para ler a tabela usando o SDK de Armazenamento do Azure. Veja um exemplo de uma
função 2.x que consulta uma tabela de log do Azure Functions:
using Microsoft.WindowsAzure.Storage.Table;
using System;
namespace FunctionAppCloudTable2
{
public class LogEntity : TableEntity
{
public string OriginalName { get; set; }
}
public static class CloudTableDemo
{
[FunctionName("CloudTableDemo")]
[TimerTrigger("0 */1 * * * *")] TimerInfo myTimer,
[Table("AzureWebJobsHostLogscommon")] CloudTable cloudTable,
ILogger log)
{
TableQuery<LogEntity> rangeQuery = new TableQuery<LogEntity>().Where(

TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
"FD2"),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThan,
"t")));
// Execute the query and loop through the results

foreach (LogEntity entity in
await cloudTable.ExecuteQuerySegmentedAsync(rangeQuery, null))
{
log.LogInformation(
$"{entity.PartitionKey}\t{entity.RowKey}\t{entity.Timestamp}\t{entity.OriginalName}");
}
}
}
}
Para obter mais informações sobre como usar o CloudTable, consulte Introdução ao Armazenamento de Tabelas
do Azure.
Se você tentar associar CloudTable e receber uma mensagem de erro, certifique-se de ter uma referência para a
versão correta do SDK do Armazenamento.
Entrada - exemplo de script de C# - uma entidade
O exemplo a seguir mostra uma associação de entrada de tabela em um arquivo function.json e código script C#
que usa a associação. A função usa um gatilho de fila para ler uma linha da tabela.
O arquivo function.json especifica um partitionKey e um rowKey . O rowKey valor “{queueTrigger}” indica que a
chave de linha foi obtida da cadeia de caracteres da mensagem da fila.
{
"bindings": [
{
"connection": "MyStorageConnectionAppSetting",
"direction": "in"
},
{
"name": "personEntity",
"type": "table",
"tableName": "Person",
"partitionKey": "Test",
"rowKey": "{queueTrigger}",
"direction": "in"
}
],
"disabled": false
}

public static void Run(string myQueueItem, Person personEntity, ILogger log)

{
log.LogInformation($"Name in Person entity: {personEntity.Name}");
}
public class Person

{
}
Entrada - exemplo de script de C# - IQueryable

O exemplo a seguir mostra uma associação de entrada de tabela em um arquivo function.json e código script C#
que usa a associação. A função lê entidades para uma chave de partição especificada em uma mensagem da fila.
{
"bindings": [
{
"direction": "in"
},
{
"name": "tableBinding",
"type": "table",
"direction": "in"
}
],
"disabled": false
}

O código script C# adiciona uma referência ao SDK de Armazenamento do Azure para que o tipo de entidade
possa derivar de TableEntity :
public static void Run(string myQueueItem, IQueryable<Person> tableBinding, ILogger log)

{
foreach (Person person in tableBinding.Where(p => p.PartitionKey == myQueueItem).ToList())
{
log.LogInformation($"Name: {person.Name}");
}
}
public class Person : TableEntity

{
}
Entrada - exemplo de script de C# - CloudTable

IQueryable não tem suporte no tempo de execução do Functions v2. Uma alternativa é usar um CloudTable
parâmetro do método para ler a tabela usando o SDK de Armazenamento do Azure. Veja um exemplo de uma
função 2.x que consulta uma tabela de log do Azure Functions:
{
"bindings": [
{
"name": "myTimer",
"direction": "in",
"schedule": "0 */1 * * * *"
},
{
"name": "cloudTable",
"type": "table",
"connection": "AzureWebJobsStorage",
"tableName": "AzureWebJobsHostLogscommon",
"direction": "in"
}
],
"disabled": false
}
using System;
public static async Task Run(TimerInfo myTimer, CloudTable cloudTable, ILogger log)
{
TableQuery<LogEntity> rangeQuery = new TableQuery<LogEntity>().Where(

TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
"FD2"),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThan,
"a")));
// Execute the query and loop through the results

foreach (LogEntity entity in
await cloudTable.ExecuteQuerySegmentedAsync(rangeQuery, null))
{
log.LogInformation(
$"{entity.PartitionKey}\t{entity.RowKey}\t{entity.Timestamp}\t{entity.OriginalName}");
}
}
public class LogEntity : TableEntity

{
public string OriginalName { get; set; }
}
Para obter mais informações sobre como usar o CloudTable, consulte Introdução ao Armazenamento de Tabelas
do Azure.
Se você tentar associar CloudTable e receber uma mensagem de erro, certifique-se de ter uma referência para a
versão correta do SDK do Armazenamento.
Entrada - exemplo #F
O exemplo a seguir mostra uma associação de entrada de tabela em um arquivo function.json e código script F#
que usa a associação. A função usa um gatilho de fila para ler uma linha da tabela.
{
"bindings": [
{
"direction": "in"
},
{
"type": "table",
"direction": "in"
}
],
"disabled": false
}

[<CLIMutable>]
type Person = {
PartitionKey: string
RowKey: string
Name: string
}
let Run(myQueueItem: string, personEntity: Person) =

log.LogInformation(sprintf "F# Queue trigger function processed: %s" myQueueItem)
log.LogInformation(sprintf "Name in Person entity: %s" personEntity.Name)
Entrada - exemplo de JavaScript

O exemplo a seguir mostra uma associação de entrada de tabela em um arquivofunction.json e o código
JavaScript que usa a associação. A função usa um gatilho de fila para ler uma linha da tabela.
{
"bindings": [
{
"direction": "in"
},
{
"type": "table",
"direction": "in"
}
],
"disabled": false
}


context.log('Node.js queue trigger function processed work item', myQueueItem);
context.log('Person entity name: ' + context.bindings.personEntity.Name);
context.done();
};
Entrada - exemplo de Java

O exemplo a seguir mostra uma função disparada por HTTP que retorna a contagem total de itens em uma
partição especificada no Armazenamento de Tabelas.
@FunctionName("getallcount")
public int run(
methods = {HttpMethod.GET},
authLevel = AuthorizationLevel.ANONYMOUS) Object dummyShouldNotBeUsed,
@TableInput(name = "items",
tableName = "mytablename", partitionKey = "myparkey",
connection = "myconnvarname") MyItem[] items
) {
return items.length;
}
Em bibliotecas de classes C#, use os seguintes atributos para configurar uma associação de entrada da tabela:
TableAttribute
O construtor do atributo usa o nome da tabela, a chave de partição e a chave de linha. Ele pode ser usado
em um parâmetro de saída ou no valor de retorno da função, conforme mostrado no exemplo a seguir:
[Table("MyTable", "Http", "{queueTrigger}")] MyPoco poco,
ILogger log)
{
...
}
[Table("MyTable", "Http", "{queueTrigger}", Connection = "StorageConnectionAppSetting")] MyPoco
poco,
ILogger log)
{
...
}
Para ver um exemplo completo, confira Entrada - exemplo de C#.

Oferece uma maneira de especificar a conta de armazenamento para usar. O construtor toma o nome de
uma configuração de aplicativo que contenha uma cadeia de conexão de armazenamento. O atributo pode
ser aplicado no nível de classe, método ou parâmetro. O exemplo a seguir mostra o nível de classe e
método:
{
{
...
}

A propriedade Table do atributo Connection .
O StorageAccount atributo aplicado ao mesmo parâmetro do Table atributo.
A conta de armazenamento padrão para a função de aplicativo (configuração de aplicativo
"AzureWebJobsStorage").
Entrada - anotações de Java

Na biblioteca de tempo de execução de funções Java, use a anotação @TableInput nos parâmetros cujo valor
possa ser proveniente do Armazenamento de Tabelas. Esta anotação pode ser usada com tipos Java nativos,
POJOs ou valores anuláveis usando T<> opcional.
e o Table atributo.
type n/d Deve ser definido como table . Esse

portal do Azure.
direction n/d Deve ser definido como in . Esse

portal do Azure.

tabela ou entidade no código de
função.
tableName TableName O nome da tabela.
partitionKey PartitionKey Opcional. Chave de partição da

entidade de tabela para leitura.
Consulte a seção de uso para obter
orientação sobre como usar essa
propriedade.
rowKey RowKey Opcional. Chave de linha da entidade

de tabela para leitura. Consulte a seção
de uso para obter orientação sobre
como usar essa propriedade.
take Take Opcional. O número máximo de

entidades para ler em JavaScript.
Consulte a seção de uso para obter
orientação sobre como usar essa
propriedade.
filter Filter Opcional. Uma expressão de filtro

OData para a entrada de tabela em
JavaScript. Consulte a seção de uso
para obter orientação sobre como usar
essa propriedade.

conexão de Armazenamento para usar
para essa associação. Se o nome de
configuração do aplicativo começar
caracteres de conexão de
Entrada - uso
A associação de entrada da Tabela de Armazenamento dá suporte aos seguintes cenários:
Ler uma linha em C# ou o script do C#
Definir e rowKey . Acessar os dados da tabela usando um parâmetro de método
partitionKey
T <paramName> . No script do C#, paramName é o valor especificado na propriedade name de function.json.
T geralmente é um tipo que implementa ITableEntity ou deriva de TableEntity . As propriedades
filter e take não são usadas neste cenário.
Ler uma ou mais linhas em C# ou o script do C#

Acessar os dados da tabela usando um parâmetro de método IQueryable<T> <paramName> . No script do C#,
paramName é o valor especificado na propriedade name de function.json. T geralmente é um tipo que
implementa ITableEntity ou deriva de TableEntity . Você pode usar IQueryable métodos para fazer a
filtragem necessária. As propriedades partitionKey , rowKey , filter e take não são usadas neste
cenário.
NOTE
IQueryable não tem suporte no tempo de execução do Functions v2. Uma alternativa é usar um parâmetro do
método paramName de CloudTable para ler a tabela usando o SDK de Armazenamento do Azure. Se você tentar
associar CloudTable e receber uma mensagem de erro, certifique-se de ter uma referência para a versão correta
do SDK do Armazenamento.
Ler uma ou mais linhas em JavaScript

Definir as propriedades filter e take . Não definir partitionKey ou rowKey . Acesse a entidade (ou
entidades) de tabela de entrada usando context.bindings.<BINDING_NAME> . Os objetos desserializados têm
propriedades RowKey e PartitionKey .
Saída
Use uma associação de saída de armazenamento de Tabela do Azure para gravar entidades para uma tabela em
uma conta de Armazenamento do Azure.
NOTE
Essa associação de saída não dá suporte para atualização de entidades existentes. Use a TableOperation.Replace
operação do SDK do Armazenamento do Microsoft Azure para atualizar uma entidade existente.
Saída - exemplo
C#
Script do C# (.csx)
F#
JavaScript
Saída - exemplo C#
O exemplo a seguir mostra uma função C# que usa um gatilho HTTP para gravar uma única linha de tabela.

{
public class MyPoco
{
}
[FunctionName("TableOutput")]
[return: Table("MyTable")]
public static MyPoco TableOutput([HttpTrigger] dynamic input, ILogger log)
{
log.LogInformation($"C# http trigger function processed: {input.Text}");
return new MyPoco { PartitionKey = "Http", RowKey = Guid.NewGuid().ToString(), Text = input.Text };
}
}

O exemplo a seguir mostra uma associação de saída de tabela em um arquivo function.json e código script C#
que usa a associação. A função escreve múltiplas entidades de tabela.
{
"bindings": [
{
"name": "input",
"type": "manualTrigger",
"direction": "in"
},
{
"type": "table",
"direction": "out"
}
],
"disabled": false
}

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

{
}
Saída - Exemplo #F
{
"bindings": [
{
"name": "input",
"direction": "in"
},
{
"type": "table",
"direction": "out"
}
],
"disabled": false
}

[<CLIMutable>]
type Person = {
PartitionKey: string
RowKey: string
Name: string
}
let Run(input: string, tableBinding: ICollector<Person>, log: ILogger) =

for i = 1 to 10 do
log.LogInformation(sprintf "Adding Person entity %d" i)
tableBinding.Add(
{ PartitionKey = "Test"
RowKey = i.ToString()
Name = "Name" + i.ToString() })

{
"bindings": [
{
"name": "input",
"direction": "in"
},
{
"type": "table",
"direction": "out"
}
],
"disabled": false
}

context.bindings.tableBinding = [];
for (var i = 1; i < 10; i++) {

context.bindings.tableBinding.push({
PartitionKey: "Test",
RowKey: i.toString(),
Name: "Name " + i
});
}
context.done();
};
Saída - atributos
Em bibliotecas de classes do C#, use o TableAttribute.
O construtor do atributo usa o nome da tabela. Ele pode ser usado em um out parâmetro ou no valor de
retorno da função, conforme mostrado no exemplo a seguir:
[return: Table("MyTable")]
public static MyPoco TableOutput(
[HttpTrigger] dynamic input,
ILogger log)
{
...
}
[return: Table("MyTable", Connection = "StorageConnectionAppSetting")]
public static MyPoco TableOutput(
[HttpTrigger] dynamic input,
ILogger log)
{
...
}

Você pode usar o StorageAccount atributo para especificar a conta de armazenamento no nível de classe, método
ou parâmetro. Para obter mais informações, consulte Entrada - atributos.
e no Table atributo.
type n/d Deve ser definido como table . Esse

portal do Azure.
direction n/d Deve ser definido como out . Esse

portal do Azure.
name n/d O nome da variável usada no código da

função que representa a tabela ou
entidade. Definido como $return
para referenciar o valor de retorno da
função.
tableName TableName O nome da tabela.
partitionKey PartitionKey Chave de partição da entidade de

tabela para gravar. Consulte a seção de
uso para obter orientação sobre como
usar essa propriedade.
rowKey RowKey A chave de linha da entidade de tabela

para gravar. Consulte a seção de uso
para obter orientação sobre como usar
essa propriedade.

conexão de Armazenamento para usar
para essa associação. Se o nome de
configuração do aplicativo começar
caracteres de conexão de
Saída - uso
A associação de entrada de Armazenamento da Tabela dá suporte aos seguintes cenários:
Gravar uma linha em qualquer idioma
Em C# e o script C#, acesse a entidade de tabela de saída usando um parâmetro de método como
out T paramName ou valor de retorno da função. No script do C#, paramName é o valor especificado na
propriedade name de function.json. T pode ser qualquer tipo serializável, se a chave de partição e a chave
de linha forem fornecidos pelo arquivo function.json ou o Table atributo. Caso contrário, T deve ser um
tipo que inclua PartitionKey e RowKey propriedades. Nesse cenário, T normalmente implementa
ITableEntity ou deriva de TableEntity , mas ele não precisa.
Gravar uma ou mais linhas em C# ou no script do C#

Em C# e o script C#, acesse a entidade de tabela de saída usando um parâmetro de método como
ICollector<T> paramName ou IAsyncCollector<T> paramName . No script do C#, paramName é o valor
especificado na propriedade name de function.json. T especifica o esquema das entidades que você
deseja adicionar. Geralmente, T deriva de TableEntity ou implementa ITableEntity , mas isso não é
obrigatório. A chave de partição e a linha valores de chave em function.json ou o Table construtor de
atributo não são usados neste cenário.
Uma alternativa é usar um CloudTable parâmetro do método para gravar a tabela usando o SDK de
Armazenamento do Azure. Se você tentar associar CloudTable e receber uma mensagem de erro,
certifique-se de ter uma referência para a versão correta do SDK do Armazenamento. Para um exemplo de
código que associa a CloudTable , consulte os exemplos de associação de entrada para C# ou script de C#
anteriormente neste artigo.
Gravar uma ou mais linhas em JavaScript
Em funções do JavaScript, acesse a tabela de saída usando context.bindings.<BINDING_NAME> .

Tabela Códigos de erro de tabelas
Próximas etapas
Gatilho de temporizador para o Azure Functions
Este artigo explica como trabalhar com gatilhos de temporizador no Azure Functions. Um gatilho de
temporizador permite executar uma função em uma agenda.
O gatilho de timer é fornecido no Microsoft.Azure.WebJobs.Extensions pacote NuGet, versão 2. x. O código-
fonte do pacote está no repositório GitHub azure-webjobs-sdk-extensions.
O gatilho de timer é fornecido no Microsoft.Azure.WebJobs.Extensions pacote NuGet, versão 2. x. O código-
fonte do pacote está no repositório GitHub azure-webjobs-sdk-extensions.
Exemplo
C#
Script do C# (.csx)
F#
Java
JavaScript
Python
Exemplo de C#
O exemplo a seguir mostra uma C# função que é executada cada vez que os minutos têm um valor divisível
por cinco (por exemplo, se a função começar em 18:57:00, o próximo desempenho será em 19:00:00). O objeto
TimerInfo é passado para a função.
[FunctionName("TimerTriggerCSharp")]
public static void Run([TimerTrigger("0 */5 * * * *")]TimerInfo myTimer, ILogger log)
{
{
log.LogInformation("Timer is running late!");
}
}
O exemplo a seguir mostra uma associação de gatilho de temporizador em um arquivo function.json e uma
função C# script que usa a associação. A função grava um log que indica se esta chamada de função deve-se a
uma ocorrência de agendamento ausente. O objeto TimerInfo é passado para a função.
{
"schedule": "0 */5 * * * *",
"name": "myTimer",
"direction": "in"
}

{
{
}
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}" );
}
Exemplo de F#
função de script F# que usa a associação. A função grava um log que indica se esta chamada de função deve-se
a uma ocorrência de agendamento ausente. O objeto TimerInfo é passado para a função.
{
"schedule": "0 */5 * * * *",
"name": "myTimer",
"direction": "in"
}
Aqui está o código de script F#:
let Run(myTimer: TimerInfo, log: ILogger ) =

if (myTimer.IsPastDue) then
log.LogInformation("F# function is running late.")
let now = DateTime.Now.ToLongTimeString()
log.LogInformation(sprintf "F# function executed at %s!" now)
Exemplo do Java
A função de exemplo a seguir é disparada e executada a cada cinco minutos. A anotação @TimerTrigger na
função define o agendamento usando o mesmo formato de cadeia de caracteres que as expressões CRON.
@FunctionName("keepAlive")
public void keepAlive(
@TimerTrigger(name = "keepAliveTrigger", schedule = "0 */5 * * * *") String timerInfo,
ExecutionContext context
) {
// timeInfo is a JSON string, you can deserialize it to an object using your favorite JSON library
context.getLogger().info("Timer is triggered: " + timerInfo);
}
função JavaScript que usa a associação. A função grava um log que indica se esta chamada de função deve-se
a uma ocorrência de agendamento ausente. Um objeto de timer é passado para a função.
{
"schedule": "0 */5 * * * *",
"name": "myTimer",
"direction": "in"
}

{
context.log('Node is running late!');
}
context.log('Node timer trigger function ran!', timeStamp);
context.done();
};
Exemplo de Python
O exemplo a seguir usa uma associação de gatilho de temporizador cuja configuração é descrita no arquivo
Function. JSON . A função Python real que usa a associação é descrita no arquivo init. py . O objeto passado
para a função é do tipo objeto Azure. Functions. TimerRequest. A lógica de função grava nos logs indicando se
a invocação atual é devido a uma ocorrência de agendamento ausente.
{
"name": "mytimer",
"direction": "in",
"schedule": "0 */5 * * * *"
}

import datetime
import logging
def main(mytimer: func.TimerRequest) -> None:

utc_timestamp = datetime.datetime.utcnow().replace(
tzinfo=datetime.timezone.utc).isoformat()
if mytimer.past_due:
logging.info('The timer is past due!')
logging.info('Python timer trigger function ran at %s', utc_timestamp)
Atributos
Em bibliotecas de classes do C#, utilize o atributo TimerTriggerAttribute.
O construtor do atributo usa a expressão CRON ou um TimeSpan . Você poderá usar TimeSpan apenas se o
aplicativo de função estiver em execução em um Plano do Serviço de Aplicativo. O exemplo a seguir mostra
uma expressão CRON:
[FunctionName("TimerTriggerCSharp")]
public static void Run([TimerTrigger("0 */5 * * * *")]TimerInfo myTimer, ILogger log)
{
{
}
}
Configuração
function.json e no atributo TimerTrigger .
type n/d Deve ser definido como "timerTrigger".

Essa propriedade é definida
direction n/d Deve ser definido como "in". Essa


objeto de temporizador no código de
função.
schedule ScheduleExpression Um expressão CRON ou um valor

TimeSpan. É possível usar um
TimeSpan somente para um
aplicativo de função executado em um
Plano do Serviço de Aplicativo. Você
pode colocar a expressão de
agendamento em uma configuração
de aplicativo e definir essa propriedade
como o nome da configuração do
aplicativo envolvido em sinais % ,
como neste exemplo:
"%ScheduleAppSetting%".
runOnStartup runOnStartup Se true , a função será invocada

quando o tempo de execução for
iniciado. Por exemplo, o tempo de
execução inicia quando o aplicativo de
função desperta depois de ficar ocioso
devido à inatividade. Quando o
aplicativo de função reinicia devido a
alterações de função e quando o
aplicativo de função é escalado
horizontalmente. Portanto,
runOnStartup deve raramente ou
nunca ser definido como true ,
especialmente em produção.
useMonitor UseMonitor Definido como true ou false para

indicar se o agendamento deve ser
monitorado. Agendar o
monitoramento persiste as ocorrências
de agendamento para ajudar a
garantir que o agendamento seja
mantido corretamente mesmo quando
instâncias do aplicativo de função
forem reiniciadas. Se não for definido
explicitamente, o padrão será true
para agendas que têm um intervalo
de recorrência maior ou igual a 1
minuto. Para agendamentos que
disparam mais de uma vez por
minuto, o padrão é false .
Cau t i on
Recomendamos a configuração runOnStartup para true em produção. Usar essa configuração faz com que
código seja executado em momentos altamente imprevisíveis. Em determinadas configurações de produção,
essas execuções extras podem resultar em custos significativamente mais altos para aplicativos hospedados
em planos de consumo. Por exemplo, com runOnStartup habilitado, o gatilho é invocado sempre que seu
aplicativo de funções é dimensionado. Verifique se você compreender totalmente o comportamento de
produção de suas funções antes de habilitar runOnStartup em produção.
Uso
Quando uma função de gatilho de temporizador é invocada, um objeto de temporizador é passado para a
função. O JSON a seguir é uma representação de exemplo do objeto timer.
{
"Schedule":{
},
"ScheduleStatus": {
"Last":"2016-10-04T10:15:00+00:00",
"LastUpdated":"2016-10-04T10:16:00+00:00",
"Next":"2016-10-04T10:20:00+00:00"
},
"IsPastDue":false
}
A propriedade IsPastDue é true quando a invocação da função atual é posterior ao agendado. Por exemplo,
uma reinicialização do aplicativo de função pode causar a perda de uma invocação.
Expressões NCRONTAB
Azure Functions usa a biblioteca NCronTab para interpretar as expressões NCronTab. Um NCRONTAB
exppression é semelhante a uma expressão CRON, exceto pelo fato de que ele inclui um sexto campo adicional
no início a ser usado para a precisão de tempo em segundos:
{second} {minute} {hour} {day} {month} {day-of-week}
Cada campo pode ter um dos seguintes tipos de valores:
TYPE EXEMPLO QUANDO DISPARADO
Um valor específico "0 5 * * * *" em hh:05:00, em que hh é cada hora

(uma vez por hora)
Todos os valores ( * ) "0 * 5 * * *" em 5:mm: 00 diariamente, em que

mm é cada minuto da hora (60 vezes
por dia)
Um intervalo ( - operador) "5-7 * * * * *" em hh:mm:05, hh:mm:06 e hh:mm:07,

em que hh é cada minuto de cada
hora (3 vezes por minuto)
Um conjunto de valores ( , "5,8,10 * * * * *" em hh:mm:05, hh:mm:08 e hh:mm:10,

operador) em que hh é cada minuto de cada
hora (3 vezes por minuto)
Um valor de intervalo ( / operador) "0 */5 * * * *" em hh:05:00, hh:10:00, hh:15:00 e

assim por diante por meio de
hh:55:00, em que hh é cada hora (12
vezes por hora)
Para especificar meses ou dias, você pode usar valores numéricos, nomes ou abreviações de nomes:
Por dias, os valores numéricos são 0 a 6, onde 0 começa com o domingo.
Nomes estão em inglês. Por exemplo, Monday , January .
Os nomes não diferenciam maiúsculas de minúsculas.
Os nomes podem ser abreviados. Três letras é o comprimento de abreviação recomendada. Por exemplo,
Mon , Jan .
Exemplos de NCRONTAB
Aqui estão alguns exemplos de expressões NCRONTAB que você pode usar para o gatilho de temporizador no
Azure Functions.
EXEMPLO QUANDO DISPARADO
"0 */5 * * * *" uma vez a cada cinco minutos
"0 0 * * * *" uma vez a cada hora
"0 0 */2 * * *" uma vez a cada duas horas
"0 0 9-17 * * *" uma vez a cada hora entre 9h e 17h
"0 30 9 * * *" às 9h30 todos os dias
"0 30 9 * * 1-5" às 9h30 todo dia útil
"0 30 9 * Jan Mon" em 9H30 toda segunda-feira em janeiro
NCRONTAB fuso horário

Os números em uma expressão CRON se referem a uma hora e uma data, não a um período de tempo. Por
exemplo, um 5 no campo hour se refere a 5h, não cada cinco horas.
O fuso horário padrão usado com as expressões CRON é a Hora Universal Coordenada (UTC ). Para que a
expressão CRON se baseie em outro fuso horário, crie uma configuração de aplicativo para o aplicativo de
funções denominada WEBSITE_TIME_ZONE . Defina o valor para o nome do fuso horário desejado, conforme
mostrado no Índice de fuso horário da Microsoft.
Por exemplo, a Hora padrão da costa leste dos EUA é UTC -05:00. Para que o gatilho do temporizador seja
acionado às 10:00 AM EST todos os dias, use a seguinte expressão NCRONTAB que conta para o fuso horário
UTC:
"0 0 15 * * *"
Ou criar uma configuração de aplicativo para seu aplicativo de funções denominada WEBSITE_TIME_ZONE e
definir o valor como Horário padrão da costa leste dos EUA. Em seguida, usa a seguinte expressão
NCRONTAB:
"0 0 10 * * *"
Quando você usa WEBSITE_TIME_ZONE , o horário é ajustado para as alterações de hora no fuso horário
específico, como o horário de verão.
TimeSpan
É possível usar um TimeSpan somente para um aplicativo de função executado em um Plano do Serviço de
Aplicativo.
Ao contrário de uma expressão CRON, um valor TimeSpan especifica o intervalo de tempo entre cada
invocação de função. Quando uma função é concluída após a execução por mais tempo do que o intervalo
especificado, o temporizador imediatamente chama a função novamente.
Expresso como uma cadeia de caracteres, o formato TimeSpan é hh:mm:ss quando hh é menor que 24.
Quando os dois primeiros dígitos são 24 ou superior, o formato é dd:hh:mm . Estes são alguns exemplos:
EXEMPLO QUANDO DISPARADO
"01:00:00" a cada hora
"00:01:00" a cada minuto
"24:00:00" a cada 24 horas
"1,00:00:00" Todos os dias
Escalabilidade
Se um aplicativo de funções se expandir para várias instâncias, apenas uma única instância de uma função
disparada por temporizador será executada em todas as instâncias.
Armazenamento de compartilhamento de aplicativos de função

Se você estiver compartilhando contas de armazenamento entre aplicativos de funções que não são
implantados no serviço de aplicativo, talvez seja necessário atribuir explicitamente a ID do host a cada
aplicativo.
VERSÃO DO FUNCTIONS CONFIGURAÇÃO
2. x variável de ambiente AzureFunctionsWebHost__hostid
1.x id em host. JSON
Você pode omitir o valor de identificação ou definir manualmente cada aplicativo de função que identifica a
configuração para um valor diferente.
O gatilho de temporizador usa um bloqueio de armazenamento para garantir que haja apenas uma instância
de temporizador quando um aplicativo de funções é dimensionado para várias instâncias. Se dois aplicativos
de funções compartilharem a mesma configuração de identificação e cada um usar um gatilho de
temporizador, apenas um temporizador será executado.
Tentar comportamento novamente

Ao contrário do gatilho de fila, o gatilho de temporizador não tenta novamente após a falha de uma função.
Quando uma função falha, ele não é chamado novamente até a próxima vez na agenda.
Solução de problemas
Para obter informações sobre o que fazer quando o gatilho de timer não funcionar conforme o esperado,
confira Investigar e relatar problemas com funções disparadas de timer não acionadas.
Próximas etapas
Vá para um guia de início rápido que use um gatilho de temporizador
Associação de Twilio para o Azure Functions
Este artigo explica como enviar mensagens de texto usando-se as associações de Twilio no Azure Functions. O
Azure Functions oferece suporte a uma associação de saída para o Twilio.
As ligações do Twilio são fornecidas no pacote Microsoft.Azure.WebJobs.Extensions.Twilio NuGet, versão 1.x. O
código-fonte do pacote está no repositório GitHub azure-webjobs-sdk.

As ligações do Twilio são fornecidas no pacote Microsoft.Azure.WebJobs.Extensions.Twilio NuGet, versão 3.x. O
código-fonte do pacote está no repositório GitHub azure-webjobs-sdk.


Python
Exemplo - Functions 1.x
C#
Script do C# (.csx)
JavaScript
Exemplo de C#
A exemplo a seguir mostra uma função C# que envia uma mensagem de texto quando é acionada por uma
mensagem de fila.
[FunctionName("QueueTwilio")]
[return: TwilioSms(AccountSidSetting = "TwilioAccountSid", AuthTokenSetting = "TwilioAuthToken", From =
"+1425XXXXXXX" )]
public static SMSMessage Run(
[QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")] JObject order,
TraceWriter log)
{
log.Info($"C# Queue trigger function processed: {order}");
var message = new SMSMessage()

{
Body = $"Hello {order["name"]}, thanks for your order!",
To = order["mobileNumber"].ToString()
};
return message;
}
Este exemplo usa o atributo TwilioSms com o valor de retorno do método. Uma alternativa é usar o atributo com
um parâmetro out SMSMessage ou um parâmetro ICollector<SMSMessage> ou IAsyncCollector<SMSMessage> .
O exemplo a seguir mostra uma associação de saída de Twilio em um arquivo function.json e uma função script
C# que usa a associação. A função usa um parâmetro out para enviar uma mensagem de texto.
{
"type": "twilioSms",
"name": "message",
"accountSid": "TwilioAccountSid",
"authToken": "TwilioAuthToken",
"to": "+1704XXXXXXX",
"from": "+1425XXXXXXX",
"direction": "out",
"body": "Azure Functions Testing"
}

#r "Twilio.Api"
using System;
using Twilio;
public static void Run(string myQueueItem, out SMSMessage message, TraceWriter log)
{
// 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.";
// Even if you want to use a hard coded message and number in the binding, you must at least
// initialize the SMSMessage variable.
message = new SMSMessage();
// 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 to the mobile number provided for
// order status updates.
message.Body = msg;
message.To = order.mobileNumber;
}
Você não pode usar os parâmetros em código assíncrono. Aqui está um exemplo de código de script C#
assíncrono:
#r "Twilio.Api"
using System;
using Twilio;
public static async Task Run(string myQueueItem, IAsyncCollector<SMSMessage> message, ILogger log)
{
// initialize the SMSMessage variable.
SMSMessage smsText = new SMSMessage();
smsText.Body = msg;
smsText.To = order.mobileNumber;
await message.AddAsync(smsText);
}
O exemplo a seguir mostra uma associação de saída do Twilio em um arquivo function.json e código script C#
{
"name": "message",
"accountSid": "TwilioAccountSid",
"authToken": "TwilioAuthToken",
"to": "+1704XXXXXXX",
"direction": "out",
}

var msg = "Hello " + myQueueItem.name + ", thank you for your order.";
// initialize the message binding.
context.bindings.message = {};
body : msg,
to : myQueueItem.mobileNumber
};
context.done();
};
Exemplo – Functions 2.x

2.x C#
Script 2.x C# (.csx)
2.x JavaScript
Exemplo de 2.x C#
A exemplo a seguir mostra uma função C# que envia uma mensagem de texto quando é acionada por uma
mensagem de fila.
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;
namespace TwilioQueueOutput
{
public static class QueueTwilio
{
[return: TwilioSms(AccountSidSetting = "TwilioAccountSid", AuthTokenSetting = "TwilioAuthToken", From
= "+1425XXXXXXX")]
public static CreateMessageOptions Run(
[QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")] JObject order,
ILogger log)
{
log.LogInformation($"C# Queue trigger function processed: {order}");
var message = new CreateMessageOptions(new PhoneNumber(order["mobileNumber"].ToString()))

{
Body = $"Hello {order["name"]}, thanks for your order!"
};
return message;
}
}
}
Este exemplo usa o atributo TwilioSms com o valor de retorno do método. Uma alternativa é usar o atributo com
um parâmetro out CreateMessageOptions ou um parâmetro ICollector<CreateMessageOptions> ou
IAsyncCollector<CreateMessageOptions> .
Exemplo de script 2.x C#

O exemplo a seguir mostra uma associação de saída de Twilio em um arquivo function.json e uma função script
C# que usa a associação. A função usa um parâmetro out para enviar uma mensagem de texto.
{
"name": "message",
"accountSidSetting": "TwilioAccountSid",
"authTokenSetting": "TwilioAuthToken",
"direction": "out",
}

#r "Twilio"
#r "Microsoft.Azure.WebJobs.Extensions.Twilio"
using System;
using Microsoft.Azure.WebJobs.Extensions.Twilio;
using Twilio.Types;
public static void Run(string myQueueItem, out CreateMessageOptions message, ILogger log)
{
// You must initialize the CreateMessageOptions variable with the "To" phone number.
message = new CreateMessageOptions(new PhoneNumber("+1704XXXXXXX"));
// the order information to personalize a text message.
message.Body = msg;
}
Você não pode usar os parâmetros em código assíncrono. Aqui está um exemplo de código de script C#
assíncrono:
#r "Twilio"
#r "Microsoft.Azure.WebJobs.Extensions.Twilio"
using System;
using Microsoft.Azure.WebJobs.Extensions.Twilio;
using Twilio.Types;
public static async Task Run(string myQueueItem, IAsyncCollector<CreateMessageOptions> message, ILogger log)
{
// You must initialize the CreateMessageOptions variable with the "To" phone number.
CreateMessageOptions smsText = new CreateMessageOptions(new PhoneNumber("+1704XXXXXXX"));
// the order information to personalize a text message.
smsText.Body = msg;
await message.AddAsync(smsText);
}
Exemplo de JavaScript 2.x C#

O exemplo a seguir mostra uma associação de saída do Twilio em um arquivo function.json e código script C#
{
"name": "message",
"accountSidSetting": "TwilioAccountSid",
"authTokenSetting": "TwilioAuthToken",
"direction": "out",
}

var msg = "Hello " + myQueueItem.name + ", thank you for your order.";
// Even if you want to use a hard coded message in the binding, you must at least
// initialize the message binding.
context.bindings.message = {};
// A dynamic message can be set instead of the body in the output binding. The "To" number
// must be specified in code.
body : msg,
to : myQueueItem.mobileNumber
};
context.done();
};
Atributos
Em bibliotecas de classes do C#, use o atributo TwilioSms.
Para obter informações sobre as propriedades de atributo que você pode configurar, consulte Configuração. Aqui
está um exemplo de atributo TwilioSms em uma assinatura de método:
[return: TwilioSms(AccountSidSetting = "TwilioAccountSid", AuthTokenSetting = "TwilioAuthToken", From =
"+1425XXXXXXX")]
public static CreateMessageOptions Run(
[QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")] JObject order, ILogger log)
{
...
}
Para ver um exemplo completo, consulte Exemplo de C#.
Configuração
e no atributo TwilioSms .
PROPRIEDADE PROPRIEDADE
FUNCTION.JSON V1 FUNCTION.JSON V2 PROPRIEDADE DE ATRIBUTO DESCRIÇÃO
type type deve ser definido como

twilioSms .
direction direction deve ser definido como

out .
name name Nome da variável usada no

código de função para a
mensagem de texto SMS do
Twilio.
accountSid accountSidSetting AccountSidSetting Esse valor deve ser definido

como o nome de uma
Configuração de aplicativo
que contém a SID da sua
conta do Twilio, por
exemplo, TwilioAccountSid.
Se não configurado, o nome
da configuração do
aplicativo padrão será
"AzureWebJobsTwilioAccoun
tSid".
authToken authTokenSetting AuthTokenSetting Esse valor deve ser definido

como o nome de uma
Configuração de aplicativo
que contém seu token de
autenticação do Twilio por
exemplo,
TwilioAccountAuthToken. Se
não configurado, o nome da
configuração do aplicativo
padrão será
"AzureWebJobsTwilioAuthTo
ken".
to N/D – especificar no código To Esse valor é definido como o

número de telefone para o
qual será enviada a
mensagem de texto SMS.
from from From Esse valor é definido como o

número de telefone com o
qual será enviada a
mensagem de texto SMS.
body body Corpo Esse valor pode ser usado

para fixar a mensagem de
texto SMS no código se
você não precisa defini-la
dinamicamente no código
de sua função.
Próximas etapas
Referência host.json para o Azure
Functions 2.x
O arquivo de metadados host.json contém opções de configuração global que afetam todas
as funções de um aplicativo de funções. Este artigo lista as configurações disponíveis para o
tempo de execução v2.
NOTE
Este artigo serve para o Azure Functions 2.x. Para obter uma referência de host.json no Functions
1.x, confira Referência de host.json para o Azure Functions 1.x.
Outras opções de configuração de aplicativo de funções são gerenciadas nas configurações

de aplicativo.
Algumas configurações host.json são usadas apenas quando executadas localmente no
Arquivo host.json de exemplo

Os seguintes arquivos host.json de exemplo têm todas as opções possíveis especificadas.
{
"version": "2.0",
"aggregator": {
"batchSize": 1000,
},
"extensions": {
"cosmosDb": {},
"durableTask": {},
"eventHubs": {},
"http": {},
"queues": {},
"sendGrid": {},
"serviceBus": {}
},
"functions": [ "QueueProcessor", "GitHubWebHook" ],
"functionTimeout": "00:05:00",
"healthMonitor": {
"enabled": true,
"healthCheckInterval": "00:00:10",
"healthCheckWindow": "00:02:00",
"healthCheckThreshold": 6,
"counterThreshold": 0.80
},
"logging": {
"fileLoggingMode": "debugOnly",
"logLevel": {
"Function.MyFunction": "Information",
"default": "None"
},
"isEnabled": true,
}
}
},
"enabled": true
},
"singleton": {
"lockPeriod": "00:00:15",
"listenerLockPeriod": "00:01:00",
"listenerLockRecoveryPollingInterval": "00:01:00",
"lockAcquisitionTimeout": "00:01:00",
"lockAcquisitionPollingInterval": "00:00:03"
},
"watchDirectories": [ "Shared", "Test" ]
}
As seções seguintes deste artigo explicam cada propriedade de nível superior. Todas são
opcionais, a menos que seja indicado o contrário.
agregador
Especifica quantas invocações de função são agregadas ao calcular métricas para o
{
"aggregator": {
"batchSize": 1000,
}
}
batchSize 1000 Número máximo de solicitações

para agregação.
flushTimeout 00:00:30 Período de tempo máximo para

agregação.
As invocações de função são agregadas quando o primeiro dos dois limites é atingido.
applicationInsights
Essa configuração é a filha de Registro em log.
Controla o recurso de amostragem no Application Insights.
{
"isEnabled": true,
}
}
}
NOTE
A amostragem de log pode fazer com que algumas execuções não apareçam na folha do Monitor
do Application Insights.
isEnabled verdadeiro Habilita ou desabilita a

amostragem.
maxTelemetryItemsPerSecond 20 O limite em que a amostragem

começa.
EnableLiveMetrics verdadeiro Habilita a coleta de métricas em

tempo real.
EnableDependencyTracking verdadeiro Habilita o rastreamento de

dependência.
EnablePerformanceCountersCol verdadeiro Habilita a coleta de contadores

lection de desempenho kudu.
cosmosDb
A definição de configuração pode ser encontrada em Associações e gatilhos do Cosmos DB.
durableTask
A definição de configuração pode ser encontrada em Associações para Durable Functions.
eventHub
As definições de configuração podem ser encontradas em Associações e gatilhos do Hub de
Eventos.
extensions
Propriedade que retorna um objeto que contém todas as configurações específicas de
associação, como http e eventHub.
funções
Uma lista de funções que o host de trabalho executa. Uma matriz vazia significa que todas as
funções serão executadas. Para uso somente quando em execução localmente. Em
aplicativos de funções no Azure, você deve seguir as etapas em Como desabilitar funções no
Azure Functions para desabilitar funções específicas em vez de usar essa configuração.
{
"functions": [ "QueueProcessor", "GitHubWebHook" ]
}
functionTimeout
Indica a duração do tempo limite para todas as funções. Ele segue o formato de cadeia de
caracteres TimeSpan. Em um plano de Consumo sem servidor, o intervalo válido é de 1
segundo a 10 minutos e o valor padrão é 5 minutos.
Em um plano dedicado (serviço de aplicativo), não há nenhum limite geral e o valor padrão é
30 minutos. Um valor de -1 indica execução não associada.
{
"functionTimeout": "00:05:00"
}
healthMonitor
Definições de configuração para monitor de integridade de Host.
{
"healthMonitor": {
"enabled": true,
}
}
Habilitado verdadeiro Especifica se o recurso está

habilitado.
healthCheckInterval 10 segundos O intervalo de tempo entre as

verificações de integridade em
segundo plano.
healthCheckWindow 2 minutos Uma janela de tempo

deslizante usada em conjunto
com a configuração
healthCheckThreshold .
healthCheckThreshold 6 Número máximo de vezes que

a verificação de integridade
pode falhar antes de uma
reciclagem de host ser iniciada.
counterThreshold 0.80 O limite no qual um contador

de desempenho será
considerado não íntegro.
http
As definições de configuração podem ser encontradas em Associações e gatilhos HTTP.
registro em log
Controla os comportamentos de registro em log do aplicativo de funções, incluindo o
"logging": {
"fileLoggingMode": "debugOnly"
"logLevel": {
"Function.MyFunction": "Information",
"default": "None"
},
"console": {
...
},
...
}
}
fileLoggingMode debugOnly Define qual nível de log de

arquivos está habilitado. As
opções são: never , always e
debugOnly .
logLevel n/d Objeto que define a filtragem

da categoria de log para
funções no aplicativo. A versão
2.x segue o layout do ASP.NET
Core para filtragem de
categoria de log. Isso permite
filtrar o registro para funções
específicas. Para obter mais
informações, consulte Filtragem
de logs na documentação do
ASP.NET Core.
console n/d A configuração de log do

console.
applicationInsights n/d A configuração

applicationInsights.
console
Essa configuração é a filha de Registro em log. Ela controla o log do console quando não
está no modo de depuração.
{
"logging": {
...
"console": {
"isEnabled": "false"
},
...
}
}
isEnabled false Habilita ou desabilita o log de

console.
managedDependency
A dependência gerenciada é um recurso que atualmente só tem suporte com funções
baseadas no PowerShell. Ele permite que as dependências sejam gerenciadas
automaticamente pelo serviço. Quando a propriedade enabled é definida como true , o
arquivo de requirements.psd1 é processado. As dependências são atualizadas quando
qualquer versão secundária é lançada. Para obter mais informações, consulte dependência
gerenciada no artigo do PowerShell.
{
"enabled": true
}
}
filas
As definições de configuração podem ser encontradas em Associações e gatilhos da fila de
armazenamento.
sendGrid
A definição de configuração pode ser encontrada em Associações e gatilhos do SendGrid.
serviceBus
A definição de configuração pode ser encontrada em Associações e gatilhos do Barramento
de Serviço.
singleton
Parâmetro de configuração para o comportamento de bloqueio de Singleton. Para obter
mais informações, consulte Problema com o GitHub referente ao suporte de singleton.
{
"singleton": {
}
}
lockPeriod 00:00:15 O período em que ocorrem os

bloqueios de nível de função.
Os bloqueios têm renovação
automática.
listenerLockPeriod 00:01:00 O período em que ocorrem os

bloqueios de ouvinte.
listenerLockRecoveryPollingInte 00:01:00 O intervalo de tempo usado

rval para a recuperação do bloqueio
de ouvinte caso não tenha sido
possível adquirir um bloqueio
de ouvinte durante a
inicialização.
lockAcquisitionTimeout 00:01:00 A quantidade máxima de

tempo em que o tempo de
execução tenta adquirir um
bloqueio.
lockAcquisitionPollingInterval n/d O intervalo entre as tentativas

de aquisição de bloqueio.
version
A cadeia de caracteres de versão "version": "2.0" é necessária para um aplicativo de
funções que segmente o tempo de execução v2.
watchDirectories
Um conjunto de diretórios de código compartilhado que devem ser monitorados quanto a
alterações. Garante que, quando o código nesses diretórios é alterado, as alterações sejam
coletadas pelas funções.
{
"watchDirectories": [ "Shared" ]
}
Próximas etapas
Saiba como atualizar o arquivo host.json
Consulte as configurações globais em variáveis de ambiente
Referência de host.json para as funções do Azure
1.x
O arquivo de metadados host.json contém opções de configuração global que afetam todas as funções de um
aplicativo de funções. Este artigo lista as configurações disponíveis para o tempo de execução v1. O esquema
JSON está em http://json.schemastore.org/host.
NOTE
Este artigo serve para o Azure Functions 1.x. Para obter uma referência de host.json em Funções 2.x, consulte a
referência host.json para as Funções do Azure 2.x.
Outras opções de configuração de aplicativo de funções são gerenciadas nas configurações de aplicativo.
Algumas configurações host.json são usadas apenas quando executadas localmente no arquivo
Arquivo host.json de exemplo

Os seguintes arquivos host.json de exemplo têm todas as opções possíveis especificadas.
{
"aggregator": {
"batchSize": 1000,
},
"sampling": {
"isEnabled": true,
}
},
"documentDB": {
"leaseOptions": {
"leasePrefix": "prefix"
}
},
"eventHub": {
"maxBatchSize": 64,
},
"functions": [ "QueueProcessor", "GitHubWebHook" ],
"functionTimeout": "00:05:00",
"healthMonitor": {
"enabled": true,
},
"http": {
"dynamicThrottlesEnabled": false
},
"id": "9f4ea53c5136457d883d685e57164f08",
"logger": {
"categoryFilter": {
"categoryLevels": {
"Host": "Error",
}
}
},
"queues": {
"maxPollingInterval": 2000,
"batchSize": 16,
},
"sendGrid": {
"from": "Contoso Group <admin@contoso.com>"
},
"serviceBus": {
"autoRenewTimeout": "00:05:00"
},
"singleton": {
},
"tracing": {
"consoleLevel": "verbose",
},
"watchDirectories": [ "Shared" ],
}
As seções seguintes deste artigo explicam cada propriedade de nível superior. Todas são opcionais, a menos
que seja indicado o contrário.
agregador
Especifica quantas invocações de função são agregadas ao calcular métricas para o Application Insights.
{
"aggregator": {
"batchSize": 1000,
}
}
batchSize 1000 Número máximo de solicitações para

agregação.
flushTimeout 00:00:30 Período de tempo máximo para

agregação.
As invocações de função são agregadas quando o primeiro dos dois limites é atingido.
applicationInsights
Controla o recurso de amostragem no Application Insights.
{
"sampling": {
"isEnabled": true,
}
}
}
isEnabled true Habilita ou desabilita a amostragem.
maxTelemetryItemsPerSecond 5 O limite em que a amostragem

começa.
DocumentDB
Definições de configuração para o gatilho Azure Cosmos DB e associações.
{
"documentDB": {
"leaseOptions": {
"leasePrefix": "prefix1"
}
}
}
GatewayMode Gateway O modo de conexão usado pela

Azure Cosmos DB. As opções são
Direct e Gateway
Protocolo Https O protocolo de conexão usado pela

Azure Cosmos DB. Leia aqui para obter
uma explicação de ambos os modos
leasePrefix n/d Prefixo de concessão a ser usado em

todas as funções em um aplicativo.
durableTask
Definições de configuração para Funções Duráveis.
Durable Functions 1. x
{
"durableTask": {
"hubName": "MyTaskHub",
"controlQueueBatchSize": 32,
"partitionCount": 4,
"controlQueueVisibilityTimeout": "00:05:00",
"workItemQueueVisibilityTimeout": "00:05:00",
"maxConcurrentActivityFunctions": 10,
"maxConcurrentOrchestratorFunctions": 10,
"maxQueuePollingInterval": "00:00:30",
"azureStorageConnectionStringName": "AzureWebJobsStorage",
"trackingStoreConnectionStringName": "TrackingStorage",
"trackingStoreNamePrefix": "DurableTask",
"traceInputsAndOutputs": false,
"logReplayEvents": false,
"eventGridTopicEndpoint": "https://topic_name.westus2-1.eventgrid.azure.net/api/events",
"eventGridKeySettingName": "EventGridKey",
"eventGridPublishRetryCount": 3,
"eventGridPublishRetryInterval": "00:00:30",
"eventGridPublishEventTypes": ["Started", "Completed", "Failed", "Terminated"]
}
}
Durable Functions 2. x
{
"durableTask": {
"hubName": "MyTaskHub",
"storageProvider": {
"controlQueueBatchSize": 32,
"partitionCount": 4,
"controlQueueVisibilityTimeout": "00:05:00",
"workItemQueueVisibilityTimeout": "00:05:00",
"maxQueuePollingInterval": "00:00:30",
"connectionStringName": "AzureWebJobsStorage",
"trackingStoreConnectionStringName": "TrackingStorage",
"trackingStoreNamePrefix": "DurableTask"
},
"tracing": {
"traceInputsAndOutputs": false,
"traceReplayEvents": false,
},
"notifications": {
"eventGrid": {
"topicEndpoint": "https://topic_name.westus2-1.eventgrid.azure.net/api/events",
"keySettingName": "EventGridKey",
"publishRetryCount": 3,
"publishRetryInterval": "00:00:30",
"publishEventTypes": [
"Started",
"Pending",
"Failed",
"Terminated"
]
}
},
"maxConcurrentActivityFunctions": 10,
"maxConcurrentOrchestratorFunctions": 10,
"extendedSessionsEnabled": false,
"extendedSessionIdleTimeoutInSeconds": 30
}
}
Nomes de hubs de tarefas devem começar com uma letra e devem ser compostos somente por letras e
números. Se não for especificado, o nome do hub de tarefas padrão de um aplicativo de funções será
DurableFunctionsHub. Para obter mais informações, consulte Hubs de tarefas.
hubName DurableFunctionsHub Nomes alternativos para hub de

tarefas podem ser usados para isolar
vários aplicativos de Funções Duráveis
uns dos outros, mesmo se eles
estiverem usando o mesmo back-end
de armazenamento.
controlQueueBatchSize 32 O número de mensagens para efetuar

pull da fila de controle por vez.
partitionCount 4 A contagem de partição para a fila de

controle. Pode ser um número inteiro
positivo entre 1 e 16.
controlQueueVisibilityTimeout 5 minutos O limite de tempo de visibilidade das

mensagens de remoção da fila de
controle.
workItemQueueVisibilityTimeout 5 minutos O limite de tempo de visibilidade das

mensagens de remoção da fila de item
de trabalho.
maxConcurrentActivityFunctions 10 vezes o número de processadores O número máximo de funções de

no computador atual atividade que podem ser processadas
simultaneamente em uma única
instância de host.
maxConcurrentOrchestratorFunctions 10 vezes o número de processadores O número máximo de funções do

no computador atual orquestrador que podem ser
processadas simultaneamente em
uma única instância do host.
maxQueuePollingInterval 30 segundos O intervalo de sondagem de fila de

item de trabalho e de controle
máximo no formato hh: mm: SS .
Valores mais altos podem resultar em
latências de processamento de
mensagens mais altas. Valores mais
baixos podem resultar em custos de
armazenamento maiores devido a
maiores transações de
armazenamento.
azureStorageConnectionStringName AzureWebJobsStorage O nome da configuração de aplicativo

que tem a cadeia de conexão do
Armazenamento do Azure usada para
gerenciar os recursos subjacentes do
trackingStoreConnectionStringName O nome de uma cadeia de conexão a

ser usada para as tabelas de histórico
e instâncias. Se não for especificado, a
conexão
azureStorageConnectionStringName
será usada.
trackingStoreNamePrefix O prefixo a ser usado para as tabelas

de histórico e instâncias quando
trackingStoreConnectionStringName
for especificado. Se não estiver
definido, o valor de prefixo padrão
será DurableTask . Se
trackingStoreConnectionStringName
não for especificado, as tabelas de
histórico e instâncias usarão o valor de
hubName como seu prefixo e
qualquer configuração para
trackingStoreNamePrefix será
ignorada.
traceInputsAndOutputs false Um valor que indica se as entradas e

saídas de chamadas de função sertão
rastreadas. O comportamento padrão
durante o rastreamento de eventos de
execução de função é incluir o número
de bytes nas entradas e saídas
serializadas para chamadas de função.
Esse comportamento fornece
informações mínimas sobre o que as
entradas e saídas parecem sem inflar
os logs ou expor inadvertidamente
informações confidenciais. A definição
dessa propriedade como true faz com
que o log de função padrão registre
todo o conteúdo de entradas e saídas
da função.
logReplayEvents false Um valor que indica se é necessário

gravar eventos de reprodução de
orquestração para o Application
Insights.
eventGridTopicEndpoint A URL de um ponto de extremidade

de tópico personalizado da Grade de
Eventos do Azure. Quando essa
propriedade é definida, os eventos de
notificação do ciclo de vida da
orquestração são publicados nesse
ponto de extremidade. Esta
propriedade dá suporte à resolução
de Configurações do Aplicativo.
eventGridKeySettingName O nome da configuração de aplicativo

que contém a chave usada para
autenticar com o tópico personalizado
da Grade de Eventos do Azure em
EventGridTopicEndpoint .
eventGridPublishRetryCount 0 O número de novas tentativas se a

publicação no Tópico de Grade de
Eventos falha.
eventGridPublishRetryInterval 5 minutos A Grade de Eventos publica o

intervalo de repetição no formato
hh:mm:ss.
eventGridPublishEventTypes Uma lista de tipos de eventos a serem

publicados na grade de eventos. Se
não for especificado, todos os tipos de
evento serão publicados. Os valores
permitidos incluem Started ,
Completed , Failed``Terminated .
Muitas dessas configurações são para otimizar o desempenho. Para obter mais informações, consulte
Desempenho e escala.
eventHub
Definições de configuração para gatilhos e associações de Hub de Eventos.
{
"eventHub": {
"maxBatchSize": 64,
}
}


subjacente.

funções
Uma lista de funções que o host de trabalho executa. Uma matriz vazia significa que todas as funções serão
executadas. Para uso somente quando em execução localmente. Em aplicativos de funções no Azure, você
deve seguir as etapas em Como desabilitar funções no Azure Functions para desabilitar funções específicas
em vez de usar essa configuração.
{
"functions": [ "QueueProcessor", "GitHubWebHook" ]
}
functionTimeout
Indica a duração do tempo limite para todas as funções. Em um plano de Consumo sem servidor, o intervalo
válido é de 1 segundo a 10 minutos e o valor padrão é 5 minutos. Em um plano do serviço de aplicativo, não
há nenhum limite geral e o padrão é NULL, o que indica que não há tempo limite.
{
"functionTimeout": "00:05:00"
}
healthMonitor
Definições de configuração para monitor de integridade de Host.
{
"healthMonitor": {
"enabled": true,
}
}
Habilitado verdadeiro Especifica se o recurso está habilitado.
healthCheckInterval 10 segundos O intervalo de tempo entre as

verificações de integridade em
segundo plano.
healthCheckWindow 2 minutos Uma janela de tempo deslizante usada

em conjunto com a configuração
healthCheckThreshold .
healthCheckThreshold 6 Número máximo de vezes que a

verificação de integridade pode falhar
antes de uma reciclagem de host ser
iniciada.
counterThreshold 0.80 O limite no qual um contador de

desempenho será considerado não
íntegro.
http
Parâmetros de configuração para gatilhos e associações http.
{
"http": {
"dynamicThrottlesEnabled": true
}
}

dynamicThrottlesEnabled false Quando habilitada, essa configuração

faz o pipeline de processamento de
solicitação verificar periodicamente os
contadores de desempenho do
sistema como
conexões/threads/processos/memória/
cpu/etc. e, se algum desses
contadores tiver excedido um alto
limite interno (80%), as solicitações
serão rejeitadas com a resposta 429
"Muito ocupado" até que os
contadores retornem aos níveis
normais.
maxConcurrentRequests Não associado ( -1 ) O número máximo de funções http

que serão executadas em paralelo.
Isso permite controlar a
simultaneidade, o que pode ajudar a
gerenciar a utilização de recursos. Por
exemplo, talvez você tenha uma
função http que use muitos recursos
do sistema (memória/cpu/soquetes),
de modo que ela causará problemas
quando a simultaneidade for muito
alta. Ou talvez você tenha uma função
que faça solicitações de saída a um
serviço de terceiro, e essas chamadas
precisem ser limitadas por taxa.
Nesses casos, aplicar uma limitação
aqui pode ajudar.
maxOutstandingRequests Não associado ( -1 ) O número máximo de solicitações

pendentes mantidas em um dado
momento. Esse limite inclui
solicitações que estão na fila, mas não
iniciaram a execução, bem como
qualquer execução em andamento.
Quaisquer solicitações recebidas acima
desse limite são rejeitadas com uma
resposta "Muito ocupado" 429. Isso
permite que os chamadores
empreguem estratégias de repetição
com base em tempo e também ajuda
você a controlar as latências máximas
de solicitação. Isso controla apenas o
enfileiramento que ocorre no caminho
de execução do host de script. Outras
filas, como a fila de solicitação
ASP.NET, ainda estarão vigor e não
serão afetadas por essa configuração.
routePrefix api O prefixo da rota que se aplica a todas

as rotas. Use uma cadeia de caracteres
vazia para remover o prefixo padrão.
ID
A ID exclusiva do host de trabalho. Pode ser uma GUID em letras minúsculas, sem traços. Obrigatório ao
executar localmente. Ao executar no Azure, é recomendável que você não defina um valor de ID. Uma ID é
gerada automaticamente no Azure quando id está omitido.
Se você compartilhar uma conta de Armazenamento em vários aplicativos de funções, verifique se cada
aplicativo de função tem um id diferente. É possível omitir a propriedade id ou definir manualmente cada
aplicativo de funções id para um valor diferente. O gatilho de temporizador usa um bloqueio de
armazenamento para garantir que haverá apenas uma instância de temporizador quando um aplicativo de
funções escalar horizontalmente para várias instâncias. Se dois aplicativos de funções compartilharem o
mesmo id e cada um usar um gatilho de temporizador, somente um temporizador irá executar.
{
"id": "9f4ea53c5136457d883d685e57164f08"
}
agente
Controles de filtragem de logs gravados por um objeto ILogger ou por context.log.
{
"logger": {
"categoryFilter": {
"categoryLevels": {
"Host": "Error",
}
}
}
}
categoryFilter n/d Especifica a filtragem por categoria
defaultLevel Informações Para as categorias não especificadas

na matriz categoryLevels , envie
logs nesse nível e acima para o
categoryLevels n/d Uma matriz de categorias que

especifica o nível mínimo de logs que
será enviado ao Application Insights
para cada categoria. A categoria
especificada aqui controla todas as
categorias que começam com o
mesmo valor, com precedência para os
valores maiores. No arquivo de
exemplo host.json anterior, todas as
categorias que começam com o log
"Host.Aggregator" no nível
Information . Todas as outras
categorias que começam com o log
"Host", como "Host.Executor", no nível
Error .
filas
Parâmetros de configuração para gatilhos e associações de Armazenamento.
{
"queues": {
"maxPollingInterval": 2000,
"batchSize": 16,
}
}
maxPollingInterval 60000 O intervalo máximo em milissegundos

entre as votações da fila.
visibilityTimeout 0 O intervalo de tempo entre as

repetições quando o processamento
de uma mensagem falha.
batchSize 16 O número de mensagens em fila que

o tempo de execução de Funções
recupera simultaneamente e processa
em paralelo. Quando o número que
está sendo processado chega até
newBatchThreshold , o tempo de
execução obtém outro lote e começa a
processar as mensagens. Portanto, o
número máximo de mensagens
simultâneas que estão sendo
processadas por função é batchSize
mais newBatchThreshold . Esse limite
se aplica separadamente a cada
Se quiser evitar uma execução paralela

para mensagens recebidas em uma
fila, é possível definir batchSize
como 1. No entanto, essa
configuração elimina a simultaneidade
desde que seu aplicativo de função
seja executado em uma única máquina
virtual (VM). Se o aplicativo de função
se expande para várias VMs, cada VM
pode executar uma instância de cada
O máximo batchSize é 32.
maxDequeueCount 5 O número de vezes para tentar

processar uma mensagem antes de
movê-la para a fila de mensagens
suspeitas.
newBatchThreshold batchSize/2 Sempre que o número de mensagens

processadas simultaneamente chega a
esse número, o tempo de execução
recupera outro lote.
SendGrid
Parâmetro de configuração para a Associação de saída SendGrind
{
"sendGrid": {
"from": "Contoso Group <admin@contoso.com>"
}
Da n/d Endereço de email do remetente em

todas as funções.
serviceBus
Parâmetro de configuração para gatilhos e associações do Barramento de Serviço.
{
"serviceBus": {
"autoRenewTimeout": "00:05:00"
}
}

processar uma única fila ou
mensagem de tópico de cada vez,
defina maxConcurrentCalls como 1.

subjacente.
autoRenewTimeout 00:05:00 A duração máxima na qual o bloqueio

automaticamente.
singleton
Parâmetro de configuração para o comportamento de bloqueio de Singleton. Para obter mais informações,
consulte Problema com o GitHub referente ao suporte de singleton.
{
"singleton": {
}
}
lockPeriod 00:00:15 O período em que ocorrem os

bloqueios de nível de função. Os
bloqueios têm renovação automática.
listenerLockPeriod 00:01:00 O período em que ocorrem os

bloqueios de ouvinte.
listenerLockRecoveryPollingInterval 00:01:00 O intervalo de tempo usado para a

recuperação do bloqueio de ouvinte
caso não tenha sido possível adquirir
um bloqueio de ouvinte durante a
inicialização.
lockAcquisitionTimeout 00:01:00 A quantidade máxima de tempo em

que o tempo de execução tenta
adquirir um bloqueio.
lockAcquisitionPollingInterval n/d O intervalo entre as tentativas de

aquisição de bloqueio.
rastreamento
Versão 1.x
Parâmetros de configuração para logs que você cria usando um objeto TraceWriter . Consulte Registro de
logs em C# e Registro de logs em Node.js.
{
"tracing": {
"consoleLevel": "verbose",
}
}
consoleLevel informações O nível de rastreamento para o

registro em log no console. As opções
são: off , error , warning , info
e verbose .
fileLoggingMode debugOnly O nível de rastreamento para registros

em log de arquivo. As opções são:
never , always e debugOnly .
watchDirectories
Um conjunto de diretórios de código compartilhado que devem ser monitorados quanto a alterações. Garante
que, quando o código nesses diretórios é alterado, as alterações sejam coletadas pelas funções.
{
"watchDirectories": [ "Shared" ]
}
Próximas etapas
Saiba como atualizar o arquivo host.json
Consulte as configurações globais em variáveis de ambiente
Perguntas frequentes sobre rede em Azure Functions
Este artigo lista as perguntas frequentes sobre a rede em Azure Functions. Para obter uma visão geral mais
abrangente, consulte funções de rededo functions.
Como fazer definir um IP estático em funções?

A implantação de uma função em um Ambiente do Serviço de Aplicativo é atualmente a única maneira de ter um
IP de entrada e saída estático para sua função. Para obter detalhes sobre como usar um Ambiente do Serviço de
Aplicativo, comece com o artigo criar e usar um balanceador de carga interno com um ambiente do serviço de
aplicativo.
Como fazer restringir o acesso à Internet à minha função?

Você pode restringir o acesso à Internet de duas maneiras:
Restrições de IP: Restrinja o tráfego de entrada para seu aplicativo de funções por intervalo de IP.
Em restrições de IP, você também pode configurar pontos de extremidade de serviço, que restringem
sua função para aceitar somente o tráfego de entrada de uma rede virtual específica.
Remoção de todos os gatilhos HTTP. Para alguns aplicativos, é suficiente simplesmente evitar gatilhos HTTP e
usar qualquer outra origem de evento para disparar sua função.
Tenha em mente que o editor de portal do Azure requer acesso direto à sua função em execução. Qualquer
alteração de código por meio da portal do Azure exigirá que o dispositivo que você está usando para procurar o
portal tenha seu IP na lista de permissões. Mas você ainda pode usar qualquer coisa na guia recursos da
plataforma com restrições de rede em vigor.
Como fazer restringir meu aplicativo de funções a uma rede virtual?

Você pode restringir o tráfego de entrada para um aplicativo de funções a uma rede virtual usando pontos de
extremidade de serviço. Essa configuração ainda permite que o aplicativo de funções faça chamadas de saída para
a Internet.
A única maneira de restringir totalmente uma função de forma que todo o tráfego flua por meio de uma rede
virtual é usar um Ambiente do Serviço de Aplicativo com balanceamento de carga internamente. Essa opção
implanta seu site em uma infraestrutura dedicada dentro de uma rede virtual e envia todos os gatilhos e tráfego
por meio da rede virtual.
Para obter detalhes sobre como usar um Ambiente do Serviço de Aplicativo, comece com o artigo criar e usar um
balanceador de carga interno com um ambiente do serviço de aplicativo.
Como posso acessar recursos em uma rede virtual por meio de um

aplicativo de funções?
Você pode acessar recursos em uma rede virtual de uma função em execução usando a integração de rede virtual.
Para obter mais informações, consulte integração de rede virtual.
Como fazer acessar recursos protegidos por pontos de extremidade de

serviço?
Usando a integração de rede virtual, você pode acessar recursos protegidos por ponto de extremidade de serviço
de uma função em execução. Para obter mais informações, consulte integração de rede virtual.
Como posso disparar uma função de um recurso em uma rede virtual?

Você pode permitir que gatilhos HTTP sejam chamados de uma rede virtual usando pontos de extremidade de
serviço.
Você também pode disparar uma função de um recurso em uma rede virtual implantando seu aplicativo de
funções em um Ambiente do Serviço de Aplicativo. Para obter detalhes sobre como usar um Ambiente do Serviço
de Aplicativo, consulte criar e usar um balanceador de carga interno com um ambiente do serviço de aplicativo.
O plano do serviço de aplicativo e Premium dá suporte a gatilhos HTTP de uma rede virtual, mas apenas um
ambiente do serviço de aplicativo dá suporte a todos os outros tipos de gatilho de função por meio de uma rede
virtual.
Como posso implantar meu aplicativo de funções em uma rede virtual?

A implantação em um Ambiente do Serviço de Aplicativo é a única maneira de criar um aplicativo de funções que
está totalmente dentro de uma rede virtual. Para obter detalhes sobre como usar um balanceador de carga interno
com uma Ambiente do Serviço de Aplicativo, comece com o artigo criar e usar um balanceador de carga interno
com um ambiente do serviço de aplicativo.
Para cenários em que você precisa apenas de acesso unidirecional a recursos de rede virtual ou um isolamento de
rede menos abrangente, consulte a visão geraldo Functions Networking.
Próximas etapas
Para saber mais sobre rede e funções:
Siga o tutorial sobre como começar com a integração de rede virtual
Saiba mais sobre as opções de rede no Azure Functions
Saiba mais sobre a integração de rede virtual com o serviço de aplicativo e as funções
Saiba mais sobre as redes virtuais no Azure
Habilitar mais recursos de rede e controle com ambientes de serviço de aplicativo
Suporte aos metadados de OpenAPI 2.0 no Azure
Functions (versão prévia)
O suporte aos metadados de OpenAPI 2.0 (conhecido antes como Swagger) no Azure Functions é um recurso de
visualização que você pode usar para gravar uma definição de OpenAPI 2.0 dentro de um aplicativo de funções.
Depois, você pode hospedar esse arquivo usando o aplicativo de funções.
IMPORTANT
A versão prévia do recurso do OpenAPI só está disponível no tempo de execução 1.x, no momento. Informações de como
criar um aplicativo de funções 1.x podem ser encontradas aqui.
Metadados de OpenAPI permitem que uma função que hospeda uma API REST seja consumida por vários outros
softwares. Entre esses softwares estão as ofertas da Microsoft como o PowerApps e o recurso de Aplicativos de
API do Serviço de Aplicativo do Azure, ferramentas de desenvolvedor de terceiros, como Postman e muitos outros
pacotes.
Essas são as informações de referência para desenvolvedores do Azure Functions. Se for novo no Azure Functions,
comece com os seguintes recursos:
TIP
É recomendável iniciar com o tutorial de introdução e, em seguida, retornar a este documento para saber mais sobre recursos
específicos.
Habilitar o suporte à definição de OpenAPI

Você pode definir todas as configurações de OpenAPI na página Definição de API nos Recursos da plataforma
de seu aplicativo de funções.
NOTE
O recurso de definição de API de função não tem suporte no tempo de execução beta no momento.
Para habilitar a geração de uma definição de OpenAPI hospedada e uma definição de início rápido, defina Origem
de definição da API para Função (Versão prévia) . URL Externa permite que sua função use uma definição de
OpenAPI que é hospedada em outro lugar.
Gerar um esqueleto de Swagger dos metadados de sua função

Um modelo pode ajudar você a começar a gravar sua primeira definição de OpenAPI. O recurso de modelo de
definição cria uma definição de OpenAPI esparsa usando todos os metadados no arquivo function.json para cada
uma de suas funções de gatilho HTTP. Você precisará preencher mais informações sobre sua API na especificação
de OpenAPI, como modelos de solicitação e resposta.
Para obter instruções passo a passo, confira este tutorial de introdução.
Modelos disponíveis
NOME DESCRIÇÃO
Definição gerada Uma definição de OpenAPI com a quantidade máxima de

informações que podem ser inferidas de metadados existentes
da função.
Metadados incluídos na definição gerada

A tabela a seguir representa as configurações do Portal do Azure e dados correspondentes no function.json
conforme ele são mapeados para o esqueleto de Swagger gerado.
SWAGGER.JSON INTERFACE DO USUÁRIO DO PORTAL FUNCTION.JSON
Host Configurações do aplicativo de Não presente

funções > Configurações do Serviço
de Aplicativo > Visão geral > URL
Caminhos Integrar > Métodos HTTP Associações: Rota

selecionados
Item de caminho Integrar > Modelos de rota Associações: Métodos
Segurança Chaves Não presente
operationID* Rota + Verbos permitidos Rota + verbos permitidos
*A ID da operação só é necessário para a integração com PowerApps e Flow.
NOTE
A extensão x-ms-summary fornece um nome de exibição nos Aplicativos Lógicos, PowerApps e Flow.
Para saber mais, confira Personalizar sua definição de Swagger para PowerApps.
Usar o CI/CD para configurar uma definição de API

Você deve habilitar a hospedagem de definição de API no portal antes de habilitar o controle de código-fonte para
modificar sua definição da API do controle do código-fonte. Siga estas instruções:
1. Navegue até Definição de API (prévia) em suas configurações de aplicativo de funções.
a. Definir Origem de definição de API como Função.
b. Clique em Gerar modelo de definição de API e depois em Salvar para criar uma definição de modelo
a fim de modificar posteriormente.
c. Anote a URL e a chave de definição da API.
2. Configurar a integração contínua/implantação contínua(CI/CD ).
3. Modifique o swagger.json no controle do código-fonte em \site\wwwroot.azurefunctions\swagger\swagger.json.
Agora, as alterações em swagger.json em seu repositório são hospedadas por seu aplicativo de funções na URL e
chave de definição de API que você anotou na etapa 1.c.
Próximas etapas
Tutorial de introdução. Experimente o nosso passo a passo para exibir uma definição de OpenAPI em ação.
Repositório do GitHub do Azure Functions. Confira o repositório Funções para fornecer comentários sobre a
versão prévia de suporte de definição de API. Execute o GitHub para qualquer coisa que você gostaria de ver
atualizada.
Referência do desenvolvedor do Azure Functions. Saiba mais sobre a codificação de funções e definição de
gatilhos e associações.
Escala e hospedagem no Azure Functions
Ao criar um aplicativo de funções no Azure, você deve escolher um plano de hospedagem

para seu aplicativo. Há três planos de hospedagem disponíveis para Azure Functions: plano
de consumo, plano Premiume plano do serviço de aplicativo.
O plano de hospedagem que você escolher ditará os seguintes comportamentos:
Como seu aplicativo de funções é dimensionado.
Os recursos disponíveis para cada instância do aplicativo de funções.
Suporte para recursos avançados, como conectividade VNET.
Os planos de consumo e Premium adicionam capacidade de computação automaticamente
quando seu código está em execução. Seu aplicativo é escalado horizontalmente quando
necessário para lidar com a carga e diminuído verticalmente quando o código para de ser
executado. Para o plano de consumo, você também não precisa pagar por VMs ociosas ou
reservar a capacidade antecipadamente.
O plano Premium fornece recursos adicionais, como instâncias de computação Premium, a
capacidade de manter instâncias quentes indefinidamente e conectividade VNet.
O plano do serviço de aplicativo permite que você aproveite a infraestrutura dedicada, que
você gerencia. Seu aplicativo de funções não é dimensionado com base em eventos, o que
significa que nunca é dimensionado para zero. (Requer que o Always on esteja habilitado.)
NOTE
Você pode alternar entre consumo e planos Premium alterando a propriedade Plan do recurso de
Suporte ao plano de hospedagem

O suporte a recursos se enquadra nas duas categorias a seguir:
Versão prévia: ainda não há suporte total e aprovado para uso em produção.
A tabela a seguir indica o nível de suporte atual para os três planos de hospedagem, quando
executado no Windows ou no Linux:
PLANO DE CONSUMO PLANO PREMIUM PLANO DEDICADO
Windows GA GA GA
Linux GA GA GA
Plano de consumo
Quando você estiver usando o plano de consumo, as instâncias do host Azure Functions
serão adicionadas e removidas dinamicamente com base no número de eventos de entrada.
Esse plano sem servidor escala automaticamente, e você é cobrado pelos recursos de
computação apenas durante a execução de suas funções. Em um plano de consumo, a
execução de uma função expire após um período configurável.
A cobrança baseia-se no número de execuções, no tempo de execução e na memória usada.
A cobrança é agregada entre todas as funções em um aplicativo de funções. Para saber mais,
confira a página de preços do Azure Functions.
O plano de Consumo é o plano de hospedagem padrão e oferece os seguintes benefícios:
Pague apenas quando suas funções forem executadas
Escale horizontalmente de forma automática, mesmo durante períodos de carga alta
Os aplicativos de funções na mesma região podem ser atribuídos ao mesmo plano de
consumo. Não há nenhuma desvantagem ou impacto para ter vários aplicativos em
execução no mesmo plano de consumo. A atribuição de vários aplicativos ao mesmo plano
de consumo não afeta a resiliência, a escalabilidade ou a confiabilidade de cada aplicativo.
Para saber mais sobre como estimar os custos durante a execução em um plano de
consumo, consulte noções básicas sobre custos do plano de consumo.
Plano Premium
Quando você estiver usando o plano Premium, as instâncias do host Azure Functions serão
adicionadas e removidas com base no número de eventos de entrada, assim como o plano
de consumo. O plano Premium dá suporte aos seguintes recursos:
Instâncias passivas perpétuas para evitar qualquer início frio
Conectividade de VNet
Duração de execução ilimitada
Tamanhos de instância Premium (um núcleo, duas principais e quatro instâncias de
núcleo)
Preços mais previsíveis
Alocação de aplicativo de alta densidade para planos com vários aplicativos de funções
Informações sobre como você pode configurar essas opções podem ser encontradas no
documento Azure Functions plano Premium.
Em vez de cobrança por execução e memória consumida, a cobrança pelo plano Premium é
baseada no número de segundos de núcleo e na memória usada nas instâncias necessárias e
pré-configuradas. Pelo menos uma instância deve estar sempre em espera por plano. Isso
significa que há um custo mensal mínimo por plano ativo, independentemente do número
de execuções. Tenha em mente que todos os aplicativos de funções em um plano Premium
compartilham instâncias ativas e pré-configuradas.
Considere o plano Azure Functions Premium nas seguintes situações:
Os aplicativos de funções executam continuamente ou quase continuamente.
Você tem um número alto de execuções pequenas e tem uma cobrança de alta execução,
mas a cobrança de baixo GB por segundo no plano de consumo.
Você precisa de mais opções de CPU ou memória do que o fornecido pelo plano de
consumo.
Seu código precisa ser executado por mais tempo do que o máximo permitido no plano
de consumo.
Você precisa de recursos que estão disponíveis apenas em um plano Premium, como
conectividade VNET/VPN.
Ao executar funções de JavaScript em um plano Premium, você deve escolher uma instância
que tenha menos vCPUs. Para obter mais informações, consulte escolher planos Premium
de núcleo único.
Plano dedicado (serviço de aplicativo)

Seus aplicativos de funções também podem ser executados nas mesmas VMs dedicadas que
outros aplicativos do serviço de aplicativo (SKUs Basic, Standard, Premium e Isolated).
Considere um plano do serviço de aplicativo nas seguintes situações:
Você tem VMs subutilizadas que já estão executando outras instâncias do Serviço de
Aplicativo.
Você deseja fornecer uma imagem personalizada na qual executar suas funções.
Você paga o mesmo para aplicativos de funções em um plano do serviço de aplicativo como
faria para outros recursos do serviço de aplicativo, como aplicativos Web. Para obter
detalhes sobre como o plano do Serviço de Aplicativo funciona, consulte Visão geral
detalhada de planos de Serviço de Aplicativo do Azure.
Com um plano do serviço de aplicativo, você pode escalar horizontalmente manualmente
Adicionando mais instâncias de VM. Você também pode habilitar o dimensionamento
automático. Para saber mais, confira Dimensionar a contagem de instâncias manual ou
automaticamente. Você também pode escalar verticalmente escolhendo um plano do
Serviço de Aplicativo diferente. Para obter mais informações, consulte Escalar verticalmente
um aplicativo no Azure.
Ao executar funções JavaScript em um plano do Serviço de Aplicativo, você deve escolher
um plano que tenha menos vCPUs. Para obter mais informações, consulte escolher planos
de serviço de aplicativo de núcleo único.
Always On
Se executar em um plano do Serviço de Aplicativo, você deverá habilitar a configuração
Always On para que o aplicativo de funções execute corretamente. Em um plano do Serviço
de Aplicativo, o tempo de execução das funções ficará ocioso após alguns minutos de
inatividade, portanto, apenas gatilhos HTTP "despertarão" suas funções. Always On está
disponível apenas em um plano de Serviço de Aplicativo. Em um plano de Consumo, a
plataforma ativa automaticamente os aplicativos de função.

A duração do tempo limite de um aplicativo de funções é definida pela propriedade
functionTimeout no arquivo de projeto host. JSON . A tabela a seguir mostra os valores
padrão e máximo em minutos para ambos os planos e em ambas as versões de tempo de
execução:
VERSÃO DE TEMPO DE
Consumo 1.x 5 10
Consumo 2. x 5 10
VERSÃO DE TEMPO DE
NOTE
Independentemente da configuração do tempo limite do aplicativo de funções, 230 segundos é a
quantidade máxima de tempo que uma função disparada por HTTP pode levar para responder a
uma solicitação. Isso ocorre devido ao tempo limite de ociosidade padrão de Azure Load Balancer.
Para tempos de processamento mais longos, considere usar o padrão assíncrono Durable Functions
ou adiar o trabalho real e retornar uma resposta imediata.
Mesmo com Always On habilitado, o tempo limite de execução para funções individuais é
controlado pela configuração functionTimeout no arquivo de projeto host.json.
Determinar o plano de Hospedagem de um aplicativo

existente
Para determinar o plano de hospedagem usado pelo aplicativo de funções, consulte plano
do Serviço de Aplicativo/tipo de preço na guia Visão geral do aplicativo de funções no
portal do Azure. Para planos do Serviço de Aplicativo, o tipo de preço também é indicado.
Também é possível usar a CLI do Azure para determinar o plano, da seguinte maneira:
appServicePlanId=$(az functionapp show --name <my_function_app_name> --resource-group

<my_resource_group> --query appServicePlanId --output tsv)
az appservice plan list --query "[?id=='$appServicePlanId'].sku.tier" --output tsv
Quando a saída desse comando for dynamic , o aplicativo de funções estará no plano de
Consumo. Quando a saída desse comando for ElasticPremium , seu aplicativo de funções
estará no plano Premium. Todos os outros valores indicam diferentes camadas de um plano
Requisitos da conta de armazenamento
Em qualquer plano, um aplicativo de funções requer uma conta de armazenamento do
Azure geral, que dá suporte ao blob do Azure, à fila, aos arquivos e ao armazenamento de
tabelas. Isso ocorre porque o Functions depende do Armazenamento do Microsoft Azure
para operações como o gerenciamento de gatilhos e execuções de funções de registro em
log, mas algumas contas de armazenamento não dão suporte a filas e tabelas. Essas contas,
que incluem contas de armazenamento somente blob (incluindo armazenamento Premium)
e contas de armazenamento para uso geral com replicação de armazenamento com
redundância de zona, são filtradas das seleções da Conta de Armazenamento existente
quando você cria um aplicativo de funções.
A mesma conta de armazenamento usada por seu aplicativo de funções também pode ser
usada por seus gatilhos e associações para armazenar os dados do aplicativo. No entanto,
para operações com uso intensivo de armazenamento, você deve usar uma conta de
armazenamento separada.
Para saber mais sobre os tipos de conta de armazenamento, consulte Apresentando os
serviços de armazenamento do Azure.
Como funcionam os planos de consumo e Premium

Nos planos de consumo e Premium, a infraestrutura de Azure Functions escala recursos de
CPU e memória adicionando instâncias adicionais do host do functions, com base no
número de eventos em que suas funções são disparadas. Cada instância do host do
Functions no plano de consumo é limitada a 1,5 GB de memória e uma CPU. Uma instância
do host é o aplicativo de funções inteiro, o que significa que todas as funções em um
aplicativo de funções compartilham recursos dentro de uma instância e são dimensionadas
ao mesmo tempo. Os aplicativos de funções que compartilham o mesmo plano de consumo
são dimensionados de forma independente. No plano Premium, o tamanho do plano
determinará a memória disponível e a CPU para todos os aplicativos nesse plano nessa
instância.
Os arquivos de código de função são armazenados em compartilhamentos de arquivos do
Azure na conta de armazenamento principal da função. Quando você exclui a conta de
armazenamento principal do aplicativo de funções, os arquivos de código de função são
excluídos e não podem ser recuperados.
Escalonamento de tempo de execução
O Azure Functions usa um componente chamado controlador de escala para monitorar a
taxa de eventos e determinar se deve aumentar ou reduzir. O controlador de escala usa
heurística para cada tipo de gatilho. Por exemplo, ao usar um gatilho do armazenamento de
Filas do Azure, ele escala com base no tamanho da fila e na idade da mensagem em fila mais
antiga.
A unidade de escala para Azure Functions é o aplicativo de funções. Quando o aplicativo de
funções é dimensionado na horizontal, mais recursos são alocados para executar várias
instâncias do host do Azure Functions. Em contrapartida, quando a demanda por
computação é reduzida, o controlador de escala remove as instâncias do host de função. O
número de instâncias é eventualmente reduzido a zero quando nenhuma função está em
execução em um aplicativo de funções.
Noções básicas dos comportamentos de dimensionamento
O dimensionamento pode variar em uma série de fatores e ser diferente com base no
gatilho e na linguagem selecionada. Há algumas complexidades de comportamentos de
dimensionamento a serem considerados:
Um único aplicativo de funções será escalado verticalmente somente para um máximo de
200 instâncias. Uma única instância pode processar mais de uma mensagem ou
solicitação por vez, portanto, não há um limite definido de número de execuções
simultâneas.
Para gatilhos HTTP, novas instâncias só serão alocadas no máximo uma vez a cada 1
segundo.
Para gatilhos não HTTP, novas instâncias só serão alocadas no máximo uma vez a cada
30 segundos.
Gatilhos diferentes também podem ter diferentes limites de dimensionamento, como
documentado abaixo:
Hub de Evento
Melhores práticas e padrões para aplicativos escalonáveis
Há muitos aspectos de um aplicativo de funções que afetarão a qualidade da escala,
incluindo a configuração do host, o espaço de tempo de execução e a eficiência dos recursos.
Para obter mais informações, consulte a seção de escalabilidade do artigo sobre
considerações de desempenho. Adicionalmente, é necessário que você saiba como as
conexões se comportam na medida em que o aplicativo de funções é dimensionado. Para
saber mais, confira Como gerenciar conexões no Azure Functions.
Modelo de cobrança
A cobrança pelos diferentes planos é descrita em detalhes na página de preços de Azure
Functions. O uso é agregado no nível do aplicativo de funções e conta apenas o tempo
durante o qual o código de função é executado. Veja a seguir as unidades de cobrança:
Consumo de recursos em GB/s (gigabyte por segundo) . Calculado como uma
combinação do tamanho da memória e o tempo de execução para todas as funções
dentro de um aplicativo de Funções.
Execuções. Contadas toda vez que uma função é executada em resposta a um gatilho de
evento.
Consultas e informações úteis sobre como entender sua fatura de consumo podem ser
encontradas nas perguntas frequentes sobre cobrança.
Limites de serviço
A tabela a seguir indica os limites que se aplicam a aplicativos de funções ao serem
executados em vários planos de hospedagem:
GRUPOS PLANO DE CONSUMO PLANO PREMIUM APLICATIVO1
Expansão Controlado por Controlado por Manual/dimensionam

evento evento ento automático
Máximo de instâncias 200 20 10-20
Duração do tempo 5 30 302

limite padrão (min)
Duração máxima de 10 não associado Não associado3

tempo limite (min)
Máximo de conexões 600 ativo (total de não associado não associado

de saída (por 1200)
instância)

solicitação (MB)4

de consulta4
Comprimento máximo 8192 8192 8192

da URL de solicitação4
ACU por instância 100 210-840 100-840
Memória máxima (GB 1.5 3,5-14 1,75-14

por instância)
Aplicativos de funções 100 100 Não associado5

por plano
Planos do Serviço de 100 por região 100 por grupo de 100 por grupo de
Aplicativo recursos recursos
Armazenamento6 1 GB 250 GB 50-1000 GB
Domínios 5007 500 500

personalizados por
aplicativo
domínio personalizado conexão SSL SNI não conexões SSL SNI não conexões SSL SNI não
Suporte a SSL vinculada incluída associadas e 1 IP SSL associadas e 1 IP SSL
incluídas incluídas
1
1 para limites específicos para as várias opções do plano do serviço de aplicativo, consulte os
limites do plano do serviço de aplicativo.

2 por padrão, o tempo limite para o tempo de execução do Functions 1. x em um plano do
serviço de aplicativo é não associado.

3 requer que o plano do serviço de aplicativo seja definido como Always on. Pague com
tarifaspadrão.
4 esses limites são definidos no host.
5 o número real de aplicativos de funções que você pode hospedar depende da atividade dos
aplicativos, do tamanho das instâncias de máquina e da utilização de recursos

correspondente.
6 o limite de armazenamento é o tamanho total do conteúdo no armazenamento temporário
em todos os aplicativos no mesmo plano do serviço de aplicativo. O plano de consumo usa

os arquivos do Azure para armazenamento temporário.
7 quando seu aplicativo de funções está hospedado em um plano de consumo, somente a
opção CNAME tem suporte. Para aplicativos de funções em um plano Premium ou um

plano do serviço de aplicativo, é possível mapear um domínio personalizado usando um
registro CNAME ou um.

Azure Functions PDF

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Azure Functions PDF

Загружено:

Авторское право:

Доступные форматы

Contents

O que posso fazer com o Functions?

Quanto custa o Functions?

JavaScript (apenas Funções 2.x )

Nesse exemplo, os valores F1 , F2 , F3 e F4 são os nomes de outras funções no aplicativo de funções.

// Get a list of N work items to process in parallel.

// Aggregate all N outputs and send the result to F3.

JavaScript (apenas Funções 2.x )

// Get a list of N work items to process in parallel.

// Aggregate all N outputs and send the result to F3.

Padrão 3: APIs HTTP assíncronas

> curl -X POST https://myfunc.azurewebsites.net/orchestrators/DoWork -H "Content-Length: 0" -i

> curl https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/b79baf67f717453ca9e86c5da21e03ec -i

> curl https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/b79baf67f717453ca9e86c5da21e03ec -i

while (context.CurrentUtcDateTime < expiryTime)

// Orchestration sleeps until this time.

// Perform more work here, or let the orchestration end.

JavaScript (apenas Funções 2.x )

// Orchestration sleeps until this time.

// Perform more work here, or let the orchestration end.

Task<bool> approvalEvent = context.WaitForExternalEvent<bool>("ApprovalEvent");

JavaScript (apenas Funções 2.x )

const dueTime = moment.utc(context.df.currentUtcDateTime).add(72, 'h');

const approvalEvent = context.df.waitForExternalEvent("ApprovalEvent");

Para criar o temporizador durável, chame context.CreateTimer (.NET) ou context.df.createTimer (JavaScript). A

module.exports = async function (context) {

Padrão nº 6: Agregador (versão prévia)

public class Counter

public void Add(int amount) => this.CurrentValue += amount;

public void Reset() => this.CurrentValue = 0;

public int Get() => this.CurrentValue;

// The "Counter/{metricType}" entity is created on-demand.

Comece a usar agora

Este artigo compara os seguintes serviços em nuvem da Microsoft:

Comparar o Microsoft Flow e os Aplicativos Lógicos do Azure

MICROSOFT FLOW APLICATIVOS LÓGICOS

Usuários Funcionários do escritório, usuários de Integradores profissionais e

Cenários Autoatendimento Integrações avançadas

Ferramenta de design Aplicativo do navegador e móvel, No navegador e no Visual Studio,

Segurança Logs de auditoria de Segurança e Garantia de segurança do Azure:

Comparar o Azure Functions e os Aplicativos Lógicos do Azure

FUNÇÕES DURÁVEIS APLICATIVOS LÓGICOS

Desenvolvimento Primeiro o código (obrigatória) Primeiro o designer (declarativa)

Conectividade Vários tipos de associação integradas, Grande coleção de conectores,

Monitoramento Azure Application Insights Portal do Azure, Logs do Azure Monitor

Contexto de execução Pode ser executado localmente ou na É executado somente na nuvem

Comparar Functions e WebJobs

FUNÇÕES WEBJOBS COM O SDK DO WEBJOBS

Modelo de aplicativo sem servidor com ✔

Desenvolver e testar no navegador ✔

Preço de pagamento por uso ✔

Integração com os Aplicativos Lógicos ✔

Eventos de gatilho Timer Timer

Idiomas com suporte C# C#1

Gerenciador de pacotes NPM e NuGet NuGet2

Microsoft Flow, Aplicativos Lógicos, Functions e WebJobs juntos

Suporte ao plano de hospedagem

PLANO DE CONSUMO PLANO PREMIUM PLANO DEDICADO

Plano dedicado (serviço de aplicativo)

Duração do tempo limite do aplicativo de funções

Serviço de aplicativo 1.x Ilimitado Ilimitado

Serviço de aplicativo 2. x 30 Ilimitado