Python-Entwicklerhandbuch für Azure FunctionsAzure Functions Python developer guide

Dieser Artikel ist eine Einführung in die Entwicklung von Azure Functions mithilfe von Python.This article is an introduction to developing Azure Functions using Python. Der folgende Inhalt geht davon aus, dass Sie das Azure Functions: Entwicklerhandbuch bereits gelesen haben.The content below assumes that you've already read the Azure Functions developers guide.

Informationen zu eigenständigen Functions-Beispielprojekten in Python finden Sie in den Functions-Beispielen für Python.For standalone Function sample projects in Python, see the Python Functions samples.

ProgrammiermodellProgramming model

Azure Functions geht davon aus, dass eine Funktion eine zustandslose Methode in Ihrem Python-Skript ist, die Eingaben verarbeitet und Ausgaben erzeugt.Azure Functions expects a function to be a stateless method in your Python script that processes input and produces output. Standardmäßig erwartet die Runtime, dass die Methode als globale Methode namens main() in der __init__.py-Datei implementiert ist.By default, the runtime expects the method to be implemented as a global method called main() in the __init__.py file. Sie können auch einen alternativen Einstiegspunkt angeben.You can also specify an alternate entry point.

Daten von Triggern und Bindungen werden mittels Methodenattributen an die Funktion gebunden, die die in der Konfigurationsdatei function.json definierte Eigenschaft name verwenden.Data from triggers and bindings is bound to the function via method attributes using the name property defined in the function.json file. Beispielsweise beschreibt die unten stehende function.json eine einfache Funktion, die von einer HTTP-Anforderung namens req ausgelöst wird: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"
    }
  ]
}

Die Datei __init__.py enthält folgenden Funktionscode:The __init__.py file contains the following function code:

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

Sie können auch Python-Typanmerkungen verwenden, um die Attributtypen und den Rückgabetyp in der Funktion explizit zu deklarieren.you can also explicitly declare the attribute types and return type in the function using Python type annotations. Auf diese Weise können Sie die IntelliSense-und AutoVervollständigen-Funktionen nutzen, die von vielen Python-Code-Editoren bereitgestellt werden.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}!'

Verwenden Sie die Python-Anmerkungen im Paket azure.functions.*, um Eingaben und Ausgaben an Ihre Methoden zu binden.Use the Python annotations included in the azure.functions.* package to bind input and outputs to your methods.

Alternativer EinstiegspunktAlternate entry point

Sie können das Standardverhalten einer Funktion ändern, indem Sie die Eigenschaften scriptFile und entryPoint in der function.json-Datei angeben.You can change the default behavior of a function by optionally specifying the scriptFile and entryPoint properties in the function.json file. Beispielsweise weist die unten stehende function.json die Runtime an, die Methode customentry() in der main.py-Datei als Einstiegspunkt für Ihre Azure-Funktion zu verwenden.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": [
      ...
  ]
}

OrdnerstrukturFolder structure

Die Ordnerstruktur für ein Python Functions-Projekt sieht wie im folgenden Beispiel aus: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

Sie können die freigegebene Datei host.json zum Konfigurieren der Funktions-App verwenden.There's a shared host.json file that can be used to configure the function app. Jede Funktion verfügt über eine eigene Codedatei sowie über eine eigene Bindungskonfigurationsdatei (function.json).Each function has its own code file and binding configuration file (function.json).

Freigegebener Code sollte in einem separaten Ordner gespeichert werden.Shared code should be kept in a separate folder. Um auf Module im Ordner „SharedCode“ zu verweisen, können Sie die folgende Syntax verwenden:To reference modules in the SharedCode folder, you can use the following syntax:

from __app__.SharedCode import myFirstHelperFunction

Um auf Module zu verweisen, die lokal für eine Funktion sind, können Sie die relative Importsyntax wie folgt verwenden:To reference modules local to a function, you can use the relative import syntax as follows:

from . import example

Wenn Sie ein Functions-Projekt in Ihrer Funktions-App in Azure bereitstellen, sollte der gesamte Inhalt des Ordners FunctionApp in das Paket aufgenommen werden, jedoch nicht der Ordner selbst.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.

