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à.

Versioni di runtime Synthetics

Quando crei o aggiorni un Canary, scegli una versione di runtime Synthetics per il Canary. Un runtime Synthetics è una combinazione del codice Synthetics che chiama il gestore di script e dei livelli Lambda delle dipendenze in bundle.

CloudWatch Synthetics attualmente supporta runtime che utilizzano Node.js per gli script e il framework Puppeteer e runtime che utilizzano Python per lo scripting e Selenium Webdriver per il framework.

Ti consigliamo di utilizzare sempre la versione di runtime più recente per i Canary in modo da poter utilizzare le funzionalità e gli aggiornamenti più recenti apportati alla libreria Synthetics.

Quando create un canarino, uno dei livelli creati è un livello Synthetics a cui fa preposto. Synthetics Questo livello è di proprietà dell'account del servizio Synthetics e contiene il codice di runtime.

CloudWatch Politica di supporto per il runtime di Synthetics

Le versioni runtime di Synthetics sono soggette ad aggiornamenti di manutenzione e sicurezza. Quando un componente di una versione runtime non è più supportato, la versione runtime di Synthetics viene resa obsoleta.

Non è possibile creare nuovi canary utilizzando versioni runtime obsolete. I canary che utilizzano runtime obsoleti continueranno a funzionare. Puoi interrompere, avviare ed eliminare questi Canary. Puoi aggiornare un canary esistente che utilizza versioni runtime obsolete aggiornando il canary per utilizzare una versione di runtime supportata.

CloudWatch Synthetics ti avvisa via e-mail se hai canari che utilizzano runtime programmati per essere obsoleti nei prossimi 60 giorni. Ti consigliamo di eseguire la migrazione dei canary a una versione runtime supportata per trarre vantaggio dai nuovi miglioramenti alle funzionalità, alla sicurezza e alle prestazioni inclusi nelle versioni più recenti.

Come posso aggiornare un canary a una nuova versione di runtime?

Puoi aggiornare la versione di runtime di Canary utilizzando la console, il o il. CloudWatch AWS CloudFormation AWS CLI AWS SDK Quando usi la CloudWatch console, puoi aggiornare fino a cinque canarini contemporaneamente selezionandoli nella pagina dell'elenco dei canarini e quindi scegliendo Azioni, Aggiorna Runtime.

Puoi verificare l'aggiornamento clonando prima il canarino utilizzando la CloudWatch console e aggiornando la sua versione di runtime. Questo crea un altro canary che è un clone del tuo canary originale. Dopo aver verificato il canary con la nuova versione di runtime, puoi aggiornare la versione di runtime del canary originale ed eliminare il canary clone.

Puoi anche aggiornare più canary utilizzando uno script di aggiornamento. Per ulteriori informazioni, consulta Script di aggiornamento del runtime del canary.

Se aggiorni un canary e l'operazione non va a buon fine, consulta Risoluzione dei problemi di un canary fallito.

Date di deprecazione del runtime

Script di aggiornamento del runtime del canary

Per aggiornare uno script canary a una versione di runtime supportata, utilizza lo script seguente.

const AWS = require('aws-sdk');

// You need to configure your AWS credentials and Region.
//   https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
//   https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-region.html

const synthetics = new AWS.Synthetics();

const DEFAULT_OPTIONS = {
  /**
   * The number of canaries to upgrade during a single run of this script.
   */
  count: 10,
  /**
   * No canaries are upgraded unless force is specified.
   */
  force: false
};

/**
 * The number of milliseconds to sleep between GetCanary calls when
 * verifying that an update succeeded.
 */
const SLEEP_TIME = 5000;

