Amostras para monitores sintéticos

Este documento descreve os modelos e o exemplo de código disponíveis para ajudar você a criar monitores sintéticos. Os exemplos de funções estão disponíveis na Repositório do GitHub do Google Cloud/synthetics-sdk-nodjs (link em inglês).

Se você cria testes e não usa um modelo, garanta que eles seja transmitida, a menos que uma Error seja gerada. Recomendamos use a biblioteca Assert para garantir que quando ocorrem falhas, elas são atribuídas à linha de código adequada.

Aviso: atualize o valor do campo url antes de implantar o exemplo de código. Não defina esse campo como https://www.google.com.

Modelos genéricos

Os modelos genéricos são configurados para coletar dados de trace e registro para solicitações HTTP de saída. A solução usa Módulo auto-instrumentation-node do OpenTelemetry e o winston logger. Devido à dependência de produtos de código aberto, você deve esperar mudanças no a estrutura dos dados de rastreamento e registro. Portanto, o trace coletado e os dados de registro só devem ser usados para fins de depuração.

Observação :para ativar a coleta de registros e traces, seu código precisa importar o pacote instantiateAutoInstrumentation e invoque o instantiateAutoInstrumentation() antes de executar qualquer outra ação. Além disso, verifique se o código especifica o logger como um callback assíncrono .

Você pode implementar sua própria abordagem para coletar rastreamento e dados de registro para solicitações HTTP. Para um exemplo de abordagem personalizada, consulte a classe SyntheticAutoInstrumentation.

Amostra genérica do Node.js

O exemplo generic-synthetic-nodejs ilustra como consultar um URL. Este exemplo contém a mesma função que a padrão exibidos pelo console do Google Cloud. Para acessar o exemplo completo, clique em Mais, e selecione Ver no 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));
}));

Exemplo do TypeScript

O exemplo generic-synthetic-typescript ilustra como consultar um URL. Para acessar o exemplo completo, clique em Mais, e selecione Ver no 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));
}));

Modelo do Puppeteer

Se você usa o Puppeteer, comece com a Exemplo de generic-puppeteer-nodejs.

Observação :as configurações padrão de memória, CPU e segurança alocadas podem não ser suficientes. Recomendamos que a memória seja definida como ter pelo menos 1 GiB.

Configuração necessária do Puppeteer

Para usar o Puppeteer, conclua as seguintes etapas:

1. Inclua .puppeteerrc.cjs no diretório de origem do seu Função do Cloud:

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

2. Adicione o script a seguir ao arquivo package.json do seu Função do Cloud:

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

Amostra do Puppeteer

O exemplo generic-puppeteer-nodejs ilustra como para usar o Puppeteer com a função do Cloud. Para acessar o exemplo completo, clique em Mais, e selecione Ver no 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();
}));

Modelo Selenium WebDriver

Se você usa o Selenium WebDriver, comece pela Exemplo de generic-selenium-nodejs. A amostra, que está disponível no GitHub e inclui os arquivos index.js e package.json.

Observação :as configurações padrão de memória, CPU e segurança alocadas podem não ser suficientes. Recomendamos que a memória seja definida como ter pelo menos 1 GiB.

Para ver o exemplo completo, clique em Mais e selecione Ver no 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();
  })
);

Modelo Mocha

Se você criar testes que dependem do modelo Mocha, considerar se uma sequência de testes deve continuar ou parar quando um quando ocorre uma falha. Para interromper uma sequência de testes após uma falha, defina o flag bail.

Para um exemplo completo que inclui a implantação de uma API, um exemplo do teste Mocha para os endpoints de API e como configurar o monitor sintético, consulte o blog Tutorial de monitoramento sintético do Google Cloud.

O exemplo mocha-url-ok ilustra como uma função do Cloud pode invocar Mocha (link em inglês) e oferece um exemplo de pacote de testes. Para acessar o exemplo completo, clique em Mais, e selecione Ver no 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;
});

Modelo de link corrompido

O broken-links-ok exemplo ilustra como configurar um verificador de links corrompidos. Para este modelo, especifique apenas os valores do objeto options. Isso especifica o URI a ser testado e os parâmetros do teste.

Se você usa o Puppeteer, certifique-se de concluir o Etapas de configuração necessárias do Puppeteer.

Observação :as configurações padrão de memória, CPU e segurança alocadas podem não ser suficientes. Recomendamos que a memória seja definida como ter pelo menos 1 GiB.

Para ver o exemplo completo, clique em Mais e selecione Ver no 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));

A seguir

• Criar um monitor sintético
• Criar um verificador de links corrompidos
• Gerenciar monitores sintéticos
• Explorar os resultados do monitor sintético