Esempi per i monitoraggi sintetici

I modelli preconfigurati e il codice campione ti consentono di creare monitor sintetici in Node.js e TypeScript utilizzando framework come Puppeteer, Selenium WebDriver e Mocha. Puoi utilizzare questi esempi, disponibili nel repository GitHub synthetics-sdk-nodejs, per eseguire query sugli URL, eseguire percorsi utente basati su browser, testare endpoint API o verificare la presenza di link non funzionanti.

Linee guida per l'utilizzo di esempi e la scrittura di test personalizzati

Prima di eseguire il deployment di un campione o scrivere un test personalizzato, rivedi i seguenti requisiti:

• Aggiorna l'URL di destinazione: prima di eseguire il deployment di qualsiasi codice campione, aggiorna il campo url in modo che punti all'endpoint di destinazione. Non impostare questo campo su https://www.google.com.
• Genera un Error in caso di test non riuscito: se scrivi test personalizzati anziché utilizzare un modello, assicurati che il test venga superato a meno che non venga generato un Error. Ti consigliamo di utilizzare la libreria Assert in modo che eventuali errori vengano attribuiti alla riga di codice corretta.

Modelli generici

I modelli generici sono configurati per raccogliere dati di traccia e log per le richieste HTTP in uscita. La soluzione sfrutta il modulo OpenTelemetry auto-instrumentation-node e il logger Winston. A causa della dipendenza dai prodotti open source, devi aspettarti modifiche alla struttura dei dati di traccia e log. Pertanto, i dati di traccia e di log raccolti devono essere utilizzati solo a scopo di debug.

Nota :per attivare la raccolta di log e tracce, il codice deve importare il pacchetto instantiateAutoInstrumentation e richiamare il metodo instantiateAutoInstrumentation() prima di eseguire qualsiasi altra azione. Inoltre, assicurati che il codice specifichi logger come gestore di callback asincrono.

Puoi implementare il tuo approccio per raccogliere dati di traccia e log per le richieste HTTP in uscita. Per un esempio di approccio personalizzato, vedi il corso SyntheticAutoInstrumentation.

Esempio Node.js generico

L'esempio generic-synthetic-nodejs mostra come eseguire una query su un URL. Questo esempio contiene lo stesso codice della funzione predefinita visualizzata dalla console Google Cloud . Per visualizzare l'esempio completo, seleziona il logo GitHub nella barra degli strumenti dell'esempio.

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

Esempio di TypeScript

L'esempio generic-synthetic-typescript mostra come eseguire una query su un URL. Per visualizzare l'esempio completo, seleziona il logo GitHub nella barra degli strumenti dell'esempio.

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

Modello Puppeteer

Se utilizzi Puppeteer, ti consigliamo di iniziare con l'esempio generic-puppeteer-nodejs.

Nota: le impostazioni predefinite per la memoria, la CPU e la sicurezza allocate potrebbero non essere sufficienti. Ti consigliamo di impostare la memoria su almeno 1 GiB.

Configurazione di Puppeteer richiesta

Per utilizzare Puppeteer, assicurati di completare i seguenti passaggi:

1. Includi .puppeteerrc.cjs nella directory di origine della tua funzione Cloud Run:

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

2. Aggiungi il seguente script al file package.json della tua funzione Cloud Run:

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

Esempio di Puppeteer

L'esempio generic-puppeteer-nodejs mostra come utilizzare Puppeteer con la funzione Cloud Run. Per visualizzare l'esempio completo, seleziona il logo GitHub nella barra degli strumenti dell'esempio.

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

Modello Selenium WebDriver

Se utilizzi Selenium WebDriver, ti consigliamo di iniziare con l'esempio generic-selenium-nodejs. L'esempio, disponibile su GitHub, include i file index.js e package.json.

Nota: le impostazioni predefinite per la memoria, la CPU e la sicurezza allocate potrebbero non essere sufficienti. Ti consigliamo di impostare la memoria su almeno 1 GiB.

Per visualizzare l'esempio completo, seleziona il logo GitHub nella barra degli strumenti dell'esempio.

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

Modello Mocha

Se scrivi test che si basano sul modello Mocha, valuta se una sequenza di test deve continuare o interrompersi quando si verifica un errore. Per interrompere una sequenza di test dopo un errore, devi impostare il flag bail.

Per un esempio end-to-end che include il deployment di un'API, la scrittura di una suite di test Mocha di esempio per gli endpoint API e la configurazione del monitor sintetico, consulta il post del blog Google Cloud Tutorial sul monitoraggio sintetico.

L'esempio mocha-url-ok mostra come una funzione Cloud Run può richiamare una suite di test Mocha e fornisce una suite di test di esempio. Per visualizzare l'esempio completo, seleziona il logo GitHub nella barra degli strumenti dell'esempio.

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

Modello di link non funzionante

L'esempio broken-links-ok mostra come configurare un controllo dei link non funzionanti. Per questo modello, specifica solo i valori dell'oggetto options. Questo oggetto specifica l'URI da testare e i parametri del test.

Se utilizzi Puppeteer, assicurati di completare i passaggi di configurazione di Puppeteer obbligatoria.

Nota: le impostazioni predefinite per la memoria, la CPU e la sicurezza allocate potrebbero non essere sufficienti. Ti consigliamo di impostare la memoria su almeno 1 GiB.

Per visualizzare l'esempio completo, seleziona il logo GitHub nella barra degli strumenti dell'esempio.

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

Passaggi successivi

• Creare un monitoraggio sintetico
• Creare un controllo dei link non funzionanti
• Gestire i monitor sintetici
• Esplorare i risultati del monitoraggio sintetico