Azure Functions fejlesztői referencia-útmutató Python-alkalmazásokhoz

Azure Functions egy kiszolgáló nélküli számítási szolgáltatás, amely lehetővé teszi az eseményvezérelt kód futtatását az infrastruktúra kiépítése és kezelése nélkül. A függvényvégrehajtásokat események, például HTTP-kérések, üzenetsor-üzenetek, időzítők vagy a tárterület változásai aktiválják, és igény szerint automatikusan skálázhatók.

Ez az útmutató kifejezetten a Python-alapú Azure Functions kialakítására összpontosít, és segít:

Függvényalkalmazások helyi létrehozása és futtatása
A Python programozási modell ismertetése
Az alkalmazás rendszerezése és konfigurálása
Az alkalmazás üzembe helyezése és monitorozása a Azure
Ajánlott eljárások alkalmazása a skálázáshoz és a teljesítményhez

Fogalmi áttekintést keres? Lásd a Azure Functions fejlesztői referenciát.

Érdeklik a valós használati esetek? Ismerkedjen meg a Forgatókönyvek és minták laplal.

Kezdő lépések

Válassza ki a munkafolyamatának megfelelő környezetet, és vágjon bele az Azure Functions for Python használatába.

A függvényalkalmazás létrehozása

Ez a szakasz a Python függvényalkalmazás létrehozásához és strukturálásához szükséges alapvető összetevőket ismerteti. A témakörök közé tartozik a programozási modell, a projektstruktúra, az eseményindítók és kötések, valamint a függőségkezelés.

Programozási modell

A Functions a Python programozási modell két verzióját támogatja:

verzió	Leírás
2.x	Dekorátoralapú megközelítéssel közvetlenül definiálhat triggereket és kötéseket a Python kódfájlban. Minden függvényt globális, állapot nélküli metódusként implementálhat egy `function_app.py` fájlban vagy egy hivatkozott tervfájlban. Ez a modellverzió az új Python-alkalmazásokhoz ajánlott.
1.x	Az egyes függvények eseményindítóit és kötéseit külön `function.json` fájlban határozhatja meg. Az egyes függvényeket globális, állapot nélküli metódusként implementálhatja a Python kódfájlban. A modell ezen verziója támogatja az örökölt alkalmazásokat.

Ez a cikk egy adott Python modellverziót céloz meg. Válassza ki a kívánt verziót a cikk tetején.

Fontos

A v2 programozási modell használatával dekorátoralapú megközelítést használhat az eseményindítók és kötések közvetlen definiálásához a kódban.

Az Python 1-s verziójú programozási modellben minden függvény globális, állapot nélküli main() metódusként van definiálva egy __init__.py nevű fájlban. A függvény eseményindítói és kötései külön vannak konfigurálva egy function.json fájlban, és a kötési name értékeket main() a metódus paraméterként használja.

Example

Íme egy egyszerű függvény, amely egy HTTP-kérésre válaszol:

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

Íme a megfelelő function.json fájl:

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

Főbb fogalmak

A függvény egyetlen HTTP-eseményindítóval rendelkezik.
A HttpRequest objektum kérelemfejléceket, lekérdezési paramétereket, útvonalparamétereket és üzenettörzset tartalmaz. Ez a függvény lekéri a name lekérdezési paraméter értékét a paramsHttpRequest objektum paraméteréből.
Ha el szeretne küldeni egy nevet ebben a példában, fűzze hozzá ?name={name} a közzétett függvény URL-címéhez. Ha például helyileg fut, a teljes URL-cím a következőképpen http://localhost:7071/api/http_trigger?name=Testnézhet ki. A kötéseket használó példákért lásd az eseményindítókat és a kötéseket.

Használja az azure-functions SDK-t, és adjon meg típusjegyzeteket az IntelliSense és a szerkesztő támogatásának javításához:

# __init__.py
import azure.functions as func

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

# requirements.txt
azure-functions

A `azure-functions` könyvtár

A azure-functions Python kódtár biztosítja a Azure Functions futtatókörnyezettel való interakcióhoz használt alapvető típusokat. Az összes elérhető típus és metódus megtekintéséhez látogasson el az azure-functions API-ba. A függvénykód a következőre használható azure-functions :

Hozzáférési eseményindító bemeneti adatai (például HttpRequest, TimerRequest)
Kimeneti értékek létrehozása (például HttpResponse)
Futtatókörnyezet által biztosított környezet és kötési adatokkal való interakció

Ha a(z) azure-functions komponensét használja az alkalmazásában, akkor azt fel kell venni a projektfüggőségeibe.

Feljegyzés

