Partage via

guide de référence Azure Functions développeur 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 de Azure Functions basées sur des 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 Azure Functions Référence du développeur.

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 passez à 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 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 . 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 de modèle Python spécifique. 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 état main() dans un fichier nommé __init__.py. Les déclencheurs et les liaisons de la fonction sont configurés séparément dans un fichier, et les valeurs de liaison sont utilisées comme paramètres dans votre 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 :

{
    "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 requête à partir du paramètre de l’objet HttpRequest .
  • Pour envoyer un nom dans cet exemple, ajoutez à l’URL de la fonction exposée. Par exemple, si vous l'exécutez localement, l’URL complète peut ressembler à . Pour obtenir des exemples d’utilisation de liaisons, consultez Déclencheurs et liaisons.

Utilisez le 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

La bibliothèque azure-functions 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’API. Votre code de fonction peut être utilisé pour :

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

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

Remarque

La bibliothèque azure-functions définit l’aire de programmation pour Python Azure Functions, mais ce n’est pas un SDK à usage général. Utilisez-le spécifiquement pour la création et l’exécution de fonctions au sein du 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 et dans le fichier . Par exemple, le fichier function.json suivant dirige le runtime pour utiliser la méthode custom_entry() dans le fichier main.py 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 Python Azure Functions :

<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 est défini. ✅
function.json/ Contient la configuration de liaison pour la fonction. ✅
host.json Configuration globale pour toutes les fonctions de l’application. ✅
requirements.txt Python dépendances installées lors de la publication lors de l’utilisation de remote build. (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, , , ). (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 decorator 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 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 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 requête à partir du paramètre de l’objet HttpRequest .
  • Pour envoyer un nom dans cet exemple, ajoutez à l’URL de la fonction exposée. Par exemple, si vous l'exécutez localement, l’URL complète peut ressembler à . Pour obtenir des exemples d’utilisation de liaisons, consultez Déclencheurs et liaisons.

Bibliothèque

La bibliothèque azure-functions 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’API. Le code de votre application de fonction dépend de cette bibliothèque pour :

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

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

Remarque

La bibliothèque azure-functions définit l’aire de programmation pour Python Azure Functions, mais ce n’est pas un SDK à usage général. Utilisez-le spécifiquement pour la création et l’exécution de fonctions au sein du 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 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 :

    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 à l’aide de azure-functions-durable. exemple View →

Structure de dossiers

Utilisez la structure suivante pour un projet Python Azure Functions :

<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ù les 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 Python dépendances installées lors de la publication lors de l’utilisation de remote build. (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, , , ). (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 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 triggers pour démarrer l’exécution de la fonction et bindings 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 liaisons disponibles, consultez Triggers et liaisons dans Azure Functions.

Exemple : déclencheur de minuteur 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 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 valeur « in » dans . Les sorties ont un de .
  • Vous pouvez accéder aux détails de la demande via l’objet et construire un objet personnalisé 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 ou des décorateurs spécifiques au déclencheur (, 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 , et d’autres.
  • Les sorties peuvent être les suivantes :
    • Retourné directement (s’il n’y a qu’un résultat)
    • Affecté à l’aide des liaisons et de la méthode pour plusieurs sorties.
  • Vous pouvez accéder aux détails de la demande via l’objet et construire un objet personnalisé 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 SDK Azure et frameworks 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 n’est disponible que 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 :

  • Localement : dans le fichierlocal.settings.json, pendant le développement local.
  • Dans Azure : comme Application Settings dans la page de configuration de votre application de fonction dans le portail Azure.

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

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

Remarque

Azure Functions reconnaît également les variables d’environnement système qui configurent le runtime Functions et Python comportement de travail. 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, répertoriez-les dans un fichier requirements.txt à 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 la création et le déploiement d’options avec des dépendances externes, consultez Build Options pour Python Function Apps.

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

<requirements.txt>
requests==2.31.0

Installez le package localement avec .

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 Python bibliothèques standard (par exemple, email/, json/).
    • N'incluez pas Python bibliothèques natives (comme logging, asyncio ou uuid) dans requirements.txt.
  • Déploiement:
    • Pour éviter les erreurs, vérifiez que toutes les dépendances requises sont répertoriées dans .
    • Si vous mettez à jour la version Python de votre application, régénérez et redéployez votre application sur la nouvelle version Python pour éviter les conflits de dépendances avec les packages créés précédemment.
  • Dépendances non-PyPI :
    • Vous pouvez inclure des dépendances qui ne sont pas disponibles sur PyPI dans votre application, telles que les packages locaux, les fichiers de roue ou les flux privés. Pour obtenir des instructions de configuration, consultez Dépendancescustom dans Python Azure Functions.
  • dépendances worker Azure Functions Python :
    • Si votre package contient certaines bibliothèques qui peuvent entrer en conflit avec les dépendances du worker (par exemple, ou ), 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 les fonctions running localement, Python prise en charge des versions, build et 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 déployer sur Azure.

Utilisation de Azure Functions Core Tools

Installez Azure Functions Core Tools et démarrez le runtime local en exécutant la commande func start à 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 Develop 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 Langues prises 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 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 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 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) Command Palette → « 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 GitHub CI/CD. Active les déploiements automatisés lors d’un push ou des fusions de PR.
Azure Pipelines Tâche CI/CD d’entreprise à l’aide de 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 → Obligatoire lorsque vous avez besoin de packages au niveau du système d’exploitation, de builds de 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 de azure-functions et de la bibliothèque standard intégrée Python.

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.

Après le 30 septembre 2025, aucune nouvelle fonctionnalité ni aucune nouvelle prise en charge de pile linguistique ne sera ajoutée au plan de consommation Linux. Les dernières versions de langage prises en charge pour la consommation Linux sont les suivantes : .NET 9, Python 3.12, Node.js 22, PowerShell 7.4 et Java 21. Les versions linguistiques plus récentes ne sont pas prises en charge pour la consommation Linux.

Pour plus d’informations, consultez Migrer les applications du plan Consommation vers le plan Flex Consumption.

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 à niveau votre application vers des versions de worker Python spécifiques en référençant le package azure-functions-runtime dans votre requirements.txt.

    • Sans le 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éversion 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 sur des versions d’exécution préliminaires (alpha, bêta ou dev).

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

    • 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 d'exécution épinglée 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 du runtime pendant le développement.
      Aucune référence de package n/a En ne définissant pas le azure-functions-runtime, votre 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 ou ) sont entièrement isolées des dépendances du worker, ce qui empêche les conflits de version. Le paramètre d’application PYTHON_ISOLATE_WORKER_DEPENDENCIES n’a 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 worker 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 de worker Python spécifiques en référençant le package azure-functions-runtime-v1 dans votre requirements.txt.

    • Sans le 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éversion 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 sur des versions d’exécution préliminaires (alpha, bêta ou dev).

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

    • 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 d'exécution épinglée 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 du runtime pendant le développement.
      Aucune référence de package n/a En ne définissant pas le azure-functions-runtime-v1, votre 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 ou ) sont entièrement isolées des dépendances du worker, ce qui empêche les conflits de version. Le paramètre d’application PYTHON_ISOLATE_WORKER_DEPENDENCIES n’a 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 worker et des fonctionnalités de mémoire partagée.

Observabilité et test

Cette section couvre logging, monitoring et testing fonctionnalités 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 logging intégré 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 des niveaux de journalisation (debug, info, warning, error, critical), et ils apparaissent dans le portail Azure sous Journaux ou Application Insights.

Pour en savoir plus sur la surveillance des 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 et en définissant sur ou dans votre fichierhost.json. Par défaut, les journaux de débogage ne sont pas visibles dans Application Insights.

Journalisation à partir des threads d’arrière-plan

Si votre fonction démarre un nouveau thread et doit se connecter à partir de ce thread, veillez à passer l’argument dans le thread. Le contient un stockage local de threads et le actuel, qui doit être défini 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 dans Python lorsque vous avez besoin d’un meilleur contrôle 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 personnalisé, utilisez Python'logging.getLogger() 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 également en charge OpenTelemetry, ce qui vous permet d’émettre des traces, des métriques 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 de configuration et des exemples de code.

Test des unités

Écrivez et exécutez des tests unitaires pour vos fonctions à l’aide de . Vous pouvez tester des fonctions Python comme d’autres Python code à 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 package.

En utilisant 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 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 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