Azure Fundamentals · Les

Triggers en bindings van Azure Functions

Schrijf een functie met een HTTP-trigger, voeg een outputbinding toe om naar Azure Queue Storage te schrijven en begrijp het automatische schaalmodel van het Consumption Plan.

Les 1 van 413 stappen

Triggers en bindings van Azure Functions is een gratis Azure Fundamentals-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Azure Fundamentals. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Azure Fundamentals bevat in totaal 4 lessen.

Wat zijn Azure Functions?

Azure Functions is een serverloze compute-service waarmee je kleine code-eenheden (functies) kunt uitvoeren als reactie op gebeurtenissen, zonder infrastructuur te beheren. Je betaalt alleen voor de uitvoeringstijd en het geheugen dat wordt gebruikt terwijl je functie wordt uitgevoerd — wanneer de functie inactief is, zijn er geen kosten. Functions zijn ideaal voor gebeurtenisgestuurde taken, lichte API's, geplande taken en het integreren van cloudservices zonder een permanente server.

Triggers: wat start een functie?

Elke Azure Function moet precies één trigger hebben die de gebeurtenis definieert waardoor de functie wordt uitgevoerd. Veelgebruikte triggers zijn HTTP (binnenkomend HTTP-verzoek), Timer (CRON-planning), Blob Storage (nieuwe blob in een container), Queue Storage (nieuw bericht in een wachtrij), Event Hub (gebeurtenissenstroom), Service Bus (bericht in een wachtrij of onderwerp) en Cosmos DB (wijzigingsfeed). De trigger ontvangt de gebeurtenisgegevens en geeft deze door aan je functiecode.

// 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: configuratie van triggers en bindings

In niet-gecompileerde talen (JavaScript, Python) declareert een bestand function.json in de map van elke functie de triggers en bindings. Dit bestand koppelt gebeurtenisbronnen en uitvoer aan benoemde parameters in je functiecode. Voor C# en Java worden bindings rechtstreeks in de code gedeclareerd met attributen/annotaties. De Functions-runtime leest de configuratie en stelt automatisch de verbindingen met Azure-services in.

// 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'
    }
  ]
}

Uitvoerbindings: schrijven naar services

Met uitvoerbindings kan je functie gegevens naar Azure-services schrijven (Blob Storage, Queue Storage, Cosmos DB, Event Hub enzovoort) zonder SDK's of verbindingsreeksen te beheren. Je wijst eenvoudig een waarde toe aan de parameter van de uitvoerbinding en de Functions-runtime verzorgt het schrijven. Hierdoor is veel minder standaardcode nodig en wordt je functie losgekoppeld van de specifieke implementatiedetails van de Azure-service.

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

Timer-trigger met CRON-expressies

De Timer-trigger voert een functie uit volgens een planning die door een CRON-expressie wordt gedefinieerd. Azure Functions gebruikt een CRON-indeling met 6 delen: {seconds} {minutes} {hours} {day} {month} {day-of-week}. Gebruik 0 0 * * * * voor elk uur, 0 0 0 * * * voor dagelijks om middernacht of 0 0 9-17 * * 1-5 voor elk uur tijdens kantooruren op werkdagen. Timer-functies zijn handig voor opruimtaken, het genereren van rapporten en statuscontroles.

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

Verbruiksplan: serverloos schalen

Met het Consumption-plan schaalt Azure Functions automatisch van nul naar honderden instanties op basis van de snelheid waarmee triggergebeurtenissen binnenkomen. Je betaalt alleen voor het aantal uitvoeringen en de verbruikte GB-seconden aan geheugen — de eerste 1 miljoen uitvoeringen per maand zijn gratis. De Functions-host kan een HTTP-trigger opschalen naar maximaal 200 instanties en een wachtrijtrigger naar het aantal wachtrijberichten dat gelijktijdig wordt verwerkt. Een koude start (de eerste uitvoering na inactiviteit) veroorzaakt een korte vertraging, die wordt beperkt door vooraf opgestarte instanties in het Premium-plan.

# 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

Premium- en Dedicated-plannen

