Använd beroenden på OS-nivå via containrar med Azure Functions Flex Consumption

Important

Den här funktionen är i förhandsversion. Förhandsgranskningsfunktionerna kan ändras.

Genom att använda beroendestöd på OS-nivå via containrar kan du köra Flex Consumer-funktionsappar som behöver mer än bara applikationskod och språkpaket i sin exekveringsmiljö. Du tillhandahåller en Linux-containerbild som inkluderar applikationen samt dess nödvändiga språk- och OS-beroenden. Azure fortsätter att tillhandahålla Functions-värd, triggerintegration, routing och skalning.

Overview

Du bygger en Linux-containerbild som inkluderar din funktionskod, en stödd Functions-språkarbetare, språk- och applikationsberoenden samt systempaket, inbyggda bibliotek, körbara filer, typsnitt, certifikat eller andra filer som din app behöver vid körning.

Azure kör och patchar Functions-hosten och hanterar routing, triggerintegration och skalning utanför bilden. Denna separation låter dig anpassa worker-miljön samtidigt som avbildens attackyta minskar och behovet av att själv paketera, skydda och uppdatera Functions-hosten elimineras.

Flex Consumption använder en containermodell endast för arbetare. Din avbild är inte en godtycklig webbbehållare. Det är inte heller en komplett Function App-avbildning som paketerar Functions-hosten, språkarbetaren, applikationen och beroenden tillsammans för ett annat hostingalternativ.

För ett komplett exempel som paketerar ett beroende på OS-nivå i en containerbild endast för arbetsprocessen, se Azure Functions Flex Consumption .NET-isolerade containerexempel.

För ett komplett exempel som paketerar ett beroende på OS-nivå i en containerbild som endast är för arbetare, se Azure Functions Flex Consumption Python-containerexemplet.

För ett komplett exempel som paketerar ett beroende på OS-nivå i en containerbild endast för arbetare, se Azure Functions Flex Consumption Go-containerexemplet.

För ett komplett exempel som paketerar ett beroende på OS-nivå i en containerbild endast för arbetare, se Azure Functions Flex Consumption Node.js container-exemplet.

Benefits

  • Paketera applikationen, språkworkern, språkberoenden och beroenden på OS-nivå i en versionsanpassad image.
  • Välj när du ska använda worker-, språk-runtime- och beroendeuppdateringar genom att bygga om, testa och distribuera på nytt avbildningen.
  • Låt Azure utanför avbilden hantera och uppdatera Functions-värden, triggerintegrering, routning och skalning.
  • Minska de komponenter du måste inkludera, skydda och underhålla i din bild jämfört med en komplett Function App-avbildning.

När du ska använda den här funktionen

Använd containrar för beroenden på OS-nivå i Flex Consumption när:

  • Din Flex Consumption-app kräver beroenden som du inte kan få tag i enbart via språkpakethanteraren.
  • Du kan bygga, skanna, patcha, testa och publicera en Linux-image.
  • Du kan underhålla den valda basbilden och språkets worker-version i bilden.

Jämför containervärdalternativ

Välj den värdmodell som matchar den del av körtiden du behöver kontrollera.

Capability Flex Consumption-containeravbildning Elastic Premium eller Dedicated (App Service) anpassad avbildning Funktioner på Azure Container Apps
Avbildskontrakt Endast worker Slutför Function App-avbildningen Fullständig Function App-avbildning
Functions-värd/körning Tillhandahålls, drivs och patchas av Azure utanför din image Inkluderat i din avbild, vanligtvis från en Functions-basavbild Inkluderat i din avbild
Din bild innehåller App, en språkworker, språk-/applikationsberoenden och OS-paket Functions host, worker, app och beroenden Functions-värd, arbetsprocess, app och beroenden
Scaling Funktionsstyrd Flex-konsumtionsskalning Funktionshanterad Premium-skalning eller App Service-planskalning Container-appskalning
Billing Standard Flex Consumption-fakturering Fakturering för Elastic Premium eller App Service-plan Container Apps-fakturering
Bästa passform Lägg till beroenden på OS-nivå samtidigt som kontraktet för den serverlösa Flex-plattformen behålls Hantera en komplett Functions-container på App Service-infrastrukturen Kör kompletta Functions-containrar med Container Apps-funktioner

För mer information om kompletta Function App-bilder, se stöd för Linux-container i Azure Functions.

Arkitektur och ansvarsgräns

