Maak gebruik van afhankelijkheden op OS-niveau via containers met Azure Functions Flex Consumption

Important

Deze functie is beschikbaar als preview-versie. Previewmogelijkheden kunnen veranderen.

Door gebruik te maken van ondersteuning voor afhankelijkheid op OS-niveau via containers, kunt u Flex Consumer-functie-apps draaien die meer nodig hebben dan alleen applicatiecode en taalpakketten in hun uitvoeringsomgeving. U levert een Linux-containerimage die de applicatie en de vereiste taal- en besturingssysteemafhankelijkheden bevat. Azure blijft de Functions-host, trigger-integratie, routering en schaalbaarheid leveren.

Overview

Je bouwt een Linux-containerimage die je functiecode, een ondersteunde Functions-taalwerker, taal- en applicatieafhankelijkheden, en de systeempakketten, native bibliotheken, uitvoerbare bestanden, lettertypen, certificaten of andere bestanden bevat die je app tijdens runtime nodig heeft.

Azure draait en patcht de Functions-host en beheert routering, triggerintegratie en schaling buiten het image. Deze scheiding stelt u in staat de worker-omgeving aan te passen, terwijl de oppervlakte van de image wordt verkleind en de noodzaak wegneemt om de Functions-host zelf te verpakken, te beveiligen en bij te werken.

Flex Consumption gebruikt een containermodel met alleen een worker-container. Je image is geen willekeurige webcontainer. Het is ook geen complete Function App-afbeelding, die de Functions-host, taalwerker, applicatie en afhankelijkheden samenvoegt voor een andere hostingoptie.

Voor een volledig voorbeeld dat een afhankelijkheid op OS-niveau verpakt in een alleen voor werkers bestemde containerafbeelding, zie het Azure Functions Flex Consumption .NET-voorbeeld voor geïsoleerde containers.

Voor een volledig voorbeeld dat een afhankelijkheid op OS-niveau verpakt in een alleen voor werkers bestemde containerafbeelding, zie het Azure Functions Flex Consumption Python-containervoorbeeld.

Voor een volledig voorbeeld dat een afhankelijkheid op OS-niveau verpakt in een worker-only container-image, zie het Azure Functions Flex Consumption Go-containervoorbeeld.

Voor een volledig voorbeeld dat een afhankelijkheid op OS-niveau verpakt in een worker-only container-image, zie het voorbeeld van Azure Functions Flex Consumption Node.js container.

Benefits

  • Verpak de applicatie, language worker, taalafhankelijkheden en OS-niveauafhankelijkheden in één versie-image.
  • Kies wanneer u worker-, taalruntime- en afhankelijkheidsupdates wilt adopteren door de image opnieuw op te bouwen, te testen en opnieuw uit te rollen.
  • Houd de Functions-host, trigger-integratie, routering en schaling buiten de image, zodat deze door Azure worden beheerd en gepatcht.
  • Beperk de componenten die je in je afbeelding moet opnemen, beveiligen en onderhouden in vergelijking met een volledige Function App-afbeelding.

Wanneer gebruikt u deze functie

Gebruik containers voor OS-niveau afhankelijkheden van Flex Consumption wanneer:

  • Je Flex Consumption-app vereist afhankelijkheden die je niet alleen via de taalpakketmanager kunt krijgen.
  • Je kunt een Linux-image bouwen, scannen, patchen, testen en publiceren.
  • U kunt de geselecteerde basisimage en de versie van de taalworker in het image behouden.

Containerhostingopties vergelijken

Kies het hostingmodel dat aansluit bij het deel van de runtime dat u wilt beheren.

Capability Afbeelding van Flex Consumption container Elastic Premium ofwel Dedicated (App Service) aangepaste image Functies op Azure Container Apps
Image contract Alleen worker Complete Function App-afbeelding Complete Function App-afbeelding
Functions host/runtime Geleverd, beheerd en gepatcht door Azure buiten uw image Opgenomen in uw image, meestal vanuit een basisimage van Functions Opgenomen in je image
Uw afbeelding bevat App, één language worker, taal-/applicatieafhankelijkheden en OS-pakketten Functions host, worker, app en afhankelijkheden Functions host, worker, app en afhankelijkheden
Scaling door Functions beheerde Flex Consumption-schaal Door Functions beheerde Premium-schaling of schaling van het App Service-plan Container Apps schalen
Billing Standaard Flex Consumption facturering Elastic Premium- of App Service-abonnementsfacturering Container-apps facturering
Beste pasvorm Voeg afhankelijkheden op OS-niveau toe terwijl het Flex serverless platformcontract behouden blijft Een volledige Functions-container beheren op App Service-infrastructuur Volledige Functions-containers uitvoeren met de mogelijkheden van Container Apps

Raadpleeg ondersteuning voor Linux-containers in Azure Functions voor meer informatie over volledige Function App-containerinstallatiekopieën.

Architectuur en verantwoordelijkheidsafbakening

Een gebeurtenis of HTTP-verzoek bereikt eerst het door Azure beheerde Functions-platform. Azure voert de host en runtime van Functions uit, evalueert triggers, routet aanroepen en bepaalt wanneer instanties worden toegevoegd of verwijderd. Wanneer een aanroep klaar is, stuurt het platform deze naar de Functions language worker in uw image. De language worker laadt uw functie-app en uw app kan de taal-, applicatie- en afhankelijkheden op besturingssysteemniveau gebruiken die in de image zijn verpakt.

Je image bevat de Functions-host niet en vervangt deze niet, implementeert geen trigger-routing en beheert geen platformschaling. Je onderhoudt de applicatie, de language worker, de basisimage en afhankelijkheden binnen de afbeelding. Microsoft onderhoudt en werkt de componenten van het Functions-platform buiten de installatiekopie bij.

