Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Scrittura di uno script Node.js canary utilizzando il runtime Puppeteer **Topics** + [Creare un canarino di Synthetics partendo da zero CloudWatch](#CloudWatch_Synthetics_Canaries_write_from_scratch) + [Impacchettare i tuoi file canary Node.js](#CloudWatch_Synthetics_Canaries_package) + [Modifica di uno script Puppeteer esistente da utilizzare come canary di Synthetics](#CloudWatch_Synthetics_Canaries_modify_puppeteer_script) + [Argomenti correlati](#CloudWatch_Synthetics_Canaries_Nodejs_Pup_related) ## Creare un canarino di Synthetics partendo da zero CloudWatch Ecco un esempio minimo di script Synthetics canary. Questo script passa come esecuzione riuscita e restituisce una stringa. Per vedere come appare un canary fallito, passare `let fail = false;` a `let fail = true;`. È necessario definire una funzione di punto di ingresso per lo script canary. Per vedere come i file vengono caricati nella posizione Amazon S3 specificata come `ArtifactS3Location` del canary, crea questi file nella cartella `/tmp`. Tutti gli artefatti canary devono essere archiviati nella directory `/tmp`, perché è l'unica scrivibile. Assicurati che il percorso dello screenshot sia impostato su `/tmp` per tutti gli screenshot o gli altri file creati dallo script. Synthetics carica automaticamente i file nella directory ` /tmp` in un bucket S3. ``` /tmp/ ``` Dopo l'esecuzione dello script, le metriche di pass/fail stato e durata vengono pubblicate CloudWatch e i file in esso contenuti `/tmp` vengono caricati in un bucket S3. ``` const basicCustomEntryPoint = async function () { // Insert your code here // Perform multi-step pass/fail check // Log decisions made and results to /tmp // Be sure to wait for all your code paths to complete // before returning control back to Synthetics. // In that way, your canary will not finish and report success // before your code has finished executing // Throw to fail, return to succeed let fail = false; if (fail) { throw "Failed basicCanary check."; } return "Successfully completed basicCanary checks."; }; exports.handler = async () => { return await basicCustomEntryPoint(); }; ``` Quindi, espandi lo script per utilizzare la registrazione di Synthetics ed effettua una chiamata utilizzando l'SDK. AWS A scopo dimostrativo, questo script creerà un client Amazon DynamoDB ed effettuerà una chiamata all'API ListTables DynamoDB. Registra la risposta alla richiesta e i registri passano o falliscono in base all'esito positivo della richiesta. ``` const log = require('@aws/synthetics-logger'); const AWS = require('aws-sdk'); // Require any dependencies that your script needs // Bundle additional files and dependencies into a .zip file with folder structure // nodejs/node_modules/{{additional files and folders}} const basicCustomEntryPoint = async function () { log.info("Starting DynamoDB:listTables canary."); let dynamodb = new AWS.DynamoDB(); var params = {}; let request = await dynamodb.listTables(params); try { let response = await request.promise(); log.info("listTables response: " + JSON.stringify(response)); } catch (err) { log.error("listTables error: " + JSON.stringify(err), err.stack); throw err; } return "Successfully completed DynamoDB:listTables canary."; }; exports.handler = async () => { return await basicCustomEntryPoint(); }; ``` ## Impacchettare i tuoi file canary Node.js **Per syn-nodejs-puppeteer-11.0 e versioni successive** La vecchia struttura di creazione dei pacchetti (per syn-nodejs-puppeteer-10.0 e versioni precedenti) è ancora supportata nelle versioni più recenti. Crea uno script utilizzando una delle seguenti opzioni: + File .js (sintassi CommonJS) + File .mjs (sintassi dei moduli ES) Per i moduli ES, utilizza una delle opzioni seguenti: + File .js (sintassi CommonJS) + File .mjs (sintassi dei moduli ES) La struttura del pacchetto è definita di seguito: + Root-level file del gestore (indice). js/index.mjs) + File di configurazione facoltativo (synthetics.json) + Dipendenze aggiuntive in node\_modules (se necessario) Esempio di struttura di impacchettamento: ``` my_function/ ├── index.mjs ├── synthetics.json ├── helper-utils.mjs └── node_modules/ └── dependencies ``` Per impacchettare, segui i seguenti passaggi: 1. Installa le dipendenze (se presenti). ``` npm install ``` 1. Crea un pacchetto .zip. ``` zip -r my_deployment_package.zip ``` **Per syn-nodejs-puppeteer-11.0 e versioni precedenti** Quando si utilizza Amazon S3 è richiesta la seguente struttura: ``` nodejs/ └── node_modules/ └── myCanaryFilename.js ``` **Per aggiungere un supporto facoltativo per le sottocartelle in syn-nodejs-puppeteer-3.4\+:** ``` nodejs/ └── node_modules/ └── myFolder/ └── myCanaryFilename.js ``` **Nota** Il percorso del gestore nella configurazione deve corrispondere alla posizione del file. **Nome del gestore** Assicurati di impostare il punto di ingresso (gestore) dello script di Canary in modo che ` myCanaryFilename.functionName` corrisponda al nome del file del punto di ingresso dello script. Se utilizzi un runtime precedente a `syn-nodejs-puppeteer-3.4`, `functionName` deve corrispondere a `handler`. Se utilizzi un tempo ` syn-nodejs-puppeteer-3.4` o successivo, puoi scegliere qualsiasi nome di funzione come gestore. Se utilizzi un tempo `syn-nodejs-puppeteer-3.4` o successivo, puoi anche memorizzare il canary in una cartella separata, ad esempio ` nodejs/node_modules/myFolder/my_canary_filename`. Se lo archivi in una cartella separata, definisci il percorso nel punto di ingresso dello script, ad esempio ` myFolder/my_canary_filename.functionName`. ## Modifica di uno script Puppeteer esistente da utilizzare come canary di Synthetics Questa sezione spiega come prendere script Puppeteer e modificarli per essere eseguiti come script canary Synthetics. Per ulteriori informazioni su Puppeteer, consulta [Puppeteer API v1.14.0](https://github.com/puppeteer/puppeteer/blob/v1.14.0/docs/api.md). Inizia con questo esempio di script Puppeteer: ``` const puppeteer = require('puppeteer'); (async () => { const browser = await puppeteer.launch(); const page = await browser.newPage(); await page.goto('https://example.com'); await page.screenshot({path: 'example.png'}); await browser.close(); })(); ``` Le fasi di conversione sono le seguenti: + Creare ed esportare una funzione `handler`. Il gestore è la funzione del punto di ingresso per lo script. Se utilizzi un runtime precedente a ` syn-nodejs-puppeteer-3.4`, la funzione del gestore deve essere denominata `handler`. Se utilizzi un tempo `syn-nodejs-puppeteer-3.4` o successivo, la funzione può avere un nome qualsiasi, purché corrisponda a quello utilizzato nello script. Inoltre, se utilizzi un tempo `syn-nodejs-puppeteer-3.4` o successivo, puoi archiviare gli script in qualsiasi cartella e definire quest'ultima nel nome del gestore. ``` const basicPuppeteerExample = async function () {}; exports.handler = async () => { return await basicPuppeteerExample(); }; ``` + Usa la dipendenza `Synthetics`. ``` var synthetics = require('@aws/synthetics-puppeteer'); ``` + Utilizzare la funzione `Synthetics.getPage` per ottenere un oggetto `Page` Puppeteer. ``` const page = await synthetics.getPage(); ``` L'oggetto page restituito dalla Synthetics.getPage funzione contiene ** page.on `response` e gli ` requestfailed` eventi strumentati per ** `request` la registrazione. Synthetics imposta anche la generazione di file HAR per le richieste e le risposte nella pagina e aggiunge l'ARN canary alle intestazioni user-agent delle richieste in uscita nella pagina. Lo script è ora pronto per essere eseguito come Canary di Synthetics. Ecco lo script aggiornato: ``` var synthetics = require('@aws/synthetics-puppeteer'); // Synthetics dependency const basicPuppeteerExample = async function () { const page = await synthetics.getPage(); // Get instrumented page from Synthetics await page.goto('https://example.com'); await page.screenshot({path: '/tmp/example.png'}); // Write screenshot to /tmp folder }; exports.handler = async () => { // Exported handler function return await basicPuppeteerExample(); }; ``` ## Argomenti correlati + [Variabili di ambiente](CloudWatch_Synthetics_Canaries_CommonFeatures.md#CloudWatch_Synthetics_Environment_Variables) + [Crittografia delle variabili di ambiente inattive con una chiave gestita dal cliente](CloudWatch_Synthetics_Canaries_CommonFeatures.md#CloudWatch_Synthetics_function_encryption) + [Crittografia delle variabili di ambiente in transito](CloudWatch_Synthetics_Canaries_CommonFeatures.md#CloudWatch_Synthetics_transit_encryption) + [Forzare il canary a utilizzare un indirizzo IP statico](CloudWatch_Synthetics_Canaries_CommonFeatures.md#CloudWatch_Synthetics_Canaries_staticIP)