En händelse eller HTTP-förfrågan når först den Azure-hanterade Functions-plattformen. Azure kör Functions-hosten och runtime, utvärderar triggers, routerar anrop och bestämmer när instanser ska läggas till eller tas bort. När ett anrop är klart skickar plattformen det till språkarbetaren Functions i din avbildning. Språkarbetaren laddar din funktionsapp och din app kan använda de språk-, applikations- och OS-nivåberoenden som ingår i avbildningen.

Din avbild inkluderar inte eller ersätter inte Functions-värden, implementerar inte triggerroutning eller kontrollerar plattformsskalning. Du underhåller applikationen, språkarbetsprocessen, basavbildningen och beroenden inuti avbildningen. Microsoft underhåller och uppdaterar Functions-plattformskomponenterna utanför imagen.

Den aktiva Functions-språkarbetaren måste vara en av de språkarbetare som anges i tabellen över stöd i förhandsversionen. Förhandsgranskningen stöder inte att ersätta den med en godtycklig kundutvecklad språkworker eller anpassad hanterare. Bilden kan inkludera andra runtimes eller körbara filer, såsom en Rust-komponent som anropas av en stödd funktion, som programberoenden. Begränsningen till en worker gäller för aktiva Functions-språk-workers, inte för hjälpruntider eller verktyg som följer med appen.

Förhandsversion av språkstöd

Förhandsgranskningen stöder följande språkspecifika workers för Functions. Välj ditt språk högst upp i artikeln för stödda runtime-versioner, information om kompatibilitet för workers och ett exempel på en Dockerfile.

Funktionsspråk Hur workern inkluderas
.NET isolerad Inkluderas via applikationens NuGet-beroenden och publiceringsutdata
Python Tillagd som en Microsoft-worker-artefakt specifik för Python-versionen
Node.js Tillagd som en Microsoft-publicerad Node.js artefakt
Gå Inkluderas via Go worker SDK och kompileras i applikationsbinärfilen

Andra Functions-språkworkers stöds inte under förhandsversionen.

Prerequisites

Innan du börjar behöver du:

  • En applikation som använder ett förhandsgranskningsspråk som stöds.
  • En Docker-kompatibel imagebyggmiljö.
  • En Linux- eller språkbaserad image som du kan underhålla.
  • Applikationskällan och dess språkberoenden.
  • De nödvändiga operativsystempaketen, inbyggda bibliotek, typsnitt, drivrutiner eller verktyg.
  • Åtkomst till ett containerregister.
  • Behörighet att bygga, skanna, pusha och distribuera avbildningar.

Förhandsgranskningen stöder Linux-bilderamd64.

Förstå Flex Consumption-containermodellen

Din avbild är ansvarig för:

  • Applikationspayloaden.
  • Ett språkstöd för Functions.
  • Språk- och applikationsberoenden.
  • Beroenden på OS-nivå.
  • Linux- eller språkbasbilden som du väljer.
  • Bildsäkerhet, åtgärdande av sårbarheter och explicita komponentversioner.

Azure ansvarar för:

  • Functions-värden.
  • Routing och triggerintegration.
  • Funktionsstyrd skalning.
  • Plattformskomponenter utanför din image.

Flex Consumption låter dig välja den Linux- eller språkbasbild som bäst passar dina applikations- och organisationskrav. Bygg vidare på den avbildningen genom att lägga till en stödd språkarbetare för Functions, din applikation och dess beroenden enligt denna containermodell endast för worker. Microsoft tillhandahåller versionerade worker-artefakter och exempel på Dockerfiler för att hjälpa dig skapa en kompatibel avbild, medan Azure hanterar Functions-värden utanför din image.

Start av worker är språkberoende. Använd exempel-Dockerfile för ditt språk istället för att kopiera en inträdespunkt från ett annat språk. Plattformen tillhandahåller RPC-anslutningsargument för workern och applikationskatalogen. Din containeravbildning startar språkarprocessens eller applikationens binärfil direkt; den installerar eller startar inte Functions-värden och innehåller inte konfiguration för plattformens slutpunkt.

Miljövariabler och skriptets rotkatalog

Du konfigurerar inte Functions-värd- eller worker-connection-miljövariabler. Plattformen injicerar de värden för arbetsidentitet, anslutning, protokoll och bootstrap som språkarbetaren behöver för att kommunicera med den Azure-hanterade Functions-värden.

När din Flex Consumption-app använder en containeravbildning, konfigurera appens inställning AzureWebJobsScriptRoot=/home/site/wwwroot. Din avbild måste placera funktionsapplikationen på den sökvägen. Azure injicerar inställningen i containern vid körning, så du behöver inte deklarera den som en ENV instruktion i Dockerfile. Du kan fortsätta använda andra appinställningar som krävs av din applikation.

