Déclencher des fonctions Cloud Run à l'aide de Cloud Tasks

Ce tutoriel explique comment utiliser Cloud Tasks dans une application App Engine pour déclencher une fonction Cloud Run et envoyer un e-mail programmé.

Objectifs

  • Comprendre le code de chacun des composants
  • Créer un compte SendGrid
  • Télécharger le code source
  • Déployer une fonction Cloud Run pour recevoir des requêtes Cloud Tasks et envoyer un e-mail via l'API SendGrid
  • Créer une file d'attente Cloud Tasks
  • Créez un compte de service pour authentifier vos requêtes Cloud Tasks.
  • Déployez le code client permettant à un utilisateur d'envoyer un e-mail.

Coûts

Cloud Tasks, Cloud Run Functions et App Engine disposent d'une version sans frais. Par conséquent, si vous exécutez le tutoriel dans cette version sans frais des produits concernés, cela ne devrait pas entraîner de coûts supplémentaires. Pour en savoir plus, reportez-vous à la page Tarifs.

Avant de commencer

  1. Sélectionnez ou créez un Google Cloud projet.

    Accéder à la page App Engine

  2. Initialisez une application App Engine dans votre projet :

    1. Sur la page Bienvenue dans App Engine, cliquez sur Créer une application.

    2. Sélectionnez une région pour votre application. Cet emplacement servira de paramètre LOCATION_ID pour vos requêtes Cloud Tasks. Notez-le donc. Notez que deux sites appelés europe-west et us-central dans les commandes App Engine sont appelés respectivement europe-west1 et us-central1 dans les commandes Cloud Tasks.

    3. Sélectionnez Node.js pour le langage et Standard pour l'environnement.

    4. Si la fenêtre pop-up Activer la facturation s'affiche, sélectionnez votre compte de facturation. Si vous ne possédez pas de compte de facturation, cliquez sur Créer un compte de facturation et suivez les instructions de l'assistant.

    5. Sur la page Premiers pas, cliquez sur Suivant. Vous vous en occuperez plus tard.

  3. Activez les API Cloud Run Functions et Cloud Tasks.

    Activer les API

  4. Installez et initialisez gcloud CLI.

Comprendre le code

Cette section décrit le code de l'application et son fonctionnement.

Créer la tâche

La page d'index est diffusée à l'aide de gestionnaires dans app.yaml. Les variables nécessaires à la création de tâches sont transmises en tant que variables d'environnement.

runtime: nodejs16

env_variables:
  QUEUE_NAME: "my-queue"
  QUEUE_LOCATION: "us-central1"
  FUNCTION_URL: "https://<region>-<project_id>.cloudfunctions.net/sendEmail"
  SERVICE_ACCOUNT_EMAIL: "<member>@<project_id>.iam.gserviceaccount.com"

# Handlers for serving the index page.
handlers:
  - url: /static
    static_dir: static
  - url: /
    static_files: index.html
    upload: index.html

Ce code crée le point de terminaison /send-email. Ce point de terminaison gère les envois de formulaires depuis la page d'index et transmet ces données au code de création de tâche.

app.post('/send-email', (req, res) => {
  // Set the task payload to the form submission.
  const {to_name, from_name, to_email, date} = req.body;
  const payload = {to_name, from_name, to_email};

  createHttpTaskWithToken(
    process.env.GOOGLE_CLOUD_PROJECT,
    QUEUE_NAME,
    QUEUE_LOCATION,
    FUNCTION_URL,
    SERVICE_ACCOUNT_EMAIL,
    payload,
    date
  );

  res.status(202).send('📫 Your postcard is in the mail! 💌');
});

Ce code crée la tâche et l'envoie à la file d'attente Cloud Tasks. Le code crée la tâche en effectuant ce qui suit :

  • Spécifier le type de cible comme HTTP Request.

  • Spécifier la méthode HTTP method à utiliser et la valeur URL de la cible.

  • Définir l'en-tête Content-Type sur application/json pour que les applications en aval puissent analyser la charge utile structurée.

  • Ajout d'une adresse e-mail de compte de service afin que Cloud Tasks puisse fournir des identifiants à la cible de la requête, ce qui nécessite une authentification. Le compte de service est créé séparément.

  • Vérifier que l'entrée utilisateur pour la date est comprise dans la limite de 30 jours et l'ajouter à la requête en tant que champ scheduleTime.

const MAX_SCHEDULE_LIMIT = 30 * 60 * 60 * 24; // Represents 30 days in seconds.

const createHttpTaskWithToken = async function (
  project = 'my-project-id', // Your GCP Project id
  queue = 'my-queue', // Name of your Queue
  location = 'us-central1', // The GCP region of your queue
  url = 'https://example.com/taskhandler', // The full url path that the request will be sent to
  email = '<member>@<project-id>.iam.gserviceaccount.com', // Cloud IAM service account
  payload = 'Hello, World!', // The task HTTP request body
  date = new Date() // Intended date to schedule task
) {
  // Imports the Google Cloud Tasks library.
  const {v2beta3} = require('@google-cloud/tasks');

  // Instantiates a client.
  const client = new v2beta3.CloudTasksClient();

  // Construct the fully qualified queue name.
  const parent = client.queuePath(project, location, queue);

  // Convert message to buffer.
  const convertedPayload = JSON.stringify(payload);
  const body = Buffer.from(convertedPayload).toString('base64');

  const task = {
    httpRequest: {
      httpMethod: 'POST',
      url,
      oidcToken: {
        serviceAccountEmail: email,
        audience: url,
      },
      headers: {
        'Content-Type': 'application/json',
      },
      body,
    },
  };

  const convertedDate = new Date(date);
  const currentDate = new Date();

  // Schedule time can not be in the past.
  if (convertedDate < currentDate) {
    console.error('Scheduled date in the past.');
  } else if (convertedDate > currentDate) {
    const date_diff_in_seconds = (convertedDate - currentDate) / 1000;
    // Restrict schedule time to the 30 day maximum.
    if (date_diff_in_seconds > MAX_SCHEDULE_LIMIT) {
      console.error('Schedule time is over 30 day maximum.');
    }
    // Construct future date in Unix time.
    const date_in_seconds =
      Math.min(date_diff_in_seconds, MAX_SCHEDULE_LIMIT) + Date.now() / 1000;
    // Add schedule time to request in Unix time using Timestamp structure.
    // https://googleapis.dev/nodejs/tasks/latest/google.protobuf.html#.Timestamp
    task.scheduleTime = {
      seconds: date_in_seconds,
    };
  }

  try {
    // Send create task request.
    const [response] = await client.createTask({parent, task});
    console.log(`Created task ${response.name}`);
    return response.name;
  } catch (error) {
    // Construct error for Stackdriver Error Reporting
    console.error(Error(error.message));
  }
};

module.exports = createHttpTaskWithToken;

Création de l'e-mail

Ce code crée la fonction Cloud Run qui est la cible de la requête Cloud Tasks. Il utilise le corps de la requête pour créer un e-mail et l'envoyer via l'API SendGrid.

const sendgrid = require('@sendgrid/mail');

/**
 * Responds to an HTTP request from Cloud Tasks and sends an email using data
 * from the request body.
 *
 * @param {object} req Cloud Function request context.
 * @param {object} req.body The request payload.
 * @param {string} req.body.to_email Email address of the recipient.
 * @param {string} req.body.to_name Name of the recipient.
 * @param {string} req.body.from_name Name of the sender.
 * @param {object} res Cloud Function response context.
 */
exports.sendEmail = async (req, res) => {
  // Get the SendGrid API key from the environment variable.
  const key = process.env.SENDGRID_API_KEY;
  if (!key) {
    const error = new Error(
      'SENDGRID_API_KEY was not provided as environment variable.'
    );
    error.code = 401;
    throw error;
  }
  sendgrid.setApiKey(key);

  // Get the body from the Cloud Task request.
  const {to_email, to_name, from_name} = req.body;
  if (!to_email) {
    const error = new Error('Email address not provided.');
    error.code = 400;
    throw error;
  } else if (!to_name) {
    const error = new Error('Recipient name not provided.');
    error.code = 400;
    throw error;
  } else if (!from_name) {
    const error =