Azure Functions-útmutató Python-fejlesztőknek

Cikk
11/14/2023

Ez az útmutató az Azure Functions Python használatával történő fejlesztésének bemutatása. A cikk feltételezi, hogy már elolvasta az Azure Functions fejlesztői útmutatóját.

Fontos

Ez a cikk a Python 1- és 2-s verziós programozási modelljét is támogatja az Azure Functionsben. A Python v1-modell egy functions.json-fájlt használ a függvények definiálásához, az új v2-modell pedig dekorátoralapú megközelítést használ. Ez az új megközelítés egyszerűbb fájlstruktúrát eredményez, és kódközpontúbb. Az új programozási modell megismeréséhez válassza a cikk tetején található v2-választót.

Python-fejlesztőként az alábbi cikkek valamelyike is érdekelheti:

Első lépések	Fogalmak	Forgatókönyvek és minták
Python-függvények létrehozása a Visual Studio Code használatával Python-függvények létrehozása terminál vagy parancssor használatával	Fejlesztői útmutató Üzemeltetési lehetőségek Teljesítménnyel kapcsolatos szempontok	Képbesorolás a PyTorch használatával Azure Automation-minta Gépi tanulás a TensorFlow használatával Python-minták tallózása

Első lépések	Fogalmak	Példák
Python-függvények létrehozása a Visual Studio Code használatával Python-függvények létrehozása terminál vagy parancssor használatával	Fejlesztői útmutató Üzemeltetési lehetőségek Teljesítménnyel kapcsolatos szempontok	Példakódok

Fejlesztési lehetőségek

Mindkét Python Functions-programozási modell támogatja a helyi fejlesztést az alábbi környezetek egyikében:

Python v2 programozási modell:

Vegye figyelembe, hogy a Python v2 programozási modell csak a 4.x függvények futtatókörnyezetében támogatott. További információkért tekintse meg az Azure Functions futtatókörnyezeti verzióinak áttekintését.

Python v1 programozási modell:

Python v1-függvényeket is létrehozhat az Azure Portalon.

Tipp.

Bár a Python-alapú Azure-függvényeket helyileg fejlesztheti Windows rendszeren, a Python csak Linux-alapú üzemeltetési csomagban támogatott, amikor az Azure-ban fut. További információkért tekintse meg a támogatott operációs rendszerek/futtatókörnyezet-kombinációk listáját.

Programozási modell

Az Azure Functions azt várja, hogy egy függvény állapot nélküli metódus legyen a Python-szkriptben, amely feldolgozza a bemenetet, és kimenetet állít elő. Alapértelmezés szerint a futtatókörnyezet azt várja, hogy a metódus globális metódusként main() legyen implementálva a __init__.py fájlban. Másik belépési pontot is megadhat.

Az function.json fájlban definiált tulajdonságot használó name metódusattribútumokon keresztül köthet adatokat a függvényhez triggerekből és kötésekből. Az alábbi function.json fájl például egy egyszerű függvényt ír le, amelyet egy HTTP-kérés reqaktivál:

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

A definíció alapján a függvénykódot tartalmazó __init__.py fájl a következő példához hasonlóan nézhet ki:

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

Az attribútumtípusok explicit deklarálhatók és visszaadhatók a függvényben Python-típusú széljegyzetek használatával. Ezzel segít a számos Python-kódszerkesztő által biztosított IntelliSense és automatikus kiegészítési funkciók használatában.

import azure.functions

def main(req: azure.functions.HttpRequest) -> str:
    user = req.params.get('user')
    return f'Hello, {user}!'

Az azure.functions.* csomagban található Python-széljegyzetekkel kötheti a bemenetet és a kimeneteket a metódusokhoz.

Az Azure Functions azt várja, hogy egy függvény állapot nélküli metódus legyen a Python-szkriptben, amely feldolgozza a bemenetet, és kimenetet állít elő. Alapértelmezés szerint a futtatókörnyezet elvárja, hogy a metódus globális metódusként legyen implementálva a function_app.py fájlban.

Az eseményindítók és kötések deklarálhatók és használhatók egy dekorátoralapú függvényben. Ezek ugyanabban a fájlban vannak definiálva, function_app.py, mint a függvények. A következő function_app.py fájl például egy HTTP-kérés által aktivált függvényt jelöl.

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req):
    user = req.params.get("user")
    return f"Hello, {user}!"

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req: func.HttpRequest) -> str:
    user = req.params.get("user")
    return f"Hello, {user}!"

A v2-modell ismert korlátairól és kerülő megoldásairól az Azure Functions Python-hibáinak hibaelhárítása című témakörben olvashat.

Alternatív belépési pont

A függvények alapértelmezett viselkedését módosíthatja a function.json fájlban található tulajdonságok és entryPoint tulajdonságok opcionális megadásávalscriptFile. Az alábbi function.json például arra utasítja a futtatókörnyezetet, hogy a customentry() metódust a main.py fájlban használja az Azure-függvény belépési pontjaként.

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

A belépési pont csak a function_app.py fájlban található. A projekten belüli függvényekre azonban tervekkel vagy importálással hivatkozhat a function_app.py.

Mappastruktúra

Egy Python-függvényprojekt ajánlott mappastruktúrája a következő példához hasonlóan néz ki:

 <project_root>/
 | - .venv/
 | - .vscode/
 | - my_first_function/
 | | - __init__.py
 | | - function.json
 | | - example.py
 | - my_second_function/
 | | - __init__.py
 | | - function.json
 | - shared_code/
 | | - __init__.py
 | | - my_first_helper_function.py
 | | - my_second_helper_function.py
 | - tests/
 | | - test_my_second_function.py
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - requirements.txt
 | - Dockerfile

A fő projektmappa ( <project_root>) a következő fájlokat tartalmazhatja:

local.settings.json: Alkalmazásbeállítások és kapcsolati sztring tárolása helyi futtatáskor. Ez a fájl nem lesz közzétéve az Azure-ban. További információ: local.settings.file.
requirements.txt: A rendszer által az Azure-ban való közzétételkor telepített Python-csomagok listáját tartalmazza.
host.json: Olyan konfigurációs beállításokat tartalmaz, amelyek egy függvényalkalmazás-példány összes függvényét érintik. Ez a fájl megjelenik az Azure-ban. Helyi futtatáskor nem minden beállítás támogatott. További információ: host.json.
.vscode/: (Nem kötelező) A tárolt Visual Studio Code-konfigurációt tartalmazza. További információ: Visual Studio Code-beállítások.
.venv/: (Nem kötelező) A helyi fejlesztés által használt Python virtuális környezetet tartalmaz.
Dockerfile: (Nem kötelező) A projekt egyéni tárolóban való közzétételekor használatos.
tesztek/: (Nem kötelező) A függvényalkalmazás teszteseteit tartalmazza.
.funcignore: (Nem kötelező) Deklarálja azokat a fájlokat, amelyeket nem szabad közzétenni az Azure-ban. Ez a fájl általában .vscode/-t tartalmaz, amely figyelmen kívül hagyja a szerkesztőbeállítást, a .venv/ parancsot a helyi Python virtuális környezet figyelmen kívül hagyásához, a teszteseteket és a local.settings.json a helyi alkalmazásbeállítások közzétételének megakadályozásához.

Minden függvény saját kódfájllal és kötéskonfigurációs fájllal rendelkezik, function.json.

Egy Python-függvényprojekt ajánlott mappastruktúrája a következő példához hasonlóan néz ki:

 <project_root>/
 | - .venv/
 | - .vscode/
 | - function_app.py
 | - additional_functions.py
 | - tests/
 | | - test_my_function.py
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - requirements.txt
 | - Dockerfile