Lägg inte till FUNCTIONS_WORKER_RUNTIME eller FUNCTIONS_EXTENSION_VERSION i en Flex Consumption-app som använder en containerbild. Plattformen hanterar dessa runtime-detaljer utanför din avbild.

Hämta språkworkern

Inkludera en specifik worker-release i bilden så att en ombyggnad av samma bildkälla inte tyst väljer en annan worker. För en nedladdad worker-artifact, ange dess utgåveversion och verifiera dess SHA-256-kontrollsumma. För en worker som levereras via ett applikationsberoende, ange beroendeversionen i applikationsprojektet. Att uppdatera workern kräver att du ändrar den versionen, bygger om, testar, pushar och distribuerar imagen på nytt.

.NET isolerad

Förhandsgranskningen stöder den isolerade .NET-arbetarmodellen på .NET 10 och .NET 11. En .NET-isolerad applikation inkluderar Functions-arbetaren via dess normala NuGet-beroenden och byggutdata. Workern publiceras inte som en separat artefakt för varje stödd .NET-runtime-version. Ange Microsoft.Azure. Functions.Worker- och relaterade paketversioner i projektet, och publicera applikationen i /home/site/wwwroot.

Använd den senaste versionen av Azure.Functions.Sdk som projekt-SDK. För befintliga projekt, följ Migrate to Azure.Functions.Sdk.

Använd följande minimiversioner för paket:

  • Microsoft.Azure.Functions.Worker version 2.53.0-preview.1 eller senare.
  • Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCoreversion 2.1.2-preview.1 eller senare, om din app använder ASP.NET Core-integration.

Important

Använd en stödd .NET-version. Du ansvarar för att välja och underhålla en stödd .NET-runtime-image samt kompatibla beroenden för Functions-arbetaren och programmet.

För fullständiga applikations- och distributionsfiler, se exemplet på Azure Functions Flex Consumption .NET isolerad container.

.NET-isolerad exempeldockerfil

Följande exempel på Dockerfile publicerar den isolerade applikationen för .NET och kopierar publiceringsutdata till en .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"]

Detta exempel riktar sig mot .NET 10. När du väljer en annan stödd .NET-version, uppdatera båda .NET-basavbildningstaggarna tillsammans och validera versionerna av applikationen och Functions worker-paketen.

Python

Förhandsvisningen stöder Python 3.13 till och med Python 3.15. En avbild med Python innehåller applikationen, Python-beroenden, beroenden på OS-nivå och en stödd Python Functions-artefakt. Worker-artefakten måste matcha Python-runtimeversionen i bilden.

Important

Använd en stödd Python-version och dess motsvarande arbetsartefakt. Kombinera inte en arbetsartefakt för en Python-version med en annan Python-runtime-version.

Börja med exemplet på Dockerfile i Azure Functions Flex Consumption Python-containerexemplet.

Exempelapplikationen använder azure-functions==2.3.0. Python Dockerfile specificerar en version av Python-arbetaren, verifierar den nedladdade artefakten med sin SHA-256-kontrollsumma och extraherar den till avbilden. Dess startpunkt startar Python-arbetaren direkt. Byt Python-basavbildning, worker-artefaktsuffix och checksumma tillsammans när du väljer en Python-version.

Python Dockerfile

Följande värden identifierar den stödda worker-artefakten för varje Python-version:

Python-version Basbild WORKER_PYTHON WORKER_SHA256
3.13 python:3.13-slim-bookworm 313 39c67d052ef10575519006e5b73b5da977a9a5dff2bab0a222084b4b03070a5e
3,14 python:3.14-slim-bookworm 314 29295af2b1e0332ca801e228678b147c47d67fefe6d247df0becf6ff92a79883
3.15 python:3.15-slim-bookworm 315 ae40f55204cdf7b278aa80df4be03ab7fd5432de6726b250ad9b243e4725a5de

Detta exempel riktar sig till Python 3.15. Uppdatera de tre första ARG värdena genom att använda föregående tabell när du bygger för Python 3.13 eller 3.14.

ARG PYTHON_BASE=python:3.15-slim-bookworm
FROM ${PYTHON_BASE} AS build

