Sdílet prostřednictvím

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

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 Pythonu a pomáhá vám:

  • Vytváření a spouštění aplikací Function Apps místně
  • Vysvětlení programovacího modelu Pythonu
  • 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 referenční informace pro vývojáře azure Functions.

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

Version Popis
2.x Pomocí dekorátoru můžete definovat triggery a vazby přímo v souboru kódu Pythonu. 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 v Pythonu.
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 Pythonu. Tato verze modelu podporuje starší verze aplikací.

Tento článek cílí na konkrétní verzi modelu Pythonu. 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 Pythonu v1 je každá funkce definována jako globální bezstavová main() metoda 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

azure-functions Knihovna Pythonu 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 Azure Functions v Pythonu, ale nejedná se o sadu SDK pro obecné účely. Použijte ho speciálně pro vytváření a spouštění funkcí v modulu runtime Azure Functions.

Alternativní vstupní bod

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

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

Struktura složek

Pro projekt Azure Functions v Pythonu 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 Závislosti Pythonu nainstalované během publikování při použití vzdáleného sestavení ❌ (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 Pythonu v2 používá Azure Functions přístup založený na dekorátoru 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

azure-functions Knihovna Pythonu 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 Azure Functions v Pythonu, ale nejedná se o sadu SDK pro obecné účely. Použijte ho speciálně pro vytváření a spouštění funkcí v modulu runtime Azure Functions.

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í použijte podrobné plány k definování funkcí v samostatných souborech Pythonu a jejich registraci 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 Pythonu, 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 Azure Functions v Pythonu 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, ve kterém jsou pomocí dekorátorů definované funkce a triggery Azure Functions. ✅
host.json Globální konfigurace pro všechny funkce v aplikaci ✅
requirements.txt Závislosti Pythonu nainstalované během publikování při použití vzdáleného sestavení ❌ (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 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í funkce a vazby pro připojení kódu k dalším službám, jako jsou úložiště, fronty a databáze. V programovacím modelu Pythonu 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 ve službě 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 function.json zadáte direction 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 sadami 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 Pythonu v2.

Proměnné prostředí

Proměnné prostředí ve službě 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á proměnné systémového prostředí, které konfigurují modul runtime Functions a chování pracovních procesů 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 ve své aplikaci Azure Functions používat další balíčky Pythonu, uveďte je v souboru v requirements.txt kořenovém adresáři projektu. Tyto balíčky se naimportují systémem importu Pythonu 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 Možnosti sestavení pro aplikace funkcí Pythonu.

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 standardních knihovnách Pythonu (například email/, json/).
    • Nezahrnujte nativní knihovny Pythonu (například logging, asyncionebo uuid) do 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 verzi Pythonu své aplikace, přestavte ji a znovu nasadíte v nové verzi Pythonu, abyste se vyhnuli konfliktům závislostí s dříve sestavenými balíčky.
  • Závislosti jiného typu než PyPI:
  • Závislosti pracovních procesů Azure Functions v Pythonu:

Spuštění a nasazení

Tato část obsahuje informace o místním spouštění funkcí, podpoře verzí Pythonu, možnostech sestavení a nasazení a konfiguraci modulu runtime. Pomocí těchto informací můžete úspěšně spustit aplikaci funkcí v místním prostředí i v prostředích Azure.

Lokální spuštění

Před nasazením do Azure můžete spustit a otestovat aplikaci funkcí Pythonu na místním počítači.

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

Nainstalujte nástroje Azure Functions Core Tools a spusťte místní modul runtime spuštěním func start příkazu 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 tom, jak používat Nástroje Core Tools, najdete v tématu Vývoj azure Functions místně pomocí nástrojů Core Tools.

Přímé vyvolání funkce

Pomocí , azure-functions >= 1.21.0můžete také volat funkce přímo pomocí interpretu Pythonu 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 pomocí Pythonu:

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

> 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 Pythonu

Azure Functions podporuje verze Pythonu uvedené v podporovaných jazycích ve službě Azure Functions. Další obecné informace najdete v zásadách podpory modulu runtime Azure Functions.

Důležité

Pokud změníte verzi Pythonu pro vaši aplikaci funkcí, musíte aplikaci znovu sestavit a znovu nasadit pomocí nové verze. Existující artefakty a závislosti nasazení se při změně verze Pythonu automaticky nepřegenerují.

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 Technologie nasazení ve službě 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: Nasazení do 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í sestavení Pythonu, 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 Pythonu.

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. Tato změna nemá vliv na aplikace spuštěné ve Windows v plánu Consumption. Další informace najdete v oznámení o vyřazení plánu Linux Consumption.

Aktualizace Pythonu 3.13 nebo novější

Počínaje Pythonem 3.13 zavádí Služba Azure Functions 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í runtime: Nyní můžete volitelně zafixovat nebo upgradovat aplikaci na konkrétní pracovní verze Pythonu odkazem 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 Pythonu, kterou spravuje služba Functions. Soubor requirements.txt musíte upravit tak, aby požadoval nejnovější vydané verze, předběžnou verzi nebo připnul aplikaci na konkrétní verzi modulu runtime Pythonu.

    • Správu verzí modulu runtime povolíte tak, že do souboru requirements.txt přidáte odkaz na balíček modulu runtime Python, 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 měli přehled o změnách, pravidelně si projděte poznámky k verzi modulu runtime Pythonu .

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

      Version Example Chování
      Žádná sada hodnot azure-functions-runtime Vaše aplikace v Pythonu 3.13 nebo novější běží na nejnovější dostupné verzi modulu runtime Functions Python. 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 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 Tím, že nenastavíte azure-functions-runtime, vaše aplikace Python 3.13+ běží na výchozí verzi modulu runtime Pythonu, která je za nejnovější vydané verze. 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 nebude mít žádný vliv na aplikace spuštěné v Pythonu 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í runtime: Nyní můžete volitelně zafixovat nebo upgradovat aplikaci na konkrétní pracovní verze Pythonu odkazem 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 Pythonu, kterou spravuje služba Functions. Soubor requirements.txt musíte upravit tak, aby požadoval nejnovější vydané verze, předběžnou verzi nebo připnul aplikaci na konkrétní verzi modulu runtime Pythonu.

    • Správu verzí modulu runtime povolíte tak, že do souboru requirements.txt přidáte odkaz na balíček modulu runtime Python, 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 měli přehled o změnách, pravidelně si projděte poznámky k verzi modulu runtime Pythonu .

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

      Version Example Chování
      Žádná sada hodnot azure-functions-runtime-v1 Vaše aplikace v Pythonu 3.13 nebo novější běží na nejnovější dostupné verzi modulu runtime Functions Python. 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 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í modulu runtime. 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 Tím, že nenastavíte azure-functions-runtime-v1, vaše aplikace Python 3.13+ běží na výchozí verzi modulu runtime Pythonu, která je za nejnovější vydané verze. 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 nebude mít žádný vliv na aplikace spuštěné v Pythonu 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 popisuje možnosti protokolování, monitorování a testování , které vám pomůžou ladit problémy, sledovat výkon a zajistit spolehlivost aplikací funkcí Pythonu.

Protokolování a monitorování

Azure Functions zveřejňuje kořenový protokolovací nástroj, který můžete použít přímo s integrovaným logging modulem Pythonu. Všechny zprávy napsané pomocí tohoto protokolovacího nástroje se automaticky posílají do Application Insights , když je vaše aplikace spuštěná 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 webu Azure Portal v části Protokoly nebo Application Insights.

Další informace o monitorování azure Functions na portálu najdete v tématu Monitorování 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 v Pythonu můžete nakonfigurovat, 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. Pokud chcete nakonfigurovat vlastní protokolovací modul, použijte Python logging.getLogger() 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 ukázkový kód najdete v našem rychlém startu OpenTelemetry pro Azure Functions (Python ).

Testování částí

Pište a spouštějte jednotkové testy pro vaše funkce pomocí pytest. Funkce Pythonu, jako jsou jiné kódy Pythonu, můžete otestovat 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í Pythonu 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í funkcí Pythonu 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 Pythonu? Dejte nám vědět a zapište problém.

  • Last updated on