Profilování využití paměti aplikací v Pythonu ve službě Azure Functions

Během vývoje nebo po nasazení místního projektu aplikace funkcí Pythonu do Azure je vhodné analyzovat potenciální kritické body paměti ve vašich funkcích. Taková úzká místa mohou snížit výkon vašich funkcí a vést k chybám. Následující pokyny ukazují, jak používat balíček Pythonu profiler paměti, který poskytuje analýzu spotřeby paměti jednotlivých řádků vašich funkcí při jejich provádění.

Poznámka:

Profilace paměti je určená pouze pro analýzu stop paměti ve vývojových prostředích. Nepoužívejte profiler paměti v produkčních aplikacích funkcí.

Požadavky

Než začnete vyvíjet aplikaci funkcí Pythonu, musíte splnit tyto požadavky:

• Python 3.10 nebo vyšší. Úplný seznam podporovaných verzí Pythonu ve službě Azure Functions najdete v příručce pro vývojáře Pythonu.

• Nástroje Azure Functions Core Tools verze 4.x nebo vyšší. Zkontrolujte svou verzi pomocí func --version. Další informace o aktualizaci najdete v tématu Azure Functions Core Tools na GitHubu.

• Visual Studio Code nainstalovaný na jedné z podporovaných platforem.

• Aktivní předplatné Azure.

Pokud nemáte účet Azure, vytvořte si bezplatný účet před tím, než začnete.

Proces profilace paměti

1. V requirements.txt přidejte memory-profiler , abyste zajistili, že je balíček součástí vašeho nasazení. Pokud vyvíjíte na svém místním počítači, možná budete chtít aktivovat virtuální prostředí Pythonu a provést vyřešení závislostí balíčku pomocí pip install -r requirements.txt.

2. Do skriptu funkce (například __init__.py pro programovací model Pythonu v1 a function_app.py pro model v2) přidejte nad main() funkci následující řádky. Tyto řádky zajišťují, že kořenový logger uvádí názvy podřízených loggerů, aby bylo možné protokoly profilace paměti rozlišit podle předpony memory_profiler_logs.

   import logging
   import memory_profiler
   root_logger = logging.getLogger()
   root_logger.handlers[0].setFormatter(logging.Formatter("%(name)s: %(message)s"))
   profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)
   

3. Použijte následující dekorátor nad všemi funkcemi, které potřebují profilaci paměti. Dekorátor nefunguje přímo na metodě vstupního bodu triggeru main(). Potřebujete vytvořit dílčí funkce a ozdobit je. Navíc kvůli známému problému profileru paměti je při použití u asynchronní korutiny návratová hodnota korutiny vždy None.

   @memory_profiler.profile(stream=profiler_logstream)
   

4. Otestujte profiler paměti na místním počítači pomocí příkazu func host startAzure Functions Core Tools . Když tyto funkce zavoláte, měly by vygenerovat zprávu o využití paměti. Zpráva obsahuje název souboru, řádek kódu, využití paměti, přírůstek paměti a obsah daného řádku.

5. Pokud chcete v Azure zkontrolovat protokoly profilace paměti u existující instance aplikace Function App, můžete pomocí dotazů Kusto v části Protokoly služby Application Insights zadat dotaz na protokoly profilace paměti pro nedávná spuštění.

   

   traces
   | where timestamp > ago(1d)
   | where message startswith_cs "memory_profiler_logs:"
   | parse message with "memory_profiler_logs: " LineNumber "  " TotalMem_MiB "  " IncreMem_MiB "  " Occurrences "  " Contents
   | union (
       traces
       | where timestamp > ago(1d)
       | where message startswith_cs "memory_profiler_logs: Filename: "
       | parse message with "memory_profiler_logs: Filename: " FileName
       | project timestamp, FileName, itemId
   )
   | project timestamp, LineNumber=iff(FileName != "", FileName, LineNumber), TotalMem_MiB, IncreMem_MiB, Occurrences, Contents, RequestId=itemId
   | order by timestamp asc
   