Trigger und EingabenTriggers and Inputs

Eingaben werden in Azure Functions in zwei Kategorien unterteilt: Triggereingaben und zusätzliche Eingaben.Inputs are divided into two categories in Azure Functions: trigger input and additional input. Obwohl sie sich in der Datei function.json unterscheiden, ist ihre Verwendung im Python-Code identisch.Although they are different in the function.json file, usage is identical in Python code. Verbindungszeichenfolgen oder Geheimnisse für Trigger- und Eingabequellen werden bei lokaler Ausführung Werten in der Datei local.settings.json und bei der Ausführung in Azure den Anwendungseinstellungen zugeordnet.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.

Im folgenden Code wird beispielsweise der Unterschied zwischen beiden dargestellt: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()}')

Bei Aufruf der Funktion wird die HTTP-Anforderung als req an die Funktion übergeben.When the function is invoked, the HTTP request is passed to the function as req. Es wird ein Eintrag, der auf der ID in der Routen-URL basiert, aus Azure Blob Storage abgerufen und als obj im Funktionstext verfügbar gemacht.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. Hier ist das angegebene Speicherkonto die Verbindungszeichenfolge für dasselbe Speicherkonto, das von der Funktions-App verwendet wird.Here the storage account specified is the connection string found in , which is the same storage account used by the function app.

AusgabenOutputs

Ausgaben können sowohl im Rückgabewert als auch in Ausgabeparametern angegeben werden.Output can be expressed both in return value and output parameters. Wenn es nur eine Ausgabe gibt, empfehlen wir, den Rückgabewert zu verwenden.If there's only one output, we recommend using the return value. Bei mehreren Ausgaben müssen Sie Ausgabeparameter verwenden.For multiple outputs, you'll have to use output parameters.

Um den Rückgabewert einer Funktion als Wert für eine Ausgabebindung zu verwenden, sollte die name-Eigenschaft der Bindung in function.json auf $return festgelegt werden.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.

Um mehrere Ausgaben zu erzeugen, verwenden Sie die set()-Methode, die von der azure.functions.Out-Schnittstelle bereitgestellt wird, um der Bindung einen Wert zuzuweisen.To produce multiple outputs, use the set() method provided by the azure.functions.Out interface to assign a value to the binding. Die folgende Funktion kann z. B. mithilfe von Push eine Nachricht an eine Warteschlange übertragen und auch eine HTTP-Antwort zurückgeben.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

ProtokollierungLogging

Zugriff auf die Azure Functions-Runtimeprotokollierung ist über einen Stamm-logging-Handler in Ihrer Funktions-App verfügbar.Access to the Azure Functions runtime logger is available via a root logging handler in your function app. Diese Protokollierung ist an Application Insights gebunden und ermöglicht es Ihnen, während der Funktionsausführung aufgetretene Warnungen und Fehler zu kennzeichnen.This logger is tied to Application Insights and allows you to flag warnings and errors encountered during the function execution.

Im folgenden Beispiel wird eine Informationsmeldung protokolliert, wenn die Funktion über einen HTTP-Trigger aufgerufen wird.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.')

Es sind zusätzliche Protokollierungsmethoden verfügbar, mit denen Sie auf anderen Ablaufverfolgungsebenen in die Konsole schreiben können:Additional logging methods are available that let you write to the console at different trace levels:

MethodeMethod BESCHREIBUNGDescription
critical(_message_) Schreibt eine Meldung mit der Stufe KRITISCH in die Stammprotokollierung.Writes a message with level CRITICAL on the root logger.
error(_message_) Schreibt eine Meldung mit der Stufe ERROR in die Stammprotokollierung.Writes a message with level ERROR on the root logger.
warning(_message_) Schreibt eine Meldung mit der Stufe WARNUNG in die Stammprotokollierung.Writes a message with level WARNING on the root logger.
info(_message_) Schreibt eine Meldung mit der Stufe INFO in die Stammprotokollierung.Writes a message with level INFO on the root logger.
debug(_message_) Schreibt eine Meldung mit der Stufe DEBUG in die Stammprotokollierung.Writes a message with level DEBUG on the root logger.

Weitere Informationen über Protokollierung finden Sie unter Überwachen von Azure Functions.To learn more about logging, see Monitor Azure Functions.

HTTP-Trigger und -BindungenHTTP Trigger and bindings

Der HTTP-Trigger ist in der Datei „function.jon“ definiert.The HTTP trigger is defined in the function.jon file. Der name der Bindung muss mit dem benannten Parameter in der Funktion identisch sein.The name of the binding must match the named parameter in the function. In den vorherigen Beispielen wird der Bindungsname req verwendet.In the previous examples, a binding name req is used. Dieser Parameter ist ein HttpRequest-Objekt, und es wird ein HttpResponse-Objekt zurückgegeben.This parameter is an HttpRequest object, and an HttpResponse object is returned.

Aus dem HttpRequest-Objekt können Sie Anforderungsheader, Abfrageparameter, Routenparameter und den Nachrichtentext extrahieren.From the HttpRequest object, you can get request headers, query parameters, route parameters, and the message body.

Das folgende Beispiel stammt aus der HTTP-Trigger-Vorlage für Python.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
        )

In dieser Funktion wird der Wert des name-Abfrageparameters aus dem params-Parameter des HttpRequest-Objekts ermittelt.In this function, the value of the name query parameter is obtained from the params parameter of the HttpRequest object. Der JSON-codierte Nachrichtentext wird mit der get_json-Methode gelesen.The JSON-encoded message body is read using the get_json method.

Außerdem können Sie status_code und headers für die Antwortnachricht im zurückgegebenen HttpResponse-Objekt festlegen.Likewise, you can set the status_code and headers for the response message in the returned HttpResponse object.

ParallelitätConcurrency

Standardmäßig kann die Python-Runtime von Functions nur einen Aufruf einer Funktion zu einem Zeitpunkt verarbeiten.By default, the Functions Python runtime can only process one invocation of a function at a time. Dieser Grad an Parallelität ist in den folgenden Situationen jedoch u. U. nicht ausreichend:This concurrency level might not be sufficient under one or more of the following conditions:

  • Sie versuchen, eine große Anzahl von Aufrufen gleichzeitig zu verarbeiten.You're trying to handle a number of invocations being made at the same time.
  • Sie verarbeiten eine große Anzahl von E/A-Ereignissen.You're processing a large number of I/O events.
  • Ihre Anwendung ist E/A-gebunden.Your application is I/O bound.

In diesen Fällen können Sie die Leistung durch asynchrones Ausführen und Verwenden von mehreren Sprachworkerprozessen verbessern.In these situations, you can improve performance by running asynchronously and by using multiple language worker processes.

AsyncAsync

Es wird empfohlen, dass Sie mit der async def-Anweisung die Ausführung der Funktion als asynchrone Coroutine festlegen.We recommend that you use the async def statement to make your function run as an asynchronous coroutine.

# Runs with asyncio directly

async def main():
    await some_nonblocking_socket_io_op()

Wenn die main()-Funktion synchron ist (ohne den async-Qualifizierer), wird die Funktion automatisch in einem asyncio-Threadpool ausgeführt.When the main() function is synchronous (without the async qualifier), the function is automatically run in an asyncio thread-pool.

# Runs in an asyncio thread-pool

def main():
    some_blocking_socket_io()

Verwenden mehrerer SprachworkerprozesseUse multiple language worker processes

Standardmäßig verfügt jede Functions-Hostinstanz über einen einzigen Sprachworkerprozess.By default, every Functions host instance has a single language worker process. Mehrere Sprachworkerprozesse pro Hostinstanz werden jedoch unterstützt.However there's support to have multiple language worker processes per host instance. Funktionsaufrufe werden dann gleichmäßig auf diese Sprachworkerprozesse verteilt.Function invocations can then be evenly distributed among these language worker processes. Ändern Sie diesen Wert mithilfe der Anwendungseinstellung FUNCTIONS_WORKER_PROCESS_COUNT.Use the FUNCTIONS_WORKER_PROCESS_COUNT application setting to change this value.

KontextContext

Um den Aufrufkontext einer Funktion während der Ausführung abzurufen, nehmen Sie das context-Argument in ihre Signatur auf.To get the invocation context of a function during execution, include the context argument in its signature.

Beispiel:For example:

import azure.functions


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

Die Context-Klasse weist die folgenden Zeichenfolgenattribute auf:The Context class has the following string attributes:

function_directory
Das Verzeichnis, in dem die Funktion ausgeführt wird.The directory in which the function is running.

function_name
Name der Funktion.Name of the function.

invocation_id
ID des aktuellen Funktionsaufrufs.ID of the current function invocation.

Globale VariablenGlobal variables

Es besteht keine Garantie, dass der Status Ihrer App für zukünftige Ausführungen beibehalten wird.It is not guaranteed that the state of your app will be preserved for future executions. Jedoch verwendet die Azure Functions-Runtime oft wieder den gleichen Prozess für mehrere Ausführungen derselben App.However, the Azure Functions runtime often reuses the same process for multiple executions of the same app. Zum Zwischenspeichern der Ergebnisse einer teuren Berechnung deklarieren Sie diese als globale Variable.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

UmgebungsvariablenEnvironment variables

In Functions werden Anwendungseinstellung, z.B. Dienstverbindungszeichenfolgen, während der Ausführung als Umgebungsvariablen verfügbar gemacht.In Functions, application settings, such as service connection strings, are exposed as environment variables during execution. Sie können auf diese Einstellungen zugreifen, indem Sie import os deklarieren und dann setting = os.environ["setting-name"] verwenden.You can access these settings by declaring import os and then using, setting = os.environ["setting-name"].

Im folgenden Beispiel wird die Anwendungseinstellung mit dem Schlüssel myAppSetting ermittelt: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}')

Für die lokale Entwicklung werden Anwendungseinstellungen in der Datei „local.settings.json“ verwaltet.For local development, application settings are maintained in the local.settings.json file.

Python-Version und PaketverwaltungPython version and package management

Zurzeit unterstützt Azure Functions nur Python 3.6.x (offizielle CPython-Verteilung).Currently, Azure Functions only supports Python 3.6.x (official CPython distribution).

Bei der lokalen Entwicklung mithilfe der Azure Functions Core Tools oder von Visual Studio Code fügen Sie die Namen und Versionen der erforderlichen Pakete in der requirements.txt-Datei hinzu, und installieren Sie sie mithilfe von pip.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.

Beispielsweise können die folgende Datei mit Anforderungen und der pip-Befehl verwendet werden, um das requests-Paket aus PyPI zu installieren.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

Veröffentlichen in AzurePublishing to Azure

Wenn Sie zur Veröffentlichung bereit sind, stellen Sie sicher, dass alle Ihre Abhängigkeiten in der Datei requirements.txt aufgeführt sind, die sich im Stamm Ihres Projektverzeichnisses befindet.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. Azure Functions kann diese Abhängigkeiten remote erstellen.Azure Functions can remotely build these dependencies.

Projektdateien und -ordner, die von der Veröffentlichung ausgeschlossen sind, einschließlich des Ordners der virtuellen Umgebung, werden in der .funcignore-Datei aufgelistet.Project files and folders that are excluded from publishing, including the virtual environment folder, are listed in the .funcignore file.

Für die Bereitstellung in Azure und zur Ausführung einer Remoteerstellung verwenden Sie den folgenden Befehl:To deploy to Azure and perform a remote build, use the following command:

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

Wenn Sie keine Remoteerstellung verwenden und ein Paket verwenden, das einen Compiler erfordert und nicht die Installation von manylinux-kompatiblen Wheels aus PyPI unterstützt, schlägt die Veröffentlichung in Azure ohne lokale Erstellung mit folgendem Fehler fehl: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

Um die erforderlichen Binärdateien lokal zu erstellen und diese zu konfigurieren, installieren Sie Docker auf Ihrem lokalen Computer, und führen Sie den folgenden Befehl aus, um mithilfe der Azure Functions Core Tools (func) zu veröffentlichen.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). Denken Sie daran, <app name> durch den Namen Ihrer Funktions-App in Azure zu ersetzen.Remember to replace <app name> with the name of your function app in Azure.

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

Im Hintergrund verwenden die Core Tools Docker, um das mcr.microsoft.com/azure-functions/python-Image als Container auf Ihrem lokalen Computer auszuführen.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. Unter Verwendung diese Umgebung werden dann die erforderlichen Module aus der Quellverteilung erstellt und installiert, bevor sie zur endgültigen Bereitstellung in Azure gepackt werden.Using this environment, it will then build and install the required modules from source distribution, before packaging them up for final deployment to Azure.

Verwenden Sie Azure-Pipelines, um Ihre Abhängigkeiten zu erstellen und mithilfe eines Continuous Delivery-Systems zu veröffentlichen.To build your dependencies and publish using a continuous delivery (CD) system, use Azure Pipelines.

KomponententestsUnit Testing

In Python geschriebene Funktionen können wie anderer Python-Code mithilfe von Standardtestframeworks getestet werden.Functions written in Python can be tested like other Python code using standard testing frameworks. Bei den meisten Bindungen können Sie ein Pseudoeingabeobjekt erstellen, indem Sie eine Instanz einer geeigneten Klasse aus dem azure.functions-Paket erstellen.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. Da das azure.functions-Paket nicht sofort verfügbar ist, müssen Sie es über Ihre Datei requirements.txt installieren. Die Vorgehensweise wird oben im Abschnitt Python-Version und Paketverwaltung beschrieben.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.

Beim Folgenden handelt es sich beispielsweise um einen Pseudotest einer durch HTTP ausgelösten Funktion: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',
        )

Im Folgenden finden Sie ein weiteres Beispiel mit einer durch eine Warteschlange ausgelösten Funktion: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',
        )

Bekannte Probleme und FAQKnown issues and FAQ

Alle bekannten Probleme und Funktionsanfragen werden mithilfe der GitHub-Problemeliste nachverfolgt.All known issues and feature requests are tracked using GitHub issues list. Wenn Sie auf ein Problem stoßen, das in GitHub nicht zu finden ist, öffnen Sie ein neues Problem mit einer ausführlichen Problembeschreibung.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.

Cross-Origin Resource SharingCross-origin resource sharing

Azure Functions unterstützt jetzt die Ressourcenfreigabe zwischen verschiedenen Ursprüngen (Cross-Origin Resource Sharing, CORS).Azure Functions supports cross-origin resource sharing (CORS). CORS wird im Portal und über die Azure-Befehlszeilenschnittstelle konfiguriert.CORS is configured in the portal and through the Azure CLI. Die CORS-Liste der zulässigen Ursprünge gilt auf Funktions-App-Ebene.The CORS allowed origins list applies at the function app level. Wenn CORS aktiviert ist, enthalten Antworten den Access-Control-Allow-Origin-Header.With CORS enabled, responses include the Access-Control-Allow-Origin header. Weitere Informationen finden Sie unter Cross-Origin Resource Sharing (CORS).For more information, see Cross-origin resource sharing.

Die Liste der zulässigen Ursprünge wird für Python-Funktions-Apps derzeit nicht unterstützt.The allowed origins list isn't currently supported for Python function apps. Wegen dieser Einschränkung müssen Sie den Access-Control-Allow-Origin-Header in Ihren HTTP-Funktionen explizit festlegen, wie dies im folgenden Beispiel gezeigt ist: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
    )

Sie dürfen nicht vergessen, Ihre „function.json“-Datei so zu aktualisieren, dass sie die HTTP-Methode OPTIONS unterstützt:Make sure that you also update your function.json to support the OPTIONS HTTP method:

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

Diese Methode wird vom Chrome-Browser verwendet, um die Liste der zulässigen Ursprünge auszuhandeln.This method is used by the Chrome browser to negotiate the allowed origins list.

Nächste SchritteNext steps

Weitere Informationen finden Sie in den folgenden Ressourcen:For more information, see the following resources: