Échantillons pour les surveillances synthétiques

Ce document décrit les modèles et les exemples de code disponibles pour vous aider à créer des surveillances synthétiques. Les exemples de fonctions sont disponibles dans le dépôt GitHub Google Cloud/synthetics-sdk-nodjs.

Si vous écrivez des tests et que vous ne vous appuyez pas sur un modèle, assurez-vous qu'il réussit à moins qu'une Error ne soit générée. Nous vous recommandons d'utiliser la bibliothèque Assert pour vous assurer que lorsque des échecs se produisent, ils sont attribués à la ligne de code appropriée.

Avertissement :Veillez à mettre à jour la valeur du champ url avant de déployer l'exemple de code. Ne définissez pas ce champ sur https://www.google.com.

Modèles génériques

Les modèles génériques sont configurés pour collecter les données de trace et de journal des requêtes HTTP sortantes. La solution exploite le module auto-instrumentation-node d'OpenTelemetry et l'enregistreur winston. En raison de la dépendance aux produits Open Source, vous devez vous attendre à des modifications dans la structure des données de trace et de journal. Par conséquent, les données de trace et de journal collectées ne doivent être utilisées qu'à des fins de débogage.

Remarque :Pour activer la collecte des journaux et des traces, votre code doit importer le package instantiateAutoInstrumentation et appeler la méthode instantiateAutoInstrumentation() avant d'effectuer toute autre action. Assurez-vous également que votre code spécifie logger en tant que gestionnaire de rappel asynchrone.

Vous pouvez mettre en œuvre votre propre approche pour collecter les données de trace et de journal pour les requêtes HTTP sortantes. Pour obtenir un exemple d'approche personnalisée, consultez la classe SyntheticAutoInstrumentation.

Exemple Node.js générique

L'exemple generic-synthetic-nodejs montre comment interroger une URL. Cet exemple contient la même fonction que la fonction par défaut affichée par la console Google Cloud.

Pour afficher l'exemple generic-synthetic-nodejs complet, cliquez sur Plus, puis sélectionnez Afficher sur GitHub:

const { instantiateAutoInstrumentation, runSyntheticHandler } = require('@google-cloud/synthetics-sdk-api');
// Run instantiateAutoInstrumentation before any other code runs, to get automatic logs and traces
instantiateAutoInstrumentation();
const functions = require('@google-cloud/functions-framework');
const axios = require('axios');
const assert = require('node:assert');

functions.http('SyntheticFunction', runSyntheticHandler(async ({logger, executionId}) => {
  /*
   * This function executes the synthetic code for testing purposes.
   * If the code runs without errors, the synthetic test is considered successful.
   * If an error is thrown during execution, the synthetic test is considered failed.
   */
  logger.info('Making an http request using synthetics, with execution id: ' + executionId);
  const url = 'https://www.google.com/'; // URL to send the request to
  return await assert.doesNotReject(axios.get(url));
}));

Exemple TypeScript

L'exemple generic-synthetic-typescript montre comment interroger une URL.

Pour afficher l'exemple generic-synthetic-typescript complet, cliquez sur Plus, puis sélectionnez Afficher sur GitHub:

import {runSyntheticHandler, instantiateAutoInstrumentation} from '@google-cloud/synthetics-sdk-api'
// Run instantiateAutoInstrumentation before any other code runs, to get automatic logs and traces
instantiateAutoInstrumentation();
import * as ff from '@google-cloud/functions-framework';
import axios from 'axios';
import assert from 'node:assert';
import {Logger} from 'winston';

ff.http('SyntheticFunction', runSyntheticHandler(async ({logger, executionId}: {logger: Logger, executionId: string|undefined}) => {
  /*
   * This function executes the synthetic code for testing purposes.
   * If the code runs without errors, the synthetic test is considered successful.
   * If an error is thrown during execution, the synthetic test is considered failed.
   */
  logger.info('Making an http request using synthetics, with execution id: ' + executionId);
  const url = 'https://www.google.com/'; // URL to send the request to
  return await assert.doesNotReject(axios.get(url));
}));

Modèle Puppeteer

Si vous utilisez Puppeteer, envisagez de commencer avec l'exemple generic-puppeteer-nodejs.

