Megosztás:

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

Az 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 létrehozására összpontosít, és a következőkben nyújt segítséget:

  • 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
  • Alkalmazás üzembe helyezése és monitorozása az Azure-ban
  • Ajánlott eljárások alkalmazása a skálázáshoz és a teljesítményhez

Fogalmi áttekintést keres? Tekintse meg az Azure Functions fejlesztői referenciaanyagá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 munkafolyamatnak megfelelő környezetet, és ugorjon az Azure Functions for Pythonra:

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 a Python-kódfájlban definiálhat triggereket és kötéseket. 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ó ú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. Mindegyik függvényt 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.

A Python v1 programozási modellben minden függvény globális, állapot nélküli main() metódusként van definiálva egy nevű __init__.pyfá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 az Azure Functions-futtatókörnyezettel való interakcióhoz használt alapvető típusokat biztosítja. 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 meghatározza a Python Azure Functions programozási felületét, de nem általános célú SDK. Kifejezetten az 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 arra utasítja a futtatókörnyezetet, hogy a custom_entry() fájlban lévő main.py metódust használja az 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-ban 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 A közzététel során telepített Python-függőségek távoli buildeléskor. ❌ (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 Pythonhoz (ki van zárva az üzembe helyezésből). ❌
.vscode/ Szerkesztőkonfiguráció a Visual Studio Code-hoz. 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-ban. ❌
Dockerfile Egyéni tárolót határoz meg az üzembe helyezéshez. ❌

A Python v2 programozási modellben az Azure Functions dekorátoralapú megközelítést használ az eseményindítók és kötések közvetlen definiálásához 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 az 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

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

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

  1. Terv definiálá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!")

  2. 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 a tervek használatát is támogatja a azure-functions-durable alkalmazásával. 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-ban való futtatásához szükséges
function_app.py Fő szkript, amelyben az Azure Functions és az eseményindítók dekorátorok használatával vannak definiálva. ✅
host.json Az alkalmazás összes függvényének globális konfigurációja. ✅
requirements.txt A közzététel során telepített Python-függőségek távoli buildeléskor. ❌ (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 Pythonhoz (ki van zárva az üzembe helyezésből). ❌
.vscode/ Szerkesztőkonfiguráció a Visual Studio Code-hoz. 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-ban. ❌
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

Az Azure Functions eseményindítókkal indítja el a függvények végrehajtását, és kötésekkel 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 dekorátorokkal deklarálhatja a kötéseket.

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ő triggerekről és kötésekről további információt az Azure Functions eseményindítói és kötései című témakörben talál.

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 SDK-k é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 támogatása csak a Python v2 programozási modellben érhető el.

Környezeti változók

Az Azure Functions környezeti változói lehetővé teszik a konfigurációs értékek, kapcsolati sztringek és alkalmazástitkok biztonságos kezelését anélkül, hogy a függvénykódban rögzítették őket.

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

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

Az Azure Functions felismeri a Functions-futtatókörnyezetet és a Python-feldolgozó viselkedését konfiguráló rendszerkörnyezeti változókat is. 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 az Azure Functions-alkalmazásban, listázhatja őket a requirements.txt projekt gyökerében található fájlban. Ezeket a csomagokat a Python importáló rendszere importálja, majd a szokásos módon hivatkozhat ezekre a csomagokra. A külső függőségekkel rendelkező létrehozási és üzembehelyezési lehetőségekről további információt a Python-függvényalkalmazások buildelési beállításai című témakörben talál.

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 projekt könyvtárak elnevezését a Python standard könyvtárak (például email/, json/) után.
    • Ne foglalja bele a Python natív kódtárait (például logging, asynciovagy uuid) a fájlba requirements.txt.
  • 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ón, hogy elkerülje a függőségi ütközéseket a korábban létrehozott csomagokkal.
  • Nem PyPI-függőségek:
  • Az Azure Functions Python feldolgozói függőségei:

Futtatás és üzembe helyezés

Ez a szakasz a függvények helyi futtatásáról, a Python-verzió támogatásáról, a buildelési és üzembehelyezési lehetőségekről, valamint 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örnyezetben is.

Helyi futtatás

Az Azure-ban való üzembe helyezés előtt futtathatja és tesztelheti a Python-függvényalkalmazást a helyi gépen.

Az Azure Functions Core Tools használata

Telepítse az Azure Functions Core Toolst , és indítsa el a helyi futtatókörnyezetet a func start projektgyökér parancsának futtatásával:

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

A Core Tools használatáról további információt az Azure Functions helyi fejlesztése a Core Tools használatával című témakörben talál.

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

A használatával azure-functions >= 1.21.0kö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 Pythonnal:

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

> 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

Az Azure Functions támogatja az Azure Functions támogatott nyelveiben felsorolt Python-verziókat. További általános információkért tekintse meg az Azure Functions futtatókörnyezet támogatási szabályzatát.

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 Python-verzió módosításakor a meglévő üzembehelyezési összetevők és függőségek nem lesznek automatikusan újraépülve.

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éhez tekintse meg az Azure Functions üzembehelyezési technológiáit.

Ü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) Parancskatalógus → "Azure Functions: Üzembe helyezés az Azure-ban..." 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 GitHub-alapú CI/CD-hez ideális. Lehetővé teszi az automatizált üzembe helyezéseket push vagy Pull Request egyesítéseknél.
Azure Pipelines AzureFunctionApp@2 Feladat Nagyvállalati CI/CD az 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 az Azure Portalon → 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. Nem telepíthet és nem hivatkozhat csomagra a beépített Python standard kódtáron kívül azure-functions .

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. Ez a változás nem érinti a Windows rendszeren futó alkalmazásokat a használatalapú csomagban.

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+ frissítések

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

  • Futtatókörnyezeti verziókövetés: Mostantól tetszés szerint rögzítheti vagy frissítheti az alkalmazást adott Python-munkavállaló verziókra a azure-functions-runtime csomagra requirements.txt hivatkozva.

    • 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 a legújabb kiadott verziót, egy előre kiadott verziót igényelje, vagy hogy rögzítse az alkalmazást a Python-futtatókörnyezet egy adott verziójára.

    • A futtatókörnyezet verziókövetését úgy engedélyezheti, hogy hozzáad egy hivatkozást a Python-futtatókörnyezet-csomaghoz a requirements.txt fájlhoz, 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.

    • A változások megismerése érdekében rendszeresen tekintse át 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+ 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+ 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-runtimePython 3.13+-alkalmazást, a Python-futtatókörnyezet egy alapértelmezett verzióján fut, amely a legújabb kiadott verzió mögött található. 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óban 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 tetszés szerint rögzítheti vagy frissítheti az alkalmazást adott Python-munkavállaló verziókra a azure-functions-runtime-v1 csomagra requirements.txt hivatkozva.

    • 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 a legújabb kiadott verziót, egy előre kiadott verziót igényelje, vagy hogy rögzítse az alkalmazást a Python-futtatókörnyezet egy adott verziójára.

    • A futtatókörnyezet verziókövetését úgy engedélyezheti, hogy hozzáad egy hivatkozást a Python-futtatókörnyezet-csomaghoz a requirements.txt fájlhoz, 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.

    • A változások megismerése érdekében rendszeresen tekintse át 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+ 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+ 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-v1Python 3.13+-alkalmazást, a Python-futtatókörnyezet egy alapértelmezett verzióján fut, amely a legújabb kiadott verzió mögött található. 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óban 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 naplózási, monitorozási és tesztelési képességeket ismerteti, amelyek segítenek a problémák elhárításában, 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

Az Azure Functions egy gyökérnaplózót tesz elérhetővé, amelyet közvetlenül a Python beépített logging moduljával használhat. Az ezzel a naplózóval írt üzeneteket a rendszer automatikusan elküldi az Application Insightsnak , 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, warningerror, ), criticalés azok megjelennek az Azure Portalon a Naplók vagy az Application Insights alatt.

Az Azure Functions portálon való monitorozásáról további információt az Azure Functions monitorozása című témakörben talál.

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 a Pythonban, 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ót. Egyéni naplózó konfigurálásához használja a Pythont logging.getLogger() egy 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 Pythonhoz készült Azure Functions támogatja az OpenTelemetria használatát is, amely lehetővé teszi nyomkövetések, metrikák és naplók szabványosított formátumban történő 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).

A beállítási utasításokért és a mintakódért tekintse meg az Azure Functions (Python) OpenTelemetry rövid útmutatóját .

Egységtesztelés

Írjon és futtasson egységteszteket a függvényeihez a következő használatával pytest: A Python-függvényeket a többi Python-kódhoz hasonlóan szabványos tesztelési keretrendszerek használatával tesztelheti. 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 futtatva tesztelheti az alkalmazást:

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.

  • Last updated on