A azure-functions kódtár határozza meg a Python Azure Functions programozási felületét, de ez nem általános célú SDK. Kifejezetten a Azure Functions futtatókörnyezeten belüli függvények készítéséhez és futtatásához használható.

Alternatív belépési pont

A függvény alapértelmezett viselkedését úgy módosíthatja, hogy a scriptFile és entryPoint tulajdonságokat a function.json fájlban adja meg. Az alábbi function.json fájl például a futtatókörnyezetet a custom_entry() metódus használatára irányítja a main.py fájlban a Azure függvény belépési pontjaként.

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

Mappastruktúra

Használja a következő struktúrát egy Python Azure Functions projekthez:

<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

Kulcsfájlok és mappák

Fájl/mappa	Leírás	Az alkalmazás Azure való futtatásához szükséges
`my_first_function/`	Egyetlen függvény mappája.	✅
`__init__.py/`	Fő szkript, ahol a `my_first_function` függvénykód definiálva van.	✅
`function.json/`	A `my_first_function` függvény kötéskonfigurációját tartalmazza.	✅
`host.json`	Az alkalmazás összes függvényének globális konfigurációja.	✅
`requirements.txt`	Python remote build használatakor a közzététel során telepített függőségek.	❌ (csomagkezeléshez ajánlott)
`local.settings.json`	Csak helyi alkalmazásbeállítások és titkos kódok (soha nem tették közzé).	❌ (helyi fejlesztéshez szükséges)
`.funcignore`	Megadja az üzembe helyezésből kizárandó fájlokat és mappákat (például `.venv/`: ; `tests/`). `local.settings.json`	❌ (ajánlott)
`.venv/`	Helyi virtuális környezet a Python számára (az üzembe helyezésből ki van zárva).	❌
`.vscode/`	A Visual Studio Code szerkesztő konfigurációja. Az üzembe helyezéshez nem szükséges.	❌
`shared/`	A függvényalkalmazás-projektben megosztott segédkódot tárolja	❌
`additional_functions/`	Moduláris kódrendszerezéshez használatos – jellemzően tervekkel.	❌
`tests/`	Egységtesztek a függvényalkalmazáshoz. Nincs közzétéve az Azure-ra.	❌
`Dockerfile`	Egyéni tárolót határoz meg az üzembe helyezéshez.	❌

A Python v2 programozási modellben Azure Functions decorator-alapú megközelítést használ az eseményindítók és kötések definiálásához közvetlenül a kódban. Minden függvény globális, állapot nélküli metódusként van implementálva egy fájlon function_app.py belül.

Example

Íme egy egyszerű függvény, amely egy HTTP-kérésre válaszol:

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

Főbb fogalmak

A kód importálja a azure-functions csomagot, és dekorátorokat és típusokat használ a függvényalkalmazás definiálásához.
A függvény egyetlen HTTP-eseményindítóval rendelkezik.
A HttpRequest objektum kérelemfejléceket, lekérdezési paramétereket, útvonalparamétereket és üzenettörzset tartalmaz. Ez a függvény lekéri a name lekérdezési paraméter értékét a paramsHttpRequest objektum paraméteréből.
Ha el szeretne küldeni egy nevet ebben a példában, fűzze hozzá ?name={name} a közzétett függvény URL-címéhez. Ha például helyileg fut, a teljes URL-cím a következőképpen http://localhost:7071/api/http_trigger?name=Testnézhet ki. A kötéseket használó példákért lásd az eseményindítókat és a kötéseket.

A `azure-functions` könyvtár

A azure-functions Python kódtár a Azure Functions programozási modell alapvető része. Biztosítja a dekorátorok, eseményindítók és kötéstípusok, valamint a függvények futásidőben történő definiálásához és kezeléséhez használt kérés-/válaszobjektumokat. Az összes elérhető típus és dekorátor megtekintéséhez látogasson el az azure-functions API-ba. A függvényalkalmazás kódja a következő kódtártól függ:

