Referenční příručka pro vývojáře Azure Functions pro aplikace Python

Azure Functions je bezserverová výpočetní služba, která umožňuje spouštět kód řízený událostmi bez zřizování nebo správy infrastruktury. Spouštění funkcí se aktivují událostmi, jako jsou požadavky HTTP, zprávy fronty, časovače nebo změny v úložišti, a automaticky se škálují na základě poptávky.

Tato příručka se zaměřuje konkrétně na vytváření Azure Functions založených na Python a pomáhá vám:

Vytváření a spouštění aplikací Function Apps místně
Vysvětlení programovacího modelu Python
Uspořádání a konfigurace aplikace
Nasazení a monitorování aplikace v Azure
Použití osvědčených postupů pro škálování a výkon

Hledáte koncepční přehled? Viz Azure Functions Reference pro vývojáře.

Zajímá vás skutečné případy použití? Projděte si stránku Scénáře a ukázky .

Začínáme

Zvolte prostředí, které vyhovuje vašemu pracovnímu postupu, a přejděte do Azure Functions pro Python:

Sestavení aplikace funkcí

Tato část se věnuje základním komponentám pro vytváření a strukturování aplikace funkcí Python. Mezi témata patří programovací model, struktura projektu, triggery a vazby a správa závislostí.

Programovací model

Funkce podporují dvě verze programovacího modelu Python:

Version	Popis
2.x	K definování triggerů a vazeb přímo v souboru kódu Python použijte přístup založený na dekorátoru. Každou funkci implementujete jako globální bezstavovou metodu `function_app.py` v souboru nebo odkazovaném souboru šablony. Tato verze modelu se doporučuje pro nové aplikace Python.
1.x	Pro každou funkci v samostatném `function.json` souboru definujete triggery a vazby. Každou funkci implementujete jako globální bezstavovou metodu v souboru kódu Python. Tato verze modelu podporuje starší verze aplikací.

Tento článek cílí na konkrétní verzi modelu Python. V horní části článku zvolte požadovanou verzi.

Důležité

K definování triggerů a vazeb přímo v kódu použijte programovací model v2 pro přístup založený na dekorátoru .

V programovacím modelu Python v1 je každá funkce definována jako globální bezstavová metoda main() uvnitř souboru s názvem __init__.py. Triggery a vazby funkce se konfigurují samostatně v function.json souboru a hodnoty vazby name se používají jako parametry ve vaší main() metodě.

Příklad

Tady je jednoduchá funkce, která reaguje na požadavek HTTP:

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

Tady je odpovídající function.json soubor:

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

Klíčové koncepty

Funkce má jeden trigger HTTP.
HttpRequest objekt obsahuje hlavičky požadavku, parametry dotazu, parametry trasy a text zprávy. Tato funkce získá hodnotu parametru name dotazu z params parametru HttpRequest objektu.
Pokud chcete v tomto příkladu odeslat jméno, připojte ?name={name} k URL adrese zpřístupněné funkce. Pokud například běží místně, může úplná adresa URL vypadat takto http://localhost:7071/api/http_trigger?name=Test. Příklady použití vazeb najdete v tématu Triggery a vazby.

azure-functions Použití sady SDK a zahrnutí poznámek k typům ke zlepšení podpory IntelliSense a editoru:

# __init__.py
import azure.functions as func

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

# requirements.txt
azure-functions

Knihovna `azure-functions`

Knihovna azure-functions Python poskytuje základní typy používané k interakci s modulem runtime Azure Functions. Pokud chcete zobrazit všechny dostupné typy a metody, navštivte azure-functions rozhraní API. Kód funkce může použít azure-functions k:

Access aktivuje vstupní data (například HttpRequest, TimerRequest)
Vytvoření výstupních hodnot (například HttpResponse)
Interakce s kontextovými a vazbovými daty poskytnutými za běhu

Pokud ve své aplikaci používáte azure-functions, přidejte ho mezi závislosti projektu.

Poznámka:

Knihovna azure-functions definuje programovací plochu pro Python Azure Functions, ale nejedná se o sadu SDK pro obecné účely. Použijte ho speciálně pro vytváření a spouštění funkcí v Azure Functions runtime.

Alternativní vstupní bod

Výchozí chování funkce můžete změnit zadáním vlastností scriptFile a entryPoint v souboru function.json. Například následující soubor function.json směruje modul runtime tak, aby jako vstupní bod funkce Azure použil metodu custom_entry() v souboru main.py.

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

