Déployer une API Serverless avec Azure Functions et Azure API Management

Introduction

Dans un contexte où la rapidité de mise sur le marché et la scalabilité sont des exigences majeures, les architectures serverless offrent une alternative flexible aux services traditionnels. Azure Functions fournit le moteur d’exécution, tandis qu’Azure API Management (APIM) permet de publier, versionner et sécuriser les points d’entrée. Cet article vous guide pas à pas : création d’une Function, exposition via APIM et sécurisation avec Azure Active Directory.

Créer l’Azure Function

1. Pré-requis : Azure CLI (v2.30+), un compte Azure et le module azure-functions-core-tools.
2. Création du projet :

# Crée un répertoire et initialise un projet Function en Python
mkdir my_api && cd my_api
func init --worker-runtime python

3. Ajout d’une fonction HTTP :

func new --name hello --template "HTTP trigger" --authlevel "function"

Le fichier hello/__init__.py contiendra le code métier :

import logging
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')
    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')
    if name:
        return func.HttpResponse(f"Hello, {name}!")
    else:
        return func.HttpResponse(
            "Please pass a name on the query string or in the request body",
            status_code=400
        )

4. Déploiement :

# Crée le groupe de ressources et le plan de consommation
az group create --name rg-serverless --location eastus
az functionapp create \
  --resource-group rg-serverless \
  --consumption-plan-location eastus \
  --runtime python \
  --functions-version 4 \
  --name myapi-func \
  --storage-account mystorageaccount

# Déploie le code
func azure functionapp publish myapi-func

À ce stade, l’URL de la fonction ressemble à : https://myapi-func.azurewebsites.net/api/hello?name=World.

Configurer Azure API Management

APIM agit comme une passerelle frontale, offrant :

• Un point d’entrée unique (https://myapi.azure-api.net).
• Le versionnage des API.
• Des politiques (quota, transformation, etc.).

Provisionnement d’un service APIM

az apim create \
  --name myapi-apim \
  --resource-group rg-serverless \
  --publisher-email dev@example.com \
  --publisher-name "Dev Team" \
  --sku-name Consumption

Import de la Function dans APIM

Dans le portail Azure :

1. Ouvrez le service APIM créé.
2. Accédez à API > + Add API > Function App.
3. Sélectionnez le groupe de ressources rg-serverless et la Function App myapi-func.
4. Azure détecte automatiquement l’opération hello. Validez l’import.

Publication d’un point d’accès public

APIM crée une URL publique : https://myapi-apim.azure-api.net/hello. Vous pouvez maintenant ajouter un suffixe de version (v1) via la configuration de l’API.

Sécuriser l’API avec Azure AD

Pour éviter l’accès anonyme, nous utilisons le flux OAuth 2.0 avec Azure AD.

1. Enregistrement d’une application :

az ad app create \
  --display-name "myapi-client" \
  --identifier-uris "api://myapi" \
  --reply-urls "https://myapi-apim.azure-api.net"

Notez l’appId (client ID). 2. Création d’un secret :

az ad app credential reset \
  --id <appId> \
  --append \
  --credential-description "client-secret" \
  --years 2

3. Déclaration dans APIM :
   • Dans APIM → Security > OAuth 2.0 : ajoutez un serveur OAuth avec l’authorization endpoint (https://login.microsoftonline.com/<tenant>/oauth2/v2.0/authorize) et le token endpoint correspondant.
   • Dans la section API > Settings, associez la politique validate-jwt à votre API :

<validate-jwt header-name="Authorization" failed-validation-httpcode="401" require-scheme="Bearer">
  <openid-config url="https://login.microsoftonline.com/<tenant>/v2.0/.well-known/openid-configuration" />
  <required-claims>
    <claim name="aud" match="any" >api://myapi</claim>
  </required-claims>
</validate-jwt>

Désormais, chaque appel doit fournir un jeton d’accès valide.

Tests et bonnes pratiques

• Test local : func start puis curl "http://localhost:7071/api/hello?name=Test".
• Postman : configurez l’autorisation OAuth 2.0, récupérez le jeton et appelez https://myapi-apim.azure-api.net/hello.
• Surveillance : activez Application Insights sur la Function App et APIM pour suivre latence et erreurs.
• Gestion du cycle de vie : utilisez des slots de déploiement (staging) pour valider les nouvelles versions avant la mise en production.
• Limitation de débit : ajoutez une politique rate-limit-by-key dans APIM afin de protéger l’API contre les abus.

Conclusion

Combiner Azure Functions et Azure API Management permet de bâtir rapidement des APIs robustes, évolutives et sécurisées. En suivant les étapes décrites – création de la Function, importation dans APIM, sécurisation via Azure AD et mise en place de bonnes pratiques – vous disposez d’une architecture prête pour la production et les exigences de conformité des environnements cloud modernes.