Partager via

Guide de référence pour les développeurs Azure Functions pour les applications Python

Azure Functions est un service de calcul serverless qui vous permet d’exécuter du code piloté par les événements sans provisionner ni gérer l’infrastructure. Les exécutions de fonction sont déclenchées par des événements tels que les requêtes HTTP, les messages de file d’attente, les minuteurs ou les modifications dans le stockage, et sont mises à l’échelle automatiquement en fonction de la demande.

Ce guide se concentre spécifiquement sur la création d’Azure Functions basé sur Python et vous aide à :

  • Créer et exécuter des applications de fonction localement
  • Comprendre le modèle de programmation Python
  • Organiser et configurer votre application
  • Déployer et surveiller votre application dans Azure
  • Appliquer les meilleures pratiques pour la mise à l’échelle et les performances

Vous recherchez une vue d’ensemble conceptuelle ? Consultez la référence du développeur Azure Functions.

Intéressé par les cas d’usage réels ? Explorez la page Scénarios et exemples .

Mise en route

Choisissez l’environnement qui correspond à votre flux de travail et accédez à Azure Functions pour Python :

Création de votre application de fonction

Cette section décrit les composants essentiels pour créer et structurer votre application de fonction Python. Les rubriques incluent le modèle de programmation, la structure de projet, les déclencheurs et les liaisons et la gestion des dépendances.

Modèle de programmation

Functions prend en charge deux versions du modèle de programmation Python :

Version Descriptif
2.x Utilisez une approche basée sur des décorateurs pour définir des déclencheurs et des liaisons directement dans votre fichier de code Python. Vous implémentez chaque fonction en tant que méthode globale sans état dans un function_app.py fichier ou un fichier blueprint référencé. Cette version de modèle est recommandée pour les nouvelles applications Python.
1.x Vous définissez des déclencheurs et des liaisons pour chaque fonction dans un fichier distinct function.json . Vous implémentez chaque fonction en tant que méthode globale sans état dans votre fichier de code Python. Cette version du modèle prend en charge les applications héritées.

Cet article cible une version spécifique du modèle Python. Choisissez votre version souhaitée en haut de l’article.

Important

Utilisez le modèle de programmation v2 pour une approche basée sur des décorateurs pour définir des déclencheurs et des liaisons directement dans votre code.

Dans le modèle de programmation Python v1, chaque fonction est définie comme une méthode globale sans main() état à l’intérieur d’un fichier nommé __init__.py. Les déclencheurs et les liaisons de la fonction sont configurés séparément dans un function.json fichier, et les valeurs de liaison name sont utilisées comme paramètres dans votre main() méthode.

Exemple

Voici une fonction simple qui répond à une requête HTTP :

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

Voici le fichier correspondant function.json :

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

Concepts clés

  • La fonction a un seul déclencheur HTTP.
  • L’objet HttpRequest contient des en-têtes de requête, des paramètres de requête, des paramètres de routage et le corps du message. Cette fonction obtient la valeur du paramètre de name requête à partir du params paramètre de l’objet HttpRequest .
  • Pour envoyer un nom dans cet exemple, ajoutez ?name={name} à l’URL de la fonction exposée. Par exemple, si vous l'exécutez localement, l’URL complète peut ressembler à http://localhost:7071/api/http_trigger?name=Test. Pour obtenir des exemples d’utilisation de liaisons, consultez Déclencheurs et liaisons.

Utilisez le azure-functions Kit de développement logiciel (SDK) et incluez des annotations de type pour améliorer la prise en charge d’IntelliSense et de l’éditeur :

# __init__.py
import azure.functions as func

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

# requirements.txt
azure-functions

Bibliothèque azure-functions

La azure-functions bibliothèque Python fournit les types principaux utilisés pour interagir avec le runtime Azure Functions. Pour afficher tous les types et méthodes disponibles, visitez l’APIazure-functions. Votre code de fonction peut être utilisé azure-functions pour :

  • Accéder aux données d’entrée du déclencheur (par exemple, HttpRequest, TimerRequest)
  • Créer des valeurs de sortie (par exemple HttpResponse)
  • Interagir avec le contexte et les données de liaison fournis par le runtime

