Sdílet prostřednictvím

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 v aplikaci používáte azure-functions , musí být součástí závislostí 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 Pythonové závislosti jsou nainstalovány během publikování s použitím 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 Nepublikuje se 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í azure-functions být součástí závislostí projektu. Další informace najdete v tématu Správa balíčků.

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.

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

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

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:

  1. 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!")

  2. 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 Pythonové závislosti jsou nainstalovány během publikování s použitím 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 Nepublikuje se do Azure. ❌
Dockerfile Definuje vlastní kontejner pro nasazení. ❌

[POZNÁMKA!] Při nasazení pomocí requirements.txt sestavení zahrňte soubor. Pokud nepoužíváte vzdálené sestavení nebo chcete k definování závislostí aplikací použít jiný soubor, můžete provést místní sestavení a nasadit aplikaci s předem sestavenými závislostmi.

Pokyny k testování jednotek najdete v tématu Testování částí. Nasazení kontejnerů najdete v tématu Nasazení s vlastními kontejnery.

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 Azure SDKs 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.

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í:

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á systémové proměnné prostředí, které konfigurují Functions runtime a chování pracovní 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. Tyto balíčky se naimportují systémem importu Python a pak na tyto balíčky můžete odkazovat obvyklým způsobem. 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 .

Jakmile je balíček nainstalovaný, můžete ho importovat a používat v kódu funkce:

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í:
    • Chcete-li zabránit ModuleNotFound chybám, ujistěte se, že jsou uvedeny všechny požadované závislosti v requirements.txt.
    • 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 jiného typu než PyPI:
  • Azure Functions Python závislostí pracovního procesu:
    • Pokud váš balíček obsahuje určité knihovny, které můžou kolidovat se závislostmi pracovního procesu (například protobufgrpcio), nakonfigurujte PYTHON_ISOLATE_WORKER_DEPENDENCIES na hodnotu 1 v nastavení aplikace, aby aplikace nemohla odkazovat na závislosti pracovního procesu. U Python verze 3.13 a vyšší je ve výchozím nastavení povolená funkce this.

Spuštění a nasazení

Tato část obsahuje informace o spouštění funkcí místně, podpora verzí Pythonu, možnosti sestavení a 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. Podrobnější testování najdete v tématu Testování částí.

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.

Důležité

Pokud změníte Python verzi aplikace funkcí, musíte aplikaci znovu sestavit a znovu nasadit pomocí nové verze. Existující artefakty nasazení a závislosti nejsou automaticky přestavěny při změně verze Pythonu.

Build and Deployment

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 nasazovací technologie v prostředí Azure Functions.

Rychlé porovná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 CI/CD založené na GitHubu. 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 Azure portálu → v 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é

Po 30. září 2028 se v plánu Consumption vyřadí možnost hostovat aplikaci funkcí v Linuxu. Abyste se vyhnuli přerušení, migrujte stávající aplikace plánu Consumption, které běží v Linuxu, do plánu Flex Consumption před tímto datem. Na aplikace spuštěné na Windows v plánu Consumption tato změna nemá vliv.

Po 30. září 2025 se do plánu Consumption pro Linux nepřidají žádné nové funkce a žádná podpora zásobníku nových jazyků. Poslední podporované jazykové verze pro Linux Consumption jsou: .NET 9, Python 3.12, Node.js 22, PowerShell 7.4 a Java 21. Novější jazykové verze nejsou podporovány pro využití Linuxu.

Další informace najdete v dokumentu Migrace aplikací z plánu Consumption do plánu Flex Consumption.

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 pracovního procesu Python 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).

    • Pokud chcete být informováni o změnách, pravidelně si projděte poznámky k vydání prostředí Python runtime.

    • 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 Pokud nenastavíte azure-functions-runtime, vaše aplikace Python 3.13 nebo novější poběží 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í aplikace PYTHON_ISOLATE_WORKER_DEPENDENCIES nebude mít žádný vliv na aplikace spuštěné na Python 3.13 nebo novější.

  • 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 pracovního procesu Python 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).

    • Pokud chcete být informováni o změnách, pravidelně si projděte poznámky k vydání prostředí Python runtime.

    • 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 Pokud nenastavíte azure-functions-runtime-v1, vaše aplikace Python 3.13 nebo novější poběží 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í aplikace PYTHON_ISOLATE_WORKER_DEPENDENCIES nebude mít žádný vliv na aplikace spuštěné na Python 3.13 nebo novější.

  • 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 spustí nové vlákno a potřebuje protokolovat z daného vlákna, nezapomeňte do vlákna předat context argument. context obsahuje vláknově lokální úložiště a aktuální invocation_id, které musí být nastaveny v pracovním vlákně, aby protokoly byly správně přiřazeny ke spuště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',
    )

Ve složce virtuálního prostředí Python můžete aplikaci otestovat spuštěním následujících příkazů:

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:

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

  • Last updated on