De actieve Functions-taalwerker moet een van de werkers zijn die in de preview-ondersteuningstabel staan vermeld. De preview ondersteunt het niet om deze te vervangen door een willekeurige, door de klant ontwikkelde taalwerker of aangepaste handler. De image kan andere runtimes of uitvoerbare bestanden bevatten, zoals een Rust-component die wordt aangeroepen door een ondersteunde functie, als applicatieafhankelijkheden. De beperking tot één worker is van toepassing op actieve Functions-taalwerkers, niet op aanvullende runtimes of tools die bij de app zijn geleverd.

Preview-ondersteuning voor talen

De preview ondersteunt de volgende Functions-taalwerkers. Selecteer bovenaan het artikel uw taal voor ondersteunde runtimeversies, informatie over workercompatibiliteit en een voorbeeld-Dockerfile.

Functietaal Hoe de worker wordt opgenomen
.NET geïsoleerd Opgenomen via de NuGet-afhankelijkheden en publicatie-output van de applicatie
Python Toegevoegd als Microsoft-werkartefact specifiek voor de Python-versie
Node.js Toegevoegd als een door Microsoft gepubliceerd Node.js worker-artefact
Go Opgenomen via de Go worker SDK en gecompileerd in de applicatiebinaire

Andere Functions-taalwerkers worden tijdens de preview niet ondersteund.

Prerequisites

Voordat u begint, hebt u het volgende nodig:

  • Een applicatie die een ondersteunde previewtaal gebruikt.
  • Een Docker-compatibele image-buildomgeving.
  • Een Linux- of taalgebaseerde image die je kunt onderhouden.
  • De applicatiebron en de taalafhankelijkheden daarvan.
  • De vereiste OS-pakketten, native bibliotheken, lettertypen, drivers of tools.
  • Toegang tot een containerregister.
  • Toestemming om images te bouwen, te scannen, te pushen en te implementeren.

De previewversie ondersteunt Linux-amd64afbeeldingen.

Begrijp het Flex Consumption containermodel

Uw afbeelding is verantwoordelijk voor:

  • De applicatiepayload.
  • Eén ondersteunde taalworker voor Functions.
  • Taal- en applicatieafhankelijkheden.
  • Afhankelijkheden op OS-niveau.
  • De Linux- of taalbasisafbeelding die u selecteert.
  • Beeldbeveiliging, kwetsbaarheidsherstel en expliciete componentversies.

Azure is verantwoordelijk voor:

  • De host van Functions.
  • Routing en trigger-integratie.
  • Door Functions beheerde schaling.
  • Platformcomponenten buiten je image.

Met Flex Consumption kun je het Linux- of taalgebaseerde image kiezen dat het beste aansluit bij je applicatie- en organisatiebehoeften. Bouw voort op die afbeelding door een ondersteunde Functions-taalwerker, uw applicatie en de bijbehorende afhankelijkheden toe te voegen volgens dit worker-only containermodel. Microsoft biedt versiegebonden worker-artefacten en voorbeeld-Dockerbestanden om u te helpen een compatibele image te maken, terwijl Azure de Functions-host buiten uw image beheert.

Worker startup is taalspecifiek. Gebruik het voorbeeld-Dockerfile voor uw taal in plaats van een entrypoint uit een andere taal te kopiëren. Het platform levert de worker-RPC-verbindingsargumenten en de applicatiemap. Uw image start de taalwerker- of applicatiebinary direct; het installeert of start de Functions-host niet en bevat geen platform-endpointconfiguratie.

Omgevingsvariabelen en scriptroot

U configureert geen omgevingsvariabelen voor de Functions-host of de workerverbinding. Het platform injecteert de worker-identiteit, verbinding, protocol en bootstrap-waarden die de taalwerker nodig heeft om te communiceren met de door Azure beheerde Functions-host.

Wanneer uw Flex Consumption-app een containerafbeelding gebruikt, configureer dan de app-instelling AzureWebJobsScriptRoot=/home/site/wwwroot. Je image moet de functieapplicatie op dat pad plaatsen. Azure injecteert de instelling in de container tijdens runtime, zodat u de instelling niet als ENV-instructie hoeft te declareren in de Dockerfile. U kunt de andere app-instellingen blijven gebruiken die door uw applicatie vereist zijn.

Voeg FUNCTIONS_WORKER_RUNTIME of FUNCTIONS_EXTENSION_VERSION niet toe aan een Flex Consumption-app die gebruikmaakt van een containerimage. Het platform beheert deze runtime-details buiten uw image.

Haal de language worker op

Gebruik de ondersteunde workerreferentie die voor uw taal is gedocumenteerd. De Python- en Node.js-voorbeelden gebruiken Microsoft-beheerde aka.ms-referenties die wijzen op het nieuwste ondersteunde worker-artefact. Hun implementatietooling resolveert het huidige artefact of hasht het zodat een worker-update de image build-invoer verandert.

Verifieer gedownloade werkartefacten met behulp van de gepubliceerde SHA-256-checksum. Wanneer een floating worker-referentie opschuift, herbouw, test, push en herimplementeer de image voordat de bijgewerkte worker wordt geadopteerd. Specificeer voor een worker die via een applicatieafhankelijkheid wordt geleverd de versie van de afhankelijkheid in het applicatieproject.

.NET geïsoleerd

De preview ondersteunt het geïsoleerde worker-model van .NET op .NET 10 en .NET 11. Een geïsoleerde .NET-applicatie bevat de Functions worker via zijn normale NuGet-afhankelijkheden en build-output. De worker wordt niet als een apart artefact gepubliceerd voor elke ondersteunde .NET-runtimeversie. Specificeer de Microsoft.Azure.Functions.Worker- en gerelateerde pakketversies in het project, en publiceer de applicatie in /home/site/wwwroot.

Gebruik de nieuwste versie van Azure.Functions.Sdk als project-SDK. Voor bestaande projecten, volg Migreren naar Azure.Functions.Sdk.

Gebruik de volgende minimale pakketversies:

  • Microsoft.Azure.Functions.Worker versie 2.53.0-preview.1 of hoger.
  • Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCoreversie 2.1.2-preview.1 of hoger, als uw app gebruikmaakt van ASP.NET Core-integratie.

Important

