Versiones de tiempo de ejecución de Synthetics

Al crear o actualizar un valor controlado, se elige una versión de tiempo de ejecución de Synthetics para este. Un tiempo de ejecución de Synthetics es una combinación del código de Synthetics que llama al controlador de scripts y de las capas Lambda de las dependencias agrupadas.

CloudWatch Synthetics admite actualmente los tiempos de ejecución que utilizan Node.js para scripts y el marco de Puppeteer, y los tiempos de ejecución que utilizan Python para scripting y Selenium Webdriver para el marco.

Recomendamos utilizar siempre la versión de tiempo de ejecución más reciente para sus valores controlados a fin de poder usar las últimas características y actualizaciones realizadas en la biblioteca de Synthetics.

Cuando crea un valor controlado, una de las capas que se crean es una capa de Synthetics a la que se le antepone Synthetics. Esta capa es propiedad de la cuenta del servicio Synthetics y contiene el código del tiempo de ejecución.

Política de soporte de tiempo de ejecución de CloudWatch Synthetics

Las versiones de tiempo de ejecución de Synthetics están sujetas a operaciones de mantenimiento y actualizaciones de seguridad. Cuando cualquier componente de una versión de tiempo de ejecución deja de ser compatible, dicha versión de tiempo de ejecución de Synthetics queda obsoleta.

No puede crear canaries nuevos con versiones de tiempo de ejecución obsoletas. Los Canaries que utilizan tiempos de ejecución obsoletos siguen ejecutándose. Puede detener, iniciar y eliminar estos canaries. Para actualizar un valor controlado existente que utiliza versiones de tiempo de ejecución obsoletas, actualícelo de forma que utilice una versión de tiempo de ejecución compatible.

CloudWatch Synthetics le notifica por email si tiene canaries que utilizan tiempos de ejecución programados para quedar obsoletos en los próximos 60 días. Se recomienda que migre los canaries a una versión de tiempo de ejecución compatible para beneficiarse de las nuevas mejoras de funcionalidad, seguridad y de rendimiento que se incluyen en las versiones más recientes.

¿Cómo se actualiza un valor controlado a una nueva versión en tiempo de ejecución?

Se puede actualizar la versión en tiempo de ejecución de un valor controlado mediante la consola de CloudWatch, AWS CloudFormation, AWS CLI o el SDK de AWS. Cuando utilice la consola de CloudWatch, puede actualizar hasta cinco valores controlados a la vez si los selecciona en la página de la lista de valores controlados y, a continuación, elige Acciones, Actualizar tiempo de ejecución.

Se puede verificar la actualización al clonar primero el valor controlado mediante la consola de CloudWatch y si se actualiza la versión de tiempo de ejecución. Esto crea otro valor controlado que es un clon del valor controlado original. Una vez que haya verificado el valor controlado con la nueva versión de tiempo de ejecución, puede actualizar la versión de tiempo de ejecución del valor controlado original y eliminar el valor controlado clon.

También puede actualizar varios canaries si se utiliza un script de actualización. Para obtener más información, consulte Script de actualización en tiempo de ejecución de valores controlados.

Si se actualiza un valor controlado y falla, consulte Solución de problemas de un valor controlado.

Fechas de caducidad de los tiempos de ejecución

Script de actualización en tiempo de ejecución de valores controlados

Para actualizar un script de valor controlado a una versión compatible de tiempo de ejecución, utilice el siguiente script.

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