M

MLOG

Français

Découvrez la puissance du serverless avec Google Cloud Functions. Ce guide explore les déclencheurs HTTP pour créer des applications évolutives et événementielles.

Google Cloud Functions : Guide complet des déclencheurs HTTP

Google Cloud Functions (GCF) est un environnement d'exécution serverless qui vous permet de créer et de connecter des services cloud. Avec Cloud Functions, vous écrivez des fonctions simples et mono-tâches qui sont attachées aux événements émis par votre infrastructure et vos services cloud. Votre fonction s'exécute lorsque l'événement que vous surveillez se produit. Cette approche vous permet de développer des applications événementielles sans gérer de serveurs ou d'environnements d'exécution.

L'une des méthodes les plus courantes pour déclencher une Cloud Function est via une requête HTTP. Ce guide plongera dans le monde des déclencheurs HTTP dans Google Cloud Functions, vous fournissant les connaissances nécessaires pour construire des applications puissantes, évolutives et rentables.

Qu'est-ce qu'un déclencheur HTTP ?

Un déclencheur HTTP vous permet d'exécuter votre Cloud Function en réponse à une requête HTTP. Essentiellement, lorsqu'une requête HTTP est envoyée à une URL spécifique, Google Cloud Functions exécutera automatiquement la fonction associée. Cela rend les déclencheurs HTTP idéaux pour la création d'API, de webhooks et d'applications web événementielles.

Avantages clés de l'utilisation des déclencheurs HTTP :

Création d'une Cloud Function avec un déclencheur HTTP

Suivons le processus de création d'une simple Cloud Function avec un déclencheur HTTP. Nous allons créer une fonction qui répond avec un message "Hello, World!". Cet exemple peut être adapté à diverses localisations mondiales en modifiant simplement la chaîne de sortie.

Prérequis :

Étapes :

  1. Créer un nouveau projet (si vous n'en avez pas) :

    Si vous n'avez pas encore de projet GCP, créez-en un dans la console Google Cloud.

  2. Activer l'API Cloud Functions :

    Dans la console Cloud, accédez à l'API Cloud Functions et activez-la.

  3. Créer un répertoire de fonction :

    Créez un nouveau répertoire pour votre Cloud Function. Par exemple :

    mkdir hello-http
cd hello-http
  4. Écrire le code de la fonction :

    Créez un fichier nommé `main.py` (ou `index.js` pour Node.js) avec le code suivant :

    Python (main.py) :

    def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): L'objet requête.
        
        
    Returns:
        Le texte de réponse, ou tout ensemble de valeurs pouvant être transformé en un
        objet Response à l'aide de `make_response`
        .
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return f'Hello, {name}!'

    Node.js (index.js) :

    exports.helloHttp = (req, res) => {
  let name = 'World';
  if (req.body.name) {
    name = req.body.name;
  } else if (req.query.name) {
    name = req.query.name;
  }
  res.status(200).send(`Hello, ${name}!`);
};
  5. Créer un fichier requirements (Python uniquement) :

    Si vous utilisez Python, créez un fichier nommé `requirements.txt` et ajoutez toutes les dépendances dont votre fonction a besoin. Pour cet exemple, il n'est pas strictement nécessaire, mais c'est une bonne pratique d'en inclure un. Vous pouvez le laisser vide si vous n'avez pas de dépendances.

  6. Déployer la fonction :

    Utilisez la commande `gcloud functions deploy` pour déployer votre fonction. Remplacez `VOTRE_NOM_DE_FONCTION` par le nom souhaité pour votre fonction.

    Python :

    gcloud functions deploy VOTRE_NOM_DE_FONCTION \
    --runtime python39 \
    --trigger-http \
    --allow-unauthenticated

    Node.js :

    gcloud functions deploy VOTRE_NOM_DE_FONCTION \
    --runtime nodejs16 \
    --trigger-http \
    --allow-unauthenticated

    Explication des paramètres :

    • `VOTRE_NOM_DE_FONCTION` : Le nom que vous souhaitez donner à votre Cloud Function.
    • `--runtime` : L'environnement d'exécution de votre fonction (par exemple, `python39`, `nodejs16`).
    • `--trigger-http` : Spécifie que la fonction doit être déclenchée par des requêtes HTTP.
    • `--allow-unauthenticated` : Permet à quiconque d'appeler la fonction sans authentification. Attention : Utilisez la prudence lorsque vous activez cela dans des environnements de production ! Envisagez de mettre en œuvre une authentification et une autorisation appropriées.
  7. Tester la fonction :

    Après le déploiement, la commande `gcloud` affichera l'URL de votre fonction. Vous pouvez ensuite la tester en envoyant une requête HTTP à cette URL à l'aide d'un outil comme `curl` ou Postman.

    curl VOTRE_URL_DE_FONCTION

    Vous devriez voir le message "Hello, World!" dans la réponse. Vous pouvez également passer un nom en tant que paramètre de requête :

    curl "VOTRE_URL_DE_FONCTION?name=VotreNom"

    Cela devrait renvoyer "Hello, VotreNom !"

Comprendre la requête et la réponse HTTP

Lorsqu'une Cloud Function est déclenchée par une requête HTTP, elle reçoit un objet contenant des informations sur la requête. Cet objet comprend généralement :

Votre fonction doit ensuite renvoyer une réponse HTTP, qui comprend :

Exemple : Gestion de différentes méthodes HTTP

Voici un exemple de la façon de gérer différentes méthodes HTTP dans votre Cloud Function :

Python (main.py) :

from flask import escape

def http_method(request):
    """Répond à toute requête HTTP.
    Args:
        request (flask.Request): Objet de requête HTTP.
    Returns:
        Le texte de réponse ou tout ensemble de valeurs pouvant être transformé en un
        objet Response à l'aide de
        `make_response``.
    """
    if request.method == 'GET':
        return 'Ceci est une requête GET !'
    elif request.method == 'POST':
        request_json = request.get_json(silent=True)
        if request_json and 'message' in request_json:
            message = escape(request_json['message'])
            return f'Ceci est une requête POST avec le message : {message}'
        else:
            return 'Ceci est une requête POST sans message.'
    else:
        return 'Méthode HTTP non prise en charge.', 405

Node.js (index.js) :

exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('Ceci est une requête GET !');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`Ceci est une requête POST avec le message : ${message}`);
      } else {
        res.status(200).send('Ceci est une requête POST sans message.');
      }
      break;
    default:
      res.status(405).send('Méthode HTTP non prise en charge !');
      break;
  }
};

N'oubliez pas de déployer la fonction mise à jour en utilisant la commande `gcloud functions deploy`.

Sécurisation de vos déclencheurs HTTP

La sécurité est primordiale lorsque vous travaillez avec des déclencheurs HTTP, surtout lorsque vous traitez des données sensibles ou des opérations critiques. Voici quelques considérations de sécurité clés :

Authentification et Autorisation

Par défaut, les Cloud Functions déclenchées par HTTP sont accessibles publiquement si vous utilisez `--allow-unauthenticated`. Dans la plupart des scénarios de production, vous voudrez restreindre l'accès aux utilisateurs ou services autorisés. Google Cloud propose plusieurs options d'authentification et d'autorisation :

Validation des entrées

Validez toujours les données d'entrée reçues par votre Cloud Function pour prévenir les vulnérabilités de sécurité telles que l'injection SQL ou le cross-site scripting (XSS). Utilisez des techniques de sanitisation et d'échappement appropriées pour vous protéger contre les entrées malveillantes.

HTTPS

Assurez-vous que votre Cloud Function n'est accessible que via HTTPS pour chiffrer la communication entre le client et la fonction. Google Cloud Functions fournit automatiquement des points de terminaison HTTPS.

Limitation du débit

Implémentez la limitation du débit pour prévenir les abus et les attaques par déni de service (DoS). Vous pouvez utiliser des services comme Google Cloud Armor pour protéger vos Cloud Functions contre le trafic excessif.

Cas d'utilisation des déclencheurs HTTP

Les déclencheurs HTTP sont polyvalents et peuvent être utilisés dans un large éventail d'applications. Voici quelques cas d'utilisation courants :

Exemples dans différentes industries

Techniques avancées

Utilisation des variables d'environnement

Les variables d'environnement vous permettent de configurer votre Cloud Function sans coder en dur des informations sensibles ou des valeurs de configuration dans votre code. Vous pouvez définir des variables d'environnement à l'aide de la commande `gcloud functions deploy` ou dans la console Google Cloud.

gcloud functions deploy VOTRE_NOM_DE_FONCTION \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=VOTRE_CLE_API,DATABASE_URL=VOTRE_URL_BASE_DE_DONNEES

Dans votre code, vous pouvez accéder aux variables d'environnement à l'aide du dictionnaire `os.environ` (Python) ou de l'objet `process.env` (Node.js).

Python :

import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Utiliser la clé API dans votre fonction
    return f'Clé API : {api_key}'

Node.js :

exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Utiliser la clé API dans votre fonction
  res.status(200).send(`Clé API : ${apiKey}`);
};

Gestion des tâches asynchrones

Pour les tâches longues ou gourmandes en calcul, il est préférable d'utiliser le traitement asynchrone pour éviter de bloquer la requête HTTP. Vous pouvez utiliser des services tels que Google Cloud Tasks ou Cloud Pub/Sub pour décharger ces tâches vers des files d'attente distinctes.

Gestion des erreurs et journalisation

Implémentez une gestion des erreurs et une journalisation robustes dans vos Cloud Functions pour identifier et résoudre rapidement les problèmes. Utilisez Google Cloud Logging pour collecter les journaux de vos fonctions et surveiller leurs performances.

Bonnes pratiques

Dépannage des problèmes courants

Conclusion

Google Cloud Functions avec les déclencheurs HTTP offrent un moyen puissant et flexible de créer des applications serverless. En comprenant les concepts et techniques abordés dans ce guide, vous pouvez exploiter la puissance de Cloud Functions pour créer des solutions évolutives, rentables et événementielles pour un public mondial. Adoptez la révolution serverless et libérez tout le potentiel de vos applications cloud !