Gebruik een ondersteunde .NET-versie. U bent verantwoordelijk voor het selecteren en onderhouden van een ondersteunde .NET-runtime-image en compatibele afhankelijkheden van de Functions-worker en applicatie.

Voor de volledige applicatie- en implementatiebestanden, zie het voorbeeld van de geïsoleerde container van Azure Functions Flex Consumption .NET.

.NET geïsoleerde voorbeeld-Dockerfile

De volgende voorbeeldversie van Dockerfile publiceert de geïsoleerde .NET-applicatie en kopieert de publicatie-uitvoer naar een .NET 10 runtime-image:

FROM mcr.microsoft.com/dotnet/sdk:10.0-noble AS build

WORKDIR /src
COPY NuGet.config FlexDotnetWorker.csproj ./
RUN dotnet restore FlexDotnetWorker.csproj --runtime linux-x64 -p:PublishReadyToRun=true

COPY *.cs host.json ./

RUN dotnet publish FlexDotnetWorker.csproj --configuration Release --runtime linux-x64 --self-contained false \
    --no-restore -p:PublishReadyToRun=true --output /publish \
    && rm -f /publish/worker.config.json /publish/functions.metadata

FROM mcr.microsoft.com/dotnet/aspnet:10.0-noble

WORKDIR /home/site/wwwroot
COPY --from=build /publish/ ./

USER $APP_UID
ENTRYPOINT ["dotnet", "FlexDotnetWorker.dll"]

Dit voorbeeld richt zich op .NET 10. Wanneer u een andere ondersteunde .NET-versie selecteert, werkt u beide .NET-base-image-tags samen bij en valideert u de versies van het applicatie- en Functions Worker-pakket.

Python

De preview ondersteunt Python 3.13 tot en met Python 3.15. Een Python-image bevat de applicatie, Python-afhankelijkheden, afhankelijkheden op OS-niveau en een ondersteund Python Functions-werkartefact. Het worker-artefact moet overeenkomen met de Python-runtimeversie in de afbeelding.

Important

Gebruik een ondersteunde Python-versie en het bijbehorende worker-artefact. Combineer geen worker-artefact voor één Python-versie met een andere Python-runtimeversie.

Begin met het voorbeeld van Dockerfile in het Azure Functions Flex Consumption Python-containervoorbeeld.

De voorbeeldapplicatie gebruikt azure-functions==2.3.0. Het Python Dockerfile downloadt de momenteel ondersteunde Python-werker van een door Microsoft beheerde aka.ms referentie, verifieert het gedownloade artefact aan de hand van de gepubliceerde SHA-256-checksum en extraheert het in de image. Het entrypoint start de Python-worker direct.

Python Dockerfile

De volgende waarden geven de ondersteunde basisimage en de floating worker reference aan voor elke Python-versie:

Python-versie Basisafbeelding Werknemerreferentie
3.13 python:3.13-slim-bookworm https://aka.ms/azurefunctions/releases/python/3.13/worker/latest/azure-functions-python-worker-py313-linux-x64.tar.gz
3,14 python:3.14-slim-bookworm https://aka.ms/azurefunctions/releases/python/3.14/worker/latest/azure-functions-python-worker-py314-linux-x64.tar.gz
3.15 python:3.15-slim-bookworm https://aka.ms/azurefunctions/releases/python/3.15/worker/latest/azure-functions-python-worker-py315-linux-x64.tar.gz

Dit voorbeeld richt zich op Python 3.15. Maak een bestand worker-release-url.txt aan dat de Python 3.15-werkreferentie bevat uit de voorgaande tabel. Wanneer u Python 3.13 of 3.14 selecteert, werk dan de basisafbeelding, de werkreferentie en de naam van het werkarchief samen bij.

FROM python:3.15-slim-bookworm AS build

COPY worker-release-url.txt /tmp/worker-release-url.txt

RUN python -c "from pathlib import Path; from urllib.request import urlretrieve; url = Path('/tmp/worker-release-url.txt').read_text(encoding='utf-8').strip(); latest = 'https://aka.ms/azurefunctions/releases/python/3.15/worker/latest/azure-functions-python-worker-py315-linux-x64.tar.gz'; archive = '/tmp/azure-functions-python-worker-py315-linux-x64.tar.gz'; urlretrieve(latest, archive); urlretrieve(latest + '.sha256', archive + '.sha256'); urlretrieve(url + '.sha256', archive + '.expected.sha256')" \
    && cd /tmp \
    && cmp azure-functions-python-worker-py315-linux-x64.tar.gz.sha256 azure-functions-python-worker-py315-linux-x64.tar.gz.expected.sha256 \
    && sha256sum --check --strict azure-functions-python-worker-py315-linux-x64.tar.gz.sha256 \
    && mkdir -p /opt/functions-worker \
    && tar -xzf azure-functions-python-worker-py315-linux-x64.tar.gz -C /opt/functions-worker \
    && rm azure-functions-python-worker-py315-linux-x64.tar.gz azure-functions-python-worker-py315-linux-x64.tar.gz.sha256 azure-functions-python-worker-py315-linux-x64.tar.gz.expected.sha256

COPY requirements.txt /tmp/requirements.txt
RUN --mount=type=secret,id=pip_config,target=/etc/pip.conf \
    python -m pip install --no-cache-dir --only-binary=:all: \
    --target /home/site/wwwroot/.python_packages/lib/site-packages \
    -r /tmp/requirements.txt

FROM python:3.15-slim-bookworm

RUN groupadd --gid 10001 app \
    && useradd --uid 10001 --gid 10001 --create-home --shell /usr/sbin/nologin app

WORKDIR /home/site/wwwroot
COPY --from=build /opt/functions-worker/ /opt/functions-worker/
COPY --from=build /tmp/worker-release-url.txt /opt/functions-worker-release-url.txt
COPY --from=build /home/site/wwwroot/.python_packages/ ./.python_packages/
COPY function_app.py host.json ./

USER 10001:10001
ENTRYPOINT ["python", "/opt/functions-worker/worker.py"]