A fő projektmappa ( <project_root>) a következő fájlokat tartalmazhatja:

.venv/: (Nem kötelező) Olyan Python virtuális környezetet tartalmaz, amelyet a helyi fejlesztés használ.
.vscode/: (Nem kötelező) A tárolt Visual Studio Code-konfigurációt tartalmazza. További információ: Visual Studio Code-beállítások.
function_app.py: Az összes függvény és azok kapcsolódó eseményindítóinak és kötéseinek alapértelmezett helye.
additional_functions.py: (Nem kötelező) Minden más Python-fájl, amely függvényeket (általában logikai csoportosításhoz) tartalmaz, amelyek tervekkel hivatkoznak function_app.py.
tesztek/: (Nem kötelező) A függvényalkalmazás teszteseteit tartalmazza.
.funcignore: (Nem kötelező) Deklarálja azokat a fájlokat, amelyeket nem szabad közzétenni az Azure-ban. Ez a fájl általában .vscode/-t tartalmaz, amely figyelmen kívül hagyja a szerkesztőbeállítást, a .venv/ parancsot a helyi Python virtuális környezet figyelmen kívül hagyásához, a tesztelési esetek figyelmen kívül hagyásához, és local.settings.json a helyi alkalmazásbeállítások közzétételének megakadályozásához.
host.json: Olyan konfigurációs beállításokat tartalmaz, amelyek egy függvényalkalmazás-példány összes függvényét érintik. Ez a fájl megjelenik az Azure-ban. Helyi futtatáskor nem minden beállítás támogatott. További információ: host.json.
local.settings.json: Alkalmazásbeállítások és kapcsolati sztring tárolására szolgál, ha helyileg fut. Ez a fájl nem lesz közzétéve az Azure-ban. További információ: local.settings.file.
requirements.txt: A rendszer által az Azure-ban való közzétételkor telepített Python-csomagok listáját tartalmazza.
Dockerfile: (Nem kötelező) A projekt egyéni tárolóban való közzétételekor használatos.

Amikor üzembe helyezi a projektet egy függvényalkalmazásban az Azure-ban, a fő projektmappa teljes tartalmát ( <project_root>) a csomagban kell tartalmaznia, magát a mappát azonban nem, ami azt jelenti, hogy host.json a csomag gyökerében kell lennie. Javasoljuk, hogy a teszteket egy mappában tartsa karban más függvényekkel együtt (ebben a példában a tesztek/). További információ: Egységtesztelés.

Kapcsolódás adatbázishoz

Az Azure Functions számos használati esetben jól integrálható az Azure Cosmos DB-vel, beleértve az IoT-t, az e-kereskedelmet, a játékokat stb.

Az eseményforráshoz például a két szolgáltatás az Azure Cosmos DB változáscsatorna funkciójával integrálva van az eseményvezérelt architektúrákba. A változáscsatorna lehetővé teszi az alsóbb rétegbeli mikroszolgáltatások számára a beszúrások és frissítések megbízható és növekményes olvasását (például rendelési eseményeket). Ez a funkció felhasználható egy állandó eseménytár üzenetközvetítőként az állapotmódosítási eseményekhez és a rendelésfeldolgozási munkafolyamat számos mikroszolgáltatás között (amely kiszolgáló nélküli Azure Functionsként implementálható).

Azure Cosmos DB rendelési folyamat referenciaarchitektúrája

A Cosmos DB-hez való csatlakozáshoz először hozzon létre egy fiókot, adatbázist és tárolót. Ezután triggerek és kötések használatával csatlakoztathatja a Functionst a Cosmos DB-hez, például ebben a példában.

Összetettebb alkalmazáslogika implementálásához használhatja a Cosmos DB Python-kódtárát is. Az aynchronous I/O-implementáció a következőképpen néz ki:

pip install azure-cosmos
pip install aiohttp

from azure.cosmos.aio import CosmosClient
from azure.cosmos import exceptions
from azure.cosmos.partition_key import PartitionKey
import asyncio

# Replace these values with your Cosmos DB connection information
endpoint = "https://azure-cosmos-nosql.documents.azure.com:443/"
key = "master_key"
database_id = "cosmicwerx"
container_id = "cosmicontainer"
partition_key = "/partition_key"

# Set the total throughput (RU/s) for the database and container
database_throughput = 1000

# Singleton CosmosClient instance
client = CosmosClient(endpoint, credential=key)

# Helper function to get or create database and container
async def get_or_create_container(client, database_id, container_id, partition_key):
    database = await client.create_database_if_not_exists(id=database_id)
    print(f'Database "{database_id}" created or retrieved successfully.')

    container = await database.create_container_if_not_exists(id=container_id, partition_key=PartitionKey(path=partition_key))
    print(f'Container with id "{container_id}" created')
 
    return container
 
async def create_products():
    container = await get_or_create_container(client, database_id, container_id, partition_key)
    for i in range(10):
        await container.upsert_item({
            'id': f'item{i}',
            'productName': 'Widget',
            'productModel': f'Model {i}'
        })
 
async def get_products():
    items = []
    container = await get_or_create_container(client, database_id, container_id, partition_key)
    async for item in container.read_all_items():
        items.append(item)
    return items

async def query_products(product_name):
    container = await get_or_create_container(client, database_id, container_id, partition_key)
    query = f"SELECT * FROM c WHERE c.productName = '{product_name}'"
    items = []
    async for item in container.query_items(query=query, enable_cross_partition_query=True):
        items.append(item)
    return items

async def main():
    await create_products()
    all_products = await get_products()
    print('All Products:', all_products)

    queried_products = await query_products('Widget')
    print('Queried Products:', queried_products)

if __name__ == "__main__":
    asyncio.run(main())

Blueprints

A Python v2 programozási modell bemutatja a tervek fogalmát. A terv egy új osztály, amely példányosítva regisztrálja a függvényeket az alapfüggvényalkalmazáson kívül. A tervpéldányokban regisztrált függvényeket nem indexeli közvetlenül a függvény futtatókörnyezete. A tervfüggvények indexeléséhez a függvényalkalmazásnak regisztrálnia kell a függvényeket a tervpéldányokból.

A tervek használata a következő előnyöket nyújtja:

Lehetővé teszi, hogy a függvényalkalmazást moduláris összetevőkre bontsa, így több Python-fájlban definiálhat függvényeket, és fájlonként különböző összetevőkre oszthatja őket.
Bővíthető nyilvános függvényalkalmazás-felületeket biztosít saját API-k létrehozásához és újrafelhasználásához.

Az alábbi példa a tervek használatát mutatja be:

Először egy http_blueprint.py fájlban először egy HTTP-aktivált függvény lesz definiálva, és hozzáadódik egy tervobjektumhoz.

import logging 

import azure.functions as func 

bp = func.Blueprint() 

@bp.route(route="default_template") 
def default_template(req: func.HttpRequest) -> func.HttpResponse: 
    logging.info('Python HTTP trigger function processed a request.') 

    name = req.params.get('name') 
    if not name: 
        try: 
            req_body = req.get_json() 
        except ValueError: 
            pass 
        else: 
            name = req_body.get('name') 

    if name: 
        return func.HttpResponse( 
            f"Hello, {name}. This HTTP-triggered function " 
            f"executed successfully.") 
    else: 
        return func.HttpResponse( 
            "This HTTP-triggered function executed successfully. " 
            "Pass a name in the query string or in the request body for a" 
            " personalized response.", 
            status_code=200 
        )

Ezután a function_app.py fájlban importálja a tervobjektumot, és a függvények regisztrálva lesznek a függvényalkalmazásban.

import azure.functions as func 
from http_blueprint import bp

app = func.FunctionApp() 

app.register_functions(bp)

