Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
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.Workerversie2.53.0-preview.1of hoger. -
Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCoreversie2.1.2-preview.1of 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 het geïsoleerde .NET-voorbeeldbestand Dockerfile.
Start bij het Python-voorbeeld-Dockerfile.
Begin met de Go-voorbeeld-Dockerfile.
Begin bij het Node.js voorbeeld-Dockerfile.
Het Dockerfile-voorbeeld stelt een containerimage samen; het is geen door Microsoft geleverde basisafbeelding.
- Selecteer een ondersteunde Linux- of taal-base-image uit een bron die uw organisatie vertrouwt.
- Selecteer een expliciete basisafbeeldingsversietag of onveranderlijke samenvatting volgens uw supply-chainbeleid. Vermijd zwevende tags zoals
latest. - Installeer de vereiste OS-pakketten en verwijder de gegevens van de tijdelijke pakketbeheerder.
- Herstel of installeer taal- en applicatieafhankelijkheden.
- Voeg de applicatiepayload en de ondersteunde Functions-taalwerker toe.
- Configureer het taalspecifieke toegangspunt volgens het voorbeeld-Dockerfile voor uw taal. Bak de configuratie van het platform voor endpoints niet in de image.
- Bouw en scan de image.
- Bevestig dat de image is gericht op Linux
amd64en dat de vereiste bestanden en uitvoerrechten aanwezig zijn. - 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:
- Tag de afbeelding voor het door u gekozen registry en de repository.
- Verifieer de registry.
- Push een onveranderlijke afbeeldingsversie.
- Noteer de resulterende tag en digest.
- 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.typeingesteld opBlobContainer. - Een uitrol van een containerimage gebruikt
properties.functionAppConfig.deployment.storage.typeingesteld opRegistry.
Voor Registry-implementatie:
- Stel
deployment.storage.valuein op de gekwalificeerde imagereferentie. Behoud de waarde exact. - Stel
deployment.storage.authenticationin op een ondersteunde authenticatievorm. - Laat
functionAppConfig.runtimeweg.
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:
- Vergelijk
deployment.storage.typezonder onderscheid tussen hoofdletters en kleine letters voordat jeruntime.nameofruntime.versionleest. Apps die de Registry-implementatie gebruiken, latenruntimeweg. - Bewaar
scaleAndConcurrency,siteUpdateStrategy, namen van authenticatieinstellingen en niet-herkendefunctionAppConfigvelden, tenzij u van plan bent deze te wijzigen. - 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 createaz functionapp deployment config setaz functionapp deployment config showaz 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:
- Bevestig dat de app verwijst naar de bedoelde image tag of digest.
- Bevestig dat het platform zich kan authenticeren bij de registry en de image kan ophalen.
- Bevestig dat het workerproces start en gereed komt.
- Bevestig dat de verwachte functies en triggers zijn ontdekt.
- Roep een representatieve functie in.
- Controleer of de vereiste afhankelijkheid op OS-niveau wordt gebruikt.
- 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:
- Werk de expliciete componentversies bij in de afbeeldingsbron.
- Bouw de image opnieuw op.
- Voer tests op bronniveau uit en controles voor image-bouw en beveiliging.
- Push de nieuwe image en registreer de digest ervan of wijs er een nieuwe tag aan toe.
- Werk de Flex Consumption-functie-app bij om naar de nieuwe image te verwijzen.
- 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:
- Configuratie: Bevestig dat de app verwijst naar de bedoelde image en authenticatie-instellingen.
- Registertoegang: Bevestig dat de geconfigureerde identiteit of inloggegevens toegang heeft tot de afbeelding.
- Netwerk en DNS: Bevestig dat het platform de registry kan omzetten naar een IP-adres en kan bereiken.
- Afbeeldingsresolutie en -pull: Bevestig dat de tag of digest bestaat en een ondersteund formaat gebruikt.
- Opstart: Bevestig dat het workerproces start en de taalspecifieke platformverbinding tot stand brengt.
- Gereedheid van de worker: Bevestig dat de applicatie klaar is.
- Triggerdetectie en -schaling: Bevestig dat verwachte functies en triggers zijn ontdekt.
- Aanroepen: Bevestig dat de werker aanroepen ontvangt en de verpakte afhankelijkheid kan gebruiken.
- 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.