Referenzhandbuch für Azure Functions-Entwickler für Python-Apps

Azure Functions ist ein serverloser Computedienst, mit dem Sie ereignisgesteuerten Code ohne Bereitstellung oder Verwaltung der Infrastruktur ausführen können. Funktionsausführungen werden durch Ereignisse wie HTTP-Anforderungen, Warteschlangenmeldungen, Zeitgeber oder Änderungen am Speicher ausgelöst und automatisch basierend auf Bedarf skaliert.

Dieser Leitfaden konzentriert sich speziell auf das Erstellen von Python-basierten Azure-Funktionen und hilft Ihnen dabei:

Lokales Erstellen und Ausführen von Funktions-Apps
Grundlegendes zum Python-Programmiermodell
Organisieren und Konfigurieren Ihrer Anwendung
Bereitstellen und Überwachen Ihrer App in Azure
Anwenden bewährter Methoden für Skalierung und Leistung

Suchen Sie nach einer konzeptionellen Übersicht? Weitere Informationen finden Sie in der Entwicklerreferenz zu Azure Functions.

Interessieren Sie sich für reale Anwendungsfälle? Erkunden Sie die Seite "Szenarien und Beispiele ".

Erste Schritte

Wählen Sie die Umgebung aus, die Ihrem Workflow entspricht, und springen Sie zu Azure Functions für Python:

Erstellen Ihrer Funktions-App

In diesem Abschnitt werden die wesentlichen Komponenten zum Erstellen und Strukturieren Ihrer Python-Funktions-App behandelt. Zu den Themen gehören das Programmiermodell, die Projektstruktur, Trigger und Bindungen sowie das Abhängigkeitsmanagement.

Programmiermodell

Funktionen unterstützen zwei Versionen des Python-Programmiermodells:

Version	BESCHREIBUNG
2.x	Verwenden Sie einen dekoratorbasierten Ansatz, um Trigger und Bindungen direkt in Ihrer Python-Code-Datei zu definieren. Sie implementieren jede Funktion als globale, zustandslose Methode in einer `function_app.py` Datei oder in einer referenzierten Blueprintdatei. Diese Modellversion wird für neue Python-Apps empfohlen.
1.x	Sie definieren Trigger und Bindungen für jede Funktion in einer separaten `function.json` Datei. Sie implementieren jede Funktion als globale, zustandslose Methode in Ihrer Python-Codedatei. Diese Version des Modells unterstützt Legacy-Apps.

Dieser Artikel zielt auf eine bestimmte Python-Modellversion ab. Wählen Sie oben im Artikel Ihre gewünschte Version aus.

Wichtig

Verwenden Sie das v2-Programmiermodell für einen Dekorateur-basierten Ansatz , um Trigger und Bindungen direkt in Ihrem Code zu definieren.

Im Python v1-Programmiermodell wird jede Funktion als globale, zustandslose main() Methode innerhalb einer Datei mit dem Namen __init__.pydefiniert. Die Trigger und Bindungen der Funktion werden separat in einer function.json Datei konfiguriert, und die Bindungswerte name werden als Parameter in Ihrer main() Methode verwendet.

Beispiel

Hier ist eine einfache Funktion, die auf eine HTTP-Anforderung antwortet:

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

Dies ist die entsprechende function.json Datei:

{
    "scriptFile": "__init__.py",
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "type": "http",
            "direction": "out",
            "name": "$return"
        }
    ]
}

Wichtige Begriffe

Die Funktion verfügt über einen einzelnen HTTP-Trigger.
Das HttpRequest-Objekt enthält Anforderungsheader, Abfrageparameter, Routenparameter und den Nachrichtentext. Diese Funktion ruft den Wert des name Abfrageparameters aus dem params Parameter des HttpRequest-Objekts ab.
Um in diesem Beispiel einen Namen zu senden, fügen Sie ?name={name} an die URL der verfügbar gemachten Funktion an. Beispielsweise könnte die vollständige URL, wenn sie lokal ausgeführt wird, so aussehen: http://localhost:7071/api/http_trigger?name=Test. Beispiele für Bindungen finden Sie unter Trigger und Bindungen.

Verwenden Sie das azure-functions SDK, und fügen Sie Typanmerkungen ein, um die Unterstützung von IntelliSense und Editoren zu verbessern:

# __init__.py
import azure.functions as func

def http_trigger(req: func.HttpRequest) -> str:

# requirements.txt
azure-functions

Die `azure-functions` Bibliothek

Die azure-functions Python-Bibliothek stellt die Kerntypen bereit, die für die Interaktion mit der Azure Functions-Laufzeit verwendet werden. Um alle verfügbaren Typen und Methoden anzuzeigen, besuchen Sie die azure-functions API. Ihr Funktionscode kann azure-functions verwenden, um:

Zugangstrigger-Eingabedaten (z. B. HttpRequest, TimerRequest)
Erstellen von Ausgabewerten (z. B HttpResponse. )
Interagiere mit von der Laufzeit bereitgestellten Kontext- und Bindungsdaten

Wenn Sie azure-functions in Ihrer App verwenden, muss es in Ihre Projektabhängigkeiten einbezogen werden.

Hinweis

Die azure-functions Bibliothek definiert die Programmieroberfläche für Python Azure Functions, ist aber kein allgemeines SDK. Verwenden Sie sie speziell zum Erstellen und Ausführen von Funktionen innerhalb der Azure Functions-Laufzeit.

Alternativer Einstiegspunkt

Sie können das Standardverhalten einer Funktion ändern, indem Sie die Eigenschaften scriptFile und entryPoint in der function.json-Datei angeben. Beispielsweise weist die folgende function.json-Datei die Laufzeitumgebung an, die custom_entry()-Methode in der main.py-Datei als Einstiegspunkt für Ihre Azure-Funktion zu verwenden.

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

Ordnerstruktur

Verwenden Sie die folgende Struktur für ein Python Azure Functions-Projekt:

<project_root>/
│
├── .venv/                   # (Optional) Local Python virtual environment
├── .vscode/                 # (Optional) VS Code workspace settings
│
├── my_first_function/       # Function directory
│   └── __init__.py          # Function code file
│   └── function.json        # Function binding configuration file
│
├── my_second_function/
│   └── __init__.py  
│   └── function.json 
│
├── shared/                  # (Optional) Pure helper code with no triggers/bindings
│   └── utils.py
│
├── additional_functions/    # (Optional) Contains blueprints for organizing related Functions
│   └── blueprint_1.py  
│
├── tests/                   # (Optional) Unit tests for your functions
│   └── test_my_function.py
│
├── .funcignore              # Excludes files from being published
├── host.json                # Global function app configuration
├── local.settings.json      # Local-only app settings (not published)
├── requirements.txt         # (Optional) Defines Python dependencies for remote build
├── Dockerfile               # (Optional) For custom container deployment

Schlüsseldateien und Ordner

Datei/ Ordner	BESCHREIBUNG	Erforderlich, damit die App in Azure ausgeführt werden kann
`my_first_function/`	Verzeichnis für eine einzelne Funktion.	✅
`__init__.py/`	Hauptskript, in dem der `my_first_function` Funktionscode definiert ist.	✅
`function.json/`	Enthält die Bindungskonfiguration für die `my_first_function` Funktion.	✅
`host.json`	Globale Konfiguration für alle Funktionen in der App.	✅
`requirements.txt`	Python-Abhängigkeiten, die während der Veröffentlichung bei Verwendung des Remotebuilds installiert wurden.	❌ (empfohlen für die Paketverwaltung)
`local.settings.json`	Nur lokale App-Einstellungen und geheime Schlüssel (nie veröffentlicht).	❌ (erforderlich für die lokale Entwicklung)
`.funcignore`	Gibt Dateien und Ordner an, die von der Bereitstellung ausgeschlossen werden sollen (z. B. `.venv/`, `tests/`, `local.settings.json`).	❌ (recommended)
`.venv/`	Lokale virtuelle Umgebung für Python (von der Bereitstellung ausgeschlossen).	❌
`.vscode/`	Editorkonfiguration für Visual Studio Code. Für die Bereitstellung nicht erforderlich.	❌
`shared/`	Enthält Hilfscode, der für das Funktions-App-Projekt freigegeben ist.	❌
`additional_functions/`	Wird für die modulare Codeorganisation verwendet, in der Regel mit Blueprints.	❌
`tests/`	Komponententests für Ihre Funktions-App. Nicht in Azure veröffentlicht.	❌
`Dockerfile`	Definiert einen benutzerdefinierten Container für die Bereitstellung.	❌

Im Python v2-Programmiermodell verwendet Azure Functions einen dekoratorenbasierten Ansatz, um Trigger und Bindungen direkt in Ihrem Code zu definieren. Jede Funktion wird als globale, zustandslose Methode in einer function_app.py Datei implementiert.

Beispiel

Hier ist eine einfache Funktion, die auf eine HTTP-Anforderung antwortet:

import azure.functions as func

app = func.FunctionApp()

@app.route("hello")
def http_trigger(req):
    user = req.params.get("user")
    return f"Hello, {user}!"

# requirements.txt
azure-functions

Wichtige Begriffe

Der Code importiert das azure-functions Paket und verwendet Dekoratoren und Typen, um die Funktions-App zu definieren.
Die Funktion verfügt über einen einzelnen HTTP-Trigger.
Das HttpRequest-Objekt enthält Anforderungsheader, Abfrageparameter, Routenparameter und den Nachrichtentext. Diese Funktion ruft den Wert des name Abfrageparameters aus dem params Parameter des HttpRequest-Objekts ab.
Um in diesem Beispiel einen Namen zu senden, fügen Sie ?name={name} an die URL der verfügbar gemachten Funktion an. Beispielsweise könnte die vollständige URL, wenn sie lokal ausgeführt wird, so aussehen: http://localhost:7071/api/http_trigger?name=Test. Beispiele für Bindungen finden Sie unter Trigger und Bindungen.

Die `azure-functions` Bibliothek

Die azure-functions Python-Bibliothek ist ein Kernteil des Azure Functions-Programmiermodells. Es stellt die Dekoratoren, Trigger- und Bindungstypen sowie Anforderungs-/Antwortobjekte bereit, die zum Definieren und Interagieren mit Funktionen zur Laufzeit verwendet werden. Um alle verfügbaren Typen und Dekoratoren anzuzeigen, besuchen Sie die azure-functions API. Ihr Funktions-App-Code hängt von dieser Bibliothek ab:

Definieren aller Funktionen mithilfe des FunctionApp Objekts
Deklaration von Triggern und Bindungen (z. B. @app.route, @app.timer_trigger)
Zugriff auf getippte Eingaben und Ausgaben (z. B. HttpRequest und HttpResponse und Out`)

Das azure-functions muss in Ihre Projektabhängigkeiten aufgenommen werden. Weitere Informationen finden Sie unter Paketverwaltung.

Hinweis

Verwenden Sie Typanmerkungen , um die Unterstützung von IntelliSense und Editoren zu verbessern:

def http_trigger(req: func.HttpRequest) -> str:

Organisieren mit Plänen

Verwenden Sie für größere oder modulare Apps Blueprints , um Funktionen in separaten Python-Dateien zu definieren und mit Ihrer Haupt-App zu registrieren. Diese Trennung sorgt dafür, dass Ihr Code organisiert und wiederverwendbar ist.

So definieren und registrieren Sie einen Blueprint:

Definieren Sie einen Blueprint in einer anderen Python-Datei, wie z. B. http_blueprint.py.

import azure.functions as func

bp = func.Blueprint()

@bp.route(route="default_template")
def default_template(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello World!")

Registrieren Sie den Blueprint in der Hauptdatei function_app.py :

import azure.functions as func
from http_blueprint import bp

app = func.FunctionApp()
app.register_functions(bp)

Mit diesen Blueprints können Sie Folgendes:

Aufteilen Ihrer App in wiederverwendbare Module
Verwandte Funktionen nach Datei oder Feature gruppieren
Erweitern oder Freigeben von Blueprints für alle Projekte

Hinweis

Dauerhafte Funktionen unterstützen auch Blueprints mithilfe von azure-functions-durable. Beispiel-→ anzeigen

Ordnerstruktur

Verwenden Sie die folgende Struktur für ein Python Azure Functions-Projekt:

<project_root>/
│
├── .venv/                   # (Optional) Local Python virtual environment
├── .vscode/                 # (Optional) VS Code workspace settings
│
├── function_app.py          # Main function entry point (decorator model)
├── shared/                  # (Optional) Pure helper code with no triggers/bindings
│   └── utils.py
│
├── additional_functions/    # (Optional) Contains blueprints for organizing related Functions
│   └── blueprint_1.py  
│
├── tests/                   # (Optional) Unit tests for your functions
│   └── test_my_function.py
│
├── .funcignore              # Excludes files from being published
├── host.json                # Global function app configuration
├── local.settings.json      # Local-only app settings (not published)
├── requirements.txt         # (Optional) Defines Python dependencies for remote build
├── Dockerfile               # (Optional) For custom container deployment

Schlüsseldateien und Ordner

Datei/ Ordner	BESCHREIBUNG	Erforderlich, damit die App in Azure ausgeführt werden kann
`function_app.py`	Hauptskript, in dem Azure-Funktionen und -Trigger mithilfe von Dekoratoren definiert werden.	✅
`host.json`	Globale Konfiguration für alle Funktionen in der App.	✅
`requirements.txt`	Python-Abhängigkeiten, die während der Veröffentlichung bei Verwendung des Remotebuilds installiert wurden.	❌ (empfohlen für die Paketverwaltung)
`local.settings.json`	Nur lokale App-Einstellungen und geheime Schlüssel (nie veröffentlicht).	❌ (erforderlich für die lokale Entwicklung)
`.funcignore`	Gibt Dateien und Ordner an, die von der Bereitstellung ausgeschlossen werden sollen (z. B. `.venv/`, `tests/`, `local.settings.json`).	❌ (recommended)
`.venv/`	Lokale virtuelle Umgebung für Python (von der Bereitstellung ausgeschlossen).	❌
`.vscode/`	Editorkonfiguration für Visual Studio Code. Für die Bereitstellung nicht erforderlich.	❌
`shared/`	Enthält Hilfscode, der für das Funktions-App-Projekt freigegeben ist.	❌
`additional_functions/`	Wird für die modulare Codeorganisation verwendet – in der Regel mit Blueprints.	❌
`tests/`	Komponententests für Ihre Funktions-App. Nicht in Azure veröffentlicht.	❌
`Dockerfile`	Definiert einen benutzerdefinierten Container für die Bereitstellung.	❌

[HINWEIS!] Schließen Sie eine requirements.txt Datei ein, wenn Sie mit Remote-Build bereitstellen. Wenn Sie keinen Remotebuild verwenden oder eine andere Datei zum Definieren von App-Abhängigkeiten verwenden möchten, können Sie einen lokalen Build ausführen und die App mit vordefinierten Abhängigkeiten bereitstellen.

Anleitungen zu Komponententests finden Sie unter Komponententests. Informationen zu Containerbereitstellungen finden Sie unter Bereitstellen mit benutzerdefinierten Containern.

Trigger und Bindungen

Azure Functions verwendet Trigger zum Starten der Funktionsausführung und Bindungen , um Ihren Code mit anderen Diensten wie Speicher, Warteschlangen und Datenbanken zu verbinden. Im Python v2-Programmiermodell deklarieren Sie Bindungen mithilfe von Dekoratoren.

Es gibt zwei Haupttypen von Bindungen:

Trigger (Eingabe, die die Funktion startet)
Eingaben und Ausgaben (zusätzliche Datenquellen oder Ziele)

Weitere Informationen zu den verfügbaren Triggern und Bindungen finden Sie unter Trigger und Bindungen in Azure Functions.

Beispiel: Timertrigger mit Blob-Eingabe

Diese Funktion bewirkt Folgendes:

Löst alle 10 Minuten aus
Liest aus einem Blob mithilfe von SDK-Typbindungen
Zwischenspeichert Ergebnisse und Schreibvorgänge in eine temporäre Datei

import azure.functions as func
import azurefunctions.extensions.bindings.blob as blob
import logging
import tempfile

CACHED_BLOB_DATA = None

app = func.FunctionApp()

@app.function_name(name="TimerTriggerWithBlob")
@app.schedule(schedule="0 */10 * * * *", arg_name="mytimer")
@app.blob_input(arg_name="client",
                path="PATH/TO/BLOB",
                connection="BLOB_CONNECTION_SETTING")
def timer_trigger_with_blob(mytimer: func.TimerRequest,
                            client: blob.BlobClient,
                            context: func.Context) -> None:
    global CACHED_BLOB_DATA
    if CACHED_BLOB_DATA is None:
        # Download blob and save as a global variable
        CACHED_BLOB_DATA = client.download_blob().readall()

        # Create temp file prefix
        my_prefix = context.invocation_id
        temp_file = tempfile.NamedTemporaryFile(prefix=my_prefix)
        temp_file.write(CACHED_BLOB_DATA)
        logging.info(f"Cached data written to {temp_file.name}")

Wichtige Begriffe

Verwenden Sie SDK-Typbindungen, um mit umfangreichen Typen zu arbeiten. Weitere Informationen finden Sie unter SDK-Typbindungen.
Sie können globale Variablen verwenden, um teure Berechnungen zwischenzuspeichern, aber ihr Zustand ist nicht garantiert, dass sie über Funktionsausführungen hinweg beibehalten werden.
Temporäre Dateien werden in tmp/ gespeichert und es wird nicht garantiert, dass sie über Aufrufe oder verschiedene Skalierungsinstanzen hinweg bestehen bleiben.
Sie können über die Context-Klasse auf den Aufrufkontext einer Funktion zugreifen.

Beispiel: HTTP-Trigger mit Cosmos DB-Eingabe und Event Hub-Ausgabe

Diese Funktion bewirkt Folgendes:

Trigger für eine HTTP-Anforderung
Liest aus einer Cosmos-Datenbank
Schreibt an einen Event Hub-Ausgang
Gibt eine HTTP-Antwort zurück.

# __init__.py
import azure.functions as func

def main(req: func.HttpRequest,
         documents: func.DocumentList,
         event: func.Out[str]) -> func.HttpResponse:

    # Content from HttpRequest and Cosmos DB input
    http_content = req.params.get("body")
    doc_id = documents[0]["id"] if documents else "No documents found"

    event.set(f"HttpRequest content: {http_content} | CosmosDB ID: {doc_id}")

    return func.HttpResponse(
        "Function executed successfully.",
        status_code=200
    )

// function.json
{
  "scriptFile": "__init__.py",
  "entryPoint": "main",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"],
      "route": "file"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "cosmosDB",
      "direction": "in",
      "name": "documents",
      "databaseName": "test",
      "containerName": "items",
      "id": "cosmosdb-input-test",
      "connection": "COSMOSDB_CONNECTION_SETTING"
    },
    {
      "type": "eventHub",
      "direction": "out",
      "name": "event",
      "eventHubName": "my-test-eventhub",
      "connection": "EVENTHUB_CONNECTION_SETTING"
    }
  ]
}

Wichtige Konzepte

Jede Funktion verfügt über einen einzelnen Trigger, kann jedoch mehrere Bindungen aufweisen.
Fügen Sie Eingaben hinzu, indem Sie direction als "in" in function.json angeben. Die Ausgabe hat eine direction von out.
Sie können über das HttpRequest Objekt auf Anforderungsdetails zugreifen und einen benutzerdefinierten HttpResponse Code mit Kopfzeilen, Statuscode und Textkörper erstellen.

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTriggerWithCosmosDB")
@app.route(route="file")
@app.cosmos_db_input(arg_name="documents",
                     database_name="test",
                     container_name="items",
                     connection="COSMOSDB_CONNECTION_SETTING")
@app.event_hub_output(arg_name="event",
                      event_hub_name="my-test-eventhub",
                      connection="EVENTHUB_CONNECTION_SETTING")
def http_trigger_with_cosmosdb(req: func.HttpRequest,
                               documents: func.DocumentList,
                               event: func.Out[str]) -> func.HttpResponse:
    # Content from HttpRequest and Cosmos DB input
    http_content = req.params.get('body')
    doc_id = documents[0]['id']

    event.set("HttpRequest content: " + http_content
              + " | CosmosDB ID: " + doc_id)

    return func.HttpResponse(
        f"Function executed successfully.",
        status_code=200
    )

Wichtige Begriffe

Verwenden Sie @route() oder triggerspezifische Dekoratoren (@timer_trigger, @queue_trigger und andere), um zu definieren, wie Ihre Funktion aufgerufen wird.
Fügen Sie Eingaben hinzu, indem Sie Dekoratoren wie @blob_input, @queue_inputund andere verwenden.
Die Ausgaben können sein:
- Direkt zurückgegeben (wenn nur eine Ausgabe vorhanden ist)
- Zugewiesen durch Out-Bindungen und die Methode .set() für mehrere Ausgaben.
Sie können über das HttpRequest Objekt auf Anforderungsdetails zugreifen und einen benutzerdefinierten HttpResponse Code mit Kopfzeilen, Statuscode und Textkörper erstellen.

SDK-Typbindungen

Für ausgewählte Trigger und Bindungen können Sie mit Datentypen arbeiten, die von den zugrunde liegenden Azure SDKs und Frameworks implementiert werden. Mithilfe dieser SDK-Typbindungen können Sie mit Bindungsdaten interagieren, als ob Sie das zugrunde liegende Dienst-SDK verwenden. Weitere Informationen finden Sie unter unterstützten SDK-Typbindungen.

Wichtig

Die Unterstützung von SDK-Typbindungen für Python ist nur im Python v2-Programmiermodell verfügbar.

Umgebungsvariablen

Mit Umgebungsvariablen in Azure Functions können Sie Konfigurationswerte, Verbindungszeichenfolgen und Geheime Apps sicher verwalten, ohne sie in Ihrem Funktionscode zu codieren.

Sie können Umgebungsvariablen definieren:

Lokal: in der local.settings.json-Datei bei der lokalen Entwicklung.
In Azure: als Anwendungseinstellungen auf der Konfigurationsseite Ihrer Funktions-App im Azure-Portal.

Zugreifen auf die Variablen direkt in Ihrem Code mithilfe os.environ oder os.getenv.

setting_value = os.getenv("myAppSetting", "default_value")

Hinweis

Azure Functions erkennt auch Systemumgebungsvariablen, die das Verhalten der Funktionen-Laufzeit und des Python-Arbeitsverhaltens konfigurieren. Diese Variablen werden nicht explizit im Funktionscode verwendet, wirken sich jedoch auf die Ausführung Der App aus. Eine vollständige Liste der Systemumgebungsvariablen finden Sie unter App-Einstellungsreferenz.

Paketverwaltung

Wenn Sie andere Python-Pakete in Ihrer Azure Functions-App verwenden möchten, listen Sie sie in einer requirements.txt Datei im Stammverzeichnis Ihres Projekts auf. Diese Pakete werden vom Importsystem von Python importiert, und Sie können dann wie gewohnt auf diese Pakete verweisen. Weitere Informationen zum Erstellen und Bereitstellen von Optionen mit externen Abhängigkeiten finden Sie unter Buildoptionen für Python-Funktions-Apps.

Im folgenden Beispiel wird beispielsweise gezeigt, wie das requests Modul in der Funktions-App enthalten und verwendet wird.

<requirements.txt>
requests==2.31.0

Installieren Sie das Paket lokal mit pip install -r requirements.txt.

Nachdem das Paket installiert wurde, können Sie es in Ihrem Funktionscode importieren und verwenden:

import azure.functions as func
import requests

def main(req: func.HttpRequest) -> func.HttpResponse:
    r = requests.get("https://api.github.com")
    return func.HttpResponse(f"Status: {r.status_code}")

import azure.functions as func
import requests

app = func.FunctionApp()

@app.function_name(name="HttpExample")
@app.route(route="call_api")
def main(req: func.HttpRequest) -> func.HttpResponse:
    r = requests.get("https://api.github.com")
    return func.HttpResponse(f"Status: {r.status_code}")

Überlegungen

Konflikte mit integrierten Modulen:
- Vermeiden Sie das Benennen von Projektordnern nach Python-Standardbibliotheken (z. B email/. , json/).
- Fügen Sie keine nativen Python-Bibliotheken (wie logging, asynciooder uuid) in requirements.txt.
Einsatz:
- Um Fehler zu vermeidenModuleNotFound, stellen Sie sicher, dass alle erforderlichen Abhängigkeiten aufgelistet requirements.txtsind.
- Wenn Sie die Python-Version Ihrer App aktualisieren, erstellen Sie Ihre App neu, und stellen Sie sie erneut auf der neuen Python-Version bereit, um Abhängigkeitskonflikte mit zuvor erstellten Paketen zu vermeiden.
Nicht-PyPI-Abhängigkeiten:
- Sie können Abhängigkeiten einschließen, die in Ihrer App nicht auf PyPI verfügbar sind, z. B. lokale Pakete, Raddateien oder private Feeds. Anweisungen zum Einrichten finden Sie unter benutzerdefinierte Abhängigkeiten in Python Azure Functions .
Azure Functions Python-Worker-Abhängigkeiten:
- Wenn Ihr Paket bestimmte Bibliotheken enthält, die möglicherweise mit den Abhängigkeiten des Workers kollidieren (z. B. protobuf oder grpcio), konfigurieren Sie PYTHON_ISOLATE_WORKER_DEPENDENCIES in den App-Einstellungen auf 1, um zu verhindern, dass Ihre Anwendung auf die Abhängigkeiten des Workers verweist. Für Python 3.13 und höher ist dieses Feature standardmäßig aktiviert.

Ausführen und Bereitstellen

Dieser Abschnitt enthält Informationen zum lokalen Ausführen von Funktionen, Python-Versionsunterstützung, Build- und Bereitstellungsoptionen sowie zur Laufzeitkonfiguration. Verwenden Sie diese Informationen, um Ihre Funktions-App erfolgreich in lokalen und Azure-Umgebungen auszuführen.

Lokales Ausführen

Sie können Ihre Python-Funktions-App auf Ihrem lokalen Computer ausführen und testen, bevor Sie sie in Azure bereitstellen.

Verwenden von Azure Functions Core Tools

Installieren Sie Azure Functions Core Tools , und starten Sie die lokale Laufzeit, indem Sie den func start Befehl aus Ihrem Projektstamm ausführen:

func start

Wenn Sie die Funktions-App lokal starten, zeigt Core Tools alle Funktionen an, die es für Ihre App findet.

Functions:
        http_trigger:  http://localhost:7071/api/http_trigger

Weitere Informationen zur Verwendung von Core Tools finden Sie unter "Lokales Entwickeln von Azure Functions mithilfe von Core Tools".

Direktes Aufrufen der Funktion

Mithilfe von azure-functions >= 1.21.0" können Sie Funktionen auch direkt aufrufen, indem Sie den Python-Interpreter verwenden, ohne Core Tools auszuführen. Dieser Ansatz eignet sich für schnelle Komponententests:

# function_app.py
import azure.functions as func

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="http_trigger")
def http_trigger(req: func.HttpRequest) -> func.HttpResponse:
    return "Hello, World!"

# Test the function directly
print(http_trigger(None))

Um die Ausgabe anzuzeigen, führen Sie die Datei direkt mit Python aus:

> python function_app.py

Hello, World!

# __init__.py
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello, World!")

# Test the function directly
print(main(None))

Um die Ausgabe anzuzeigen, führen Sie die Datei direkt mit Python aus:

> python __init__.py

Hello, World!

Bei diesem Ansatz sind keine zusätzlichen Pakete oder Setups erforderlich und eignet sich ideal für eine schnelle Überprüfung während der Entwicklung. Ausführlichere Tests finden Sie unter Komponententests

Unterstützte Python-Versionen

Azure Functions unterstützt die python-Versionen, die in unterstützten Sprachen in Azure Functions aufgeführt sind. Allgemeine Informationen finden Sie in der Azure Functions-Laufzeitunterstützungsrichtlinie.

Wichtig

Wenn Sie die Python-Version für Ihre Funktions-App ändern, müssen Sie die App mithilfe der neuen Version neu erstellen und erneut bereitstellen. Vorhandene Bereitstellungsartefakte und Abhängigkeiten werden nicht automatisch neu erstellt, wenn sich die Python-Version ändert.

Build & Deployment

Weitere Informationen zum empfohlenen Buildmechanismus für Ihr Szenario finden Sie unter "Buildoptionen". Eine allgemeine Übersicht über die Bereitstellung finden Sie unter Bereitstellungstechnologien in Azure Functions.

Schneller Vergleich von Bereitstellungsmechanismen

Tool / Plattform	Befehl/Aktion	Optimaler Anwendungsfall
Azure Functions Core Tools	`func azure functionapp publish <APP_NAME>`	Ideal für CI-Läufe, lokale Automatisierung oder für die plattformübergreifende Arbeit.
AZ CLI	`az functionapp deployment source config-zip`	Hilfreich beim Skripting von Bereitstellungen außerhalb von Core Tools. Funktioniert gut in automatisierten Pipelines oder cloudbasierten Terminals (Azure Cloud Shell).
Visual Studio Code (Azure Functions Extension)	Befehlspalette → "Azure-Funktionen: Bereitstellen in Azure..."	Am besten geeignet für Anfänger oder interaktive Bereitstellungen. Bearbeitet automatisch die Paketierung und den Build-Prozess.
GitHub-Aktionen	`Azure/functions-action@v1`	Ideal geeignet für GitHub-basierte CI/CD. Ermöglicht automatisierte Bereitstellungen bei Push- oder PR-Merges.
Azure-Pipelines	`AzureFunctionApp@2` Aufgabe	Unternehmens-CI/CD mit Azure DevOps. Am besten geeignet für kontrollierte Freigabeworkflows, gesteuerte Builds und mehrstufige Pipelines.
Benutzerdefinierte Containerbereitstellung	Pushcontainer-→ `az functionapp create --image <container>`	Erforderlich, wenn Sie Pakete auf Betriebssystemebene, benutzerdefinierte Python-Builds, angeheftete Runtimes oder nicht unterstützte Abhängigkeiten benötigen (z. B. Systembibliotheken, lokale Binärdateien).
Portalbasierte Funktionserstellung	Erstellen einer Funktion im Azure-Portal → Inline-Editor	Wird nur für einfache, abhängigkeitsfreie Funktionen verwendet. Ideal für Demos oder Lernen, aber nicht für Apps empfohlen , die Pakete von Drittanbietern erfordern.

Hinweis

Die portalbasierte Funktionserstellung unterstützt keine Abhängigkeiten von Drittanbietern und wird nicht für das Erstellen von Produktions-Apps empfohlen. Sie können keine Pakete außerhalb azure-functions und der integrierten Python-Standardbibliothek installieren oder verweisen.

Wichtig

Nach dem 30. September 2028 wird die Option zum Hosten Ihrer Funktions-App unter Linux in einem Verbrauchsplan eingestellt. Um Unterbrechungen zu vermeiden, migrieren Sie Ihre vorhandenen Verbrauchsplan-Apps, die unter Linux ausgeführt werden, vor diesem Datum zum Flex-Verbrauchsplan . Apps, die unter Windows in einem Verbrauchsplan ausgeführt werden, sind von dieser Änderung nicht betroffen. Weitere Informationen finden Sie in der Linux-Verbrauchsplan-Rückzugsankündigung.

Python 3.13+ Aktualisierungen

Ab Python 3.13 führt Azure Functions mehrere wichtige Laufzeit- und Leistungsverbesserungen ein, die sich darauf auswirken, wie Sie Ihre Apps erstellen und ausführen. Zu den wichtigsten Änderungen gehören:

Laufzeitversionskontrolle: Sie können Ihre App jetzt optional an bestimmte Python-Workerversionen anheften oder aktualisieren, indem Sie auf das azure-functions-runtime Paket in Ihrem requirements.txtPaket verweisen.

Ohne aktivierte Versionskontrolle wird Ihre App auf einer Standardversion der Python-Laufzeit ausgeführt, die von den Funktionen verwaltet wird. Sie müssen Ihre requirements.txt Datei ändern, um die neueste veröffentlichte Version, eine vorab veröffentlichte Version anzufordern oder Ihre App an eine bestimmte Version der Python-Runtime anzuheften.
Sie aktivieren die Laufzeitversionskontrolle, indem Sie ihrem requirements.txt-Datei einen Verweis auf das Python-Laufzeitpaket hinzufügen, wobei der dem Paket zugewiesene Wert die verwendete Laufzeitversion bestimmt.
Vermeiden Sie es, Produktionsanwendungen an Vorabversionen (Alpha, Beta oder Entwickler) der Laufzeitumgebung anzubinden.
Wenn Sie änderungen beachten möchten, überprüfen Sie regelmäßig die Anmerkungen zur Python-Laufzeitversion .

Die folgende Tabelle gibt das Versionsverwaltungsverhalten basierend auf dem Versionswert dieser Einstellung in Ihrer requirements.txt Datei an:

Version	Example	Verhalten
Kein Wert festgelegt	`azure-functions-runtime`	Ihre Python 3.13+-App wird auf der neuesten verfügbaren Version der Functions Python-Laufzeit ausgeführt. Diese Option eignet sich am besten, um mit Plattformverbesserungen und -features auf dem laufenden zu bleiben, da Ihre App automatisch die neuesten stabilen Laufzeitupdates erhält.
An eine bestimmte Version fixiert	`azure-functions-runtime==1.2.0`	Ihre Python 3.13+-App bleibt auf der fixierten Laufzeitversion und erhält keine automatischen Updates. Stattdessen müssen Sie Ihre angeheftete Version manuell aktualisieren, um neue Features, Fixes und Verbesserungen in der Laufzeit zu nutzen. Eine Fixierung wird für kritische Produktionsarbeitslasten empfohlen, bei denen Stabilität und Vorhersehbarkeit unerlässlich sind. Durch das Anheften können Sie Ihre App auch während der Entwicklung auf vorabveröffentlichten Laufzeitversionen testen.
Kein Paketverweis	n/a	Wenn Sie `azure-functions-runtime` nicht festlegen, läuft Ihre Python 3.13+-App auf einer Standardversion der Python-Runtime, die älter ist als die neueste veröffentlichte Version. Updates werden regelmäßig von Funktionen vorgenommen. Diese Option sorgt für Stabilität und breite Kompatibilität. Der Zugriff auf die neuesten Features und Fixes wird jedoch verzögert, bis die Standardversion aktualisiert wird.

Abhängigkeitsisolierung: Die Abhängigkeiten Ihrer App (wie zum Beispiel grpcio oder protobuf) sind vollständig von den Abhängigkeiten des Workers isoliert, um Versionskonflikte zu vermeiden. Die App-Einstellung PYTHON_ISOLATE_WORKER_DEPENDENCIES hat keine Auswirkungen auf Apps, die auf Python 3.13 oder höher ausgeführt werden.
Vereinfachtes HTTP-Streaming-Setup – keine speziellen App-Einstellungen erforderlich.
Die Unterstützung für Worker-Erweiterungen und geteilte Speichereigenschaften wurde entfernt.

Laufzeitversionskontrolle: Sie können Ihre App jetzt optional an bestimmte Python-Workerversionen anheften oder aktualisieren, indem Sie auf das azure-functions-runtime-v1 Paket in Ihrem requirements.txtPaket verweisen.

Ohne aktivierte Versionskontrolle wird Ihre App auf einer Standardversion der Python-Laufzeit ausgeführt, die Azure Functions verwaltet. Sie müssen Ihre requirements.txt Datei ändern, um die neueste veröffentlichte Version, eine vorab veröffentlichte Version anzufordern oder Ihre App an eine bestimmte Version der Python-Runtime anzuheften.
Sie aktivieren die Laufzeitversionskontrolle, indem Sie ihrem requirements.txt-Datei einen Verweis auf das Python-Laufzeitpaket hinzufügen, wobei der dem Paket zugewiesene Wert die verwendete Laufzeitversion bestimmt.
Vermeiden Sie, Produktions-Apps an vorläufige (Alpha-, Beta- oder Dev-Versionen) anzupinnen.
Wenn Sie änderungen beachten möchten, überprüfen Sie regelmäßig die Anmerkungen zur Python-Laufzeitversion .

Die folgende Tabelle gibt das Versionsverwaltungsverhalten basierend auf dem Versionswert dieser Einstellung in Ihrer requirements.txt Datei an:

Version	Example	Verhalten
Kein Wert festgelegt	`azure-functions-runtime-v1`	Ihre Python 3.13+-App wird auf der neuesten verfügbaren Version der Functions Python-Laufzeit ausgeführt. Diese Option eignet sich am besten, um mit Plattformverbesserungen und -features auf dem laufenden zu bleiben, da Ihre App automatisch die neuesten stabilen Laufzeitupdates erhält.
An eine bestimmte Version fixiert	`azure-functions-runtime-v1==1.2.0`	Ihre Python 3.13+-App bleibt auf der festgelegten Laufzeitversion und erhält keine automatischen Updates. Stattdessen müssen Sie Ihre angeheftete Version manuell aktualisieren, um neue Features, Fixes und Verbesserungen in der Laufzeit zu nutzen. Anheften wird für kritische Produktionsarbeitslasten empfohlen, bei denen Stabilität und Vorhersagbarkeit unerlässlich sind. Durch das Anheften können Sie Ihre App auch während der Entwicklung auf vorabveröffentlichten Laufzeitversionen testen.
Kein Paketverweis	n/a	Wenn Sie `azure-functions-runtime-v1` nicht festlegen, wird Ihre Python 3.13+-App auf einer Standardversion der Python-Runtime ausgeführt, die nicht auf dem neuesten Stand der veröffentlichten Version ist. Updates werden regelmäßig von Funktionen vorgenommen. Diese Option sorgt für Stabilität und breite Kompatibilität. Der Zugriff auf die neuesten Features und Fixes wird jedoch verzögert, bis die Standardversion aktualisiert wird.

Abhängigkeitsisolierung: Die Abhängigkeiten Ihrer App (wie zum Beispiel grpcio oder protobuf) sind vollständig von den Abhängigkeiten des Workers isoliert, um Versionskonflikte zu vermeiden. Die App-Einstellung PYTHON_ISOLATE_WORKER_DEPENDENCIES hat keine Auswirkungen auf Apps, die auf Python 3.13 oder höher ausgeführt werden.
Die Unterstützung für Workererweiterungen und gemeinsame Speicherfunktionen wurde entfernt.

Beobachtbarkeit und Testen

In diesem Abschnitt werden Protokollierungs-, Überwachungs - und Testfunktionen behandelt, um Probleme zu debuggen, die Leistung nachzuverfolgen und die Zuverlässigkeit Ihrer Python-Funktions-Apps sicherzustellen.

Protokollierung und Überwachung

Azure Functions macht einen Stammlogger verfügbar, den Sie direkt mit dem integrierten Python-Modul logging verwenden können. Alle mit diesem Logger geschriebenen Nachrichten werden automatisch an Application Insights gesendet, wenn Ihre App in Azure ausgeführt wird.

Mit der Protokollierung können Sie Laufzeitinformationen erfassen und Probleme diagnostizieren, ohne dass sie mehr Setup benötigen.

Protokollierungsbeispiel mit einem HTTP-Trigger

import logging
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.debug("Example debug log")
    logging.info("Example info log")
    logging.warning("Example warning")
    logging.error("Example error log")
    return func.HttpResponse("OK")

import logging
import azure.functions as func

app = func.FunctionApp()

@app.route(route="http_trigger")
def http_trigger(req) -> func.HttpResponse:
    logging.debug("Example debug log")
    logging.info("Example info log")
    logging.warning("Example warning")
    logging.error("Example error log")
    return func.HttpResponse("OK")

Sie können den vollständigen Satz von Protokollierungsebenen (debug, info, warning, error, critical) verwenden, und sie werden im Azure-Portal unter Protokollen oder Application Insights angezeigt.

Weitere Informationen zum Überwachen von Azure-Funktionen im Portal finden Sie unter Überwachen von Azure-Funktionen.

Hinweis

Um Debugprotokolle in Application Insights anzuzeigen, ist mehr Setup erforderlich. Sie können diese Funktion aktivieren, indem Sie PYTHON_ENABLE_DEBUG_LOGGING auf 1 setzen und logLevel auf trace oder debug in Ihrer host.json-Datei. Standardmäßig sind Debugprotokolle in Application Insights nicht sichtbar.

Protokollierung von Hintergrundthreads

Wenn die Funktion einen neuen Thread startet und aus diesem Thread protokollieren muss, stellen Sie sicher, dass Sie das context Argument an den Thread übergeben. Der context enthält threadlokalen Speicher und den aktuellen invocation_id, der auf dem Worker-Thread festgelegt werden muss, damit die Protokolle ordnungsgemäß der Funktionsausführung zugeordnet werden können.

import logging
import threading
import azure.functions as func

def main(req: func.HttpRequest, context) -> func.HttpResponse:
    logging.info("Function started")
    t = threading.Thread(target=log_from_thread, args=(context,))
    t.start()
    return "okay"

def log_from_thread(context):
    # Associate the thread with the current invocation
    context.thread_local_storage.invocation_id = context.invocation_id  
    logging.info("Logging from a background thread")

import azure.functions as func
import logging
import threading

app = func.FunctionApp()

@app.route(route="http_trigger")
def http_trigger(req, context) -> func.HttpResponse:
    logging.info("Function started")
    t = threading.Thread(target=log_from_thread, args=(context,))
    t.start()
    return "okay"

def log_from_thread(context):
    # Associate the thread with the current invocation
    context.thread_local_storage.invocation_id = context.invocation_id  
    logging.info("Logging from a background thread")

Konfigurieren von benutzerdefinierten Loggern

Sie können benutzerdefinierte Logger in Python konfigurieren, wenn Sie mehr Kontrolle über das Protokollierungsverhalten benötigen, z. B. benutzerdefinierte Formatierung, Protokollfilterung oder Integrationen von Drittanbietern. Um einen benutzerdefinierten Logger zu konfigurieren, verwenden Sie Pythons logging.getLogger() mit einem benutzerdefinierten Namen, und fügen Sie Handler oder Formatierer nach Bedarf hinzu.

import logging

custom_logger = logging.getLogger('my_custom_logger')

OpenTelemetry-Unterstützung

Azure Functions for Python unterstützt auch OpenTelemetry, mit dem Sie Ablaufverfolgungen, Metriken und Protokolle in einem standardisierten Format ausgeben können. Die Verwendung von OpenTelemetry ist besonders nützlich für verteilte Anwendungen oder Szenarien, in denen Sie Telemetrie in Tools außerhalb von Application Insights (z. B. Grafana oder Jaeger) exportieren möchten.

Anweisungen zum Einrichten und Beispielcode finden Sie in unserer OpenTelemetry-Schnellstartanleitung für Azure-Funktionen (Python ).

Komponententests

Schreiben und führen Sie Komponententests für Ihre Funktionen mithilfe von pytest aus. Sie können Python-Funktionen wie andere Python-Code testen, indem Sie Standardtestframeworks verwenden. Für die meisten Bindungen können Sie ein simuliertes Eingabeobjekt erstellen, indem Sie eine Instanz einer geeigneten Klasse aus dem azure.functions Paket erstellen.

Das folgende Beispiel zeigt, wie man my_function als ein Beispiel verwendet: ein simulierter Test einer HTTP-ausgelösten Funktion.

Erstellen Sie zunächst die <Datei project_root>/function_app.py , und implementieren Sie die my_function Funktion als HTTP-Trigger.

# <project_root>/function_app.py
import azure.functions as func
import logging

app = func.FunctionApp()

# Define the HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
@app.function_name(name="my_function")
@app.route(route="hello")
def my_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Executing myfunction.')

    initial_value: int = int(req.params.get('value'))
    doubled_value: int = initial_value * 2

    return func.HttpResponse(
        body=f"{initial_value} * 2 = {doubled_value}",
        status_code=200
    )

Jetzt können Sie mit dem Schreiben von Testfällen für den HTTP-Trigger beginnen.

# <project_root>/test_my_function.py
import unittest
import azure.functions as func

from function_app 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/my_function',
                           params={'value': '21'})
    # Call the function.
    func_call = main.build().get_user_function()
    resp = func_call(req)
    # Check the output.
    self.assertEqual(
        resp.get_body(),
        b'21 * 2 = 42',
    )

In Ihrem Ordner "Virtuelle Python-Umgebung" können Sie die folgenden Befehle ausführen, um die App zu testen:

pip install pytest
pytest test_my_function.py

pytest Die Ergebnisse werden wie folgt im Terminal angezeigt:

============================================================================================================ test session starts ============================================================================================================
collected 1 item                                                                                                                                                                                                                             

test_my_function.py .                                                                                                                                                                                                                  [100%] 
============================================================================================================= 1 passed in 0.24s =============================================================================================================

Optimierung und fortgeschrittene Themen

Weitere Informationen zum Optimieren Ihrer Python-Funktionen-Apps finden Sie in den folgenden Artikeln:

Weitere Informationen zu Funktionen finden Sie in den folgenden Artikeln:

Haben Sie Probleme mit der Verwendung von Python? Lassen Sie uns wissen und ein Problem einreichen.

Feedback

War diese Seite hilfreich?

Last updated on 2026-01-16

Freigeben über

Referenzhandbuch für Azure Functions-Entwickler für Python-Apps

Erste Schritte

Erstellen Ihrer Funktions-App

Programmiermodell

Wichtige Begriffe

Die azure-functions Bibliothek

Alternativer Einstiegspunkt

Ordnerstruktur

Schlüsseldateien und Ordner

Wichtige Begriffe

Die azure-functions Bibliothek

Organisieren mit Plänen

Ordnerstruktur

Schlüsseldateien und Ordner

Trigger und Bindungen

Beispiel: Timertrigger mit Blob-Eingabe

Wichtige Begriffe

Beispiel: HTTP-Trigger mit Cosmos DB-Eingabe und Event Hub-Ausgabe

Wichtige Begriffe

SDK-Typbindungen

Umgebungsvariablen

Paketverwaltung

Überlegungen

Ausführen und Bereitstellen

Lokales Ausführen

Verwenden von Azure Functions Core Tools

Direktes Aufrufen der Funktion

Unterstützte Python-Versionen

Build & Deployment

Python 3.13+ Aktualisierungen

Beobachtbarkeit und Testen

Protokollierung und Überwachung

Protokollierungsbeispiel mit einem HTTP-Trigger

Protokollierung von Hintergrundthreads

Konfigurieren von benutzerdefinierten Loggern

OpenTelemetry-Unterstützung

Komponententests

Optimierung und fortgeschrittene Themen

Verwandte Artikel

Feedback

Zusätzliche Ressourcen

Die `azure-functions` Bibliothek

Die `azure-functions` Bibliothek