De Azure Sample zet de floating worker-verwijzing om naar de geversioneerde GitHub-release-URL voordat de afbeeldingscontext wordt gestaged. Het Dockerfile vereist dat de checksum van die geselecteerde release overeenkomt met de checksum die momenteel via aka.ms wordt gepubliceerd, waarna het archief wordt geverifieerd. Als de verwijzingen het niet eens zijn, mislukt de build.

Bouw en push de image vanuit de map die de Dockerfile- en applicatiebestanden bevat. Dit voorbeeld gebruikt Azure Container Registry en systeemtoegewezen identiteit:

az acr login --name <ACR_NAME>

docker build --platform linux/amd64 --progress plain \
  -f Dockerfile \
  -t <ACR_NAME>.azurecr.io/<REPOSITORY>:python315 .

docker push <ACR_NAME>.azurecr.io/<REPOSITORY>:python315

az functionapp create -g <RESOURCE_GROUP> -n <APP_NAME> -s <STORAGE_ACCOUNT> \
  --flexconsumption-location <REGION> \
  --deployment-image <ACR_NAME>.azurecr.io/<REPOSITORY>:python315 \
  --deployment-image-auth-type SystemAssignedIdentity \
  --assign-identity [system] --role AcrPull --scope <ACR_RESOURCE_ID>

az functionapp deployment config show -g <RESOURCE_GROUP> -n <APP_NAME>

Go

De preview ondersteunt Go 1.27. Een Go-image bevat de applicatie, afhankelijkheden op OS-niveau en de ondersteunde Go Functions-werker en SDK die zijn gecompileerd in de applicatiebinary. De worker wordt niet als een afzonderlijk artefact gepubliceerd voor elke ondersteunde Go-versie.

Important

Gebruik een ondersteunde Go-versie. Je bent verantwoordelijk voor het compileren van de applicatie met een ondersteunde Go-toolchain en een compatibele Go Functions worker SDK-versie.

Begin met het voorbeeld-Dockerfile in het Azure Functions Flex Consumption Go-containervoorbeeld.

Het voorbeeldbestand go.mod geeft github.com/azure/azure-functions-golang-worker versie v1.0.2 op. De Go Dockerfile gebruikt een meerfasige build en start de gecompileerde applicatiebinary direct.

Go Dockerfile

FROM golang:1.27-bookworm AS build
WORKDIR /src

COPY go.mod go.sum ./
RUN go mod download

COPY *.go ./
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
    go build -mod=readonly -trimpath -ldflags="-s -w" -o /out/app .

FROM ubuntu:24.04

WORKDIR /home/site/wwwroot
COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
COPY --from=build --chmod=0555 /out/app ./app
COPY host.json ./

USER 10001:10001
ENTRYPOINT ["/home/site/wwwroot/app"]

Bouw en push de image vanuit de map die de Dockerfile- en applicatiebestanden bevat. Dit voorbeeld gebruikt Azure Container Registry en systeemtoegewezen identiteit:

az acr login --name <ACR_NAME>

docker build --platform linux/amd64 --progress plain \
  -f go.Dockerfile \
  -t <ACR_NAME>.azurecr.io/<REPOSITORY>:go127 .

docker push <ACR_NAME>.azurecr.io/<REPOSITORY>:go127

az functionapp create -g <RESOURCE_GROUP> -n <APP_NAME> -s <STORAGE_ACCOUNT> \
  --flexconsumption-location <REGION> \
  --deployment-image <ACR_NAME>.azurecr.io/<REPOSITORY>:go127 \
  --deployment-image-auth-type SystemAssignedIdentity \
  --assign-identity [system] --role AcrPull --scope <ACR_RESOURCE_ID>

az functionapp deployment config show -g <RESOURCE_GROUP> -n <APP_NAME>

Node.js

De preview ondersteunt Node.js 24. Een Node.js-image bevat de applicatie, Node.js afhankelijkheden, afhankelijkheden op OS-niveau en een ondersteund Node.js Functions-werkartefact. De worker wordt niet als een apart artefact gepubliceerd voor elke ondersteunde Node.js runtime-versie.

Important

Gebruik een ondersteunde Node.js versie. U bent verantwoordelijk voor het selecteren en onderhouden van een ondersteunde Node.js-basisimage en compatibele afhankelijkheden van Functions-werkers en applicaties.

Begin met het voorbeeld JavaScript of TypeScript Dockerfile in het Azure Functions Flex Consumption Node.js containervoorbeeld.

De voorbeeldapplicatie gebruikt @azure/functions versie 4.17.0. De Node.js Dockerfile downloadt de momenteel ondersteunde Node.js worker van een Microsoft-beheerde aka.ms referentie en extraheert deze naar de image. De voorbeeldimplementatietool berekent de SHA-256-waarde van het gedownloade artefact, neemt die waarde op in de image-context hash en geeft deze door aan de image-build voor verificatie. Het entrypoint van de image start de Node.js worker direct.

Node.js Dockerfile

De volgende Dockerfiles gebruiken de lay-out van de voorbeeldprojecten voor JavaScript en TypeScript. Werk de COPY commando- en bouwstappen bij zodat ze overeenkomen met de directorystructuur en uitvoer van je applicatie. Voor TypeScript compileert het voorbeeld de applicatie en kopieert het gegenereerde JavaScript van dist. De dist directory is een voorbeeldconventie, geen vereiste van het Flex Consumption containermodel. Zorg ervoor dat het main veld in package.json de gegenereerde JavaScript-bestanden identificeert.

FROM node:24-bookworm-slim AS worker

ARG FUNCTIONS_NODE_WORKER_SHA256

ADD --checksum=sha256:${FUNCTIONS_NODE_WORKER_SHA256} \
    https://aka.ms/azurefunctions/releases/node/worker/latest/worker.tar.gz \
    /tmp/worker.tar.gz

RUN mkdir -p /opt/functions-worker \
    && tar -xzf /tmp/worker.tar.gz -C /opt/functions-worker \
    && rm /tmp/worker.tar.gz

FROM node:24-bookworm-slim AS dependencies
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund

FROM node:24-bookworm-slim
WORKDIR /home/site/wwwroot
COPY --from=worker /opt/functions-worker/ /opt/functions-worker/
COPY --from=dependencies /app/node_modules/ ./node_modules/
COPY package.json host.json ./
COPY src/ ./src/

USER node
ENTRYPOINT ["node", "/opt/functions-worker/dist/src/nodejsWorker.js"]

Bouw en push de image vanuit de map die de Dockerfile- en applicatiebestanden bevat. Dit voorbeeld gebruikt Azure Container Registry en systeemtoegewezen identiteit:

(
  set -e

  az acr login --name <ACR_NAME>

  WORKER_URL=https://aka.ms/azurefunctions/releases/node/worker/latest/worker.tar.gz
  WORKER_FILE=azure-functions-nodejs-worker.tar.gz
  WORKER_DIR=$(mktemp -d)

  trap 'rm -f -- "$WORKER_DIR/$WORKER_FILE" "$WORKER_DIR/$WORKER_FILE.sha256"; rmdir -- "$WORKER_DIR"' EXIT

  curl --fail --location "$WORKER_URL" \
    --output "$WORKER_DIR/$WORKER_FILE"
  curl --fail --location "${WORKER_URL}.sha256" \
    --output "$WORKER_DIR/$WORKER_FILE.sha256"

  (
    cd "$WORKER_DIR"
    sha256sum --check --strict "$WORKER_FILE.sha256"
  )

  FUNCTIONS_NODE_WORKER_SHA256=$(
    sha256sum "$WORKER_DIR/$WORKER_FILE" | cut -d ' ' -f 1
  )

  docker build --platform linux/amd64 --progress plain \
    -f node24.Dockerfile \
    --build-arg FUNCTIONS_NODE_WORKER_SHA256="$FUNCTIONS_NODE_WORKER_SHA256" \
    -t <ACR_NAME>.azurecr.io/<REPOSITORY>:node24 .

  docker push <ACR_NAME>.azurecr.io/<REPOSITORY>:node24

  az functionapp create -g <RESOURCE_GROUP> -n <APP_NAME> -s <STORAGE_ACCOUNT> \
    --flexconsumption-location <REGION> \
    --deployment-image <ACR_NAME>.azurecr.io/<REPOSITORY>:node24 \
    --deployment-image-auth-type SystemAssignedIdentity \
    --assign-identity [system] --role AcrPull --scope <ACR_RESOURCE_ID>

  az functionapp deployment config show -g <RESOURCE_GROUP> -n <APP_NAME>
)

De image bouwen

Gebruik het voorbeeld-Dockerfile voor uw ondersteunde taal als uitgangspunt:

Begin met de Go-voorbeeld-Dockerfile.

Het Dockerfile-voorbeeld stelt een containerimage samen; het is geen door Microsoft geleverde basisafbeelding.

  1. Selecteer een ondersteunde Linux- of taal-base-image uit een bron die uw organisatie vertrouwt.
  2. Selecteer een expliciete basisafbeeldingsversietag of onveranderlijke samenvatting volgens uw supply-chainbeleid. Vermijd zwevende tags zoals latest.
  3. Installeer de vereiste OS-pakketten en verwijder de gegevens van de tijdelijke pakketbeheerder.
  4. Herstel of installeer taal- en applicatieafhankelijkheden.
  5. Voeg de applicatiepayload en de ondersteunde Functions-taalwerker toe.
  6. Configureer het taalspecifieke toegangspunt volgens het voorbeeld-Dockerfile voor uw taal. Bak de configuratie van het platform voor endpoints niet in de image.
  7. Bouw en scan de image.
  8. Bevestig dat de image is gericht op Linux amd64 en dat de vereiste bestanden en uitvoerrechten aanwezig zijn.
  9. Wijs een versie-tag of -digest toe. Beide referentievormen worden ondersteund, maar een digest heeft de voorkeur voor deterministische uitrol en rollback.

De preview biedt momenteel geen ondersteunde ontwikkelaarservaring voor het lokaal uitvoeren of testen van de containerafbeelding.

Lokale ontwikkeling en testen

Ontwikkel je functiecode op normale wijze. Gebruik de testtools van uw taal en voer func start het lokaal uit om de bronapplicatie te valideren.

Bouw na validatie op bronniveau de containerafbeelding met behulp van het gepubliceerde imagecontract en het voorbeeld-Dockerfile voor uw taal. U kunt bevestigen dat de build slaagt en de imagearchitectuur, bestanden en machtigingen inspecteren. De preview biedt momenteel geen ondersteunde ontwikkelaarservaring voor het lokaal uitvoeren of testen van de containerafbeelding.

Push de installatiekopie, configureer de Flex Consumption-functie-app met behulp van Azure CLI en valideer de gecontaineriseerde workload in Azure.

Push de image naar een registry

Nadat u tests op bronniveau en het bouwen van de image en beveiligingscontroles hebt voltooid:

  1. Tag de afbeelding voor het door u gekozen registry en de repository.
  2. Verifieer de registry.
  3. Push een onveranderlijke afbeeldingsversie.
  4. Noteer de resulterende tag en digest.
  5. Bevestig dat de identiteit of inloggegevens die door de Flex Consumption app worden gebruikt, de image kan pullen.

Registerondersteuning

Publiceer de image in de door u gekozen containerregistry.

De configuratie van de containerimage ondersteunt anonieme toegang, basisauthenticatie, systeemtoegewezen identiteit en door de gebruiker toegewezen identiteit. Gebruik anonieme toegang voor een openbare image. Basisauthenticatie verwijst naar namen van app-instellingen die de aanmeldingsgegevens van het register bevatten; plaats de waarden van die aanmeldingsgegevens niet rechtstreeks in de configuratie van de containerimage. Systeemtoegewezen en door gebruiker toegewezen beheerde identiteitsauthenticatie zijn van toepassing op Azure Container Registry.

