Vývoj rozšíření pracovních procesů Pythonu pro Azure Functions

Článek
04/26/2023

Azure Functions umožňuje integrovat vlastní chování v rámci provádění funkcí Pythonu. Tato funkce umožňuje vytvářet obchodní logiku, kterou můžou zákazníci snadno používat ve svých vlastních aplikacích funkcí. Další informace najdete v referenčních informacích pro vývojáře v Pythonu. Rozšíření pracovních procesů jsou podporovaná v programovacích modelech Pythonu v1 i v2.

V tomto kurzu se naučíte:

Vytvořte rozšíření pracovního procesu Pythonu na úrovni aplikace pro Azure Functions.
Využití rozšíření v aplikaci tak, jak to dělají vaši zákazníci.
Zabalte a publikujte rozšíření pro použití.

Požadavky

Než začnete, musíte splňovat tyto požadavky:

Python 3.7 nebo novější. Úplný seznam podporovaných verzí Pythonu v Azure Functions najdete v příručce pro vývojáře v Pythonu.
Azure Functions Core Tools verze 4.0.5095 nebo novější, která podporuje použití rozšíření s programovacím modelem Pythonu v2. Zkontrolujte svoji verzi pomocí func --versionpříkazu .
Visual Studio Code nainstalovaný na jedné z podporovaných platforem.

Vytvoření rozšíření Python Worker

Rozšíření, které vytvoříte, hlásí uplynulý čas vyvolání triggeru HTTP v protokolech konzoly a v těle odpovědi HTTP.

Struktura složek

Složka pro projekt rozšíření by měla být podobná následující struktuře:

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

Složka nebo soubor	Popis
.venv/	(Volitelné) Obsahuje virtuální prostředí Pythonu používané pro místní vývoj.
python_worker_extension/	Obsahuje zdrojový kód rozšíření pracovního procesu Pythonu. Tato složka obsahuje hlavní modul Pythonu, který se má publikovat do PyPI.
setup.py	Obsahuje metadata balíčku rozšíření pracovního procesu Pythonu.
readme.md	Obsahuje pokyny a použití vašeho rozšíření. Tento obsah se zobrazí jako popis na domovské stránce vašeho projektu PyPI.

Konfigurace metadat projektu

Nejprve vytvoříte setup.py, který poskytuje základní informace o balíčku. Abyste měli jistotu, že je vaše rozšíření správně distribuované a integrované do aplikací funkcí zákazníka, ověřte, že 'azure-functions >= 1.7.0, < 2.0.0' je to v install_requires části.

V následující šabloně byste měli podle potřeby změnit authorpole , author_emailinstall_requires, license, packages, a url .

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

Dále implementujete kód rozšíření v oboru na úrovni aplikace.

Implementace rozšíření časovače

Přidejte do souboru následující kód python_worker_extension_timer/__init__.py pro implementaci rozšíření na úrovni aplikace:

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

Tento kód dědí z AppExtensionBase , takže rozšíření platí pro všechny funkce v aplikaci. Rozšíření můžete také implementovat v oboru na úrovni funkce tak, že zdědíte z FuncExtensionBase.

Metoda init je metoda třídy, která je volána pracovním procesem při importu třídy rozšíření. Tady můžete provádět inicializační akce pro rozšíření. V tomto případě je inicializována mapa hash pro záznam počátečního času vyvolání pro každou funkci.

Metoda configure je určená pro zákazníky. V souboru readme můžete zákazníkům sdělit, kdy potřebují volat Extension.configure(). Soubor Readme by měl také zdokumentovat možnosti rozšíření, možnou konfiguraci a použití rozšíření. V tomto příkladu si zákazníci můžou zvolit, jestli se má uplynulý čas hlásit v HttpResponsesouboru .

Metodu pre_invocation_app_level volá pracovní proces Pythonu před spuštěním funkce. Poskytuje informace z funkce, například kontext funkce a argumenty. V tomto příkladu rozšíření protokoluje zprávu a zaznamenává čas zahájení vyvolání na základě jeho invocation_id.

Podobně se post_invocation_app_level volá po spuštění funkce. Tento příklad vypočítá uplynulý čas na základě času zahájení a aktuálního času. Přepíše také návratovou hodnotu odpovědi HTTP.

Vytvoření readme.md

V kořenovém adresáři projektu rozšíření vytvořte soubor readme.md. Tento soubor obsahuje pokyny a použití vašeho rozšíření. Obsah readme.md se zobrazí jako popis na domovské stránce projektu PyPI.

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

Místní využití rozšíření

Teď, když jste vytvořili rozšíření, můžete ho použít v projektu aplikace a ověřit, že funguje podle očekávání.