Feljegyzés

A Durable Functions a terveket is támogatja. A Durable Functions-alkalmazások tervrajzainak létrehozásához regisztrálja vezénylési, tevékenységi és entitás-eseményindítóit és ügyfélkötéseit az azure-functions-durableBlueprint osztály használatával, az itt látható módon. Az eredményként kapott terv ezután a szokásos módon regisztrálható. Tekintse meg a mintánk egy példáját.

Importálási viselkedés

A függvénykódban lévő modulokat abszolút és relatív hivatkozások használatával is importálhatja. A korábban ismertetett mappastruktúra alapján a következő importálások működnek a project_root\my_first_function\__init__.py függvényfájlból<:>

from shared_code import my_first_helper_function #(absolute)

import shared_code.my_second_helper_function #(absolute)

from . import example #(relative)

Feljegyzés

Abszolút importálási szintaxis használatakor a shared_code/ mappának tartalmaznia kell egy __init__.py fájlt, hogy Python-csomagként jelölje meg.

A következő __app__ importálás és a felső szintű relatív importáláson túl elavult, mert a statikus típus-ellenőrző nem támogatja őket, és a Python-tesztkörnyezetek nem támogatják őket:

from __app__.shared_code import my_first_helper_function #(deprecated __app__ import)

from ..shared_code import my_first_helper_function #(deprecated beyond top-level relative import)

Triggerek és bemenetek

A bemenetek két kategóriába sorolhatók az Azure Functionsben: trigger bemenet és egyéb bemenetek. Bár a function.json fájlban eltérnek, a használatuk azonos a Python-kódban. Csatlakozás trigger- és bemeneti források sztringjei vagy titkos kódjai a local.settings.json fájl értékeire vannak leképezve, amikor helyileg futnak, és az Azure-ban való futtatáskor az alkalmazásbeállításokhoz vannak megfeleltetve.

A következő kód például a két bemenet közötti különbséget mutatja be:

// function.json
{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous",
      "route": "items/{id}"
    },
    {
      "name": "obj",
      "direction": "in",
      "type": "blob",
      "path": "samples/{id}",
      "connection": "STORAGE_CONNECTION_STRING"
    }
  ]
}

// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "STORAGE_CONNECTION_STRING": "<AZURE_STORAGE_CONNECTION_STRING>",
    "AzureWebJobsStorage": "<azure-storage-connection-string>"
  }
}

# __init__.py
import azure.functions as func
import logging

def main(req: func.HttpRequest, obj: func.InputStream):
    logging.info(f'Python HTTP-triggered function processed: {obj.read()}')

A függvény meghívásakor a HTTP-kérést a függvény a következőképpen továbbítja a függvénynek req. A rendszer egy bejegyzést kér le az Azure Blob Storage-fiókból az útvonal URL-címében szereplő azonosító alapján, és a függvény törzsének megfelelően obj elérhetővé válik. Itt a megadott tárfiók az alkalmazásbeállításban CONNECTION_STRING található kapcsolati sztring.

A bemenetek két kategóriába sorolhatók az Azure Functionsben: trigger bemenet és egyéb bemenetek. Bár különböző dekorátorokkal vannak definiálva, a használatuk hasonló a Python-kódban. Csatlakozás trigger- és bemeneti források sztringjei vagy titkos kódjai a local.settings.json fájl értékeire vannak leképezve, amikor helyileg futnak, és az Azure-ban való futtatáskor az alkalmazásbeállításokhoz vannak megfeleltetve.

A következő kód például bemutatja, hogyan definiálhat egy Blob Storage bemeneti kötést:

// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "STORAGE_CONNECTION_STRING": "<AZURE_STORAGE_CONNECTION_STRING>",
    "AzureWebJobsStorage": "<azure-storage-connection-string>",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing"
  }
}

# function_app.py
import azure.functions as func
import logging

app = func.FunctionApp()

@app.route(route="req")
@app.read_blob(arg_name="obj", path="samples/{id}", 
               connection="STORAGE_CONNECTION_STRING")
def main(req: func.HttpRequest, obj: func.InputStream):
    logging.info(f'Python HTTP-triggered function processed: {obj.read()}')

Az adatigényes kötési műveletekhez érdemes lehet külön tárfiókot használni. További információ: Tárfiókok útmutatója.

Kimenetek

A kimenet a visszatérési értékben és a kimeneti paraméterekben is kifejezhető. Ha csak egy kimenet van, javasoljuk a visszatérési érték használatát. Több kimenet esetén kimeneti paramétereket kell használnia.

Ha egy függvény visszatérési értékét kimeneti kötés értékeként szeretné használni, a name kötés tulajdonságát a function.json fájlban kell beállítani$return.

Több kimenet létrehozásához használja az set() interfész által azure.functions.Out biztosított metódust egy érték kötéshez való hozzárendeléséhez. Az alábbi függvény például leküldhet egy üzenetet egy üzenetsorba, és HTTP-választ is küldhet.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "msg",
      "direction": "out",
      "type": "queue",
      "queueName": "outqueue",
      "connection": "STORAGE_CONNECTION_STRING"
    },
    {
      "name": "$return",
      "direction": "out",
      "type": "http"
    }
  ]
}

import azure.functions as func

def main(req: func.HttpRequest,
         msg: func.Out[func.QueueMessage]) -> str:

    message = req.params.get('body')
    msg.set(message)
    return message

# function_app.py
import azure.functions as func

app = func.FunctionApp()

@app.write_blob(arg_name="msg", path="output-container/{name}",
                connection="CONNECTION_STRING")
def test_function(req: func.HttpRequest,
                  msg: func.Out[str]) -> str:

    message = req.params.get('body')
    msg.set(message)
    return message

Naplózás

Az Azure Functions futtatókörnyezet-naplózójához való hozzáférés a függvényalkalmazás gyökérkezelőjével logging érhető el. Ez a naplózó az Alkalmazás Elemzések van kötve, és lehetővé teszi a függvény végrehajtása során előforduló figyelmeztetések és hibák megjelölését.

Az alábbi példa egy információs üzenetet naplóz, amikor a függvényt HTTP-eseményindítón keresztül hívják meg.

import logging

def main(req):
    logging.info('Python HTTP trigger function processed a request.')

További naplózási módszerek állnak rendelkezésre, amelyekkel különböző nyomkövetési szinteken írhat a konzolra:

Metódus	Leírás
`critical(_message_)`	Kritikus szintű üzenetet ír a gyökérnaplózón.
`error(_message_)`	Olyan üzenetet ír, amely hibaszinttel rendelkezik a gyökérnaplózón.
`warning(_message_)`	Figyelmeztetés szintű üzenetet ír a gyökérnaplózóra.
`info(_message_)`	Olyan üzenetet ír, amely a legfelső szintű naplózón található információszinttel rendelkezik.
`debug(_message_)`	Egy debug szintű üzenetet ír a gyökérnaplózón.

A naplózásról további információt az Azure Functions monitorozása című témakörben talál.

Naplózás létrehozott szálakból

A létrehozott szálakból származó naplók megtekintéséhez adja meg az context argumentumot a függvény aláírásában. Ez az argumentum egy helyi invocation_idattribútumot thread_local_storage tartalmaz. Ez a függvény aktuális invocation_id értékére állítható be a környezet módosításának biztosítása érdekében.

import azure.functions as func
import logging
import threading


def main(req, context):
    logging.info('Python HTTP trigger function processed a request.')
    t = threading.Thread(target=log_function, args=(context,))
    t.start()


def log_function(context):
    context.thread_local_storage.invocation_id = context.invocation_id
    logging.info('Logging from thread.')

Egyéni telemetriai adatok naplózása

