Guia de referência para programadores Azure Functions para aplicações Python

O Azure Functions é um serviço de computação serverless que lhe permite executar código orientado a eventos sem necessidade de provisionar ou gerir infraestrutura. As execuções de funções são desencadeadas por eventos como pedidos HTTP, mensagens de fila, temporizadores ou alterações no armazenamento — e escalam automaticamente com base na procura.

Este guia foca-se especificamente na construção de Funções Azure baseadas em Python e ajuda-o a:

Criar e executar aplicações de funções localmente
Compreender o modelo de programação em Python
Organize e configure a sua aplicação
Implemente e monitorize a sua aplicação no Azure
Aplicar as melhores práticas para escalabilidade e desempenho

Procura uma visão conceptual? Consulte a Referência para Desenvolvedores Azure Functions.

Interessado em casos de uso do mundo real? Explore a página de Cenários e Exemplos .

Como Começar

Escolha o ambiente que se adapte ao seu fluxo de trabalho e entre no Azure Functions para Python:

Criar a sua aplicação de funções

Esta secção cobre os componentes essenciais para criar e estruturar a sua aplicação de funções em Python. Os tópicos incluem o modelo de programação, estrutura do projeto, gatilhos e ligações, e gestão de dependências.

Modelo de programação

O Functions suporta duas versões do modelo de programação Python:

Versão	Descrição
2.x	Use uma abordagem baseada em decoradores para definir gatilhos e bindings diretamente no seu ficheiro de código Python. Implementas cada função como um método global e sem estado num `function_app.py` ficheiro ou num ficheiro blueprint referenciado. Esta versão do modelo é recomendada para novas aplicações Python.
1,x	Você define os triggers e ligações para cada função num ficheiro separado `function.json`. Implementas cada função como um método global e sem estado no teu ficheiro de código Python. Esta versão do modelo suporta aplicações legadas.

Este artigo dirige-se a uma versão específica do modelo Python. Escolha a versão desejada no topo do artigo.

Importante

Utilize o modelo de programação v2 para uma abordagem baseada em decoradores para definir triggers e bindings diretamente no seu código.

No modelo de programação Python v1, cada função é definida como um método global e sem main() estado dentro de um ficheiro chamado __init__.py. Os desencadeadores e associações da função são configurados separadamente num ficheiro function.json, e os valores de associação name são usados como parâmetros no seu método main().

Exemplo

Aqui está uma função simples que responde a um pedido HTTP:

# __init__.py
def main(req):
    user = req.params.get('user')
    return f'Hello, {user}!'

Aqui está o ficheiro correspondente function.json :

{
    "scriptFile": "__init__.py",
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "type": "http",
            "direction": "out",
            "name": "$return"
        }
    ]
}

Conceitos-chave

A função tem um único gatilho HTTP.
O objeto HttpRequest contém cabeçalhos de pedido, parâmetros de consulta, parâmetros de rota e o corpo da mensagem. Esta função obtém o valor do name parâmetro de consulta a partir do params parâmetro do objeto HttpRequest .
Para enviar um nome neste exemplo, adicione ?name={name} à URL da função exposta. Por exemplo, se for executado localmente, a URL completa pode parecer http://localhost:7071/api/http_trigger?name=Test. Para exemplos usando ligações, veja Triggers e Ligações.

Use o azure-functions SDK e inclua anotações de tipo para melhorar o suporte ao IntelliSense e ao editor:

# __init__.py
import azure.functions as func

def http_trigger(req: func.HttpRequest) -> str:

# requirements.txt
azure-functions

A `azure-functions` biblioteca

A azure-functions biblioteca Python fornece os tipos principais usados para interagir com o runtime Azure Functions. Para ver todos os tipos e métodos disponíveis, visite a azure-functions API. O seu código de função pode usar azure-functions para:

Dados de entrada do gatilho de acesso (por exemplo, HttpRequest, TimerRequest)
Criar valores de saída (como HttpResponse)
Interagir com o contexto fornecido em tempo de execução e com dados de ligação

Se estiver a utilizar azure-functions na sua aplicação, este deve ser incluído nas dependências do projeto.

Nota

A azure-functions biblioteca define a superfície de programação para Python Azure Functions, mas não é um SDK de uso geral. Use-o especificamente para criar e executar funções dentro do runtime Azure Functions.

Ponto de entrada alternativo

Pode alterar o comportamento padrão de uma função especificando as scriptFile propriedades e entryPoint no function.json ficheiro. Por exemplo, o ficheiro seguinte function.json direciona o tempo de execução para usar o custom_entry() método do main.py ficheiro como ponto de entrada para a sua função Azure.

{
  "scriptFile": "main.py",
  "entryPoint": "custom_entry",
  "bindings": [
      ...
  ]
}

Estrutura de pastas

Use a seguinte estrutura para um projeto Azure Functions em Python:

<project_root>/
│
├── .venv/                   # (Optional) Local Python virtual environment
├── .vscode/                 # (Optional) VS Code workspace settings
│
├── my_first_function/       # Function directory
│   └── __init__.py          # Function code file
│   └── function.json        # Function binding configuration file
│
├── my_second_function/
│   └── __init__.py  
│   └── function.json 
│
├── shared/                  # (Optional) Pure helper code with no triggers/bindings
│   └── utils.py
│
├── additional_functions/    # (Optional) Contains blueprints for organizing related Functions
│   └── blueprint_1.py  
│
├── tests/                   # (Optional) Unit tests for your functions
│   └── test_my_function.py
│
├── .funcignore              # Excludes files from being published
├── host.json                # Global function app configuration
├── local.settings.json      # Local-only app settings (not published)
├── requirements.txt         # (Optional) Defines Python dependencies for remote build
├── Dockerfile               # (Optional) For custom container deployment

Ficheiros-chave e pastas-chave

Ficheiro / Pasta	Descrição	Necessário para a aplicação correr no Azure
`my_first_function/`	Diretório para uma única função.	✅
`__init__.py/`	Script principal onde o `my_first_function` código da função está definido.	✅
`function.json/`	Contém a configuração de ligação para a `my_first_function` função.	✅
`host.json`	Configuração global para todas as funções na aplicação.	✅
`requirements.txt`	Dependências em Python instaladas durante a publicação ao usar compilação remota.	❌ (recomendado para gestão de pacotes)
`local.settings.json`	Configurações e segredos de aplicação somente locais (nunca publicados).	❌ (necessária para desenvolvimento local)
`.funcignore`	Especifica ficheiros e pastas a excluir da implementação (por exemplo, `.venv/`, `tests/`, `local.settings.json`).	❌ (recomendado)
`.venv/`	Ambiente virtual local para Python (excluído da implementação).	❌
`.vscode/`	Configuração do editor para Visual Studio Code. Não é obrigatório para a implementação.	❌
`shared/`	Detém código auxiliar partilhado em todo o projeto Function App	❌
`additional_functions/`	Usado para organização modular de código — tipicamente com blueprints.	❌
`tests/`	Testes unitários para a tua aplicação de funções. Não publicado no Azure.	❌
`Dockerfile`	Define um contentor personalizado para implementação.	❌

No modelo de programação Python v2, o Azure Functions utiliza uma abordagem baseada em decoradores para definir triggers e bindings diretamente no seu código. Cada função é implementada como um método global e sem estado dentro de um function_app.py ficheiro.

Exemplo

Aqui está uma função simples que responde a um pedido HTTP:

import azure.functions as func

app = func.FunctionApp()

@app.route("hello")
def http_trigger(req):
    user = req.params.get("user")
    return f"Hello, {user}!"

# requirements.txt
azure-functions

Conceitos-chave

O código importa o azure-functions pacote e usa decoradores e tipos para definir a aplicação funcional.
A função tem um único gatilho HTTP.
O objeto HttpRequest contém cabeçalhos de pedido, parâmetros de consulta, parâmetros de rota e o corpo da mensagem. Esta função obtém o valor do name parâmetro de consulta a partir do params parâmetro do objeto HttpRequest .
Para enviar um nome neste exemplo, adicione ?name={name} à URL da função exposta. Por exemplo, se for executado localmente, a URL completa pode parecer http://localhost:7071/api/http_trigger?name=Test. Para exemplos usando bindings, veja Triggers e Bindings.

A `azure-functions` biblioteca

A azure-functions biblioteca Python é uma parte central do modelo de programação Azure Functions. Fornece os decoradores, os tipos de trigger e de ligação, e os objetos de pedido/resposta usados para definir e interagir com funções durante o tempo de execução. Para ver todos os tipos e decoradores disponíveis, visite a azure-functions API. O código da sua aplicação de função depende desta biblioteca para:

Defina todas as funções usando o FunctionApp objeto
Declarar gatilhos e ligações (por exemplo, @app.route, @app.timer_trigger)
Aceder a entradas e saídas tipadas (como HttpRequest e HttpResponse, e Out')

Têm azure-functions de estar incluídos nas dependências do teu projeto. Para saber mais, consulte gestão de pacotes.

Nota

Use anotações de tipos para melhorar o suporte ao IntelliSense e ao editor:

def http_trigger(req: func.HttpRequest) -> str:

Organização com plantas arquitetónicas

Para aplicações maiores ou modulares, usa blueprints para definir funções em ficheiros Python separados e regista-as na tua aplicação principal. Esta separação mantém o seu código organizado e reutilizável.

Para definir e registar um blueprint:

Defina um blueprint noutro ficheiro Python, como http_blueprint.py:

import azure.functions as func

bp = func.Blueprint()

@bp.route(route="default_template")
def default_template(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello World!")

Registe o plano no ficheiro principal function_app.py :

import azure.functions as func
from http_blueprint import bp

app = func.FunctionApp()
app.register_functions(bp)

Ao utilizar modelos (blueprints), pode:

Divide a tua aplicação em módulos reutilizáveis
Mantenha as funções relacionadas agrupadas por ficheiro ou característica
Estenda ou partilhe planos entre projetos

Nota

O Durable Functions também suporta blueprints usando azure-functions-durable. Ver exemplo →

Estrutura de pastas

Use a seguinte estrutura para um projeto Azure Functions em Python:

<project_root>/
│
├── .venv/                   # (Optional) Local Python virtual environment
├── .vscode/                 # (Optional) VS Code workspace settings
│
├── function_app.py          # Main function entry point (decorator model)
├── shared/                  # (Optional) Pure helper code with no triggers/bindings
│   └── utils.py
│
├── additional_functions/    # (Optional) Contains blueprints for organizing related Functions
│   └── blueprint_1.py  
│
├── tests/                   # (Optional) Unit tests for your functions
│   └── test_my_function.py
│
├── .funcignore              # Excludes files from being published
├── host.json                # Global function app configuration
├── local.settings.json      # Local-only app settings (not published)
├── requirements.txt         # (Optional) Defines Python dependencies for remote build
├── Dockerfile               # (Optional) For custom container deployment

Ficheiros-chave e pastas-chave

Ficheiro / Pasta	Descrição	Necessário para a aplicação correr no Azure
`function_app.py`	Script principal onde Azure Functions e triggers são definidos usando decoradores.	✅
`host.json`	Configuração global para todas as funções na aplicação.	✅
`requirements.txt`	Dependências em Python instaladas durante a publicação ao usar compilação remota.	❌ (recomendado para gestão de pacotes)
`local.settings.json`	Configurações e segredos de aplicação somente locais (nunca publicados).	❌ (necessária para desenvolvimento local)
`.funcignore`	Especifica ficheiros e pastas a excluir da implementação (por exemplo, `.venv/`, `tests/`, `local.settings.json`).	❌ (recomendado)
`.venv/`	Ambiente virtual local para Python (excluído da implementação).	❌
`.vscode/`	Configuração do editor para Visual Studio Code. Não é obrigatório para a implementação.	❌
`shared/`	Detém código auxiliar partilhado em todo o projeto Function App	❌
`additional_functions/`	Usado para organização modular de código — tipicamente com blueprints.	❌
`tests/`	Testes unitários para a tua aplicação de funções. Não publicado no Azure.	❌
`Dockerfile`	Define um contentor personalizado para implementação.	❌

[NOTA!] Inclui um requirements.txt ficheiro quando implementares com compilação remota. Se não usares compilação remota ou quiseres usar outro ficheiro para definir dependências de aplicações, podes fazer uma compilação local e implementar a aplicação com dependências pré-construídas.

Para orientações sobre testes unitários, consulte Testes Unitários. Para implementações de contentores, veja Implementar com contentores personalizados.

Acionadores e enlaces

O Azure Functions usa triggers para iniciar a execução de funções e bindings para ligar o seu código a outros serviços como armazenamento, filas e bases de dados. No modelo de programação Python v2, declaras bindings usando decoradores.

Existem dois tipos principais de encadernações:

Triggers (entrada que inicia a função)
Entradas e saídas (fontes ou destinos de dados extra)

Para mais informações sobre os gatilhos e ligações disponíveis, consulte Gatilhos e Ligações nas Funções Azure.

Exemplo: Gatilho do Temporizador com Entrada de Blob

Esta função:

Aciona a cada 10 minutos
Lê a partir de um Blob usando Ligações de Tipo SDK
Armazena em cache os resultados e grava num ficheiro temporário

import azure.functions as func
import azurefunctions.extensions.bindings.blob as blob
import logging
import tempfile

CACHED_BLOB_DATA = None

app = func.FunctionApp()

@app.function_name(name="TimerTriggerWithBlob")
@app.schedule(schedule="0 */10 * * * *", arg_name="mytimer")
@app.blob_input(arg_name="client",
                path="PATH/TO/BLOB",
                connection="BLOB_CONNECTION_SETTING")
def timer_trigger_with_blob(mytimer: func.TimerRequest,
                            client: blob.BlobClient,
                            context: func.Context) -> None:
    global CACHED_BLOB_DATA
    if CACHED_BLOB_DATA is None:
        # Download blob and save as a global variable
        CACHED_BLOB_DATA = client.download_blob().readall()

        # Create temp file prefix
        my_prefix = context.invocation_id
        temp_file = tempfile.NamedTemporaryFile(prefix=my_prefix)
        temp_file.write(CACHED_BLOB_DATA)
        logging.info(f"Cached data written to {temp_file.name}")

Conceitos-chave

Usa bindings de tipos SDK para trabalhar com tipos ricos. Para mais informações, consulte ligações de tipos SDK.
Podes usar variáveis globais para armazenar em cache cálculos caros, mas o seu estado não garante que persista em execuções de funções.
Ficheiros temporários são armazenados em tmp/ e não é garantido que persistam entre invocações ou em instâncias de scale-out.
Pode aceder ao contexto de invocação de uma função através da classe Context.

Exemplo: HTTP Trigger com entrada do Cosmos DB e saída do Event Hub

Esta função:

Gatilhos em um pedido HTTP
Leituras de um DB Cosmos
Escreve numa saída do Event Hub
Devolve uma resposta HTTP

# __init__.py
import azure.functions as func

def main(req: func.HttpRequest,
         documents: func.DocumentList,
         event: func.Out[str]) -> func.HttpResponse:

    # Content from HttpRequest and Cosmos DB input
    http_content = req.params.get("body")
    doc_id = documents[0]["id"] if documents else "No documents found"

    event.set(f"HttpRequest content: {http_content} | CosmosDB ID: {doc_id}")

    return func.HttpResponse(
        "Function executed successfully.",
        status_code=200
    )

// function.json
{
  "scriptFile": "__init__.py",
  "entryPoint": "main",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"],
      "route": "file"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "cosmosDB",
      "direction": "in",
      "name": "documents",
      "databaseName": "test",
      "containerName": "items",
      "id": "cosmosdb-input-test",
      "connection": "COSMOSDB_CONNECTION_SETTING"
    },
    {
      "type": "eventHub",
      "direction": "out",
      "name": "event",
      "eventHubName": "my-test-eventhub",
      "connection": "EVENTHUB_CONNECTION_SETTING"
    }
  ]
}

Conceitos-chave

Cada função tem um único gatilho, mas pode ter múltiplas ligações.
Adicionar entradas especificando o direction como "in" em function.json. As saídas têm um direction de out.
Pode aceder aos detalhes do pedido através do HttpRequest objeto e construir um personalizado HttpResponse com cabeçalhos, código de estado e corpo.

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTriggerWithCosmosDB")
@app.route(route="file")
@app.cosmos_db_input(arg_name="documents",
                     database_name="test",
                     container_name="items",
                     connection="COSMOSDB_CONNECTION_SETTING")
@app.event_hub_output(arg_name="event",
                      event_hub_name="my-test-eventhub",
                      connection="EVENTHUB_CONNECTION_SETTING")
def http_trigger_with_cosmosdb(req: func.HttpRequest,
                               documents: func.DocumentList,
                               event: func.Out[str]) -> func.HttpResponse:
    # Content from HttpRequest and Cosmos DB input
    http_content = req.params.get('body')
    doc_id = documents[0]['id']

    event.set("HttpRequest content: " + http_content
              + " | CosmosDB ID: " + doc_id)

    return func.HttpResponse(
        f"Function executed successfully.",
        status_code=200
    )

Conceitos-chave

Use @route() ou decoradores específicos para gatilhos (@timer_trigger, @queue_trigger, e outros) para definir como a sua função é invocada.
Adiciona entradas usando decoradores como @blob_input, @queue_input, e outros.
As saídas podem ser:
- Retornado diretamente (caso haja apenas uma saída)
- Atribuído através das associações Out e do método .set() para saída múltipla.
Pode aceder aos detalhes do pedido através do HttpRequest objeto e construir um personalizado HttpResponse com cabeçalhos, código de estado e corpo.

Ligações de tipo SDK

Para selecionar gatilhos e associações, você pode trabalhar com tipos de dados implementados pelos SDKs e estruturas subjacentes do Azure. Ao usar estas ligações de tipos de SDK, pode interagir com dados de ligação como se estivesse a usar o SDK de serviço subjacente. Para mais informações, veja as ligações de tipos SDK suportadas.

Importante

O suporte a bindings do tipo SDK para Python está disponível apenas no modelo de programação Python v2.

Variáveis de ambiente

As variáveis de ambiente no Azure Functions permitem-lhe gerir de forma segura valores de configuração, cadeias de ligação e segredos da aplicação sem os codificar diretamente no seu código de função.

Pode definir variáveis de ambiente:

Localmente: no ficheiro local.settings.json, durante o desenvolvimento local.
No Azure: como Definições de Aplicação na página de configuração da sua Function App no portal Azure.

Acede diretamente às variáveis no teu código usando os.environ ou os.getenv.

setting_value = os.getenv("myAppSetting", "default_value")

Nota

O Azure Functions também reconhece variáveis do ambiente do sistema que configuram o tempo de execução de Functions e o comportamento do worker em Python. Estas variáveis não são usadas explicitamente no código da sua função, mas afetam a forma como a sua aplicação corre. Para uma lista completa de variáveis do ambiente do sistema, consulte a referência de definições da aplicação.

Gestão de pacotes

Para usar outros pacotes Python na tua aplicação Azure Functions, lista-os num requirements.txt ficheiro na raiz do teu projeto. Estes pacotes são importados pelo sistema de importação do Python, e depois podes referenciar esses pacotes como habitualmente. Para saber mais sobre opções de construção e implementação com dependências externas, consulte Opções de Construção para Aplicações de Funções em Python.

Por exemplo, o exemplo seguinte mostra como o requests módulo é incluído e utilizado na aplicação de funções.

<requirements.txt>
requests==2.31.0

