Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Importante
Este recurso está em pré-visualização. As capacidades de pré-visualização podem mudar.
Ao utilizar suporte a dependências ao nível do sistema operativo através de contentores, pode executar aplicações da função Flex Consumption que precisam de mais do que apenas código de aplicação e pacotes de linguagem no seu ambiente de execução. Fornece uma imagem de contentor Linux que inclui a aplicação e as dependências de linguagem e do SO necessárias. O Azure continua a fornecer o host do Functions, integração de triggers, roteamento e escalamento.
Overview
Cria uma imagem de contentor Linux que inclui o código da sua função, um worker de linguagem Functions suportado, dependências de linguagem e aplicação, bem como os pacotes de sistema, bibliotecas nativas, executáveis, fontes, certificados ou outros ficheiros de que a sua aplicação necessita em tempo de execução.
O Azure executa e aplica patches ao host das Funções e gere o encaminhamento, a integração de triggers e o escalamento fora da imagem. Esta separação permite-lhe personalizar o ambiente do worker, reduzindo simultaneamente a área de superfície da imagem e eliminando a necessidade de empacotar, proteger e atualizar o anfitrião do Functions por si próprio.
O Flex Consumption utiliza um modelo de contentor apenas para trabalhadores. A tua imagem não é um contentor web arbitrário. Também não é uma imagem completa da Function App, que agrupa o host das Funções, o worker da língua, a aplicação e as dependências para outra opção de alojamento.
Para um exemplo completo que empacota uma dependência ao nível do sistema operativo numa imagem de contentor apenas worker, consulte o exemplo de contentor isolado Funções do Azure Flex Consumption .NET.
Para um exemplo completo que empacota uma dependência ao nível do sistema operativo numa imagem de contentor apenas de trabalho, consulte o exemplo de contentor Funções do Azure Flex Consumption Python.
Para um exemplo completo que empacota uma dependência ao nível do sistema operativo numa imagem de contentor apenas para trabalhadores, consulte o exemplo de contêiner Funções do Azure Flex Consumption Go.
Para um exemplo completo que empacota uma dependência ao nível do sistema operativo numa imagem de contentor só para worker, consulte o exemplo de contentor do Funções do Azure Flex Consumption Node.js.
Benefits
- Empacote a aplicação, o worker de idioma, as dependências de idioma e as dependências a nível de sistema operativo numa única imagem versionada.
- Escolha quando adotar atualizações de worker, runtime de linguagem e dependências reconstruindo, testando e reimplantando a imagem.
- Deixe o host do Functions, a integração de acionadores, o encaminhamento e o dimensionamento geridos e corrigidos pelo Azure fora da imagem.
- Reduza os componentes que deve incluir, proteger e manter na sua imagem em comparação com uma imagem completa da Aplicação de Funções.
Quando utilizar esta funcionalidade
Utilize contentores para dependências ao nível do SO no Flex Consumption quando:
- A sua aplicação Flex Consumption requer dependências que não consegue obter apenas através do gestor de pacotes da linguagem.
- Pode compilar, analisar, aplicar patches, testar e publicar uma imagem Linux.
- Pode gerir a imagem base selecionada e a versão do worker de idioma na imagem.
Compare opções de alojamento de contentores
Escolha o modelo de alojamento que corresponda à parte do tempo de execução que precisa de controlar.
| Capacidade | Imagem do contentor Flex Consumption | Imagem personalizada Elastic Premium ou Dedicated (App Service) | Funções no Azure Container Apps |
|---|---|---|---|
| Especificação da imagem | Apenas worker | Imagem completa da Function App | Imagem completa da Function App |
| Anfitrião/tempo de execução do Functions | Fornecido, operado e atualizado pelo Azure fora da sua imagem | Incluído na sua imagem, normalmente a partir de uma imagem base de Funções | Incluído na sua imagem |
| A sua imagem contém | Aplicação, um worker de linguagem, dependências de idioma/aplicação e pacotes de sistema operativo | Funções host, worker, app e dependências | Funções host, worker, app e dependências |
| Scaling | Escalamento de Consumo Flexível gerido por funções | Escalamento Premium gerido por funções ou escalamento do plano App Service | Dimensionamento do Container Apps |
| Billing | Faturação padrão de Standard Flex Consumption | Faturação do plano Elastic Premium ou App Service | Faturação de Container Apps |
| Melhor ajuste | Adicionar dependências ao nível do sistema operativo mantendo o contrato da plataforma serverless Flex | Controle um contentor completo de Functions na infraestrutura do App Service | Execute contentores completos de Functions com capacidades de Container Apps |
Para mais informações sobre imagens completas da Function App, consulte suporte a contentores Linux no Funções do Azure.
Arquitetura e fronteira de responsabilidade
Um evento ou pedido HTTP chega primeiro à plataforma de Funções geridas pelo Azure. O Azure executa o host e o runtime do Functions, avalia triggers, encaminha invocações e determina quando adicionar ou remover instâncias. Quando uma invocação está pronta, a plataforma envia-a para o language worker do Functions na sua imagem. O worker de linguagem carrega a sua aplicação de funções, e a sua aplicação pode usar as dependências de linguagem, aplicação e nível de sistema operativo incluídas na imagem.
A sua imagem não inclui nem substitui o host do Functions, não implementa o encaminhamento de gatilhos nem controla a escala da plataforma. Você mantém a aplicação, o language worker, a imagem base e as dependências dentro da imagem. A Microsoft mantém e atualiza os componentes da plataforma Functions fora da imagem.
O worker de linguagem ativo das Funções deve ser um dos workers listados na tabela de suporte de pré-visualização. A pré-visualização não suporta a sua substituição por qualquer worker de linguagem ou handler personalizado desenvolvido pelo cliente. A imagem pode incluir outros runtimes ou executáveis, como um componente Rust invocado por uma função suportada, enquanto dependências da aplicação. A restrição de um único trabalhador aplica-se aos trabalhadores ativos da linguagem das Funções, não a runtimes auxiliares ou ferramentas incluídas na aplicação.
Suporte de idiomas em pré-visualização
A versão de pré-visualização suporta os seguintes workers de linguagem do Functions. Selecione o seu idioma no topo do artigo para ver versões em tempo de execução suportadas, informações sobre compatibilidade dos workers e um ficheiro Dockerfile de exemplo.
| Linguagem das Funções | Como o worker é incluído |
|---|---|
| .NET isolado | Incluído através das dependências NuGet da aplicação e da saída de publicação |
| Python | Adicionado como um artefacto de trabalho Microsoft específico da versão Python |
| Node.js | Adicionado como artefacto de worker do Node.js publicado pela Microsoft |
| Go | Incluído através do Go worker SDK e compilado no binário da aplicação |
Os workers de linguagem do Functions não são suportados durante a pré-visualização.
Prerequisites
Antes de começar, você precisa:
- Uma aplicação que utiliza uma linguagem em pré-visualização suportada.
- Um ambiente de construção de imagem compatível com Docker.
- Uma imagem base de Linux ou de linguagem que consiga manter.
- O código-fonte da aplicação e as suas dependências linguísticas.
- Os pacotes de sistema operativo necessários, bibliotecas nativas, fontes, drivers ou ferramentas.
- Acesso a um registo de contentores.
- Permissão para criar, analisar, publicar e implementar em produção imagens.
A pré-visualização suporta imagens Linux amd64 .
Compreenda o modelo de contentor Flex Consumption
A sua imagem é responsável por:
- A carga útil da aplicação.
- Um worker de linguagem do Functions suportado.
- Dependências de linguagem e aplicação.
- Dependências ao nível do sistema operativo.
- A imagem Linux ou da base de linguagem que selecionar.
- Segurança de imagem, remediação de vulnerabilidades e versões explícitas de componentes.
O Azure é responsável por:
- O anfitrião das Funções.
- Integração de roteamento e gatilhos.
- Escalamento gerido por funções.
- Componentes de plataforma fora da sua imagem.
O Flex Consumption permite-lhe escolher a imagem base Linux ou de linguagem que melhor se adequa às necessidades da sua aplicação e organização. Construa sobre essa imagem adicionando um worker de linguagem do Functions suportado, a sua aplicação e as respetivas dependências de acordo com este modelo de contentor só com o worker. A Microsoft disponibiliza artefactos do worker versionados e ficheiros Dockerfiles de exemplo para o ajudar a criar uma imagem compatível, enquanto o Azure gere o host de Funções fora da sua imagem.
O arranque do worker é específico da linguagem. Utilize o ficheiro Dockerfile de exemplo para o seu idioma em vez de copiar um ponto de entrada de outro idioma. A plataforma fornece ao trabalhador, os argumentos de ligação RPC e o diretório da aplicação. A sua imagem inicia diretamente o binário do worker da linguagem ou da aplicação; não instala nem inicia a configuração do host Functions nem do endpoint de plataforma.
Variáveis de ambiente e raiz do script
Não configura variáveis de ambiente do anfitrião do Functions ou de ligação do trabalhador. A plataforma injeta os valores de identidade do trabalhador, ligação, protocolo e bootstrap que o worker da linguagem necessita para comunicar com o host das Funções geridas pelo Azure.
Quando a sua aplicação Flex Consumption utiliza uma imagem de contentor, configure a definição AzureWebJobsScriptRoot=/home/site/wwwrootda aplicação. A sua imagem deve colocar a aplicação da função nesse caminho. O Azure injeta a definição no contentor em tempo de execução, por isso não precisa de a declarar como uma ENV instrução no Dockerfile. Pode continuar a usar outras definições da aplicação exigidas pela sua aplicação.
Não adicione FUNCTIONS_WORKER_RUNTIME nem FUNCTIONS_EXTENSION_VERSION a uma aplicação Flex Consumption que utilize uma imagem de contentor. A plataforma gere estes detalhes de execução fora da sua imagem.
Obtenha o worker de linguagem
Utilize a referência de worker suportada documentada para o seu idioma. Os exemplos Python e Node.js utilizam referências geridas aka.ms por Microsoft que apontam para o artefacto do worker suportado mais recente. A ferramenta de implementação deles resolve ou faz hash do artefacto atual para que uma atualização do worker altere a entrada de construção da imagem.
Verifique os artefactos do worker descarregados utilizando o checksum SHA-256 publicado. Quando a referência flutuante do worker é atualizada, reconstrua, teste, envie e volte a distribuir a imagem antes de adotar o worker atualizado. Para um worker fornecido através de uma dependência de aplicação, especifique a versão da dependência no projeto de aplicação.
.NET isolado
A pré-visualização suporta o modelo de worker isolado do .NET no .NET 10 e no .NET 11. Uma aplicação isolada .NET inclui o worker Functions através das suas dependências NuGet normais e da saída de compilação. O worker não é publicado como um artefacto separado para cada versão de runtime .NET suportada. Especifique as versões do Microsoft.Azure.Functions.Worker e do pacote relacionado no projeto, e publique a aplicação em /home/site/wwwroot.
Use a versão mais recente de Azure.Functions.Sdk como SDK do projeto. Para projetos existentes, consulte Migrar para Azure.Functions.Sdk.
Utilize as seguintes versões mínimas de pacotes:
-
Microsoft.Azure.Functions.Workerversão2.53.0-preview.1ou posterior. -
Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCoreversão2.1.2-preview.1ou posterior, se a sua aplicação utilizar a integração ASP.NET Core.
Importante
Utilize uma versão .NET suportada. É responsável por selecionar e manter uma imagem de runtime .NET suportada e um worker do Functions compatível, bem como as dependências da aplicação.
Para os ficheiros completos da aplicação e de implementação, consulte o exemplo de contentor isolado Funções do Azure Flex Consumption .NET.
Dockerfile de exemplo para .NET isolado
O seguinte Dockerfile de exemplo publica a aplicação isolada .NET e copia a saída de publicação para uma imagem de runtime .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"]
Este exemplo tem como alvo .NET 10. Ao selecionar outra versão .NET suportada, atualize ambas as etiquetas de imagem base .NET em conjunto e valide as versões do pacote de trabalho da aplicação e das Funções.
Python
A pré-visualização suporta Python 3.13 até Python 3.15. Uma imagem Python contém a aplicação, dependências de Python, dependências ao nível do sistema operativo e um worker artifact do Python Functions suportado. O artefacto worker deve corresponder à versão em tempo de execução Python na imagem.
Importante
Use uma versão do Python suportada e o respetivo artefacto de trabalho. Não combine um artefacto do worker para uma versão do Python com uma versão diferente do runtime do Python.
Comece com o exemplo Dockerfile no exemplo do contentor Funções do Azure Flex Consumption Python.
A aplicação de exemplo utiliza azure-functions==2.3.0. O ficheiro Python Dockerfile descarrega o worker Python suportado atualmente a partir de uma referência gerida aka.ms pela Microsoft, verifica o artefacto descarregado através do seu checksum SHA-256 publicado e extrai-o para a imagem. O seu ponto de entrada inicia diretamente o trabalhador Python.
Python Dockerfile
Os seguintes valores identificam a imagem base suportada e a referência do worker flutuante para cada versão de Python:
| Versão em Python | Imagem base | Referência do trabalhador |
|---|---|---|
| 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 |
Este exemplo tem como alvo o Python 3.15. Crie um ficheiro nomeado worker-release-url.txt que contenha a referência do worker Python 3.15 da tabela anterior. Quando selecionar Python 3.13 ou 3.14, atualize a imagem base, a referência do worker e o nome do arquivo do worker em conjunto.
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"]
O Azure Sample converte a referência flutuante do worker no URL da release versionada no GitHub antes de preparar o contexto da imagem. O Dockerfile exige que a soma de verificação dessa versão selecionada corresponda à soma de verificação atualmente publicada através de aka.ms, e depois verifica o arquivo compactado. Se as referências discordarem, a build falha.
A partir do diretório que contém o ficheiro Dockerfile e os ficheiros da aplicação, construa e envie a imagem. Este exemplo utiliza o Azure Container Registry e a identidade atribuída pelo sistema:
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
A pré-visualização suporta o Go 1.27. Uma imagem Go contém a aplicação, dependências ao nível do sistema operativo e o worker e SDK Go Functions suportados, compilados no binário da aplicação. O worker não é publicado como um artefacto separado para cada versão suportada do Go.
Importante
Use uma versão Go suportada. É responsável por compilar a aplicação com uma cadeia de ferramentas Go suportada e uma versão compatível do Go Functions worker SDK.
Comece com o exemplo Dockerfile no exemplo do contentor Funções do Azure Flex Consumption Go.
O ficheiro de exemplo go.mod especifica github.com/azure/azure-functions-golang-worker a versão v1.0.2. O Go Dockerfile utiliza uma compilação multinível e inicia diretamente o binário compilado da aplicação.
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"]
A partir do diretório que contém o ficheiro Dockerfile e os ficheiros da aplicação, construa e envie a imagem. Este exemplo utiliza o Azure Container Registry e a identidade atribuída pelo sistema:
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
A pré-visualização suporta Node.js 24. Uma imagem Node.js contém a aplicação, dependências do Node.js, dependências ao nível do sistema operativo e um artefacto do worker do Node.js Functions suportado. O worker não é publicado como um artefacto separado para cada versão suportada Node.js runtime.
Importante
Use uma versão Node.js suportada. É responsável por selecionar e manter uma imagem base Node.js suportada e dependências compatíveis do worker do Functions e da aplicação.
Comece com o exemplo de ficheiro Dockerfile de JavaScript ou TypeScript no exemplo de contentor Funções do Azure Flex Consumption Node.js.
A aplicação de exemplo utiliza @azure/functions a versão 4.17.0. O Dockerfile do Node.js descarrega o worker de Node.js suportado atualmente a partir de uma referência gerida pela Microsoft aka.ms e extrai-o para a imagem. A ferramenta de implementação de exemplo calcula o valor SHA-256 do artefacto descarregado, inclui esse valor no hash do contexto da imagem e passa-o para a versão da imagem para verificação. O ponto de entrada da imagem inicia o trabalhador Node.js diretamente.
Node.js Dockerfile
Os seguintes ficheiros Dockerfiles utilizam o layout dos projetos de exemplo JavaScript e TypeScript. Atualize os COPY comandos e os passos de compilação para corresponderem à estrutura de diretórios da sua aplicação e à saída da compilação. Para TypeScript, o exemplo compila a aplicação e copia o JavaScript gerado a partir de dist. O diretório dist é uma convenção de exemplo, não um requisito do modelo de contentor Flex Consumption. Certifique-se de que o campo main em package.json identifica os ficheiros JavaScript gerados.
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"]
A partir do diretório que contém o ficheiro Dockerfile e os ficheiros da aplicação, construa e envie a imagem. Este exemplo utiliza o Azure Container Registry e a identidade atribuída pelo sistema:
(
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>
)
Criar a imagem
Utilize o exemplo de ficheiro Dockerfile para o seu idioma suportado como ponto de partida:
Inicie a partir do ficheiro Dockerfile de exemplo isolado em .NET.
Comece a partir do Dockerfile de exemplo para Python.
Comece com o Dockerfile de exemplo do Go.
Comece pelo ficheiro Dockerfile de exemplo do Node.js.
O ficheiro Dockerfile de exemplo monta uma imagem de contentor; não é uma imagem base fornecida pela Microsoft.
- Selecione uma imagem Linux ou base de linguagem suportada a partir de uma fonte em que a sua organização confie.
- Selecione uma etiqueta explícita de versão da imagem base ou um digest imutável de acordo com a sua política de cadeia de abastecimento. Evite etiquetas flutuantes como
latest. - Instale os pacotes do sistema operativo necessários e remova os dados temporários do gestor de pacotes.
- Restaurar ou instalar dependências de idioma e aplicação.
- Adicione a carga útil da aplicação e o worker de linguagem Functions suportado.
- Configure o ponto de entrada específico da língua de acordo com o ficheiro Dockerfile de exemplo para a sua língua. Não incorpore a configuração do endpoint da plataforma na imagem.
- Construa e analise a imagem.
- Confirme que a imagem tem como alvo Linux
amd64e que os ficheiros necessários e as permissões de execução estão presentes. - Atribua uma etiqueta de versão ou um digest. Ambas as formas de referência são suportadas, mas um digest é preferido para implantação determinística e reversão.
A pré-visualização atualmente não oferece uma experiência de programador suportada para executar ou testar localmente a imagem do contentor.
Desenvolvimento local e testes
Desenvolve o teu código de função normalmente. Utilize as ferramentas de teste da sua linguagem e execute func start para validar localmente a aplicação.
Após a validação ao nível de origem, construa a imagem do contentor utilizando o contrato de imagem publicado e o ficheiro Dockerfile de exemplo para a sua linguagem. Pode confirmar que a compilação foi bem-sucedida e inspecionar a arquitetura da imagem, os ficheiros e as permissões. A pré-visualização atualmente não oferece uma experiência de programador suportada para executar ou testar localmente a imagem do contentor.
Envie a imagem, configure a aplicação da função Flex Consumption usando o CLI do Azure e valide a carga de trabalho conteinerizada no Azure.
Enviar a imagem para um registo
Depois de concluir testes ao nível de origem e verificações de construção de imagem e segurança:
- Identifique a imagem para o registo e repositório escolhidos.
- Autentica-te no registry.
- Enviar uma versão de imagem imutável.
- Registe a etiqueta resultante e o digest.
- Confirme que a identidade ou credencial usada pela aplicação Flex Consumption pode puxar a imagem.
Suporte ao registo
Publique a imagem no registo de contentores escolhido.
A configuração da imagem do contentor suporta acesso anónimo, autenticação básica, identidade atribuída pelo sistema e identidade atribuída pelo utilizador. Utilize o acesso anónimo para uma imagem pública. Autenticação básica faz referência a nomes de configuração de aplicação que contêm as credenciais do registo; não coloque valores de credenciais diretamente na configuração da imagem do contentor. A autenticação de identidade gerida atribuída pelo sistema e pelo utilizador aplica-se ao Azure Container Registry.
Usar contentores em Flex Consumption não introduz restrições adicionais de rede. Aplicam-se os requisitos existentes de rede de Flex Consumption. O registo configurado deve ser acessível e resolvível por DNS a partir do caminho de rede da aplicação.
Utilizar identidade gerida e referências do Key Vault
Uma aplicação Flex Consumption que utiliza uma imagem de contentor suporta o mesmo comportamento de identidade gerida ao nível da aplicação que uma aplicação Flex com pacote de código. Pode atribuir uma identidade atribuída pelo sistema ou pelo utilizador à aplicação de funções, e o host de Funções geridas pelo Azure e as extensões suportadas podem usar essa identidade normalmente. O seu código de aplicação também pode usar a identidade atribuída através da biblioteca de identidade Azure apropriada.
As definições da aplicação podem usar referências do Key Vault da mesma forma que outras aplicações no plano Flex Consumption. Configura a identidade usada para resolver uma referência do Key Vault independentemente do método de autenticação utilizado para puxar a imagem do contentor. Por exemplo, pode usar uma identidade atribuída pelo utilizador para o pull do registo e outra identidade para o acesso da aplicação aos recursos do Azure.
Configurar uma aplicação da função Flex Consumption para utilizar uma imagem de contentor
Pode criar uma nova aplicação da função Flex Consumption com a implementação do Registo ou alterar uma aplicação existente elegível de BlobContainer implementação para Registry implementação.
O Microsoft.Web/sites recurso utiliza o tipo de armazenamento de implementação para identificar o modelo de implementação:
- Uma aplicação de pacote de código usa
properties.functionAppConfig.deployment.storage.typedefinido comoBlobContainer. - Uma implementação de imagem de contentor utiliza
properties.functionAppConfig.deployment.storage.typedefinida comoRegistry.
Para implementação do Registry:
- Definir
deployment.storage.valuepara a referência de imagem qualificada. Preserve o valor exatamente. - Definir
deployment.storage.authenticationpara um tipo de autenticação suportado. - Omite
functionAppConfig.runtime.
Escolha uma referência de imagem
A properties.functionAppConfig.deployment.storage.value propriedade deve conter um nome de anfitrião de registo totalmente qualificado e uma etiqueta, digest explícito, ou ambos:
-
Digest (recomendado):
myregistry.example.com/app/worker@sha256:<digest> -
Etiqueta:
myregistry.example.com/app/worker:v1 -
Etiqueta e digest:
myregistry.example.com/app/worker:v1@sha256:<digest>
Quando uma referência de imagem contém tanto uma etiqueta como um digest, a plataforma obtém a imagem identificada pelo digest. A etiqueta é descritiva.
Uma referência de imagem sem uma tag ou digest explícito não é suportada. Para usar a latest etiqueta, especifique-a explicitamente como myregistry.example.com/app/worker:latest. A API também rejeita a abreviação do registo que omite o nome de host totalmente qualificado do registo.
Para uma referência só com tag, a plataforma resolve a tag sempre que cria uma instância de worker. Se o conteúdo da tag mudar sem uma alteração correspondente para deployment.storage.value, diferentes versões de imagem podem ser executadas ao mesmo tempo. Para mais informações, consulte Evitar atualizar uma etiqueta mutável existente.
Configurar o recurso
O seguinte fragmento do Bicep mostra a properties forma:
properties: {
functionAppConfig: {
deployment: {
storage: {
type: 'Registry'
value: '<qualified-image-reference>'
authentication: {
type: 'SystemAssignedIdentity'
}
}
}
}
}
Ao atualizar, preserve os valores existentes scaleAndConcurrency e siteUpdateStrategy a menos que pretenda alterá-los.
Utilize uma destas formas de autenticação:
| Tipo de autenticação | Campos adicionais | Usage |
|---|---|---|
Anonymous |
None | Retirar de um registry que permita acesso anónimo. |
SystemAssignedIdentity |
None | Utilize a identidade atribuída pelo sistema da aplicação. |
UserAssignedIdentity |
userAssignedIdentityResourceId |
Utilize a identidade atribuída pelo utilizador especificada. |
Basic |
usernameSettingName, passwordSettingName |
Consulte as definições da aplicação que contenham as credenciais do registry. Nunca coloque valores de credenciais embutidos. |
Quando lê ou atualiza o recurso:
- Compare
deployment.storage.typesem distinguir maiúsculas de minúsculas antes de lerruntime.nameouruntime.version. As aplicações que utilizam a implantação do Registry omitemruntime. - Mantenha
scaleAndConcurrency,siteUpdateStrategy, nomes das definições de autenticação e campos não reconhecidosfunctionAppConfig, a menos que pretenda alterá-los. - Mantenha a referência da imagem exatamente como fornecida.
CLI do Azure
A versão de pré-visualização inclui suporte para CLI do Azure. Utilize o CLI do Azure para criar uma aplicação de funções de Consumo Flexível com uma imagem de contentor ou para atualizar uma aplicação elegível existente.
As opções de imagem aplicam-se a estes comandos:
az functionapp createaz functionapp deployment config setaz functionapp deployment config showaz functionapp show
| Argument | Alias | Purpose |
|---|---|---|
--deployment-image |
None | Referência de imagem qualificada. O valor é enviado inalterado. |
--deployment-image-auth-type |
--diat |
Anonymous, SystemAssignedIdentity, UserAssignedIdentity, ou Basic. |
--deployment-image-identity |
--dii |
ID de recurso de identidade atribuído pelo utilizador. |
--deployment-image-username-setting |
--dius |
Nome da configuração da aplicação que contém o nome de utilizador do registo. |
--deployment-image-password-setting |
--dips |
Nome da configuração da aplicação que contém a palavra-passe do registo. |
Criar uma aplicação de funções com uma imagem de contentor
Crie uma aplicação da função Flex Consumption que utilize a sua identidade atribuída pelo sistema para extrair a imagem do 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>
Atualizar uma aplicação de funções existente para utilizar uma imagem de contentor
Altere uma aplicação de funções Flex Consumption elegível de BlobContainer para Registry com uma identidade atribuída pelo utilizador:
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>
Altere uma aplicação existente que utiliza a implementação através do Registry para autenticação Básica, referenciando as definições da aplicação de credenciais:
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
A CLI envia a referência de imagem inalterada para validação do serviço. A autenticação básica aceita nomes de configuração, não valores de credenciais. Configure em separado a identidade do registo e as atribuições de funções utilizando opções como --assign-identity, --role e --scope.
As opções de tempo de execução não se aplicam a aplicações que utilizam a implementação do Registry. Os comandos show retornam os nomes da configuração do registo e das definições de autenticação, mas nunca as credenciais do registo.
Verificar implantação e primeira invocação
Após a implantação, valide a imagem do contentor e a integração da plataforma no Azure:
- Confirme que a aplicação faz referência à tag ou digest da imagem pretendida.
- Confirme que a plataforma consegue autenticar-se no registry e obter a imagem.
- Confirme que o processo do trabalhador inicia e fica pronto.
- Confirme que as funções e gatilhos esperados foram descobertos.
- Invocar uma função representativa.
- Verifique se a dependência requerida ao nível do sistema operativo está a ser utilizada.
- Revise a telemetria da aplicação para falhas de arranque e invocação.
Triggers HTTP e não-HTTP
Durante a pré-visualização, uma aplicação da função Flex Consumption que utiliza uma imagem de contentor suporta os mesmos gatilhos HTTP e não-HTTP que uma aplicação Flex Consumption com pacote de código, exceto Durable Functions e a extensão Azure Service Bus.
Atualizar e reverter uma imagem
Use um digest imutável para implementações e reversões previsíveis. Se usar etiquetas, atribua uma nova etiqueta a cada versão da imagem em vez de sobrescrever uma etiqueta que já está em uso.
Para atualizar o código da aplicação, o worker de Funções, o runtime da linguagem, o sistema operativo base, os pacotes do sistema operativo ou as dependências da aplicação:
- Atualize as versões explícitas dos componentes no código-fonte da imagem.
- Reconstrua a imagem.
- Execute testes ao nível do código-fonte e verificações de construção de imagem e segurança.
- Envie a nova imagem e grave o seu digest ou atribua-lhe uma nova tag.
- Atualize a aplicação da função Flex Consumption para referenciar a nova imagem.
- Verifique o arranque, a descoberta de gatilhos e as invocações representativas.
A Microsoft não corrige silenciosamente uma imagem que já criou anteriormente. Acompanhe as fontes de origem da sua imagem base e dependências, e reconstrua quando forem necessárias atualizações.
Comportamento de rollout, drenagem e rollback da plataforma
Quando atualiza a aplicação de funções para referenciar um resumo ou etiqueta de imagem diferente, a atualização começa a propagar-se e desencadeia as seguintes ações:
- As novas instâncias de trabalhador utilizam a imagem atualizada.
- A plataforma identifica os triggers na imagem atualizada e atualiza os triggers registados da aplicação.
- As instâncias existentes deixam de aceitar novas invocações e começam a drenar sem esperar que a imagem atualizada inicie ou conclua a descoberta de triggers.
- A plataforma permite que pedidos HTTP e execuções de funções não-HTTP que já estejam em execução sejam concluídas, até ao período de carência da terminação da plataforma.
Estas ações ocorrem em paralelo. A descoberta de triggers não tem de terminar antes de as instâncias existentes começarem a escoar.
Importante
Uma atualização de imagem não tem uma verificação de integridade pré-implementação nem uma reversão automática. Se a imagem atualizada não puder ser obtida, falhar ao arrancar ou não conseguir concluir a descoberta de gatilhos, as instâncias anteriores continuam em drenagem. Os gatilhos HTTP e não-HTTP podem falhar até configurar uma imagem válida.
Se a aplicação de funções for parada quando atualiza a sua referência de imagem, a plataforma remove quaisquer instâncias existentes e regista a nova referência. Quando inicia a aplicação, a plataforma utiliza a imagem atualizada e identifica os seus acionadores.
Evite atualizar uma tag mutável existente
Fazer push de uma nova imagem com a mesma tag mutável não inicia um rollout porque a referência da imagem configurada na aplicação de funções não mudou. As instâncias existentes continuam a usar a imagem anterior. Instâncias criadas durante uma escala posterior podem resolver a etiqueta para a nova imagem, o que pode fazer com que diferentes versões de imagem sejam executadas ao mesmo tempo.
Reiniciar a aplicação de funções drena as instâncias existentes para que as instâncias recém-criadas resolvam a tag atualizada. No entanto, uma reinicialização não reexecuta a deteção de accionadores. Se a imagem atualizada adicionar ou alterar funções ou triggers, atualize a aplicação de funções para referenciar um novo resumo ou etiqueta.
Para um comportamento previsível de lançamento, atualize a aplicação de funções para um novo digest imutável para cada versão.
Reverter uma imagem
A plataforma não reverte automaticamente uma atualização de imagem sem sucesso. Conserve o digest de cada imagem previamente validada.
Para reverter, atualize a Function App para referenciar o digest ou a tag anteriores que funcionavam. Esta atualização inicia a descoberta de triggers e provisiona novas instâncias de trabalho a partir da imagem restaurada.
Registo e telemetria
As recomendações de comportamento e registo do Application Insights para aplicações Flex Consumption que utilizam uma imagem de contentor são as mesmas que para o Flex Consumption padrão e outras opções de alojamento do Funções do Azure.
Para registos e rastreamentos de aplicações, instrumente a sua aplicação de funções com OpenTelemetry e envie telemetria diretamente para Application Insights. Recomenda-se a instrumentação direta em vez de depender do host das Funções para encaminhar a telemetria da aplicação, especialmente à medida que a aplicação escala. Para orientações de configuração, consulte Use OpenTelemetry with Funções do Azure.
Para registos e rastreios de aplicações, instrumente a sua aplicação de função Go com OpenTelemetry. O middleware worker Go exporta a telemetria utilizando as definições do OpenTelemetry Protocol (OTLP). Envie a telemetria para um OpenTelemetry Collector ou outro pipeline de telemetria que a encaminhe para o Azure Monitor. Uma cadeia de ligação do Application Insights por si só não é suficiente para a telemetria do trabalhador Go. Para orientações de configuração, consulte Use OpenTelemetry with Funções do Azure.
A plataforma gerida pelo Azure continua a encaminhar erros de arranque de trabalhadores e indexação de funções para o Application Insights. Utilize estes erros para investigar falhas que ocorrem antes de uma invocação de função chegar ao código da sua aplicação.
A experiência das métricas do Azure Monitor no portal Azure não é suportada na pré-visualização. Utilize os registos e rastreamentos do Application Insights para monitorizar e diagnosticar e resolver problemas da aplicação.
Monitorizar e resolver problemas
Resolver problemas da implementação por ordem de ciclo de vida:
- Configuração: Confirme que a aplicação faz referência à imagem pretendida e às definições de autenticação.
- Acesso ao registo: Confirme que a identidade ou credenciais configuradas podem aceder à imagem.
- Rede e DNS: Confirme que a plataforma consegue resolver e aceder ao registry.
- Resolução e pull da imagem: Confirme que a tag ou digest existe e utiliza um formato suportado.
- Arranque: Confirme que o processo de worker inicia e estabelece a ligação à plataforma específica da língua.
- Preparação do trabalhador: Confirme que a aplicação está pronta.
- Descoberta e dimensionamento de triggers: Confirme que as funções e os triggers esperados são detetados.
- Invocação: Confirme que o worker recebe invocações e pode usar a dependência empacotada.
- Atualizar ou reverter: Confirme que a aplicação faz referência à versão da imagem pretendida.
Recolha a referência da imagem, a hora de implementação, a versão do trabalhador, a imagem base, a região, o tipo de gatilho e os identificadores de correlação relevantes antes de contactar o suporte. Não inclua credenciais de registry.
Responsabilidades de segurança, patches e manutenção
| Area | Responsabilidades do cliente | Responsabilidade da Microsoft |
|---|---|---|
| Linux base ou imagem de linguagem | Selecione uma versão explícita, analise, aplique patches, reconstrua e valide | Requisitos de compatibilidade para publicação na plataforma |
| processo de linguagem do Functions na imagem | Especifique uma versão suportada, inclua-a corretamente, reconstrua, teste e volte a implementar atualizações | Publicar artefactos do worker suportados, informações de lançamento e exemplos |
| Dependências do sistema operativo e das aplicações | Selecionar, configurar, licenciar, analisar, corrigir e validar | Publicar restrições da plataforma |
| Código do aplicativo | Compilar, testar, analisar, aplicar patches e implementar | Operar os componentes da plataforma gerida pelo Azure que invocam o worker |
| Proveniência e registo da imagem | Aplicar controlos na cadeia de abastecimento e restringir o acesso | Suportar o processo documentado de autenticação do registo e de obtenção de imagens |
| anfitrião do Functions, roteamento, accionadores e escalamento | Configure a aplicação através das interfaces suportadas | Operar e atualizar a plataforma gerida pelo Azure |
Utilize o acesso ao registo com privilégio mínimo, versões de imagem imutáveis, análise de vulnerabilidades, práticas de lista de materiais de software e fontes de artefactos confiáveis de acordo com as políticas da sua organização.
Limitações de pré-visualização
- Durable Functions não é suportado.
- A extensão Azure Service Bus não é suportada.
- O suporte para zonas de disponibilidade não está disponível.
- As imagens devem visar o Linux
amd64. - O suporte para a linguagem de pré-visualização está limitado a .NET isolado, Python, Node.jse Go.
- A pré-visualização atualmente não oferece uma experiência de programador suportada para executar ou testar localmente a imagem do contentor.
- A experiência de métricas do Azure Monitor no portal Azure não é suportada. Utilize registos e Application Insights para monitorização.