Si vous utilisez azure-functions dans votre application, elle doit être incluse dans vos dépendances de projet.

Remarque

La azure-functions bibliothèque définit l’aire de programmation pour Python Azure Functions, mais elle n’est pas un SDK à usage général. Utilisez-le spécifiquement pour la création et l’exécution de fonctions dans le runtime Azure Functions.

Autre point d’entrée

Vous pouvez modifier le comportement par défaut d'une fonction en spécifiant les propriétés scriptFile et entryPoint dans le fichier function.json. Par exemple, le fichier suivant function.json dirige le runtime pour utiliser la custom_entry() méthode dans le main.py fichier comme point d’entrée pour votre fonction Azure.

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

Structure de dossiers

Utilisez la structure suivante pour un projet Azure Functions Python :

<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

Fichiers et dossiers clés

Fichier/dossier Descriptif Obligatoire pour que l’application s’exécute dans Azure
my_first_function/ Répertoire d’une fonction unique. ✅
__init__.py/ Script principal où le code de la fonction my_first_function est défini. ✅
function.json/ Contient la configuration de liaison pour la my_first_function fonction. ✅
host.json Configuration globale pour toutes les fonctions de l’application. ✅
requirements.txt Dépendances Python installées lors de la publication lors de l’utilisation de la build distante. ❌ (recommandé pour la gestion des packages)
local.settings.json Paramètres et secrets de l’application locale uniquement (jamais publiés). ❌ (requis pour le développement local)
.funcignore Spécifie les fichiers et dossiers à exclure du déploiement (par exemple, .venv/, tests/, local.settings.json). ❌ (recommandé)
.venv/ Environnement virtuel local pour Python (exclu du déploiement). ❌
.vscode/ Configuration de l’éditeur pour Visual Studio Code. Non requis pour le déploiement. ❌
shared/ Contient le code d’assistance partagé dans le projet Function App ❌
additional_functions/ Utilisé pour l’organisation du code modulaire, généralement avec des blueprints. ❌
tests/ Tests unitaires pour votre application de fonction. Non publié sur Azure. ❌
Dockerfile Définit un conteneur personnalisé pour le déploiement. ❌

Dans le modèle de programmation Python v2, Azure Functions utilise une approche basée sur des décorateurs pour définir des déclencheurs et des liaisons directement dans votre code. Chaque fonction est implémentée en tant que méthode globale sans état dans un function_app.py fichier.

Exemple

Voici une fonction simple qui répond à une requête HTTP :

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

Concepts clés

  • Le code importe le azure-functions package et utilise des décorateurs et des types pour définir l’application de fonction.
  • La fonction a un seul déclencheur HTTP.
  • L’objet HttpRequest contient des en-têtes de requête, des paramètres de requête, des paramètres de routage et le corps du message. Cette fonction obtient la valeur du paramètre de name requête à partir du params paramètre de l’objet HttpRequest .
  • Pour envoyer un nom dans cet exemple, ajoutez ?name={name} à l’URL de la fonction exposée. Par exemple, si vous l'exécutez localement, l’URL complète peut ressembler à http://localhost:7071/api/http_trigger?name=Test. Pour obtenir des exemples d’utilisation de liaisons, consultez Déclencheurs et liaisons.

Bibliothèque azure-functions

