Referensguide för Azure Functions-utvecklare för Python-appar

Azure Functions är en serverlös beräkningstjänst som gör att du kan köra händelsedriven kod utan att etablera eller hantera infrastruktur. Funktionskörningar utlöses av händelser som HTTP-begäranden, kömeddelanden, timers eller ändringar i lagring – och skalas automatiskt baserat på efterfrågan.

Den här guiden fokuserar specifikt på att skapa Python-baserade Azure Functions och hjälper dig att:

Skapa och köra funktionsappar lokalt
Förstå Python-programmeringsmodellen
Organisera och konfigurera ditt program
Distribuera och övervaka din app i Azure
Tillämpa metodtips för skalning och prestanda

Letar du efter en konceptuell översikt? Se Referens för Azure Functions-utvecklare.

Är du intresserad av verkliga användningsfall? Utforska sidan Scenarier och exempel .

Komma igång

Välj den miljö som passar ditt arbetsflöde och hoppa in i Azure Functions för Python:

Skapa din funktionsapp

Det här avsnittet beskriver de viktigaste komponenterna för att skapa och strukturera din Python-funktionsapp. Ämnena omfattar programmeringsmodellen, projektstrukturen, utlösare och bindningar samt beroendehantering.

Programmeringsmodell

Functions stöder två versioner av Python-programmeringsmodellen:

Utgåva	beskrivning
2.x	Använd en dekoratörsbaserad metod för att definiera utlösare och bindningar direkt i Python-kodfilen. Du implementerar varje funktion som en global, tillståndslös metod i en `function_app.py` fil eller en refererad skissfil. Den här modellversionen rekommenderas för nya Python-appar.
1.x	Du definierar utlösare och bindningar för varje funktion i en separat `function.json` fil. Du implementerar varje funktion som en global, tillståndslös metod i Python-kodfilen. Den här versionen av modellen stöder äldre appar.

Den här artikeln riktar sig till en specifik Python-modellversion. Välj önskad version överst i artikeln.

Viktigt!

Använd programmeringsmodellen v2 för en dekoratörsbaserad metod för att definiera utlösare och bindningar direkt i koden.

I programmeringsmodellen Python v1 definieras varje funktion som en global, tillståndslös main() metod i en fil med namnet __init__.py. Funktionens utlösare och bindningar konfigureras separat i en function.json fil och bindningsvärdena name används som parametrar i din main() metod.

Exempel

Här är en enkel funktion som svarar på en HTTP-begäran:

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

Här är motsvarande function.json fil:

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

Viktiga begrepp

Funktionen har en enda HTTP-utlösare.
HttpRequest-objektet innehåller begärandehuvuden, frågeparametrar, routningsparametrar och meddelandetexten. Den här funktionen hämtar värdet för name frågeparametern från parametern params för HttpRequest-objektet .
För att skicka ett namn i det här exemplet, lägg till ?name={name} till URL:en till den exponerade funktionen. Om du till exempel kör lokalt kan den fullständiga URL:en se ut som http://localhost:7071/api/http_trigger?name=Test. Exempel på bindningar finns i Utlösare och bindningar.

azure-functions Använd SDK och inkludera skrivkommentarer för att förbättra IntelliSense- och redigeringsstöd:

# __init__.py
import azure.functions as func

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

# requirements.txt
azure-functions

Biblioteket `azure-functions`

azure-functions Python-biblioteket innehåller de kärntyper som används för att interagera med Azure Functions-körningen. Om du vill se alla tillgängliga typer och metoder går du till API:etazure-functions. Funktionskoden kan använda azure-functions för att:

Åtkomst till indata för utlösare (till exempel HttpRequest, TimerRequest)
Skapa utdatavärden (till exempel HttpResponse)
Interagera med kontext och bindningsdata som tillhandahålls av runtime

Om du använder azure-functions i din app måste den ingå i dina projektberoenden.

Anteckning

Biblioteket azure-functions definierar programmeringsytan för Python Azure Functions, men det är inte en allmän SDK. Använd den specifikt för redigering och körning av funktioner i Azure Functions-körningen.

Alternativ startpunkt

Du kan ändra standardbeteendet för en funktion genom att ange scriptFile- och entryPoint-egenskaperna i function.json-filen. Följande function.json-fil dirigerar till exempel programkörningen att använda metoden i filen main.py som startpunkt för din Azure-funktion.

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