Alapértelmezés szerint a Functions-futtatókörnyezet naplókat és egyéb telemetriai adatokat gyűjt, amelyeket a függvények hoznak létre. Ez a telemetria nyomkövetésként végződik az Application Elemzések-ban. Az egyes Azure-szolgáltatások kérési és függőségi telemetriáját alapértelmezés szerint az eseményindítók és kötések is gyűjtik.

Az OpenCensus Python-bővítmények használatával egyéni kéréseket és egyéni függőségi telemetriát gyűjthet a kötéseken kívül. Ez a bővítmény egyéni telemetriai adatokat küld az alkalmazás Elemzések-példánynak. A támogatott bővítmények listáját az OpenCensus-adattárban találja.

Feljegyzés

Az OpenCensus Python-bővítmények használatához engedélyeznie kell a Python feldolgozóbővítményeket a függvényalkalmazásban a következő beállítással PYTHON_ENABLE_WORKER_EXTENSIONS1: . Az Alkalmazás Elemzések kapcsolati sztring használatára is át kell váltania, ha hozzáadja a beállítást az APPLICATIONINSIGHTS_CONNECTION_STRINGalkalmazásbeállításokhoz, ha még nincs ott.

// requirements.txt
...
opencensus-extension-azure-functions
opencensus-ext-requests

import json
import logging

import requests
from opencensus.extension.azure.functions import OpenCensusExtension
from opencensus.trace import config_integration

config_integration.trace_integrations(['requests'])

OpenCensusExtension.configure()

def main(req, context):
    logging.info('Executing HttpTrigger with OpenCensus extension')

    # You must use context.tracer to create spans
    with context.tracer.span("parent"):
        response = requests.get(url='http://example.com')

    return json.dumps({
        'method': req.method,
        'response': response.status_code,
        'ctx_func_name': context.function_name,
        'ctx_func_dir': context.function_directory,
        'ctx_invocation_id': context.invocation_id,
        'ctx_trace_context_Traceparent': context.trace_context.Traceparent,
        'ctx_trace_context_Tracestate': context.trace_context.Tracestate,
        'ctx_retry_context_RetryCount': context.retry_context.retry_count,
        'ctx_retry_context_MaxRetryCount': context.retry_context.max_retry_count,
    })

HTTP-eseményindító

A HTTP-eseményindító a function.json fájlban van definiálva. A name kötésnek meg kell egyeznie a függvény elnevezett paraméterével. Az előző példákban egy kötésnevet req használunk. Ez a paraméter egy HttpRequest objektum, és a függvény egy HttpResponse objektumot ad vissza.

A HttpRequest objektumból lekérheti a kérésfejléceket, a lekérdezési paramétereket, az útvonalparamétereket és az üzenet törzsét.

Az alábbi példa a Python HTTP-triggersablonjából származik.

def main(req: func.HttpRequest) -> func.HttpResponse:
    headers = {"my-http-header": "some-value"}

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        return func.HttpResponse(f"Hello {name}!", headers=headers)
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             headers=headers, status_code=400
        )

Ebben a függvényben a name lekérdezési paraméter értékét a params HttpRequest objektum paraméteréből szerzi be. A JSON-kódolt üzenettörzset a get_json metódus használatával olvassa el.

Hasonlóképpen beállíthatja a status_code válaszüzenetet és headers a válaszüzenetet a visszaadott HttpResponse objektumban.

A HTTP-eseményindító egy metódus, amely egy elnevezett kötési paramétert vesz fel, amely egy HttpRequest objektum, és egy HttpResponse objektumot ad vissza. A függvénynév meghatározásához alkalmazza a function_name dekoratőrt a metódusra, a HTTP-végpont pedig a route dekorátor alkalmazásával van beállítva.

Ez a példa a Python v2 programozási modell HTTP-triggersablonjából származik, ahol a kötési paraméter neve .req Ez a mintakód, amelyet a függvények Azure Functions Core Tools vagy Visual Studio Code használatával történő létrehozásakor ad meg.

@app.function_name(name="HttpTrigger1")
@app.route(route="hello")
def test_function(req: func.HttpRequest) -> func.HttpResponse:
     logging.info('Python HTTP trigger function processed a request.')

     name = req.params.get('name')
     if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

     if name:
        return func.HttpResponse(f"Hello, {name}. This HTTP-triggered function executed successfully.")
     else:
        return func.HttpResponse(
             "This HTTP-triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
             status_code=200
        )

A HttpRequest objektumból lekérheti a kérésfejléceket, a lekérdezési paramétereket, az útvonalparamétereket és az üzenet törzsét. Ebben a függvényben a name lekérdezési paraméter értékét a params HttpRequest objektum paraméteréből szerzi be. A JSON-kódolt üzenettörzset a get_json metódus használatával olvassa el.

Hasonlóképpen beállíthatja a status_code válaszüzenetet és headers a válaszüzenetet a visszaadott HttpResponse objektumban.

Ha egy nevet szeretne megadni ebben a példában, illessze be a függvény futtatásakor megadott URL-címet, majd fűzze hozzá "?name={name}".

Webes keretrendszerek

A Web Server Gateway Interface (WSGI)-kompatibilis és aszinkron kiszolgálóátjáró-adapterrel (ASGI) kompatibilis keretrendszereket, például a Flaskot és a FastAPI-t a HTTP által aktivált Python-függvényekkel használhatja. Ez a szakasz bemutatja, hogyan módosíthatja a függvényeket a keretrendszerek támogatásához.

Először is frissíteni kell a function.json fájlt, hogy belefoglaljon a route HTTP-eseményindítóba, ahogy az alábbi példában látható:

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

A host.json fájlt is frissíteni kell, hogy tartalmazzon EGY HTTP-t routePrefix, ahogy az a következő példában is látható:

{
  "version": "2.0",
  "logging": 
  {
    "applicationInsights": 
    {
      "samplingSettings": 
      {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": 
  {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[3.*, 4.0.0)"
  },
  "extensions": 
  {
    "http": 
    {
        "routePrefix": ""
    }
  }
}

Frissítse a Python-kódfájlt init.py a keretrendszer által használt felülettől függően. Az alábbi példa egy ASGI kezelő megközelítést vagy a Flask WSGI burkoló megközelítését mutatja be:

ASGI
WSGI

app = fastapi.FastAPI()

@app.get("hello/{name}")
async def get_name(name: str):
  return {"name": name}

def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
    return func.AsgiMiddleware(app).handle(req, context)

app = Flask("Test")

@app.route("hello/<name>", methods=["GET"])
def hello(name: str):
    return f"hello {name}"

def main(req: func.HttpRequest, context) -> func.HttpResponse:
  logging.info("Python HTTP trigger function processed a request.")
  return func.WsgiMiddleware(app).handle(req, context)

Teljes példáért lásd a Flask Framework használata az Azure Functions használatával című témakört.

Az Aszinkron kiszolgálóátjáró-adapter (ASGI)-kompatibilis és webkiszolgálói átjárófelülettel (WSGI) kompatibilis keretrendszereket, például a Flaskot és a FastAPI-t a HTTP által aktivált Python-függvényekkel használhatja. Először frissítenie kell a host.json fájlt, hogy egy HTTP-t routePrefixtartalmazzon, ahogy az alábbi példában látható:

{
  "version": "2.0",
  "logging": 
  {
    "applicationInsights": 
    {
      "samplingSettings": 
      {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": 
  {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[2.*, 3.0.0)"
  },
  "extensions": 
  {
    "http": 
    {
        "routePrefix": ""
    }
  }
}

A keretrendszer kódja a következő példához hasonlóan néz ki:

ASGI
WSGI

AsgiFunctionApp az ASGI HTTP-függvények létrehozására szolgáló legfelső szintű függvényalkalmazás-osztály.

# function_app.py

import azure.functions as func 
from fastapi import FastAPI, Request, Response 

fast_app = FastAPI() 

@fast_app.get("/return_http_no_body") 
async def return_http_no_body(): 
    return Response(content="", media_type="text/plain") 

app = func.AsgiFunctionApp(app=fast_app, 
                           http_auth_level=func.AuthLevel.ANONYMOUS)

WsgiFunctionApp A WSGI HTTP-függvények létrehozására szolgáló legfelső szintű függvényalkalmazás-osztály.

# function_app.py

import azure.functions as func 
from flask import Flask, Response 

flask_app = Flask(__name__) 

@flask_app.get("/return_http") 
def return_http(): 
    return Response("<h1>Hello World™</h1>", mimetype="text/html") 

app = func.WsgiFunctionApp(app=flask_app.wsgi_app, 
                           http_auth_level=func.AuthLevel.ANONYMOUS)

Skálázás és teljesítmény

A Python-függvényalkalmazások méretezésével és teljesítményével kapcsolatos ajánlott eljárásokért tekintse meg a Python-skálázásról és a teljesítményről szóló cikket.

Környezet

Ha egy függvény meghívási környezetét szeretné lekérni futás közben, vegye fel az argumentumot az context aláírásba.

Példa:

import azure.functions


def main(req: azure.functions.HttpRequest,
         context: azure.functions.Context) -> str:
    return f'{context.invocation_id}'

Az Context osztály a következő sztringattribútumokkal rendelkezik:

Attribútum	Leírás
`function_directory`	Az a könyvtár, amelyben a függvény fut.
`function_name`	A függvény neve.
`invocation_id`	Az aktuális függvényhívás azonosítója.
`thread_local_storage`	A függvény szál helyi tárolója. `invocation_id` A létrehozott szálakból való naplózás helyi beállítását tartalmazza.
`trace_context`	Az elosztott nyomkövetés környezete. További információ: `Trace Context`.
`retry_context`	A függvényre való újrapróbálkozáshoz használt környezet. További információ: `retry-policies`.

Globális változók

Nem garantált, hogy az alkalmazás állapota megmarad a jövőbeli végrehajtásokhoz. Az Azure Functions-futtatókörnyezet azonban gyakran ugyanazt a folyamatot használja fel ugyanazon alkalmazás több végrehajtásához is. A költséges számítások eredményeinek gyorsítótárazásához deklarálja globális változóként.

CACHED_DATA = None


def main(req):
    global CACHED_DATA
    if CACHED_DATA is None:
        CACHED_DATA = load_json()

    # ... use CACHED_DATA in code

Környezeti változók

Az Azure Functionsben az alkalmazásbeállítások, például a szolgáltatási kapcsolati sztring környezeti változókként jelennek meg futás közben. A kódban kétféleképpen érheti el ezeket a beállításokat.

Metódus	Leírás
`os.environ["myAppSetting"]`	Megpróbálja lekérni az alkalmazásbeállítást kulcsnév alapján, és sikertelenség esetén hibát jelez.
`os.getenv("myAppSetting")`	Megpróbálja lekérni az alkalmazásbeállítást kulcsnév alapján, és sikertelenül adja vissza `null` .

Mindkét módszerhez deklarálnia kell a deklaráltat import os.

Az alábbi példa az alkalmazás beállításának lekérésére használja os.environ["myAppSetting"] a következő kulccsalmyAppSetting:

import logging
import os

import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
  # Get the setting named 'myAppSetting'
  my_app_setting_value = os.environ["myAppSetting"]
  logging.info(f'My app setting value:{my_app_setting_value}')

A helyi fejlesztéshez az alkalmazásbeállítások megmaradnak a local.settings.json fájlban.

Metódus	Leírás
`os.environ["myAppSetting"]`	Megpróbálja lekérni az alkalmazásbeállítást kulcsnév alapján, és sikertelenség esetén hibát jelez.
`os.getenv("myAppSetting")`	Megpróbálja lekérni az alkalmazásbeállítást kulcsnév alapján, és sikertelenül adja vissza `null` .

Mindkét módszerhez deklarálnia kell a deklaráltat import os.

Az alábbi példa az alkalmazás beállításának lekérésére használja os.environ["myAppSetting"] a következő kulccsalmyAppSetting:

import logging
import os

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req: func.HttpRequest) -> func.HttpResponse:
  # Get the setting named 'myAppSetting'
  my_app_setting_value = os.environ["myAppSetting"]
  logging.info(f'My app setting value:{my_app_setting_value}')

A helyi fejlesztéshez az alkalmazásbeállítások megmaradnak a local.settings.json fájlban.

Amikor az új programozási modellt használja, engedélyezze a következő alkalmazásbeállítást a local.settings.json fájlban, az itt látható módon:

"AzureWebJobsFeatureFlags": "EnableWorkerIndexing"

A függvény telepítésekor ez a beállítás nem jön létre automatikusan. Ezt a beállítást kifejezetten létre kell hoznia az Azure-beli függvényalkalmazásban ahhoz, hogy a v2 modell használatával fusson.

Python-verzió

Az Azure Functions a következő Python-verziókat támogatja:

Functions-verzió	Python*-verziók
4.x	3.11 3,10 3.9 3,8 3.7
3.x	3.9 3,8 3.7

* Hivatalos Python-disztribúciók

Ha egy adott Python-verziót szeretne kérni a függvényalkalmazás Azure-ban való létrehozásakor, használja a --runtime-versionaz functionapp create parancsot. A Functions futtatókörnyezet verzióját a --functions-version beállítás állítja be. A Python-verzió a függvényalkalmazás létrehozásakor van beállítva, és a Használat csomagban futó alkalmazások esetében nem módosítható.

A futtatókörnyezet az elérhető Python-verziót használja, amikor helyileg futtatja.

Python-verzió módosítása

Ha egy Python-függvényalkalmazást egy adott nyelvi verzióra szeretne beállítani, meg kell adnia a nyelv és a nyelv verzióját a LinuxFxVersion helykonfiguráció mezőjében. Ha például módosítani szeretné a Python alkalmazást a Python 3.8 használatára, állítsa be linuxFxVersion a következőt python|3.8: .

A webhelybeállítás megtekintéséről és módosításáról az linuxFxVersion Azure Functions futtatókörnyezeti verzióinak megcélzása című témakörben olvashat.

További általános információkért tekintse meg az Azure Functions futtatókörnyezet támogatási szabályzatát és az Azure Functions támogatott nyelveket.

Csomagkezelés

Ha a Core Tools vagy a Visual Studio Code használatával fejleszt helyileg, adja hozzá a szükséges csomagok nevét és verzióit a requirements.txt fájlhoz, majd telepítse őket a használatával pip.

Például a következő requirements.txt fájl és pip parancs használatával telepítheti a csomagot a requests PyPI-ból.

requests==2.19.1

pip install -r requirements.txt

Ha egy App Service-csomagban futtatja a függvényeket, a requirements.txt definiált függőségek elsőbbséget élveznek a beépített Python-modulokkal szemben, például logging. Ez az elsőbbség ütközéseket okozhat, ha a beépített modulok neve megegyezik a kód könyvtárainak nevével. Használatalapú csomagban vagy Rugalmas prémium csomagban való futtatás esetén az ütközések kevésbé valószínűek, mert a függőségek alapértelmezés szerint nem rangsorolásra kerülnek.

Az App Service-csomagban futó problémák elkerülése érdekében ne nevezze el a címtárakat ugyanúgy, mint bármely Python-natív modul, és ne foglalja bele a Python natív kódtárait a projekt requirements.txt fájljába.

Közzététel az Azure-ban

Ha készen áll a közzétételre, győződjön meg arról, hogy az összes nyilvánosan elérhető függőség szerepel a requirements.txt fájlban. Ezt a fájlt a projektkönyvtár gyökerében találja.

A közzétételből kizárt projektfájlokat és mappákat , beleértve a virtuális környezet mappát is, a projekt gyökérkönyvtárában találja.

A Python-projekt Azure-ban való közzétételéhez három buildelési művelet támogatott: távoli buildelés, helyi buildelés és egyéni függőségeket használó buildek.

Az Azure Pipelines használatával is létrehozhatja függőségeit, és folyamatos kézbesítéssel (CD) teheti közzé. További információ: Folyamatos teljesítés az Azure Pipelines használatával.

Távoli buildelés

Távoli build használatakor a kiszolgálón visszaállított függőségek és a natív függőségek megegyeznek az éles környezettel. Ez egy kisebb feltöltőcsomagot eredményez. Használjon távoli buildet, amikor Python-alkalmazásokat fejleszt Windows rendszeren. Ha a projekt egyéni függőségekkel rendelkezik, a távoli buildet további index URL-címmel is használhatja.

A függőségek a requirements.txt fájl tartalma alapján távolról lesznek lekértek . A távoli buildelés az ajánlott buildelési módszer. Alapértelmezés szerint a Core Tools távoli buildet kér, amikor az alábbi func azure functionapp publish paranccsal közzéteszi a Python-projektet az Azure-ban.

func azure functionapp publish <APP_NAME>

Ne felejtse el lecserélni <APP_NAME> a függvényalkalmazás nevét az Azure-ban.

A Visual Studio Code-hoz készült Azure Functions-bővítmény alapértelmezés szerint távoli buildet is kér.

Helyi build

A függőségek helyileg lesznek lekértek a requirements.txt fájl tartalma alapján. A távoli buildelést az alábbi func azure functionapp publish paranccsal megakadályozhatja, hogy helyi buildel tegye közzé a következőket:

func azure functionapp publish <APP_NAME> --build local

Ne felejtse el lecserélni <APP_NAME> a függvényalkalmazás nevét az Azure-ban.

A beállítás használatakor a --build local program beolvassa a projektfüggőségeket a requirements.txt fájlból, és ezek a függő csomagok helyileg lesznek letöltve és telepítve. A projektfájlok és függőségek a helyi számítógépről az Azure-ba vannak üzembe helyezve. Ez egy nagyobb üzembehelyezési csomagot eredményez az Azure-ba való feltöltéshez. Ha valamilyen okból nem tudja lekérni a requirements.txt fájlt a Core Tools használatával, a közzétételhez az egyéni függőségek lehetőséget kell használnia.

Nem javasoljuk, hogy helyi buildeket használjunk, amikor helyi fejlesztést használ Windows rendszeren.

Egyéni függőségek

Ha a projekt olyan függőségekkel rendelkezik, amelyek nem találhatók a Python-csomagindexben, kétféleképpen hozhatja létre a projektet. Az első módszer, a buildelési módszer attól függ, hogyan kell felépíteni a projektet.

Távoli build extra index URL-címmel

Ha a csomagok elérhetőek egy elérhető egyéni csomagindexből, használjon távoli buildet. A közzététel előtt mindenképpen hozzon létre egy alkalmazásbeállítástPIP_EXTRA_INDEX_URL. Ennek a beállításnak az értéke az egyéni csomagindex URL-címe. Ezzel a beállítással a távoli build a beállítással --extra-index-url futtathatópip install. További információkért tekintse meg a Python pip install dokumentációját.

Az alapszintű hitelesítési hitelesítő adatokat a csomagindex további URL-címeivel is használhatja. További információ: Alapszintű hitelesítési hitelesítő adatok a Python dokumentációjában.

Helyi csomagok telepítése

Ha a projekt olyan csomagokat használ, amelyek nem érhetők el nyilvánosan az eszközeink számára, azokat elérhetővé teheti az alkalmazás számára a __app__/.python_packages könyvtárba helyezésével. A közzététel előtt futtassa a következő parancsot a függőségek helyi telepítéséhez:

pip install  --target="<PROJECT_DIR>/.python_packages/lib/site-packages"  -r requirements.txt

Egyéni függőségek használatakor a közzétételi lehetőséget kell használnia --no-build , mert már telepítette a függőségeket a projektmappába.

func azure functionapp publish <APP_NAME> --no-build

Ne felejtse el lecserélni <APP_NAME> a függvényalkalmazás nevét az Azure-ban.

Egységtesztelés

A Pythonban írt függvények szabványos tesztelési keretrendszerek használatával tesztelhetők más Python-kódokkal. A legtöbb kötés esetében létrehozhat egy makett bemeneti objektumot egy megfelelő osztály példányának létrehozásával a azure.functions csomagból. Mivel a azure.functions csomag nem érhető el azonnal, mindenképpen telepítse a requirements.txt fájlon keresztül, a fenti csomagkezelési szakaszban leírtak szerint.

Ha például my_second_function , az alábbiakban egy HTTP-aktivált függvény modelltesztje látható:

Először hozzon létre egy <project_root/my_second_function>/function.json fájlt, majd definiálja ezt a függvényt HTTP-eseményindítóként.

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

Ezután implementálhatja és végrehajthatja my_second_function a shared_code.my_second_helper_function.

# <project_root>/my_second_function/__init__.py
import azure.functions as func
import logging

# Use absolute import to resolve shared_code modules
from shared_code import my_second_helper_function

# Define an HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
def main(req: func.HttpRequest) -> func.HttpResponse:
  logging.info('Executing my_second_function.')

  initial_value: int = int(req.params.get('value'))
  doubled_value: int = my_second_helper_function.double(initial_value)

  return func.HttpResponse(
    body=f"{initial_value} * 2 = {doubled_value}",
    status_code=200
    )

# <project_root>/shared_code/__init__.py
# Empty __init__.py file marks shared_code folder as a Python package

# <project_root>/shared_code/my_second_helper_function.py

def double(value: int) -> int:
  return value * 2

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

# <project_root>/tests/test_my_second_function.py
import unittest

import azure.functions as func
from my_second_function import main

class TestFunction(unittest.TestCase):
  def test_my_second_function(self):
    # Construct a mock HTTP request.
    req = func.HttpRequest(method='GET',
                           body=None,
                           url='/api/my_second_function',
                           params={'value': '21'})
    # Call the function.
    resp = main(req)

    # Check the output.
    self.assertEqual(resp.get_body(), b'21 * 2 = 42',)

A .venv Python virtuális környezet mappájában telepítse kedvenc Python-tesztkörnyezetét, példáulpip install pytest. Ezután futtassa pytest tests a teszt eredményét.

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

# <project_root>/function_app.py
import azure.functions as func
import logging

# Use absolute import to resolve shared_code modules
from shared_code import my_second_helper_function

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_second_function")
@app.route(route="hello")
def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Executing my_second_function.')

    initial_value: int = int(req.params.get('value'))
    doubled_value: int = my_second_helper_function.double(initial_value)

    return func.HttpResponse(
        body=f"{initial_value} * 2 = {doubled_value}",
        status_code=200
    )

# <project_root>/shared_code/__init__.py
# Empty __init__.py file marks shared_code folder as a Python package

# <project_root>/shared_code/my_second_helper_function.py

def double(value: int) -> int:
  return value * 2

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

# <project_root>/tests/test_my_second_function.py
import unittest
import azure.functions as func

from function_app import main

class TestFunction(unittest.TestCase):
  def test_my_second_function(self):
    # Construct a mock HTTP request.
    req = func.HttpRequest(method='GET',
                           body=None,
                           url='/api/my_second_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 .venv Python virtuális környezet mappájában telepítse kedvenc Python-tesztkörnyezetét, példáulpip install pytest. Ezután futtassa pytest tests a teszt eredményét.

Ideiglenes fájlok

A tempfile.gettempdir() metódus egy ideiglenes mappát ad vissza, amely Linuxon / tmp. Az alkalmazás ezt a könyvtárat használhatja a függvények által létrehozott és használt ideiglenes fájlok tárolására, amikor azok futnak.

Fontos

Az ideiglenes könyvtárba írt fájlok nem garantáltan megmaradnak a meghívások között. A vertikális felskálázás során az ideiglenes fájlok nem lesznek megosztva a példányok között.

Az alábbi példa létrehoz egy elnevezett ideiglenes fájlt az ideiglenes könyvtárban (/tmp):

import logging
import azure.functions as func
import tempfile

from os import listdir

#---
   tempFilePath = tempfile.gettempdir()
   fp = tempfile.NamedTemporaryFile()
   fp.write(b'Hello world!')
   filesDirListInTemp = listdir(tempFilePath)

Javasoljuk, hogy a teszteket a projektmappától különálló mappában tartsa karban. Ez a művelet megakadályozza, hogy tesztkódot helyezzen üzembe az alkalmazással.

Előre telepített kódtárak

Néhány kódtár a Python-függvények futtatókörnyezetével rendelkezik.

A Python standard kódtára

A Python standard kódtára tartalmazza az egyes Python-disztribúciókhoz szállított beépített Python-modulok listáját. A kódtárak többsége segít elérni a rendszer funkcióit, például a fájlbemenetet/kimenetet (I/O). Windows rendszereken ezek a kódtárak Pythonnal vannak telepítve. Unix-alapú rendszereken csomaggyűjtemények biztosítják őket.

A Python-verzió kódtárának megtekintéséhez nyissa meg a következőt:

Az Azure Functions Python feldolgozói függőségei

Az Azure Functions Python-feldolgozónak egy adott kódtárkészletre van szüksége. Ezeket a kódtárakat a függvényekben is használhatja, de nem részei a Python szabványnak. Ha a függvények ezen kódtárak bármelyikére támaszkodnak, előfordulhat, hogy nem érhetők el a kódhoz, ha az Azure Functionsen kívül fut. A függőségek részletes listáját a setup.py fájl "install_requires" szakaszában találja.

Feljegyzés

Ha a függvényalkalmazás requirements.txt fájlja tartalmaz egy bejegyzéstazure-functions-worker, távolítsa el. A függvényfeldolgozót automatikusan az Azure Functions platform felügyeli, és rendszeresen frissítjük új funkciókkal és hibajavításokkal. A feldolgozó egy régi verziójának manuális telepítése a requirements.txt fájlban váratlan problémákat okozhat.

Feljegyzés

Ha a csomag olyan kódtárakat tartalmaz, amelyek ütközhetnek a feldolgozó függőségeivel (például protobuf, tensorflow vagy grpcio), konfigurálja PYTHON_ISOLATE_WORKER_DEPENDENCIES1 az alkalmazásbeállításokban, hogy az alkalmazás ne hivatkozhat a feldolgozó függőségeire.

Az Azure Functions Python-kódtára

Minden Python-feldolgozó frissítése tartalmazza az Azure Functions Python-kódtár (azure.functions) új verzióját. Ez a megközelítés megkönnyíti a Python-függvényalkalmazások folyamatos frissítését, mivel minden frissítés visszamenőlegesen kompatibilis. A kódtár kiadásainak listáját az Azure-functions PyPi-ban találja.

A futtatókörnyezeti kódtár verzióját az Azure kijavította, és a requirements.txt nem bírálhatja felül. A azure-functions requirements.txt bejegyzése csak a linting és az ügyfelek tudatosságára vonatkozik.

A pythonfüggvénytár aktuális verziójának nyomon követéséhez használja a következő kódot a futtatókörnyezetben:

getattr(azure.functions, '__version__', '< 1.2.1')

Futtatókörnyezeti rendszerkódtárak

A Python-feldolgozó Docker-lemezképeiben lévő előre telepített rendszerkódtárak listáját a következő témakörben találja:

Függvények futtatókörnyezete	Debian-verzió	Python-verziók
3.x-es verzió	Buster	Python 3.7 Python 3.8 Python 3.9

Python-feldolgozó bővítmények

Az Azure Functionsben futó Python-feldolgozó folyamat lehetővé teszi külső kódtárak integrálását a függvényalkalmazásba. Ezek a bővítménytárak köztes szoftverként működnek, amelyek adott műveleteket injektálhatnak a függvény végrehajtásának életciklusa során.

A bővítmények a függvénykódban ugyanúgy vannak importálva, mint egy szabványos Python-kódtármodul. A bővítmények a következő hatókörök alapján futnak:

Hatókör	Leírás
Alkalmazásszintű	Bármely függvény-eseményindítóba importálva a bővítmény az alkalmazás összes függvényvégrehajtására érvényes.
Függvényszint	A végrehajtás csak arra a függvény-eseményindítóra korlátozódik, amelybe importálja.

Tekintse át az egyes bővítmények adatait, hogy többet tudjon meg arról a hatókörről, amelyben a bővítmény fut.

A bővítmények pythonos feldolgozóbővítmény-felületet implementálnak. Ez a művelet lehetővé teszi, hogy a Python-feldolgozó folyamat a függvény végrehajtási életciklusa során behívja a bővítménykódot. További információ: Bővítmények létrehozása.

Bővítmények használata

A Python-függvényekben pythonos feldolgozóbővítménytárat az alábbi módon használhat:

Adja hozzá a bővítménycsomagot a projekt requirements.txt fájljához.
Telepítse a kódtárat az alkalmazásba.
Adja hozzá a következő alkalmazásbeállításokat:
- Helyi: Adja meg "PYTHON_ENABLE_WORKER_EXTENSIONS": "1" a Values local.settings.json fájl szakaszát.
- Azure: Adja meg PYTHON_ENABLE_WORKER_EXTENSIONS=1 az alkalmazás beállításait.
Importálja a bővítménymodult a függvényindítóba.
Szükség esetén konfigurálja a bővítménypéldányt. A konfigurációs követelményeket a bővítmény dokumentációjában kell megadni.

Fontos

A Microsoft nem támogatja vagy garantálja a külső Python-feldolgozóbővítmény-kódtárakat. Győződjön meg arról, hogy a függvényalkalmazásban használt bővítmények megbízhatóak, és teljes mértékben fennáll a veszélye annak, hogy rosszindulatú vagy rosszul írt bővítményt használ.

A külső feleknek konkrét dokumentációt kell nyújtaniuk a bővítmények a függvényalkalmazásban való telepítéséről és felhasználásáról. A bővítmények használatára vonatkozó alapvető példa: A bővítmény használata.

Íme néhány példa a bővítmények függvényalkalmazásban való használatára hatókör szerint:

Alkalmazásszintű
Függvényszint

# <project_root>/requirements.txt
application-level-extension==1.0.0

# <project_root>/Trigger/__init__.py

from application_level_extension import AppExtension
AppExtension.configure(key=value)

def main(req, context):
  # Use context.app_ext_attributes here

# <project_root>/requirements.txt
function-level-extension==1.0.0


# <project_root>/Trigger/__init__.py

from function_level_extension import FuncExtension
func_ext_instance = FuncExtension(__file__)

def main(req, context):
  # Use func_ext_instance.attributes here

Bővítmények létrehozása

A bővítményeket külső könyvtárfejlesztők hozzák létre, akik olyan funkciókat hoztak létre, amelyek integrálhatók az Azure Functionsbe. A bővítményfejlesztők olyan Python-csomagokat terveznek, implementálnak és bocsátanak ki, amelyek kifejezetten a függvényvégrehajtás kontextusában futtatandó egyéni logikát tartalmaznak. Ezek a bővítmények közzétehetők a PyPI-beállításjegyzékben vagy a GitHub-adattárakban.

A Python-feldolgozóbővítmény-csomagok létrehozásának, csomagolásának, közzétételének és felhasználásának megismeréséhez lásd : Python-feldolgozóbővítmények fejlesztése az Azure Functionshez.

Alkalmazásszintű bővítmények

Egy alkalmazás hatókörében futó futtatásoktól AppExtensionBase öröklődő bővítmény.

AppExtensionBase a következő absztrakt osztálymódszereket teszi elérhetővé a megvalósításhoz:

Metódus	Leírás
`init`	A bővítmény importálása után hívható meg.
`configure`	Függvénykódból hívható meg, amikor a bővítmény konfigurálásához szükség van rá.
`post_function_load_app_level`	Közvetlenül a függvény betöltése után hívva. A függvény nevét és függvénykönyvtárát a rendszer átadja a bővítménynek. Ne feledje, hogy a függvénykönyvtár írásvédett, és a könyvtárban lévő helyi fájlba való írási kísérlet meghiúsul.
`pre_invocation_app_level`	Közvetlenül a függvény aktiválása előtt hívható meg. A függvénykörnyezet és a függvényhívás argumentumai a bővítménynek lesznek átadva. A függvénykód használatához általában más attribútumokat is átadhat a környezeti objektumban.
`post_invocation_app_level`	Közvetlenül a függvény végrehajtása után hívva. A függvénykörnyezet, a függvényhívási argumentumok és a meghívás visszatérési objektuma át lesz adva a bővítménynek. Ez a megvalósítás jó hely annak ellenőrzésére, hogy az életciklus-horgok végrehajtása sikeres volt-e.

Függvényszintű bővítmények

A FuncExtensionBase-től öröklő bővítmény egy adott függvény-eseményindítóban fut.

FuncExtensionBase az implementációkhoz a következő absztrakt osztálymódszereket teszi elérhetővé:

Metódus	Leírás
`__init__`	A bővítmény konstruktora. A függvény akkor hívja meg, ha egy bővítménypéldányt inicializál egy adott függvényben. Az absztrakt metódus megvalósításakor érdemes lehet elfogadni egy paramétert `filename` , és átadni a szülő metódusának `super().__init__(filename)` a megfelelő bővítményregisztrációhoz.
`post_function_load`	Közvetlenül a függvény betöltése után hívva. A függvény nevét és függvénykönyvtárát a rendszer átadja a bővítménynek. Ne feledje, hogy a függvénykönyvtár írásvédett, és a könyvtárban lévő helyi fájlba való írási kísérlet meghiúsul.
`pre_invocation`	Közvetlenül a függvény aktiválása előtt hívható meg. A függvénykörnyezet és a függvényhívás argumentumai a bővítménynek lesznek átadva. A függvénykód használatához általában más attribútumokat is átadhat a környezeti objektumban.
`post_invocation`	Közvetlenül a függvény végrehajtása után hívva. A függvénykörnyezet, a függvényhívási argumentumok és a meghívás visszatérési objektuma át lesz adva a bővítménynek. Ez a megvalósítás jó hely annak ellenőrzésére, hogy az életciklus-horgok végrehajtása sikeres volt-e.

Az Azure Functions támogatja a forrásközi erőforrás-megosztást (CORS). A CORS a portálon és az Azure CLI-ben van konfigurálva. A CORS által engedélyezett forráslista a függvényalkalmazás szintjén érvényes. Ha a CORS engedélyezve van, a válaszok tartalmazzák a fejlécet Access-Control-Allow-Origin . További információ: Eltérő eredetű erőforrás-megosztás

A több forrásból származó erőforrás-megosztás (CORS) teljes mértékben támogatott a Python-függvényalkalmazásokban.

Aszinkron

A Python gazdagéppéldányai alapértelmezés szerint egyszerre csak egy függvényhívást képesek feldolgozni. Ennek az az oka, hogy a Python egy egyszálas futtatókörnyezet. Olyan függvényalkalmazások esetében, amelyek nagy számú I/O-eseményt dolgoznak fel, vagy I/O-kötöttek, a függvények aszinkron futtatásával jelentősen javíthatja a teljesítményt. További információ: A Python-alkalmazások teljesítményének javítása az Azure Functionsben.

Megosztott memória (előzetes verzió)

Az átviteli sebesség javítása érdekében az Azure Functions lehetővé teszi, hogy a folyamaton kívüli Python-nyelvi feldolgozó memóriát osztson meg a Functions-gazdafolyamattal. Ha a függvényalkalmazás szűk keresztmetszeteket ér el, engedélyezheti a megosztott memóriát úgy, hogy hozzáad egy FUNCTIONS_WORKER_SHARED_MEMORY_DATA_TRANSFER_ENABLED nevű alkalmazásbeállítást, amelynek értéke a következő1. Ha engedélyezve van a megosztott memória, a DOCKER_SHM_SIZE beállítással a megosztott memóriát 256 MB-nak megfelelő értékre 268435456állíthatja.

Például engedélyezheti a megosztott memóriát, hogy csökkentse a szűk keresztmetszeteket, ha Blob Storage-kötéseket használ az 1 MB-nál nagyobb hasznos adatok átviteléhez.

Ez a funkció csak prémium és dedikált (Azure-alkalmazás szolgáltatáscsomagokban) futó függvényalkalmazásokhoz érhető el. További információ: Megosztott memória.

Ismert problémák és gyakori kérdések

Az alábbiakban két hibaelhárítási útmutatót talál a gyakori problémákhoz:

A v2 programozási modell ismert problémáihoz két hibaelhárítási útmutatót talál:

Az összes ismert probléma és funkciókérés nyomon követhető a GitHub-problémák listájában. Ha problémába ütközik, és nem találja a problémát a GitHubon, nyisson meg egy új problémát, és adja meg a probléma részletes leírását.

Következő lépések

További információkat találhat az alábbi forrásokban:

Problémákat tapasztal a Python használatával kapcsolatban? Mondja el, mi folyik itt.

Azure Functions-útmutató Python-fejlesztőknek

Fejlesztési lehetőségek

Programozási modell

Alternatív belépési pont

Mappastruktúra

Kapcsolódás adatbázishoz

Blueprints

Importálási viselkedés

Triggerek és bemenetek

Kimenetek

Naplózás

Naplózás létrehozott szálakból

Egyéni telemetriai adatok naplózása

HTTP-eseményindító

Webes keretrendszerek

Skálázás és teljesítmény

Környezet

Globális változók

Környezeti változók

Python-verzió

Python-verzió módosítása

Csomagkezelés

Közzététel az Azure-ban

Távoli buildelés

Helyi build

Egyéni függőségek

Távoli build extra index URL-címmel

Helyi csomagok telepítése

Egységtesztelés

Ideiglenes fájlok

Előre telepített kódtárak

A Python standard kódtára

Az Azure Functions Python feldolgozói függőségei

Az Azure Functions Python-kódtára

Futtatókörnyezeti rendszerkódtárak

Python-feldolgozó bővítmények

Bővítmények használata

Bővítmények létrehozása

Alkalmazásszintű bővítmények

Függvényszintű bővítmények

Eltérő eredetű erőforrások megosztása

Aszinkron

Megosztott memória (előzetes verzió)

Ismert problémák és gyakori kérdések

Következő lépések

További források