Share via

Azure Functions handleiding voor ontwikkelaars voor Python-apps

Azure Functions is een serverloze rekenservice waarmee u gebeurtenisgestuurde code kunt uitvoeren zonder infrastructuur in te richten of te beheren. Functie-uitvoeringen worden geactiveerd door gebeurtenissen zoals HTTP-aanvragen, wachtrijberichten, timers of wijzigingen in de opslag en automatisch schalen op basis van aanvraag.

Deze handleiding is specifiek gericht op het bouwen van op Python gebaseerde Azure Functions en helpt u bij het volgende:

  • Functie-apps lokaal maken en uitvoeren
  • Meer informatie over het Python programmeermodel
  • Uw toepassing organiseren en configureren
  • Uw app implementeren en bewaken in Azure
  • Aanbevolen procedures toepassen voor schalen en prestaties

Zoekt u een conceptueel overzicht? Zie de Azure Functions Developer Reference.

Bent u geïnteresseerd in praktijkgebruiksvoorbeelden? Verken de pagina Scenario's en voorbeelden .

Aan de slag

Kies de omgeving die past bij uw werkstroom en spring in Azure Functions voor Python:

Uw functie-app bouwen

In deze sectie worden de essentiële onderdelen beschreven voor het maken en structureren van uw Python functie-app. Onderwerpen zijn onder andere het programmeermodel, projectstructuur, triggers en bindingen en afhankelijkheidsbeheer.

Programmeermodel

Functions ondersteunt twee versies van het Python programmeermodel:

Versie Beschrijving
2.x Gebruik een op decorator gebaseerde benadering om triggers en bindingen rechtstreeks in uw Python codebestand te definiëren. U implementeert elke functie als een globale, staatloze methode in een bestand of een blauwdrukbestand waarnaar wordt verwezen. Deze modelversie wordt aanbevolen voor nieuwe Python-apps.
1.x U definieert triggers en bindingen voor elke functie in een afzonderlijk bestand. U implementeert elke functie als een globale, staatloze methode in uw Python codebestand. Deze versie van het model ondersteunt verouderde apps.

Dit artikel is gericht op een specifieke Python modelversie. Kies de gewenste versie bovenaan het artikel.

Belangrijk

Gebruik het v2-programmeermodel voor een op decorator gebaseerde benadering om triggers en bindingen rechtstreeks in uw code te definiëren.

In het programmeermodel Python v1 wordt elke functie gedefinieerd als een globale, staatloze methode main() in een bestand met de naam __init__.py. De triggers en bindingen van de functie worden afzonderlijk geconfigureerd in een bestand en de bindingswaarden worden gebruikt als parameters in uw methode.

Voorbeeld

Hier volgt een eenvoudige functie die reageert op een HTTP-aanvraag:

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

Dit is het bijbehorende bestand:

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

Belangrijke concepten

  • De functie heeft één HTTP-trigger.
  • Het HttpRequest-object bevat aanvraagheaders, queryparameters, routeparameters en de hoofdtekst van het bericht. Met deze functie wordt de waarde van de queryparameter opgehaald uit de parameter van het HttpRequest-object .
  • Als u een naam in dit voorbeeld wilt verzenden, voegt u deze toe aan de weergegeven functie-URL. Als u bijvoorbeeld lokaal werkt, kan de volledige URL er als volgt uitzien. Zie Triggers en bindingen voor voorbeelden van het gebruik van bindingen.

Gebruik de SDK en voeg typeaantekeningen toe om ondersteuning voor IntelliSense en editor te verbeteren:

# __init__.py
import azure.functions as func

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

# requirements.txt
azure-functions

De bibliotheek

De bibliotheek azure-functions Python biedt de kerntypen die worden gebruikt voor interactie met de Azure Functions runtime. Als u alle beschikbare typen en methoden wilt zien, gaat u naar de API. Uw functiecode kan het volgende gebruiken :

  • Invoergegevens van Access-trigger (bijvoorbeeld , )
  • Uitvoerwaarden maken (zoals )
  • Interactie met door runtime geleverde context en bindingsgegevens

Als u in uw app gebruikt, moet deze zijn opgenomen in uw projectafhankelijkheden.