Az összes függvény definiálása az FunctionApp objektum használatával
Eseményindítók és kötések deklarálása (például @app.route, @app.timer_trigger)
A beírt bemenetekhez és kimenetekhez való hozzáférés (például HttpRequest és HttpResponse, valamint Out`)

Ennek azure-functions szerepelnie kell a projektfüggőségekben. További információ: csomagkezelés.

Feljegyzés

Típusjegyzetek használata az IntelliSense és a szerkesztő támogatásának javításához:

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

Tervezés munkatervekkel

Nagyobb vagy moduláris alkalmazások esetén a blueprints segítségével definiálhat függvényeket külön Python fájlokban, és regisztrálhatja őket a főalkalmazásban. Ez az elkülönítés rendszerezetten és újra felhasználhatóvá teszi a kódot.

Terv definiálása és regisztrálása:

Terv meghatározása egy másik Python fájlban, például 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!")

A terv regisztrálása a főfájlban function_app.py :

import azure.functions as func
from http_blueprint import bp

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

Tervekkel a következőt teheti:

Az alkalmazás újrahasználható modulokra bontása
Kapcsolódó függvények csoportosítása fájl vagy szolgáltatás szerint
Tervek kiterjesztése vagy megosztása projektek között

Feljegyzés

Durable Functions azure-functions-durable használatával is támogatja a terveket. Minta megtekintése →

Mappastruktúra

Használja a következő struktúrát egy Python Azure Functions projekthez:

<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

Kulcsfájlok és mappák

Fájl/mappa	Leírás	Az alkalmazás Azure való futtatásához szükséges
`function_app.py`	Fő szkript, amelyben a Azure Functions és az eseményindítók dekorátorokkal vannak definiálva.	✅
`host.json`	Az alkalmazás összes függvényének globális konfigurációja.	✅
`requirements.txt`	Python remote build használatakor a közzététel során telepített függőségek.	❌ (csomagkezeléshez ajánlott)
`local.settings.json`	Csak helyi alkalmazásbeállítások és titkos kódok (soha nem tették közzé).	❌ (helyi fejlesztéshez szükséges)
`.funcignore`	Megadja az üzembe helyezésből kizárandó fájlokat és mappákat (például `.venv/`: ; `tests/`). `local.settings.json`	❌ (ajánlott)
`.venv/`	Helyi virtuális környezet a Python számára (az üzembe helyezésből ki van zárva).	❌
`.vscode/`	A Visual Studio Code szerkesztő konfigurációja. Az üzembe helyezéshez nem szükséges.	❌
`shared/`	A függvényalkalmazás-projektben megosztott segédkódot tárolja	❌
`additional_functions/`	Moduláris kódrendszerezéshez használatos – jellemzően tervekkel.	❌
`tests/`	Egységtesztek a függvényalkalmazáshoz. Nincs közzétéve az Azure-ra.	❌
`Dockerfile`	Egyéni tárolót határoz meg az üzembe helyezéshez.	❌

[MEGJEGYZÉS!] Tartalmazzon egy requirements.txt fájlt, amikor a távoli buildet telepíti. Ha nem használ távoli buildet, vagy egy másik fájlt szeretne használni az alkalmazásfüggőségek meghatározásához, végrehajthat egy helyi buildet , és üzembe helyezheti az alkalmazást előre összeállított függőségekkel.

Az egységtesztelésről további információt az Egységtesztelés című témakörben talál. Tárolók telepítéséhez lásd: Telepítés egyéni tárolókkal.

Eseményindítók és kötések

Azure Functions triggers használatával indítja el a függvények végrehajtását, és bindings csatlakoztatja a kódot más szolgáltatásokhoz, például tárolókhoz, üzenetsorokhoz és adatbázisokhoz. A Python v2 programozási modellben a kötéseket dekórátorok használatával deklarálhatja.

A kötések két fő típusa létezik:

Eseményindítók (a függvényt elindító bemenet)
Bemenetek és kimenetek (további adatforrások vagy célhelyek)

Az elérhető eseményindítókkal és kötésekkel kapcsolatos további információkért lásd: Triggers and Bindings in Azure Functions.

Példa: Időzítő eseményindító blobbemenettel

Ez a függvény:

Eseményindítók 10 percenként
Blobból SDK típuskötések használatával történő olvasás
Gyorsítótárazza az eredményeket és az írásokat egy ideiglenes fájlba

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

Főbb fogalmak

Használja az SDK-típuskötéseket a gazdag típusokkal való munkához. További információ: SDK-típuskötések.
A globális változók használatával gyorsítótárazhatók a költséges számítások, de az állapotuk nem garantáltan megmarad a függvényvégrehajtások között.
Az ideiglenes fájlok a tmp/ rendszerben vannak tárolva, és nem garantáltan tartósak a hívások és a méretezett példányok között.
Egy függvény meghívási környezetét a Context osztályon keresztül érheti el.

Példa: HTTP-eseményindító Cosmos DB bemenettel és Event Hub kimenettel

Ez a függvény:

HTTP-kérelem eseményindítói
Olvasás Cosmos DB-ből
Írás egy Event Hub-kimenetbe
HTTP-választ ad vissza

# __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"
    }
  ]
}

főbb fogalmak

Mindegyik függvény egyetlen eseményindítóval rendelkezik, de több kötéssel is rendelkezhet.
A bemenetek hozzáadásához adja meg a direction értéket "in"-ként a function.json. A kimenetek directionout értékkel rendelkeznek.
A kérelem részleteit az HttpRequest objektumon keresztül érheti el, és létrehozhat egy egyénit HttpResponse fejlécekkel, állapotkóddal és törzstel.

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
    )

Főbb fogalmak

A függvény meghívásának módjának meghatározásához használjon @route() vagy aktiváljon konkrét dekorátorokat (@timer_trigger@queue_triggerés másokat).
Adjon hozzá bemeneteket dekorátorok, például @blob_input, @queue_input és mások használatával.
A kimenetek a következőek lehetnek:
- Közvetlenül visszaadva (ha csak egy kimenet van)
- Out Kötésekkel való hozzárendelés és a .set() metódus több kimenetre történő alkalmazása.
A kérelem részleteit az HttpRequest objektumon keresztül érheti el, és létrehozhat egy egyénit HttpResponse fejlécekkel, állapotkóddal és törzstel.

SDK-típuskötések

Az eseményindítók és kötések kiválasztásához használhatja az alapul szolgáló Azure SDKs és keretrendszerek által implementált adattípusokat. Ezeknek az SDK-típusú kötéseknek a használatával úgy kezelheti a kötési adatokat, mintha a mögöttes szolgáltatás SDK-t használták volna. További információ: támogatott SDK-típuskötések.

Fontos

A Python SDK típusú kötések csak a Python 2-es verziós programozási modellben érhetők el.

Környezeti változók

A környezeti változók az Azure Functions-ben lehetővé teszik a konfigurációs értékek, kapcsolati sztringek és alkalmazás titkok biztonságos kezelését anélkül, hogy azokat hardcode-olnák a függvénykódban.

Környezeti változókat definiálhat:

Helyileg: a local.settings.json fájlban, a helyi fejlesztés során.
Az Azure: Alkalmazás beállításai a függvényalkalmazás konfigurációs lapján az Azure portálon.

A változókat közvetlenül a kódban érheti el os.environ vagy os.getenv használatával.

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

Feljegyzés

Azure Functions felismeri a Functions-futtatókörnyezetet konfiguráló rendszerkörnyezeti változókat, és Python feldolgozói viselkedést. Ezeket a változókat a függvénykód nem használja explicit módon, de hatással van az alkalmazás működésére. A rendszerkörnyezet változóinak teljes listájáért tekintse meg az alkalmazásbeállításokra vonatkozó hivatkozást.

Csomagkezelés

Ha más Python csomagokat szeretne használni a Azure Functions alkalmazásban, listázhatja őket egy requirements.txt fájlban a projekt gyökerében. Ezeket a csomagokat Python importáló rendszere importálja, és a szokásos módon hivatkozhat ezekre a csomagokra. A külső függőségekkel rendelkező építési és üzembehelyezési lehetőségekről a Függvényalkalmazások Python beépített beállításai című témakörben olvashat bővebben.

Az alábbi példa például azt mutatja be, hogyan tartalmazza és használja a requests modult a függvényalkalmazás.

<requirements.txt>
requests==2.31.0

Telepítse a csomagot helyileg a következővel pip install -r requirements.txt: .

A csomag telepítése után importálhatja és használhatja a függvénykódban:

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

Megfontolások

Ütközések a beépített modulokkal:
- Kerülje a projektmappák elnevezését Python standard kódtárak után (például email/, json/).
- Ne vegye bele a Python natív kódtárakat (például logging, asyncio vagy uuid) a requirements.txt-be.
Telepítési:
- A hibák elkerülése ModuleNotFoundérdekében győződjön meg arról, hogy az összes szükséges függőség szerepel a requirements.txtlistában.
- Ha frissíti az alkalmazás Python verzióját, újraépítheti és újra üzembe helyezheti az alkalmazást az új Python verzióban, hogy elkerülje a függőségi ütközéseket a korábban létrehozott csomagokkal.
Nem PyPI-függőségek:
- Olyan függőségeket is tartalmazhat, amelyek nem érhetők el a PyPI-ban az alkalmazásban, például helyi csomagokat, kerékfájlokat vagy privát hírcsatornákat. A beállítási utasításokat a Custom-függőségek Python Azure Functions című témakörben találja.
Azure Functions Python munkamenet függőségek:
- Ha a csomag olyan kódtárakat tartalmaz, amelyek ütközhetnek a worker függőségeivel (például protobuf vagy grpcio), az alkalmazásbeállításokban konfigurálja a PYTHON_ISOLATE_WORKER_DEPENDENCIES 1 értékre, hogy az alkalmazás ne hivatkozzon a worker függőségeire. A 3.13-Python és újabb verziók esetében a a funkció alapértelmezés szerint engedélyezve van.

Futtatás és üzembe helyezés

Ez a szakasz a helyi futtatási függvényekről, Python verziótámogatásról, - és üzembe helyezési lehetőségekről és a futtatókörnyezet konfigurálásáról nyújt tájékoztatást. Ezekkel az információkkal sikeresen futtathatja a függvényalkalmazást helyi és Azure környezetekben is.

Helyi futtatás

A Azure üzembe helyezése előtt futtathatja és tesztelheti a Python függvényalkalmazást a helyi gépen.

Az Azure Functions Core Tools használata

Telepítse Azure Functions Core Tools és indítsa el a helyi futtatókörnyezetet a func start parancs futtatásával a projekt gyökérkönyvtárából:

func start

Amikor helyileg indítja el a függvényalkalmazást, a Core Tools megjeleníti az alkalmazáshoz talált összes függvényt:

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

Az alábbi linken keresztül többet megtudhat arról, hogyan használhatja a Core Tools alkalmazást az Azure Functions helyi fejlesztéséhez: Az Azure Functions helyi fejlesztése Core Tools használatával.

A függvény közvetlen meghívása

A azure-functions >= 1.21.0 használatával közvetlenül is meghívhat függvényeket a Python értelmező használatával a Core Tools futtatása nélkül. Ez a módszer a gyorsegység-tesztekhez hasznos:

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

A kimenet megtekintéséhez futtassa a fájlt közvetlenül a Python segítségével.

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

A kimenet megtekintéséhez futtassa a fájlt közvetlenül a Python segítségével.

> python __init__.py

Hello, World!

Ez a megközelítés nem igényel további csomagokat vagy beállításokat, és ideális a gyors ellenőrzéshez a fejlesztés során. Részletesebb tesztelésért lásd: Egységtesztelés

Támogatott Python verziók

Azure Functions támogatja a Támogatott nyelvek Azure Functions felsorolt Python-verziókat. További általános információ: Azure Functions futtatókörnyezet támogatási szabályzata.

Fontos

Ha módosítja a függvényalkalmazás Python verzióját, újra kell építenie és újra kell üzembe helyeznie az alkalmazást az új verzióval. A meglévő üzembehelyezési összetevők és függőségek nem lesznek automatikusan újraépülve, amikor a Python verzió módosul.

buildelés és üzembe helyezés

A forgatókönyvhöz javasolt buildelési mechanizmusról további információt a Build beállításai című témakörben talál. Az üzembe helyezés általános áttekintését lásd: A Azure Functions üzembehelyezési technológiái.

Üzembehelyezési mechanizmusok gyors összehasonlítása

Eszköz/platform	Parancs / tevékenység	Legjobb használati eset
Azure Functions Core Tools	`func azure functionapp publish <APP_NAME>`	Ideális ci-futtatásokhoz, helyi automatizáláshoz vagy platformfüggetlen munkavégzéshez.
AZ CLI	`az functionapp deployment source config-zip`	Hasznos, ha a Core Tools-on kívüli telepítéseket szkriptel. Jól működik automatizált folyamatokban vagy felhőalapú terminálokban (Azure Cloud Shell).
Visual Studio Code (Azure Functions bővítmény)	Parancs paletta → "Azure Functions: Üzembe helyezés Azure..."	Kezdőknek vagy interaktív telepítésekhez legmegfelelőbb. Automatikusan kezeli a csomagolást és az összeállítást.
GitHub Actions	`Azure/functions-action@v1`	Ideális GitHub-alapú CI/CD-hez. Lehetővé teszi az automatizált üzembe helyezéseket push vagy Pull Request egyesítéseknél.
Azure Pipelines	`AzureFunctionApp@2` Feladat	Vállalati CI/CD Azure DevOps használatával. A legjobb megoldás szabályozott kiadási munkafolyamatokhoz, kapus buildekhez és többfázisú folyamatokhoz.
Egyéni konteiner üzembe helyezése	Leküldéses tároló → `az functionapp create --image <container>`	Operációsrendszer-szintű csomagokra, egyéni Python buildekre, rögzített futtatókörnyezetekre vagy nem támogatott függőségekre (például rendszertárakra, helyi bináris fájlokra) van szükség.
Portálalapú függvény létrehozása	Függvény létrehozása a Azure portálon → beágyazott szerkesztőben	Csak egyszerű, függőségmentes függvényekhez használható. Nagyszerűen használható demókhoz vagy tanuláshoz, de külső csomagokat igénylő alkalmazásokhoz nem ajánlott .

Feljegyzés

A portálalapú függvénylétrehozás nem támogatja a külső függőségeket, és nem ajánlott éles alkalmazások létrehozásához. A azure-functions és a beépített Python standard kódtáron kívül nem telepíthet és nem hivatkozhat csomagokra.

Fontos

2028. szeptember 30. után megszűnik az a lehetőség, hogy a függvényalkalmazást Linuxon üzemeltetje egy használatalapú csomagban. A fennakadások elkerülése érdekében migrálja a Linuxon futó meglévő használatterv-alkalmazásokat a Flex Consumption csomagba az adott dátum előtt. A használatalapú csomagban Windows futó alkalmazásokat ez a változás nem érinti.

2025. szeptember 30. után nem adnak hozzá új funkciókat és új nyelvi veremtámogatást a Linux-fogyasztói tervhez. A Linux-használat legutóbbi támogatott nyelvi verziói a következők: .NET 9, Python 3.12, Node.js 22, PowerShell 7.4 és Java 21. Linux Consumption esetén az újabb nyelvi verziók nem támogatottak.

További információ: Használati terv alkalmazásainak migrálása a Flex fogyasztási csomagba.

Python 3.13+-os frissítések

A Python 3.13-tól kezdve a Azure Functions számos jelentős futtatókörnyezeti és teljesítménybeli fejlesztést vezet be, amelyek hatással vannak az alkalmazások készítésére és futtatására. A legfontosabb változások a következők:

Futtatókörnyezeti verziókövetés: Mostantól hozzárendelheti vagy frissítheti az alkalmazást adott Python munkavégző verziókra a azure-functions-runtimerequirements.txt csomagra való hivatkozással.

A verziókövetés engedélyezése nélkül az alkalmazás a Python futtatókörnyezet alapértelmezett verzióján fut, amelyet a Functions felügyel. Módosítania kell a requirements.txt fájlt, hogy lekérje a legújabb kiadott verziót, egy előre kiadott verziót, vagy rögzítse az alkalmazást a Python futtatókörnyezet egy adott verziójára.
A futtatókörnyezet verziókövetésének engedélyezéséhez adjon egy hivatkozást a requirements.txt fájlhoz a Python futtatókörnyezet-csomagra, ahol a csomaghoz rendelt érték határozza meg a használt futtatókörnyezet-verziót.
Kerülje az éles alkalmazások kötését az előzetes kiadású (alfa, béta vagy fejlesztői) verziókhoz.
Legyen tisztában a változásokkal, és tekintse át rendszeresen a Python futtatókörnyezet kibocsátási megjegyzéseit.

Az alábbi táblázat a verziószámozási viselkedést jelzi a requirements.txt fájlban található beállítás verzióértékének megfelelően:

verzió	Example	Magatartás
Nincs értékkészlet	`azure-functions-runtime`	A Python 3.13+-os verziójú alkalmazás a Functions Python futtatókörnyezet legújabb elérhető verzióján fut. Ez a lehetőség a legjobb megoldás a platformfejlesztések és -funkciók naprakészen maradásához, mivel az alkalmazás automatikusan megkapja a legújabb stabil futtatókörnyezeti frissítéseket.
Egy adott verzióhoz rögzítve	`azure-functions-runtime==1.2.0`	A Python 3.13+-os verziójú alkalmazás a rögzített futtatókörnyezeti verzióban marad, és nem kap automatikus frissítéseket. Ehelyett manuálisan kell frissítenie a rögzített verziót, hogy kihasználhassa az új funkciókat, javításokat és fejlesztéseket a futtatókörnyezetben. A rögzítés kritikus fontosságú éles feladatokhoz ajánlott, ahol elengedhetetlen a stabilitás és a kiszámíthatóság. A rögzítéssel az alkalmazást előzetes kiadású futtatókörnyezeti verziókon is tesztelheti a fejlesztés során.
Nincs csomaghivatkozás	nincs adat	Ha nem állítja be a `azure-functions-runtime`, a Python 3.13+-os verziójú alkalmazás a legújabb kiadású verzió mögötti Python futtatókörnyezet alapértelmezett verzióján fut. A függvények rendszeresen frissítéseket eszközölnek. Ez a beállítás biztosítja a stabilitást és a széles körű kompatibilitást. A legújabb funkciókhoz és javításokhoz való hozzáférés azonban az alapértelmezett verzió frissítéséig késik.

Függőségek elkülönítése: Az alkalmazás függőségei (például grpcio vagy protobuf) teljesen el vannak különítve a feldolgozó függőségeitől, így megelőzve a verzióütközéseket. Az alkalmazásbeállítás PYTHON_ISOLATE_WORKER_DEPENDENCIES nem lesz hatással a Python 3.13-on vagy újabb verziókon futó alkalmazásokra.
Egyszerűsített HTTP-streamelés beállítása – nincs szükség speciális alkalmazásbeállításokra.
A feldolgozói bővítmények és a megosztott memóriafunkciók támogatása megszűnt.

Futtatókörnyezeti verziókövetés: Mostantól hozzárendelheti vagy frissítheti az alkalmazást adott Python munkavégző verziókra a azure-functions-runtime-v1requirements.txt csomagra való hivatkozással.

A verziókövetés engedélyezése nélkül az alkalmazás a Python futtatókörnyezet alapértelmezett verzióján fut, amelyet a Functions felügyel. Módosítania kell a requirements.txt fájlt, hogy lekérje a legújabb kiadott verziót, egy előre kiadott verziót, vagy rögzítse az alkalmazást a Python futtatókörnyezet egy adott verziójára.
A futtatókörnyezet verziókövetésének engedélyezéséhez adjon egy hivatkozást a requirements.txt fájlhoz a Python futtatókörnyezet-csomagra, ahol a csomaghoz rendelt érték határozza meg a használt futtatókörnyezet-verziót.
Kerülje az éles alkalmazások kötését az előzetes kiadású (alfa, béta vagy fejlesztői) verziókhoz.
Legyen tisztában a változásokkal, és tekintse át rendszeresen a Python futtatókörnyezet kibocsátási megjegyzéseit.

Az alábbi táblázat a verziószámozási viselkedést jelzi a requirements.txt fájlban található beállítás verzióértékének megfelelően:

verzió	Example	Magatartás
Nincs értékkészlet	`azure-functions-runtime-v1`	A Python 3.13+-os verziójú alkalmazás a Functions Python futtatókörnyezet legújabb elérhető verzióján fut. Ez a lehetőség a legjobb megoldás a platformfejlesztések és -funkciók naprakészen maradásához, mivel az alkalmazás automatikusan megkapja a legújabb stabil futtatókörnyezeti frissítéseket.
Egy adott verzióhoz rögzítve	`azure-functions-runtime-v1==1.2.0`	A Python 3.13+-os verziójú alkalmazás a rögzített futtatókörnyezeti verzióban marad, és nem kap automatikus frissítéseket. Ehelyett manuálisan kell frissítenie a rögzített verziót, hogy kihasználhassa az új funkciókat, javításokat és fejlesztéseket a futtatókörnyezetben. A rögzítés kritikus fontosságú éles feladatokhoz ajánlott, ahol elengedhetetlen a stabilitás és a kiszámíthatóság. A rögzítéssel az alkalmazást előzetes kiadású futtatókörnyezeti verziókon is tesztelheti a fejlesztés során.
Nincs csomaghivatkozás	nincs adat	Ha nem állítja be a `azure-functions-runtime-v1`, a Python 3.13+-os verziójú alkalmazás a legújabb kiadású verzió mögötti Python futtatókörnyezet alapértelmezett verzióján fut. A függvények rendszeresen frissítéseket eszközölnek. Ez a beállítás biztosítja a stabilitást és a széles körű kompatibilitást. A legújabb funkciókhoz és javításokhoz való hozzáférés azonban az alapértelmezett verzió frissítéséig késik.

Függőségek elkülönítése: Az alkalmazás függőségei (például grpcio vagy protobuf) teljesen el vannak különítve a feldolgozó függőségeitől, így megelőzve a verzióütközéseket. Az alkalmazásbeállítás PYTHON_ISOLATE_WORKER_DEPENDENCIES nem lesz hatással a Python 3.13-on vagy újabb verziókon futó alkalmazásokra.
A feldolgozói bővítmények és a megosztott memóriafunkciók támogatása megszűnt.

Megfigyelhetőség és tesztelés

Ez a szakasz a logging, monitoring és tesztelési képességeket ismerteti, amelyek segítenek a problémák hibakeresésében, a teljesítmény nyomon követésében és a Python függvényalkalmazások megbízhatóságának biztosításában.

Naplózás és figyelés

Azure Functions egy gyökérnaplózót tesz elérhetővé, amelyet közvetlenül használhat a Python beépített logging moduljával. A naplózó használatával írt üzenetek automatikusan elküldésre kerülnek az Application Insights-hoz, amikor az alkalmazás az Azure-ban fut.

A naplózás lehetővé teszi a futtatókörnyezet adatainak rögzítését és a problémák diagnosztizálását anélkül, hogy további telepítésre van szükség.

Naplózási példa HTTP-eseményindítóval

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

Használhatja a naplózási szintek teljes készletét (debug, info, warning, error, critical), és ezek megjelennek a naplók vagy az Application Insights alatti Azure portálon.

A Azure Functions a portálon való figyeléséről a Monitor Azure Functions című témakörben talál további információt.

Feljegyzés

Az Application Insights hibakeresési naplóinak megtekintéséhez további beállításokra van szükség. Ezt a funkciót úgy engedélyezheti, hogy a PYTHON_ENABLE_DEBUG_LOGGING változót 1 értékre állítja, és a logLevel-t trace vagy debug-re állítja a host.json fájlban. Alapértelmezés szerint a hibakeresési naplók nem láthatók az Application Insightsban.

Naplózás háttérszálakból

Ha a függvény új szálat indít el, és erről a szálról kell bejelentkeznie, mindenképpen adja át az context argumentumot a szálnak. A context szál helyi tárolóját és az aktuálisat invocation_idtartalmazza, amelyet a munkavégző szálon kell beállítani ahhoz, hogy a naplók megfelelően legyenek társítva a függvény végrehajtásával.

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

Egyéni naplózók konfigurálása

Egyéni naplózókat akkor konfigurálhat Python, ha nagyobb mértékben kell szabályoznia a naplózási viselkedést, például egyéni formázást, naplószűrést vagy külső integrációkat. Egyéni naplózó konfigurálásához használja Python logging.getLogger() egyéni névvel, és szükség szerint adjon hozzá kezelőket vagy formázókat.

import logging

custom_logger = logging.getLogger('my_custom_logger')

OpenTelemetry-támogatás

A Python Azure Functions támogatja a OpenTelemetria is, amely lehetővé teszi nyomkövetések, metrikák és naplók szabványosított formátumban való kibocsátását. Az OpenTelemetria használata különösen hasznos elosztott alkalmazásokhoz vagy olyan forgatókönyvekhez, ahol telemetriát szeretne exportálni az Application Insightson kívüli eszközökre (például Grafana vagy Jaeger).

Tekintse meg az OpenTelemetry gyorsindítóját az Azure Functions (Python) szolgáltatáshoz a beállítási utasításokért és a mintakódért.

Egységtesztelés

Írjon és futtasson egységteszteket a függvényeihez a következő használatával pytest: Standard tesztelési keretrendszerek használatával tesztelheti Python függvényeket, például más Python kódot. A legtöbb kötés esetében létrehozhat egy példabemeneti objektumot úgy, hogy létrehoz egy megfelelő osztálypéldányt a azure.functions csomagból.

my_function Példaként a következő példa egy HTTP által aktivált függvény modelltesztje:

Először hozza létre a <project_root>/function_app.py fájlt, és implementálja a my_function függvényt HTTP-eseményindítóként.

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

Elkezdhet teszteseteket írni a HTTP-eseményindítóhoz.

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

A Python virtuális környezet mappájában az alábbi parancsokat futtathatja az alkalmazás teszteléséhez:

pip install pytest
pytest test_my_function.py

Az eredmények a pytest terminálban a következőképpen láthatók:

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

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

Optimalizálás és speciális témakörök

A Python függvényalkalmazások optimalizálásával kapcsolatos további információkért tekintse meg az alábbi cikkeket:

A Functions szolgáltatással kapcsolatos további információkért tekintse meg az alábbi cikkeket:

Problémákat tapasztal a Python használatával kapcsolatban? Tudassa velünk, és jelentse be a problémát.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-03-11

Megosztás a következőn keresztül:

Azure Functions fejlesztői referencia-útmutató Python-alkalmazásokhoz

Kezdő lépések

A függvényalkalmazás létrehozása

Programozási modell

Főbb fogalmak

A azure-functions könyvtár

Alternatív belépési pont

Mappastruktúra

Kulcsfájlok és mappák

Főbb fogalmak

A azure-functions könyvtár

Tervezés munkatervekkel

Mappastruktúra

Kulcsfájlok és mappák

Eseményindítók és kötések

Példa: Időzítő eseményindító blobbemenettel

Főbb fogalmak

Példa: HTTP-eseményindító Cosmos DB bemenettel és Event Hub kimenettel

Főbb fogalmak

SDK-típuskötések

Környezeti változók

Csomagkezelés

Megfontolások

Futtatás és üzembe helyezés

Helyi futtatás

Az Azure Functions Core Tools használata

A függvény közvetlen meghívása

Támogatott Python verziók

buildelés és üzembe helyezés

Python 3.13+-os frissítések

Megfigyelhetőség és tesztelés

Naplózás és figyelés

Naplózási példa HTTP-eseményindítóval

Naplózás háttérszálakból

Egyéni naplózók konfigurálása

OpenTelemetry-támogatás

Egységtesztelés

Optimalizálás és speciális témakörök

Kapcsolódó cikkek

Visszajelzés

További források

A `azure-functions` könyvtár

A `azure-functions` könyvtár