Synthetics Laufzeitversionen

Wenn Sie ein Canary erstellen oder aktualisieren, wählen Sie eine Synthetics-Laufzeitversion für das Canary aus. Eine Synthetics-Laufzeit ist eine Kombination aus Synthetics-Code, der Ihren Skript-Handler aufruft, und den Lambda-Ebenen gebündelter Abhängigkeiten.

CloudWatch Synthetics unterstützt derzeit Laufzeiten, die Node.js für Skripts und das Puppeteer-Framework verwenden, sowie Laufzeiten, die Python für das Scripting und Selenium Webdriver für das Framework verwenden.

Wir empfehlen, immer die aktuellste Laufzeitversion für Ihre Canarys zu verwenden, um die neuesten Features und Aktualisierungen der Synthetics-Bibliothek nutzen zu können.

Wenn Sie einen Kanarienvogel erstellen, handelt es sich bei einer der erstellten Ebenen um eine Synthetics-Ebene, der vorangestellt ist. Synthetics Diese Ebene gehört dem Synthetics-Dienstkonto und enthält den Laufzeitcode.

Anmerkung

Wenn Sie ein Canary auf eine neue Version der Synthetics-Laufzeitumgebung aktualisieren, werden auch alle Synthetics-Bibliotheksfunktionen, die Ihr Canary verwendet, automatisch auf die gleiche Version von NodeJS aktualisiert, die die Synthetics-Laufzeitumgebung unterstützt.

Themen

• CloudWatch Richtlinie zur Unterstützung von Synthetics Runtime
• Laufzeitversionen mit Node.js und Puppeteer
• Laufzeitversionen mit Python und Selenium Webdriver

CloudWatch Richtlinie zur Unterstützung von Synthetics Runtime

Synthetics-Laufzeitversionen unterliegen Wartungs- und Sicherheitsupdates. Wenn eine Komponente einer Laufzeitversion nicht mehr unterstützt wird, gilt diese Synthetics-Laufzeitversion als veraltet.

Sie können keine Canaries mit veralteten Laufzeitversionen erstellen. Canaries, die veraltete Laufzeiten verwenden, werden weiterhin ausgeführt. Sie können diese Canaries stoppen, starten und löschen. Sie können ein vorhandenes Canary aktualisieren, das eine veraltete Laufzeitversion verwendet, indem Sie das Canary so aktualisieren, dass es eine unterstützte Laufzeitversion verwendet.

CloudWatch Synthetics benachrichtigt Sie per E-Mail, wenn Sie Canaries haben, die Laufzeiten verwenden, die voraussichtlich in den nächsten 60 Tagen nicht mehr unterstützt werden. Es wird empfohlen, Ihre Canarys auf eine unterstützte Laufzeitversion zu migrieren, um von den neuen Funktionalitäts-, Sicherheits- und Leistungsverbesserungen zu profitieren, die in neueren Versionen enthalten sind.

Wie aktualisiere ich einen Canary auf eine neue Laufzeitversion?

Sie können die Runtime-Version eines Canary mithilfe der Konsole aktualisieren. CloudWatch AWS CloudFormation, der AWS CLI oder der AWS SDK. Wenn Sie die CloudWatch Konsole verwenden, können Sie bis zu fünf Canaries gleichzeitig aktualisieren, indem Sie sie auf der Canary-Listenseite auswählen und dann Actions, Update Runtime wählen.

Sie können das Upgrade überprüfen, indem Sie zuerst den Canary mithilfe der CloudWatch Konsole klonen und seine Runtime-Version aktualisieren. Dadurch entsteht ein weiterer Canary, der ein Klon Ihres ursprünglichen Canarys ist. Sobald Sie Ihren Canary mit der neuen Laufzeitversion verifiziert haben, können Sie die Laufzeitversion Ihres ursprünglichen Canary aktualisieren und den Klon-Canary löschen.

Sie können auch mehrere Canarys mit einem Upgrade-Skript aktualisieren. Weitere Informationen finden Sie unter Canary-Laufzeit-Upgradeskript.

Wenn Sie einen Canary aktualisieren und dies fehlschlägt, finden Sie unter Problembehandlung bei fehlgeschlagenem Canary.

Datumsangaben für die Laufzeitabweichung

Laufzeitversion	Datum der Veraltung
syn-nodejs-puppeteer-6.1	8. März 2024
syn-nodejs-puppeteer-6.0	8. März 2024
syn-nodejs-puppeteer-5.1	8. März 2024
syn-nodejs-puppeteer-5.0	8. März 2024
syn-nodejs-puppeteer-4.0	8. März 2024
syn-nodejs-puppeteer-3.9	8. Januar 2024
syn-nodejs-puppeteer-3.8	8. Januar 2024
syn-python-selenium-2.0	8. März 2024
syn-python-selenium-1.3	8. März 2024
syn-python-selenium-1.2	8. März 2024
syn-python-selenium-1.1	8. März 2024
syn-python-selenium-1.0	8. März 2024
syn-nodejs-puppeteer-3.7	8. Januar 2024
syn-nodejs-puppeteer-3.6	8. Januar 2024
syn-nodejs-puppeteer-3.5	8. Januar 2024
syn-nodejs-puppeteer-3.4	13. November 2022
syn-nodejs-puppeteer-3.3	13. November 2022
syn-nodejs-puppeteer-3.2	13. November 2022
syn-nodejs-puppeteer-3.1	13. November 2022
syn-nodejs-puppeteer-3.0	13. November 2022
syn-nodejs-2.2	28. Mai 2021
syn-nodejs-2.1	28. Mai 2021
syn-nodejs-2.0	28. Mai 2021
syn-nodejs-2.0-beta	8. Februar 2021
syn-1.0	28. Mai 2021

Canary-Laufzeit-Upgradeskript

Verwenden Sie das folgende Skript, um ein Canary-Skript auf eine unterstützte Laufzeitversion zu aktualisieren.

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