(async () => {
  try {
    const options = getOptions();

    const versions = await getRuntimeVersions();
    const canaries = await getAllCanaries();
    const upgrades = canaries
      .filter(canary => !versions.isLatestVersion(canary.RuntimeVersion))
      .map(canary => {
        return {
          Name: canary.Name,
          FromVersion: canary.RuntimeVersion,
          ToVersion: versions.getLatestVersion(canary.RuntimeVersion)
        };
      });

    if (options.force) {
      const promises = [];

      for (const upgrade of upgrades.slice(0, options.count)) {
        const promise = upgradeCanary(upgrade);
        promises.push(promise);
        // Sleep for 100 milliseconds to avoid throttling.
        await usleep(100);
      }

      const succeeded = [];
      const failed = [];
      for (let i = 0; i < upgrades.slice(0, options.count).length; i++) {
        const upgrade = upgrades[i];
        const promise = promises[i];
        try {
          await promise;
          console.log(`The update of ${upgrade.Name} succeeded.`);
          succeeded.push(upgrade.Name);
        } catch (e) {
          console.log(`The update of ${upgrade.Name} failed with error: ${e}`);
          failed.push({
            Name: upgrade.Name,
            Reason: e
          });
        }
      }

      if (succeeded.length) {
        console.group('The following canaries were upgraded successfully.');
        for (const name of succeeded) {
          console.log(name);
        }
        console.groupEnd()
      } else {
        console.log('No canaries were upgraded successfully.');
      }

      if (failed.length) {
        console.group('The following canaries were not upgraded successfully.');
        for (const failure of failed) {
          console.log('\x1b[31m', `${failure.Name}: ${failure.Reason}`, '\x1b[0m');
        }
        console.groupEnd();
      }
    } else {
      console.log('Run with --force [--count <count>] to perform the first <count> upgrades shown. The default value of <count> is 10.')
      console.table(upgrades);
    }
  } catch (e) {
    console.error(e);
  }
})();

function getOptions() {
  const force = getFlag('--force', DEFAULT_OPTIONS.force);
  const count = getOption('--count', DEFAULT_OPTIONS.count);
  return { force, count };

  function getFlag(key, defaultValue) {
    return process.argv.includes(key) || defaultValue;
  }
  function getOption(key, defaultValue) {
    const index = process.argv.indexOf(key);
    if (index < 0) {
      return defaultValue;
    }
    const value = process.argv[index + 1];
    if (typeof value === 'undefined' || value.startsWith('-')) {
      throw `The ${key} option requires a value.`;
    }
    return value;
  }
}

function getAllCanaries() {
  return new Promise((resolve, reject) => {
    const canaries = [];

    synthetics.describeCanaries().eachPage((err, data) => {
      if (err) {
        reject(err);
      } else {
        if (data === null) {
          resolve(canaries);
        } else {
          canaries.push(...data.Canaries);
        }
      }
    });
  });
}

function getRuntimeVersions() {
  return new Promise((resolve, reject) => {
    const jsVersions = [];
    const pythonVersions = [];
    synthetics.describeRuntimeVersions().eachPage((err, data) => {
      if (err) {
        reject(err);
      } else {
        if (data === null) {
          jsVersions.sort((a, b) => a.ReleaseDate - b.ReleaseDate);
          pythonVersions.sort((a, b) => a.ReleaseDate - b.ReleaseDate);
          resolve({
            isLatestVersion(version) {
              const latest = this.getLatestVersion(version);
              return latest === version;
            },
            getLatestVersion(version) {
              if (jsVersions.some(v => v.VersionName === version)) {
                return jsVersions[jsVersions.length - 1].VersionName;
              } else if (pythonVersions.some(v => v.VersionName === version)) {
                return pythonVersions[pythonVersions.length - 1].VersionName;
              } else {
                throw Error(`Unknown version ${version}`);
              }
            }
          });
        } else {
          for (const version of data.RuntimeVersions) {
            if (version.VersionName === 'syn-1.0') {
              jsVersions.push(version);
            } else if (version.VersionName.startsWith('syn-nodejs-2.')) {
              jsVersions.push(version);
            } else if (version.VersionName.startsWith('syn-nodejs-puppeteer-')) {
              jsVersions.push(version);
            } else if (version.VersionName.startsWith('syn-python-selenium-')) {
              pythonVersions.push(version);
            } else {
              throw Error(`Unknown version ${version.VersionName}`);
            }
          }
        }
      }
    });
  });
}

async function upgradeCanary(upgrade) {
  console.log(`Upgrading canary ${upgrade.Name} from ${upgrade.FromVersion} to ${upgrade.ToVersion}`);
  await synthetics.updateCanary({ Name: upgrade.Name, RuntimeVersion: upgrade.ToVersion }).promise();
  while (true) {
    await usleep(SLEEP_TIME);
    console.log(`Getting the state of canary ${upgrade.Name}`);
    const response = await synthetics.getCanary({ Name: upgrade.Name }).promise();
    const state = response.Canary.Status.State;
    console.log(`The state of canary ${upgrade.Name} is ${state}`);
    if (state === 'ERROR' || response.Canary.Status.StateReason) {
      throw response.Canary.Status.StateReason;
    }
    if (state !== 'UPDATING') {
      return;
    }
  }
}

function usleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}