Function Compute:Présentation des déclencheurs HTTP

Fonctionnement

Un déclencheur HTTP expose votre fonction sous la forme d'un endpoint HTTP. Lorsqu'une requête arrive, Function Compute l'authentifie (si cette option est configurée), puis transmet la requête à votre fonction et renvoie la réponse HTTP correspondante à l'appelant.

Méthodes HTTP prises en charge : GET, POST, PUT, DELETE, HEAD, PATCH et OPTIONS.

Exemple de gestionnaire de fonction web minimal en Node.js :

exports.handler = (event, context, callback) => {
  const request = JSON.parse(event);
  const response = {
    statusCode: 200,
    headers: { 'Content-Type': 'text/plain' },
    body: 'Hello from Function Compute'
  };
  callback(null, response);
};

L'objet event contient l'intégralité de la requête HTTP (chemin, en-têtes, corps, méthode). Pour envoyer une réponse HTTP, renvoyez un objet comprenant statusCode, headers et body.

Remarques d'utilisation

Avant de développer avec des déclencheurs HTTP, prenez connaissance des comportements suivants.

Risque lié à l'accès anonyme

Si vous définissez Authentication Method sur No Authentication, toute personne disposant de l'URL de l'endpoint peut invoquer votre fonction. Pour appliquer une autorisation personnalisée, validez l'en-tête Authorization dans le code de votre fonction. Pour plus d'informations, consultez Configurer l'authentification par signature pour les déclencheurs HTTP.

Restriction de téléchargement des fichiers APK

Depuis le 10 juin 2024, les déclencheurs HTTP nouvellement créés bloquent le téléchargement des fichiers APK (type MIME application/vnd.android.package-archive) via les endpoints du réseau public. Les requêtes renvoient le code d'état HTTP 400. Pour plus d'informations, consultez Comment garantir que l'endpoint public de votre déclencheur HTTP renvoie correctement les fichiers .apk.

Rotation des adresses VIP

Function Compute fait tourner périodiquement les adresses IP virtuelles (VIP) associées aux endpoints publics et privés. Le codage en dur des VIP entraîne des interruptions de service non couvertes par l'accord de niveau de service (SLA) de Function Compute. Utilisez un nom de domaine personnalisé avec une configuration CNAME pour assurer un accès stable. Pour plus d'informations, consultez Configurer un nom de domaine personnalisé.

Comportement du domaine par défaut et des pièces jointes

Lorsque vous utilisez le domaine par défaut aliyuncs.com, Function Compute ajoute l'en-tête content-disposition: attachment à toutes les réponses. Cela force les navigateurs à télécharger les réponses sous forme de fichiers au lieu de les afficher. Configurez un nom de domaine personnalisé pour désactiver ce comportement.

Limites

Méthodes d'invocation

Authentification et autorisation

Les appelants externes doivent réussir les vérifications d'authentification de Function Compute avant d'accéder à votre fonction via un déclencheur HTTP. Méthodes prises en charge :

• Authentification par signature

• Authentification de base

• Authentification JWT

• Authentification Bearer

Partage des ressources entre origines multiples (CORS)

Function Compute propose trois méthodes pour gérer les requêtes de partage de ressources entre origines multiples (CORS), chacune présentant des compromis différents en termes de coût, de complexité et de flexibilité.

exports.handler = (event, context, callback) => {
  const method = JSON.parse(event).requestContext.http.method;
  if (method === 'OPTIONS') {
    const fcResponse = {
      statusCode: 204,
      headers: {
        'Access-Control-Allow-Origin': 'http://www.fc.com',
        'Access-Control-Allow-Methods': 'POST',
        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
        'Access-Control-Max-Age': '3600'
      },
      body: ''
    };
    callback(null, fcResponse);
  } else {
    callback(null, {
      statusCode: 200,
      body: 'hello world'
    });
  }
};

import json

def handler(event, context):
    evt = json.loads(event)
    method = evt.get('requestContext', {}).get('http', {}).get('method', '')
    if method == 'OPTIONS':
        return {
            'statusCode': 204,
            'headers': {
                'Access-Control-Allow-Origin': 'http://www.fc.com',
                'Access-Control-Allow-Methods': 'POST',
                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
                'Access-Control-Max-Age': '3600'
            },
            'body': ''
        }
    return {
        'statusCode': 200,
        'body': 'hello world'
    }

package main

import (
    "context"
    "encoding/json"
)

type HttpRequest struct {
    RequestContext struct {
        Http struct {
            Method string `json:"method"`
        } `json:"http"`
    } `json:"requestContext"`
}

type HttpResponse struct {
    StatusCode int               `json:"statusCode"`
    Headers    map[string]string `json:"headers"`
    Body       string            `json:"body"`
}

func Handler(ctx context.Context, event []byte) (*HttpResponse, error) {
    var req HttpRequest
    if err := json.Unmarshal(event, &req); err != nil {
        return nil, err
    }
    if req.RequestContext.Http.Method == "OPTIONS" {
        return &HttpResponse{
            StatusCode: 204,
            Headers: map[string]string{
                "Access-Control-Allow-Origin":  "http://www.fc.com",
                "Access-Control-Allow-Methods": "POST",
                "Access-Control-Allow-Headers": "Content-Type, Authorization",
                "Access-Control-Max-Age":       "3600",
            },
            Body: "",
        }, nil
    }
    return &HttpResponse{StatusCode: 200, Body: "hello world"}, nil
}

Déclencheur HTTP vs déclencheur API Gateway

Les déclencheurs HTTP et les déclencheurs API Gateway permettent tous deux de créer des applications web.

Les déclencheurs HTTP offrent les avantages suivants par rapport aux déclencheurs API Gateway :

• Configuration plus rapide et débogage simplifié, sans configuration de passerelle supplémentaire.

• Aucune surcharge d'encodage ou de décodage JSON : les déclencheurs HTTP transmettent directement les requêtes et les réponses.

• Compatibilité avec les outils de test HTTP standard.

• Intégration aisée avec les services prenant en charge les webhooks, tels que l'extraction d'origine CDN et Simple Message Queue (anciennement MNS).

FAQ

Pourquoi mon appel d'API échoue-t-il après avoir ajouté OPTIONS à allowMethods ?

N'ajoutez pas OPTIONS à corsConfig.allowMethods. La passerelle gère automatiquement toutes les requêtes préliminaires. L'inclusion manuelle de OPTIONS provoque des erreurs de traitement des requêtes.

Après avoir configuré le CORS par API, les requêtes OPTIONS renvoient 200 au lieu de 204. Pourquoi ?

Confirmez que votre compte a bien obtenu l'accès à l'aperçu sur invitation. Si le plugin de passerelle n'est pas entièrement activé, celle-ci revient au comportement CORS par défaut, qui renvoie 200 et transfère la requête à votre fonction.

**Puis-je utiliser des caractères génériques de sous-domaine dans allowOrigins, par exemple *.example.com ?**

Non. Les caractères génériques de sous-domaine ne sont pas pris en charge. Répertoriez explicitement tous les domaines requis dans le tableau allowOrigins, ou utilisez https://* pour une correspondance large des origines HTTPS.

Le code de ma fonction définit également des en-têtes CORS. Y aura-t-il des conflits ?

Non. Les en-têtes générés par la passerelle et ceux renvoyés par la fonction sont fusionnés. En cas de doublons, les navigateurs utilisent la première valeur conforme. Les applications existantes continuent de fonctionner pendant la migration.