Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Versi runtime Synthetics

Ketika Anda membuat atau memperbarui canary, Anda memilih versi runtime Synthetic untuk canary. Runtime Synthetic adalah kombinasi kode Synthetic yang memanggil pengatur skrip Anda, dan lapisan Lambda dari Dependensi gabungan.

CloudWatch Synthetics saat ini mendukung runtime yang menggunakan Node.js untuk skrip dan framework Puppeteer, dan runtime yang menggunakan Python untuk scripting dan Selenium Webdriver untuk framework.

Kami menyarankan agar Anda selalu menggunakan versi runtime terbaru untuk canary Anda, agar dapat menggunakan fitur dan pembaruan terbaru yang dibuat untuk pustaka Synthetic.

Saat Anda membuat kenari, salah satu lapisan yang dibuat adalah layer Synthetics yang dilengkapi dengan. Synthetics Lapisan ini dimiliki oleh akun layanan Synthetics dan berisi kode runtime.

CloudWatch Kebijakan dukungan runtime Synthetics

Versi runtime Synthetic bergantung pada pembaruan pemeliharaan dan keamanan. Ketika komponen mana pun dari sebuah versi runtime tidak lagi didukung, maka versi runtime Synthetics itu tidak lagi digunakan.

Anda tidak dapat membuat canary menggunakan versi runtime yang tidak lagi digunakan. Canary yang menggunakan runtime yang tidak lagi digunakan terus berjalan. Anda dapat menghentikan, memulai, dan menghapus canary ini. Anda dapat memperbarui canary yang sudah ada yang menggunakan versi runtime tercatat dengan memperbarui canary untuk menggunakan versi runtime yang didukung.

CloudWatch Synthetics memberi tahu Anda melalui email jika Anda memiliki kenari yang menggunakan runtime yang dijadwalkan tidak digunakan lagi dalam 60 hari ke depan. Kami merekomendasikan Anda memigrasi canary Anda ke versi runtime yang didukung untuk mendapatkan keuntungan dari peningkatan fungsionalitas, keamanan, dan peningkatan performa baru yang disertakan dalam rilis terbaru.

Bagaimana cara memperbarui canary ke versi runtime baru?

Anda dapat memperbarui versi runtime kenari dengan menggunakan CloudWatch konsol, AWS CloudFormation, AWS CLI atau. AWS SDK Saat Anda menggunakan CloudWatch konsol, Anda dapat memperbarui hingga lima kenari sekaligus dengan memilihnya di halaman daftar kenari dan kemudian memilih Tindakan, Perbarui Runtime.

Anda dapat memverifikasi peningkatan dengan terlebih dahulu mengkloning kenari menggunakan CloudWatch konsol dan memperbarui versi runtime-nya. Hal ini menciptakan canary lain yang merupakan klon dari canary asli Anda. Setelah Anda memverifikasi canary Anda dengan versi runtime yang baru, Anda dapat memperbarui versi runtime canary asli Anda dan menghapus canary klon tersebut.

Anda juga dapat memperbarui beberapa canary menggunakan skrip peningkatan. Untuk informasi selengkapnya, lihat Skrip peningkatan runtime canary.

Jika Anda meningkatkan canary dan gagal, silakan lihat Memecahkan masalah canary yang gagal.

Tanggal pengusangan runtime

Skrip peningkatan runtime canary

Untuk meningkatkan skrip canary untuk versi runtime yang didukung, gunakan skrip berikut.

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