Notitie

De bibliotheek azure-functions definieert het programmeeroppervlak voor Python Azure Functions, maar is geen SDK voor algemeen gebruik. Gebruik deze functie specifiek voor het ontwerpen en uitvoeren van functies in de Azure Functions runtime.

Alternatief toegangspunt

U kunt het standaardgedrag van een functie wijzigen door de en eigenschappen in het bestand op te geven. Gebruik bijvoorbeeld het volgende bestand function.json om de runtime te instrueren de methode custom_entry() in het bestand main.py als invoerpunt voor uw Azure-functie te gebruiken.

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

Mapstructuur

Gebruik de volgende structuur voor een Python Azure Functions project:

<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

Belangrijke bestanden en mappen

bestand/map Beschrijving Vereist voor uitvoering van de app in Azure
my_first_function/ Map voor een enkele functie. ✅
__init__.py/ Hoofdscript waarin de functiecode is gedefinieerd. ✅
function.json/ Bevat de bindingsconfiguratie voor de functie. ✅
host.json Globale configuratie voor alle functies in de app. ✅
requirements.txt Python afhankelijkheden die tijdens het publiceren zijn geïnstalleerd bij het gebruik van remote build. (aanbevolen voor pakketbeheer)
local.settings.json Instellingen en geheimen voor apps die alleen lokaal zijn (nooit gepubliceerd). (vereist voor lokale ontwikkeling)
.funcignore Hiermee geeft u bestanden en mappen die moeten worden uitgesloten van implementatie (bijvoorbeeld , ). (aanbevolen)
.venv/ Lokale virtuele omgeving voor Python (uitgesloten van implementatie). ❌
.vscode/ Editorconfiguratie voor Visual Studio Code. Niet vereist voor implementatie. ❌
shared/ Bevat helpercode die wordt gedeeld in het function-app-project ❌
additional_functions/ Wordt gebruikt voor modulaire code-organisatie, meestal met blauwdrukken. ❌
tests/ Eenheidstests voor uw functie-app. Niet vrijgegeven in Azure. ❌
Dockerfile Definieert een aangepaste container voor implementatie. ❌

In het programmeermodel Python v2 gebruikt Azure Functions een benadering op basis van decorator om triggers en bindingen rechtstreeks in uw code te definiëren. Elke functie wordt geïmplementeerd als een globale, staatloze methode in een bestand.

Voorbeeld

Hier volgt een eenvoudige functie die reageert op een HTTP-aanvraag:

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

Belangrijke concepten

  • De code importeert het pakket en gebruikt decorators en typen om de functie-app te definiëren.
  • De functie heeft één HTTP-trigger.
  • Het HttpRequest-object bevat aanvraagheaders, queryparameters, routeparameters en de hoofdtekst van het bericht. Met deze functie wordt de waarde van de queryparameter opgehaald uit de parameter van het HttpRequest-object .
  • Als u een naam in dit voorbeeld wilt verzenden, voegt u deze toe aan de weergegeven functie-URL. Als u bijvoorbeeld lokaal werkt, kan de volledige URL er als volgt uitzien. Zie Triggers en bindingen voor voorbeelden van het gebruik van bindingen.

De bibliotheek

De bibliotheek azure-functions Python is een belangrijk onderdeel van het Azure Functions programmeermodel. Het biedt de decorators, trigger- en bindingstypen en aanvraag-/antwoordobjecten die worden gebruikt om functies tijdens runtime te definiëren en ermee te communiceren. Als u alle beschikbare typen en decorators wilt zien, gaat u naar de API. De code van uw functie-app is afhankelijk van deze bibliotheek voor het volgende:

  • Alle functies definiëren met behulp van het object
  • Triggers en bindingen declareren (bijvoorbeeld , )
  • Toegewezen toegang tot getypte invoer en uitvoer (zoals en , en Uit`)

De moet worden opgenomen in de projectafhankelijkheden. Zie pakketbeheer voor meer informatie.

Notitie

De bibliotheek azure-functions definieert het programmeeroppervlak voor Python Azure Functions, maar is geen SDK voor algemeen gebruik. Gebruik deze functie specifiek voor het ontwerpen en uitvoeren van functies in de Azure Functions runtime.

Typeaantekeningen gebruiken om ondersteuning voor IntelliSense en editor te verbeteren:

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

Organiseren met blauwdrukken

Voor grotere of modulaire apps gebruikt u blueprints om functies in afzonderlijke Python bestanden te definiëren en ze te registreren bij uw hoofd-app. Met deze scheiding blijft uw code georganiseerd en herbruikbaar.

Een blauwdruk definiëren en registreren:

  1. Definieer een blauwdruk in een ander Python-bestand, zoals 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!")

  2. Registreer de blauwdruk in het hoofdbestand :

    import azure.functions as func
from http_blueprint import bp

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

Met behulp van blauwdrukken kunt u het volgende doen:

  • Uw app opsplitsen in herbruikbare modules
  • Gerelateerde functies gegroepeerd houden op bestand of functie
  • Blauwdrukken uitbreiden of delen over projecten heen

Notitie

Durable Functions ondersteunt ook blauwdrukken met behulp van azure-functions-durable. Voorbeeld weergeven →

Mapstructuur

Gebruik de volgende structuur voor een Python Azure Functions project:

<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

Belangrijke bestanden en mappen

bestand/map Beschrijving Vereist voor uitvoering van de app in Azure
function_app.py Hoofdscript waarin Azure Functions en triggers worden gedefinieerd met behulp van decorators. ✅
host.json Globale configuratie voor alle functies in de app. ✅
requirements.txt Python afhankelijkheden die tijdens het publiceren zijn geïnstalleerd bij het gebruik van remote build. (aanbevolen voor pakketbeheer)
local.settings.json Instellingen en geheimen voor apps die alleen lokaal zijn (nooit gepubliceerd). (vereist voor lokale ontwikkeling)
.funcignore Hiermee geeft u bestanden en mappen die moeten worden uitgesloten van implementatie (bijvoorbeeld , ). (aanbevolen)
.venv/ Lokale virtuele omgeving voor Python (uitgesloten van implementatie). ❌
.vscode/ Editorconfiguratie voor Visual Studio Code. Niet vereist voor implementatie. ❌
shared/ Bevat helpercode die wordt gedeeld in het function-app-project ❌
additional_functions/ Wordt gebruikt voor modulaire code-organisatie, meestal met blauwdrukken. ❌
tests/ Eenheidstests voor uw functie-app. Niet gepubliceerd op Azure. ❌
Dockerfile Definieert een aangepaste container voor implementatie. ❌

[OPMERKING!] Neem een bestand op wanneer u implementeert met externe build. Als u geen externe build gebruikt of een ander bestand wilt gebruiken voor het definiëren van app-afhankelijkheden, kunt u een lokale build uitvoeren en de app implementeren met vooraf gebouwde afhankelijkheden.

Zie Eenheidstests voor hulp bij het testen van eenheden. Zie Implementeren met aangepaste containers voor containerimplementaties.

Triggers en bindingen

Azure Functions gebruikt triggers om de uitvoering van functies te starten en bindingen om uw code te verbinden met andere services, zoals opslag, wachtrijen en databases. In het Python v2-programmeermodel declareert u bindingen met behulp van decorators.

Er bestaan twee hoofdtypen bindingen:

  • Triggers (invoer waarmee de functie wordt gestart)
  • Invoer en uitvoer (extra gegevensbronnen of bestemmingen)

Zie Triggers en bindingen in Azure Functions voor meer informatie over de beschikbare triggers en bindingen.

Voorbeeld: Timertrigger met Blob-invoer

Deze functie:

  • Triggers elke 10 minuten
  • Leesbewerkingen uit een blob met behulp van SDK-typebindingen
  • Slaat resultaten en schrijfbewerkingen op in een tijdelijk bestand
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}")

Belangrijke concepten

  • Gebruik SDK-typebindingen om te werken met uitgebreide typen. Zie SDK-typebindingen voor meer informatie.
  • U kunt globale variabelen gebruiken om dure berekeningen in de cache te zetten, maar hun toestand wordt niet gegarandeerd behouden bij uitvoeringen van functies.
  • Tijdelijke bestanden worden opgeslagen in en blijven niet gegarandeerd behouden tussen aanroepen of uitschaalinstanties.
  • U hebt toegang tot de aanroepcontext van een functie via de contextklasse.

Voorbeeld: HTTP-trigger met Cosmos DB-invoer en Event Hub-uitvoer

Deze functie:

  • Triggers op een HTTP-aanvraag
  • Lezen uit een Cosmos DB
  • Schrijft naar een Event Hub-uitvoer
  • Retourneert een HTTP-antwoord
# __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"
    }
  ]
}

belangrijke concepten

  • Elke functie heeft één trigger, maar kan meerdere bindingen hebben.
  • Voeg invoer toe door de waarde 'in' op te geven in . Uitvoer heeft een van .
  • U kunt toegang krijgen tot aanvraagdetails via het object en een aangepaste maken met headers, statuscode en hoofdtekst.
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
    )

Belangrijke concepten

  • Gebruik of triggerspecifieke decorators (, en andere) om te definiëren hoe uw functie wordt aangeroepen.
  • Voeg invoer toe met behulp van decorators zoals , en andere.
  • Uitvoer kan het volgende zijn:
    • Rechtstreeks geretourneerd (als er slechts één uitvoer is)
    • Toegewezen met behulp van bindingen en de methode voor meerdere uitvoer.
  • U kunt toegang krijgen tot aanvraagdetails via het object en een aangepaste maken met headers, statuscode en hoofdtekst.

SDK-typebindingen

Voor geselecteerde triggers en bindingen kunt u werken met gegevenstypen die zijn geïmplementeerd door de onderliggende Azure-SDK's en frameworks. Door deze SDK-typebindingen te gebruiken, kunt u communiceren met bindingsgegevens alsof u de onderliggende service-SDK gebruikt. Zie ondersteunde SDK-typebindingen voor meer informatie.

Belangrijk

Ondersteuning voor SDK-typebindingen voor Python is alleen beschikbaar in het programmeermodel Python v2.

Omgevingsvariabelen

Met omgevingsvariabelen in Azure Functions kunt u configuratiewaarden, verbindingsreeksen en app-geheimen veilig beheren zonder deze in uw functiecode vast te leggen.

U kunt omgevingsvariabelen definiëren:

  • Lokaal: in het local.settings.json-bestand, tijdens lokale ontwikkeling.
  • In Azure: als Application Settings op de configuratiepagina van uw functie-app in de Azure-portal.

Open de variabelen rechtstreeks in uw code met behulp van of .

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

Notitie

Azure Functions herkent ook systeemomgevingsvariabelen die de Functions-runtime en Python werkrolgedrag configureren. Deze variabelen worden niet expliciet gebruikt in uw functiecode, maar hebben wel invloed op de manier waarop uw app wordt uitgevoerd. Zie de naslaginformatie over app-instellingen voor een volledige lijst met omgevingsvariabelen van het systeem.

Pakketbeheer

Als u andere Python-pakketten in uw Azure Functions-app wilt gebruiken, vermeldt u deze in een requirements.txt-bestand in de hoofdmap van uw project. Deze pakketten worden geïmporteerd door het importsysteem van Python en u kunt vervolgens naar deze pakketten verwijzen zoals gebruikelijk. Zie Build Options for Python Function Apps voor meer informatie over het bouwen en implementeren van opties voor externe afhankelijkheden.

In het volgende voorbeeld ziet u bijvoorbeeld hoe de module wordt opgenomen en gebruikt in de functie-app.

<requirements.txt>
requests==2.31.0

Installeer het pakket lokaal met .

Zodra het pakket is geïnstalleerd, kunt u het importeren en gebruiken in uw functiecode:

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

Overwegingen

  • Conflicten met ingebouwde modules:
    • Vermijd het benoemen van projectmappen na Python standaardbibliotheken (bijvoorbeeld email/, json/).
    • Neem Python systeemeigen bibliotheken (zoals logging, asyncio of uuid) niet op in requirements.txt.
  • Implementatie:
    • Om fouten te voorkomen, moet u ervoor zorgen dat alle vereiste afhankelijkheden worden vermeld in .
    • Als u de Python versie van uw app bijwerkt, bouwt u de app opnieuw en implementeert u deze opnieuw op de nieuwe Python versie om afhankelijkheidsconflicten met eerder gebouwde pakketten te voorkomen.
  • Niet-PyPI-afhankelijkheden:
  • Azure Functions Python werkrolafhankelijkheden:
    • Als uw pakket bepaalde bibliotheken bevat die kunnen botsen met afhankelijkheden van werkrollen (bijvoorbeeld of ), configureert u PYTHON_ISOLATE_WORKER_DEPENDENCIES naar 1 in app-instellingen om te voorkomen dat uw toepassing verwijst naar afhankelijkheden van werkrollen. Voor Python 3.13 en hoger is de functie standaard ingeschakeld.

Uitvoeren en implementeren

Deze sectie bevat informatie over running-functies lokaal, Python-versieondersteuning, build- en implementatieopties en runtimeconfiguratie. Gebruik deze informatie om uw functie-app uit te voeren in zowel lokale als Azure omgevingen.

Lokaal uitvoeren

U kunt uw Python-functie-app uitvoeren en testen op uw lokale computer voordat u implementeert in Azure.

Azure Functions Core Tools gebruiken

Installeer Azure Functions Core Tools en start de lokale runtime door de opdracht func start uit te voeren vanuit de hoofdmap van uw project:

func start

Wanneer u de functie-app lokaal start, worden in Core Tools alle functies weergegeven die voor uw app worden gevonden:

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

Meer informatie over het gebruik van Core Tools vindt u in Ontwikkeling Azure Functions lokaal met behulp van Core Tools.

De functie rechtstreeks aanroepen

Met behulp van azure-functions >= 1.21.0 kunt u functies ook rechtstreeks aanroepen met behulp van de Python-interpreter zonder Core Tools uit te voeren. Deze methode is handig voor snelle eenheidstests:

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

Als u de uitvoer wilt zien, voert u het bestand rechtstreeks uit met Python:

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

Als u de uitvoer wilt zien, voert u het bestand rechtstreeks uit met Python:

> python __init__.py

Hello, World!

Deze aanpak vereist geen extra pakketten of installatie en is ideaal voor snelle validatie tijdens de ontwikkeling. Raadpleeg Eenheidstests voor meer diepgaande tests

Ondersteunde Python versies

Azure Functions ondersteunt de Python versies die worden vermeld in Ondersteunde talen in Azure Functions. Zie het Azure Functions runtime-ondersteuningsbeleid voor meer algemene informatie.

Belangrijk

Als u de Python-versie voor uw functie-app wijzigt, moet u de app opnieuw bouwen en opnieuw implementeren met behulp van de nieuwe versie. Bestaande implementatieartefacten en afhankelijkheden worden niet automatisch opnieuw opgebouwd wanneer de Python versie wordt gewijzigd.

Bouwen en implementeren

Zie Buildopties voor meer informatie over het aanbevolen buildmechanisme voor uw scenario. Zie Deployment-technologieën in Azure Functions voor een algemeen overzicht van de implementatie.

Snelle vergelijking van implementatiemechanismen

Hulpprogramma/platform Opdracht/actie Beste gebruiksvoorbeeld
Azure Functions Core Tools func azure functionapp publish <APP_NAME> Ideaal voor CI-uitvoeringen, lokale automatisering of bij het werken op meerdere platforms.
AZ CLI az functionapp deployment source config-zip Handig bij het uitvoeren van scripts buiten Core Tools. Werkt goed in geautomatiseerde pijplijnen of cloudterminals (Azure Cloud Shell).
Visual Studio Code (Azure Functions Extension) Command Palette → "Azure Functions: Implementeren in Azure..." Het meest geschikt voor beginners of interactieve implementaties. Behandelt automatisch het verpakkingsproces en het buildproces.
GitHub Actions Azure/functions-action@v1 Ideaal voor GitHub-gebaseerde CI/CD. Hiermee kunt u geautomatiseerde implementaties uitvoeren bij push- of PR-mergebewerkingen.
Azure-pipelines Taak Enterprise CI/CD met behulp van Azure DevOps. Het meest geschikt voor gecontroleerde releasewerkstromen, gated builds en pijplijnen met meerdere fasen.
Aangepaste containerimplementatie Container uploaden → Vereist wanneer u pakketten op besturingssysteemniveau, aangepaste Python builds, vastgemaakte runtimes of niet-ondersteunde afhankelijkheden nodig hebt (bijvoorbeeld systeembibliotheken, lokale binaire bestanden).
Functie maken op basis van portal Functie maken in de Azure-portal → inline-editor Alleen gebruiken voor eenvoudige, afhankelijkheidsvrije functies. Ideaal voor demo's of leren, maar niet aanbevolen voor apps die pakketten van derden vereisen.

Notitie

Functie maken op basis van de portal biedt geen ondersteuning voor afhankelijkheden van derden en wordt niet aanbevolen voor het maken van productie-apps. U kunt geen pakketten buiten azure-functions en de ingebouwde Python standaardbibliotheek installeren of ernaar verwijzen.

Belangrijk

Na 30 september 2028 wordt de optie voor het hosten van uw functie-app op Linux in een verbruiksabonnement buiten gebruik gesteld. Als u onderbrekingen wilt voorkomen, migreert u uw bestaande verbruiksabonnement-apps die op Linux worden uitgevoerd naar het Flex Consumption-abonnement vóór die datum. Apps die worden uitgevoerd op Windows in een verbruiksabonnement, worden niet beïnvloed door deze wijziging.

Na 30 september 2025 worden er geen nieuwe functies en geen nieuwe taalstackondersteuning toegevoegd aan het Linux-verbruiksabonnement. De laatst ondersteunde taalversies voor Linux-verbruik zijn: .NET 9, Python 3.12, Node.js 22, PowerShell 7.4 en Java 21. Nieuwere taalversies worden niet ondersteund voor Linux-verbruik.

Zie Verbruiksabonnement-apps migreren naar het Flex Consumption-abonnement voor meer informatie.

Python 3.13+ updates

Vanaf Python 3.13 introduceert Azure Functions verschillende belangrijke runtime- en prestatieverbeteringen die van invloed zijn op hoe u uw apps bouwt en uitvoert. Belangrijke wijzigingen zijn onder andere:

  • Versiebeheer voor runtime: u kunt uw app nu desgewenst vastzetten of upgraden naar specifieke versies van Python workers door te verwijzen naar het azure-functions-runtime-pakket in uw requirements.txt.

    • Als versiebeheer niet is ingeschakeld, wordt uw app uitgevoerd op een standaardversie van de Python runtime, die door Functions wordt beheerd. U moet het bestand requirements.txt wijzigen om de meest recente uitgebrachte versie, een vooraf uitgebrachte versie aan te vragen of om uw app vast te maken aan een specifieke versie van de Python runtime.

    • U schakelt runtimeversiebeheer in door een verwijzing naar het Python runtimepakket toe te voegen aan uw bestand requirements.txt, waarbij de waarde die aan het pakket is toegewezen, bepaalt welke runtimeversie wordt gebruikt.

    • Vermijd het koppelen van een productie-app aan prerelease (alfa, bèta of dev) runtimeversies.

    • Bekijk regelmatig Python runtime releaseopmerkingen om op de hoogte te zijn van wijzigingen.

    • De volgende tabel geeft het versiegedrag aan op basis van de versiewaarde van deze instelling in uw requirements.txt-bestand :

      Versie Example Gedrag
      Geen waarde ingesteld azure-functions-runtime Uw Python 3.13+-app wordt uitgevoerd op de nieuwste beschikbare versie van de Functions Python runtime. Deze optie is het beste om op de hoogte te blijven van platformverbeteringen en -functies, omdat uw app automatisch de meest recente stabiele runtime-updates ontvangt.
      Vastgemaakt aan een specifieke versie azure-functions-runtime==1.2.0 Uw Python 3.13+ app blijft op de vastgemaakte runtime-versie staan en ontvangt geen automatische updates. U moet in plaats daarvan uw vastgemaakte versie handmatig bijwerken om te profiteren van nieuwe functies, fixes en verbeteringen in de runtime. Vastmaken wordt aanbevolen voor kritieke productieworkloads, waarbij stabiliteit en voorspelbaarheid essentieel zijn. Door vast te zetten kunt u uw app ook testen op pre-release-runtimeversies tijdens de ontwikkeling.
      Geen pakketreferentie n/a Als u de azure-functions-runtime niet instelt, wordt uw Python 3.13+ app uitgevoerd op een standaardversie van de Python runtime die zich achter de nieuwste uitgebrachte versie bevindt. Updates worden periodiek uitgevoerd door Functions. Deze optie zorgt voor stabiliteit en brede compatibiliteit. De toegang tot de nieuwste functies en oplossingen wordt echter uitgesteld totdat de standaardversie wordt bijgewerkt.

  • Afhankelijkheidsisolatie: de afhankelijkheden van uw app (zoals of ) zijn volledig geïsoleerd van de afhankelijkheden van de workerprocessen, waardoor versieconflicten worden voorkomen. De app-instelling PYTHON_ISOLATE_WORKER_DEPENDENCIES heeft geen invloed op apps die worden uitgevoerd op Python 3.13 of hoger.

  • Vereenvoudigde instellingen voor HTTP-streaming : er zijn geen speciale app-instellingen vereist.

  • Ondersteuning voor werkrolextensies en gedeelde geheugenfuncties is verwijderd.

  • Versiebeheer voor runtime: u kunt uw app nu desgewenst vastzetten of upgraden naar specifieke versies van Python workers door te verwijzen naar het azure-functions-runtime-v1-pakket in uw requirements.txt.

    • Als versiebeheer niet is ingeschakeld, wordt uw app uitgevoerd op een standaardversie van de Python runtime, die door Functions wordt beheerd. U moet het bestand requirements.txt wijzigen om de meest recente uitgebrachte versie, een vooraf uitgebrachte versie aan te vragen of om uw app vast te maken aan een specifieke versie van de Python runtime.

    • U schakelt runtimeversiebeheer in door een verwijzing naar het Python runtimepakket toe te voegen aan uw bestand requirements.txt, waarbij de waarde die aan het pakket is toegewezen, bepaalt welke runtimeversie wordt gebruikt.

    • Vermijd het koppelen van een productie-app aan prerelease (alfa, bèta of dev) runtimeversies.

    • Bekijk regelmatig Python runtime releaseopmerkingen om op de hoogte te zijn van wijzigingen.

    • De volgende tabel geeft het versiegedrag aan op basis van de versiewaarde van deze instelling in uw requirements.txt-bestand :

      Versie Example Gedrag
      Geen waarde ingesteld azure-functions-runtime-v1 Uw Python 3.13+-app wordt uitgevoerd op de nieuwste beschikbare versie van de Functions Python runtime. Deze optie is het beste om op de hoogte te blijven van platformverbeteringen en -functies, omdat uw app automatisch de meest recente stabiele runtime-updates ontvangt.
      Vastgemaakt aan een specifieke versie azure-functions-runtime-v1==1.2.0 Uw Python 3.13+ app blijft op de vastgemaakte runtime-versie staan en ontvangt geen automatische updates. U moet in plaats daarvan uw vastgemaakte versie handmatig bijwerken om te profiteren van nieuwe functies, fixes en verbeteringen in de runtime. Vastmaken wordt aanbevolen voor kritieke productieworkloads, waarbij stabiliteit en voorspelbaarheid essentieel zijn. Door vast te zetten kunt u uw app ook testen op pre-release-runtimeversies tijdens de ontwikkeling.
      Geen pakketreferentie n/a Als u de azure-functions-runtime-v1 niet instelt, wordt uw Python 3.13+ app uitgevoerd op een standaardversie van de Python runtime die zich achter de nieuwste uitgebrachte versie bevindt. Updates worden periodiek uitgevoerd door Functions. Deze optie zorgt voor stabiliteit en brede compatibiliteit. De toegang tot de nieuwste functies en oplossingen wordt echter uitgesteld totdat de standaardversie wordt bijgewerkt.

  • Afhankelijkheidsisolatie: de afhankelijkheden van uw app (zoals of ) zijn volledig geïsoleerd van de afhankelijkheden van de workerprocessen, waardoor versieconflicten worden voorkomen. De app-instelling PYTHON_ISOLATE_WORKER_DEPENDENCIES heeft geen invloed op apps die worden uitgevoerd op Python 3.13 of hoger.

  • Ondersteuning voor werkrolextensies en gedeelde geheugenfuncties is verwijderd.

Waarneembaarheid en testen

In deze sectie worden logging, monitoring en testmogelijkheden beschreven om problemen op te sporen, prestaties bij te houden en de betrouwbaarheid van uw Python functie-apps te garanderen.

Logboekregistratie en bewaking

Azure Functions maakt een hoofdlogger beschikbaar die u rechtstreeks kunt gebruiken met Python ingebouwde module logging. Berichten die met deze logger worden geschreven, worden automatisch verzonden naar Application Insights wanneer uw app in Azure draait.

Met logboekregistratie kunt u runtime-informatie vastleggen en problemen diagnosticeren zonder dat u meer installatie nodig hebt.

Voorbeeld van logboekregistratie met een 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")

U kunt de volledige set logboekregistratieniveaus (debug, info, warning, error, critical) gebruiken en deze worden weergegeven in de Azure-portal onder Logboeken of Application Insights.

Zie Monitor Azure Functions voor meer informatie over het bewaken van Azure Functions in de portal.

Notitie

Als u foutopsporingslogboeken in Application Insights wilt weergeven, is er meer installatie vereist. U kunt deze functie inschakelen door PYTHON_ENABLE_DEBUG_LOGGING op en op of in te stellen in uw bestand host.json. Foutopsporingslogboeken zijn standaard niet zichtbaar in Application Insights.

Loggen vanuit achtergrond-threads

Als uw functie een nieuwe thread start en u moet loggen vanuit die thread, zorg dan dat u het -argument doorgestuurd aan de thread. De bevat thread-lokale opslag en de huidige , die moeten worden ingesteld op de werkdraad om ervoor te zorgen dat logbestanden correct worden gekoppeld aan de uitvoering van de functie.

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

Aangepaste logboekregistraties configureren

U kunt aangepaste logboekregistraties configureren in Python wanneer u meer controle nodig hebt over het gedrag van logboekregistratie, zoals aangepaste opmaak, logboekfiltering of integraties van derden. Als u een aangepaste logboekregistratie wilt configureren, gebruikt u de logging.getLogger() van Python met een aangepaste naam en voegt u indien nodig handlers of formatters toe.

import logging

custom_logger = logging.getLogger('my_custom_logger')

Ondersteuning voor OpenTelemetry

Azure Functions voor Python ondersteunt ook OpenTelemetry, waarmee u traceringen, metrische gegevens en logboeken in een gestandaardiseerde indeling kunt verzenden. Het gebruik van OpenTelemetry is vooral waardevol voor gedistribueerde toepassingen of scenario's waarin u telemetrie wilt exporteren naar hulpprogramma's buiten Application Insights (zoals Grafana of Jaeger).

Zie onze OpenTelemetry Quickstart voor Azure Functions (Python) voor installatie-instructies en voorbeeldcode.

Het testen van modules

Schrijf en voer eenheidstests uit voor uw functies met behulp van . U kunt Python functies zoals andere Python code testen met behulp van standaard testframeworks. Voor de meeste bindingen kunt u een mock-invoerobject maken door een exemplaar van een geschikte klasse te maken op basis van het pakket.

Met als voorbeeld is het volgende een mocktest van een HTTP-getriggerde functie.

Maak eerst het bestand project_root/function_app.py en implementeer de functie als de 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
    )

U kunt beginnen met het schrijven van testcases voor uw HTTP-trigger.

# <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 de map Python virtuele omgeving kunt u de volgende opdrachten uitvoeren om de app te testen:

pip install pytest
pytest test_my_function.py

U ziet de resultaten in de terminal, zoals deze:

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

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

Optimalisatie en geavanceerde onderwerpen

Zie de volgende artikelen voor meer informatie over het optimaliseren van uw Python functions-apps:

Zie de volgende artikelen voor meer informatie over Functions:

Ondervindt u problemen met het gebruik van Python? Laat het ons weten en dien een probleem in.

  • Last updated on