Příklad

Tady je příklad profilace paměti u asynchronního a synchronního triggeru HTTP s názvem HttpTriggerAsync a HttpTriggerSync. Vytvoříme aplikaci funkcí Pythonu, která jednoduše odešle požadavky GET na domovskou stránku Microsoftu.

Vytvoření aplikace funkcí Pythonu

Aplikace funkcí v Pythonu by měla dodržovat strukturu složek specifikovanou pro Azure Functions. K vytvoření kostry projektu doporučujeme použít nástroje Azure Functions Core Tools spuštěním následujících příkazů:

v1

func init PythonMemoryProfilingDemo --python
cd PythonMemoryProfilingDemo
func new -l python -t HttpTrigger -n HttpTriggerAsync -a anonymous
func new -l python -t HttpTrigger -n HttpTriggerSync -a anonymous

v2

func init PythonMemoryProfilingDemov2 --python -m v2
cd PythonMemoryProfilingDemov2

Pro programovací model Python v2 se triggery a vazby vytvářejí jako dekorátory v samotném souboru Pythonu function_app.py soubor. Informace o tom, jak vytvořit novou funkci s novým programovacím modelem, najdete v příručce pro vývojáře v Pythonu pro Azure Functions. func new nepodporuje verzi Preview programovacího modelu Pythonu v2.

Aktualizace obsahu souboru

Requirements.txt definuje balíčky, které se v našem projektu používají. Kromě sady Azure Functions SDK a profileru paměti zavádíme aiohttp pro asynchronní požadavky HTTP a requests pro synchronní volání HTTP.

# requirements.txt

azure-functions
memory-profiler
aiohttp
requests

Vytvořte asynchronní trigger HTTP.

v1

Nahraďte kód v asynchronním triggeru HTTP HttpTriggerAsync/__init__.py následujícím kódem, který nakonfiguruje profilování paměti, formát kořenového loggeru a vazbu streamování loggeru.

# HttpTriggerAsync/__init__.py

import azure.functions as func
import aiohttp
import logging
import memory_profiler

# Update root logger's format to include the logger name. Ensure logs generated
# from memory profiler can be filtered by "memory_profiler_logs" prefix.
root_logger = logging.getLogger()
root_logger.handlers[0].setFormatter(logging.Formatter("%(name)s: %(message)s"))
profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)

async def main(req: func.HttpRequest) -> func.HttpResponse:
    await get_microsoft_page_async('https://microsoft.com')
    return func.HttpResponse(
        f"Microsoft page loaded.",
        status_code=200
    )

@memory_profiler.profile(stream=profiler_logstream)
async def get_microsoft_page_async(url: str):
    async with aiohttp.ClientSession() as client:
        async with client.get(url) as response:
            await response.text()
    # @memory_profiler.profile does not support return for coroutines.
    # All returns become None in the parent functions.
    # GitHub Issue: https://github.com/pythonprofilers/memory_profiler/issues/289

v2

Nahraďte kód v souboru function_app.py následujícím kódem, který konfiguruje profilování paměti, formát kořenového loggeru a vazbu pro streamování loggeru.

# function_app.py
import azure.functions as func
import logging
import aiohttp
import requests
import memory_profiler

app = func.FunctionApp()

# Update root logger's format to include the logger name. Ensure logs generated
# from memory profiler can be filtered by "memory_profiler_logs" prefix.
root_logger = logging.getLogger()
root_logger.handlers[0].setFormatter(logging.Formatter("%(name)s: %(message)s"))
profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)

@app.function_name(name="HttpTriggerAsync")
@app.route(route="HttpTriggerAsync", auth_level=func.AuthLevel.ANONYMOUS)
async def test_function(req: func.HttpRequest) -> func.HttpResponse:
    await get_microsoft_page_async('https://microsoft.com')
    return func.HttpResponse(f"Microsoft page loaded.")