Struktura složek

Pro projekt Python Azure Functions použijte následující strukturu:

<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

Klíčové soubory a složky

Soubor nebo složka	Popis	Vyžaduje se, aby aplikace běžela v Azure
`my_first_function/`	Adresář pro jednu funkci.	✅
`__init__.py/`	Hlavní skript, ve `my_first_function` kterém je definován kód funkce.	✅
`function.json/`	Obsahuje konfiguraci vazby pro funkci `my_first_function`.	✅
`host.json`	Globální konfigurace pro všechny funkce v aplikaci	✅
`requirements.txt`	Python závislosti nainstalovány během publikování při použití remote build.	❌ (doporučeno pro správu balíčků)
`local.settings.json`	Nastavení a tajné kódy aplikace jen pro místní prostředí (nikdy nepublikované)	❌ (vyžadováno pro místní vývoj)
`.funcignore`	Určuje soubory a složky, které se mají vyloučit z nasazení (například `.venv/`, `tests/`, `local.settings.json`).	❌ (doporučeno)
`.venv/`	Místní virtuální prostředí pro Python (vyloučené z nasazení)	❌
`.vscode/`	Konfigurace editoru pro Visual Studio Code Nevyžaduje se pro nasazení.	❌
`shared/`	Obsahuje pomocný kód sdílený v rámci projektu aplikace funkcí.	❌
`additional_functions/`	Používá se pro modulární organizaci kódu – obvykle s podrobnými plány.	❌
`tests/`	Jednotkové testy pro vaši funkční aplikaci Není publikováno do Azure.	❌
`Dockerfile`	Definuje vlastní kontejner pro nasazení.	❌

V programovacím modelu Python v2 používá Azure Functions přístup založený na decoratoru k definování triggerů a vazeb přímo v kódu. Každá funkce se implementuje jako globální bezstavová metoda v rámci function_app.py souboru.

Příklad

Tady je jednoduchá funkce, která reaguje na požadavek 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

Klíčové koncepty

Kód naimportuje azure-functions balíček a k definování aplikace funkcí používá dekorátory a typy.
Funkce má jeden trigger HTTP.
HttpRequest objekt obsahuje hlavičky požadavku, parametry dotazu, parametry trasy a text zprávy. Tato funkce získá hodnotu parametru name dotazu z params parametru HttpRequest objektu.
Pokud chcete v tomto příkladu odeslat jméno, připojte ?name={name} k URL adrese zpřístupněné funkce. Pokud například běží místně, může úplná adresa URL vypadat takto http://localhost:7071/api/http_trigger?name=Test. Příklady použití vazeb najdete v tématu Triggery a vazby.

Knihovna `azure-functions`

Knihovna azure-functions Python je základní součástí programovacího modelu Azure Functions. Poskytuje dekorátory, typy triggerů a vazeb a objekty požadavků a odpovědí používané k definování a interakci s funkcemi za běhu. Pokud chcete zobrazit všechny dostupné typy a dekorátory, navštivte azure-functions rozhraní API. Kód vaší aplikace funkcí závisí na této knihovně:

Definování všech funkcí pomocí objektu FunctionApp
Deklarace triggerů a vazeb (například @app.route, @app.timer_trigger)
Přístup ke specifickým vstupům a výstupům (například HttpRequest, HttpResponse a Out`)

Musíte zahrnout azure-functions mezi závislosti projektu. Další informace najdete v tématu Správa balíčků.

Poznámka:

Ke zlepšení podpory IntelliSense a editoru použijte poznámky typu :

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

Čtení parametrů trasy

Parametry trasy můžete definovat přímo v šabloně trasy HTTP a číst je z objektu požadavku.

Například trasa products/{product_id} zachytí hodnotu z URL cesty a zpřístupní ji prostřednictvím HttpRequest.route_params.

import azure.functions as func

app = func.FunctionApp()

@app.route(route="products/{product_id}", methods=["GET"])
def get_product(req: func.HttpRequest) -> func.HttpResponse:
    product_id = req.route_params.get("product_id")
    if not product_id:
        return func.HttpResponse("Missing route parameter: product_id", status_code=400)
    return func.HttpResponse(f"Product: {product_id}")

Důležité

V modelu Python v2 nepřidávejte parametry trasy jako další funkční argumenty. Přečtěte si je raději z req.route_params.

Uspořádání s využitím podrobných plánů

U větších nebo modulárních aplikací můžete pomocí blueprintů definovat funkce v samostatných Python souborech a zaregistrovat je v hlavní aplikaci. Toto oddělení udržuje váš kód uspořádaný a opakovaně použitelný.

Definování a registrace podrobného plánu:

Definujte podrobný plán v jiném souboru Python, například 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!")

Zaregistrujte blueprint v hlavním function_app.py souboru:

import azure.functions as func
from http_blueprint import bp

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

Pomocí podrobných plánů můžete:

Rozdělení aplikace na opakovaně použitelné moduly
Zachování souvisejících funkcí seskupených podle souboru nebo funkce
Rozšíření nebo sdílení podrobných plánů napříč projekty

Poznámka:

Durable Functions také podporuje podrobné plány pomocí azure-functions-durable. Zobrazit ukázku →

Struktura složek

Pro projekt Python Azure Functions použijte následující strukturu:

<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

Klíčové soubory a složky

Soubor nebo složka	Popis	Vyžaduje se, aby aplikace běžela v Azure
`function_app.py`	Hlavní skript, kde jsou definovány Azure Functions a triggery pomocí dekorátorů.	✅
`host.json`	Globální konfigurace pro všechny funkce v aplikaci	✅
`requirements.txt`	Python závislosti nainstalovány během publikování při použití remote build.	❌ (doporučeno pro správu balíčků)
`local.settings.json`	Nastavení a tajné kódy aplikace jen pro místní prostředí (nikdy nepublikované)	❌ (vyžadováno pro místní vývoj)
`.funcignore`	Určuje soubory a složky, které se mají vyloučit z nasazení (například `.venv/`, `tests/`, `local.settings.json`).	❌ (doporučeno)
`.venv/`	Místní virtuální prostředí pro Python (vyloučené z nasazení)	❌
`.vscode/`	Konfigurace editoru pro Visual Studio Code Nevyžaduje se pro nasazení.	❌
`shared/`	Obsahuje pomocný kód sdílený v rámci projektu aplikace funkcí.	❌
`additional_functions/`	Používá se pro modulární organizaci kódu – obvykle s podrobnými plány.	❌
`tests/`	Jednotkové testy pro vaši funkční aplikaci Není publikováno do Azure.	❌
`Dockerfile`	Definuje vlastní kontejner pro nasazení.	❌

Poznámka:

Při nasazení pomocí requirements.txt sestavení zahrňte soubor. Pokud nepoužíváte remote build nebo chcete použít jiný soubor pro definování závislostí aplikací, můžete provést lokální sestavení a nasadit aplikaci s předpřipravenými závislostmi.

Další informace najdete tady:

Spouštěče a vazby

Azure Functions používá triggery ke spuštění spouštění funkcí a bindings pro připojení kódu k jiným službám, jako jsou úložiště, fronty a databáze. V programovacím modelu Python v2 deklarujete vazby pomocí dekorátorů.

Existují dva hlavní typy vazeb:

Spouštěče (vstup, který aktivuje funkci)
Vstupy a výstupy (další zdroje dat nebo cíle)

Další informace o dostupných triggerech a vazbách najdete v tématu Triggery a vazby v Azure Functions.

Příklad: Trigger časovače s Blob vstupem

Tato funkce:

Spouští se každých 10 minut
Čtení z objektu blob pomocí vazeb typu sady SDK
Ukládá výsledky do mezipaměti a zapisuje do dočasného souboru.

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}")

Klíčové koncepty

Použijte vazby typů SDK pro práci s bohatými typy. Další informace najdete v tématu Vazby typu sady SDK.
Globální proměnné můžete použít k ukládání drahých výpočtů do mezipaměti, ale jejich stav není zaručený pro zachování napříč prováděními funkcí.
Dočasné soubory se ukládají do tmp/ a nejsou zaručené, že se zachovají napříč vyvoláním nebo instancemi horizontálního navýšení kapacity.
K kontextu vyvolání funkce můžete přistupovat prostřednictvím třídy Context.

Příklad: Trigger HTTP se vstupem služby Cosmos DB a výstupem centra událostí

Tato funkce:

Spouštěče na HTTP požadavku
Čtení dat z Cosmos DB
Zápis dat do výstupu Event Hubu
Vrátí odpověď 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"
    }
  ]
}

Klíčové koncepty

Každá funkce má jeden trigger, ale může mít více vazeb.
Přidejte vstupy tak, že v direction zadáte function.json jako „in“. Výstupy mají direction o hodnotě out.
K podrobnostem žádosti můžete přistupovat prostřednictvím objektu HttpRequest a vytvořit vlastní HttpResponse pomocí hlaviček, stavového kódu a textu.

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
    )

Klíčové koncepty

K definování způsobu vyvolání funkce použijte @route() nebo dekorátory specifické pro triggery (@timer_trigger@queue_triggera další).
Přidejte vstupy pomocí dekorátorů, jako jsou @blob_input, @queue_input a další.
Výstupy můžou být:
- Vráceno přímo (pokud pouze jeden výstup)
- Přiřazeno pomocí Out vazeb a .set() metody pro více výstupů.
K podrobnostem žádosti můžete přistupovat prostřednictvím objektu HttpRequest a vytvořit vlastní HttpResponse pomocí hlaviček, stavového kódu a textu.

Vazby typu sady SDK

U vybraných triggerů a vazeb můžete pracovat s datovými typy implementovanými podkladovými Sady Azure SDK a architekturami. Pomocí těchto vazeb typu sady SDK můžete pracovat s daty vazeb, jako byste používali podkladovou sadu SDK služby. Další informace najdete v podporovaných vazbách typu sady SDK.

Důležité

Podpora vazeb typu sady SDK pro Python je dostupná pouze v programovacím modelu Python v2.

Přidružení agentů

Důležité

Vazby agenta pro funkční aplikace v Pythonu jsou aktuálně ve verzi Preview. Funkce, názvy balíčků a konfigurace se mohou měnit ještě před obecnou dostupností.

Agentní vazby umožňují vstříknout objekt Agent do funkce a zároveň zachovat standardní spouštěče, vazby a logiku aplikace Azure Functions. Agentové vazby můžete použít ke spojení deterministického kódu s agentickým uvažováním, včetně orchestrací Durable Functions. Další informace najdete v článku Vazby agenta pro aplikace funkcí v Pythonu.

Proměnné prostředí

Proměnné prostředí v Azure Functions umožňují bezpečně spravovat hodnoty konfigurace, připojovací řetězce a tajné kódy aplikací bez jejich pevně zakódování v kódu funkce.

Můžete definovat proměnné prostředí:

Místně: v souborulocal.settings.json během místního vývoje.
V Azure: jako Nastavení aplikace na stránce konfigurace aplikace funkcí na portálu Azure.

Přístup k proměnným přímo v kódu pomocí os.environ nebo os.getenv.

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

Poznámka:

Azure Functions také rozpozná proměnné systémového prostředí, které konfigurují prostředí runtime Functions a běh pracovního procesu Pythonu. Tyto proměnné se explicitně nepoužívají v kódu funkce, ale ovlivňují způsob spouštění vaší aplikace. Úplný seznam systémových proměnných prostředí najdete v referenčních informacích k nastavení aplikace.

Správa balíčků

Pokud chcete v aplikaci Azure Functions použít jiné balíčky Python, vypište je do souboru requirements.txt v kořenovém adresáři projektu. Python importuje tyto balíčky a můžete na ně odkazovat jako obvykle. Další informace o vytváření a nasazení s externími závislostmi najdete v tématu Nástavové možnosti pro aplikace funkcí Python.

Například následující ukázka ukazuje, jak requests je modul zahrnutý a používaný v aplikaci funkcí.

<requirements.txt>
requests==2.31.0

Nainstalujte balíček místně pomocí pip install -r requirements.txtsouboru .

Po instalaci balíčku ho můžete importovat a použít ve svém funkčním kódu:

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}")

Úvahy

Konflikty s integrovanými moduly:
- Vyhněte se pojmenování složek projektu po Python standardních knihoven (například email/, json/).
- Do logging nezahrnujte Python nativní knihovny (například asyncio, uuid nebo requirements.txt).
Nasazení:
- Abyste předešli ModuleNotFound chybám, ujistěte se, že v requirements.txt uvedete všechny požadované závislosti.
- Pokud aktualizujete Python verzi aplikace, znovu ji znovu nasaďte na novou verzi Python, aby nedocházelo ke konfliktům závislostí s dříve sestavenými balíčky.
Závislosti mimo PyPI:
- Můžete do své aplikace zahrnout závislosti, které nejsou dostupné na PyPI, jako jsou místní balíčky, wheel soubory nebo soukromé feedy. Pro instrukce k nastavení viz Vlastní závislosti v Python Azure Functions.
Azure Functions Python závislostí pracovního procesu:
- Pokud váš balíček obsahuje určité knihovny, které mohou kolidovat se závislostmi pracovního procesu (například grpcio nebo protobuf), nastavte v nastavení aplikace PYTHON_ISOLATE_WORKER_DEPENDENCIES na 1, aby se vaše aplikace neodkazovala na závislosti pracovního procesu. Pro Python 3.13 a novější je tato funkce ve výchozím nastavení povolena.

Spuštění a nasazení

Tato část obsahuje informace o spouštění funkcí místně, podpoře verzí Pythonu, sestavení a možnostech nasazení a konfiguraci modulu runtime. Tyto informace slouží k úspěšnému spuštění aplikace funkcí v místním prostředí i v prostředích Azure.

Lokální spuštění

Aplikaci funkcí Python můžete spustit a otestovat na místním počítači před nasazením do Azure.

Použití nástrojů Azure Functions Core Tools

Nainstalujte Azure Functions Core Tools a spusťte místní modul runtime spuštěním příkazu func start z kořenového adresáře projektu:

func start

Když spustíte funkční aplikaci místně, nástroje Core Tools zobrazí všechny funkce, které pro vaši aplikaci najde:

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

Další informace o používání nástrojů Core Tools najdete v tématu Develop Azure Functions místně pomocí nástrojů Core Tools.

Přímé vyvolání funkce

Pomocí azure-functions >= 1.21.0 můžete také volat funkce přímo pomocí interpretu Python bez spuštění nástrojů Core Tools. Tento přístup je užitečný pro rychlé testy jednotek:

# 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))

Pokud chcete zobrazit výstup, spusťte soubor přímo s 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))

Pokud chcete zobrazit výstup, spusťte soubor přímo s Python:

> python __init__.py

Hello, World!

Tento přístup nevyžaduje žádné další balíčky ani nastavení a je ideální pro rychlé ověření během vývoje. Pro podrobnější testování viz Jednotkové testování.

Podporované verze Python

Azure Functions podporuje verze Python uvedené v Supported languages in Azure Functions. Další obecné informace najdete v zásadách podpory modulu runtime Azure Functions.

Mějte tyto věci na paměti při aktualizaci své aplikace:

Pokud existující aplikace Python 3.11 na plánu Linux Elastic Premium nebo Dedicated (App Service) používá spravovaný obraz Debian Bullseye, aktualizujte aplikaci na obraz Debian Bookworm, aby zůstala na podporované distribuci Linuxu.
Znovu sestavte aplikaci a její závislosti pomocí nové verze, pokud změníte Python verzi pro svou funkční aplikaci.
Znovu nasadit přestavěnou aplikaci. Změna verze Pythonu automaticky znovu nesestaví stávající artefakty nasazení a závislosti.

Sestavení a nasazení

Další informace o doporučeném mechanismu sestavení pro váš scénář najdete v tématu Možnosti sestavení. Obecný přehled nasazení najdete v tématu technologie nasazení v Azure Functions.

Rychlé srovnání mechanismů nasazení

Nástroj / platforma	Příkaz / akce	Nejlepší případ použití
Azure Functions Core Tools	`func azure functionapp publish <APP_NAME>`	Ideální pro běhy CI, místní automatizaci nebo při práci napříč platformami.
AZ CLI	`az functionapp deployment source config-zip`	Užitečné při skriptování nasazení mimo Core Tools. Funguje dobře v automatizovaných kanálech nebo cloudových terminálech (Azure Cloud Shell).
Visual Studio Code (rozšíření Azure Functions)	Paleta příkazů → "Azure Functions: Deploy to Azure..."	Nejvhodnější pro začátečníky nebo interaktivní nasazení. Automaticky zpracovává balení a sestavování.
GitHub Actions	`Azure/functions-action@v1`	Ideální pro GitHub CI/CD. Umožňuje automatizovaná nasazení při push nebo sloučení PR.
Azure Pipelines	`AzureFunctionApp@2` Úkol	Podniková CI/CD s využitím Azure DevOps. Nejvhodnější pro řízené pracovní postupy vydávání verzí, řízené buildy a vícestupňové pipeliny.
Vlastní nasazení kontejneru	Nasdílení → kontejneru `az functionapp create --image <container>`	Vyžaduje se, když potřebujete balíčky na úrovni operačního systému, vlastní Python sestavení, připnuté moduly runtime nebo nepodporované závislosti (například systémové knihovny, místní binární soubory).
Vytvoření funkce založené na portálu	Vytvořte funkci v portálu Azure → integrovaném editoru	Používejte pouze pro jednoduché funkce bez závislostí. Skvělé pro ukázky nebo učení, ale nedoporučuje se pro aplikace vyžadující balíčky třetích stran.

Poznámka:

Vytvoření funkce založené na portálu nepodporuje závislosti třetích stran a nedoporučuje se pro vytváření produkčních aplikací. Nemůžete instalovat ani odkazovat balíčky mimo azure-functions a integrovanou standardní knihovnu Python.

Důležité

Aplikace funkcí stále spouštějí modul runtime verze v3 s ukončenou podporou na Linuxu v plánu spotřeby přestanou běžet po 30. září 2026. Pokud se chcete vyhnout přerušení služeb, migrujte aplikaci do modulu runtime v4.

Možnost hostovat funkční aplikace na Linuxu v plánu Consumption bude vyřazena z provozu 30. září 2028. Plán spotřeby pro Linux již nedostává žádné nové funkce ani jazykové verze. Aplikace spuštěné na Windows v plánu Consumption nejsou aktuálně ovlivněné. Migrujte své aplikace do plánu Flex Consumption před datem vyřazení.

aktualizace Python verze 3.13 nebo novější

Počínaje Python 3.13 Azure Functions zavádí několik hlavních vylepšení modulu runtime a výkonu, která ovlivňují vytváření a spouštění aplikací. Mezi klíčové změny patří:

Správa verzí modulu runtime: Nyní můžete volitelně připnout nebo upgradovat aplikaci na konkrétní verze Python workeru odkazováním na balíček azure-functions-runtime ve vašem requirements.txt.

Bez povolené správy verzí běží vaše aplikace na výchozí verzi modulu runtime Python, kterou spravuje služba Functions. Soubor requirements.txt je nutné upravit tak, aby požadoval nejnovější vydanou verzi, předběžnou verzi nebo připnul aplikaci na konkrétní verzi modulu runtime Python.
Správu verzí modulu runtime povolíte přidáním odkazu na balíček modulu runtime Python do souboru requirements.txt, kde hodnota přiřazená balíčku určuje použitou verzi modulu runtime.
Vyhněte se připnutí jakékoli produkční aplikace k předběžné verzi modulu runtime (alpha, beta nebo dev).
Abyste byli informováni o změnách, pravidelně si projděte poznámky k verzi prostředí Python.

Následující tabulka označuje chování správy verzí na základě hodnoty verze tohoto nastavení v souboru requirements.txt :

Version	Příklad	Chování
Žádná sada hodnot	`azure-functions-runtime`	Vaše aplikace Python verze 3.13 nebo novější běží na nejnovější dostupné verzi modulu runtime Python Functions. Tato možnost je nejvhodnější pro udržování aktuálního stavu díky vylepšením a funkcím platformy, protože vaše aplikace automaticky obdrží nejnovější stabilní aktualizace modulu runtime.
Připnuto ke konkrétní verzi	`azure-functions-runtime==1.2.0`	Vaše aplikace Python verze 3.13 nebo novější zůstává na připnuté verzi modulu runtime a nepřijímá automatické aktualizace. Místo toho musíte ručně aktualizovat připnutou verzi, abyste mohli využívat nové funkce, opravy a vylepšení běhového prostředí. Připnutí se doporučuje pro kritické produkční úlohy, u kterých je důležitá stabilita a předvídatelnost. Připnutí také umožňuje otestovat aplikaci na předem připravených verzích modulu runtime během vývoje.
Žádný odkaz na balíček	není k dispozici	Když nenastavíte `azure-functions-runtime`, vaše aplikace Python 3.13 nebo novější běží na výchozí verzi modulu runtime Python, která zaostává za nejnovější vydanou verzí. Funkce pravidelně provádí aktualizace. Tato možnost zajišťuje stabilitu a širokou kompatibilitu. Přístup k nejnovějším funkcím a opravám se ale zpozdí, dokud se neaktualizuje výchozí verze.

Izolace závislostí: Závislosti vaší aplikace (například grpcio nebo protobuf) jsou plně izolované od závislostí pracovního procesu, což brání konfliktům verzí. Nastavení PYTHON_ISOLATE_WORKER_DEPENDENCIES aplikace nemá žádný vliv na aplikace běžící na Python 3.13 nebo novějším.
Zjednodušené nastavení streamování HTTP – nevyžaduje se žádné speciální nastavení aplikace.
Byla odebrána podpora rozšíření pracovních procesů a funkcí sdílené paměti.

Správa verzí modulu runtime: Nyní můžete volitelně připnout nebo upgradovat aplikaci na konkrétní verze Python workeru odkazováním na balíček azure-functions-runtime-v1 ve vašem requirements.txt.

Bez povolené správy verzí běží vaše aplikace na výchozí verzi modulu runtime Python, kterou spravuje služba Functions. Soubor requirements.txt je nutné upravit tak, aby požadoval nejnovější vydanou verzi, předběžnou verzi nebo připnul aplikaci na konkrétní verzi modulu runtime Python.
Správu verzí modulu runtime povolíte přidáním odkazu na balíček modulu runtime Python do souboru requirements.txt, kde hodnota přiřazená balíčku určuje použitou verzi modulu runtime.
Vyhněte se připnutí jakékoli produkční aplikace k předběžné verzi modulu runtime (alpha, beta nebo dev).
Abyste byli informováni o změnách, pravidelně si projděte poznámky k verzi prostředí Python.

Následující tabulka označuje chování správy verzí na základě hodnoty verze tohoto nastavení v souboru requirements.txt :

Version	Příklad	Chování
Žádná sada hodnot	`azure-functions-runtime-v1`	Vaše aplikace Python verze 3.13 nebo novější běží na nejnovější dostupné verzi modulu runtime Python Functions. Tato možnost je nejvhodnější pro udržování aktuálního stavu díky vylepšením a funkcím platformy, protože vaše aplikace automaticky obdrží nejnovější stabilní aktualizace modulu runtime.
Připnuto ke konkrétní verzi	`azure-functions-runtime-v1==1.2.0`	Vaše aplikace Python verze 3.13 nebo novější zůstává na připnuté verzi modulu runtime a nepřijímá automatické aktualizace. Místo toho musíte ručně aktualizovat připnutou verzi, abyste mohli využívat nové funkce, opravy a vylepšení běhového prostředí. Připnutí se doporučuje pro kritické produkční úlohy, u kterých je důležitá stabilita a předvídatelnost. Připnutí také umožňuje otestovat aplikaci na předem připravených verzích modulu runtime během vývoje.
Žádný odkaz na balíček	není k dispozici	Když nenastavíte `azure-functions-runtime-v1`, vaše aplikace Python 3.13 nebo novější běží na výchozí verzi modulu runtime Python, která zaostává za nejnovější vydanou verzí. Funkce pravidelně provádí aktualizace. Tato možnost zajišťuje stabilitu a širokou kompatibilitu. Přístup k nejnovějším funkcím a opravám se ale zpozdí, dokud se neaktualizuje výchozí verze.

Izolace závislostí: Závislosti vaší aplikace (například grpcio nebo protobuf) jsou plně izolované od závislostí pracovního procesu, což brání konfliktům verzí. Nastavení PYTHON_ISOLATE_WORKER_DEPENDENCIES aplikace nemá žádný vliv na aplikace běžící na Python 3.13 nebo novějším.
Byla odebrána podpora rozšíření pracovních procesů a funkcí sdílené paměti.

Pozorovatelnost a testování

Tato část se věnuje logging, monitoring a testování, které vám pomůžou ladit problémy, sledovat výkon a zajistit spolehlivost aplikací funkcí Python.

Protokolování a monitorování

Azure Functions zpřístupňuje kořenový protokolovací nástroj, který můžete použít přímo s integrovaným modulem logging Python. Všechny zprávy napsané pomocí tohoto protokolovacího nástroje se automaticky posílají do Application Insights při spuštění aplikace v Azure.

Protokolování umožňuje zaznamenávat informace o době běhu a diagnostikovat problémy bez potřeby jakéhokoli dalšího nastavení.

Příklad protokolování pomocí triggeru 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")

Můžete použít úplnou sadu úrovní protokolování (debug, info, warning, error, critical) a zobrazí se na portálu Azure v části Protokoly nebo Application Insights.

Další informace o monitorování Azure Functions na portálu najdete v tématu Monitor Azure Functions.

Poznámka:

Pokud chcete zobrazit protokoly ladění v Application Insights, vyžaduje se další nastavení. Tuto funkci můžete povolit nastavením PYTHON_ENABLE_DEBUG_LOGGING na 1 a nastavením logLevel na trace nebo debug ve vašem souboru host.json. Ve výchozím nastavení nejsou protokoly ladění ve službě Application Insights viditelné.

Protokolování z vláken běžících na pozadí

Pokud vaše funkce spouští nové vlákno a potřebuje z tohoto vlákna zapisovat do protokolu, ujistěte se, že argument context předáte tomuto vláknu. context obsahuje místní úložiště vlákna a aktuální invocation_id; obojí musí být nastaveno v pracovním vlákně, aby bylo možné protokoly správně přiřadit k provádění funkce.

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

Konfigurace vlastních protokolovacích nástrojů

Vlastní protokolovací nástroje můžete nakonfigurovat v Python, když potřebujete větší kontrolu nad chováním protokolování, jako je vlastní formátování, filtrování protokolů nebo integrace třetích stran. Ke konfiguraci vlastního protokolovacího nástroje použijte logging.getLogger() Python s vlastním názvem a podle potřeby přidejte obslužné rutiny nebo formátovací rutiny.

import logging

custom_logger = logging.getLogger('my_custom_logger')

Podpora OpenTelemetry

Azure Functions pro Python také podporuje OpenTelemetry, což umožňuje generovat trasování, metriky a protokoly ve standardizovaném formátu. Použití OpenTelemetry je zvláště cenné pro distribuované aplikace nebo scénáře, ve kterých chcete exportovat telemetrii do nástrojů mimo Application Insights (například Grafana nebo Jaeger).

Pokyny k nastavení a vzorový kód najdete v našem rychlém startu pro OpenTelemetry pro Azure Functions (Python).

Testování částí

Pište a spouštějte jednotkové testy pro vaše funkce pomocí pytest. Funkce Python jako jiné Python kódu můžete testovat pomocí standardních testovacích architektur. U většiny vazeb můžete vytvořit napodobený vstupní objekt vytvořením instance příslušné třídy z azure.functions balíčku.

Pomocí my_function jako příkladu je následující ukázka testem funkce aktivované protokolem HTTP:

Nejprve vytvořte <soubor project_root>/function_app.py a implementujte my_function funkci jako 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
    )

Můžete začít psát testovací případy pro trigger 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',
    )

Uvnitř složky Python virtuálního prostředí spusťte následující příkazy k otestování aplikace:

pip install pytest
pytest test_my_function.py

V terminálu se zobrazí výsledky pytest takto:

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

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

Optimalizace a pokročilá témata

Další informace o optimalizaci aplikací Python functions najdete v těchto článcích:

Další informace o službě Functions najdete v těchto článcích:

Dokumentace k rozhraní API balíčku Azure Functions
Osvědčené postupy pro Azure Functions
Azure Functions triggery a vazby
vazby Blob Storage
HTTP a webhookové vazby
Vazby fronty úložiště
Triggery časovače

Máte problémy s používáním Python? Dejte nám vědět a zapište problém.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-09-10

Referenční příručka pro vývojáře Azure Functions pro aplikace Python

Začínáme

Sestavení aplikace funkcí

Programovací model

Klíčové koncepty

Knihovna azure-functions

Alternativní vstupní bod

Struktura složek

Klíčové soubory a složky

Klíčové koncepty

Knihovna azure-functions

Čtení parametrů trasy

Uspořádání s využitím podrobných plánů

Struktura složek

Klíčové soubory a složky

Spouštěče a vazby

Příklad: Trigger časovače s Blob vstupem

Klíčové koncepty

Příklad: Trigger HTTP se vstupem služby Cosmos DB a výstupem centra událostí

Klíčové koncepty

Vazby typu sady SDK

Přidružení agentů

Proměnné prostředí

Správa balíčků

Úvahy

Spuštění a nasazení

Lokální spuštění

Použití nástrojů Azure Functions Core Tools

Přímé vyvolání funkce

Podporované verze Python

Sestavení a nasazení

aktualizace Python verze 3.13 nebo novější

Pozorovatelnost a testování

Protokolování a monitorování

Příklad protokolování pomocí triggeru HTTP

Protokolování z vláken běžících na pozadí

Konfigurace vlastních protokolovacích nástrojů

Podpora OpenTelemetry

Testování částí

Optimalizace a pokročilá témata

Související články

Váš názor

Další materiály

Knihovna `azure-functions`

Knihovna `azure-functions`