Azure Functions Python fejlesztői útmutatóAzure Functions Python developer guide

Ez a cikk bemutatja, hogyan fejlesztheti Azure Functions a Python használatával.This article is an introduction to developing Azure Functions using Python. Az alábbi tartalom azt feltételezi, hogy már elolvasta a Azure functions fejlesztői útmutatót.The content below assumes that you've already read the Azure Functions developers guide.

A Pythonban futó önálló függvények esetében tekintse meg a Python függvények mintáit.For standalone Function sample projects in Python, see the Python Functions samples.

A programozási modellProgramming model

A Azure Functions egy olyan állapot nélküli metódust vár a Python-parancsfájlban, amely feldolgozza a bemenetet, és kimenetet hoz létre.Azure Functions expects a function to be a stateless method in your Python script that processes input and produces output. Alapértelmezés szerint a futtatókörnyezet azt várja, hogy a metódus a fájlban megadott main() __init__.py globális metódusként legyen implementálva.By default, the runtime expects the method to be implemented as a global method called main() in the __init__.py file. Alternatív belépési pontot is megadhat.You can also specify an alternate entry point.

Az eseményindítók és kötések adatai a Function name . JSON fájlban megadott tulajdonság használatával a metódus attribútumain keresztül vannak kötve.Data from triggers and bindings is bound to the function via method attributes using the name property defined in the function.json file. Az alábbi function. JSON például a következő nevű reqHTTP-kérelem által aktivált egyszerű függvényt írja le:For example, the function.json below describes a simple function triggered by an HTTP request named req:

{
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "$return",
      "direction": "out",
      "type": "http"
    }
  ]
}

A __init__.py fájl a következő függvény kódját tartalmazza:The __init__.py file contains the following function code:

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

a függvényben explicit módon deklarálhatja az attribútum típusát és a visszatérési típust is a Python típusú jegyzetek használatával.you can also explicitly declare the attribute types and return type in the function using Python type annotations. Ez segít a számos Python-kód-szerkesztő által biztosított IntelliSense-és automatikus kiegészítési funkciók használatában.This helps you use the intellisense and autocomplete features provided by many Python code editors.

import azure.functions


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

Használja az Azure. functions. * csomagban található Python-megjegyzéseket a bemenetek és kimenetek a metódusokhoz való kötéséhez.Use the Python annotations included in the azure.functions.* package to bind input and outputs to your methods.

Másodlagos belépési pontAlternate entry point

A függvények alapértelmezett viselkedését megváltoztathatja, ha a function. JSON fájlban scriptFile a entryPoint és a tulajdonságokat is megadja.You can change the default behavior of a function by optionally specifying the scriptFile and entryPoint properties in the function.json file. Az alábbi function. JSON például arra utasítja a futtatókörnyezetet, hogy az customentry() Main.py -fájlban lévő metódust használja az Azure-függvény belépési pontjaként.For example, the function.json below tells the runtime to use the customentry() method in the main.py file, as the entry point for your Azure Function.

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

Mappa szerkezeteFolder structure

A Python functions projekthez tartozó mappastruktúrát a következő példához hasonlóan néz ki:The folder structure for a Python Functions project looks like the following example:

 FunctionApp
 | - MyFirstFunction
 | | - __init__.py
 | | - function.json
 | | - example.py
 | - MySecondFunction
 | | - __init__.py
 | | - function.json
 | - SharedCode
 | | - myFirstHelperFunction.py
 | | - mySecondHelperFunction.py
 | - host.json
 | - requirements.txt

Létezik egy megosztott Host. JSON fájl, amely a Function alkalmazás konfigurálására használható.There's a shared host.json file that can be used to configure the function app. Minden függvényhez tartozik a saját kód fájlja és a kötési konfigurációs fájl (function. JSON).Each function has its own code file and binding configuration file (function.json).

A megosztott kódokat külön mappában kell tárolni.Shared code should be kept in a separate folder. A következő szintaxissal hivatkozhat a SharedCode mappában található modulokra:To reference modules in the SharedCode folder, you can use the following syntax:

from __app__.SharedCode import myFirstHelperFunction

A függvények helyi hivatkozásához a relatív importálási szintaxist a következőképpen használhatja:To reference modules local to a function, you can use the relative import syntax as follows:

from . import example