Remarque :Les paramètres par défaut de la mémoire, du processeur et de la sécurité alloués peuvent ne pas être suffisants. Nous vous recommandons de définir la mémoire sur au moins 1 Gio.

Configuration de Puppeteer requise

Pour utiliser Puppeteer, procédez comme suit:

1. Incluez .puppeteerrc.cjs dans le répertoire source de votre fonction Cloud:

   const { join } = require('path');
   
   /**
    * @type {import("puppeteer").Configuration}
    */
   module.exports = {
     cacheDirectory: join(__dirname, '.cache', 'puppeteer'),
   };

2. Ajoutez le script suivant au fichier package.json de votre fonction Cloud:

   "scripts": {
        "gcp-build": "node node_modules/puppeteer/install.mjs"
   },
   

Exemple Puppeteer

L'exemple generic-puppeteer-nodejs montre comment utiliser Puppeteer avec votre fonction Cloud.

Pour afficher l'exemple generic-puppeteer-nodejs complet, cliquez sur Plus, puis sélectionnez Afficher sur GitHub:

const { instantiateAutoInstrumentation, runSyntheticHandler } = require('@google-cloud/synthetics-sdk-api');
// Run instantiateAutoInstrumentation before any other code runs, to get automatic logs and traces
instantiateAutoInstrumentation();
const functions = require('@google-cloud/functions-framework');
const axios = require('axios');
const assert = require('node:assert');
const puppeteer = require('puppeteer');


functions.http('CustomPuppeteerSynthetic', runSyntheticHandler(async ({logger, executionId}) => {
 /*
  * This function executes the synthetic code for testing purposes.
  * If the code runs without errors, the synthetic test is considered successful.
  * If an error is thrown during execution, the synthetic test is considered failed.
  */

 // Launch a headless Chrome browser and open a new page
 const browser = await puppeteer.launch({ headless: 'new', timeout: 0});
 const page = await browser.newPage();

 // Navigate to the target URL
 const result = await page.goto('https://www.example.com', {waitUntil: 'load'});

 // Confirm successful navigation
 await assert.equal(result.status(), 200);

 // Print the page title to the console
 const title = await page.title();
 logger.info(`My Page title: ${title} ` + executionId);

 // Close the browser
 await browser.close();
}));

Modèle Selenium WebDriver

Si vous utilisez Selenium WebDriver, envisagez de commencer par l'exemple generic-selenium-nodejs. L'exemple, disponible sur GitHub, inclut les fichiers index.js et package.json.

Remarque :Les paramètres par défaut de la mémoire, du processeur et de la sécurité alloués peuvent ne pas être suffisants. Nous vous recommandons de définir la mémoire sur au moins 1 Gio.

Pour afficher l'exemple generic-selenium-nodejs complet, cliquez sur Plus, puis sélectionnez Afficher sur GitHub:

const {
  instantiateAutoInstrumentation,
  runSyntheticHandler,
} = require('@google-cloud/synthetics-sdk-api');
// Run instantiateAutoInstrumentation before any other code runs, to get automatic logs and traces
instantiateAutoInstrumentation();
const functions = require('@google-cloud/functions-framework');
const assert = require('node:assert');

const { Builder, Browser, By } = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

/*
 * This function executes the synthetic code for testing purposes.
 * If the code runs without errors, the synthetic test is considered successful.
 * If an error is thrown during execution, the synthetic test is considered failed.
 */
functions.http(
  'CustomSeleniumSynthetic',
  runSyntheticHandler(async ({ logger, executionId }) => {
    /*
     * Construct chrome options
     * Note: `setChromeBinaryPath` must be set to '/srv/bin/chromium' when running in
     *   GCF (but will need to be changed if running on local machine).
     */
    const options = new chrome.Options();
    options.setChromeBinaryPath('/srv/bin/chromium');
    options.addArguments('--headless', '--disable-gpu', '--no-sandbox');

    // Launch headless chrome webdriver with options
    const driver = await new Builder()
      .forBrowser(Browser.CHROME)
      .setChromeOptions(options)
      .build();

    // Navigate to the target URL
    await driver.get('https://example.com');

    // Retrieve title and `a` tag of page
    const title = await driver.getTitle();
    const aTag = await driver.findElement(By.css('a')).getText();

    // assert title is as expected and print to console
    await assert.equal(title, 'Example Domain');
    logger.info(`My URL title is: ${title} ` + executionId);

    await driver.quit();
  })
);

Modèle mocha

Si vous écrivez des tests qui reposent sur le modèle Mocha, déterminez si une séquence de tests doit se poursuivre ou s'arrêter en cas d'échec. Pour arrêter une séquence de tests après un échec, vous devez définir l'option bail.

Pour obtenir un exemple de bout en bout incluant le déploiement d'une API, un exemple de suite de tests Mocha pour les points de terminaison d'API et la configuration de la surveillance synthétique, consultez le tutoriel Google Cloud Synthetic Monitoring.

L'exemple mocha-url-ok montre comment une fonction Cloud peut appeler une suite de tests Mocha et fournit un exemple de suite de tests.

Pour afficher l'exemple mocha-url-ok complet, cliquez sur Plus, puis sélectionnez Afficher sur GitHub:

const functions = require('@google-cloud/functions-framework');
const GcmSynthetics = require('@google-cloud/synthetics-sdk-mocha');

/*
 * This is the server template that is required to run a synthetic monitor in
 * Google Cloud Functions.
 */

functions.http('SyntheticMochaSuite', GcmSynthetics.runMochaHandler({
  spec: `${__dirname}/mocha_tests.spec.js`
}));

/*
 * This is the file may be interacted with to author mocha tests. To interact
 * with other GCP products or services, users should add dependencies to the
 * package.json file, and require those dependencies here A few examples:
 *  - @google-cloud/secret-manager:
 *        https://www.npmjs.com/package/@google-cloud/secret-manager
 *  - @google-cloud/spanner: https://www.npmjs.com/package/@google-cloud/spanner
 *  - Supertest: https://www.npmjs.com/package/supertest
 */

const {expect} = require('chai');
const fetch = require('node-fetch');

it('pings my website', async () => {
  const url = 'https://google.com/'; // URL to send the request to
  const externalRes = await fetch(url);
  expect(externalRes.ok).to.be.true;
});

Modèle de lien non fonctionnel

L'exemple broken-links-ok montre comment configurer un vérificateur de liens non fonctionnels. Pour ce modèle, vous ne spécifiez que les valeurs de l'objet options. Cet objet spécifie l'URI à tester et les paramètres du test. Pour en savoir plus, consultez le code suivant:

Si vous utilisez Puppeteer, assurez-vous de suivre la procédure de configuration Puppeteer requise.

Remarque :Les paramètres par défaut de la mémoire, du processeur et de la sécurité alloués peuvent ne pas être suffisants. Nous vous recommandons de définir la mémoire sur au moins 1 Gio.

Pour afficher l'exemple broken-links-ok complet, cliquez sur Plus, puis sélectionnez Afficher sur GitHub:

const functions = require('@google-cloud/functions-framework');
const GcmSynthetics = require('@google-cloud/synthetics-sdk-broken-links');

const options = {
  origin_uri: "https://example.com",
  // link_limit: 10,
  // query_selector_all: "a", // https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll
  // get_attributes: ['href'], // https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttribute
  // link_order: "FIRST_N", // "FIRST_N" or "RANDOM"
  // link_timeout_millis: 30000, // timeout per link
  // max_retries: 0, // number of retries per link if it failed for any reason
  // wait_for_selector: '', // https://pptr.dev/api/puppeteer.page.waitforselector
  // per_link_options: {},
    /*
    // example:
      per_link_options: {
        'http://fake-link1': { expected_status_code: "STATUS_CLASS_4XX" },
        'http://fake-link2': { expected_status_code: 304 },
        'http://fake-link3': { link_timeout_millis: 10000 },
        'http://fake-link4': {
          expected_status_code: "STATUS_CLASS_3XX",
          link_timeout_millis: 10,
        },
      },
    */
  // total_synthetic_timeout_millis: 60000 // Timeout set for the entire Synthetic Monitor
  // screenshot_options: { capture_condition: 'FAILING', storage_location: '' }
};

functions.http('BrokenLinkChecker', GcmSynthetics.runBrokenLinksHandler(options));

Étapes suivantes

• Créer une surveillance synthétique
• Créer un vérificateur de liens non fonctionnels
• Gérer les surveillances synthétiques
• Explorer les résultats de la surveillance synthétique