Ejemplos de monitores sintéticos

En este documento se describen las plantillas y el código de muestra disponibles para ayudarte a crear monitores sintéticos. Las funciones de ejemplo están disponibles en el repositorio de GitHub Google Cloud/synthetics-sdk-nodjs.

Si escribes pruebas y no utilizas una plantilla, asegúrate de que la prueba se supere a menos que se produzca una Error. Te recomendamos que uses la biblioteca Assert para asegurarte de que, cuando se produzcan errores, se atribuyan a la línea de código adecuada.

Plantillas genéricas

Las plantillas genéricas se configuran para recoger datos de trazas y registros de solicitudes HTTP salientes. La solución utiliza el módulo auto-instrumentation-node de OpenTelemetry y el registrador Winston. Debido a la dependencia de los productos de código abierto, es posible que se produzcan cambios en la estructura de los datos de traza y de registro. Por lo tanto, los datos de registro y de seguimiento recogidos solo deben usarse con fines de depuración.

Puedes implementar tu propio método para recoger datos de trazas y registros de solicitudes HTTP salientes. Para ver un ejemplo de enfoque personalizado, consulta la clase SyntheticAutoInstrumentation.

Ejemplo genérico de Node.js

El ejemplo generic-synthetic-nodejs muestra cómo consultar una URL. Este ejemplo contiene lo mismo que la función predeterminada que muestra la consola Google Cloud . Para ver el ejemplo completo, haz clic en Más y, a continuación, selecciona Ver en 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));
}));

Ejemplo de TypeScript

En el ejemplo de generic-synthetic-typescript se muestra cómo consultar una URL. Para ver el ejemplo completo, haz clic en Más y, a continuación, selecciona Ver en 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));
}));

Plantilla de Puppeteer

Si usas Puppeteer, te recomendamos que empieces con el ejemplo de generic-puppeteer-nodejs.

Configuración obligatoria de Puppeteer

Para usar Puppeteer, asegúrate de que has completado los siguientes pasos:

  1. Incluye .puppeteerrc.cjs en el directorio de origen de tu función de Cloud Run:

    const { join } = require('path');

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

  2. Añade la siguiente secuencia de comandos al archivo package.json de tu función de Cloud Run:

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

Ejemplo de marionetista

El ejemplo generic-puppeteer-nodejs muestra cómo usar Puppeteer con tu función de Cloud Run. Para ver el ejemplo completo, haz clic en Más y, a continuación, selecciona Ver en 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();
}));

Plantilla de Selenium WebDriver

Si usas Selenium WebDriver, te recomendamos que empieces con el ejemplo de generic-selenium-nodejs. El ejemplo, que está disponible en GitHub, incluye un archivo index.js y un archivo package.json.

Para ver el ejemplo completo, haz clic en Más y, a continuación, selecciona Ver en 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();
  })
);

Plantilla Mocha

Si escribes pruebas que dependen de la plantilla Mocha, piensa si una secuencia de pruebas debe continuar o detenerse cuando se produce un error. Para detener una secuencia de pruebas después de un error, debes definir la marca bail.

Para ver un ejemplo completo que incluye el despliegue de una API, un conjunto de pruebas de Mocha de ejemplo para los endpoints de la API y cómo configurar el monitor sintético, consulta la entrada de blog Google Cloud Tutorial de monitorización sintética.

En el ejemplo mocha-url-ok se muestra cómo una función de Cloud Run puede invocar una suite de pruebas de Mocha y se proporciona una suite de pruebas de ejemplo. Para ver el ejemplo completo, haz clic en Más y, a continuación, selecciona Ver en 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;
});

En el ejemplo de broken-links-ok se muestra cómo configurar un comprobador de enlaces rotos. En esta plantilla, solo debe especificar los valores del objeto options. Este objeto especifica el URI que se va a probar y los parámetros de la prueba.

Si usas Puppeteer, asegúrate de completar los pasos de la configuración obligatoria de Puppeteer.

Para ver el ejemplo completo, haz clic en Más y, a continuación, selecciona Ver en 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));

Siguientes pasos