0Pricing
Azure Fundamentals · Lezione

Trigger e binding di Azure Functions

Scriva una funzione attivata tramite HTTP, aggiunga un binding di output per scrivere in Azure Queue Storage e comprenda il modello di ridimensionamento automatico del Consumption Plan.

Trigger e binding di Azure Functions è una lezione Azure Fundamentals gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Azure Fundamentals, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Azure Fundamentals include 4 lezioni in totale.

Che cosa sono Azure Functions?

Azure Functions è un servizio di calcolo serverless che consente di eseguire piccole unità di codice (funzioni) in risposta a eventi senza gestire alcuna infrastruttura. Lei paga solo il tempo di esecuzione e la memoria utilizzata durante l'esecuzione della funzione: quando la funzione è inattiva non ci sono costi. Functions è ideale per attività basate su eventi, API leggere, processi pianificati e integrazioni tra servizi cloud senza un server persistente.

Trigger: che cosa avvia una funzione

Ogni Azure Function deve avere esattamente un trigger che definisce l'evento responsabile della sua esecuzione. I trigger comuni includono HTTP (richiesta HTTP in ingresso), Timer (pianificazione CRON), Blob Storage (nuovo blob in un contenitore), Queue Storage (nuovo messaggio in una coda), Event Hub (flusso di eventi), Service Bus (messaggio di una coda o di un topic) e Cosmos DB (feed delle modifiche). Il trigger riceve i dati dell'evento e li passa al codice della funzione.

// 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: configurazione di trigger e associazioni

Nei linguaggi non compilati (JavaScript, Python), un file function.json nella directory di ogni funzione dichiara i relativi trigger e le associazioni. Questo file associa le origini degli eventi e gli output a parametri denominati nel codice della funzione. Per C# e Java, le associazioni vengono dichiarate direttamente nel codice usando attributi/annotazioni. Il runtime di Functions legge la configurazione e configura automaticamente le connessioni ai servizi 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'
    }
  ]
}

Associazioni di output: scrittura nei servizi

Le associazioni di output consentono alla funzione di scrivere dati nei servizi Azure (Blob Storage, Queue Storage, Cosmos DB, Event Hub e così via) senza gestire SDK o stringhe di connessione. È sufficiente assegnare un valore al parametro dell'associazione di output; il runtime di Functions gestisce la scrittura. In questo modo si riduce drasticamente il codice ripetitivo e si disaccoppia la funzione dai dettagli implementativi dello specifico servizio 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' };
};

Trigger Timer con espressioni CRON

Il trigger Timer esegue una funzione secondo una pianificazione definita da un'espressione CRON. Azure Functions usa una CRON composta da 6 parti: {seconds} {minutes} {hours} {day} {month} {day-of-week}. Usi 0 0 * * * * per l'esecuzione ogni ora, 0 0 0 * * * per mezzanotte ogni giorno oppure 0 0 9-17 * * 1-5 per l'esecuzione ogni ora durante l'orario lavorativo nei giorni feriali. Le funzioni Timer sono utili per attività di pulizia, generazione di report e controlli di integrità.

// 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');
};

Piano a consumo: scalabilità serverless

Con il piano a consumo, Azure Functions ridimensiona automaticamente il numero di istanze da zero a centinaia in base alla frequenza degli eventi dei trigger. Lei paga solo il numero di esecuzioni e i GB-secondo di memoria consumati: il primo milione di esecuzioni al mese è gratuito. L'host di Functions può ridimensionare un trigger HTTP fino a 200 istanze e un trigger di coda in base al numero di messaggi elaborabili contemporaneamente. Il cold start, ovvero la prima esecuzione dopo un periodo di inattività, aggiunge una breve latenza, mitigata dalle istanze preriscaldate del piano 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 mystorageaccount

Piani Premium e Dedicato

Il piano Premium elimina i cold start mantenendo istanze preriscaldate, aggiunge l'integrazione con VNet e consente timeout di esecuzione più lunghi (fino a 60 minuti). Il piano Dedicato (App Service) esegue le funzioni nello stesso piano App Service delle app web; è utile quando sono necessari costi prevedibili o si dispone già di risorse di calcolo App Service. Scelga Consumption per un'economia realmente serverless, oppure Premium per funzioni sensibili alle prestazioni o connesse a una 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 mystorageaccount