Vytvoření funkce triggeru HTTP

Vytvořte novou složku pro projekt aplikace a přejděte do ní.
V příslušném prostředí, jako je Bash, spusťte následující příkaz, který inicializuje projekt:
```
func init --python
```
Pomocí následujícího příkazu vytvořte novou funkci triggeru HTTP, která umožňuje anonymní přístup:
```
func new -t HttpTrigger -n HttpTrigger -a anonymous
```

Aktivace virtuálního prostředí

Následujícím způsobem vytvořte virtuální prostředí Python založené na operačním systému:
- Linux
- Windows
```
python3 -m venv .venv
```
```
py -m venv .venv
```
Následujícím způsobem aktivujte virtuální prostředí Python na základě operačního systému:
- Linux
- Windows
```
source .venv/bin/activate
```
```
.venv\Scripts\Activate.ps1
```

Konfigurace rozšíření

Nainstalujte vzdálené balíčky pro projekt aplikace funkcí pomocí následujícího příkazu:
```
pip install -r requirements.txt
```
Nainstalujte příponu z místní cesty k souboru v režimu upravitelných takto:
```
pip install -e <PYTHON_WORKER_EXTENSION_ROOT>
```
V tomto příkladu nahraďte <PYTHON_WORKER_EXTENSION_ROOT> umístěním kořenového souboru projektu rozšíření.

Když zákazník použije vaše rozšíření, místo toho přidá umístění balíčku rozšíření do souboru requirements.txt, jako v následujících příkladech:
- PyPI
- GitHub
```
# requirements.txt
python_worker_extension_timer==1.0.0
```
```
# requirements.txt
git+https://github.com/Azure-Samples/python-worker-extension-timer@main
```
Otevřete soubor projektu local.settings.json a přidejte do Valuespole následující pole :
```
"PYTHON_ENABLE_WORKER_EXTENSIONS": "1" 
```
Při spuštění v Azure místo toho přidáte PYTHON_ENABLE_WORKER_EXTENSIONS=1 do nastavení aplikace funkcí.
Přidejte následující dva řádky před main funkci v souboru __init.py__ pro programovací model v1 nebo do souboru function_app.py pro programovací model v2:
```
from python_worker_extension_timer import TimerExtension
TimerExtension.configure(append_to_http_response=True)
```
Tento kód importuje TimerExtension modul a nastaví append_to_http_response konfigurační hodnotu.

Ověření rozšíření

Z kořenové složky projektu aplikace spusťte hostitele funkce pomocí func host start --verbosepříkazu . Ve výstupu by se měl zobrazit místní koncový bod vaší funkce jako https://localhost:7071/api/HttpTrigger.
V prohlížeči odešlete požadavek GET na adresu https://localhost:7071/api/HttpTrigger. Měla by se zobrazit odpověď podobná následující s připojenými daty Time Uplynulé pro požadavek.
```
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)
```

Publikování rozšíření

Po vytvoření a ověření rozšíření budete muset dokončit tyto zbývající úlohy publikování:

Zvolte licenci.
Vytvořte readme.md a další dokumentaci.
Publikujte knihovnu rozšíření do registru balíčků Pythonu nebo do systému správy verzí (VCS).

PyPI
GitHub

Publikování rozšíření do PyPI:

Spuštěním následujícího příkazu nainstalujte twine a wheel do výchozího prostředí Pythonu nebo virtuálního prostředí:
```
pip install twine wheel
```
Odeberte starou dist/ složku z úložiště rozšíření.
Spuštěním následujícího příkazu vygenerujte nový balíček uvnitř dist/:
```
python setup.py sdist bdist_wheel
```
Spuštěním následujícího příkazu nahrajte balíček do PyPI:
```
twine upload dist/*
```
Během nahrávání možná budete muset zadat přihlašovací údaje k účtu PyPI. Nahrání balíčku můžete také otestovat pomocí twine upload -r testpypi dist/*příkazu . Další informace najdete v dokumentaci k Twine.

Po provedení těchto kroků můžou zákazníci používat vaše rozšíření tak, že do svých requirements.txt zahrnou název vašeho balíčku.

Další informace najdete v oficiálním kurzu balení Pythonu.

Příklady

Dokončený ukázkový projekt rozšíření najdete v tomto článku v python_worker_extension_timer ukázkovém úložišti.
Integrace OpenCensus je opensourcový projekt, který využívá rozhraní rozšíření k integraci trasování telemetrie do aplikací Azure Functions Pythonu. Implementaci tohoto rozšíření pracovních procesů Pythonu najdete v úložišti opencensus-python-extensions-azure .

Další kroky

Další informace o Azure Functions vývoji v Pythonu najdete v následujících zdrojích informací: