Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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 environnements d'exécution qui utilisent Node.js pour les scripts et le framework Puppeteer, ainsi que les environnements d'exécution qui utilisent Python pour les scripts et Selenium Webdriver pour le framework.

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.

Lorsque vous créez un canari, l'une des couches créées est une couche Synthetics précédée de. Synthetics Cette couche appartient au compte de service Synthetics et contient le code d'exécution.

CloudWatch Politique de support de Synthetics Runtime

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 certains de vos canaris utilisent des runtimes dont la dépréciation 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 Canary en utilisant la CloudWatch console AWS CloudFormation, le AWS CLI ou le AWS SDK. Lorsque vous utilisez la CloudWatch console, vous pouvez mettre à jour jusqu'à cinq canaris à la fois en les sélectionnant dans la page de liste des canaris, puis en choisissant Actions, Update Runtime.

Vous pouvez vérifier la mise à niveau en clonant d'abord le Canary à l'aide de la CloudWatch console et en mettant à jour sa version d'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, veuillez consulter 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 d'obsolescence des exécutions

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