Mappstrukturen

Använd följande struktur för ett 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

Nyckelfiler och mappar

Fil/mapp	beskrivning	Krävs för att appen ska kunna köras i Azure
`my_first_function/`	Katalog för en enskild funktion.	✅
`__init__.py/`	Huvudskript där funktionskoden `my_first_function` definieras.	✅
`function.json/`	Innehåller bindningskonfigurationen `my_first_function` för funktionen.	✅
`host.json`	Global konfiguration för alla funktioner i appen.	✅
`requirements.txt`	Python-beroenden som installerades under publiceringen när fjärrversionen används.	❌ (rekommenderas för pakethantering)
`local.settings.json`	Inställningar och hemligheter för lokala appar (aldrig publicerade).	❌ (krävs för lokal utveckling)
`.funcignore`	Anger filer och mappar som ska undantas från distributionen (till exempel `.venv/`, `tests/`, `local.settings.json`).	❌ (rekommenderas)
`.venv/`	Lokal virtuell miljö för Python (exkluderas från distribution).	❌
`.vscode/`	Redigeringskonfiguration för Visual Studio Code. Krävs inte för distribution.	❌
`shared/`	Innehåller hjälpkod som delas i funktionsappsprojektet	❌
`additional_functions/`	Används för modulär kodorganisation – vanligtvis med skisser.	❌
`tests/`	Enhetstester för din funktionsapp. Inte publicerad i Azure.	❌
`Dockerfile`	Definierar en anpassad container för distribution.	❌

I programmeringsmodellen Python v2 använder Azure Functions en dekoratörsbaserad metod för att definiera utlösare och bindningar direkt i koden. Varje funktion implementeras som en global, tillståndslös metod i en function_app.py fil.

Exempel

Här är en enkel funktion som svarar på en HTTP-begäran:

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

Viktiga begrepp

Koden importerar azure-functions paketet och använder dekoratörer och typer för att definiera funktionsappen.
Funktionen har en enda HTTP-utlösare.
HttpRequest-objektet innehåller begärandehuvuden, frågeparametrar, routningsparametrar och meddelandetexten. Den här funktionen hämtar värdet för name frågeparametern från parametern params för HttpRequest-objektet .
För att skicka ett namn i det här exemplet, lägg till ?name={name} till URL:en till den exponerade funktionen. Om du till exempel kör lokalt kan den fullständiga URL:en se ut som http://localhost:7071/api/http_trigger?name=Test. Exempel på bindningar finns i Utlösare och bindningar.

Biblioteket `azure-functions`

Python-biblioteket azure-functions är en viktig del av Azure Functions-programmeringsmodellen. Den innehåller de dekoratörer, utlösare och bindningstyper samt begärande-/svarsobjekt som används för att definiera och interagera med funktioner vid körning. Om du vill se alla tillgängliga typer och dekoratörer går du till API:etazure-functions. Din funktionsappkod är beroende av det här biblioteket för att:

Definiera alla funktioner med hjälp av FunctionApp objektet
Deklarera utlösare och bindningar (till exempel @app.route, @app.timer_trigger)
Få åtkomst till in- och utdata (till exempel HttpRequest och HttpResponse, och Ut`)

Det azure-functions måste ingå i dina projektberoenden. Mer information finns i Pakethantering.

Anteckning

Använd typanteckningar för att förbättra intelliSense- och redigeringsstöd:

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

Organisera med skisser

För större eller modulära appar använder du skisser för att definiera funktioner i separata Python-filer och registrera dem med din huvudapp. Den här separationen håller koden organiserad och återanvändbar.

Så här definierar och registrerar du en skiss:

Definiera en skiss i en annan Python-fil, till exempel 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!")

Registrera skissen i huvudfilen function_app.py :

import azure.functions as func
from http_blueprint import bp

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

Med hjälp av skisser kan du:

Dela upp din app i återanvändbara moduler
Behåll relaterade funktioner grupperade efter fil eller funktion
Utöka eller dela skisser mellan projekt

Anteckning

Durable Functions har också stöd för skisser med hjälp av azure-functions-durable. Visa exempel →

Mappstrukturen

Använd följande struktur för ett 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

Nyckelfiler och mappar

Fil/mapp	beskrivning	Krävs för att appen ska kunna köras i Azure
`function_app.py`	Huvudskript där Azure Functions och utlösare definieras med hjälp av dekoratörer.	✅
`host.json`	Global konfiguration för alla funktioner i appen.	✅
`requirements.txt`	Python-beroenden som installerades under publiceringen när fjärrversionen används.	❌ (rekommenderas för pakethantering)
`local.settings.json`	Inställningar och hemligheter för lokala appar (aldrig publicerade).	❌ (krävs för lokal utveckling)
`.funcignore`	Anger filer och mappar som ska undantas från distributionen (till exempel `.venv/`, `tests/`, `local.settings.json`).	❌ (rekommenderas)
`.venv/`	Lokal virtuell miljö för Python (exkluderas från distribution).	❌
`.vscode/`	Redigeringskonfiguration för Visual Studio Code. Krävs inte för distribution.	❌
`shared/`	Innehåller hjälpkod som delas i funktionsappsprojektet	❌
`additional_functions/`	Används för modulär kodorganisation – vanligtvis med skisser.	❌
`tests/`	Enhetstester för din funktionsapp. Inte publicerad i Azure.	❌
`Dockerfile`	Definierar en anpassad container för distribution.	❌

[OBS!] Inkludera en requirements.txt fil när du distribuerar med fjärrversion. Om du inte använder fjärrbygge eller vill använda en annan fil för att definiera appberoenden kan du utföra en lokal version och distribuera appen med fördefinierade beroenden.

Vägledning om enhetstestning finns i Enhetstestning. Information om containerdistributioner finns i Distribuera med anpassade containrar.

Utlösare och bindningar

Azure Functions använder utlösare för att starta funktionskörning och bindningar för att ansluta koden till andra tjänster som lagring, köer och databaser. I programmeringsmodellen Python v2 deklarerar du bindningar med hjälp av dekoratörer.

Det finns två huvudsakliga typer av bindningar:

Utlösare (indata som startar funktionen)
Indata och utdata (extra datakällor eller mål)

Mer information om tillgängliga utlösare och bindningar finns i Utlösare och bindningar i Azure Functions.

Exempel: Timerutlösare med blob-input

Den här funktionen:

Utlösare var 10:e minut
Läser från en blob med hjälp av SDK-typbindningar
Cachelagrar resultat och skriver dem till en tillfällig fil

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

Viktiga begrepp

Använd SDK-typbindningar för att arbeta med omfattande typer. Mer information finns i SDK-typbindningar.
Du kan använda globala variabler för att cacha resurskrävande beräkningar, men deras tillstånd är inte garanterat att bestå mellan funktionskörningar.
Temporära filer lagras i tmp/ och är inte garanterade att sparas mellan anrop eller utskalningsinstanser.
Du kan komma åt anropskontexten för en funktion via klassen Kontext.

Exempel: HTTP-utlösare med Cosmos DB-indata och Event Hub-utdata

Den här funktionen:

Utlösare för en HTTP-begäran
Läsningar från en Cosmos-databas
Skriver till en händelsehubbens utdata
Returnerar ett HTTP-svar

# __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"
    }
  ]
}

Viktiga begrepp

Varje funktion har en enda utlösare, men den kan ha flera bindningar.
Lägg till indata genom att ange direction som "in" i function.json. Utdata har en direction av out.
Du kan komma åt information om begäran via HttpRequest objektet och skapa en anpassad HttpResponse med rubriker, statuskod och brödtext.

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
    )

Viktiga begrepp

Använd @route() eller utlösarspecifika dekoratörer (@timer_trigger, @queue_triggeroch andra) för att definiera hur funktionen anropas.
Lägg till indata med hjälp av dekoratörer som @blob_input, @queue_inputoch andra.
Utdata kan vara:
- Returneras direkt (om bara ett utdata)
- Tilldelas med hjälp av Out bindningar och .set() metoden för flera utgångar.
Du kan komma åt information om begäran via HttpRequest objektet och skapa en anpassad HttpResponse med rubriker, statuskod och brödtext.

SDK-typbindningar

För utvalda utlösare och bindningar kan du arbeta med datatyper som implementeras av underliggande Azure SDK:er och ramverk. Genom att använda dessa SDK-typbindningar kan du interagera med bindningsdata som om du använde den underliggande tjänst-SDK:t. Mer information finns i SDK-typbindningar som stöds.

Viktigt!

Stöd för SDK-typbindningar för Python är endast tillgängligt i programmeringsmodellen Python v2.

Miljövariabler

Med miljövariabler i Azure Functions kan du hantera konfigurationsvärden, anslutningssträngar och apphemligheter på ett säkert sätt utan att hårdkoda dem i funktionskoden.

Du kan definiera miljövariabler:

Lokalt: i local.settings.json-filen under lokal utveckling.
I Azure: som programinställningar på funktionsappens konfigurationssida i Azure-portalen.

Få åtkomst till variablerna direkt i koden med hjälp os.environ av eller os.getenv.

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

Anteckning

Azure Functions identifierar även systemmiljövariabler som konfigurerar Funktionskörning och Python-arbetsbeteende. Dessa variabler används inte uttryckligen i funktionskoden, men påverkar hur appen körs. En fullständig lista över systemmiljövariabler finns i Referens för appinställningar.

Pakethantering

Om du vill använda andra Python-paket i Azure Functions-appen kan du visa dem i en requirements.txt fil i roten för projektet. Dessa paket importeras av Pythons importsystem och du kan sedan referera till dessa paket som vanligt. Mer information om hur du skapar och distribuerar alternativ med externa beroenden finns i Skapa alternativ för Python-funktionsappar.

Följande exempel visar till exempel hur modulen requests ingår och används i funktionsappen.

<requirements.txt>
requests==2.31.0

Installera paketet lokalt med pip install -r requirements.txt.

När paketet har installerats kan du importera och använda det i funktionskoden:

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

Överväganden

Konflikter med inbyggda moduler:
- Undvik att namnge dina projektmappar efter Python-standardbibliotek (till exempel email/, json/).
- Inkludera inte inbyggda Python-bibliotek (till exempel logging, asyncioeller uuid) i requirements.txt.
Driftsättning
- För att förhindra ModuleNotFound fel kontrollerar du att alla nödvändiga beroenden visas i requirements.txt.
- Om du uppdaterar din apps Python-version återskapar och distribuerar du om appen på den nya Python-versionen för att undvika beroendekonflikter med tidigare byggda paket.
Icke-PyPI-beroenden:
- Du kan inkludera beroenden som inte är tillgängliga på PyPI i din app, till exempel lokala paket, hjulfiler eller privata feeds. Se Anpassade beroenden i Python Azure Functions för installationsinstruktioner.
Azure Functions Python-arbetsberoenden:
- Om paketet innehåller vissa bibliotek som kan kollidera med arbetarberoenden (till exempel protobuf eller grpcio), konfigurerar du PYTHON_ISOLATE_WORKER_DEPENDENCIES till 1 i appinställningarna för att förhindra att ditt program refererar till arbetarberoenden. För Python 3.13 och senare är den här funktionen aktiverad som standard.

Köra och distribuera

Det här avsnittet innehåller information om att köra funktioner lokalt, stöd för Python-version, bygg- och distributionsalternativ och körningskonfiguration. Använd den här informationen för att köra funktionsappen i både lokala miljöer och Azure-miljöer.

Körs på lokal nivå

Du kan köra och testa python-funktionsappen på den lokala datorn innan du distribuerar till Azure.

Använda Azure Functions Core Tools

Installera Azure Functions Core Tools och starta den lokala körningen genom att köra kommandot från projektroten func start :

func start

När du startar funktionsappen lokalt visar Core Tools alla funktioner som den hittar för din app:

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

Du kan lära dig mer om hur du använder Core Tools genom att gå till Utveckla Azure Functions lokalt med core tools.

Anropa funktionen direkt

Med hjälp azure-functions >= 1.21.0av kan du även anropa funktioner direkt med hjälp av Python-tolken utan att köra Core Tools. Den här metoden är användbar för snabbenhetstester:

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

Om du vill se utdata kör du filen direkt med 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))

Om du vill se utdata kör du filen direkt med Python:

> python __init__.py

Hello, World!

Den här metoden kräver inga extra paket eller installationer och är perfekt för snabb validering under utvecklingen. Mer djupgående testning finns i Enhetstestning

Python-versioner som stöds

Azure Functions har stöd för Python-versioner som anges i språk som stöds i Azure Functions. För mer allmän information, se Azure Functions runtime supportpolicy.

Viktigt!

Om du ändrar Python-versionen för funktionsappen måste du återskapa och distribuera om appen med hjälp av den nya versionen. Befintliga distributionsartefakter och beroenden återskapas inte automatiskt när Python-versionen ändras.

Skapa och distribuera

Mer information om den rekommenderade byggmekanismen för ditt scenario finns i Byggalternativ. En allmän översikt över distribution finns i Distributionstekniker i Azure Functions.

Snabbjämförelse av distributionsmekanismer

Verktyg/plattform	Kommando/åtgärd	Bästa användningsfall
Azure Functions Core Tools	`func azure functionapp publish <APP_NAME>`	Perfekt för CI-körningar, lokal automatisering eller när du arbetar över olika plattformar.
AZ CLI	`az functionapp deployment source config-zip`	Användbart vid skriptdistributioner utanför Core Tools. Fungerar bra i automatiserade pipelines eller molnbaserade terminaler (Azure Cloud Shell).
Visual Studio Code (Azure Functions-tillägg)	Kommandopalette → "Azure Functions: Distribuera till Azure..."	Bäst för nybörjare eller interaktiva distributioner. Hanterar paketering och bygge automatiskt.
GitHub Actions	`Azure/functions-action@v1`	Perfekt för GitHub-baserad CI/CD. Aktiverar automatiserade distributioner vid push- eller PR-sammanslagningar.
Azure Pipelines	`AzureFunctionApp@2` Uppgift	Företags-CI/CD med Azure DevOps. Bäst för kontrollerade versionsarbetsflöden, gated builds och pipelines i flera steg.
Distribution av anpassad container	Pushcontainer → `az functionapp create --image <container>`	Krävs när du behöver paket på operativsystemsnivå, anpassade Python-versioner, låsta körningar eller beroenden som inte stöds (till exempel systembibliotek, lokala binärfiler).
Skapa portalbaserad funktion	Skapa funktion i Azure-portalen → infogad redigerare	Använd endast för enkla, beroendefria funktioner. Perfekt för demonstrationer eller inlärning, men rekommenderas inte för appar som kräver paket från tredje part.

Anteckning

Portalbaserad funktionsskapande stöder inte beroenden från tredje part och rekommenderas inte för att skapa produktionsappar. Du kan inte installera eller referera till paket utanför azure-functions och det inbyggda Python-standardbiblioteket.

Viktigt!

Efter den 30 september 2028 återkallas alternativet att köra din funktionsapp på Linux inom en förbrukningsplan. För att undvika störningar migrerar du dina befintliga förbrukningsplanappar som körs på Linux till Flex Consumption-planen före det datumet. Appar som körs i Windows i en förbrukningsplan påverkas inte av den här ändringen. Mer information finns i meddelandet om tillbakadragning av Linux-förbrukningsplan.

Python 3.13+ uppdateringar

Från och med Python 3.13 introducerar Azure Functions flera större körnings- och prestandaförbättringar som påverkar hur du skapar och kör dina appar. Viktiga ändringar är:

Körningsversionskontroll: Du kan nu välja att binda eller uppgradera appen till specifika Python-arbetarversioner genom att hänvisa till paketet i azure-functions-runtimerequirements.txt.

Utan att versionskontrollen är aktiverad körs appen på en standardversion av Python-körningen, som Functions hanterar. Du måste ändra filenrequirements.txt för att begära den senaste versionen, en förhandsversion eller för att fästa appen på en viss version av Python-körningen.
Du aktiverar körningsversionskontroll genom att lägga till en referens till Python-körningspaketet i dinrequirements.txt-fil , där värdet som tilldelats paketet avgör vilken körningsversion som används.
Undvik att binda någon produktionsapp till förhandsversioner av runtime (alfa, beta eller dev).
Om du vill vara medveten om ändringar läser du viktig information om Python Runtime regelbundet.

Följande tabell anger versionsbeteendet baserat på versionsvärdet för den här inställningen i dinrequirements.txt-fil :

Utgåva	Example	Beteende
Ingen värdeuppsättning	`azure-functions-runtime`	Python 3.13+-appen körs på den senaste tillgängliga versionen av Functions Python-körningen. Det här alternativet är bäst för att hålla dig uppdaterad med plattformsförbättringar och funktioner, eftersom din app automatiskt får de senaste stabila körningsuppdateringarna.
Fäst på en viss version	`azure-functions-runtime==1.2.0`	Python 3.13+-appen förblir på den fastlåsta körningsversionen och får inga automatiska uppdateringar. Du måste istället manuellt uppdatera din fästa version så att du kan dra nytta av nya funktioner, korrigeringar och förbättringar i körmiljön. Fästning rekommenderas för kritiska produktionsarbetsbelastningar där stabilitet och förutsägbarhet är viktiga. Med fastsättning kan du också testa din app på förhandsutgivna körningsversioner under utvecklingen av programmet.
Ingen paketreferens	Inte tillämpligt	Genom att inte ange `azure-functions-runtime`körs python 3.13+-appen på en standardversion av Python-körningen som ligger bakom den senaste versionen. Uppdateringar görs regelbundet av Functions. Det här alternativet garanterar stabilitet och bred kompatibilitet. Åtkomsten till de senaste funktionerna och korrigeringarna fördröjs dock tills standardversionen har uppdaterats.

Beroendeisolering: Appens beroenden (t.ex grpcio . eller protobuf) är helt isolerade från arbetarens beroenden, vilket förhindrar versionskonflikter. Appinställningen PYTHON_ISOLATE_WORKER_DEPENDENCIES påverkar inte appar som körs på Python 3.13 eller senare.
Förenklad HTTP-strömningskonfiguration – inga särskilda appinställningar krävs.
Stöd för arbetstillägg och delade minnesfunktioner har tagits bort.

Körningsversionskontroll: Du kan nu välja att binda eller uppgradera appen till specifika Python-arbetarversioner genom att hänvisa till paketet i azure-functions-runtime-v1requirements.txt.

Utan att versionskontrollen är aktiverad körs appen på en standardversion av Python-körningen, som Functions hanterar. Du måste ändra filenrequirements.txt för att begära den senaste versionen, en förhandsversion eller för att fästa appen på en viss version av Python-körningen.
Du aktiverar körningsversionskontroll genom att lägga till en referens till Python-körningspaketet i dinrequirements.txt-fil , där värdet som tilldelats paketet avgör vilken körningsversion som används.
Undvik att binda någon produktionsapp till förhandsversioner av runtime (alfa, beta eller dev).
Om du vill vara medveten om ändringar läser du viktig information om Python Runtime regelbundet.

Följande tabell anger versionsbeteendet baserat på versionsvärdet för den här inställningen i dinrequirements.txt-fil :

Utgåva	Example	Beteende
Ingen värdeuppsättning	`azure-functions-runtime-v1`	Python 3.13+-appen körs på den senaste tillgängliga versionen av Functions Python-körningen. Det här alternativet är bäst för att hålla dig uppdaterad med plattformsförbättringar och funktioner, eftersom din app automatiskt får de senaste stabila körningsuppdateringarna.
Fäst på en viss version	`azure-functions-runtime-v1==1.2.0`	Python 3.13+-appen förblir på den fastlagda körningsversionen och får inte automatiska uppdateringar. Du måste istället uppdatera din låsta version manuellt för att dra nytta av nya funktioner, korrigeringar och förbättringar i runtime-miljön. Fästning rekommenderas för kritiska produktionsarbetsbelastningar där stabilitet och förutsägbarhet är viktiga. Med fastsättning kan du också testa din app på prerelease-versioner av runtime under utveckling.
Ingen paketreferens	Inte tillämpligt	Genom att inte ange `azure-functions-runtime-v1`körs python 3.13+-appen på en standardversion av Python-körningen som ligger bakom den senaste versionen. Uppdateringar görs regelbundet av Functions. Det här alternativet garanterar stabilitet och bred kompatibilitet. Åtkomsten till de senaste funktionerna och korrigeringarna fördröjs dock tills standardversionen har uppdaterats.

Beroendeisolering: Appens beroenden (t.ex grpcio . eller protobuf) är helt isolerade från arbetarens beroenden, vilket förhindrar versionskonflikter. Appinställningen PYTHON_ISOLATE_WORKER_DEPENDENCIES påverkar inte appar som körs på Python 3.13 eller senare.
Stöd för arbetstillägg och delade minnesfunktioner har tagits bort.

Observerbarhet och testning

Det här avsnittet beskriver funktioner för loggning, övervakning och testning som hjälper dig att felsöka problem, spåra prestanda och säkerställa tillförlitligheten för dina Python-funktionsappar.

Loggning och övervakning

Azure Functions exponerar en rotloggare som du kan använda direkt med Pythons inbyggda logging modul. Meddelanden som skrivs med den här loggaren skickas automatiskt till Application Insights när din app körs i Azure.

Med loggning kan du samla in körningsinformation och diagnostisera problem utan att behöva konfigurera mer.

Loggningsexempel med en HTTP-utlösare

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

Du kan använda den fullständiga uppsättningen loggningsnivåer (debug, , infowarning, error, critical), och de visas i Azure-portalen under Loggar eller Application Insights.

Mer information om hur du övervakar Azure Functions i portalen finns i Övervaka Azure Functions.

Anteckning

Om du vill visa felsökningsloggar i Application Insights krävs mer konfiguration. Du kan aktivera den här funktionen genom att ange PYTHON_ENABLE_DEBUG_LOGGING till 1 och ange logLevel till trace eller debug i dinhost.json-fil. Som standard visas inte felsökningsloggar i Application Insights.

Loggning från bakgrundstrådar

Om funktionen startar en ny tråd och behöver logga från den tråden context ser du till att skicka argumentet till tråden. För att loggar ska associeras korrekt med funktionskörningen måste context trådlokal lagring och den aktuella invocation_id anges i arbetstråden.

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

Konfigurera anpassade loggare

Du kan konfigurera anpassade loggare i Python när du behöver mer kontroll över loggningsbeteendet, till exempel anpassad formatering, loggfiltrering eller integreringar från tredje part. För att konfigurera en egen loggare, använd Pythons logging.getLogger() med ett anpassat namn och lägg till hanterare eller formaterare vid behov.

import logging

custom_logger = logging.getLogger('my_custom_logger')

OpenTelemetry-stöd

Azure Functions för Python har också stöd för OpenTelemetry, vilket gör att du kan generera spårningar, mått och loggar i ett standardiserat format. Att använda OpenTelemetry är särskilt värdefullt för distribuerade program eller scenarier där du vill exportera telemetri till verktyg utanför Application Insights (till exempel Grafana eller Jaeger).

Se vår Snabbstart för OpenTelemetry för Azure Functions (Python) för installationsinstruktioner och exempelkod.

Enhetstestning

Skriv och kör enhetstester för dina funktioner med hjälp av pytest. Du kan testa Python-funktioner som annan Python-kod med hjälp av standardtestramverk. För de flesta bindningar kan du skapa ett falskt indataobjekt genom att skapa en instans av en lämplig klass från azure.functions paketet.

Genom att använda my_function som exempel är följande ett test av en HTTP-triggad funktion:

Skapa först filen project_root</function_app.py och implementera funktionen som HTTP-utlösare.>my_function

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

Du kan börja skriva testfall för HTTP-utlösaren.

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

I mappen för den virtuella Python-miljön kan du köra följande kommandon för att testa appen:

pip install pytest
pytest test_my_function.py

Du ser resultatet pytest i terminalen så här:

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

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

Optimering och avancerade ämnen

Mer information om hur du optimerar dina Python-funktionsappar finns i följande artiklar:

Mer information om Functions finns i följande artiklar:

Har du problem med att använda Python? Berätta för oss och skicka in ett problem.

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-01-16

Dela via

Referensguide för Azure Functions-utvecklare för Python-appar

Komma igång

Skapa din funktionsapp

Programmeringsmodell

Viktiga begrepp

Biblioteket azure-functions

Alternativ startpunkt

Mappstrukturen

Nyckelfiler och mappar

Viktiga begrepp

Biblioteket azure-functions

Organisera med skisser

Mappstrukturen

Nyckelfiler och mappar

Utlösare och bindningar

Exempel: Timerutlösare med blob-input

Viktiga begrepp

Exempel: HTTP-utlösare med Cosmos DB-indata och Event Hub-utdata

Viktiga begrepp

SDK-typbindningar

Miljövariabler

Pakethantering

Överväganden

Köra och distribuera

Körs på lokal nivå

Använda Azure Functions Core Tools

Anropa funktionen direkt

Python-versioner som stöds

Skapa och distribuera

Python 3.13+ uppdateringar

Observerbarhet och testning

Loggning och övervakning

Loggningsexempel med en HTTP-utlösare

Loggning från bakgrundstrådar

Konfigurera anpassade loggare

OpenTelemetry-stöd

Enhetstestning

Optimering och avancerade ämnen

Relaterade artiklar

Feedback

Ytterligare resurser

Biblioteket `azure-functions`

Biblioteket `azure-functions`