ARG WORKER_PYTHON=315
ARG WORKER_SHA256=ae40f55204cdf7b278aa80df4be03ab7fd5432de6726b250ad9b243e4725a5de
ADD --checksum=sha256:${WORKER_SHA256} \
    https://github.com/Azure/azure-functions-python-worker/releases/download/azure_functions_worker-4.46.7/azure-functions-python-worker-4.46.7-py${WORKER_PYTHON}-linux-x64.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

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_BASE}

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 /home/site/wwwroot/.python_packages/ ./.python_packages/
COPY function_app.py host.json ./

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

Från katalogen som innehåller Dockerfile och applikationsfilerna, bygg och pusha avbildningen. Detta exempel använder Azure Container Registry och systemtilldelad identitet:

az acr login --name <ACR_NAME>

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

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

az functionapp create -g <RESOURCE_GROUP> -n <APP_NAME> -s <STORAGE_ACCOUNT> \
  --flexconsumption-location <REGION> \
  --deployment-image <ACR_NAME>.azurecr.io/<REPOSITORY>:python313 \
  --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>

Gå

Förhandsvisningen stöder Go 1.27. En Go-avbildning innehåller applikationen, beroenden på OS-nivå samt den stödda Go Functions-arbetaren och SDK:n kompilerade i applikationsbinären. Workern publiceras inte som en separat artefakt för varje stödd Go-version.

Important

Använd en stödd Go-version. Du ansvarar för att kompilera applikationen med en stödd Go-verktygskedja och kompatibel Go Functions worker SDK-version.

Börja med exemplet på Dockerfile i Azure Functions Flex Consumption Go-containerexemplet.

Exempelfilen go.mod anger github.com/azure/azure-functions-golang-worker version v1.0.2. Go Dockerfile använder ett flerstegsbygge och startar den kompilerade applikationsbinärfilen direkt.

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
ENV FUNCTIONS_GO_DISABLE_HTTP_PROXY=1

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"]

Från katalogen som innehåller Dockerfile och applikationsfilerna, bygg och pusha imagen. Detta exempel använder Azure Container Registry och systemtilldelad identitet:

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

Förhandsvisningen stöder Node.js 24. En Node.js-avbild innehåller applikationen, Node.js beroenden, beroenden på OS-nivå och en stödd Node.js Functions worker-artefakt. Workern publiceras inte som en separat artefakt för varje stödd Node.js runtime-version.

Important

Använd en stödd Node.js version. Du ansvarar för att välja och underhålla en stödd Node.js-basavbildning samt kompatibla Functions-worker och programberoenden.

Börja med JavaScript- eller TypeScript-exempel-Dockerfile i Azure Functions Flex Consumption Node.js-containerexemplet.

Exempelapplikationen använder @azure/functions version 4.17.0. Node.js Dockerfile specificerar en Node.js-workerutgåva, verifierar den nedladdade artefakten med dess SHA-256-kontrollsumma och extraherar den till avbilden. Dess startpunkt startar Node.js-arbetaren direkt. Ändra arbetarens version och kontrollsumma tillsammans när du uppdaterar arbetaren.

Node.js Dockerfile

Följande Dockerfiler använder layouten från exempelprojekten JavaScript och TypeScript. Uppdatera kommandon COPY och byggstegen så att de matchar din applikations katalogstruktur och byggresultat. För TypeScript kompilerar exemplet applikationen och kopierar det genererade JavaScript från dist. Katalogen dist är en exempelkonvention, inte ett krav i containermodellen Flex Consumption. Se till att fältet main i package.json identifierar de genererade JavaScript-filerna.

FROM node:24-bookworm-slim AS worker
ADD --checksum=sha256:93fbe6f007a5eab62f28e30b3fbb93c61c53ba3b9890cc135d982a8af1e4f3ca \
    https://github.com/Azure/azure-functions-nodejs-worker/releases/download/v3.17.3/azure-functions-nodejs-worker-3.17.3.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"]

Från katalogen som innehåller Dockerfile och applikationsfilerna, bygg och pusha avbildningen. Detta exempel använder Azure Container Registry och systemtilldelad identitet:

az acr login --name <ACR_NAME>

docker build --platform linux/amd64 --progress plain \
  -f node24.Dockerfile \
  -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>

Skapa avbildningen

Använd exempelfilen Dockerfile för ditt stödda språk som utgångspunkt:

Exemplet på Dockerfile sammanställer en containeravbildning; det är inte en basavbild tillhandahållen av Microsoft.

  1. Välj en stödd Linux- eller språkbasavbild från en källa som din organisation litar på.
  2. Välj en explicit tagg för basbildsversionen eller en oföränderlig digest enligt din försörjningskedjepolicy. Undvik flytande taggar såsom latest.
  3. Installera nödvändiga OS-paket och ta bort temporära pakethanterardata.
  4. Återställ eller installera språkberoenden och applikationsberoenden.
  5. Lägg till applikationens payload och den Functions-språkarbetare som stöds.
  6. Konfigurera den språkspecifika ingångspunkten enligt exempel-Dockerfilen för ditt språk. Bygg inte in plattformsendpoint-konfigurationen i avbilden.
  7. Bygg och skanna bilden.
  8. Bekräfta att imagen riktar sig mot Linux amd64 och att nödvändiga filer och körbehörigheter finns.
  9. Tilldela en versionstagg eller digest. Båda referensformerna stöds, men en digest föredras för deterministisk driftsättning och rollback.

Förhandsgranskningen erbjuder för närvarande ingen stödd utvecklarupplevelse för att köra eller testa containeravbilden lokalt.

Lokal utveckling och testning

Utveckla din funktionskod på ett normalt sätt. Använd ditt språks testverktyg och kör func start för att validera källapplikationen lokalt.

Efter validering på källnivå, bygg containeravbilden med hjälp av det publicerade bildkontraktet och exempelfilen Dockerfile för ditt språk. Du kan bekräfta att bygget lyckas och inspektera avbildsarkitekturen, filerna och behörigheterna. Förhandsgranskningen erbjuder för närvarande ingen stödd utvecklarupplevelse för att köra eller testa containeravbilden lokalt.

Pusha bilden, konfigurera Flex Consumption-funktionsappen med hjälp av Azure CLI och validera den containeriserade arbetsbördan i Azure.

Skicka avbilden till ett containerregister

Efter att du har slutfört tester på källnivå samt imagebygge och säkerhetskontroller:

  1. Tagga bilden för din valda registry och lagringsplats.
  2. Autentisera dig till registryt.
  3. Pusha en oföränderlig bildversion.
  4. Registrera den resulterande taggen och digesten.
  5. Bekräfta att identiteten eller autentiseringsuppgiften som används av Flex Consumption-appen kan hämta bilden.

Registerstöd

Publicera bilden till ditt valda containerregister.

Konfiguration av containerbilder stöder anonym åtkomst, grundläggande autentisering, systemtilldelad identitet och användartilldelad identitet. Använd anonym åtkomst för en offentlig bild. Grundläggande autentisering refererar till appinställningsnamn som innehåller inloggningsuppgifter för registret; lägg inte in värden för autentiseringsuppgifter direkt i containerbildkonfigurationen. Systemtilldelad och användartilldelad hanterad identitetsautentisering gäller för Azure Container Registry.

Att använda containrar i Flex Consumption medför inte ytterligare nätverksbegränsningar. Befintliga krav på Flex Consumption-nätverk gäller. Det konfigurerade registret måste vara åtkomligt och kan lösas via DNS från appens nätverk.

Använd referenser till hanterad identitet och Key Vault

En Flex Consumption-app som använder en containerbild stöder samma appnivå-hanterade identitetsbeteende som en kodpakets-Flex-app. Du kan tilldela en system- eller användartilldelad identitet till funktionsappen, och den Azure-hanterade Functions-värden och tillägg som stöds kan använda identiteten normalt. Din applikationskod kan också använda den tilldelade identiteten via det lämpliga Azure-identitetsbiblioteket.

Appinställningar kan använda Key Vault-referenser på samma sätt som andra Flex Consumption-appar. Du konfigurerar identiteten som används för att lösa en Key Vault-referens oberoende av autentiseringsmetoden som används för att hämta containeravbildningen. Till exempel kan du använda en användartilldelad identitet för registeruttaget och en annan identitet för applikationsåtkomst till Azure-resurser.

Konfigurera en Flex Consumption-funktionsapp för att använda en containerbild

Du kan skapa en ny Flex Consumption-funktionsapp med distribution via register eller ändra en berättigad befintlig app från BlobContainer distribution till Registry distribution.

Resursen Microsoft.Web/sites använder distributionens lagringstyp för att identifiera distributionsmodellen:

  • En kodpaketapp använder properties.functionAppConfig.deployment.storage.type satt till BlobContainer.
  • En containerbilddistribution använder properties.functionAppConfig.deployment.storage.type satt till Registry.

För distribution via registry:

  • Ställ in deployment.storage.value till den kvalificerade bildreferensen. Bevara värdet exakt.
  • Ställ in deployment.storage.authentication till en stödd autentiseringsform.
  • Utelämna functionAppConfig.runtime.

Välj en bildreferens

Egenskapen properties.functionAppConfig.deployment.storage.value måste innehålla ett fullt kvalificerat registervärdnamn och en explicit tagg, digest eller båda:

  • Digest (rekommenderat):myregistry.example.com/app/worker@sha256:<digest>
  • Tag:myregistry.example.com/app/worker:v1
  • Tagg och digest:myregistry.example.com/app/worker:v1@sha256:<digest>

När en bildreferens innehåller både en tagg och en digest hämtar plattformen bilden som identifierats av digesten. Taggen är beskrivande.

En bildreferens utan en explicit tagg eller digest stöds inte. För att använda taggen latest , ange den uttryckligen som myregistry.example.com/app/worker:latest. API:et avvisar också registry-förkortning som utelämnar det fullt kvalificerade registry-värdnamnet.

För en referens endast för taggar löser plattformen taggen varje gång den skapar en arbetsinstans. Om tagginnehållet ändras utan motsvarande ändring till deployment.storage.value, kan olika bildversioner köras samtidigt. För mer information, se Undvik att uppdatera en befintlig muterbar tagg.

Konfigurera resursen

Följande Bicep-fragment visar formenproperties:

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

Vid uppdatering, bevara befintliga scaleAndConcurrency värden och siteUpdateStrategy värden om du inte tänker ändra dem.

Använd någon av dessa autentiseringsformer:

Autentiseringstyp Ytterligare fält Usage
Anonymous None Hämta från ett register som tillåter anonym åtkomst.
SystemAssignedIdentity None Använd appens systemtilldelade identitet.
UserAssignedIdentity userAssignedIdentityResourceId Använd den angivna användartilldelade identiteten.
Basic usernameSettingName, passwordSettingName Referera till appinställningar som innehåller autentiseringsuppgifterna för registret. Ange aldrig värden för autentiseringsuppgifter direkt infogade.

När du läser eller uppdaterar resursen:

  1. Jämför deployment.storage.type skiftläges-okänsligt innan du läser runtime.name eller runtime.version. Appar som använder registerdistribution utelämnar runtime.
  2. Bevara scaleAndConcurrency, siteUpdateStrategy, autentiseringsinställningsnamn och oigenkända functionAppConfig fält om du inte avser att ändra dem.
  3. Bevara bildreferensen exakt som den tillhandahålls.

Azure CLI

Förhandsversionen inkluderar stöd för Azure CLI. Använd Azure CLI för att skapa en Flex Consumption-funktionsapp med en containerbild eller uppdatera en befintlig app.

Bildalternativen gäller för följande kommandon:

  • az functionapp create
  • az functionapp deployment config set
  • az functionapp deployment config show
  • az functionapp show
Argument Alias Purpose
--deployment-image None Kvalificerad bildreferens. Värdet skickas oförändrat.
--deployment-image-auth-type --diat Anonymous, SystemAssignedIdentity, UserAssignedIdentity, eller Basic.
--deployment-image-identity --dii Användartilldelat identitetsresurs-ID.
--deployment-image-username-setting --dius Appinställningsnamn som innehåller användarnamnet för registret.
--deployment-image-password-setting --dips Appinställningsnamn som innehåller lösenordet för registret.

Skapa en funktionsapp med en containerbild

Skapa en Flex Consumption-funktionsapp som använder sin systemtilldelade identitet för att hämta bilden från Azure Container Registry:

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>

Uppdatera en befintlig funktionsapp för att använda en containerbild

Byt en behörig Flex Consumption-funktionsapp från BlobContainer till Registry med en användartilldelad identitet:

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>

Ändra en befintlig app som använder registerdistribution till grundläggande autentisering genom att referera till appinställningarna för autentiseringsuppgifter:

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

CLI skickar bildreferensen oförändrad för servicevalidering. Grundläggande autentisering accepterar inställningsnamn, inte värden för autentiseringsuppgifter. Konfigurera registeridentitets- och rolltilldelningar separat med alternativ som --assign-identity, --role, och --scope.

Körningsalternativ gäller inte för appar som använder distribution via register. Show-kommandona returnerar namnen på registerkonfigurationen och autentiseringsinställningarna, men aldrig inloggningsuppgifter för registret.

Verifiera driftsättning och första anrop

Efter driftsättning, validera containerbilden och plattformsintegrationen i Azure:

  1. Bekräfta att appen refererar till den avsedda avbildstaggen eller digesten.
  2. Bekräfta att plattformen kan autentisera sig till registret och hämta bilden.
  3. Bekräfta att worker-processen startar och blir redo.
  4. Bekräfta att de förväntade funktionerna och triggerna har upptäckts.
  5. Åberopa en representativ funktion.
  6. Verifiera att det nödvändiga beroendet på OS-nivå används.
  7. Granska applikationstelemetri för uppstarts- och anropsfel.

HTTP- och icke-HTTP-triggers

Under förhandsgranskningen stöder en Flex Consumption-funktionsapp som använder en containerbild samma HTTP- och icke-HTTP-triggers som en kodpaketsapp Flex Consumption, förutom Durable Functions och Azure Service Bus-tillägget.

Uppdatera och återställ en avbildning

Använd en oföränderlig digest för förutsägbara distributioner och rollbacks. Om du använder taggar, tilldela en ny tagg till varje bildversion istället för att skriva över en tagg som redan är i bruk.

För att uppdatera applikationskod, Functions-arbetsprocess, språkkörning, basoperativsystem, OS-paket eller applikationsberoenden:

  1. Uppdatera de explicita komponentversionerna i bildkällan.
  2. Bygg om avbilden.
  3. Kör tester på källnivå samt imagebygge och säkerhetskontroller.
  4. Pusha den nya imagen och registrera dess digest eller tilldela den en ny tagg.
  5. Uppdatera appen för Flex Consumption för att referera till den nya avbilden.
  6. Kontrollera uppstart, identifiering av utlösare och representativa anrop.

Microsoft patchar inte tyst en image som du redan har byggt. Övervaka uppströmskällorna för din basimage och beroenden, och bygg om när uppdateringar behövs.

plattformsutrullning, dränering och rollback-beteende

När du uppdaterar funktionsappen för att referera till en annan bildsammanfattning eller tagg börjar uppdateringen spridas och utlöser följande åtgärder:

  • Nya worker-instanser använder den uppdaterade bilden.
  • Plattformen identifierar triggers i den uppdaterade bilden och uppdaterar appens registrerade triggers.
  • Befintliga instanser slutar acceptera nya anrop och börjar dräneras utan att vänta på att den uppdaterade bilden ska starta eller slutföra triggerupptäckten.
  • Plattformen tillåter HTTP-förfrågningar och icke-HTTP-funktionsexekveringar som redan körs att slutföras, fram till plattformens avslutningsfrist.

Dessa åtgärder sker parallellt. Triggerupptäckten behöver inte avslutas innan befintliga instanser börjar dräneras.

Important

En bilduppdatering har ingen hälsokontroll före driftsättning eller automatisk rollback. Om den uppdaterade bilden inte kan hämtas, inte startar eller inte kan slutföra trigger-upptäckten, dräneras de tidigare instanserna fortfarande. HTTP- och icke-HTTP-utlösare kan misslyckas tills du konfigurerar en giltig avbild.

Om funktionsappen stoppas när du uppdaterar dess bildreferens tar plattformen bort alla befintliga instanser och registrerar den nya referensen. När du startar appen använder plattformen den uppdaterade bilden och identifierar dess triggers.

Undvik att uppdatera en befintlig muterbar tagg

Att pusha en ny bild under samma mutabla tagg initierar inte en utrullning eftersom bildreferensen som konfigurerats i funktionsappen inte har ändrats. Befintliga instanser fortsätter att använda den föregående bilden. Instanser som skapas vid en senare skalning kan lösa taggen till den nya bilden, vilket kan göra att olika bildversioner körs samtidigt.

Att starta om funktionsappen dränerar befintliga instanser så att nyskapade instanser pekar mot den uppdaterade taggen. Dock kör en omstart inte triggerupptäckningen igen. Om den uppdaterade bilden lägger till eller ändrar funktioner eller triggers, uppdatera funktionsappen för att referera till en ny digest eller tagg.

För förutsägbart utrullningsbeteende, uppdatera funktionsappen till en ny oföränderlig digest för varje release.

Rulla tillbaka en image

Plattformen rullar inte automatiskt tillbaka en misslyckad bilduppdatering. Behåll digesten av varje tidigare validerad bild.

För att rulla tillbaka, uppdatera funktionsappen så att den refererar till föregående fungerande digest eller tagg. Denna uppdatering initierar triggerupptäckt och tillhandahåller nya worker-instanser från den återställda imagen.

Loggning och telemetri

Application Insights-beteende och loggningsrekommendationer för Flex Consumer-appar som använder en containerbild är desamma som för standard Flex Consumption och andra Azure Functions-hostingalternativ.