Het Premium-plan voorkomt koude starts door vooraf opgestarte instanties beschikbaar te houden, voegt VNet-integratie toe en staat langere uitvoeringstime-outs toe (maximaal 60 minuten). Het Dedicated-plan (App Service) voert functies uit op hetzelfde App Service-plan als webapps. Dit is handig wanneer je voorspelbare kosten nodig hebt of bestaande App Service-compute wilt gebruiken. Kies Consumption voor echte serverloze kostenstructuur en Premium voor functies waarbij prestaties belangrijk zijn of die met een VNet zijn verbonden.

# 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

Azure Functions implementeren

Implementeer Azure Functions met de Azure Functions Core Tools (func azure functionapp publish), de VS Code-extensie, ZIP-implementatie via de Azure CLI of een CI/CD-pijplijn in Azure Pipelines of GitHub Actions. Implementeer in productie altijd vanuit een pijplijn in plaats van vanaf de computer van een ontwikkelaar, zodat geteste en getagde versies de productie bereiken. De Functions-runtime ondersteunt ook implementatie van Docker-containers voor volledige controle over de runtimeomgeving.

# 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

Applicatie-instellingen en Key Vault-verwijzingen

Function Apps slaan configuratie op in applicatie-instellingen — deze verschijnen als omgevingsvariabelen in je functiecode. Sla verbindingsreeksen, API-sleutels en geheimen op als applicatie-instellingen. Gebruik in productie Key Vault-verwijzingen, zodat de waarde in Key Vault wordt opgeslagen en in de app-instelling alleen op naam wordt verwezen. Zo blijven geheimen buiten de portal en implementatieartefacten. Schakel een beheerde identiteit in voor de function-app om zonder referenties te authenticeren bij Key Vault.

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

Functions monitoren met Application Insights

Azure Functions integreert automatisch met Application Insights wanneer je een instrumentatiesleutel of verbindingsreeks opgeeft. Elke uitvoering van een functie wordt bijgehouden als een aanvraag, inclusief duur, geslaagd/mislukt en aangepaste eigenschappen. Gebruik de Live Metrics van Application Insights om uitvoeringen tijdens het testen in realtime te bekijken en het deelvenster Failures om fouten te analyseren met volledige uitzonderingssporen en aanroepen van afhankelijkheden.

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

Gelijktijdigheid en schaalgedrag

Bij functies die door een wachtrij worden getriggerd, verwerkt de Functions-host meerdere berichten parallel. Configureer batchSize in host.json om te bepalen hoeveel berichten één instantie gelijktijdig verwerkt. Voor HTTP-triggers voegt het uitschalen automatisch nieuwe instanties toe. Gebruik maxConcurrentCalls (Service Bus-triggers) of maxPollingInterval (wachtrijtriggers) om de verwerkingscapaciteit af te stemmen en te voorkomen dat downstreamservices zoals databases tijdens uitschalingsgebeurtenissen worden overbelast.

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

Korte kennistest

Test je begrip van de concepten uit Microsoft Azure Fundamentals (AZ-900) uit deze les.

Beantwoord dit in de interactieve les

Samenvatting van de les

In deze les heb je geleerd dat triggers de gebeurtenis definiëren die een functie start (HTTP, Timer, Queue, Blob enzovoort), dat outputbindingen functies in staat stellen om naar Azure-services te schrijven zonder SDK-code en dat het Consumption-plan echt serverloos schalen van nul mogelijk maakt, waarbij je per uitvoering betaalt. Hierna bekijken we Durable Functions voor stateful workflows.

Gratis beginnen

Leer Azure Fundamentals met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 30
Lessen: 120

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Triggers en bindings van Azure Functions” gratis?

Ja — de volledige tekst van “Triggers en bindings van Azure Functions” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Azure Fundamentals wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Azure Fundamentals bevat in totaal 4 lessen.

Wat leer ik in “Triggers en bindings van Azure Functions”?

Schrijf een functie met een HTTP-trigger, voeg een outputbinding toe om naar Azure Queue Storage te schrijven en begrijp het automatische schaalmodel van het Consumption Plan. Je oefent met Azure Fundamentals door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Azure Fundamentals te beginnen?

Ervaring vooraf is niet nodig. Azure Fundamentals op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Triggers en bindings van Azure Functions”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Azure Fundamentals?

Ja. Elke les over Azure Fundamentals bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Triggers en bindings van Azure Functions
Durable Functions voor stateful workflows
Azure Logic Apps
Event Grid en eventgedreven architectuur

← Terug naar Azure Fundamentals