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 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, ist eine der erstellten Ebenen eine Synthetics-Ebene, der vorangestellt ist. Synthetics Diese Ebene gehört dem Synthetics-Dienstkonto und enthält den Laufzeitcode.

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 aktualisieren, indem Sie die CloudWatch Konsole,, oder die verwenden. AWS CloudFormation AWS CLI AWS SDK 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, Runtime aktualisieren auswählst.

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

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