Versions d'exécution Synthetics

Lorsque vous créez ou mettez à jour un script Canary, vous choisissez une version d'environnement d'exécution Synthetics pour le script Canary. Une exécution Synthetics est une combinaison du code Synthetics qui appelle votre gestionnaire de scripts et des couches Lambda de dépendances groupées.

CloudWatch Synthetics prend actuellement en charge les exécutions basés sur les langages Node.js, Python et Java. Les cadriciels pris en charge sont Puppeteer, Playwright et Selenium.

Nous vous recommandons de toujours utiliser la version d'environnement d'exécution la plus récente pour vos scripts Canary, afin de pouvoir utiliser les dernières fonctionnalités et mises à jour apportées à la bibliothèque Synthetics.

Stratégie de prise en charge des exécutions CloudWatch Synthetics

Les versions d'environnement d'exécution Synthetics sont soumises à des mises à jour de sécurité et de maintenance. Lorsqu'un composant quelconque d'une version d'exécution n'est plus pris en charge, cette version d'exécution Synthetics devient obsolète.

Vous ne pouvez pas créer des scripts Canary à l'aide de versions d'environnement d'exécution obsolètes. Les scripts Canary qui utilisent des environnements d'exécution obsolètes continuent à fonctionner. Vous pouvez arrêter, démarrer et supprimer ces scripts Canary. Vous pouvez mettre à jour un script Canary existant qui utilise une version d'exécution obsolète en mettant à jour le script Canary pour utiliser une version d'exécution prise en charge.

CloudWatch Synthetics vous avertit par e-mail si vous disposez de scripts Canary utilisant des exécutions dont l'obsolescence est prévue dans les 60 prochains jours. Nous vous recommandons de migrer vos scripts Canary vers une version d'exécution prise en charge pour bénéficier des nouvelles fonctionnalités et des améliorations de la sécurité et des performances incluses dans les versions plus récentes.

Comment mettre à jour un canary vers une nouvelle version d'exécution ?

Vous pouvez mettre à jour la version d'exécution d'un script Canary à l'aide de la console CloudWatch, d'AWS CloudFormation, d'AWS CLI ou du kit SDK AWS. Lorsque vous utilisez la console CloudWatch, vous pouvez mettre à jour jusqu'à cinq scripts Canary à la fois en les sélectionnant dans la page de la liste des scripts Canary, puis en sélectionnant Actions, Update Runtime (Mettre à jour l'exécution).

Vous pouvez vérifier la mise à jour en la testant d’abord avant de valider la mise à jour de l’exécution. Lors de la mise à jour des versions d’exécution, sélectionnez les options Démarrer une exécution à blanc ou Valider et enregistrer plus tard dans la console CloudWatch afin de créer une exécution à blanc du script Canary d’origine, incluant toutes les modifications que vous avez apportées à la configuration. L’exécution à blanc mettra à jour et exécutera le script Canary afin de vérifier si la nouvelle version de l’exécution est compatible. Une fois la vérification de la nouvelle version d’exécution terminée et réussie, vous pouvez mettre à jour la version de l’exécution de votre script Canary. Pour de plus amples informations, consultez Effectuer des mises à jour sécurisées des scripts Canary.

Vous pouvez également vérifier la mise à jour en clonant le script Canary depuis la console CloudWatch, puis en mettant à jour la version de l’exécution. Cela crée un autre script Canary qui est un clone de votre script Canary d'origine. Une fois que vous avez vérifié votre script Canary avec la nouvelle version d'exécution, vous pouvez mettre à jour la version d'exécution de votre script Canary d'origine et supprimer le clone de script Canary.

Vous pouvez également mettre à jour plusieurs scripts Canary à l'aide d'un script de mise à niveau. Pour de plus amples informations, consultez Script de mise à niveau de l'exécution d'un script Canary.

Si vous mettez à niveau un script Canary et qu'il échoue, consultez Dépannage d'un script Canary ayant échoué.

Dates de mise hors service des exécutions CloudWatch Synthetics

Le tableau suivant répertorie les dates de mise hors service des différentes versions d’exécution CloudWatch Synthetics.

Script de mise à niveau de l'exécution d'un script Canary

Pour mettre à niveau un script Canary vers une version d'exécution prise en charge, utilisez le script suivant.

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