@memory_profiler.profile(stream=profiler_logstream)
async def get_microsoft_page_async(url: str):
    async with aiohttp.ClientSession() as client:
        async with client.get(url) as response:
            await response.text()
    # @memory_profiler.profile does not support return for coroutines.
    # All returns become None in the parent functions.
    # GitHub Issue: https://github.com/pythonprofilers/memory_profiler/issues/289

Vytvořte synchronní trigger HTTP.

v1

Nahraďte kód v asynchronním triggeru HTTP HttpTriggerSync/__init__.py následujícím kódem.

# HttpTriggerSync/__init__.py

import azure.functions as func
import requests
import logging
import memory_profiler

# Update root logger's format to include the logger name. Ensure logs generated
# from memory profiler can be filtered by "memory_profiler_logs" prefix.
root_logger = logging.getLogger()
root_logger.handlers[0].setFormatter(logging.Formatter("%(name)s: %(message)s"))
profiler_logstream = memory_profiler.LogFile('memory_profiler_logs', True)

def main(req: func.HttpRequest) -> func.HttpResponse:
    content = profile_get_request('https://microsoft.com')
    return func.HttpResponse(
        f"Microsoft page response size: {len(content)}",
        status_code=200
    )

@memory_profiler.profile(stream=profiler_logstream)
def profile_get_request(url: str):
    response = requests.get(url)
    return response.content

v2

Přidejte tento kód do dolní části existujícího souboru function_app.py .

@app.function_name(name="HttpTriggerSync")
@app.route(route="HttpTriggerSync", auth_level=func.AuthLevel.ANONYMOUS)
def test_function(req: func.HttpRequest) -> func.HttpResponse:
    content = profile_get_request('https://microsoft.com')
    return func.HttpResponse(f"Microsoft Page Response Size: {len(content)}")

@memory_profiler.profile(stream=profiler_logstream)
def profile_get_request(url: str):
    response = requests.get(url)
    return response.content

Profilování aplikace funkcí Pythonu v místním vývojovém prostředí

Po provedení výše uvedených změn je několik dalších kroků pro inicializaci virtuálního prostředí Pythonu pro modul runtime Azure Functions.

1. Otevřete prostředí Windows PowerShell nebo libovolné linuxové prostředí podle potřeby.

2. Vytvořte virtuální prostředí Pythonu ve py -m venv .venv Windows nebo python3 -m venv .venv v Linuxu.

3. Aktivujte virtuální prostředí Pythonu v .venv\Scripts\Activate.ps1 prostředí Windows PowerShell nebo source .venv/bin/activate v linuxovém prostředí.

4. Obnovení závislostí Pythonu pomocí pip install -r requirements.txt

5. Místní spuštění modulu runtime Azure Functions pomocí nástrojů Azure Functions Core Tools func host start

6. Odeslat požadavek GET do https://localhost:7071/api/HttpTriggerAsync nebo https://localhost:7071/api/HttpTriggerSync.

7. V nástrojích Azure Functions Core Tools by se měla zobrazit zpráva o profilování paměti podobná následující části.

   Filename: <ProjectRoot>\HttpTriggerAsync\__init__.py
   Line #    Mem usage    Increment  Occurrences   Line Contents
   ============================================================
       19     45.1 MiB     45.1 MiB           1   @memory_profiler.profile
       20                                         async def get_microsoft_page_async(url: str):
       21     45.1 MiB      0.0 MiB           1       async with aiohttp.ClientSession() as client:
       22     46.6 MiB      1.5 MiB          10           async with client.get(url) as response:
       23     47.6 MiB      1.0 MiB           4               await response.text()
   

Další kroky

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

• Azure Functions – Příručka pro vývojáře v Pythonu
• Osvědčené postupy pro službu Azure Functions
• Referenční informace pro vývojáře Azure Functions