Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

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 die Sprachen Node.js, Python oder Java verwenden. Die unterstützten Frameworks sind Puppeteer, Playwright und Selenium.

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.

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 Kanarienvögel haben, die Laufzeiten verwenden, die in den nächsten 60 Tagen nicht mehr unterstützt werden sollen. 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 CloudWatch Konsole, AWS CloudFormation des oder des SDK aktualisieren. AWS CLI AWS Wenn du die CloudWatch Konsole verwendest, kannst du bis zu fünf Canaries gleichzeitig aktualisieren, indem du sie auf der Canary-Listenseite auswählst und dann Aktionen, Laufzeit aktualisieren auswählst.

Sie können das Update überprüfen, indem Sie zuerst Ihr Update testen, bevor Sie das Runtime-Update durchführen. Wenn du die Runtime-Versionen aktualisierst, wähle in der CloudWatch Konsole die Optionen Testlauf starten oder Validieren und später speichern, um zusammen mit allen Änderungen, die du an der Konfiguration vorgenommen hast, einen Probelauf des ursprünglichen Canary zu erstellen. Beim Probelauf wird der Canary aktualisiert und ausgeführt, um zu überprüfen, ob das Runtime-Update für den Canary sicher ist. Sobald du deinen Canary mit der neuen Runtime-Version verifiziert hast, kannst du die Runtime-Version deines Canary aktualisieren. Weitere Informationen finden Sie unter Sichere Canary-Updates durchführen.

Alternativ kannst du das Update verifizieren, indem du zuerst den Canary mithilfe der CloudWatch Konsole klonst und die Runtime-Version aktualisierst. 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.

CloudWatch Verfallsdaten für Synthetics Runtime

In der folgenden Tabelle ist das Datum aufgeführt, an dem jede veraltete Synthetics-Laufzeit veraltet CloudWatch ist.

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