För applikationsloggar och spår, instrumentera din funktionsapp med OpenTelemetry och skicka telemetri direkt till Application Insights. Direkt instrumentering rekommenderas i stället för att förlita sig på Functions-hosten för att vidarebefordra applikationstelemetri, särskilt när appen skalar. För konfigurationsvägledning, se Använd OpenTelemetry med Azure Functions.

För applikationsloggar och spår använder du OpenTelemetry i din Go-funktionsapp. Middleware för Go-arbetare exporterar telemetri med hjälp av OpenTelemetry Protocol (OTLP)-inställningar. Skicka telemetrin till en OpenTelemetry Collector eller en annan telemetripipeline som vidarebefordrar den till Azure Monitor. En Application Insights reťazec pripojenia räcker inte ensam för Go-arbetartelemetri. För konfigurationsvägledning, se Använd OpenTelemetry med Azure Functions.

Plattformen som hanteras av Azure fortsätter att vidarebefordra fel vid start av arbetsprocessen och funktionsindexeringsfel till Application Insights. Använd dessa fel för att undersöka fel som uppstår innan ett funktionsanrop når din applikationskod.

Azure Monitor-mätvärdesupplevelsen i Azure-portalen stöds inte i förhandsvisning. Använd Application Insights-loggar och spår för att övervaka och felsöka appen.

Övervaka och felsöka

Felsök driftsättningen i livscykelordning:

  1. Konfiguration: Bekräfta att appen refererar till den avsedda bilden och autentiseringsinställningarna.
  2. Registeråtkomst: Bekräfta att den konfigurerade identiteten eller de konfigurerade inloggningsuppgifterna kan komma åt avbildningen.
  3. Nätverk och DNS: Bekräfta att plattformen kan lösa upp och nå registret.
  4. Avbildsupplösning och hämtning: Bekräfta att taggen eller digesten finns och använder ett format som stöds.
  5. Start: Bekräfta att arbetsprocessen startar och etablerar den språkspecifika plattformsanslutningen.
  6. Arbetarens beredskap: Bekräfta att applikationen blir klar.
  7. Triggerupptäckt och skalning: Bekräfta att förväntade funktioner och triggers identifieras.
  8. Anrop: Bekräfta att arbetaren tar emot anrop och kan använda det paketerade beroendet.
  9. Uppdatering eller rollback: Bekräfta att appen refererar till den avsedda bildversionen.

Samla in bildreferens, driftsättningstid, workerversion, basbild, region, triggertyp och relevanta korrelationsidentifierare innan du kontaktar support. Bifoga inte autentiseringsuppgifter för registret.

Ansvar för säkerhet, patchning och underhåll

Area Kundens ansvar Microsoft ansvar
basavbild för Linux eller språkavbild Välj en explicit version, skanna, patcha, bygga om och validera Kompatibilitetskrav för plattform för publicering
Functions-språkworkern i avbildningen Ange en stödd version, inkludera den korrekt, bygg om, testa och distribuera uppdateringar igen Publicera stödda worker-artefakter, släppinformation och exempel
OS- och applikationsberoenden Välj, konfigurera, licensiera, skanna, patcha och validera Begränsningar för publiceringsplattformen
Programkod Bygg, testa, skanna, patcha och distribuera Kör de Azure-hanterade plattformskomponenter som anropar arbetaren
Bildproveniens och registerdata Tillämpa leveranskedjekontroller och begränsa åtkomst Stöd den dokumenterade registryautentiseringen och avbildshämtningsvägen
Funktionsvärd, routning, utlösare och skalning Konfigurera appen via stödda gränssnitt Driv och uppdatera den Azure-hanterade plattformen

Använd registeråtkomst med minst möjliga privilegier, oföränderliga bildversioner, sårbarhetsskanning, praxis för programvaruförteckning och pålitliga artefaktkällor enligt din organisations policyer.

Begränsningar i förhandsversionen

  • Durable Functions stöds inte.
  • Azure Service Bus-tillägget stöds inte.
  • Stöd för tillgänglighetszoner är inte tillgängligt.
  • Bilder måste rikta sig mot Linux amd64.
  • Förhandsgranskningsspråkstödet är begränsat till .NET-isolerat, Python, Node.js och Go.
  • Förhandsgranskningen erbjuder för närvarande ingen stödd utvecklarupplevelse för att köra eller testa containeravbilden lokalt.
  • Azure Monitor-mätvärdenupplevelsen i Azure-portalen stöds inte. Använd loggar och Application Insights för övervakning.

Nästa steg