Ha egy Function-projektet telepít az Azure-beli Function alkalmazásba, a FunctionApp mappa teljes tartalmát bele kell foglalni a csomagba, de a mappát nem.When deploying a Function project to your function app in Azure, the entire content of the FunctionApp folder should be included in the package, but not the folder itself.

Eseményindítók és bemenetekTriggers and Inputs

A bemenetek két kategóriára vannak osztva Azure Functions: aktiválja a bemenetet és a további bemenetet.Inputs are divided into two categories in Azure Functions: trigger input and additional input. Bár a fájlban különböznek, function.json a használat megegyezik a Python-kóddal.Although they are different in the function.json file, usage is identical in Python code. Az trigger és a bemeneti források kapcsolódási sztringje vagy titka a local.settings.json fájlban a helyi futtatásakor, valamint az Azure-ban való futtatáskor az alkalmazás beállításainak megfelelően képezhető le.Connection strings or secrets for trigger and input sources map to values in the local.settings.json file when running locally, and the application settings when running in Azure.

A következő kód például a kettő közötti különbséget mutatja be:For example, the following code demonstrates the difference between the two:

// 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": "AzureWebJobsStorage"
    }
  ]
}
// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "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 rendszer a HTTP-kérelmet a következőként továbbítja a reqfüggvénynek:.When the function is invoked, the HTTP request is passed to the function as req. A rendszer beolvas egy bejegyzést az Azure-Blob Storage az útvonal URL -címének azonosítója alapján, és a obj függvény törzsében elérhetővé teszi őket.An entry will be retrieved from the Azure Blob Storage based on the ID in the route URL and made available as obj in the function body. Itt a megadott Storage- AzureWebJobsStorage fiók a függvény alkalmazásban használt tárolási fiók.Here the storage account specified is the connection string found in AzureWebJobsStorage which is the same storage account used by the function app.

KimenetekOutputs

A kimenet a visszatérési értékben és a kimeneti paraméterekben is kifejezhető.Output can be expressed both in return value and output parameters. Ha csak egy kimenet van, javasoljuk, hogy használja a visszatérési értéket.If there's only one output, we recommend using the return value. Több kimenet esetén a kimeneti paramétereket kell használnia.For multiple outputs, you'll have to use output parameters.

Egy függvény visszatérési értékének egy kimeneti kötés name értékeként való használatához a kötés tulajdonságát a $return következő értékre kell beállítani: function.json.To use the return value of a function as the value of an output binding, the name property of the binding should be set to $return in function.json.