La azure-functions bibliothèque Python fait partie intégrante du modèle de programmation Azure Functions. Il fournit les décorateurs, les types de déclencheur et de liaison, ainsi que les objets de requête/réponse utilisés pour définir et interagir avec les fonctions au moment de l’exécution. Pour afficher tous les types et décorateurs disponibles, visitez l’APIazure-functions. Le code de votre application de fonction dépend de cette bibliothèque pour :

  • Définir toutes les fonctions à l’aide de l’objet FunctionApp
  • Déclarer des déclencheurs et des liaisons (par exemple, @app.route, @app.timer_trigger)
  • Accès aux entrées et sorties typées (comme HttpRequest, HttpResponse, et Out`)

azure-functions doit être inclus dans les dépendances de votre projet. Pour en savoir plus, consultez la gestion des packages.

Remarque

La azure-functions bibliothèque définit l’aire de programmation pour Python Azure Functions, mais elle n’est pas un SDK à usage général. Utilisez-le spécifiquement pour la création et l’exécution de fonctions dans le runtime Azure Functions.

Utilisez des annotations de type pour améliorer la prise en charge d’IntelliSense et de l’éditeur :

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

Organisation avec des plans

Pour les applications plus volumineuses ou modulaires, utilisez des blueprints pour définir des fonctions dans des fichiers Python distincts et les inscrire auprès de votre application principale. Cette séparation conserve votre code organisé et réutilisable.

Pour définir et inscrire un blueprint :

  1. Définissez un blueprint dans un autre fichier Python, tel que 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. Inscrivez le blueprint dans le fichier principal function_app.py :

    import azure.functions as func
from http_blueprint import bp

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

À l’aide de blueprints, vous pouvez :

  • Diviser votre application en modules réutilisables
  • Conserver les fonctions associées regroupées par fichier ou fonctionnalité
  • Étendre ou partager des blueprints entre des projets

Remarque

Durable Functions prend également en charge les blueprints en utilisant azure-functions-durable. Afficher l’exemple de →

Structure de dossiers

Utilisez la structure suivante pour un projet Azure Functions Python :

<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

Fichiers et dossiers clés

Fichier/dossier Descriptif Obligatoire pour que l’application s’exécute dans Azure
function_app.py Script principal où Azure Functions et les déclencheurs sont définis à l’aide de décorateurs. ✅
host.json Configuration globale pour toutes les fonctions de l’application. ✅
requirements.txt Dépendances Python installées lors de la publication lors de l’utilisation de la build distante. ❌ (recommandé pour la gestion des packages)
local.settings.json Paramètres et secrets de l’application locale uniquement (jamais publiés). ❌ (requis pour le développement local)
.funcignore Spécifie les fichiers et dossiers à exclure du déploiement (par exemple, .venv/, tests/, local.settings.json). ❌ (recommandé)
.venv/ Environnement virtuel local pour Python (exclu du déploiement). ❌
.vscode/ Configuration de l’éditeur pour Visual Studio Code. Non requis pour le déploiement. ❌
shared/ Contient le code d’assistance partagé dans le projet Function App ❌
additional_functions/ Utilisé pour l’organisation du code modulaire, généralement avec des blueprints. ❌
tests/ Tests unitaires pour votre application de fonction. Non publié sur Azure. ❌
Dockerfile Définit un conteneur personnalisé pour le déploiement. ❌

[REMARQUE :] Incluez un fichier requirements.txt lorsque vous déployez avec la compilation distante. Si vous n’utilisez pas de build distante ou si vous souhaitez utiliser un autre fichier pour définir des dépendances d’application, vous pouvez effectuer une build locale et déployer l’application avec des dépendances prédéfinies.

Pour obtenir des conseils sur les tests unitaires, consultez Tests unitaires. Pour les déploiements de conteneurs, consultez Déployer avec des conteneurs personnalisés.

Déclencheurs et liaisons

Azure Functions utilise des déclencheurs pour démarrer l’exécution et les liaisons de fonction pour connecter votre code à d’autres services tels que le stockage, les files d’attente et les bases de données. Dans le modèle de programmation Python v2, vous déclarez des liaisons à l’aide de décorateurs.

Deux types principaux de liaisons existent :

  • Déclencheurs (entrée qui démarre la fonction)
  • Entrées et sorties (sources de données ou destinations supplémentaires)

Pour plus d’informations sur les déclencheurs et les liaisons disponibles, consultez Déclencheurs et liaisons dans Azure Functions.

Exemple : déclencheur de minuterie avec entrée Blob

Cette fonction :

  • Déclencheurs toutes les 10 minutes
  • Lit à partir d’un objet blob à l’aide de liaisons de type SDK
  • Met en cache les résultats et les écritures dans un fichier temporaire
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}")

Concepts clés

  • Utilisez des liaisons de type SDK pour travailler avec des types enrichis. Pour plus d’informations, consultez les liaisons de type sdk.
  • Vous pouvez utiliser des variables globales pour mettre en cache des calculs onéreux, mais il n'est pas garanti que leur état persiste au cours des exécutions de fonction.
  • Les fichiers temporaires sont stockés dans tmp/ et leur persistance n'est pas garantie à travers les invocations ou les instances lorsque le système s'étend.
  • Vous pouvez accéder au contexte d’appel d’une fonction via la classe Context.

Exemple : Déclencheur HTTP avec entrée Cosmos DB et sortie Event Hub

Cette fonction :

  • Déclencheurs sur une requête HTTP
  • Lectures à partir d’une base de données Cosmos DB
  • Écrit à un Event Hub de sortie
  • Retourne une réponse HTTP
# __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"
    }
  ]
}

concepts clés

  • Chaque fonction a un déclencheur unique, mais elle peut avoir plusieurs liaisons.
  • Ajoutez des entrées en spécifiant la direction valeur « in » dans function.json. Les sorties ont un direction de out.
  • Vous pouvez accéder aux détails de la demande via l’objet HttpRequest et construire un objet personnalisé HttpResponse avec des en-têtes, un code d’état et un corps.
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
    )

Concepts clés

  • Utilisez @route() ou des décorateurs spécifiques au déclencheur (@timer_trigger, @queue_trigger et d’autres) pour définir la façon dont votre fonction est invoquée.
  • Ajoutez des entrées à l’aide d’éléments décoratifs tels que @blob_input, @queue_inputet d’autres.
  • Les sorties peuvent être les suivantes :
    • Retourné directement (s'il n’y a qu’un résultat)
    • Affecté à l’aide Out des liaisons et de la .set() méthode pour plusieurs sorties.
  • Vous pouvez accéder aux détails de la demande via l’objet HttpRequest et construire un objet personnalisé HttpResponse avec des en-têtes, un code d’état et un corps.

Liaisons de type sdk

Pour sélectionner des déclencheurs et des liaisons, vous pouvez utiliser des types de données implémentés par les frameworks et les kits de développement logiciel (SDK) Azure sous-jacents. À l’aide de ces liaisons de type sdk, vous pouvez interagir avec les données de liaison comme si vous utilisiez le Kit de développement logiciel (SDK) de service sous-jacent. Pour plus d’informations, consultez les liaisons de types SDK supportées.

Important

La prise en charge des liaisons de type sdk pour Python est disponible uniquement dans le modèle de programmation Python v2.

Variables d'environnement

Les variables d’environnement dans Azure Functions vous permettent de gérer en toute sécurité les valeurs de configuration, les chaînes de connexion et les secrets d’application sans les coder en dur dans votre code de fonction.

Vous pouvez définir des variables d’environnement :

Accédez aux variables directement dans votre code à l’aide os.environ ou os.getenv.

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

Remarque

Azure Functions reconnaît également les variables d’environnement système qui configurent le comportement du runtime Functions et du worker Python. Ces variables ne sont pas explicitement utilisées dans votre code de fonction, mais affectent la façon dont votre application s’exécute. Pour obtenir la liste complète des variables d’environnement système, consultez la référence des paramètres de l’application.

Gestion des packages

Pour utiliser d’autres packages Python dans votre application Azure Functions, listez-les dans un requirements.txt fichier à la racine de votre projet. Ces packages sont importés par le système d’importation de Python, et vous pouvez ensuite référencer ces packages comme d’habitude. Pour en savoir plus sur les options de création et de déploiement avec des dépendances externes, consultez Options de génération pour les applications de fonction Python.

Par exemple, l’exemple suivant montre comment le requests module est inclus et utilisé dans l’application de fonction.

<requirements.txt>
requests==2.31.0

Installez le package localement avec pip install -r requirements.txt.

Une fois le package installé, vous pouvez l’importer et l’utiliser dans votre code de fonction :

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

Considérations

  • Conflits avec les modules intégrés :
    • Évitez de nommer vos dossiers de projet après les bibliothèques standard Python (par exemple, email/, json/).
    • N’incluez pas de bibliothèques natives Python (comme logging, asyncioou uuid) dans requirements.txt.
  • Déploiement:
    • Pour éviter les ModuleNotFound erreurs, vérifiez que toutes les dépendances requises sont répertoriées dans requirements.txt.
    • Si vous mettez à jour la version python de votre application, regénez et redéployez votre application sur la nouvelle version de Python pour éviter les conflits de dépendances avec les packages créés précédemment.
  • Dépendances non-PyPI :
  • Les dépendances du travailleur Python d'Azure Functions :
    • Si votre package contient certaines bibliothèques qui peuvent entrer en conflit avec les dépendances du worker (par exemple, protobuf ou grpcio), configurez PYTHON_ISOLATE_WORKER_DEPENDENCIES à 1 dans les paramètres d’application pour empêcher votre application de faire référence aux dépendances du worker. Pour Python 3.13 et versions ultérieures, cette fonctionnalité est activée par défaut.

Exécution et déploiement

Cette section fournit des informations sur l’exécution de fonctions localement, la prise en charge des versions de Python, les options de génération et de déploiement et la configuration du runtime. Utilisez ces informations pour exécuter correctement votre application de fonction dans des environnements locaux et Azure.

Exécution locale

Vous pouvez exécuter et tester votre application de fonction Python sur votre ordinateur local avant de le déployer sur Azure.

Utilisation d’Azure Functions Core Tools

Installez Azure Functions Core Tools et démarrez le runtime local en exécutant la func start commande à partir de la racine de votre projet :

func start

Lorsque vous démarrez l’application de fonction localement, Core Tools affiche toutes les fonctions qu’il trouve pour votre application :

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

Pour en savoir plus sur l’utilisation de Core Tools, consultez Développer Azure Functions localement à l’aide de Core Tools.

Appel direct de la fonction

En utilisant azure-functions >= 1.21.0, vous pouvez également appeler des fonctions directement à l’aide de l’interpréteur Python sans exécuter Core Tools. Cette approche est utile pour les tests unitaires rapides :

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

Pour afficher la sortie, exécutez le fichier directement avec 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))

Pour afficher la sortie, exécutez le fichier directement avec Python :

> python __init__.py

Hello, World!

Cette approche ne nécessite aucun package supplémentaire ni configuration et est idéale pour la validation rapide pendant le développement. Pour plus d’informations sur les tests approfondis, consultez Tests unitaires

Versions de Python prises en charge

Azure Functions prend en charge les versions python répertoriées dans les langages pris en charge dans Azure Functions. Pour plus d’informations générales, consultez la stratégie de prise en charge du runtime Azure Functions.

Important

Si vous modifiez la version de Python pour votre application de fonction, vous devez reconstruire et redéployer l’application à l’aide de la nouvelle version. Les artefacts et dépendances de déploiement existants ne sont pas régénérés automatiquement lorsque la version de Python change.

Compilation et déploiement

Pour en savoir plus sur le mécanisme de génération recommandé pour votre scénario, consultez Options de build. Pour obtenir une vue d’ensemble générale du déploiement, consultez Les technologies de déploiement dans Azure Functions.

Comparaison rapide des mécanismes de déploiement

Outil / Plateforme Commande / Action Meilleur cas d'utilisation
Azure Functions Core Tools func azure functionapp publish <APP_NAME> Idéal pour les exécutions CI, l’automatisation locale ou quand vous travaillez sur plusieurs plateformes.
AZ CLI az functionapp deployment source config-zip Utile lors de l’écriture de scripts en dehors des outils principaux. Fonctionne bien dans les pipelines automatisés ou les terminaux cloud (Azure Cloud Shell).
Visual Studio Code (extension Azure Functions) Palette de commandes → « Azure Functions : Déployer sur Azure... » Idéal pour les débutants ou les déploiements interactifs. Gère automatiquement l’empaquetage et la compilation.
GitHub Actions Azure/functions-action@v1 Idéal pour le CI/CD basé sur GitHub. Active les déploiements automatisés lors des fusions de push ou des PR.
Azure Pipelines AzureFunctionApp@2 Tâche CI/CD d’entreprise à l’aide d’Azure DevOps. Idéal pour les flux de travail de mise en production contrôlés, les compilations avec étapes de validation et les pipelines à plusieurs étapes.
Déploiement de conteneurs personnalisé Envoi de conteneur → az functionapp create --image <container> Obligatoire lorsque vous avez besoin de packages au niveau du système d’exploitation, de builds Python personnalisées, d’exécutions épinglées ou de dépendances non prises en charge (par exemple, bibliothèques système, fichiers binaires locaux).
Création de fonctions basée sur le portail Créer une fonction dans le portail Azure → éditeur inline Utilisez uniquement pour les fonctions simples et sans dépendance. Idéal pour les démonstrations ou l’apprentissage, mais pas recommandé pour les applications nécessitant des packages tiers.

Remarque

La création de fonctions basée sur le portail ne prend pas en charge les dépendances tierces et n’est pas recommandée pour la création d’applications de production. Vous ne pouvez pas installer ou référencer des packages en dehors azure-functions de la bibliothèque standard Python intégrée.

Important

Après le 30 septembre 2028, l’option d’hébergement de votre application de fonction sur Linux dans un plan Consommation est supprimée. Pour éviter les interruptions, migrez vos applications de plan consommation existantes qui s’exécutent sur Linux vers le plan Flex Consumption avant cette date. Les applications s’exécutant sur Windows dans un plan Consommation ne sont pas affectées par cette modification. Pour plus d’informations, consultez l’avis de mise hors service du plan de consommation Linux.

Mises à jour python 3.13+

À compter de Python 3.13, Azure Functions introduit plusieurs améliorations majeures du runtime et des performances qui affectent la façon dont vous générez et exécutez vos applications. Les principales modifications sont les suivantes :

  • Contrôle de version du runtime : vous pouvez désormais épingler ou mettre à jour votre application vers des versions spécifiques du worker Python en référençant le paquet azure-functions-runtime dans votre requirements.txt.

    • Sans contrôle de version activé, votre application s’exécute sur une version par défaut du runtime Python, que Functions gère. Vous devez modifier votre fichier requirements.txt pour demander la dernière version publiée, une version préreleasée ou pour épingler votre application à une version spécifique du runtime Python.

    • Vous activez le contrôle de version du runtime en ajoutant une référence au package d’exécution Python à votre fichier requirements.txt , où la valeur affectée au package détermine la version du runtime utilisée.

    • Évitez d’épingler une application de production aux versions de préversion (alpha, bêta ou dev) de versions du runtime.

    • Pour connaître les modifications, consultez régulièrement les notes de publication du runtime Python .

    • Le tableau suivant indique le comportement de contrôle de version en fonction de la valeur de version de ce paramètre dans votre fichier requirements.txt :

      Version Example Comportement
      Aucune valeur définie azure-functions-runtime Votre application Python 3.13+ s’exécute sur la dernière version disponible du runtime Functions Python. Cette option est idéale pour rester à jour avec les améliorations et fonctionnalités de la plateforme, car votre application reçoit automatiquement les dernières mises à jour du runtime stable.
      Épinglé à une version spécifique azure-functions-runtime==1.2.0 Votre application Python 3.13+ reste sur la version épinglée du runtime et ne reçoit pas de mises à jour automatiques. Vous devez mettre à jour manuellement votre version épinglée pour tirer parti des nouvelles fonctionnalités, des correctifs et des améliorations apportées à l'environnement d'exécution. L’épinglage est recommandé pour les charges de travail de production critiques où la stabilité et la prévisibilité sont essentielles. L’épinglage vous permet également de tester votre application sur les versions préliminaires de l'environnement d'exécution pendant le développement.
      Aucune référence de package n/a En ne définissant pas , azure-functions-runtimevotre application Python 3.13+ s’exécute sur une version par défaut du runtime Python qui se trouve derrière la dernière version publiée. Les mises à jour sont effectuées régulièrement par Functions. Cette option garantit la stabilité et la compatibilité étendue. Toutefois, l’accès aux dernières fonctionnalités et correctifs est retardé jusqu’à ce que la version par défaut soit mise à jour.

  • Isolation des dépendances : les dépendances de votre application (comme grpcio ou protobuf) sont entièrement isolées des dépendances du worker, ce qui empêche les conflits de version. Le paramètre PYTHON_ISOLATE_WORKER_DEPENDENCIES d’application n’aura aucun impact sur les applications s’exécutant sur Python 3.13 ou version ultérieure.

  • Configuration simplifiée du streaming HTTP : aucun paramètre d’application spécial n’est requis.

  • Suppression de la prise en charge des extensions de travail et des fonctionnalités de mémoire partagée.

  • Contrôle de version du runtime : vous pouvez désormais épingler ou mettre à niveau votre application vers des versions spécifiques du worker de Python en référençant le package azure-functions-runtime-v1 dans votre requirements.txt.

    • Sans contrôle de version activé, votre application s’exécute sur une version par défaut du runtime Python, que Functions gère. Vous devez modifier votre fichier requirements.txt pour demander la dernière version publiée, une version préreleasée ou pour épingler votre application à une version spécifique du runtime Python.

    • Vous activez le contrôle de version du runtime en ajoutant une référence au package d’exécution Python à votre fichier requirements.txt , où la valeur affectée au package détermine la version du runtime utilisée.

    • Évitez d'épingler toute application de production à des versions précoces (alpha, bêta ou dev) des versions d'exécution.

    • Pour connaître les modifications, consultez régulièrement les notes de publication du runtime Python .

    • Le tableau suivant indique le comportement de contrôle de version en fonction de la valeur de version de ce paramètre dans votre fichier requirements.txt :

      Version Example Comportement
      Aucune valeur définie azure-functions-runtime-v1 Votre application Python 3.13+ s’exécute sur la dernière version disponible du runtime Functions Python. Cette option est idéale pour rester à jour avec les améliorations et fonctionnalités de la plateforme, car votre application reçoit automatiquement les dernières mises à jour du runtime stable.
      Épinglé à une version spécifique azure-functions-runtime-v1==1.2.0 Votre application Python 3.13+ reste sur la version épinglée du runtime et ne reçoit pas de mises à jour automatiques. Vous devez à la place mettre à jour manuellement votre version épinglée pour tirer parti des nouvelles fonctionnalités, des correctifs et des améliorations apportées au runtime. L’épinglage est recommandé pour les charges de travail de production critiques où la stabilité et la prévisibilité sont essentielles. L’épinglage permet aussi de tester votre application sur des versions préliminaires de l'environnement d'exécution pendant le développement.
      Aucune référence de package n/a En ne définissant pas , azure-functions-runtime-v1votre application Python 3.13+ s’exécute sur une version par défaut du runtime Python qui se trouve derrière la dernière version publiée. Les mises à jour sont effectuées régulièrement par Functions. Cette option garantit la stabilité et la compatibilité étendue. Toutefois, l’accès aux dernières fonctionnalités et correctifs est retardé jusqu’à ce que la version par défaut soit mise à jour.

  • Isolation des dépendances : les dépendances de votre application (comme grpcio ou protobuf) sont entièrement isolées des dépendances du worker, ce qui empêche les conflits de version. Le paramètre PYTHON_ISOLATE_WORKER_DEPENDENCIES d’application n’aura aucun impact sur les applications s’exécutant sur Python 3.13 ou version ultérieure.

  • Suppression de la prise en charge des extensions de travail et des fonctionnalités de mémoire partagée.

Observabilité et test

Cette section traite des fonctionnalités de journalisation, de supervision et de test pour vous aider à déboguer des problèmes, à suivre les performances et à garantir la fiabilité de vos applications de fonction Python.

Enregistrement et surveillance

Azure Functions expose un enregistreur d’événements racine que vous pouvez utiliser directement avec le module intégré logging de Python. Tous les messages écrits à l’aide de cet enregistreur d’événements sont automatiquement envoyés à Application Insights lorsque votre application s’exécute dans Azure.

La journalisation vous permet de capturer des informations d’exécution et de diagnostiquer les problèmes sans avoir besoin d’une configuration supplémentaire.

Exemple de journalisation avec un déclencheur HTTP

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

Vous pouvez utiliser l’ensemble complet de niveaux de journalisation (debug, , infowarning, error, ), criticalet ils apparaissent dans le portail Azure sous Journaux ou Application Insights.

Pour en savoir plus sur la surveillance d’Azure Functions dans le portail, consultez Monitor Azure Functions.

Remarque

Pour afficher les journaux de débogage dans Application Insights, une configuration supplémentaire est requise. Vous pouvez activer cette fonctionnalité en définissant PYTHON_ENABLE_DEBUG_LOGGING sur 1 et en définissant logLevel sur trace ou debug dans votre fichierhost.json. Par défaut, les journaux de débogage ne sont pas visibles dans Application Insights.

Enregistrement des logs à partir de threads en arrière-plan

Si votre fonction démarre un nouveau thread et doit se connecter à partir de ce thread, veillez à passer l’argument context dans le thread. Le context contient le stockage local de thread et le thread actuel invocation_id, qui doit être configuré sur le thread de travail afin que les journaux soient correctement associés à l'exécution de la fonction.

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

Configuration des enregistreurs d’événements personnalisés

Vous pouvez configurer des enregistreurs d’événements personnalisés en Python lorsque vous avez besoin d’un contrôle supplémentaire sur le comportement de journalisation, comme la mise en forme personnalisée, le filtrage des journaux ou les intégrations tierces. Pour configurer un enregistreur d’événements logging.getLogger() personnalisé, utilisez Python avec un nom personnalisé et ajoutez des gestionnaires ou des formateurs si nécessaire.

import logging

custom_logger = logging.getLogger('my_custom_logger')

Prise en charge d’OpenTelemetry

Azure Functions pour Python prend en charge également OpenTelemetry, ce qui vous permet d’émettre des traces, des mesures et des journaux dans un format standardisé. L’utilisation d’OpenTelemetry est particulièrement utile pour les applications distribuées ou les scénarios où vous souhaitez exporter des données de télémétrie vers des outils en dehors d’Application Insights (par exemple, Grafana ou Jaeger).

Consultez notre guide de démarrage rapide OpenTelemetry pour Azure Functions (Python) pour obtenir des instructions d’installation et des exemples de code.

Test des unités

Écrivez et exécutez des tests unitaires pour vos fonctions à l’aide de pytest. Vous pouvez tester des fonctions Python comme d’autres code Python à l’aide de frameworks de test standard. Pour la plupart des liaisons, vous pouvez créer un objet d’entrée fictif en créant une instance d’une classe appropriée à partir du azure.functions package.

En utilisant my_function comme exemple, le test suivant est un test fictif d'une fonction déclenchée par HTTP :

Tout d’abord, créez le <fichier project_root>/function_app.py et implémentez la my_function fonction en tant que déclencheur HTTP.

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

Vous pouvez commencer à écrire des cas de test pour votre déclencheur HTTP.

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

Dans votre dossier d’environnement virtuel Python, vous pouvez exécuter les commandes suivantes pour tester l’application :

pip install pytest
pytest test_my_function.py

Vous voyez les pytest résultats dans le terminal, comme suit :

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

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

Optimisation et rubriques avancées

Pour en savoir plus sur l’optimisation de vos applications de fonctions Python, consultez les articles suivants :

Pour plus d’informations sur Functions, consultez les articles suivants :

Vous rencontrez des problèmes avec l’utilisation de Python ? Informez-nous et déposez un problème.

  • Last updated on