Instale o pacote localmente com pip install -r requirements.txt.

Depois de instalado o pacote, pode importá-lo e usá-lo no seu código de função:

import azure.functions as func
import requests

def main(req: func.HttpRequest) -> func.HttpResponse:
    r = requests.get("https://api.github.com")
    return func.HttpResponse(f"Status: {r.status_code}")

import azure.functions as func
import requests

app = func.FunctionApp()

@app.function_name(name="HttpExample")
@app.route(route="call_api")
def main(req: func.HttpRequest) -> func.HttpResponse:
    r = requests.get("https://api.github.com")
    return func.HttpResponse(f"Status: {r.status_code}")

Considerações

Conflitos com módulos incorporados:
- Evite nomear as pastas dos seus projetos como as bibliotecas padrão do Python (por exemplo, email/, json/).
- Não inclua bibliotecas nativas de Python (como logging, , ou asyncio) em uuidrequirements.txt.
Desdobramento:
- Para evitar ModuleNotFound erros, certifique-se de que todas as dependências necessárias estão listadas em requirements.txt.
- Se atualizar a versão Python da sua aplicação, reconstrua e reimplemente a sua aplicação na nova versão Python para evitar conflitos de dependência com pacotes previamente construídos.
Dependências não relacionadas com PyPI:
- Pode incluir dependências que não estão disponíveis no PyPI na sua aplicação, como pacotes locais, ficheiros do volante ou feeds privados. Consulte Dependências personalizadas em Python Azure Functions para instruções de configuração.
Dependências de trabalhadores em Python do Azure Functions:
- Se o seu pacote contiver certas bibliotecas que possam colidir com dependências do trabalhador (por exemplo, protobuf ou grpcio), configure PYTHON_ISOLATE_WORKER_DEPENDENCIES a 1 nas definições da aplicação para evitar que a sua aplicação se refira às dependências do trabalhador. Para Python 3.13 e superiores, esta funcionalidade está ativada por padrão.

Funcionamento e implantação

Esta secção fornece informações sobre funções em execução localmente, suporte a versões em Python, opções de compilação e implementação, e configuração em tempo de execução. Use esta informação para executar com sucesso a sua aplicação de funções tanto em ambientes locais como Azure.

Executando localmente

Podes executar e testar a tua aplicação de funções Python na tua máquina local antes de a implementar no Azure.

Usando as Ferramentas do Core do Azure Functions

Instale o Azure Functions Core Tools e inicie o runtime local executando o func start comando a partir da raiz do seu projeto:

func start

Quando inicia a aplicação de funções localmente, o Core Tools mostra todas as funções que encontra para a sua aplicação:

Functions:
        http_trigger:  http://localhost:7071/api/http_trigger

Pode saber mais sobre como usar Core Tools visitando Develop Azure Functions localmente usando Core Tools.

Invocação direta da função

Ao usar azure-functions >= 1.21.0, também pode chamar funções diretamente usando o interpretador Python sem correr o Core Tools. Esta abordagem é útil para testes unitários rápidos:

# function_app.py
import azure.functions as func

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="http_trigger")
def http_trigger(req: func.HttpRequest) -> func.HttpResponse:
    return "Hello, World!"

# Test the function directly
print(http_trigger(None))

Para ver o resultado, execute o ficheiro diretamente em Python:

> python function_app.py

Hello, World!

# __init__.py
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello, World!")

# Test the function directly
print(main(None))

Para ver o resultado, execute o ficheiro diretamente em Python:

> python __init__.py

Hello, World!

Esta abordagem não requer pacotes ou configurações adicionais e é ideal para validação rápida durante o desenvolvimento. Para testes mais aprofundados, veja Testes Unitários

Versões suportadas em Python

O Azure Functions suporta as versões em Python listadas em Linguagens Suportadas no Azure Functions. Para informações mais gerais, consulte a política de suporte em tempo de execução do Azure Functions.

Importante

Se mudares a versão em Python da tua aplicação de funções, tens de reconstruir e reimplementar a aplicação usando a nova versão. Artefactos e dependências de implementação existentes não são automaticamente reconstruídos quando a versão em Python muda.

Compilação e Implementação

Para saber mais sobre o mecanismo de construção recomendado para o seu cenário, consulte Opções de Construção. Para uma visão geral da implementação, veja Tecnologias de implementação no Azure Functions.

Comparação Rápida dos Mecanismos de Implementação

Ferramenta / Plataforma	Comando / Ação	Melhor caso de uso
Azure Functions Core Tools	`func azure functionapp publish <APP_NAME>`	Ideal para execuções de CI, automação local ou para trabalhar multiplataforma.
AZ CLI	`az functionapp deployment source config-zip`	Útil ao scriptar implementações fora das Ferramentas Core. Funciona bem em pipelines automatizados ou terminais baseados na cloud (Azure Cloud Shell).
Visual Studio Code (Extensão Azure Functions)	Paleta de comandos → "Azure Functions: Implementar no Azure..."	Ideal para iniciantes ou implementações interativas. Trata automaticamente da embalagem e da construção.
Ações no GitHub	`Azure/functions-action@v1`	Ideal para CI/CD baseado no GitHub. Permite implementações automáticas em fusões push ou PR.
Azure Pipelines	`AzureFunctionApp@2` Tarefa	Enterprise CI/CD usando Azure DevOps. Ideal para fluxos de trabalho controlados de lançamento, compilações com bloqueio e pipelines em múltiplas etapas.
Implementação de Contentores Personalizados	Empurrar o recipiente → `az functionapp create --image <container>`	É necessário quando se precisam de pacotes ao nível do sistema operativo, compilações personalizadas em Python, runtimes fixados ou dependências não suportadas (por exemplo, bibliotecas do sistema, binários locais).
Criação de Funções Baseada em Portais	Criar função no portal do Azure → editor embutido	Use apenas para funções simples, sem dependências. Ótimo para demonstrações ou aprendizagem, mas não recomendado para aplicações que exigem pacotes de terceiros.

Nota

A Criação de Funções baseada em portais não suporta dependências de terceiros e não é recomendada para a criação de aplicações de produção. Não podes instalar ou referenciar pacotes fora azure-functions da biblioteca padrão Python incorporada.

Importante

Após 30 de setembro de 2028, a opção de hospedar seu aplicativo funcional no Linux em um plano de consumo é desativada. Para evitar interrupções, migre seus aplicativos existentes do plano de consumo que são executados no Linux para o plano de consumo flexível antes dessa data. As aplicações executadas no Windows num plano de Consumo não são afetadas por esta alteração. Para obter mais informações, consulte o aviso de desativação do plano de consumo do Linux.

Atualizações do Python 3.13+

A partir do Python 3.13, o Azure Functions introduz várias melhorias importantes em tempo de execução e desempenho que afetam a forma como constrói e executa as suas aplicações. As principais alterações incluem:

Controlo de versões em tempo de execução: Agora pode, opcionalmente, fixar ou atualizar a sua aplicação para versões worker específicas em Python, referenciando o azure-functions-runtime pacote no seu requirements.txtarquivo .

Sem o controlo de versões ativado, a sua aplicação corre numa versão padrão do runtime Python, que o Functions gere. Deve modificar o seu ficheirorequirements.txt para solicitar a versão mais recente lançada, uma versão pré-lançada, ou para fixar a sua aplicação a uma versão específica do runtime Python.
Ativas o controlo de versões em tempo de execução adicionando uma referência ao pacote de runtime em Python ao teu ficheiro derequirements.txt , onde o valor atribuído ao pacote determina a versão de runtime utilizada.
Evite fixar qualquer aplicação de produção em versões de pré-lançamento (alpha, beta ou dev) em tempo de execução.
Para estar ciente das alterações, reveja regularmente as notas de lançamento em tempo de execução do Python .

A tabela seguinte indica o comportamento de versionamento com base no valor de versão desta definição no seu ficheiro derequirements.txt :

Versão	Example	Comportamento
Sem conjunto de valores	`azure-functions-runtime`	A sua aplicação Python 3.13+ corre na versão mais recente disponível do runtime Functions Python. Esta opção é a melhor para se manter atualizado com as melhorias e funcionalidades da plataforma, uma vez que a sua aplicação recebe automaticamente as últimas atualizações estáveis em tempo de execução.
Fixado a uma versão específica	`azure-functions-runtime==1.2.0`	A tua aplicação Python 3.13+ mantém-se na versão fixada em tempo de execução e não recebe atualizações automáticas. Em vez disso, deve atualizar manualmente a sua versão fixada para aproveitar as novas funcionalidades, correções e melhorias do ambiente de execução. É recomendado utilizar o pinning para cargas de trabalho críticas em ambiente de produção, onde a estabilidade e a previsibilidade são essenciais. Fixar também te permite testar a tua aplicação em versões de runtime pré-lançadas durante o desenvolvimento.
Sem referência de encomenda	não aplicável	Ao não definires o `azure-functions-runtime`, a tua aplicação Python 3.13+ corre numa versão padrão do runtime Python que está atrasada em relação à versão mais recente lançada. As atualizações são feitas periodicamente pelas Funções. Esta opção garante estabilidade e ampla compatibilidade. No entanto, o acesso às funcionalidades e correções mais recentes é adiado até que a versão padrão seja atualizada.

Isolamento de dependências: As dependências da sua aplicação (como grpcio ou protobuf) estão totalmente isoladas das dependências do trabalhador, prevenindo conflitos de versões. A definição PYTHON_ISOLATE_WORKER_DEPENDENCIES da aplicação não terá impacto para aplicações a correr em Python 3.13 ou posterior.
Configuração simplificada de streaming HTTP — sem necessidade de definições especiais da aplicação.
Remoção do suporte para extensões de trabalhadores e funcionalidades de memória partilhada.

Sem o controlo de versões ativado, a sua aplicação corre numa versão padrão do runtime Python, que o Functions gere. Deve modificar o seu ficheirorequirements.txt para solicitar a versão mais recente lançada, uma versão pré-lançada, ou para fixar a sua aplicação a uma versão específica do runtime Python.
Ativas o controlo de versões em tempo de execução adicionando uma referência ao pacote de runtime em Python ao teu ficheiro derequirements.txt , onde o valor atribuído ao pacote determina a versão de runtime utilizada.
Evite fixar qualquer aplicação de produção em versões de pré-lançamento (alpha, beta ou dev) em tempo de execução.
Para estar ciente das alterações, reveja regularmente as notas de lançamento em tempo de execução do Python .

A tabela seguinte indica o comportamento de versionamento com base no valor de versão desta definição no seu ficheiro derequirements.txt :

Versão	Example	Comportamento
Sem conjunto de valores	`azure-functions-runtime-v1`	A sua aplicação Python 3.13+ corre na versão mais recente disponível do runtime Functions Python. Esta opção é a melhor para se manter atualizado com as melhorias e funcionalidades da plataforma, uma vez que a sua aplicação recebe automaticamente as últimas atualizações estáveis em tempo de execução.
Fixado a uma versão específica	`azure-functions-runtime-v1==1.2.0`	A tua aplicação Python 3.13+ mantém-se na versão fixada em tempo de execução e não recebe atualizações automáticas. Em vez disso, deve atualizar manualmente a sua versão fixada para tirar partido de novas funcionalidades, correções e melhorias no tempo de execução. O pinning é recomendado para cargas de trabalho críticas em produção, onde a estabilidade e a previsibilidade são essenciais. Fixar também te permite testar a tua aplicação em versões de runtime pré-lançadas durante o desenvolvimento.
Sem referência de encomenda	não aplicável	Ao não definires o `azure-functions-runtime-v1`, a tua aplicação Python 3.13+ corre numa versão padrão do runtime Python que está atrasada em relação à versão mais recente lançada. As atualizações são feitas periodicamente pelas Funções. Esta opção garante estabilidade e ampla compatibilidade. No entanto, o acesso às funcionalidades e correções mais recentes é adiado até que a versão padrão seja atualizada.

Isolamento de dependências: As dependências da sua aplicação (como grpcio ou protobuf) estão totalmente isoladas das dependências do trabalhador, prevenindo conflitos de versões. A definição PYTHON_ISOLATE_WORKER_DEPENDENCIES da aplicação não terá impacto para aplicações a correr em Python 3.13 ou posterior.
Removido o suporte para extensões de trabalhadores e funcionalidades de memória compartilhada.

Observabilidade e teste

Esta secção aborda capacidades de registo, monitorização e testes para o ajudar a depurar problemas, acompanhar o desempenho e garantir a fiabilidade das suas aplicações de funções em Python.

Registo e monitorização

O Azure Functions expõe um root logger que podes usar diretamente com o módulo incorporado logging do Python. Quaisquer mensagens escritas com este logger são automaticamente enviadas para o Application Insights quando a sua aplicação está a correr no Azure.

O registo permite captar informação em tempo de execução e diagnosticar problemas sem necessidade de mais configurações.

Exemplo de registo com um gatilho HTTP

import logging
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.debug("Example debug log")
    logging.info("Example info log")
    logging.warning("Example warning")
    logging.error("Example error log")
    return func.HttpResponse("OK")

import logging
import azure.functions as func

app = func.FunctionApp()

@app.route(route="http_trigger")
def http_trigger(req) -> func.HttpResponse:
    logging.debug("Example debug log")
    logging.info("Example info log")
    logging.warning("Example warning")
    logging.error("Example error log")
    return func.HttpResponse("OK")

Pode usar o conjunto completo de níveis de registo (debug, info, warning, error, critical), e eles aparecem no portal Azure em Registos ou Insights de Aplicação.

Para saber mais sobre como monitorizar Azure Functions no portal, consulte Monitorizar Azure Functions.

Nota

Para visualizar registos de depuração no Application Insights, é necessária mais configuração. Pode ativar esta funcionalidade ao definir PYTHON_ENABLE_DEBUG_LOGGING para 1 e definir logLevel para trace ou debug no seu ficheiro host.json. Por padrão, os registos de depuração não são visíveis no Application Insights.

Registo de logs a partir de threads de segundo plano

Se a tua função iniciar um novo thread e precisar de fazer login a partir desse thread, certifica-te de passar o context argumento para o thread. O context contém armazenamento local na thread e o atual invocation_id, que deve ser definido na thread worker para que os logs sejam devidamente associados à execução da função.

import logging
import threading
import azure.functions as func

def main(req: func.HttpRequest, context) -> func.HttpResponse:
    logging.info("Function started")
    t = threading.Thread(target=log_from_thread, args=(context,))
    t.start()
    return "okay"

def log_from_thread(context):
    # Associate the thread with the current invocation
    context.thread_local_storage.invocation_id = context.invocation_id  
    logging.info("Logging from a background thread")

import azure.functions as func
import logging
import threading

