Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Important
Cette fonctionnalité est en version préliminaire. Les capacités d’aperçu peuvent changer.
En utilisant le support des dépendances au niveau du système d’exploitation via des conteneurs, vous pouvez exécuter des applications de fonction Flex Consumption qui nécessitent plus que du code applicatif et des paquets linguistiques dans leur environnement d’exécution. Vous fournissez une image de conteneur Linux qui inclut l’application ainsi que les packages de langage requis ainsi que les dépendances du système d’exploitation. Azure continue de fournir les fonctions hôte, intégration de déclencheurs, routage et mise à l’échelle.
Overview
Vous créez une image conteneur Linux qui inclut votre code de fonction, un travailleur de langage Functions supporté, les dépendances du langage et de l’application, ainsi que les paquets système, bibliothèques natives, exécutables, polices, certificats ou autres fichiers dont votre application a besoin à l’exécution.
Azure exécute et corrige l’hôte des fonctions et gère le routage, l’intégration des déclencheurs et la mise à l’échelle en dehors de l’image. Cette séparation vous permet de personnaliser l’environnement de travail tout en réduisant la surface de l’image et en supprimant la nécessité de regrouper, sécuriser et mettre à jour vous-même l’hôte des fonctions.
La Consommation Flexible utilise un modèle de conteneur worker uniquement. Votre image n’est pas un conteneur web arbitraire. Ce n’est pas non plus une image complète de Function App, qui regroupe l’hôte des fonctions, le worker de langage, l’application et les dépendances pour une autre option d’hébergement.
Pour un exemple complet qui empaquete une dépendance au niveau du système d’exploitation dans une image de conteneur réservée au worker, voir l’exemple de conteneur isolé Azure Functions Flex Consumption .NET.
Pour un exemple complet qui empaquete une dépendance au niveau du système d’exploitation dans une image de conteneur dédiée au worker, consultez l’exemple de conteneur Azure Functions Flex Consumption pour Python.
Pour un exemple complet qui empaquette une dépendance au niveau du système d’exploitation dans une image de conteneur réservée au worker, consultez l’exemple de conteneur Azure Functions Flex Consumption Go.
Pour un exemple complet qui empaquete une dépendance au niveau du système d’exploitation dans une image de conteneur uniquement de travail, consultez l’exemple Azure Functions Flex Consumption Node.js container.
Benefits
- Regroupez l’application, le worker de langage, les dépendances linguistiques et les dépendances au niveau du système d’exploitation dans une seule image versionnée.
- Choisissez quand adopter les mises à jour des workers, du runtime de langage et des dépendances en reconstruisant, testant et redéployant l’image.
- Conservez l’hôte Functions, l’intégration des déclencheurs, le routage et la mise à l’échelle, gérés et mis à jour par Azure, hors de l’image.
- Réduisez les composants que vous devez inclure, sécuriser et maintenir dans votre image par rapport à une image complète de l’application de fonctions.
Quand utiliser cette fonctionnalité
Utilisez des conteneurs pour les dépendances au niveau du système d’exploitation sur la consommation Flex lorsque :
- Votre application Flex Consumption nécessite des dépendances que vous ne pouvez pas obtenir uniquement via le gestionnaire de paquets linguistiques.
- Vous pouvez créer, scanner, patcher, tester et publier une image Linux.
- Vous pouvez conserver l’image de base sélectionnée et la version du worker de langage dans l’image.
Comparer les options d’hébergement de conteneurs
Choisissez le modèle d’hébergement correspondant à la partie de l’environnement d’exécution que vous devez contrôler.
| Capacité | Image du conteneur Flex Consumption | Image personnalisée Elastic Premium ou dédiée (App Service) | Fonctions sur Azure Container Apps |
|---|---|---|---|
| Contrat d’image conteneur | Travailleurs uniquement | Image complète de Function App | Image complète de Function App |
| Hôte/runtime Functions | Fourni, exploité et corrigé par Azure en dehors de votre image | Inclus dans votre image, normalement à partir d’une image de base Fonctions | Inclus dans votre image |
| Votre image contient | App, un seul travailleur linguistique, dépendances linguistiques/applications et packages d’OS | Hôte Functions, worker, application et dépendances | Hôte Functions, worker, application et dépendances |
| Scaling | Mise à l’échelle Flex Consumption gérée par Functions | Mise à l’échelle Premium gérée par Functions ou mise à l’échelle du plan App Service | Mise à l’échelle des applications conteneurs |
| Billing | Facturation standard Flex Consumption | Facturation des forfaits Elastic Premium ou App Service | Facturation de Container Apps |
| Meilleur ajustement | Ajouter des dépendances au niveau du système d’exploitation tout en conservant le contrat de la plateforme serverless Flex | Contrôler un conteneur Functions complet sur l’infrastructure App Service | Exécuter des conteneurs Functions complets avec les fonctionnalités de Container Apps |
Pour plus d’informations sur les images complètes de Function App, voir Support des conteneurs Linux dans Azure Functions.
Architecture et limites de responsabilité
Un événement ou une requête HTTP atteint d’abord la plateforme Azure Functions gérée. Azure exécute l’hôte Functions et le runtime, évalue les déclencheurs, achemine les invocations et détermine quand ajouter ou retirer des instances. Lorsqu’une invocation est prête, la plateforme l’envoie au processus worker de langage Azure Functions dans votre image. Le worker linguistique charge votre application de fonction, et votre application peut utiliser les dépendances au niveau du langage, de l’application et du système d’exploitation incluses dans l’image.
Votre image n’inclut pas ni ne remplace l’hôte Functions, n’implémente pas le routage des déclencheurs, ni ne contrôle l’échellement de la plateforme. Vous maintenez l’application, le worker de langage, l’image de base et les dépendances à l’intérieur de l’image. Microsoft maintient et met à jour les composants de la plateforme Functions en dehors de l’image.
Le worker de langage Functions actif doit être l’un des workers répertoriés dans le tableau de prise en charge de la préversion. L’aperçu ne permet pas de le remplacer par un worker de langage arbitraire développé par le client ou un gestionnaire personnalisé. L’image peut inclure d’autres environnements d’exécution ou exécutables, tels qu’un composant Rust invoqué par une fonction prise en charge, en tant que dépendances d’application. La restriction d’un seul travailleur s’applique aux travailleurs du langage Fonctions actifs, et non aux runtimes auxiliaires ou aux outils fournis avec l’application.
Prise en charge des langues en préversion
L’aperçu prend en charge les processus de langage Functions suivants. Sélectionnez votre langue en haut de l’article pour les versions d’exécution prises en charge, les informations de compatibilité des workers et un fichier Dockerfile d’exemple.
| Langage de fonction | Comment le worker est inclus |
|---|---|
| .NET isolé | Inclus dans les dépendances NuGet de l’application et dans la sortie de publication |
| Python | Ajouté comme artefact de travail Microsoft spécifique à une version Python |
| Node.js | Ajouté en tant qu’artefact worker Node.js publié par Microsoft |
| Go | Inclus via le SDK de travail Go et compilé dans le binaire de l’application |
Les autres workers de langage de Functions ne sont pas pris en charge pendant l’aperçu.
Prerequisites
Avant de commencer, vous avez besoin des éléments suivants :
- Une application utilisant un langage de prévisualisation pris en charge.
- Un environnement de compilation d’image compatible avec Docker.
- Une image Linux ou de base de langage que vous pouvez maintenir.
- La source de l’application et ses dépendances du langage.
- Les packages d’exploitation requis, les bibliothèques natives, les polices, les pilotes ou les outils.
- Accès à un registre de conteneurs.
- Permission de créer, de scanner, d’envoyer et de déployer des images.
L’aperçu prend en charge les images Linux amd64 .
Comprendre le modèle de conteneur Flex Consumption
Votre image est responsable de :
- La charge utile de l’application.
- Un runtime de langage Functions pris en charge.
- Dépendances linguistiques et applicatives.
- Dépendances au niveau du système d’exploitation.
- L’image Linux ou de base de langage que vous sélectionnez.
- Sécurité des images, remédiation des vulnérabilités et versions explicites des composants.
Azure est responsable de :
- L’hôte des fonctions.
- Intégration du routage et des déclencheurs.
- Mise à l’échelle gérée par les fonctions.
- Composantes de plateforme en dehors de votre image.
Flex Consumption vous permet de choisir l’image Linux ou de base linguistique qui correspond le mieux aux besoins de votre application et de votre organisation. Étendez cette image en ajoutant un worker de langage Functions pris en charge, votre application et ses dépendances selon ce modèle de conteneur avec worker uniquement. Microsoft fournit des artefacts worker versionnés et des fichiers Dockerfiles d’exemple pour vous aider à créer une image compatible, tandis qu’Azure gère l’hôte des fonctions en dehors de votre image.
Le démarrage du worker est spécifique au langage. Utilisez le fichier Dockerfile d’exemple pour votre langue au lieu de copier un point d’entrée depuis une autre langue. La plateforme fournit au travailleur les arguments de connexion RPC et le répertoire de l’application. Votre image démarre directement le binaire du travailleur linguistique ou de l’application ; elle n’installe ni ne démarre l’hôte Functions ni ne contient la configuration du point de terminaison de la plateforme.
Variables d’environnement et racine du script
Vous ne configurez pas les variables d’environnement de l’hôte Functions ou de connexion du worker. La plateforme injecte les valeurs d’identité, de connexion, de protocole et de bootstrap du worker dont le worker a besoin pour communiquer avec l’hôte Functions géré par Azure.
Lorsque votre application Flex Consumption utilise une image de conteneur, configurez le paramètre d’application AzureWebJobsScriptRoot=/home/site/wwwroot. Votre image doit placer l’application de fonction sur ce chemin. Azure injecte ce paramètre dans le conteneur à l'exécution, donc vous n'avez pas besoin de le déclarer comme une ENV instruction dans le fichier Docker. Vous pouvez continuer à utiliser d’autres paramètres d’application requis par votre application.
N’ajoutez ni FUNCTIONS_WORKER_RUNTIME ni FUNCTIONS_EXTENSION_VERSION à une application Flex Consumption qui utilise une image conteneur. La plateforme gère ces détails d’exécution en dehors de votre image.
Obtenir le worker de langage
Utilisez la référence du worker prise en charge documentée pour votre langue. Les exemples Python et Node.js utilisent des références aka.ms gérées par Microsoft qui pointent vers le dernier artefact du worker pris en charge. Leur outil de déploiement résout ou hache l’artefact actuel afin qu’une mise à jour du worker modifie l’entrée de construction de l’image.
Vérifiez les artefacts du worker téléchargés en utilisant la somme de contrôle SHA-256 publiée. Lorsqu’une référence flottante de travailleur est mise à jour, reconstruisez, testez, publiez et redéployez l’image avant d’adopter le travailleur mis à jour. Pour un worker fourni via une dépendance d’application, spécifiez la version de la dépendance dans le projet d’application.
.NET isolé
L’aperçu prend en charge le modèle worker isolé .NET sur .NET 10 et .NET 11. Une application isolée .NET inclut le worker Functions via ses dépendances NuGet normales et sa sortie de compilation. Le worker n'est pas publié comme un artefact distinct pour chaque version d'exécution .NET prise en charge. Spécifiez les versions de Microsoft.Azure.Functions.Worker et les packages associés dans le projet, puis publiez l’application dans /home/site/wwwroot.
Utilisez la dernière version de Azure.Functions.Sdk comme SDK de projet. Pour les projets existants, suivez Migrate to Azure.Functions.Sdk.
Utilisez les versions minimales de paquet suivantes :
-
Microsoft.Azure.Functions.Workerversion2.53.0-preview.1ou ultérieure. -
Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCorela version2.1.2-preview.1ou ultérieure, si votre application utilise l’intégration ASP.NET Core.
Important
Utilisez une version .NET prise en charge. Vous êtes responsable de sélectionner et de maintenir une image d’exécution .NET prise en charge ainsi que des dépendances d’application compatibles et d’un worker Functions compatible.
Pour les fichiers complets de l’application et du déploiement, voir l’exemple de conteneur isolé Azure Functions Flex Consumption .NET.
Dockerfile d’exemple pour .NET isolé
Le fichier Dockerfile d’exemple suivant publie l’application .NET en processus isolé et copie la sortie de publication dans une image d’exécution .NET 10 :
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"]
Cet exemple cible .NET 10. Lorsque vous sélectionnez une autre version .NET prise en charge, mettez à jour ensemble les deux balises image de base .NET et validez les versions des packages de travail de l’application et des fonctions.
Python
L’aperçu supporte Python 3.13 à Python 3.15. Une image Python contient l’application, les dépendances Python, les dépendances au niveau du système d’exploitation et un artefact du worker Python Functions pris en charge. L’artefact de travailleur doit correspondre à la version d’exécution Python dans l’image.
Important
Utilisez une version de Python prise en charge et son artefact de travail correspondant. Ne combinez pas un artefact worker pour une version Python avec une autre version d'exécution Python.
Commencez par l’exemple Dockerfile dans l’exemple de conteneur Python Azure Functions Flex Consumption.
L’application d’exemple utilise azure-functions==2.3.0. Le fichier Docker Python télécharge le worker Python supporté actuel à partir d’une référence gérée aka.ms par Microsoft, vérifie l’artefact téléchargé par son calcul SHA-256 publié, puis l’extrait dans l’image. Son point d’entrée démarre directement le travailleur Python.
Python Dockerfile
Les valeurs suivantes identifient l’image de base prise en charge et la référence de travail flottante pour chaque version Python :
| Version de Python | Image de base | Référence du worker |
|---|---|---|
| 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 |
Cet exemple cible Python 3.15. Créez un fichier nommé worker-release-url.txt contenant la référence du worker Python 3.15 provenant du tableau précédent. Lorsque vous sélectionnez Python 3.13 ou 3.14, mettez à jour ensemble l’image de base, la référence de travail et le nom de l’archive de travail.
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"]
L’exemple Azure résout la référence du worker flottante vers son URL de version GitHub avant de préparer le contexte de l’image. Le fichier Dockerfile exige que la somme de contrôle de cette version sélectionnée corresponde à la somme de contrôle actuellement publiée via aka.ms, puis vérifie l’archive. Si les références ne sont pas d’accord, la compilation échoue.
Depuis le répertoire contenant le fichier Dockerfile et les fichiers de l’application, créez et envoyez l’image. Cet exemple utilise Azure Container Registry et l’identité assignée au système :
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
L’aperçu supporte Go 1.27. Une image Go contient l’application, les dépendances au niveau du système d’exploitation, ainsi que le worker et le SDK Go Functions pris en charge compilés dans le binaire de l’application. Le worker n’est pas publié comme un artefact séparé pour chaque version de Go prise en charge.
Important
Utilisez une version Go prise en charge. Vous êtes responsable de compiler l’application avec une chaîne d’outils Go prise en charge et une version compatible du SDK worker Go Functions.
Commencez par le Dockerfile d’exemple du conteneur Go d’exemple Azure Functions Flex Consumption.
Le fichier d’exemple go.mod spécifie la version v1.0.2 de github.com/azure/azure-functions-golang-worker. Le fichier Go Dockerfile utilise une compilation multi-étapes et démarre directement le binaire de l’application compilée.
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"]
Depuis le répertoire contenant le fichier Dockerfile et les fichiers de l’application, créez et envoyez l’image. Cet exemple utilise Azure Container Registry et l’identité assignée au système :
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
L’aperçu supporte Node.js 24. Une image Node.js contient l’application, les dépendances Node.js, les dépendances au niveau du système d’exploitation et un artefact de processus de travail Node.js Functions pris en charge. Le worker n’est pas publié comme un artefact distinct pour chaque version du runtime Node.js prise en charge.
Important
Utilisez une version Node.js prise en charge. Vous êtes responsable de la sélection et de la maintenance d’une image de base Node.js prise en charge et des dépendances du worker Functions et de l’application compatibles.
Commencez par le fichier Dockerfile JavaScript ou TypeScript de l’exemple de conteneur Azure Functions Flex Consumption Node.js.
L’application d’exemple utilise @azure/functions la version 4.17.0. Le fichier Dockerfile Node.js télécharge le worker Node.js actuellement pris en charge depuis une référence gérée par Microsoft aka.ms et l’extrait dans l’image. L’outil de déploiement d’exemple calcule la valeur SHA-256 de l’artefact téléchargé, inclut cette valeur dans le hachage contextuel image, puis la transmet à la compilation de l’image pour vérification. Le point d’entrée de l’image démarre directement le travailleur Node.js.
Node.js Dockerfile
Les fichiers Dockerfiles suivants utilisent la mise en page des exemples de projets JavaScript et TypeScript. Mettez à jour les COPY commandes et les étapes de compilation pour correspondre à la structure de répertoires et à la sortie de compilation de votre application. Pour TypeScript, l’exemple compile l’application et copie le JavaScript généré depuis dist. Le dist répertoire est une convention d’exemple, et non une exigence du modèle de conteneur Flex Consumption. Assurez-vous que le champ main dans package.json identifie les fichiers JavaScript générés.
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"]
Depuis le répertoire contenant le fichier Dockerfile et les fichiers de l’application, créez et envoyez l’image. Cet exemple utilise Azure Container Registry et l’identité assignée au système :
(
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>
)
Créer l’image
Utilisez l’exemple de fichier Dockerfile pour votre langage pris en charge comme point de départ :
Commencez par le fichier Dockerfile d’exemple isolé .NET.
Commencez avec l’exemple Dockerfile Python.
Partez du Dockerfile d’exemple Go.
Commencez avec le fichier Dockerfile d’exemple Node.js.
Le fichier Dockerfile d'exemple assemble une image conteneur ; ce n'est pas une image de base fournie par Microsoft.
- Sélectionnez une image de base Linux ou de langage prise en charge à partir d’une source fiable pour votre organisation.
- Sélectionnez une balise de version de base explicite ou un digest immuable selon votre politique de chaîne d’approvisionnement. Évitez les balises flottantes telles que
latest. - Installez les packages OS requis et supprimez les données temporaires du gestionnaire de paquets.
- Restaurez ou installez les dépendances de langage et applicatives.
- Ajoutez la charge utile de l’application et le worker de langage Functions pris en charge.
- Configurez le point d’entrée spécifique à la langue selon l’exemple de fichier Dockerfile pour votre langue. N’intégrez pas la configuration du point de terminaison de plateforme dans l’image.
- Construisez et scannez l’image.
- Confirmez que l’image cible Linux
amd64et que les fichiers requis ainsi que les permissions d’exécutable sont présents. - Attribuez une balise de version ou un digest. Les deux formulaires de référence sont pris en charge, mais un digest est préféré pour le déploiement déterministe et le rollback.
L’aperçu ne fournit actuellement pas d’expérience développeur prise en charge pour exécuter ou tester localement l’image du conteneur.
Développement et test locaux
Développez votre code de fonction normalement. Utilisez les outils de test de votre langage et exécutez func start pour valider l’application source localement.
Après validation au niveau source, construisez l’image conteneur en utilisant le contrat d’image publié et le fichier Dockerfile d’exemple pour votre langue. Vous pouvez confirmer que la compilation réussit et inspecter l’architecture de l’image, les fichiers et les permissions. L’aperçu ne fournit actuellement pas d’expérience développeur prise en charge pour exécuter ou tester localement l’image du conteneur.
Poussez l’image, configurez l’application de fonction Flex Consumption en utilisant Azure CLI, et validez la charge de travail conteneurisée dans Azure.
Envoyer l’image vers un registre
Après avoir terminé les tests au niveau du code source, la création de l’image et les vérifications de sécurité :
- Taguez l’image pour le registry et le repository choisis.
- Authentifiez-vous auprès du registre d’images.
- Poussez une version image immuable.
- Enregistrez le tag et le condensé résultants.
- Confirmez que l’identité ou les informations d’identification utilisées par l’application Flex Consumption peuvent récupérer l’image.
Prise en charge du Registre
Publiez l’image sur le registre de conteneurs choisi.
La configuration de l’image conteneur prend en charge l’accès anonyme, l’authentification de base, l’identité assignée par le système et l’identité attribuée par l’utilisateur. Utilisez un accès anonyme pour une image publique. L’authentification de base fait référence aux noms des paramètres d’application contenant les identifiants du registre ; ne mettez pas directement de valeurs d’identification dans la configuration de l’image du conteneur. L’authentification par identité gérée attribuée par le système et par identité gérée attribuée par l’utilisateur s’appliquent à Azure Container Registry.
L’utilisation de conteneurs en Flex Consumption n’introduit pas de restrictions réseau supplémentaires. Les exigences existantes de réseautage Flex Consumption s’appliquent. Le registre configuré doit être accessible et résoluble par DNS depuis le chemin réseau de l’application.
Utiliser les références d’identité gérée et de Key Vault
Une application Flex Consumption utilisant une image conteneur prend en charge le même comportement d’identité gérée au niveau de l’application qu’une application Flex basée sur un package de code. Vous pouvez attribuer une identité assignée par le système ou par l’utilisateur à l’application de fonctions, et l’hôte des fonctions gérées par Azure ainsi que les extensions prises en charge peuvent utiliser cette identité normalement. Votre code d’application peut également utiliser l’identité attribuée via la bibliothèque d’identité Azure appropriée.
Les paramètres de l’application peuvent utiliser les références Key Vault de la même manière que les autres applications Flex Consumption. Vous configurez l’identité utilisée pour résoudre une référence Key Vault indépendamment de la méthode d’authentification utilisée pour extraire l’image du conteneur. Par exemple, vous pouvez utiliser une identité attribuée par l’utilisateur pour la pull du registre et une autre identité pour l’accès de l’application aux ressources Azure.
Configurer une application de fonction Flex Consumption pour utiliser une image de conteneur
Vous pouvez créer une nouvelle application de fonction Flex Consumption avec le déploiement du registre ou modifier une application existante éligible de BlobContainer déploiement en Registry déploiement.
Microsoft.Web/sites ressource utilise le type de stockage de déploiement pour identifier le modèle de déploiement :
- Une application de paquet de code utilise
properties.functionAppConfig.deployment.storage.typedéfini surBlobContainer. - Un déploiement d’image conteneur utilise
properties.functionAppConfig.deployment.storage.typedéfini surRegistry.
Pour un déploiement de registre :
- Réglez
deployment.storage.valuesur la référence d’image qualifiée. Conservez la valeur exactement. - Définissez
deployment.storage.authenticationsur une forme d’authentification prise en charge. - Omettre
functionAppConfig.runtime.
Choisissez une référence d’image
La properties.functionAppConfig.deployment.storage.value propriété doit contenir un nom d’hôte de registre entièrement qualifié ainsi qu’un tag, un digest explicite, ou les deux :
-
Condensé (recommandé) :
myregistry.example.com/app/worker@sha256:<digest> -
Tag :
myregistry.example.com/app/worker:v1 -
Étiquette et digest :
myregistry.example.com/app/worker:v1@sha256:<digest>
Lorsqu’une référence d’image contient à la fois une étiquette et un digest, la plateforme extrait l’image identifiée par le digest. Le tag est descriptif.
Une référence d’image sans étiquette explicite ou digest n’est pas prise en charge. Pour utiliser la latest balise, spécifiez-la explicitement comme myregistry.example.com/app/worker:latest. L’API rejette également la forme abrégée du registre qui omet le nom d’hôte du registre entièrement qualifié.
Pour une référence par balise uniquement, la plateforme résout la balise chaque fois qu’elle crée une instance de worker. Si le contenu de la balise change sans changement correspondant à deployment.storage.value, différentes versions d’image peuvent s’exécuter simultanément. Pour plus d’informations, voir Éviter de mettre à jour une balise mutable existante.
Configurez la ressource
Le fragment Bicep suivant montre la properties forme :
properties: {
functionAppConfig: {
deployment: {
storage: {
type: 'Registry'
value: '<qualified-image-reference>'
authentication: {
type: 'SystemAssignedIdentity'
}
}
}
}
}
Lors de la mise à jour, conservez les valeurs existantes scaleAndConcurrency et siteUpdateStrategy sauf si vous avez l’intention de les modifier.
Utilisez l’une de ces formes d’authentification :
| Type d’authentification | Champs supplémentaires | Usage |
|---|---|---|
Anonymous |
None | Puisez dans un registre qui autorise un accès anonyme. |
SystemAssignedIdentity |
None | Utilisez l’identité assignée par le système de l’application. |
UserAssignedIdentity |
userAssignedIdentityResourceId |
Utilisez l’identité attribuée par l’utilisateur spécifiée. |
Basic |
usernameSettingName, passwordSettingName |
Référencez les paramètres de l’application contenant les identifiants du registre. Ne mettez jamais les valeurs des identifiants directement dans le code. |
Lorsque vous lisez ou mettez à jour la ressource :
- Comparez
deployment.storage.typesans sensibilité aux majuscules avant de lireruntime.nameouruntime.version. Les applications utilisant le déploiement Registry omettentruntime. - Conservez
scaleAndConcurrency,siteUpdateStrategy, les noms des paramètres d’authentification et les champs non reconnusfunctionAppConfig, sauf si vous avez l’intention de les modifier. - Conservez la référence de l’image exactement comme elle est fournie.
Azure CLI
La version preview inclut la prise en charge de l’Azure CLI. Utilisez Azure CLI pour créer une application de fonction Flex Consumption avec une image de conteneur ou pour mettre à jour une application existante éligible.
Les options d’image s’appliquent à ces commandes :
az functionapp createaz functionapp deployment config setaz functionapp deployment config showaz functionapp show
| Argument | Alias | Purpose |
|---|---|---|
--deployment-image |
None | Référence d’image qualifiée. La valeur est envoyée inchangée. |
--deployment-image-auth-type |
--diat |
Anonymous, SystemAssignedIdentity, UserAssignedIdentity, ou Basic. |
--deployment-image-identity |
--dii |
ID de ressource d’identité attribué par l’utilisateur. |
--deployment-image-username-setting |
--dius |
Nom de paramètre d’application contenant le nom d’utilisateur du registre. |
--deployment-image-password-setting |
--dips |
Nom du paramètre d’application contenant le mot de passe du registre. |
Créer une application de fonction Azure avec une image conteneur
Créez une application de fonctions Flex Consumption qui utilise son identité assignée par le système pour extraire l’image depuis 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>
Mettre à jour une application de fonction existante pour utiliser une image conteneur
Transférer une application de fonctions Flex Consumption éligible de BlobContainer à Registry avec une identité attribuée par l’utilisateur :
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>
Modifiez une application existante qui utilise le déploiement du registre en authentification de base en faisant référence aux paramètres d’application des informations d’identification :
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
L’CLI envoie la référence d’image inchangée pour la validation du service. L’authentification de base accepte les noms de réglage, et non les valeurs des informations d’identification. Configurez séparément l’identité du registre et les attributions de rôles en utilisant des options telles que --assign-identity, --role, et --scope.
Les options d’exécution ne s’appliquent pas aux applications qui utilisent le déploiement Registry. Les commandes show renvoient les noms de configuration du registre et de paramètre d’authentification, mais jamais les identifiants du registre.
Vérifier le déploiement et la première invocation
Après le déploiement, validez l’image du conteneur et l’intégration de la plateforme dans Azure :
- Confirmez que l’application fait référence au tag d’image ou au digest prévu.
- Confirmez que la plateforme peut s’authentifier auprès du registre et récupérer l’image.
- Confirmez que le processus worker démarre et devient prêt.
- Confirmez que les fonctions et déclencheurs attendus ont été détectés.
- Invoquer une fonction représentative.
- Vérifiez que la dépendance requise au niveau du système d’exploitation est utilisée.
- Examinez la télémétrie de l’application pour détecter les échecs de démarrage et d’invocation.
Déclencheurs HTTP et non-HTTP
Pendant l’aperçu, une application de fonction Flex Consumption utilisant une image de conteneur prend en charge les mêmes déclencheurs HTTP et non-HTTP qu’une application Flex Consumption de paquet de code, sauf Durable Functions et l’extension Azure Service Bus.
Mettre à jour et restaurer une image
Utilisez un digest immuable pour des déploiements et des rollbacks prévisibles. Si vous utilisez des balises, attribuez une nouvelle balise à chaque version de l’image au lieu d’écraser une balise déjà utilisée.
Pour mettre à jour le code de l’application, le travailleur Functions, l’environnement d’exécution du langage, le système d’exploitation de base, les paquets OS ou les dépendances de l’application :
- Mettez à jour les versions explicites des composants dans la source de l’image.
- Reconstruis l’image.
- Exécutez des tests au niveau source, des vérifications de création d’image et de sécurité.
- Poussez la nouvelle image et enregistrez son empreinte ou attribuez-lui un nouveau tag.
- Mettez à jour l’application de fonction Flex Consumption pour qu’elle référence la nouvelle image.
- Vérifiez le démarrage, la découverte des déclencheurs et les invocations représentatives.
Microsoft ne corrige pas silencieusement une image que vous avez déjà créée. Surveillez les sources en amont pour votre image de base et vos dépendances, et reconstruisez lorsque des mises à jour sont nécessaires.
Comportement de déploiement, de drainage et de retour arrière de la plateforme
Lorsque vous mettez à jour l’application de fonction pour référencer un autre résumé d’image ou un autre tag, la mise à jour commence à se propager et déclenche les actions suivantes :
- Les nouvelles instances de travail utilisent l’image mise à jour.
- La plateforme identifie les déclencheurs dans l’image mise à jour et met à jour les déclencheurs de l’application enregistrés.
- Les instances existantes cessent d’accepter de nouvelles invocations et commencent à se vider sans attendre que l’image mise à jour démarre ou que la détection des déclencheurs soit terminée.
- La plateforme permet de se terminer les requêtes HTTP et les exécutions de fonctions non-HTTP déjà en cours d’exécution, jusqu’à la période de grâce de terminaison de la plateforme.
Ces actions se produisent en parallèle. La découverte des déclencheurs n’a pas besoin de se terminer avant que les instances existantes commencent à se vider.
Important
Une mise à jour d’image n’a pas de contrôle de santé préalable au déploiement ni de retour en arrière automatique. Si l’image mise à jour ne peut pas être récupérée, ne démarre pas ou ne peut pas terminer la détection du déclencheur, les instances précédentes se vident toujours. Les déclencheurs HTTP et non-HTTP peuvent échouer tant que vous n’avez pas configuré une image valide.
Si l’application de fonction est arrêtée lorsque vous mettez à jour sa référence d’image, la plateforme supprime toutes les instances existantes et enregistre la nouvelle référence. Lorsque vous lancez l’application, la plateforme utilise l’image mise à jour et identifie ses déclencheurs.
Évitez de mettre à jour une balise mutable existante
Pousser une nouvelle image sous la même étiquette mutable ne lance pas de mise à jour, car la référence d’image configurée sur l’application de fonctions n’a pas changé. Les instances existantes continuent d’utiliser l’image précédente. Les instances créées lors d’un redimensionnement ultérieur peuvent résoudre la balise vers la nouvelle image, ce qui peut entraîner l’exécution simultanée de différentes versions d’image.
Redémarrer l’application de fonction arrête progressivement les instances existantes afin que les instances nouvellement créées résolvent la balise mise à jour. Cependant, un redémarrage ne relance pas la détection des déclencheurs. Si l’image mise à jour ajoute ou modifie des fonctions ou des déclencheurs, mettez à jour l’application de fonction pour qu’elle référence un nouveau digest ou un nouveau tag.
Pour un comportement de déploiement prévisible, mettez à jour la Function App avec un nouveau digest immuable pour chaque version.
Restaurer une image
La plateforme n’annule pas automatiquement une mise à jour d’image infructueuse. Conservez le digest de chaque image précédemment validée.
Pour revenir en arrière, mettez à jour l’application de fonction afin qu’elle référence le digest ou le tag précédent qui fonctionne. Cette mise à jour initie la découverte des déclencheurs et provisionne de nouvelles instances de travail à partir de l’image restaurée.
Journalisation et télémétrie
Le comportement et les recommandations de journalisation d’Application Insights pour les applications Flex Consumption utilisant une image de conteneur sont les mêmes que pour Flex Consumption standard et les autres options d’hébergement Azure Functions.
Pour les journaux et traces d’applications, instrumentez votre application de fonction avec OpenTelemetry et envoyez la télémétrie directement à Application Insights. L’instrumentation directe est recommandée plutôt que de dépendre de l’hôte des fonctions pour transférer la télémétrie de l’application, surtout à mesure que l’application évolue. Pour des conseils de configuration, voir Utiliser OpenTelemetry avec Azure Functions.
Pour les journaux et traces d’application, instrumentez votre application de fonction Go avec OpenTelemetry. Le middleware Go worker exporte la télémétrie en utilisant les paramètres du protocole OpenTelemetry (OTLP). Envoyez la télémétrie vers un collecteur OpenTelemetry ou un autre pipeline de télémétrie qui la transmet à Azure Monitor. Une chaîne de connexion d’Application Insights seule ne suffit pas pour la télémétrie du travailleur Go. Pour des conseils de configuration, voir Utiliser OpenTelemetry avec Azure Functions.
La plateforme gérée par Azure continue de transmettre les erreurs de démarrage des travailleurs et d’indexation de fonctions vers Application Insights. Utilisez ces erreurs pour enquêter sur les défaillances survenant avant qu’une invocation de fonction n’atteigne le code de votre application.
L'expérience des métriques Azure Monitor sur le portail Azure n'est pas prise en charge en aperçu. Utilisez les journaux et traçages d’Application Insights pour surveiller et dépanner l’application.
Surveiller et résoudre les problèmes
Dépannez le déploiement selon l’ordre du cycle de vie :
- Configuration : Confirmez que l’application fait référence à l’image et aux paramètres d’authentification prévus.
- Accès au registre : Confirmez que l’identité ou les identifiants configurés peuvent accéder à l’image.
- Réseautage et DNS : Confirmez que la plateforme peut résoudre et atteindre le registry.
- Résolution et récupération de l’image : Confirmez que la balise ou le digest existe et utilise un format pris en charge.
- Démarrage : Confirmez que le processus worker démarre et établit la connexion à la plateforme propre au langage.
- Préparation des travailleurs : Confirmez que l’application est prête.
- Découverte et mise à l’échelle des déclencheurs : Confirmez que les fonctions et déclencheurs attendus sont détectés.
- Invocation : Confirmez que le travailleur reçoit les invocations et peut utiliser la dépendance packée.
- Mettre à jour ou restaurer : Confirmez que l’application fait référence à la version d’image prévue.
Collectez la référence de l’image, l’heure de déploiement, la version du worker, l’image de base, la région, le type de déclencheur et les identifiants de corrélation pertinents avant de contacter le support. N’incluez pas les identifiants du registre.
Responsabilités de sécurité, de patching et de maintenance
| Area | Responsabilités du client | Responsabilité de Microsoft |
|---|---|---|
| Linux de base ou image de langue | Sélectionnez une version explicite, analysez, patchez, reconstruisez et validez | Exigences de compatibilité de la plateforme de publication |
| Worker de langage Functions dans l’image | Spécifier une version prise en charge, l’inclure correctement, reconstruire, tester et redéployer les mises à jour | Publiez les artefacts du worker pris en charge, les informations de publication et les exemples |
| Dépendances du système d’exploitation et des applications | Sélectionner, configurer, attribuer une licence, analyser, corriger et valider | Publier les contraintes de plateforme |
| Code d’application | Construire, tester, analyser, patcher et déployer | Gérer les composants de plateforme gérés par Azure qui invoquent le travailleur |
| Provenance de l’image et registry | Appliquez les contrôles de la chaîne d’approvisionnement et restreignez l’accès | Prendre en charge le chemin documenté d’authentification du registre et de récupération d’images |
| Fonctions hôtes, routage, déclencheurs et mise à l’échelle | Configurez l’application via les interfaces prises en charge | Exploiter et corriger la plateforme gérée par Azure |
Utilisez l’accès au registre à privilège minimum, les versions d’image immuables, l’analyse des vulnérabilités, les pratiques de liste des documents logiciels et les sources d’artefacts fiables selon les politiques de votre organisation.
Limitations de la version préliminaire
- Durable Functions n'est pas pris en charge.
- L'extension Azure Service Bus n'est pas prise en charge.
- Le support de la zone de disponibilité n’est pas disponible.
- Les images doivent cibler Linux
amd64. - Le support linguistique de prévisualisation est limité à .NET isolé, Python, Node.js et Go.
- L’aperçu ne fournit actuellement pas d’expérience développeur prise en charge pour exécuter ou tester localement l’image du conteneur.
- L'expérience des métriques Azure Monitor dans le portail Azure n'est pas prise en charge. Utilisez les journaux et Application Insights pour la surveillance.