Distribuzione di Azure Functions

Distribuisca Azure Functions usando gli Azure Functions Core Tools (func azure functionapp publish), l'estensione VS Code, la distribuzione tramite ZIP deploy con Azure CLI oppure una pipeline CI/CD in Azure Pipelines o GitHub Actions. In produzione, esegua sempre la distribuzione da una pipeline anziché dal computer di uno sviluppatore, per garantire che in produzione arrivino versioni testate e contrassegnate. Il runtime di Functions supporta inoltre la distribuzione di container Docker per avere il pieno controllo dell'ambiente di runtime.

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

Impostazioni dell'applicazione e riferimenti a Key Vault

Le Function App memorizzano la configurazione nelle impostazioni dell'applicazione, che nel codice della funzione vengono visualizzate come variabili d'ambiente. Memorizzi le stringhe di connessione, le chiavi API e i segreti nelle impostazioni dell'applicazione. In produzione, usi i riferimenti a Key Vault, così il valore viene archiviato in Key Vault e nell'impostazione dell'app viene indicato solo il nome; in questo modo i segreti non vengono esposti nel portale né negli artefatti di distribuzione. Abiliti un'identità gestita nella Function App per eseguire l'autenticazione a Key Vault senza credenziali.

# 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'];

Monitoraggio di Functions con Application Insights

Azure Functions si integra automaticamente con Application Insights quando si fornisce una chiave di strumentazione o una stringa di connessione. Ogni esecuzione della funzione viene tracciata come una richiesta, includendo durata, esito positivo o negativo e proprietà personalizzate. Usi le Live Metrics di Application Insights per osservare le esecuzioni in tempo reale durante i test e il pannello Failures per diagnosticare gli errori con tracce complete delle eccezioni e chiamate alle dipendenze.

# 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 di concorrenza e scalabilità

Per le funzioni attivate da una coda, l'host di Functions elabora più messaggi in parallelo. Configuri batchSize in host.json per controllare quanti messaggi una singola istanza elabora contemporaneamente. Per i trigger HTTP, lo scale-out aggiunge automaticamente nuove istanze. Usi maxConcurrentCalls (trigger Service Bus) o maxPollingInterval (trigger di coda) per ottimizzare la velocità di elaborazione ed evitare di sovraccaricare i servizi downstream, come i database, durante gli eventi di scale-out.

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

Verifichi la Sua comprensione dei concetti di Microsoft Azure Fundamentals (AZ-900) trattati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che i trigger definiscono l'evento che avvia una funzione (HTTP, Timer, Queue, Blob e così via), i binding di output consentono alle funzioni di scrivere nei servizi Azure senza codice SDK e il piano Consumption offre una scalabilità serverless reale, con pagamento per esecuzione e possibilità di scalare da zero. Nel prossimo argomento esploreremo Durable Functions per i flussi di lavoro con stato.

Domande Frequenti

La lezione «Trigger e binding di Azure Functions» è gratuita?

Sì — il testo completo di «Trigger e binding di Azure Functions» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Azure Fundamentals, passa a CoddyKit PRO. Il corso Azure Fundamentals include 4 lezioni in totale.

Cosa imparerò in «Trigger e binding di Azure Functions»?

Scriva una funzione attivata tramite HTTP, aggiunga un binding di output per scrivere in Azure Queue Storage e comprenda il modello di ridimensionamento automatico del Consumption Plan. Eserciti Azure Fundamentals con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Azure Fundamentals?

Non è richiesta alcuna esperienza precedente. Azure Fundamentals su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Trigger e binding di Azure Functions»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Azure Fundamentals?

Sì. Ogni lezione Azure Fundamentals include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Trigger e binding di Azure Functions
  2. Durable Functions per workflow con stato
  3. Azure Logic Apps
  4. Event Grid e architettura event-driven
← Torna a Azure Fundamentals