Azure Fundamentals · leksjon

Azure Functions-utløsere og bindinger

Skriv en HTTP-utløst funksjon, legg til en utgående binding som skriver til Azure Queue Storage, og forstå Consumption Plans modell for automatisk skalering.

Leksjon 1 av 413 trinn

Azure Functions-utløsere og bindinger er en gratis leksjon i Azure Fundamentals på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Azure Fundamentals, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Azure Fundamentals inneholder totalt 4 leksjoner.

Hva er Azure Functions?

Azure Functions er en serverless-datatjeneste som lar Dem kjøre små kodeenheter (functions) som svar på hendelser, uten at De trenger å administrere infrastruktur. De betaler bare for kjøretiden og minnet som brukes mens funksjonen kjører – det koster ingenting når funksjonen er inaktiv. Functions egner seg godt til hendelsesdrevne oppgaver, lette API-er, planlagte jobber og integrasjon av skytjenester uten en permanent server.

Utløsere: Hva starter en funksjon

Hver Azure Function må ha nøyaktig én trigger som definerer hendelsen som får den til å kjøre. Vanlige utløsere omfatter HTTP (innkommende HTTP-forespørsel), Timer (CRON-plan), Blob Storage (ny blob i en container), Queue Storage (ny melding i en kø), Event Hub (hendelsesstrøm), Service Bus (kø- eller emnemelding) og Cosmos DB (endringsfeed). Utløseren mottar hendelsesdataene og sender dem videre til funksjonskoden.

// 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: Konfigurasjon av utløsere og bindinger

I ikke-kompilerte språk (JavaScript, Python) erklærer en function.json-fil i hver funksjons katalog funksjonens utløsere og bindinger. Denne filen knytter hendelseskilder og utdata til navngitte parametere i funksjonskoden. For C# og Java erklæres bindinger ved hjelp av attributter/anmerkninger direkte i koden. Functions-kjøretiden leser konfigurasjonen og oppretter automatisk tilkoblingene til Azure-tjenestene.

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

Utdatabindinger: Skrive til tjenester

Utdatabindinger lar funksjonen skrive data til Azure-tjenester (Blob Storage, Queue Storage, Cosmos DB, Event Hub osv.) uten at De trenger å administrere SDK-er eller tilkoblingsstrenger. De tilordner ganske enkelt en verdi til utdatabindingsparameteren, så håndterer Functions-kjøretiden skrivingen. Dette reduserer mengden standardkode betydelig og frikobler funksjonen fra detaljene i implementasjonen av den spesifikke Azure-tjenesten.

// 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-utløser med CRON-uttrykk

Timer-utløseren kjører en funksjon etter en tidsplan som er definert av et CRON-uttrykk. Azure Functions bruker en CRON med seks deler: {seconds} {minutes} {hours} {day} {month} {day-of-week}. Bruk 0 0 * * * * hver time, 0 0 0 * * * ved midnatt hver dag eller 0 0 9-17 * * 1-5 hver time i arbeidstiden på hverdager. Timer-funksjoner er nyttige for oppryddingsjobber, rapportgenerering og helsesjekker.

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

Forbruksplan: Serverless-skalering

Med Consumption-planen skalerer Azure Functions automatisk fra null til hundrevis av instanser basert på frekvensen av utløsende hendelser. De betaler bare for antall kjøringer og GB-sekunder med brukt minne – den første millionen kjøringer per måned er gratis. Functions-verten kan skalere en HTTP-utløser til opptil 200 instanser og en køutløser til antallet kømeldinger som behandles samtidig. En kaldstart (første kjøring etter inaktivitet) medfører en kort forsinkelse, som kan reduseres med forhåndsoppvarmede instanser i Premium-planen.

# 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- og Dedicated-planer