Több kimenet létrehozásához használja set() a azure.functions.Out csatoló által biztosított metódust, amellyel egy értéket rendelhet a kötéshez.To produce multiple outputs, use the set() method provided by the azure.functions.Out interface to assign a value to the binding. A következő függvény például leküldheti az üzeneteket egy várólistába, és HTTP-választ is küldhet.For example, the following function can push a message to a queue and also return an HTTP response.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "msg",
      "direction": "out",
      "type": "queue",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    },
    {
      "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

NaplózásLogging

A Azure functions futtatókörnyezet-naplózó hozzáférése a Function alkalmazás logging egyik gyökérszintű kezelőjén keresztül érhető el.Access to the Azure Functions runtime logger is available via a root logging handler in your function app. Ez a naplózó Application Insightshez van kötve, és lehetővé teszi a függvények végrehajtása során észlelt figyelmeztetések és hibák megjelölését.This logger is tied to Application Insights and allows you to flag warnings and errors encountered during the function execution.

Az alábbi példa egy tájékoztató üzenetet naplóz, ha a függvényt HTTP-eseményindítón keresztül hívja meg.The following example logs an info message when the function is invoked via an HTTP trigger.

import logging


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

További naplózási módszerek érhetők el, amelyek lehetővé teszik a konzolra való írást különböző nyomkövetési szinteken:Additional logging methods are available that let you write to the console at different trace levels:

MódszerMethod LeírásDescription
critical(_message_) KRITIKUS szintű üzenetet ír a gyökérszintű naplózó számára.Writes a message with level CRITICAL on the root logger.
error(_message_) A legfelső szintű naplózó üzenetbe írja a Level hibát.Writes a message with level ERROR on the root logger.
warning(_message_) Üzenet írása a root naplózó szintű FIGYELMEZTETÉSsel.Writes a message with level WARNING on the root logger.
info(_message_) A root naplózó szintű adatokat tartalmazó üzenetet ír.Writes a message with level INFO on the root logger.
debug(_message_) Egy szintű HIBAKERESÉSt tartalmazó üzenetet ír a root Logger-ben.Writes a message with level DEBUG on the root logger.

További információ a naplózásról: Azure functions figyelése.To learn more about logging, see Monitor Azure Functions.

HTTP-trigger és-kötésekHTTP Trigger and bindings

A HTTP-trigger a function. Jon fájlban van definiálva.The HTTP trigger is defined in the function.jon file. name A kötésnek meg kell egyeznie a függvény elnevezett paraméterével.The name of the binding must match the named parameter in the function. Az előző példákban egy kötési nevet req használunk.In the previous examples, a binding name req is used. Ez a paraméter egy HttpRequest objektum, és a rendszer egy HttpResponse objektumot ad vissza.This parameter is an HttpRequest object, and an HttpResponse object is returned.

A HttpRequest objektumból lekérheti a kérések fejléceit, a lekérdezési paramétereket, az útvonal paramétereit és az üzenet törzsét.From the HttpRequest object, you can get request headers, query parameters, route parameters, and the message body.

A következő példa a Pythonhoz készült http trigger sablonbólszármazik.The following example is from the HTTP trigger template for Python.

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 rendszer a HttpRequest objektum params paraméterében szerzi be.In this function, the value of the name query parameter is obtained from the params parameter of the HttpRequest object. A JSON-kódolású üzenet törzse a get_json metódus használatával olvasható.The JSON-encoded message body is read using the get_json method.

Hasonlóképpen beállíthatja status_code a és headers a válaszüzenetet is a visszaadott HttpResponse objektumban.Likewise, you can set the status_code and headers for the response message in the returned HttpResponse object.

AszinkronAsync

Javasoljuk, hogy az async def utasítás használatával írja be az Azure-függvényt aszinkronként.We recommend that you write your Azure Function as an asynchronous coroutine using the async def statement.

# Will be run with asyncio directly


async def main():
    await some_nonblocking_socket_io_op()

Ha a Main () függvény szinkron (nincs minősítő), automatikusan futtatja a függvényt egy asyncio szál-készletben.If the main() function is synchronous (no qualifier), we automatically run the function in an asyncio thread-pool.

# Would be run in an asyncio thread-pool


def main():
    some_blocking_socket_io()

KörnyezetContext

Ha egy függvény hívási környezetét szeretné lekérni a végrehajtás során, context adja meg az argumentumot az aláírásában.To get the invocation context of a function during execution, include the context argument in its signature.

Példa:For example:

import azure.functions


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

A környezeti osztály a következő módszerekkel rendelkezik:The Context class has the following methods:

function_directory
Az a címtár, amelyben a függvény fut.The directory in which the function is running.

function_name
A függvény neve.Name of the function.

invocation_id
Az aktuális függvény meghívásának azonosítója.ID of the current function invocation.

Globális változókGlobal variables

Nem garantált, hogy az alkalmazás állapota továbbra is megmarad a jövőbeli végrehajtásokhoz.It is not guaranteed that the state of your app will be preserved for future executions. Azonban a Azure Functions futtatókörnyezet gyakran ugyanazt a folyamatot használja ugyanazon alkalmazás több végrehajtásához.However, the Azure Functions runtime often reuses the same process for multiple executions of the same app. Egy költséges számítás eredményeinek gyorsítótárazásához globális változóként deklarálja.In order to cache the results of an expensive computation, declare it as a global variable.

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ókEnvironment variables

A függvények területen az Alkalmazásbeállítások, például a szolgáltatási kapcsolatok karakterláncai környezeti változókként vannak kitéve a végrehajtás során.In Functions, application settings, such as service connection strings, are exposed as environment variables during execution. Ezek a beállítások deklarálva import os , setting = os.environ["setting-name"]majd a használatával érhetők el.You can access these settings by declaring import os and then using, setting = os.environ["setting-name"].

A következő példa beolvassa az alkalmazás beállításáta nevű myAppSettingkulccsal:The following example gets the application setting, with the key named myAppSetting:

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}')

Helyi fejlesztés esetén az Alkalmazásbeállítások a Local. Settings. JSON fájlban maradnak.For local development, application settings are maintained in the local.settings.json file.

