Ejemplos de monitores sintéticos

Las plantillas preconfiguradas y el código de muestra te permiten compilar monitores sintéticos en Node.js y TypeScript con frameworks como Puppeteer, Selenium WebDriver y Mocha. Puedes usar estas muestras, disponibles en el repositorio de GitHub synthetics-sdk-nodejs, para consultar URLs, ejecutar recorridos del usuario basados en el navegador, probar extremos de API o verificar si hay vínculos rotos.

Lineamientos para usar muestras y escribir pruebas personalizadas

Antes de implementar una muestra o escribir una prueba personalizada, revisa los siguientes requisitos:

• Actualiza la URL de destino: Antes de implementar cualquier código de muestra, actualiza el campo url para que apunte a tu extremo de destino. No establezcas este campo en https://www.google.com.
• Lanza un Error si falla la prueba: Si escribes pruebas personalizadas en lugar de usar una plantilla, asegúrate de que la prueba se apruebe, a menos que se lance un Error. Te recomendamos que uses la biblioteca Assert para que las fallas se atribuyan a la línea de código correcta.

Plantillas genéricas

Las plantillas genéricas están configuradas para recopilar datos de registro y de seguimiento de las solicitudes HTTP salientes. La solución aprovecha el módulo auto-instrumentation-node de OpenTelemetry y el registrador de 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 registro y de seguimiento. Por lo tanto, los datos de registro y de seguimiento recopilados solo deben usarse con fines de depuración.

Nota: Para habilitar la recopilación de registros y seguimientos, tu código debe importar el paquete instantiateAutoInstrumentation y, luego, invocar el método instantiateAutoInstrumentation() antes de realizar cualquier otra acción. Además, asegúrate de que tu código especifique logger como un controlador de devolución de llamada asíncrono.

Puedes implementar tu propio enfoque para recopilar datos de registros y de seguimiento de solicitudes HTTP salientes. Para ver un ejemplo de un enfoque personalizado, consulta la clase SyntheticAutoInstrumentation.

Muestra genérica de Node.js

En el ejemplo de generic-synthetic-nodejs, se ilustra cómo consultar una URL. Esta muestra contiene el mismo código que la función predeterminada que muestra la consola de Google Cloud . Para ver la muestra completa, selecciona el logotipo de GitHub en la barra de herramientas de la muestra.

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));
}));

Muestra de TypeScript

En el ejemplo de generic-synthetic-typescript, se ilustra cómo consultar una URL. Para ver la muestra completa, selecciona el logotipo de GitHub en la barra de herramientas de la muestra.

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, considera comenzar con el ejemplo de generic-puppeteer-nodejs.

Nota: Es posible que la configuración predeterminada de la memoria, la CPU y la seguridad asignadas no sea suficiente. Te recomendamos que la memoria se establezca en al menos 1 GiB.

Configuración obligatoria de Puppeteer

Para usar Puppeteer, asegúrate de completar los siguientes pasos:

1. Incluye .puppeteerrc.cjs en el directorio del código fuente de tu función de Cloud Run:

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

2. Agrega 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 Puppeteer

En el ejemplo de generic-puppeteer-nodejs, se ilustra cómo usar Puppeteer con tu función de Cloud Run. Para ver la muestra completa, selecciona el logotipo de GitHub en la barra de herramientas de la muestra.

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, considera comenzar con la muestra generic-selenium-nodejs. La muestra, que está disponible en GitHub, incluye archivos index.js y package.json.

Nota: Es posible que la configuración predeterminada de la memoria, la CPU y la seguridad asignadas no sea suficiente. Te recomendamos que la memoria se establezca en al menos 1 GiB.

Para ver la muestra completa, selecciona el logotipo de GitHub en la barra de herramientas de la muestra.

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 de Mocha

Si escribes pruebas que se basan en la plantilla Mocha, considera si una secuencia de pruebas debe continuar o detenerse cuando se produce una falla. Para detener una secuencia de pruebas después de una falla, debes establecer la marca bail.

Para ver un ejemplo de extremo a extremo que incluye la implementación de una API, la escritura de un paquete de pruebas de Mocha de muestra para los endpoints de la API y la configuración del monitor sintético, consulta el blog Google Cloud Tutorial de Supervisión sintética.

La muestra mocha-url-ok ilustra cómo una función de Cloud Run puede invocar un paquete de pruebas de Mocha y proporciona un paquete de pruebas de muestra. Para ver la muestra completa, selecciona el logotipo de GitHub en la barra de herramientas de la muestra.

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;
});

Plantilla de vínculo roto

En el ejemplo de broken-links-ok, se ilustra cómo configurar un verificador de vínculos rotos. En esta plantilla, solo especificas los valores del objeto options. Este objeto especifica el URI que se probará y los parámetros de la prueba.

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

Nota: Es posible que la configuración predeterminada de la memoria, la CPU y la seguridad asignadas no sea suficiente. Te recomendamos que la memoria se establezca en al menos 1 GiB.

Para ver la muestra completa, selecciona el logotipo de GitHub en la barra de herramientas de la muestra.

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));

¿Qué sigue?

• Crea un monitor sintético
• Cómo crear un verificador de vínculos rotos
• Administra monitores sintéticos
• Explora los resultados de los monitores sintéticos