Python-feldolgozóbővítmények fejlesztése az Azure Functionshez

Megjegyzés:

A Python 3.13-tól kezdve a Python-feldolgozó bővítmények már nem támogatottak.

Az Azure Functions lehetővé teszi egyéni viselkedések integrálását a Python-függvények végrehajtásának részeként. Ez a funkció lehetővé teszi, hogy olyan üzleti logikát hozzon létre, amelyet az ügyfelek egyszerűen használhatnak saját függvényalkalmazásaikban. A feldolgozóbővítmények a v1 és a v2 Python programozási modellekben is támogatottak.

Ebben az oktatóanyagban megtanulhatja, hogyan:

Hozzon létre egy alkalmazásszintű Python-feldolgozóbővítményt az Azure Functionshez.
Fogyassza a bővítményt az alkalmazásban úgy, ahogyan az ügyfelei.
Csomagolja és tegye közzé a bővítményt felhasználás céljából.

Előfeltételek

A kezdés előtt meg kell felelnie az alábbi követelményeknek:

Python 3.7 vagy újabb. Az Azure Functionsben támogatott Python-verziók teljes listájának megtekintéséhez tekintse meg a Python fejlesztői útmutatóját.
Az Azure Functions Core Tools 4.0.5095-ös vagy újabb verziója, amely támogatja a bővítmény használatát a v2 Python programozási modellel. Ellenőrizze a verziót a használatával func --version.
Az egyik támogatott platformra telepített Visual Studio Code.

A Python Worker bővítmény létrehozása

Az Ön által készített bővítmény a HTTP-eseményindító meghívásának eltelt idejét rögzíti a konzolnaplókban és a HTTP-válasz törzsében.

Mappastruktúra

A bővítményprojekt mappájának a következő struktúrához hasonlónak kell lennie:

<python_worker_extension_root>/
 | - .venv/
 | - python_worker_extension_timer/
 | | - __init__.py
 | - setup.py
 | - readme.md

Mappa/fájl	Description
.venv/	(Nem kötelező) Helyi fejlesztéshez használt Python virtuális környezetet tartalmaz.
python_worker_extension/	A Python-feldolgozó bővítmény forráskódját tartalmazza. Ez a mappa tartalmazza a PyPI-ban közzéteendő fő Python-modult.
setup.py	A Python-feldolgozó bővítménycsomag metaadatait tartalmazza.
readme.md	A bővítmény utasításait és használatát tartalmazza. Ez a tartalom leírásként jelenik meg a PyPI-projekt kezdőlapján.

Projekt metaadatainak konfigurálása

Először hozza létre a setup.py, amely alapvető információkat nyújt a csomagról. Annak érdekében, hogy a bővítmény megfelelően el legyen osztva és integrálva legyen az ügyfél függvényalkalmazásaiba, győződjön meg arról, hogy 'azure-functions >= 1.7.0, < 2.0.0' szerepel a install_requires szakaszban.

A következő sablonban szükség szerint módosítania authorkell a , author_email, install_requires, license, packagesés url a mezőket.

from setuptools import find_packages, setup
setup(
    name='python-worker-extension-timer',
    version='1.0.0',
    author='Your Name Here',
    author_email='your@email.here',
    classifiers=[
        'Intended Audience :: End Users/Desktop',
        'Development Status :: 5 - Production/Stable',
        'Intended Audience :: End Users/Desktop',
        'License :: OSI Approved :: Apache Software License',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3.7',
        'Programming Language :: Python :: 3.8',
        'Programming Language :: Python :: 3.9',
        'Programming Language :: Python :: 3.10',
    ],
    description='Python Worker Extension Demo',
    include_package_data=True,
    long_description=open('readme.md').read(),
    install_requires=[
        'azure-functions >= 1.7.0, < 2.0.0',
        # Any additional packages that will be used in your extension
    ],
    extras_require={},
    license='MIT',
    packages=find_packages(where='.'),
    url='https://your-github-or-pypi-link',
    zip_safe=False,
)

Ezután implementálja a bővítménykódot az alkalmazásszintű hatókörben.

Az időzítőbővítmény implementálása

Adja hozzá a következő kódot python_worker_extension_timer/__init__.py az alkalmazásszintű bővítmény implementálásához:

import typing
from logging import Logger
from time import time
from azure.functions import AppExtensionBase, Context, HttpResponse
class TimerExtension(AppExtensionBase):
    """A Python worker extension to record elapsed time in a function invocation
    """

    @classmethod
    def init(cls):
        # This records the starttime of each function
        cls.start_timestamps: typing.Dict[str, float] = {}

    @classmethod
    def configure(cls, *args, append_to_http_response:bool=False, **kwargs):
        # Customer can use TimerExtension.configure(append_to_http_response=)
        # to decide whether the elapsed time should be shown in HTTP response
        cls.append_to_http_response = append_to_http_response

    @classmethod
    def pre_invocation_app_level(
        cls, logger: Logger, context: Context,
        func_args: typing.Dict[str, object],
        *args, **kwargs
    ) -> None:
        logger.info(f'Recording start time of {context.function_name}')
        cls.start_timestamps[context.invocation_id] = time()

    @classmethod
    def post_invocation_app_level(
        cls, logger: Logger, context: Context,
        func_args: typing.Dict[str, object],
        func_ret: typing.Optional[object],
        *args, **kwargs
    ) -> None:
        if context.invocation_id in cls.start_timestamps:
            # Get the start_time of the invocation
            start_time: float = cls.start_timestamps.pop(context.invocation_id)
            end_time: float = time()
            # Calculate the elapsed time
            elapsed_time = end_time - start_time
            logger.info(f'Time taken to execute {context.function_name} is {elapsed_time} sec')
            # Append the elapsed time to the end of HTTP response
            # if the append_to_http_response is set to True
            if cls.append_to_http_response and isinstance(func_ret, HttpResponse):
                func_ret._HttpResponse__body += f' (TimeElapsed: {elapsed_time} sec)'.encode()

Ez a kód öröklődik az AppExtensionBase-től , így a bővítmény az alkalmazás minden függvényére érvényes. A bővítményt egy függvényszintű hatókörre is implementálhatta volna a FuncExtensionBase-ből való örökléssel.

A init metódus egy osztálymetódus, amelyet a feldolgozó hív meg a bővítményosztály importálásakor. Itt végezhet inicializálási műveleteket a bővítményhez. Ebben az esetben a rendszer inicializál egy kivonattérképet az egyes függvények meghívási kezdő időpontjának rögzítéséhez.

A configure módszer ügyféloldali. A readme fájlban tájékoztathatja az ügyfeleket, hogy mikor kell felhívniuk Extension.configure(). A readme fájlnak dokumentálnia kell a bővítmény képességeit, a lehetséges konfigurációt és a használatot is. Ebben a példában az ügyfelek eldönthetik, hogy az eltelt idő szerepel-e a HttpResponsejelentésben.

A pre_invocation_app_level metódust a Python-feldolgozó hívja meg a függvény futtatása előtt. A függvény információit adja meg, például a függvénykörnyezetet és az argumentumokat. Ebben a példában a bővítmény naplóz egy üzenetet, és rögzíti a meghívás kezdő időpontját a invocation_id alapján.

Hasonlóképpen, a post_invocation_app_level meghívásra kerül a függvény végrehajtása után. Ez a példa a kezdési idő és az aktuális idő alapján számítja ki az eltelt időt. Felülírja a HTTP-válasz visszatérési értékét is.

Readme.md létrehozása

Hozzon létre egy readme.md fájlt a bővítményprojekt gyökerében. Ez a fájl tartalmazza a bővítmény utasításait és használatát. A readme.md tartalom a PyPI-projekt kezdőlapján található leírásként jelenik meg.

# Python Worker Extension Timer

In this file, tell your customers when they need to call `Extension.configure()`.

The readme should also document the extension capabilities, possible configuration,
and usage of your extension.

A bővítmény helyi felhasználása

Most, hogy létrehozott egy bővítményt, használhatja egy alkalmazásprojektben annak ellenőrzésére, hogy a bővítmény a kívánt módon működik-e.

HTTP-eseményindító függvény létrehozása

Hozzon létre egy új mappát az alkalmazásprojekthez, és lépjen be oda.
A projekt inicializálásához futtassa a következő parancsot a megfelelő shellből (például Bash):
```
func init --python
```
A következő paranccsal hozzon létre egy új HTTP-triggerfüggvényt, amely lehetővé teszi a névtelen hozzáférést:
```
func new -t HttpTrigger -n HttpTrigger -a anonymous
```

Virtuális környezet aktiválása

Hozzon létre egy Python virtuális környezetet az operációs rendszer alapján az alábbiak szerint:
- Linux
- Windows
```
python3 -m venv .venv
```
```
py -m venv .venv
```
Aktiválja a Python virtuális környezetet az operációs rendszer alapján az alábbiak szerint:
- Linux
- Windows
```
source .venv/bin/activate
```
```
.venv\Scripts\Activate.ps1
```