Python-verziók és-csomagok kezelésePython version and package management

Jelenleg a Azure Functions csak a Python 3.6. x (hivatalos CPython-eloszlás) használatát támogatja.Currently, Azure Functions only supports Python 3.6.x (official CPython distribution).

Amikor helyileg fejleszti a Azure functions Core Tools vagy a Visual Studio Code-ot, adja hozzá a szükséges csomagok neveit és requirements.txt verzióit a fájlhoz pip, és telepítse őket a használatával.When developing locally using the Azure Functions Core Tools or Visual Studio Code, add the names and versions of the required packages to the requirements.txt file and install them using pip.

Például az alábbi követelmények fájl és pip parancs használatával telepítheti a requests csomagot a PyPI-ből.For example, the following requirements file and pip command can be used to install the requests package from PyPI.

requests==2.19.1
pip install -r requirements.txt

Közzététel az Azure-banPublishing to Azure

Ha készen áll a közzétételre, győződjön meg arról, hogy az összes függőség szerepel a Project könyvtárának gyökérkönyvtárában található követelmények. txt fájlban.When you're ready to publish, make sure that all your dependencies are listed in the requirements.txt file, which is located at the root of your project directory. A Azure Functions képes távolról felépíteni ezeket a függőségeket.Azure Functions can remotely build these dependencies.

A közzétételből kizárt projektfájlok és mappák, beleértve a virtuális környezet mappáját is, a. funcignore fájlban vannak felsorolva.Project files and folders that are excluded from publishing, including the virtual environment folder, are listed in the .funcignore file.

Az Azure-ba történő üzembe helyezéshez és a távoli buildek elvégzéséhez használja a következő parancsot:To deploy to Azure and perform a remote build, use the following command:

func azure functionapp publish <app name> --build remote

Ha nem használ távoli buildet, és olyan csomagot használ, amely egy fordítót igényel, és nem támogatja számos, a Linux-kompatibilis kerekek PyPI való telepítését, az Azure-ba való helyi létrehozás nélküli közzététel sikertelen lesz a következő hiba miatt:If you're not using remote build, and using a package that requires a compiler and does not support the installation of many Linux-compatible wheels from PyPI, publishing to Azure without building locally will fail with the following error:

There was an error restoring dependencies.ERROR: cannot install <package name - version> dependency: binary dependencies without wheels are not supported.  
The terminal process terminated with exit code: 1

Ha helyileg szeretné kiépíteni és konfigurálni a szükséges bináris fájlokat, telepítse a Docker -t a helyi gépre, és futtassa a következő parancsot a Azure functions Core Tools (a) használatával történő közzétételhez.To build locally and configure the required binaries, install Docker on your local machine and run the following command to publish using the Azure Functions Core Tools (func). Ne felejtse <app name> el lecserélni a Function alkalmazás nevét az Azure-ban.Remember to replace <app name> with the name of your function app in Azure.

func azure functionapp publish <app name> --build-native-deps

A borítók alatt a központi eszközök a Docker használatával futtatják a MCR.microsoft.com/Azure-functions/Python -rendszerképet a helyi gépen lévő tárolóként.Underneath the covers, Core Tools will use docker to run the mcr.microsoft.com/azure-functions/python image as a container on your local machine. Ezzel a környezettel az Azure-ba történő végső üzembe helyezés előtt felépíti és telepíti a szükséges modulokat a forrás-elosztásból.Using this environment, it will then build and install the required modules from source distribution, before packaging them up for final deployment to Azure.

A függőségek létrehozásához és a folyamatos kézbesítés (CD) rendszer használatával történő közzétételhez használja az Azure-folyamatokat.To build your dependencies and publish using a continuous delivery (CD) system, use Azure Pipelines.

Egység teszteléseUnit Testing

A Pythonban írt függvények a standard szintű tesztelési keretrendszerek használatával más Python-kódokhoz hasonlóan is vizsgálhatók.Functions written in Python can be tested like other Python code using standard testing frameworks. A legtöbb kötés esetében lehetséges, hogy létrehoz egy modell típusú bemeneti objektumot úgy, hogy létrehoz egy megfelelő osztály egy példányát a azure.functions csomagból.For most bindings, it's possible to create a mock input object by creating an instance of an appropriate class from the azure.functions package. Mivel a azure.functions csomag nem érhető el azonnal, ne felejtse el telepíteni a requirements.txt fájlon keresztül, a fenti Python-verzió és csomag kezelése részben leírtak szerint.Since the azure.functions package is not immediately available, be sure to install it via your requirements.txt file as described in Python version and package management section above.

