Versões do runtime do Synthetics

Quando você cria ou atualiza um canário, você escolhe uma versão de runtime Synthetics para o canário. Um runtime do Synthetics é uma combinação do código Synthetics que chama seu manipulador de scripts e as camadas do Lambda de dependências agrupadas.

Atualmente, o CloudWatch Synthetics oferece suporte a tempos de execução que usam Node.js para scripts e o framework do Puppeteer, além de tempos de execução que usam Python para desenvolvimento de scripts e Selenium Webdriver para o framework.

Recomendamos usar sempre a versão de runtime mais recente para seus canaries, para poder utilizar os últimos recursos e atualizações feitas na biblioteca Synthetics.

Ao criar um canário, uma das camadas criadas é a Synthetics prefixada com Synthetics. Essa camada pertence à conta de serviço Synthetics e contém o código de runtime.

Política de suporte ao runtime do CloudWatch Synthetics

As versões de runtime do Synthetics estão sujeitas a atualizações de manutenção e segurança. Quando qualquer componente de uma versão de runtime não for mais compatível, essa versão de runtime do Synthetics será defasada.

Não é possível criar canários usando versões de runtime defasadas. Canaries que usam tempos de execução defasados continuam funcionando. Você pode parar, iniciar e apagar esses canaries. Você pode atualizar um canário existente que usa versões de runtime defasadas atualizando o canário para usar uma versão de runtime com suporte.

O CloudWatch Synthetics enviará uma notificação por e-mail, caso você tenha canaries que usam tempos de execução programados para serem defasados nos próximos 60 dias. Recomendamos migrar seus canaries para uma versão de runtime compatível para se beneficiar dos novos aprimoramentos de funcionalidade, segurança e performance incluídos em versões mais recentes.

Como atualizo um canário para uma nova versão de runtime?

É possível atualizar uma versão de runtime do canário usando o console do CloudWatch, o AWS CloudFormation, a AWS CLI ou o AWS SDK. Ao usar o console do CloudWatch, é possível atualizar até cinco canários ao mesmo tempo selecionando-os na página de lista do canário e escolhendo Ações, Atualizar Runtime.

É possível verificar a atualização clonando primeiro o canário com o console do CloudWatch e atualizando sua versão de runtime. Isso cria outro canário, que é um clone de seu canário original. Depois de verificar seu canário com a nova versão do runtime, é possível atualizar a versão do runtime do canário original e excluir o canário clone.

Você também pode atualizar vários canaries usando um script de atualização. Para ter mais informações, consulte Script de atualização do runtime do canário.

Se você atualizar um canário e ele falhar, consulte Solucionar problemas de um canário.

Datas de descontinuação do runtime

Script de atualização do runtime do canário

Para atualizar um script do canário para uma versão de runtime compatível, use o script a seguir.

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