Het gebruik van containers op Flex Consumption brengt geen extra netwerkbeperkingen met zich mee. Bestaande netwerkvereisten voor Flex Consumption zijn van toepassing. Het geconfigureerde containerregister moet bereikbaar en DNS-oplosbaar zijn via het netwerkpad van de app.

Gebruik referenties voor beheerde identiteit en Key Vault

Een Flex Consumption-app die een containerafbeelding gebruikt, ondersteunt hetzelfde gedrag voor beheerde identiteiten op app-niveau als een Flex-app met codepakket. U kunt een systeemtoegewezen of door de gebruiker toegewezen identiteit aan de functie-app toewijzen, en de door Azure beheerde Functions-host en ondersteunde extensies kunnen die identiteit normaal gebruiken. Uw applicatiecode kan ook de toegewezen identiteit gebruiken via de juiste Azure-identiteitsbibliotheek.

App-instellingen kunnen Key Vault-referenties op dezelfde manier gebruiken als andere Flex Consumption-apps. U configureert de identiteit die wordt gebruikt om een Key Vault-referentie op te lossen, onafhankelijk van de authenticatiemethode die wordt gebruikt om het containerimage op te halen. U kunt bijvoorbeeld één door de gebruiker toegewezen identiteit gebruiken voor de register-pull en een andere identiteit voor applicatietoegang tot Azure-resources.

Configureer een Flex Consumption-functie-app om een containerafbeelding te gebruiken

U kunt een nieuwe Flex Consumption-functie-app maken met Registry-implementatie of een in aanmerking komende bestaande app wijzigen van BlobContainer implementatie naar Registry implementatie.

De Microsoft.Web/sites resource gebruikt het implementatieopslagtype om het implementatiemodel te identificeren:

  • Een codepakket-app gebruikt properties.functionAppConfig.deployment.storage.type ingesteld op BlobContainer.
  • Een uitrol van een containerimage gebruikt properties.functionAppConfig.deployment.storage.type ingesteld op Registry.

Voor Registry-implementatie:

  • Stel deployment.storage.value in op de gekwalificeerde imagereferentie. Behoud de waarde exact.
  • Stel deployment.storage.authentication in op een ondersteunde authenticatievorm.
  • Laat functionAppConfig.runtime weg.

Selecteer een afbeeldingsreferentie

De properties.functionAppConfig.deployment.storage.value eigenschap moet een volledig gekwalificeerde registerhostnaam bevatten en een expliciete tag, digest, of beide:

  • Digest (aanbevolen):myregistry.example.com/app/worker@sha256:<digest>
  • Tag:myregistry.example.com/app/worker:v1
  • Tag en digest:myregistry.example.com/app/worker:v1@sha256:<digest>

Wanneer een afbeeldingsreferentie zowel een tag als een digest bevat, haalt het platform de door de digest geïdentificeerde afbeelding op. De tag is beschrijvend.

Een afbeeldingsreferentie zonder expliciete tag of digest wordt niet ondersteund. Om de latest tag te gebruiken, specificeer deze expliciet als myregistry.example.com/app/worker:latest. De API verwerpt ook registry-afkortingen die de volledig gekwalificeerde registryhostnaam weglaten.

Voor een tag-only referentie lost het platform de tag op telkens wanneer het een worker-instantie aanmaakt. Als de taginhoud verandert zonder een overeenkomstige wijziging van deployment.storage.value, kunnen verschillende imageversies tegelijk worden uitgevoerd. Voor meer informatie, zie Voorkom het bijwerken van een bestaande mutable tag.

De resource configureren

Het volgende Bicep-fragment toont de properties vorm:

properties: {
  functionAppConfig: {
    deployment: {
      storage: {
        type: 'Registry'
        value: '<qualified-image-reference>'
        authentication: {
          type: 'SystemAssignedIdentity'
        }
      }
    }
  }
}

Behoud bij update bestaande scaleAndConcurrency waarden en siteUpdateStrategy waarden, tenzij je van plan bent ze te wijzigen.

Gebruik een van deze authenticatievormen:

Verificatietype Aanvullende velden Usage
Anonymous None Haal uit een register dat anonieme toegang toestaat.
SystemAssignedIdentity None Gebruik de systeem-toegewezen identiteit van de app.
UserAssignedIdentity userAssignedIdentityResourceId Gebruik de door de gebruiker toegewezen identiteit.
Basic usernameSettingName, passwordSettingName Verwijs naar de app-instellingen die de inloggegevens voor het register bevatten. Zet referentiewaarden nooit inline.

Wanneer u de resource leest of bijwerkt:

  1. Vergelijk deployment.storage.type zonder onderscheid tussen hoofdletters en kleine letters voordat je runtime.name of runtime.version leest. Apps die de Registry-implementatie gebruiken, laten runtime weg.
  2. Bewaar scaleAndConcurrency, siteUpdateStrategy, namen van authenticatieinstellingen en niet-herkende functionAppConfig velden, tenzij u van plan bent deze te wijzigen.
  3. Behoud de afbeeldingsreferentie precies zoals aangegeven.

Azure CLI

De preview-versie bevat ondersteuning voor Azure CLI. Gebruik Azure CLI om een Flex Consumption-functie-app te maken met een containerafbeelding of om een geschikte bestaande app bij te werken.

De afbeeldingsopties zijn van toepassing op deze commando's:

  • az functionapp create
  • az functionapp deployment config set
  • az functionapp deployment config show
  • az functionapp show
Argument Alias Purpose
--deployment-image None Volledige afbeeldingsreferentie. De waarde wordt ongewijzigd verzonden.
--deployment-image-auth-type --diat Anonymous, SystemAssignedIdentity, UserAssignedIdentity of Basic.
--deployment-image-identity --dii Resource-ID van door de gebruiker toegewezen identiteit.
--deployment-image-username-setting --dius Naam van de app-instelling die de registrygebruikersnaam bevat.
--deployment-image-password-setting --dips App-instelling naam die het registerwachtwoord bevat.

Maak een functie-app met een containerafbeelding

Maak een Flex Consumption-functie-app die de systeem-toegewezen identiteit gebruikt om de image uit Azure Container Registry te halen:

az functionapp create -g <RESOURCE_GROUP> -n <APP_NAME> -s <STORAGE_ACCOUNT> \
  --flexconsumption-location <REGION> \
  --deployment-image <REGISTRY>/<REPOSITORY>@sha256:<DIGEST> \
  --deployment-image-auth-type SystemAssignedIdentity \
  --assign-identity [system] --role AcrPull --scope <ACR_RESOURCE_ID>

Werk een bestaande functie-app bij om een containerafbeelding te gebruiken

Schakel een in aanmerking komende Flex Consumption-functie-app over van BlobContainer naar Registry met een door de gebruiker toegewezen identiteit:

az functionapp deployment config set -g <RESOURCE_GROUP> -n <APP_NAME> \
  --deployment-image <REGISTRY>/<REPOSITORY>:<TAG> \
  --deployment-image-auth-type UserAssignedIdentity \
  --deployment-image-identity <IDENTITY_RESOURCE_ID>

Wijzig een bestaande app die Registry-implementatie gebruikt naar Basic-authenticatie door te verwijzen naar referentiegegevens in app-instellingen:

az functionapp deployment config set -g <RESOURCE_GROUP> -n <APP_NAME> \
  --deployment-image-auth-type Basic \
  --deployment-image-username-setting REGISTRY_USERNAME \
  --deployment-image-password-setting REGISTRY_PASSWORD

De CLI stuurt de afbeeldingsreferentie ongewijzigd voor servicevalidatie. Basisauthenticatie accepteert instellingennamen, niet waarden van aanmeldingsgegevens. Configureer registeridentiteit en roltoewijzingen afzonderlijk met opties zoals --assign-identity, --role en --scope.

Runtime-opties zijn niet van toepassing op apps die Registry-implementatie gebruiken. De show-commando's geven de namen van de registryconfiguratie en authenticatie-instellingen terug, maar nooit de registryinloggegevens.

Verificatie van implementatie en eerste aanroep

Valideer na implementatie de containerafbeelding en platformintegratie in Azure:

  1. Bevestig dat de app verwijst naar de bedoelde image tag of digest.
  2. Bevestig dat het platform zich kan authenticeren bij de registry en de image kan ophalen.
  3. Bevestig dat het workerproces start en gereed komt.
  4. Bevestig dat de verwachte functies en triggers zijn ontdekt.
  5. Roep een representatieve functie in.
  6. Controleer of de vereiste afhankelijkheid op OS-niveau wordt gebruikt.
  7. Controleer applicatietelemetrie op opstart- en aanroepfouten.

HTTP- en niet-HTTP-triggers

Tijdens de preview ondersteunt een Flex Consumption-functie-app die een containerafbeelding gebruikt dezelfde HTTP- en niet-HTTP-triggers als een codepakket-app Flex Consumption, behalve Durable Functions en de Azure Service Bus-extensie.

Een image bijwerken en terugzetten

Gebruik een onveranderlijk digest voor voorspelbare implementaties en rollbacks. Als je tags gebruikt, wijs dan aan elke afbeeldingsversie een nieuwe tag toe in plaats van een tag die al in gebruik is te overschrijven.

Ga als volgt te werk om applicatiecode, de Functions-worker, de taalruntime, het basisbesturingssysteem, OS-pakketten of applicatieafhankelijkheden bij te werken:

  1. Werk de expliciete componentversies bij in de afbeeldingsbron.
  2. Bouw de image opnieuw op.
  3. Voer tests op bronniveau uit en controles voor image-bouw en beveiliging.
  4. Push de nieuwe image en registreer de digest ervan of wijs er een nieuwe tag aan toe.
  5. Werk de Flex Consumption-functie-app bij om naar de nieuwe image te verwijzen.
  6. Verifieer de opstart, triggerdetectie en representatieve aanroepen.

Microsoft werkt een image die je al hebt gebouwd niet stilletjes bij. Houd de upstreambronnen voor uw basisimage en afhankelijkheden in de gaten, en bouw opnieuw wanneer updates nodig zijn.

Gedrag van de uitrol, drain en rollback van het platform

Wanneer u de functie-app bijwerkt om naar een andere image-digest of tag te verwijzen, begint de update zich voort te planten en triggert deze de volgende acties:

  • Nieuwe worker-instanties gebruiken de bijgewerkte afbeelding.
  • Het platform identificeert de triggers in de bijgewerkte image en werkt de geregistreerde triggers van de app bij.
  • Bestaande instanties accepteren geen nieuwe aanroepen meer en beginnen te leeglopen zonder te wachten tot de bijgewerkte image start of de triggerdetectie voltooid is.
  • Het platform staat toe dat HTTP-verzoeken en niet-HTTP-functie-uitvoeringen die al draaien worden afgerond, tot en met de platformbeëindigingsperiode.

Deze acties vinden parallel plaats. Triggerdetectie hoeft niet voltooid te zijn voordat de bestaande instanties worden afgevoerd.

Important

Een image-update heeft geen pre-deployment health gate of automatische rollback. Als de bijgewerkte image niet kan worden opgehaald, niet kan starten of de triggerdetectie niet kan voltooien, worden de vorige instanties nog steeds leeggelopen. HTTP- en niet-HTTP-triggers kunnen mislukken totdat u een geldig image configureert.

Als de functie-app wordt gestopt wanneer u de afbeeldingsreferentie bijwerkt, verwijdert het platform alle bestaande instanties en registreert de nieuwe referentie. Wanneer je de app start, gebruikt het platform de bijgewerkte image en identificeert het de triggers ervan.

Vermijd het bijwerken van een bestaande mutable tag

Het pushen van een nieuwe afbeelding onder dezelfde muteerbare tag start geen uitrol omdat de afbeeldingsreferentie die in de functie-app is geconfigureerd niet is gewijzigd. Bestaande instanties blijven de vorige image gebruiken. Instanties die tijdens een latere scale-out zijn aangemaakt, kunnen de tag naar de nieuwe image omzetten, waardoor verschillende afbeeldingsversies tegelijk worden uitgevoerd.