Premium-planen eliminerer kalde starter ved å holde instanser forhåndsoppvarmet, legger til VNet-integrasjon og tillater lengre tidsavbrudd for kjøring (opptil 60 minutter). Dedicated-planen (App Service) kjører funksjoner på samme App Service-plan som webapper. Den er nyttig når De trenger forutsigbare kostnader eller har eksisterende App Service-databehandling som kan brukes. Velg Consumption for ekte serverless-økonomi og Premium for funksjoner som er følsomme for ytelse eller koblet til et 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

Distribuere Azure Functions

Distribuer Azure Functions ved hjelp av Azure Functions Core Tools (func azure functionapp publish), VS Code-utvidelsen, ZIP-distribusjon via Azure CLI eller en CI/CD-pipeline i Azure Pipelines eller GitHub Actions. I produksjon bør De alltid distribuere fra en pipeline i stedet for fra en utviklermaskin, slik at testede og taggede versjoner når produksjonen. Functions-kjøretiden støtter også distribusjon av Docker-containere for full kontroll over kjøretidsmiljøet.

# 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

Programinnstillinger og Key Vault-referanser

Function Apps lagrer konfigurasjon i programinnstillinger – disse vises som miljøvariabler i funksjonskoden. Lagre tilkoblingsstrenger, API-nøkler og hemmeligheter som programinnstillinger. I produksjon bør De bruke Key Vault-referanser, slik at verdien lagres i Key Vault og bare refereres til med navn i appinnstillingen. Dermed holdes hemmeligheter utenfor portalen og distribusjonsartefaktene. Aktiver en administrert identitet på Function App-en for å autentisere mot Key Vault uten legitimasjon.

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

Overvåke Functions med Application Insights

Azure Functions integreres automatisk med Application Insights når De oppgir en instrumenteringsnøkkel eller tilkoblingsstreng. Hver funksjonskjøring spores som en forespørsel, inkludert varighet, om den lyktes eller mislyktes, og egendefinerte egenskaper. Bruk Live Metrics i Application Insights til å følge kjøringer i sanntid under testing, og Failures-ruten til å diagnostisere feil med fullstendige unntaksspor og avhengighetskall.

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

Samtidighet og skaleringsatferd

For køutløste funksjoner behandler Functions-verten flere meldinger parallelt. Konfigurer batchSize i host.json for å styre hvor mange meldinger én instans behandler samtidig. For HTTP-utløsere legger utskalering automatisk til nye instanser. Bruk maxConcurrentCalls (Service Bus-utløsere) eller maxPollingInterval (køutløsere) til å justere gjennomstrømmingen og unngå å overbelaste underliggende tjenester som databaser under utskaleringshendelser.

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

Hurtigsjekk

Test forståelsen Deres av konseptene i Microsoft Azure Fundamentals (AZ-900) fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at utløsere definerer hendelsen som starter en funksjon (HTTP, tidsur, kø, blob og så videre), at utdatabindinger lar funksjoner skrive til Azure-tjenester uten SDK-kode, og at Consumption-planen gir ekte serverless-skalering med betaling per kjøring fra null. Neste tema er Durable Functions for tilstandsfulle arbeidsflyter.

Gratis å komme i gang

Lær deg Azure Fundamentals med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Azure Functions-utløsere og bindinger» gratis?

Ja – hele teksten i «Azure Functions-utløsere og bindinger» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Azure Fundamentals-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Azure Fundamentals inneholder totalt 4 leksjoner.

Hva lærer jeg i «Azure Functions-utløsere og bindinger»?

Skriv en HTTP-utløst funksjon, legg til en utgående binding som skriver til Azure Queue Storage, og forstå Consumption Plans modell for automatisk skalering. Du øver på Azure Fundamentals med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Azure Fundamentals?

Ingen tidligere erfaring er nødvendig. Azure Fundamentals på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Azure Functions-utløsere og bindinger»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Azure Fundamentals-leksjonen?

Ja. Alle Azure Fundamentals-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Azure Functions-utløsere og bindinger
Durable Functions for tilstandsbevisste arbeidsflyter
Azure Logic Apps
Event Grid og hendelsesdrevet arkitektur

← Tilbake til Azure Fundamentals