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 i runtime che utilizzano i linguaggi Node.js, Python o Java. I framework supportati sono Puppeteer, Playwright e Selenium.

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.

Policy di supporto del runtime di CloudWatch 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 informa via e-mail se hai canary che utilizzano i runtime pianificati per diventare obsoleti nei successivi 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 un canary utilizzando la console CloudWatch, AWS CloudFormation, la AWS CLI o l'SDK AWS. Quando utilizzi la console CloudWatch, puoi aggiornare fino a cinque canary contemporaneamente selezionandoli nella pagina dell'elenco dei canary e scegliendo Actions (Operazioni), Update Runtime (Aggiorna runtime).

Puoi verificare l'aggiornamento testandolo prima di applicare in modo definitivo l'aggiornamento del runtime. Quando aggiorni le versioni di runtime, scegli le opzioni Avvia processo di test o Convalida e salva più tardi nella console CloudWatch per creare un processo di test del canary originale insieme a tutte le modifiche apportate alla configurazione. Il processo di test aggiornerà ed eseguirà il canary per verificare se l'aggiornamento del runtime è sicuro per il canary. Dopo aver verificato il canary con la nuova versione di runtime, puoi aggiornare la versione di runtime del tuo canary. Per ulteriori informazioni, consulta Esecuzione di aggiornamenti sicuri sul canary.

In alternativa, puoi verificare l'aggiornamento clonando prima il canary utilizzando la console CloudWatch e aggiornandone la 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 in cui il runtime di CloudWatch Synthetics è stato deprecato

La tabella seguente elenca la data in cui ogni runtime di CloudWatch Synthetics obsoleto è stato deprecato.

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