Het opnieuw opstarten van de functie-app voert de bestaande instanties netjes af zodat nieuw aangemaakte instanties de bijgewerkte tag oplossen. Een herstart voert echter geen triggerdetectie opnieuw uit. Als de bijgewerkte afbeelding functies of triggers toevoegt of verandert, werk dan de functie-app bij om naar een nieuwe samenvatting of tag te verwijzen.

Voor voorspelbaar uitrolgedrag werkt u de functie-app bij naar een nieuwe onveranderlijke digest voor elke release.

Een image terugdraaien

Het platform draait een mislukte afbeeldingsupdate niet automatisch terug. Bewaar de digest van elke eerder gevalideerde image.

Om terug te rollen, werk je de functie-app bij om te verwijzen naar de vorige werkende digest of tag. Deze update start triggerdetectie en provisioneert nieuwe worker-instanties vanuit de herstelde image.

Logboekregistratie en telemetrie

Application Insights-gedrags- en logaanbevelingen voor Flex Consumer-apps die een containerafbeelding gebruiken, zijn hetzelfde als voor standaard Flex Consumption en andere Azure Functions-hostingopties.

Voor applicatielogboeken en traces, instrumenteer je functie-app met OpenTelemetry en stuur de telemetrie rechtstreeks naar Application Insights. Directe instrumentatie wordt aanbevolen in plaats van afhankelijk te zijn van de Functions-host om applicatietelemetrie door te sturen, vooral naarmate de app schaalt. Voor configuratierichtlijnen, zie Gebruik OpenTelemetry met Azure Functions.

Voor applicatielogboeken en -traces kun je je Go-functie-app instrumenteren met OpenTelemetry. De Go worker middleware exporteert telemetrie via OpenTelemetry Protocol (OTLP)-instellingen. Stuur de telemetrie naar een OpenTelemetry Collector of een andere telemetriepijplijn die deze doorstuurt naar Azure Monitor. Een Application Insights-verbindingsreeks op zichzelf is niet voldoende voor Go-werkertelemetrie. Voor configuratierichtlijnen, zie Gebruik OpenTelemetry met Azure Functions.

Het door Azure beheerde platform blijft fouten bij het opstarten van werkers en het indexeren van functies doorsturen naar Application Insights. Gebruik deze fouten om mislukkingen te onderzoeken die optreden voordat een functie-aanroep uw applicatiecode bereikt.

De metrische ervaring van Azure Monitor in het Azure-portaal wordt niet ondersteund in preview. Gebruik Application Insights-logboeken en -traces om de app te monitoren en problemen op te lossen.

Bewaken en problemen oplossen

Problemen met de implementatie oplossen in de volgorde van de levenscyclus:

  1. Configuratie: Bevestig dat de app verwijst naar de bedoelde image en authenticatie-instellingen.
  2. Registertoegang: Bevestig dat de geconfigureerde identiteit of inloggegevens toegang heeft tot de afbeelding.
  3. Netwerk en DNS: Bevestig dat het platform de registry kan omzetten naar een IP-adres en kan bereiken.
  4. Afbeeldingsresolutie en -pull: Bevestig dat de tag of digest bestaat en een ondersteund formaat gebruikt.
  5. Opstart: Bevestig dat het workerproces start en de taalspecifieke platformverbinding tot stand brengt.
  6. Gereedheid van de worker: Bevestig dat de applicatie klaar is.
  7. Triggerdetectie en -schaling: Bevestig dat verwachte functies en triggers zijn ontdekt.
  8. Aanroepen: Bevestig dat de werker aanroepen ontvangt en de verpakte afhankelijkheid kan gebruiken.
  9. Update of rollback: Bevestig dat de app verwijst naar de beoogde afbeeldingsversie.

Verzamel de imagereferentie, implementatietijd, workerversie, basisimage, regio, triggertype en relevante correlatie-id's voordat u contact opneemt met support. Voeg geen inloggegevens voor de registry toe.

Beveiligings-, patch- en onderhoudsverantwoordelijkheden

Area Verantwoordelijkheid van klant Verantwoordelijkheid van Microsoft
Basis-Linux- of taalimage Selecteer een expliciete versie, scan, patch, herbouw en valideer Compatibiliteitsvereisten voor platformcompatibiliteit
Functions-language worker in de afbeelding Geef een ondersteunde versie op, neem deze correct op, herbouw, test en implementeer updates opnieuw Publiceer ondersteunde worker-artefacten, release-informatie en voorbeelden
OS- en applicatieafhankelijkheden Selecteren, configureren, licentieren, scannen, patchen en valideren Publicatieplatformbeperkingen
Toepassingscode Bouw, test, scan, patch en implementeer Beheer de door Azure beheerde platformcomponenten die de werker aanroepen
Afbeeldingsherkomst en registry Controles voor de toeleveringsketen toepassen en toegang beperken Ondersteunt het gedocumenteerde registerauthenticatie- en pad voor het ophalen van images
Functions-host, routing, triggers en scaling Configureer de app via ondersteunde interfaces Beheer en voorzie het door Azure beheerde platform van patches

Gebruik toegang tot het register volgens het least-privilege-principe, onveranderlijke afbeeldingsversies, kwetsbaarheidsscanning, SBOM-praktijken en betrouwbare artefactbronnen volgens het beleid van uw organisatie.

Preview-beperkingen

  • Durable Functions wordt niet ondersteund.
  • De Azure Service Bus-extensie wordt niet ondersteund.
  • Ondersteuning voor beschikbaarheidszones wordt niet ondersteund.
  • Images moeten gericht zijn op Linux amd64.
  • Ondersteuning voor preview-taal is beperkt tot .NET geïsoleerd, Python, Node.jsen Go.
  • De preview biedt momenteel geen ondersteunde ontwikkelaarservaring voor het lokaal uitvoeren of testen van de containerafbeelding.
  • De Azure Monitor-metriekervaring in het Azure-portaal wordt niet ondersteund. Gebruik logboeken en Application Insights voor monitoring.

Volgende stappen