Você está na página 1de 1154

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 – Python
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
Adicionar associações
Status do Azure Cosmos DB – portal
Armazenamento – Python
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
Gatilhos e associações
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?
24/10/2019 • 24 minutes to read • Edit Online

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(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
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);
}

JavaScript (apenas Funções 2.x )


const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
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
Content-Type: application/json
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
Content-Type: application/json

{"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")]
public static async Task Run(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
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.


}

JavaScript (apenas Funções 2.x )


const df = require("durable-functions");
const moment = require("moment");

module.exports = df.orchestrator(function*(context) {
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")]
public static async Task Run(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
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);
}
}
}

JavaScript (apenas Funções 2.x )

const df = require("durable-functions");
const moment = require('moment');

module.exports = df.orchestrator(function*(context) {
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")]
public static async Task Run(
[HttpTrigger] string instanceId,
[OrchestrationClient] DurableOrchestrationClient client)
{
bool isApproved = true;
await client.RaiseEventAsync(instanceId, "ApprovalEvent", isApproved);
}
const df = require("durable-functions");

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")]
public static async Task Run(
[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?
25/05/2018 • 14 minutes to read • Edit Online

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
25/05/2018 • 24 minutes to read • Edit Online

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


PLANO DE SERVIÇO DE
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
07/11/2019 • 13 minutes to read • Edit Online

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
24/10/2019 • 10 minutes to read • Edit Online

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.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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.

Executar a função localmente


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
Criar sua primeira função usando o Visual Studio
Code
07/11/2019 • 14 minutes to read • Edit Online

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).


Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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.
PROMPT VALOR DESCRIÇÃ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.

Executar a função localmente


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:

5. 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.

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.

Publicar o projeto no Azure


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
07/11/2019 • 12 minutes to read • Edit Online

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
Para concluir este guia de início rápido:
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.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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.
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.

Executar a função localmente


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.
2. No painel Terminal, copie o ponto de extremidade de URL da sua função disparada por HTTP.

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.
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.

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.

Publicar o projeto no Azure


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


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
29/10/2019 • 13 minutes to read • Edit Online

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.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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.

Executar a função localmente


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


Now listening on: http://0.0.0.0:7071
Application started. Press Ctrl+C to shut down.

...

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.

Verificar a função 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
24/10/2019 • 13 minutes to read • Edit Online

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.
1. No Gerenciador de Soluções, clique com o botão direito do mouse no nome do projeto e selecione
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.

Registrar as extensões de associação


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:

[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)
{
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;

if (!string.IsNullOrEmpty(name))
{
// Add a message to the output collection.
msg.Add(string.Format("Name passed to the function: {0}", name));
}
return name != null
? (ActionResult)new OkObjectResult($"Hello, {name}")
: new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

Executar a função localmente


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.


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:
Habilitar a integração do Application Insights
Conectar a função Java ao Armazenamento do Azure
24/10/2019 • 13 minutes to read • Edit Online

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 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.
A maioria das associações requer uma cadeia de conexão armazenada que o Functions usa para acessar o serviço
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.

Baixar as configurações do aplicativo de funções


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
local.settings.json.
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.

Adicionar uma associação de saída


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) {
...
}

Adicionar o código que usa a associação de saída


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")
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) {
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.

Executar a função 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 `echo $(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:

mvn azure-functions:deploy

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.
Em seguida, você deve habilitar o monitoramento do Application Insights para seu aplicativo de funções:
Habilitar a integração do Application Insights
Conectar funções ao Armazenamento do Azure
usando o Visual Studio Code
24/10/2019 • 20 minutes to read • Edit Online

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 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
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 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.

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 à 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.

Registrar as extensões de associação


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.
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.
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.

Adicionar uma associação de saída


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:

PROMPT VALOR DESCRIÇÃ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
Armazenamento do Azure.

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.
PROMPT VALOR DESCRIÇÃO

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
aplicativo de funções.

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"
}
]
}

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ê.
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);

Neste ponto, sua função deve ser a seguinte:

module.exports = async function (context, req) {


context.log('JavaScript HTTP trigger function processed a request.');

if (req.query.name || (req.body && req.body.name)) {


// Add a message to the Storage queue.
context.bindings.msg = "Name passed to the function: " +
(req.query.name || 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"
};
}
};

Executar a função localmente


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:
5. Para interromper a depuração, pressione Shift + F5.
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.
Examinar a fila de saída
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.
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, 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. 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>

4. 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
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 Visual Studio Code, pressione F1 para abrir a paleta de comandos. Na paleta de comandos, pesquise e
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.

4. Na página Grupo de recursos, examine a lista de recursos incluídos e verifique se eles são aqueles que
deseja excluir.
5. 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 de funções, confira Desenvolver Funções do Azure usando o Visual Studio Code.
Em seguida, você deve habilitar o monitoramento do Application Insights para seu aplicativo de funções:
Habilitar a integração do Application Insights
Adicionar uma associação de fila do Armazenamento
do Azure à sua função do Python
24/10/2019 • 14 minutes to read • Edit Online

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 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.
A maioria das associações requer uma cadeia de conexão armazenada que o Functions usa para acessar o serviço
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 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.

Baixar as configurações do aplicativo de funções


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
local.settings.json.
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.

Adicionar uma associação de saída


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.
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:

PROMPT VALOR DESCRIÇÃ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
Armazenamento do Azure.

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.
PROMPT VALOR DESCRIÇÃO

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
aplicativo de funções.

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"
}
]
}

Adicionar o código que usa a associação de saída


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
)

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ê.

Executar a função localmente


Como anteriormente, use o seguinte comando para iniciar o tempo de execução do Functions localmente:

func host start

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.

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.
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 `echo $(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, 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.

func azure functionapp publish <APP_NAME> --build remote

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
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 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.
Em seguida, você deve habilitar o monitoramento do Application Insights para seu aplicativo de funções:
Habilitar a integração do Application Insights
Criar uma função que se integra aos Aplicativos
Lógicos do Azure
07/11/2019 • 20 minutes to read • Edit Online

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.

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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
aplicativo de funções.

Selecione o botão Avançar: Monitoramento > .


5. Insira as configurações a seguir para o monitoramento.

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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

string requestBody = await new StreamReader(req.Body).ReadToEndAsync();


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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.


CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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
07/11/2019 • 13 minutes to read • Edit Online

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.
Neste tutorial, você aprenderá como:
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.
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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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 aplicativo de
funções.

Selecione o botão Avançar: Monitoramento > .


5. Insira as configurações a seguir para o monitoramento.

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.

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:
#r "Newtonsoft.Json"

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

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


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

// 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.


CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

Nome Nome globalmente exclusivo Um nome é gerado com base no


nome do seu aplicativo de funções.

Assinatura Sua assinatura A assinatura na qual este novo


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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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
07/11/2019 • 18 minutes to read • Edit Online

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.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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.

4. Use as configurações do aplicativo de funções especificadas na tabela abaixo da imagem.


CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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 Codificar Opção para publicar arquivos de


código ou um contêiner do Docker.

Pilha de tempo de execução 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 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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
Você também pode usar uma conta
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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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 revisar as seleções de configuração de aplicativo.


7. Selecione Criar para provisionar e implantar o aplicativo de funções.
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:

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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:

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO


CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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
aplicativo de funções.

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:

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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:

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

Nome Plant O nome pode ser qualquer valor. Ele


é usado para identificar o proxy.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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
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
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
28/10/2019 • 19 minutes to read • Edit Online

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
Neste tutorial, você aprenderá 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

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 uma assinatura do Azure, crie uma conta gratuita antes de começar.
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 .

Criar uma conta de Armazenamento do Azure


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

Criar um aplicativo de funções


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.


CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.


CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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 à
conta de armazenamento.
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
01/11/2019 • 12 minutes to read • Edit Online

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

Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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
https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-
tutorial/master/resources/assets/samples/cat2.png
https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-
tutorial/master/resources/assets/samples/dog1.png
https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-
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
24/10/2019 • 38 minutes to read • Edit Online

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á.
Neste tutorial, você aprenderá como:
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.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
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.

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.

Executar a função localmente


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:

%%%%%%
%%%%%%
@ %%%%%% @
@@ %%%%%% @@
@@@ %%%%%%%%%%% @@@
@@ %%%%%%%%%% @@
@@ %%%% @@
@@ %%% @@
@@ %% @@
%%
%

...

Content root path: C:\functions\MyFunctionProj


Now listening on: http://0.0.0.0:7071
Application started. Press Ctrl+C to shut down.

...

Http Functions:

HttpTrigger: http://localhost:7071/api/MyHttpTrigger

[8/27/2018 10:38:27 PM] Host started (29486ms)


[8/27/2018 10:38:27 PM] Job host started

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. 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.

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 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.
docker build --tag <docker-id>/mydockerimage:v1.0.0 .

Envie por push a imagem atualizada de volta para o Docker Hub.

docker push <docker-id>/mydockerimage:v1.0.0

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
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.
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.
Baixar as configurações do aplicativo de funções
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 local.settings.json.
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
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.
JavaScript/Python
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.
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 uma associação de saída do Armazenamento ao projeto.


Adicionar uma associação de saída
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/Python
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:

PROMPT VALOR DESCRIÇÃ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.

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
aplicativo de funções.

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"
}
]
}

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ê.
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 .

// Add a message to the Storage queue.


context.bindings.msg = "Name passed to the function: " +
(req.query.name || req.body.name);

Neste ponto, sua função deve ser a seguinte:


module.exports = async function (context, req) {
context.log('JavaScript HTTP trigger function processed a request.');

if (req.query.name || (req.body && req.body.name)) {


// Add a message to the Storage queue.
context.bindings.msg = "Name passed to the function: " +
(req.query.name || 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"
};
}
};

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.

docker build --tag <docker-id>/mydockerimage:v1.0.0 .

Envie por push a imagem atualizada de volta para o repositório.

docker push <docker-id>/mydockerimage:v1.0.0

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 .
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 `echo $(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.

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
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
24/10/2019 • 18 minutes to read • Edit Online

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.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

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
24/10/2019 • 2 minutes to read • Edit Online

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
08/11/2019 • 19 minutes to read • Edit Online

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>
<AzureFunctionsVersion>v2</AzureFunctionsVersion>

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 ✔ ✔ ✔

Armazenamento ✔ ✔ ✔ ✔
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.

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.

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
07/11/2019 • 13 minutes to read • Edit Online

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.

Criar um plano Premium


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.


4. Use as configurações do aplicativo de funções especificadas na tabela abaixo da imagem.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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 Codificar Opção para publicar arquivos de


código ou um contêiner do Docker.

Pilha de tempo de execução 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 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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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.
Você também pode usar uma conta
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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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 revisar as seleções de configuração de aplicativo.


7. Selecione Criar para provisionar e implantar o aplicativo de funções.
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
07/11/2019 • 19 minutes to read • Edit Online

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
24/10/2019 • 14 minutes to read • Edit Online

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
Para obter mais informações, consulte os seguintes recursos:
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
24/10/2019 • 3 minutes to read • Edit Online

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
25/05/2018 • 7 minutes to read • Edit Online

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",
"type": "httpTrigger",
"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:

TIPO 1.X 2. X 1 OF ENTRADA SAÍDA

Armazename ✔ ✔ ✔ ✔ ✔
nto 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

Armazename ✔ ✔ ✔ ✔
nto de filas
TIPO 1.X 2. X OF ENTRADA SAÍDA

SendGrid ✔ ✔ ✔

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
Executar manualmente uma função não disparada por HTTP
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
24/10/2019 • 5 minutes to read • Edit Online

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

#r "Newtonsoft.Json"

using Microsoft.Extensions.Logging;
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 PartitionKey { get; set; }
public string RowKey { get; set; }
public string Name { get; set; }
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
24/10/2019 • 7 minutes to read • Edit Online

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",
"extensionBundle": {
"id": "Microsoft.Azure.Functions.ExtensionBundle",
"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
24/10/2019 • 11 minutes to read • Edit Online

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
arquivo local.settings.json.
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",
"type": "queueTrigger",
"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",
"connection": "MyStorageConnection"
}
],
}

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")]
public static void Run(
[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",
"type": "queueTrigger",
"queueName": "myqueue-items",
"connection": "MyStorageConnection",
},
{
"name": "myInputBlob",
"type": "blob",
"path": "samples-workitems/{queueTrigger}",
"direction": "in",
"connection": "MyStorageConnection"
}
]

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",
"type": "httpTrigger",
"direction": "in",
"webHookType": "genericJson"
},
{
"name": "blobContents",
"type": "blob",
"direction": "in",
"path": "strings/{BlobName}",
"connection": "AzureWebJobsStorage"
},
{
"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;
using Microsoft.Extensions.Logging;

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
Usando o valor de retorno da função do Azure
Usando o valor de retorno da função do Azure
24/10/2019 • 3 minutes to read • Edit Online

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:

[FunctionName("QueueTrigger")]
[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;
}

[FunctionName("QueueTrigger")]
[return: Blob("output-container/{id}")]
public static Task<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 Task.FromResult(json);
}

Exemplo 2 de C# script
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)


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

public static Task<string> Run(WorkItem input, ILogger log)


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

Exemplo de F#
Aqui está a associação de saída no arquivo function.json:

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

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

Exemplo de JavaScript
Aqui está a associação de saída no arquivo function.json:

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

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
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 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
07/11/2019 • 2 minutes to read • Edit Online

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)
Usar tratamento de erro estruturado
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
08/11/2019 • 3 minutes to read • Edit Online

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
07/11/2019 • 22 minutes to read • Edit Online

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


{
[FunctionName("QueueTrigger")]
public static void Run(
[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")]
public static void Run(
[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")]
public static void Run(
[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": [
{
"type": "queueTrigger",
"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>
<AzureFunctionsVersion>v2</AzureFunctionsVersion>
</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")]
public static void Run(
[QueueTrigger("myqueue-items-source-3")] string myQueueItem,
[Queue("myqueue-items-destination")] ICollector<string>
myDestinationQueue,
ILogger log)
{
log.LogInformation($"C# function processed: {myQueueItem}");
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


{
[FunctionName("QueueTrigger")]
public static void Run(
[QueueTrigger("myqueue-items")] string myQueueItem,
ILogger log)
{
log.LogInformation($"C# function processed: {myQueueItem}");
}
}

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


{
public static void Run(
[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")]
public static void Run(
[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!!");
}
}
}

Gatilhos e associações
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

Armazenam ✔ ✔ ✔ ✔ ✔
ento 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

Armazenam ✔ ✔ ✔ ✔
ento de
filas

SendGrid ✔ ✔ ✔
TIPO 1.X 2. X OF ENTRADA SAÍDA

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
25/05/2018 • 20 minutes to read • Edit Online

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
| - MySecondFunction
| | - run.csx
| | - function.json
| | - function.proj
| - host.json
| - extensions.csproj
| - bin

Há um arquivo host.json compartilhado que pode ser usado para configurar o aplicativo de funçõ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": [
{
"type": "queueTrigger",
"direction": "in",
"name": "myQueueItem",
"queueName": "myqueue-items",
"connection":"MyStorageConnectionAppSetting"
}
]
}

#r "Microsoft.WindowsAzure.Storage"

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

public static void Run(CloudQueueMessage myQueueItem, ILogger log)


{
log.LogInformation($"C# Queue trigger function processed: {myQueueItem.AsString}");
}

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

using Microsoft.Extensions.Logging;

public static void Run(TimerInfo myTimer, ILogger log)


{
log.LogInformation($"Log by run.csx: {DateTime.Now}");
MyLogger(log, $"Log by MyLogger: {DateTime.Now}");
}

Exemplo 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;
using Microsoft.Extensions.Logging;

public static async Task<HttpResponseMessage> Run(Order req, IAsyncCollector<Order> outputQueueItem, ILogger


log)
{
log.LogInformation("C# HTTP trigger function received an order.");
log.LogInformation(req.ToString());
log.LogInformation("Submitting to processing queue.");

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

Exemplo run.csx para o gatilho da fila:

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

using System;
using Microsoft.Extensions.Logging;

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

outputQueueItem = myQueueItem;
}

Exemplo order.csx:
public class Order
{
public string orderId {get; set; }
public string custName {get; set;}
public string custAddress {get; set;}
public string custEmail {get; set;}
public string cartId {get; set; }

public override String ToString()


{
return "\n{\n\torderId : " + orderId +
"\n\tcustName : " + custName +
"\n\tcustAddress : " + custAddress +
"\n\tcustEmail : " + custEmail +
"\n\tcartId : " + cartId + "\n}";
}
}

Você pode usar um caminho relativo com a 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;

public static void Run(


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

Importando namespaces
Se precisar importar namespaces, você poderá fazer como geralmente faz, com a cláusula using .

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

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;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

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
Microsoft.Azure.WebJobs.Host
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.

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 void Run(TimerInfo myTimer, ILogger log)
{
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
log.LogInformation(GetEnvironmentVariable("AzureWebJobsStorage"));
log.LogInformation(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
}

public static string GetEnvironmentVariable(string name)


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

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


,
Microsoft.Azure.WebJobs.StorageAccountAttribute

Tabela de armazenamento Microsoft.Azure.WebJobs.TableAttribute


,
Microsoft.Azure.WebJobs.StorageAccountAttribute

Twilio Microsoft.Azure.WebJobs.TwilioSmsAttribute
#r
"Microsoft.Azure.WebJobs.Extensions.Twilio"

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
25/05/2018 • 13 minutes to read • Edit Online

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
| - MySecondFunction
| | - run.fsx
| | - 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 (.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
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
open Microsoft.Extensions.Logging

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
Microsoft.Azure.WebJobs.Host
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
open Microsoft.Extensions.Logging

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.

Variáveis de ambiente
Para obter uma variável de ambiente ou um valor de configuração do aplicativo, use
System.Environment.GetEnvironmentVariable , por exemplo:

open System.Environment
open Microsoft.Extensions.Logging

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
Referência do desenvolvedor do 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
25/05/2018 • 40 minutes to read • Edit Online

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
| - MySecondFunction
| | - index.js
| | - function.json
| - SharedCode
| | - myFirstHelperFunction.js
| | - mySecondHelperFunction.js
| - node_modules
| - host.json
| - package.json
| - extensions.csproj

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.

module.exports = async function (context) {


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:

module.exports = async function (context, req) {


context.log('JavaScript HTTP trigger function processed a request.');
// 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.

module.exports = async function(context) {


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.

module.exports = async function(context) {


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.
module.exports = async function(context) {
let retMsg = 'Hello, world!';
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 :

{
"type": "httpTrigger",
"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) {
// function logic goes here :)
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:

PROPRIEDADE DESCRIÇÃO

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.


PROPRIEDADE DESCRIÇÃO

rawBody O corpo da mensagem como uma cadeia de caracteres.

Objeto de resposta
O objeto context.res (resposta) tem as seguintes propriedades:

PROPRIEDADE DESCRIÇÃO

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.

Variáveis de ambiente
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 fs = require('fs');
const util = require('util');
const readFileAsync = util.promisify(fs.readFile);

module.exports = async function (context) {


let data;
try {
data = await readFileAsync('./hello.txt');
} catch (err) {
context.log.error('ERROR', err);
// This rethrown exception will be handled by the Functions Runtime and will only fail the individual
invocation
throw err;
}
context.log(`Data from file: ${data}`);
}

Próximos passos
Para saber mais, consulte os recursos a seguir:
Práticas recomendadas para o Azure Functions
Referência do desenvolvedor do Azure Functions
Gatilhos e associações de Azure Functions
Guia do desenvolvedor de Java do Azure
Functions
01/11/2019 • 18 minutes to read • Edit Online

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:

mvn archetype:generate \
-DarchetypeGroupId=com.microsoft.azure \
-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:

mvn archetype:generate \
-DarchetypeGroupId=com.microsoft.azure \
-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": [
{
"type": "httpTrigger",
"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.*;

public class Function {


@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 .

package com.example;

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

public class Function {


@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)
HttpRequestMessage<Optional<String>> request,
@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.
package com.example;

import java.util.Optional;
import com.microsoft.azure.functions.annotation.*;

public class Function {


@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,
final ExecutionContext context
) {
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.*;
import com.microsoft.azure.functions.annotation.*;

public class Function {


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());
}
return String.format(req);
}
}

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.

Variáveis de ambiente
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 class Function {
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"));
return String.format(req);
}
}

Próximos passos
Para obter mais informações sobre o desenvolvimento em Java Azure Functions, consulte os seguintes
recursos:
Práticas recomendadas para o Azure Functions
Referência do desenvolvedor do Azure Functions
Gatilhos e associações de Azure Functions
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.
Guia do desenvolvedor do Azure Functions
PowerShell
24/10/2019 • 37 minutes to read • Edit Online

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
| - MySecondFunction
| | - run.ps1
| | - function.json
| - Modules
| | - myFirstHelperModule
| | | - myFirstHelperModule.psd1
| | | - myFirstHelperModule.psm1
| | - mySecondHelperModule
| | | - mySecondHelperModule.psd1
| | | - mySecondHelperModule.psm1
| - local.settings.json
| - host.json
| - requirements.psd1
| - profile.ps1
| - extensions.csproj
| - 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:

param($MyFirstInputBinding, $MySecondInputBinding)

Push-OutputBinding -Name myQueue -Value $myValue

Você também pode passar um valor para uma ligação específica por meio do pipeline.

param($MyFirstInputBinding, $MySecondInputBinding)

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.

PS >Push-OutputBinding -Name response -Value ([HttpResponseContext]@{


StatusCode = [System.Net.HttpStatusCode]::OK
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":

PS >Push-OutputBinding -Name response -Value ([HttpResponseContext]@{


StatusCode = [System.Net.HttpStatusCode]::OK
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.
Gatilhos e associações HTTP
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:

PROPRIEDADE DESCRIÇÃO TIPO

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:

PROPRIEDADE DESCRIÇÃO TIPO

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.
PROPRIEDADE DESCRIÇÃO TIPO

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": [
{
"type": "httpTrigger",
"direction": "in",
"authLevel": "anonymous"
},
{
"type": "http",
"direction": "out"
}
]
}

run.ps1

param($req, $TriggerMetadata)

$name = $req.Query.Name

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{


StatusCode = [System.Net.HttpStatusCode]::OK
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
| - local.settings.json
| - 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.

Variáveis de ambiente
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

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 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
Para obter mais informações, consulte os seguintes recursos:
Práticas recomendadas para o Azure Functions
Referência do desenvolvedor do Azure Functions
Gatilhos e associações de Azure Functions
Guia do desenvolvedor de Python para o Azure
Functions
08/11/2019 • 21 minutes to read • Edit Online

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",
"type": "httpTrigger",
"authLevel": "anonymous"
},
{
"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
| - MySecondFunction
| | - __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",
"type": "httpTrigger",
"authLevel": "anonymous",
"route": "items/{id}"
},
{
"name": "obj",
"direction": "in",
"type": "blob",
"path": "samples/{id}",
"connection": "AzureWebJobsStorage"
}
]
}

// local.settings.json
{
"IsEncrypted": false,
"Values": {
"FUNCTIONS_WORKER_RUNTIME": "python",
"AzureWebJobsStorage": "<azure-storage-connection-string>"
}
}

# __init__.py
import azure.functions as func
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.

{
"scriptFile": "__init__.py",
"bindings": [
{
"name": "req",
"direction": "in",
"type": "httpTrigger",
"authLevel": "anonymous"
},
{
"name": "msg",
"direction": "out",
"type": "queue",
"queueName": "outqueue",
"connection": "AzureWebJobsStorage"
},
{
"name": "$return",
"direction": "out",
"type": "http"
}
]
}

import azure.functions as func

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.

Gatilhos e associações HTTP


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.

def main(req: func.HttpRequest) -> func.HttpResponse:


headers = {"my-http-header": "some-value"}

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:
return func.HttpResponse(f"Hello {name}!", headers=headers)
else:
return func.HttpResponse(
"Please pass a name on the query string or in the request body",
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

Variáveis de ambiente
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
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:

# 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": [
{
"authLevel": "function",
"type": "httpTrigger",
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]
},
{
"type": "http",
"direction": "out",
"name": "$return"
}
]
}

# myapp/httpfunc.py
import azure.functions as func
import logging

def my_function(req: func.HttpRequest) -> func.HttpResponse:


logging.info('Python HTTP trigger function processed a request.')

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:
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
)
# myapp/test_httpfunc.py
import unittest

import azure.functions as func


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
import azure.functions as func

def my_function(msg: func.QueueMessage) -> str:


return f'msg body: {msg.get_body().decode()}'

# myapp/test_func.py
import unittest

import azure.functions as func


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 azure.functions as func
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:

def main(req: func.HttpRequest) -> func.HttpResponse:

# Define the allow origin headers.


headers = {"Access-Control-Allow-Origin": "https://contoso.com"}

# Set the headers in the response.


return func.HttpResponse(
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
Para saber mais, consulte os recursos a seguir:
Documentação da API do pacote Azure Functions
Práticas recomendadas para o 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
25/05/2018 • 40 minutes to read • Edit Online

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
| - MySecondFunction
| | - index.js
| | - function.json
| - SharedCode
| | - myFirstHelperFunction.js
| | - mySecondHelperFunction.js
| - node_modules
| - host.json
| - package.json
| - extensions.csproj

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.

module.exports = async function (context) {


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:

module.exports = async function (context, req) {


context.log('JavaScript HTTP trigger function processed a request.');
// 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.

module.exports = async function(context) {


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.
module.exports = async function(context) {
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.

module.exports = async function(context) {


let retMsg = 'Hello, world!';
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 :

{
"type": "httpTrigger",
"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) {
// function logic goes here :)
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:

PROPRIEDADE DESCRIÇÃO

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:

PROPRIEDADE DESCRIÇÃO

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.

Variáveis de ambiente
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 fs = require('fs');
const util = require('util');
const readFileAsync = util.promisify(fs.readFile);

module.exports = async function (context) {


let data;
try {
data = await readFileAsync('./hello.txt');
} catch (err) {
context.log.error('ERROR', err);
// This rethrown exception will be handled by the Functions Runtime and will only fail
the individual invocation
throw err;
}
context.log(`Data from file: ${data}`);
}

Próximos passos
Para saber mais, consulte os recursos a seguir:
Práticas recomendadas para o Azure Functions
Referência do desenvolvedor do Azure Functions
Gatilhos e associações de Azure Functions
Visão geral do diagnóstico de Azure Functions
07/11/2019 • 5 minutes to read • Edit Online

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
24/10/2019 • 16 minutes to read • Edit Online

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.

CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

Assinatura Sua assinatura A assinatura com seu aplicativo de


funções.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

Grupo de recursos Seu grupo de recursos O grupo de recursos que contém seu
aplicativo de funções.

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

9/12/2019, 1:06:14 @ NO__T-0994 AM Bytes Particulares 212.189.184

9/12/2019, 1:06:30 @ NO__T-0010 AM Bytes Particulares 231.714.816

9/12/2019, 1:07:15 @ NO__T-0040 AM Bytes Particulares 210.591.744

9/12/2019, 1:12:16 @ NO__T-0285 AM Bytes Particulares 216.285.184

9/12/2019, 1:12:31 @ NO__T-0376 AM Bytes Particulares 235.806.720

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
07/11/2019 • 12 minutes to read • Edit Online

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
Para saber mais, consulte os recursos a seguir:
Como gerenciar conexões no Azure Functions
Práticas recomendadas do Serviço de Aplicativo do Azure
Trabalhe com Proxies do Azure Functions
08/11/2019 • 19 minutes to read • Edit Online

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.

{
"$schema": "http://json.schemastore.org/proxies",
"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:

{
"$schema": "http://json.schemastore.org/proxies",
"proxies": {
"proxy1": {
"matchCondition": {
"methods": [ "GET" ],
"route": "/api/{test}"
},
"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:

{
"$schema": "http://json.schemastore.org/proxies",
"proxies": {
"proxy1": {
"matchCondition": {
"methods": [ "GET" ],
"route": "/api/{test}"
},
"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
07/11/2019 • 17 minutes to read • Edit Online

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
05/11/2019 • 9 minutes to read • Edit Online

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:
1. Entre no Portal do Azure.
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:
1. Entre no Portal do Azure.
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
26/10/2019 • 6 minutes to read • Edit Online

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
Para saber mais, consulte os recursos a seguir:
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
Guia do desenvolvedor do Azure Functions
25/05/2018 • 12 minutes to read • Edit Online

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:

TIPO 1.X 2. X 1 OF ENTRADA SAÍDA

Armazenament ✔ ✔ ✔ ✔ ✔
o 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

Armazenament ✔ ✔ ✔ ✔
o de filas

SendGrid ✔ ✔ ✔
TIPO 1.X 2. X OF ENTRADA SAÍDA

Barramento de ✔ ✔ ✔ ✔
Serviço

SignalR ✔ ✔ ✔

Armazenament ✔ ✔ ✔ ✔
o de tabelas

Timer ✔ ✔ ✔

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.
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
Para obter mais informações, consulte os seguintes recursos:
Gatilhos e associações de Azure Functions
Codificar e testar o Azure Functions localmente
Práticas recomendadas para o Azure Functions
Referência do desenvolvedor de C# do Azure Functions
Referência do desenvolvedor de NodeJS do Azure Functions
Codificar e testar o Azure Functions localmente
24/10/2019 • 5 minutes to read • Edit Online

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
07/11/2019 • 53 minutes to read • Edit Online

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.
Uma assinatura ativa do Azure.
Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
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.

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 um projeto do Azure Functions
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
extremidade da função.

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#
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)"
}
}

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:

PROMPT VALOR DESCRIÇÃ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 Armazenamento do Azure.
PROMPT VALOR DESCRIÇÃO

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 MyStorageConnection O nome de uma configuração de


"local.setting.json" aplicativo que contém a cadeia de
conexão para a conta de
armazenamento. A
AzureWebJobsStorage configuração
contém a cadeia de conexão para a
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",
"queueName": "outqueue",
"connection": "MyStorageConnection"
}

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 .
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
TIPO 1.X 2. X OF ENTRADA SAÍDA

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 ✔ ✔ ✔

Armazenamento ✔ ✔ ✔ ✔
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:

PROMPT VALOR DESCRIÇÃO


PROMPT VALOR DESCRIÇÃO

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
armazenamento devem ter entre 3 e
24 caracteres e podem conter
apenas números e letras minúsculas.
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.

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.

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
Publicar em um aplicativo de funções existente substitui o conteúdo desse aplicativo no Azure.

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
aplicativo de funções.
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:
{
"IsEncrypted": false,
"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.
CONFIGURAÇÃO DESCRIÇÃO

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.

Funções de monitoramento
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.
CONFIGURAÇÃO VALOR SUGERIDO DESCRIÇÃO

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 aplicativo