A bővítmény konfigurálása

Telepítse a függvényalkalmazás-projekt távoli csomagjait az alábbi paranccsal:
```
pip install -r requirements.txt
```
Telepítse a bővítményt a helyi fájl elérési útjáról, szerkeszthető módban az alábbiak szerint:
```
pip install -e <PYTHON_WORKER_EXTENSION_ROOT>
```
Ebben a példában helyettesítse a <PYTHON_WORKER_EXTENSION_ROOT> elemet a bővítményprojekt gyökérfájl helyével.

Amikor egy ügyfél a bővítményt használja, ehelyett hozzáadja a bővítménycsomag helyét a requirements.txt fájlhoz, ahogyan az alábbi példákban is látható:
- PyPI
- GitHub
```
# requirements.txt
python_worker_extension_timer==1.0.0
```
```
# requirements.txt
git+https://github.com/Azure-Samples/python-worker-extension-timer@main
```
Nyissa meg a local.settings.json projektfájlt, és adja hozzá a következő mezőt a következőhöz Values:
```
"PYTHON_ENABLE_WORKER_EXTENSIONS": "1" 
```
Amikor az Azure-ban fut, helyette hozzá kell adnia a PYTHON_ENABLE_WORKER_EXTENSIONS=1-t a függvényalkalmazás alkalmazásbeállításaihoz.
Adjon hozzá két sort a függvény elé a mainv1 programozási modell __init.py__ fájljában vagy a v2 programozási modell function_app.py fájljában:
```
from python_worker_extension_timer import TimerExtension
TimerExtension.configure(append_to_http_response=True)
```
Ez a kód importálja a modult TimerExtension , és beállítja a append_to_http_response konfigurációs értéket.

A bővítmény ellenőrzése

Az alkalmazásprojekt gyökérmappájából indítsa el a function hostot a következővel: func host start --verbose. A kimenetben https://localhost:7071/api/HttpTriggera függvény helyi végpontjának kell megjelennie.
A böngészőben küldjön egy GET kérést a következőnek https://localhost:7071/api/HttpTrigger: . A válasznak az alábbihoz hasonlatosnak kell lennie, kiegészítve a kéréshez tartozó TimeElapsed adatokkal.
```
This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response. (TimeElapsed: 0.0009996891021728516 sec)
```

A bővítmény közzététele

A bővítmény létrehozása és ellenőrzése után továbbra is el kell végeznie a következő közzétételi feladatokat:

Válasszon egy licencet.
Hozzon létre egy readme.md és egyéb dokumentációt.
Tegye közzé a bővítménytárat egy Python-csomagregisztrációs adatbázisban vagy egy verziókövetési rendszerben (VCS).

PyPI
GitHub

A bővítmény közzététele a PyPI-ben:

Futtassa a következő parancsot a twine és wheel telepítéséhez az alapértelmezett Python-környezetben vagy egy virtuális környezetben.
```
pip install twine wheel
```
Távolítsa el a régi dist/ mappát a bővítménytárházból.
Futtassa a következő parancsot egy új csomag létrehozásához belül dist/:
```
python setup.py sdist bdist_wheel
```
Futtassa a következő parancsot a csomag PyPI-ba való feltöltéséhez:
```
twine upload dist/*
```
Előfordulhat, hogy a feltöltés során meg kell adnia a PyPI-fiók hitelesítő adatait. Tesztelheti is a csomagfeltöltést twine upload -r testpypi dist/*. További információkért tekintse meg a Twine dokumentációját.

A lépések után az ügyfelek használhatják a bővítményt úgy, hogy a csomag nevét a requirements.txt fájlba tartalmazzák.

További információkért tekintse meg a Python hivatalos csomagolási oktatóanyagát.

Példák

A befejezett mintakiterjesztési projektet ebből a cikkből tekintheti meg a python_worker_extension_timer mintaadattárban.
Az OpenCensus-integráció egy nyílt forráskódú projekt, amely a bővítményfelülettel integrálja a telemetriai nyomkövetést az Azure Functions Python-alkalmazásokban. Tekintse meg az opencensus-python-extensions-azure adattárat a Python-feldolgozó bővítmény implementációjának áttekintéséhez.

Következő lépések

Az Azure Functions Python fejlesztésével kapcsolatos további információkért tekintse meg a következő erőforrásokat:

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-01-16