Például a következő egy HTTP által aktivált függvény mintájának tesztelése:For example, following is a mock test of an HTTP triggered function:

{
  "scriptFile": "httpfunc.py",
  "entryPoint": "my_function",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}
# myapp/httpfunc.py
import azure.functions as func
import logging

def my_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}")
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             status_code=400
        )
# myapp/test_httpfunc.py
import unittest

import azure.functions as func
from httpfunc import my_function


class TestFunction(unittest.TestCase):
    def test_my_function(self):
        # Construct a mock HTTP request.
        req = func.HttpRequest(
            method='GET',
            body=None,
            url='/api/HttpTrigger',
            params={'name': 'Test'})

        # Call the function.
        resp = my_function(req)

        # Check the output.
        self.assertEqual(
            resp.get_body(),
            b'Hello Test',
        )

Íme egy másik példa, amely egy üzenetsor által aktivált függvényt mutat be:Here is another example, with a queue triggered function:

# myapp/__init__.py
import azure.functions as func


def my_function(msg: func.QueueMessage) -> str:
    return f'msg body: {msg.get_body().decode()}'
# myapp/test_func.py
import unittest

import azure.functions as func
from . import my_function


class TestFunction(unittest.TestCase):
    def test_my_function(self):
        # Construct a mock Queue message.
        req = func.QueueMessage(
            body=b'test')

        # Call the function.
        resp = my_function(req)

        # Check the output.
        self.assertEqual(
            resp,
            'msg body: test',
        )

Ismert problémák és gyakori kérdésekKnown issues and FAQ

Az összes ismert probléma és szolgáltatás kérését a GitHub-problémák listája követheti nyomon.All known issues and feature requests are tracked using GitHub issues list. Ha probléma lép fel, és a GitHubon nem találja a problémát, nyisson meg egy új problémát, és adja meg a probléma részletes leírását.If you run into a problem and can't find the issue in GitHub, open a new issue and include a detailed description of the problem.

Eltérő eredetű erőforrások megosztásaCross-origin resource sharing

A Azure Functions támogatja a több eredetű erőforrás-megosztást (CORS).Azure Functions supports cross-origin resource sharing (CORS). A CORS a portálon és az Azure CLI-n keresztül van konfigurálva.CORS is configured in the portal and through the Azure CLI. A CORS engedélyezett Origins listája a függvény alkalmazás szintjén érvényes.The CORS allowed origins list applies at the function app level. Ha a CORS engedélyezve van, a Access-Control-Allow-Origin válaszok tartalmazzák a fejlécet.With CORS enabled, responses include the Access-Control-Allow-Origin header. További információ: Eltérő eredetű erőforrás-megosztásFor more information, see Cross-origin resource sharing.

Az engedélyezett Origins lista jelenleg nem támogatott a Python-függvények alkalmazásaiban.The allowed origins list isn't currently supported for Python function apps. Ennek a korlátozásnak a miatt a http-függvények Access-Control-Allow-Origin fejlécét kifejezetten be kell állítania az alábbi példában látható módon:Because of this limitation, you must expressly set the Access-Control-Allow-Origin header in your HTTP functions, as shown in the following example:

def main(req: func.HttpRequest) -> func.HttpResponse:

    # Define the allow origin headers.
    headers = {"Access-Control-Allow-Origin": "https://contoso.com"}

    # Set the headers in the response.
    return func.HttpResponse(
            f"Allowed origin '{headers}'.",
            headers=headers, status_code=200
    )

Győződjön meg arról, hogy a function. JSON fájlt is frissíti a beállítások HTTP-metódusának támogatásához:Make sure that you also update your function.json to support the OPTIONS HTTP method:

    ...
      "methods": [
        "get",
        "post",
        "options"
      ]
    ...

Ezt a módszert a Chrome böngésző használja az engedélyezett Origins lista egyeztetéséhez.This method is used by the Chrome browser to negotiate the allowed origins list.

További lépésekNext steps

További információkért lásd a következőket:For more information, see the following resources: