Gatilhos e Associações do Azure Functions
Escreva uma função acionada por HTTP, adicione uma associação de saída para gravar no Armazenamento de Filas do Azure e compreenda o modelo de escalonamento automático do Plano de Consumo.
Gatilhos e Associações do Azure Functions é uma aula grátis de Azure Fundamentals no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Azure Fundamentals, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Azure Fundamentals inclui 4 aulas no total.
O que é o Azure Functions?
O Azure Functions é um serviço de computação sem servidor que permite executar pequenas unidades de código (funções) em resposta a eventos, sem gerenciar nenhuma infraestrutura. Você paga apenas pelo tempo de execução e pela memória usados enquanto a função é executada — não há custo quando a função está ociosa. O Functions é ideal para tarefas orientadas por eventos, APIs leves, trabalhos agendados e integração de serviços de nuvem sem um servidor persistente.
Gatilhos: o que inicia uma função
Cada Azure Function deve ter exatamente um gatilho que define o evento que faz com que ela seja executada. Entre os gatilhos comuns estão HTTP (solicitação HTTP recebida), Timer (agendamento CRON), Blob Storage (novo blob em um contêiner), Queue Storage (nova mensagem em uma fila), Event Hub (fluxo de eventos), Service Bus (mensagem de fila ou tópico) e Cosmos DB (feed de alterações). O gatilho recebe os dados do evento e os passa para o código da sua função.
// HTTP trigger function (JavaScript/Node.js)
module.exports = async function (context, req) {
const name = req.query.name || (req.body && req.body.name);
const message = name ? 'Hello, ' + name : 'Pass a name in the query or body';
context.res = {
status: 200,
body: { message }
};
};Function.json: configuração de gatilhos e associações
Em linguagens não compiladas (JavaScript, Python), um arquivo function.json no diretório de cada função declara seus gatilhos e associações. Esse arquivo mapeia fontes de eventos e saídas para parâmetros nomeados no código da função. Em C# e Java, as associações são declaradas usando atributos/anotações diretamente no código. O runtime do Functions lê a configuração e estabelece automaticamente as conexões com os serviços do Azure.
// function.json — HTTP trigger + Queue output binding
{
'bindings': [
{
'authLevel': 'function',
'type': 'httpTrigger',
'direction': 'in',
'name': 'req',
'methods': ['post']
},
{
'type': 'http',
'direction': 'out',
'name': 'res'
},
{
'type': 'queue',
'direction': 'out',
'name': 'outputQueue',
'queueName': 'processing-queue',
'connection': 'AzureWebJobsStorage'
}
]
}Associações de saída: gravação em serviços
As associações de saída permitem que sua função grave dados em serviços do Azure (Blob Storage, Queue Storage, Cosmos DB, Event Hub etc.) sem gerenciar SDKs ou cadeias de conexão. Basta atribuir um valor ao parâmetro da associação de saída, e o runtime do Functions cuidará da gravação. Isso reduz drasticamente o código repetitivo e desacopla sua função dos detalhes específicos da implementação do serviço do Azure.
// HTTP trigger with Queue output binding (Node.js)
module.exports = async function (context, req) {
const orderData = req.body;
// Write to queue via output binding -- no SDK needed!
context.bindings.outputQueue = JSON.stringify({
orderId: orderData.id,
timestamp: new Date().toISOString()
});
context.res = { status: 202, body: 'Order queued' };
};Gatilho de Timer com expressões CRON
O gatilho Timer executa uma função de acordo com um agendamento definido por uma expressão CRON. O Azure Functions usa um CRON de 6 partes: {seconds} {minutes} {hours} {day} {month} {day-of-week}. Use 0 0 * * * * para executar a cada hora, 0 0 0 * * * para executar diariamente à meia-noite ou 0 0 9-17 * * 1-5 para executar a cada hora durante o horário comercial, nos dias úteis. As funções Timer são úteis para trabalhos de limpeza, geração de relatórios e verificações de integridade.
// Timer trigger — runs every day at 02:00 UTC
// function.json binding:
// {
// 'type': 'timerTrigger',
// 'schedule': '0 0 2 * * *',
// 'name': 'myTimer'
// }
module.exports = async function (context, myTimer) {
const now = new Date().toISOString();
context.log('Daily cleanup started at', now);
// ... perform cleanup logic ...
context.log('Cleanup completed');
};Plano Consumption: escalabilidade sem servidor
No plano Consumption, o Azure Functions escala automaticamente de zero a centenas de instâncias com base na taxa de eventos dos gatilhos. Você paga apenas pela quantidade de execuções e pelos GB-segundos de memória consumidos — o primeiro milhão de execuções por mês é gratuito. O host do Functions pode escalar um gatilho HTTP para até 200 instâncias e um gatilho de fila para a quantidade de mensagens da fila processadas simultaneamente. A inicialização a frio (primeira execução após um período ocioso) adiciona uma breve latência, reduzida pelas instâncias pré-aquecidas do plano Premium.
# View billing details for a function app
az functionapp show \
--name myFunctionApp \
--resource-group MyRG \
--query '{name:name, plan:serverFarmId, state:state}'
# Create a Function App on Consumption plan
az functionapp create \
--name myFunctionApp \
--resource-group MyRG \
--consumption-plan-location eastus \
--runtime node \
--runtime-version 18 \
--storage-account mystorageaccountPlanos Premium e Dedicated
O plano Premium elimina as inicializações a frio mantendo instâncias pré-aquecidas, adiciona integração com a VNet e permite tempos limite de execução mais longos (até 60 minutos). O plano Dedicated (App Service) executa funções no mesmo plano do App Service que os aplicativos Web, sendo útil quando você precisa de custos previsíveis ou já possui recursos de computação do App Service disponíveis. Escolha Consumption para obter a verdadeira economia sem servidor; escolha Premium para funções sensíveis ao desempenho ou conectadas à VNet.
# Create a Function App on Premium plan (EP1)
az functionapp plan create \
--name MyPremiumPlan \
--resource-group MyRG \
--location eastus \
--sku EP1 \
--is-linux
az functionapp create \
--name myFunctionAppPremium \
--resource-group MyRG \
--plan MyPremiumPlan \
--runtime python \
--runtime-version 3.11 \
--storage-account mystorageaccountImplantação do Azure Functions
Implante o Azure Functions usando o Azure Functions Core Tools (func azure functionapp publish), a extensão do VS Code, a implantação ZIP por meio do Azure CLI ou um pipeline de CI/CD no Azure Pipelines ou no GitHub Actions. Em produção, implante sempre a partir de um pipeline, e não de uma máquina de desenvolvedor, para garantir que versões testadas e marcadas cheguem à produção. O runtime do Functions também oferece suporte à implantação de contêiner Docker para controle total do ambiente de execução.
# Local development: install Core Tools
npm install -g azure-functions-core-tools@4
# Start locally (triggers work against real Azure services)
func start
# Deploy to Azure
func azure functionapp publish myFunctionApp
# Or deploy via Azure CLI (ZIP deploy)
zip -r function.zip . --exclude '.git/*'
az functionapp deployment source config-zip \
--name myFunctionApp \
--resource-group MyRG \
--src function.zipConfigurações do aplicativo e referências do Key Vault
Os Function Apps armazenam a configuração em configurações do aplicativo — elas aparecem como variáveis de ambiente no código da função. Armazene cadeias de conexão, chaves de API e segredos como configurações do aplicativo. Em produção, use referências do Key Vault para que o valor seja armazenado no Key Vault e apenas referenciado pelo nome na configuração do aplicativo, mantendo os segredos fora do portal e dos artefatos de implantação. Habilite uma identidade gerenciada no Function App para autenticar-se no Key Vault sem credenciais.
# Set application settings
az functionapp config appsettings set \
--name myFunctionApp \
--resource-group MyRG \
--settings \
STORAGE_CONNECTION='@Microsoft.KeyVault(SecretUri=https://mykv.vault.azure.net/secrets/storage-conn/)' \
COSMOS_DB_URI='https://mycosmosdb.documents.azure.com'
# In function code, read as normal env var
# const storageConn = process.env['STORAGE_CONNECTION'];Monitoramento do Functions com o Application Insights
O Azure Functions integra-se automaticamente ao Application Insights quando você fornece uma chave de instrumentação ou uma cadeia de conexão. Cada execução de função é rastreada como uma solicitação, incluindo duração, sucesso ou falha e propriedades personalizadas. Use as Métricas ao vivo do Application Insights para acompanhar as execuções em tempo real durante os testes e o painel Falhas para diagnosticar erros com rastreamentos completos de exceções e chamadas de dependências.
# Connect Application Insights to a Function App
az functionapp config appsettings set \
--name myFunctionApp \
--resource-group MyRG \
--settings \
APPLICATIONINSIGHTS_CONNECTION_STRING='InstrumentationKey=xxxxxxxx;...'
# Custom telemetry in function code (Node.js)
const appInsights = require('applicationinsights');
appInsights.setup().start();
const client = appInsights.defaultClient;
client.trackEvent({ name: 'OrderProcessed', properties: { orderId: '123' } });Comportamento de simultaneidade e escalabilidade
Para funções acionadas por filas, o host do Functions processa várias mensagens em paralelo. Configure batchSize em host.json para controlar quantas mensagens uma única instância processa simultaneamente. Para gatilhos HTTP, a expansão adiciona novas instâncias automaticamente. Use maxConcurrentCalls (gatilhos do Service Bus) ou maxPollingInterval (gatilhos de fila) para ajustar o rendimento e evitar sobrecarregar serviços downstream, como bancos de dados, durante eventos de expansão.
// host.json — tune queue trigger concurrency
{
'version': '2.0',
'extensions': {
'queues': {
'batchSize': 16, // messages per instance
'newBatchThreshold': 8, // fetch more when < 8 remain
'maxPollingInterval': '00:00:02',
'visibilityTimeout': '00:05:00'
}
},
'functionTimeout': '00:10:00'
}Verificação rápida
Teste sua compreensão dos conceitos do Microsoft Azure Fundamentos (AZ-900) apresentados nesta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: os gatilhos definem o evento que inicia uma função (HTTP, Timer, Queue, Blob etc.); as vinculações de saída permitem que as funções gravem em serviços do Azure sem código do SDK; e o plano de Consumption oferece escalabilidade verdadeiramente sem servidor, com cobrança por execução, partindo de zero. A seguir, exploraremos as funções Durable para fluxos de trabalho com estado.
Perguntas Frequentes
A aula “Gatilhos e Associações do Azure Functions” é grátis?
Sim — o texto completo de “Gatilhos e Associações do Azure Functions” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Azure Fundamentals, atualize para CoddyKit PRO. O curso de Azure Fundamentals inclui 4 aulas no total.
O que vou aprender em “Gatilhos e Associações do Azure Functions”?
Escreva uma função acionada por HTTP, adicione uma associação de saída para gravar no Armazenamento de Filas do Azure e compreenda o modelo de escalonamento automático do Plano de Consumo. Você pratica Azure Fundamentals com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Azure Fundamentals?
Nenhuma experiência prévia é necessária. Azure Fundamentals no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Gatilhos e Associações do Azure Functions”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Azure Fundamentals?
Sim. Cada aula de Azure Fundamentals inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Gatilhos e Associações do Azure Functions
- Durable Functions para Fluxos de Trabalho com Estado
- Azure Logic Apps
- Event Grid e Arquitetura Orientada a Eventos