app = func.FunctionApp()

@app.route(route="http_trigger")
def http_trigger(req, context) -> func.HttpResponse:
    logging.info("Function started")
    t = threading.Thread(target=log_from_thread, args=(context,))
    t.start()
    return "okay"

def log_from_thread(context):
    # Associate the thread with the current invocation
    context.thread_local_storage.invocation_id = context.invocation_id  
    logging.info("Logging from a background thread")

Configuração de loggers personalizados

Pode configurar loggers personalizados em Python quando precisar de mais controlo sobre o comportamento dos registos, como formatação personalizada, filtragem de logs ou integrações de terceiros. Para configurar um logger personalizado, usa Python logging.getLogger() com um nome personalizado e adiciona handlers ou formateadores conforme necessário.

import logging

custom_logger = logging.getLogger('my_custom_logger')

Suporte à OpenTelemetry

O Azure Functions para Python também suporta o OpenTelemetry, que permite emitir traços, métricas e logs num formato padronizado. Usar OpenTelemetry é especialmente valioso para aplicações distribuídas ou cenários onde se pretende exportar telemetria para ferramentas fora do Application Insights (como Grafana ou Jaeger).

Consulte o nosso OpenTelemetry Quickstart para Azure Functions (Python) para instruções de configuração e código de exemplo.

Teste de unidades

Escreva e execute testes unitários para as suas funções usando pytest. Pode testar funções Python como outros códigos Python, usando frameworks de teste padrão. Para a maioria das ligações, pode criar um objeto de entrada simulado criando uma instância de uma classe apropriada do pacote azure.functions.

Usando my_function como exemplo, o seguinte exemplo é um teste simulado de uma função ativada por HTTP:

Primeiro, cria o <ficheiro project_root>/function_app.py e implementa a my_function função como trigger HTTP.

# <project_root>/function_app.py
import azure.functions as func
import logging

app = func.FunctionApp()

# Define the HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
@app.function_name(name="my_function")
@app.route(route="hello")
def my_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Executing myfunction.')

    initial_value: int = int(req.params.get('value'))
    doubled_value: int = initial_value * 2

    return func.HttpResponse(
        body=f"{initial_value} * 2 = {doubled_value}",
        status_code=200
    )

Você pode começar a escrever casos de teste para seu gatilho HTTP.

# <project_root>/test_my_function.py
import unittest
import azure.functions as func

from function_app import my_function

class TestFunction(unittest.TestCase):
  def test_my_function(self):
    # Construct a mock HTTP request.
    req = func.HttpRequest(method='GET',
                           body=None,
                           url='/api/my_function',
                           params={'value': '21'})
    # Call the function.
    func_call = main.build().get_user_function()
    resp = func_call(req)
    # Check the output.
    self.assertEqual(
        resp.get_body(),
        b'21 * 2 = 42',
    )

Dentro da sua pasta do ambiente virtual Python, pode executar os seguintes comandos para testar a aplicação:

pip install pytest
pytest test_my_function.py

Vê os pytest resultados no terminal, desta forma:

============================================================================================================ test session starts ============================================================================================================
collected 1 item                                                                                                                                                                                                                             

test_my_function.py .                                                                                                                                                                                                                  [100%] 
============================================================================================================= 1 passed in 0.24s =============================================================================================================

Otimização e tópicos avançados

Para saber mais sobre como otimizar as suas aplicações de funções Python, consulte estes artigos:

Para mais informações sobre Funções, consulte estes artigos:

Está tendo problemas com o uso do Python? Diz-nos e apresenta uma reclamação.

Feedback

Esta página foi útil?

Last updated on 2026-01-16

Partilhar via

Guia de referência para programadores Azure Functions para aplicações Python

Como Começar

Criar a sua aplicação de funções

Modelo de programação

Conceitos-chave

A azure-functions biblioteca

Ponto de entrada alternativo

Estrutura de pastas

Ficheiros-chave e pastas-chave

Conceitos-chave

A azure-functions biblioteca

Organização com plantas arquitetónicas

Estrutura de pastas

Ficheiros-chave e pastas-chave

Acionadores e enlaces

Exemplo: Gatilho do Temporizador com Entrada de Blob

Conceitos-chave

Exemplo: HTTP Trigger com entrada do Cosmos DB e saída do Event Hub

Conceitos-chave

Ligações de tipo SDK

Variáveis de ambiente

Gestão de pacotes

Considerações

Funcionamento e implantação

Executando localmente

Usando as Ferramentas do Core do Azure Functions

Invocação direta da função

Versões suportadas em Python

Compilação e Implementação

Atualizações do Python 3.13+

Observabilidade e teste

Registo e monitorização

Exemplo de registo com um gatilho HTTP

Registo de logs a partir de threads de segundo plano

Configuração de loggers personalizados

Suporte à OpenTelemetry

Teste de unidades

Otimização e tópicos avançados

Artigos relacionados

Feedback

Recursos adicionais

A `azure-functions` biblioteca

A `azure-functions` biblioteca