Administra verificaciones de tiempo de actividad

Una verificación de tiempo de actividad es una solicitud que se envía a un recurso para ver si responde. Puedes usar verificaciones de tiempo de actividad para determinar la disponibilidad de una instancia de VM, un servicio de App Engine, una URL o un balanceador de cargas de AWS.

Para supervisar la disponibilidad de un recurso, puedes crear una política de alertas que cree un incidente si falla la verificación de tiempo de actividad. La política de alertas se puede configurar para que te notifique por correo electrónico o a través de un canal diferente. La notificación puede incluir detalles sobre el recurso que no respondió. También tienes la opción de observar los resultados de las verificaciones de tiempo de actividad en los paneles de verificación de tiempo de actividad de Monitoring.

Esta página te muestra cómo hacer lo siguiente:

  • Crear una nueva verificación de tiempo de actividad
  • Consultar el panel para obtener verificaciones de tiempo de actividad
  • Editar una verificación de tiempo de actividad
  • Borra una verificación de tiempo de actividad

Consulta la sección Próximos pasos para obtener vínculos a páginas de precios y páginas que describen la supervisión de tus verificaciones de tiempo de actividad.

Antes de comenzar

  1. El uso de las verificaciones de tiempo de actividad se ve afectado por los firewalls que protegen tu servicio.

    • Si el recurso que verificas no está disponible públicamente, debes configurar su firewall para permitir el tráfico entrante de los servidores de verificación de tiempo de actividad. Consulta Obtén direcciones IP para descargar una lista de las direcciones IP.
    • Si el recurso que verificas no tiene una dirección IP externa, las verificaciones de tiempo de actividad no podrán acceder a él.
  2. La verificación de tiempo de actividad no carga los elementos de la página ni ejecuta JavaScript, y la configuración predeterminada de una verificación de tiempo de actividad no incluye la autenticación.

    Para HTTP y HTTPS, si la respuesta es una redirección a otra URL, la verificación recupera los datos de esa URL. Por último, la verificación de tiempo de actividad evalúa los datos para determinar si la verificación se realizó correctamente o no.

    Para que sea correcta, se deben cumplir estas condiciones:

    • El estado HTTP es Success.
    • Los datos no tienen contenido requerido o el contenido obligatorio está presente.

Crea una verificación de tiempo de actividad

En esta sección, se explica cómo crear y configurar verificaciones de tiempo de actividad.

Usa la API

API

Realiza una llamada al método projects.uptimeCheckConfigs.create. Configura los parámetros del método de la siguiente manera:

  • parent: Obligatorio. Este debe ser el nombre del proyecto en el que se creará la verificación de tiempo de actividad. Reemplaza [PROJECT_ID] por tu ID del proyecto de Google Cloud. El formato es:

    projects/[PROJECT_ID]
    
  • El cuerpo de la solicitud debe contener un objeto UptimeCheckConfig para la verificación de tiempo de actividad nueva. Esta página proporciona información solo en algunos campos. Para obtener la documentación completa sobre este objeto y sus campos, consulta UptimeCheckConfig:

    • Deja en blanco el campo name del objeto de configuración. El sistema establece este campo cuando se construye el objeto de configuración de respuesta.

    • Si configuras una verificación HTTP o HTTPS, debes propagar el campo HttpCheck del objeto UptimeCheckConfig. En este objeto, configura el campo requestMethod como GET o POST. Si se omite este campo o se establece como METHOD_UNSPECIFIED, se emite una solicitud GET.

      Si configuras una solicitud POST, completa los campos contentType y body.

El método create muestra el objeto UptimeCheckConfig para la nueva configuración.

Si la configuración de tiempo de actividad creada no funciona como esperas, consulta la sección Verifica fallas en esta página.

C#

public static object CreateUptimeCheck(string projectId, string hostName,
    string displayName)
{
    // Define a new config.
    var config = new UptimeCheckConfig()
    {
        DisplayName = displayName,
        MonitoredResource = new MonitoredResource()
        {
            Type = "uptime_url",
            Labels = { { "host", hostName } }
        },
        HttpCheck = new UptimeCheckConfig.Types.HttpCheck()
        {
            Path = "/",
            Port = 80,
        },
        Timeout = TimeSpan.FromSeconds(10).ToDuration(),
        Period = TimeSpan.FromMinutes(5).ToDuration()
    };
    // Create a client.
    var client = UptimeCheckServiceClient.Create();
    ProjectName projectName = new ProjectName(projectId);
    // Create the config.
    var newConfig = client.CreateUptimeCheckConfig(
        projectName,
        config,
        CallSettings.FromExpiration(
            Expiration.FromTimeout(
                TimeSpan.FromMinutes(2))));
    Console.WriteLine(newConfig.Name);
    return 0;
}

Java

private static void createUptimeCheck(
    String projectId, String displayName, String hostName, String pathName) throws IOException {
  CreateUptimeCheckConfigRequest request =
      CreateUptimeCheckConfigRequest.newBuilder()
          .setParent(ProjectName.format(projectId))
          .setUptimeCheckConfig(
              UptimeCheckConfig.newBuilder()
                  .setDisplayName(displayName)
                  .setMonitoredResource(
                      MonitoredResource.newBuilder()
                          .setType("uptime_url")
                          .putLabels("host", hostName))
                  .setHttpCheck(HttpCheck.newBuilder().setPath(pathName).setPort(80))
                  .setTimeout(Duration.newBuilder().setSeconds(10))
                  .setPeriod(Duration.newBuilder().setSeconds(300)))
          .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    UptimeCheckConfig config = client.createUptimeCheckConfig(request);
    System.out.println("Uptime check created: " + config.getDisplayName());
  } catch (Exception e) {
    usage("Exception creating uptime check: " + e.toString());
    throw e;
  }
}

Go


// createGet creates an example uptime check on a GET request.
func createGet(w io.Writer, projectID string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.CreateUptimeCheckConfigRequest{
		Parent: "projects/" + projectID,
		UptimeCheckConfig: &monitoringpb.UptimeCheckConfig{
			DisplayName: "new GET uptime check",
			Resource: &monitoringpb.UptimeCheckConfig_MonitoredResource{
				MonitoredResource: &monitoredres.MonitoredResource{
					Type: "uptime_url",
					Labels: map[string]string{
						"host": "example.com",
					},
				},
			},
			CheckRequestType: &monitoringpb.UptimeCheckConfig_HttpCheck_{
				HttpCheck: &monitoringpb.UptimeCheckConfig_HttpCheck{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_GET,
					Path:          "/",
					Port:          80,
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig GET: %v", err)
	}
	fmt.Fprintf(w, "Successfully created GET uptime check %q\n", config.GetDisplayName())
	return config, nil
}

// createPost creates an example uptime check on a POST request.
func createPost(w io.Writer, projectID string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.CreateUptimeCheckConfigRequest{
		Parent: "projects/" + projectID,
		UptimeCheckConfig: &monitoringpb.UptimeCheckConfig{
			DisplayName: "new POST uptime check",
			Resource: &monitoringpb.UptimeCheckConfig_MonitoredResource{
				MonitoredResource: &monitoredres.MonitoredResource{
					Type: "uptime_url",
					Labels: map[string]string{
						"host": "example.com",
					},
				},
			},
			CheckRequestType: &monitoringpb.UptimeCheckConfig_HttpCheck_{
				HttpCheck: &monitoringpb.UptimeCheckConfig_HttpCheck{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_POST,
					ContentType:   monitoringpb.UptimeCheckConfig_HttpCheck_URL_ENCODED,
					Path:          "/",
					Port:          80,
					Body:          []byte(base64.URLEncoding.EncodeToString([]byte("key: value"))),
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig POST: %v", err)
	}
	fmt.Fprintf(w, "Successfully created POST uptime check %q\n", config.GetDisplayName())
	return config, nil
}

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const hostname = 'mydomain.com';

const request = {
  // i.e. parent: 'projects/my-project-id'
  parent: client.projectPath(projectId),
  uptimeCheckConfig: {
    displayName: 'My Uptime Check',
    monitoredResource: {
      // See the Uptime Check docs for supported MonitoredResource types
      type: 'uptime_url',
      labels: {
        host: hostname,
      },
    },
    httpCheck: {
      path: '/',
      port: 80,
    },
    timeout: {
      seconds: 10,
    },
    period: {
      seconds: 300,
    },
  },
};

// Creates an uptime check config for a GCE instance
const [uptimeCheckConfig] = await client.createUptimeCheckConfig(request);
console.log('Uptime check created:');
console.log(`ID: ${uptimeCheckConfig.name}`);
console.log(`Display Name: ${uptimeCheckConfig.displayName}`);
console.log('Resource: %j', uptimeCheckConfig.monitoredResource);
console.log('Period: %j', uptimeCheckConfig.period);
console.log('Timeout: %j', uptimeCheckConfig.timeout);
console.log(`Check type: ${uptimeCheckConfig.check_request_type}`);
console.log(
  'Check: %j',
  uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
);
console.log(
  `Content matchers: ${uptimeCheckConfig.contentMatchers
    .map(matcher => matcher.content)
    .join(', ')}`
);
console.log(`Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\UptimeCheckConfig;
use Google\Api\MonitoredResource;

/**
 * Example:
 * ```
 * create_uptime_check($projectId, 'myproject.appspot.com', 'Test Uptime Check!');
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $hostName
 * @param string $displayName
 */
function create_uptime_check($projectId, $hostName = 'example.com', $displayName = 'New uptime check')
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $monitoredResource = new MonitoredResource();
    $monitoredResource->setType('uptime_url');
    $monitoredResource->setLabels(['host' => $hostName]);

    $uptimeCheckConfig = new UptimeCheckConfig();
    $uptimeCheckConfig->setDisplayName($displayName);
    $uptimeCheckConfig->setMonitoredResource($monitoredResource);

    $uptimeCheckConfig = $uptimeCheckClient->createUptimeCheckConfig(
        $uptimeCheckClient->projectName($projectId),
        $uptimeCheckConfig
    );

    printf('Created an uptime check: %s' . PHP_EOL, $uptimeCheckConfig->getName());
}

Python

def create_uptime_check_config_get(project_name, host_name=None, display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or "New GET uptime check"
    config.monitored_resource.type = "uptime_url"
    config.monitored_resource.labels.update({"host": host_name or "example.com"})
    config.http_check.request_method = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.RequestMethod.GET
    )
    config.http_check.path = "/"
    config.http_check.port = 80
    config.timeout.seconds = 10
    config.period.seconds = 300

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(project_name, config)
    pprint.pprint(new_config)
    return new_config

def create_uptime_check_config_post(project_name, host_name=None, display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or "New POST uptime check"
    config.monitored_resource.type = "uptime_url"
    config.monitored_resource.labels.update({"host": host_name or "example.com"})
    config.http_check.request_method = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.RequestMethod.POST
    )
    config.http_check.content_type = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.ContentType.URL_ENCODED
    )
    config.http_check.body = "foo=bar".encode("utf-8")
    config.http_check.path = "/"
    config.http_check.port = 80
    config.timeout.seconds = 10
    config.period.seconds = 300

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(project_name, config)
    pprint.pprint(new_config)
    return new_config

Ruby

def create_uptime_check_config project_id: nil, host_name: nil, display_name: nil
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  project_name = client.project_path project: project_id
  config = {
    display_name:       display_name.nil? ? "New uptime check" : display_name,
    monitored_resource: {
      type:   "uptime_url",
      labels: { "host" => host_name.nil? ? "example.com" : host_name }
    },
    http_check:         { path: "/", port: 80 },
    timeout:            { seconds: 10 },
    period:             { seconds: 300 }
  }
  new_config = client.create_uptime_check_config \
    parent:              project_name,
    uptime_check_config: config
  puts new_config.name
  new_config
end

Puede haber un retraso de hasta 5 minutos antes de que comience el flujo de los resultados de la verificación de tiempo de actividad en Monitoring. Durante ese tiempo, el panel de verificación de tiempo de actividad informa el estado como "sin datos disponibles".

Usa Cloud Console

El proceso de creación de una verificación de tiempo de actividad con Cloud Console se está actualizando. En esta sección, se describe cómo crear una verificación de tiempo de actividad mediante el flujo nuevo y el flujo clásico. Los primeros pasos de ambos flujos son idénticos. Mediante el formulario Crear verificación de tiempo de actividad, puedes indicar si estás usando el flujo nuevo o el flujo clásico.

Flujo nuevo

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

  3. Haga clic en Crear una verificación de tiempo de actividad.

  4. Si la ventana Crear verificación de tiempo de actividad se parece a la siguiente captura de pantalla, continúa con estas instrucciones. De lo contrario, haga clic en la pestaña Flujo clásico de esta tabla y siga estas instrucciones:

    Crea un diálogo de verificación de tiempo de actividad.

  5. Ingresa un título descriptivo para la verificación de tiempo de actividad y, luego, haz clic en Siguiente.

  6. Especifica el objetivo de la verificación de tiempo de actividad:

    1. Selecciona el protocolo. Tienes las opciones HTTP, HTTPS y TCP.

    2. Elige uno de los siguientes tipos de recursos:

      • URL: cualquier dirección IPv4 o nombre de host. La ruta de acceso y el puerto se ingresan por separado.
      • App Engine: Aplicaciones de App Engine (módulos).
      • Instancia: instancias de Compute Engine o AWS EC2.
      • Elastic Load Balancer: Balanceador de cargas AWS.
    3. Ingresa los campos específicos del protocolo:

      • Para verificaciones de TCP, ingresa el puerto.

      • Para las verificaciones de HTTP y HTTPS, tienes la opción de ingresar una ruta dentro de tu host o recurso. Todas las verificaciones de tiempo de actividad que usan estos protocolos envían una solicitud a http://target/path. En esta expresión, para un recurso de URL, target es un nombre de host o una dirección IP. Para un recurso de App Engine, target es un nombre de host derivado del nombre del servicio. Para recursos de instancia y balanceador de cargas, target es una dirección IP derivada del nombre que proporcionaste para el recurso o el grupo de recursos.

        Si dejas el campo path en blanco o si estableces el valor en /, la solicitud se emitirá en http://target/.

        Para emitir una verificación de tiempo de actividad en el recurso de URL example.com/tester, establece el campo de nombre de host en example.com y el campo de ruta de acceso en /tester.

        Supongamos que implementaste un servidor en App Engine con un despachador que admite / y /hello. Si dejas el campo de ruta de acceso vacío, la verificación de tiempo de actividad se envía al controlador /. Para emitir la verificación de tiempo de actividad al controlador /hello, establece el valor del campo de ruta en /hello.

    4. Ingresa los campos específicos de los recursos:

      • Para los recursos de URL, ingresa el nombre de host en el campo Nombre de host. Por ejemplo, ingresa example.com.

      • En el caso de los recursos de App Engine, ingresa el nombre del servicio en el campo Servicio.

      • En el caso de los recursos de Instancia y Elastic Load Balancer, completa los siguientes campos:

        • Para emitir una verificación de tiempo de actividad a una sola instancia o balanceador de cargas, en el campo Aplica a, selecciona Único y, luego, usa el menú para seleccionar la instancia o el balanceador de cargas específicos.
        • Para enviar una verificación de tiempo de actividad a un grupo de Monitoring, en el campo Aplica a, selecciona Grupo y, luego, usa el menú para seleccionar el nombre del grupo.
    5. El campo Frecuencia de verificación controla la frecuencia con la que se ejecuta la verificación de tiempo de actividad. Puedes dejar el valor predeterminado o seleccionar un valor en el menú de opciones.

    6. Para configurar regiones de verificador o configurar certificados SSL, autenticación, encabezados y puertos para verificaciones HTTP y HTTPS, haz clic en Más opciones de destino:

      • Regiones: selecciona las regiones en las que se encuentran las verificaciones de tiempo de actividad para recibir solicitudes. Una verificación de tiempo de actividad debe tener al menos 3 verificadores. Hay 1 verificador en todas las regiones, excepto Estados Unidos, que tiene 3 verificadores. La configuración predeterminada, Global, incluye todas las regiones.
      • General: llena este campo para verificar los hosts virtuales. Este campo no está disponible para las verificaciones de TCP.
      • Puerto: especifica un número de puerto.
      • Encabezados personalizados: proporciona encabezados personalizados y encriptados si lo deseas. La encriptación oculta los valores de los encabezados en el formulario. Usa la encriptación para los encabezados relacionados con la autenticación que no quieres que otros vean.

      • Autenticación: Proporciona un nombre de usuario y contraseña únicos. Estos valores se envían como un encabezado de autorización. Si estableces valores aquí, no establezcas un encabezado de autorización por separado; si estableces un encabezado de autorización, no establezcas valores aquí. Las contraseñas siempre están ocultas en el formulario. Este campo no está disponible para verificaciones TCP.

      • Validación del certificado SSL: si seleccionaste HTTPS para un recurso de URL, de forma predeterminada, el servicio intenta conectarse a través de HTTPS y valida el certificado SSL. La verificación del tiempo de actividad falla si una URL tiene un certificado no válido. Las razones para un certificado no válido incluyen un certificado vencido, un certificado autofirmado, un certificado con nombre de dominio incorrecto y un certificado que usa la extensión AIA.

        Para forzar una verificación de tiempo de actividad HTTPS a fin de validar el certificado SSL, asegúrate de que la opción Validar certificados SSL esté seleccionada.

        Para inhabilitar la validación de certificados SSL, asegúrate de que la opción Validar certificados SSL no esté seleccionada.

        Si tienes certificados SSL con extensiones de acceso de información de autoridad (AIA), debes inhabilitar la validación de certificados SSL. Estos tipos de certificados no son compatibles y fallan la secuencia de validación. En general, el mensaje de error es “Respuesta con error de protocolo de enlace SSL en 10,000 ms”.

        Puedes usar la métrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires para crear una alerta que te notifique antes de que venza tu certificado. Para obtener más información, consulta las Políticas de muestra: política de verificación de tiempo de actividad.

        Selecciona la casilla de verificación Validar certificados SSL.

    7. Haga clic en Next.

  7. Completa el panel de Validación de respuesta.

    • Selecciona Tiempo de espera de respuesta en el menú de opciones. Puedes elegir cualquier valor entre 1 y 60 segundos. Una verificación de tiempo de actividad falla si no se recibe respuesta de más de una ubicación en este tiempo de espera. La verificación del tiempo de actividad pasa si cualquier ubicación responde.
    • Para la coincidencia de contenido, asegúrate de que la etiqueta de activar o desactivar sea Coincidencia de contenido habilitada:

      • Selecciona Tipo de concordancia del contenido de la respuesta en el menú de opciones. Este campo determina cómo se compara el contenido de la respuesta con los datos mostrados. Por ejemplo, si el contenido de respuesta es abcd y el tipo de coincidencia de contenido es Contiene, la verificación de tiempo de actividad es correcta si los datos de respuesta contienen abcd. La verificación de tiempo de actividad falla si la respuesta no contiene abcd.
      • Ingresa el Contenido de la respuesta. Debe ser una string de no más de 1,024 bytes. En la API, este es el objeto ContentMatcher.
    • Si no deseas que se envíen las verificaciones de tiempo de actividad a Cloud Logging, desmarca la opción Fallas de verificación de registro.

    • Haz clic en Siguiente.

  8. Complete el panel Alerta y notificación:

    Crea una política de alertas si deseas que la verificación de tiempo de actividad esté supervisada. Si creas una política de alertas, se crea un incidente cuando falla tu verificación de tiempo de actividad y se envía una notificación a todos los canales de notificaciones adjuntos a la política. Por ejemplo, si agregas una dirección de correo electrónico a la política, se envía un correo electrónico a esa dirección cuando se crea un incidente.

    Puedes crear la política de alertas en este paso o puedes agregar la política de alertas después de crear la verificación. La creación de una política de alertas para la verificación de tiempo de actividad se controla mediante un botón:

    • Si el texto del botón es No crear una alerta, no se creará una política de alertas y se inhabilitarán todos los campos. Si deseas crear una política de alertas, haz clic en el botón.
    • Si el texto del botón es Crear una alerta, se creará una política de alertas y todos los campos estarán habilitados. Si no deseas crear una política de alertas, haz clic en el botón.

    Para crear una política de alertas como parte de este flujo, haz lo siguiente:

    1. Asegúrate de que el texto del botón sea Crear una alerta.
    2. En el campo de nombre, ingresa un nombre para la política de alertas o usa el nombre predeterminado.
    3. Para agregar uno o más canales de notificación a la política de alertas, haz clic en Menú en el cuadro de texto etiquetado Canal de notificaciones. Selecciona los canales que quieres agregar y haz clic en Aceptar. Los canales de notificaciones se agrupan alfabéticamente de cada tipo de canal.

      Si no aparece en un canal de notificaciones que quieras agregar a la política de alertas, haz clic en Administrar canales de notificaciones.

      Cuadro de diálogo de notificaciones en el que se muestran los botones para actualizar y administrar canales.

      Se abrirá la ventana Canales de notificaciones en una nueva pestaña del navegador. Agrega los canales de notificaciones y, luego, regresa a esta pestaña, haz clic en Actualizar y selecciona los canales de notificación para agregar a la política de alertas.

    4. En el campo de duración, selecciona por cuánto tiempo deben fallar las verificaciones de tiempo de actividad antes de crear un incidente. De forma predeterminada, la política de alertas se configura para crear un incidente si al menos 2 regiones informan fallas en la verificación de tiempo de actividad durante un período de 1 minuto.

    Consulta Administra políticas para obtener información sobre cómo inhabilitar, editar y borrar políticas de alertas.

  9. Para verificar la configuración de verificación de tiempo de actividad, haz clic en Probar (Test). Si el resultado no es el esperado, consulta la sección sobre la verificación de fallas a continuación, corrige tu configuración y repite el paso de verificación.

  10. Haga clic en Crear. Si faltan datos obligatorios, la acción de guardar falla y aparece una lista de campos que requieren datos junto a los botones de diálogo. Después de guardar los cambios, se muestra el cuadro de diálogo Verificación de tiempo de actividad creada.

Flujo clásico

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

  3. Haga clic en Crear una verificación de tiempo de actividad.

  4. Si la ventana Crear verificación de tiempo de actividad se parece a la siguiente captura de pantalla, continúa con estas instrucciones. De lo contrario, haga clic en la pestaña Flujo nuevo de esta tabla y siga estas instrucciones:

    Vista clásica del cuadro de diálogo Crear una verificación de tiempo de actividad.

  5. En la ventana Nueva verificación de tiempo de actividad (New uptime check), completa los campos de la verificación, como se describe en Opciones básicas.

  6. Haz clic en Mostrar opciones avanzadas (Show advanced options) (opcional). Para obtener más información sobre las opciones avanzadas, consulta Opciones avanzadas.

  7. Para verificar la configuración de verificación de tiempo de actividad, haz clic en Probar (Test). Si el resultado no es el esperado, consulta la sección sobre la verificación de fallas a continuación, corrige tu configuración y repite el paso de verificación.

  8. Haz clic en Guardar (Save). Si faltan datos obligatorios, la acción de guardar falla y aparece una lista de campos que requieren datos junto a los botones de diálogo. Después de guardar los cambios, se muestra el cuadro de diálogo Verificación de tiempo de actividad creada.

  9. Para recibir notificaciones sobre un error en el tiempo de actividad, haz clic en Crear una política de alertas (Create alert policy) (opcional). Si no quieres crear una política de alertas ahora, haz clic en No, gracias. Siempre puedes crear una política de alertas para una verificación de tiempo de actividad. Para obtener más información, consulta Supervisa las verificaciones de tiempo de actividad.

    Cuadro de diálogo de la verificación de tiempo de actividad creada.

Puede haber un retraso de hasta 5 minutos antes de que comience el flujo de los resultados de la verificación de tiempo de actividad en Monitoring. Durante ese tiempo, el panel de verificación de tiempo de actividad informa el estado como "sin datos disponibles".

Opciones básicas para la interfaz clásica

En esta sección, se describen los campos que usas cuando creas una verificación de tiempo de actividad cuando usas la interfaz clásica de Cloud Console o cuando usas la API. Cuando usas la API, proporcionas los valores correspondientes en un objeto UptimeCheckConfig.

  1. Título: Un nombre para identificar tu verificación. Por ejemplo, Example.com uptime check.

  2. Tipo de verificación: selecciona un protocolo HTTP, HTTPS o TCP.

    Si usas la API y el tipo de verificación es HTTP o HTTPS, puedes configurar la verificación para emitir una solicitud POST. Consulta el ejemplo de la API anterior.

    Si seleccionas HTTPS, el servicio intenta conectarse a través de HTTPS y valida el certificado SSL. De forma predeterminada, un certificado vencido o autofirmado hace que falle la verificación de tiempo de actividad.

    Para inhabilitar la validación del certificado SSL, desmarca la opción Validar certificados SSL.

  3. Tipo de recurso: elige uno de los siguientes tipos de recursos:

    • App Engine: Aplicaciones de App Engine (módulos).
    • Elastic Load Balancer: Balanceador de cargas AWS.
    • Instancia: instancias de Compute Engine o AWS EC2. En la API, esto se divide en gce_instance y aws_ec2_instance.
    • URL: cualquier dirección IPv4 o nombre de host. La ruta de acceso y el puerto se ingresan por separado.
  4. Ingresa los campos específicos del protocolo:

    • Para verificaciones de TCP, ingresa el puerto.

    • Para las verificaciones de HTTP y HTTPS, tienes la opción de ingresar una ruta dentro de tu host o recurso. Todas las verificaciones de tiempo de actividad que usan estos protocolos envían una solicitud a http://target/path. En esta expresión, para un recurso de URL, target es un nombre de host o una dirección IP. Para un recurso de App Engine, target es un nombre de host derivado del nombre de servicio. Para la instancia y los balanceadores de cargas, target es una dirección IP derivada del nombre que proporcionaste para el recurso o el grupo de recursos.

      Si dejas el campo path en blanco o si estableces el valor en /, la solicitud HTTP se emitirá a http://target/.

      Para emitir una verificación de tiempo de actividad en el recurso de URL example.com/tester, establece el campo de nombre de host en example.com y el campo de ruta de acceso en /tester.

      Supongamos que implementaste un servidor en App Engine con un despachador que admite / y /hello. Si dejas el campo de ruta de acceso vacío, la verificación de tiempo de actividad se envía al controlador /. Para emitir la verificación de tiempo de actividad en el controlador /hello, establece el valor del campo de ruta en /hello.

  5. Ingresa los campos específicos de los recursos:

    • Si seleccionas un tipo de recurso de URL y, luego, ingresa el nombre del host. Por ejemplo, ingresa example.com.

    • Si seleccionas un tipo de recurso de App Engine, selecciona el nombre del servicio.

    • Si seleccionas un Tipo de recurso de Elastic Load Balancer o Instancia, especifica si la verificación de tiempo de actividad se aplica a un solo recurso o a un grupo de recursos. Para aplicar la verificación de tiempo de actividad a una instancia o a un balanceador de cargas, selecciona Único y, luego, selecciona la instancia o el balanceador de cargas específico. Para aplicar la verificación de tiempo de actividad a un grupo de instancias o a un grupo de balanceadores de cargas, selecciona Grupo y, luego, selecciona el nombre del grupo. Si usas la API, completa el recurso supervisado con las etiquetas de recursos requeridas, como se describe en la Lista de recursos supervisados.

  6. Verificar cada: elige 1, 5, 10 o 15 minutos. Este valor determina la cadencia de las verificaciones de tiempo de actividad. Por ejemplo, si seleccionas 5 minutos, cada ubicación geográfica emite una verificación de tiempo de actividad cada 5 minutos.

Opciones avanzadas para la interfaz clásica

Haz clic en Mostrar opciones avanzadas para ver toda la configuración avanzada. La configuración avanzada que está disponible depende del tipo de verificación:

  • General: llena este campo para verificar los hosts virtuales. Este campo no está disponible para las verificaciones de TCP.
  • Puerto: especifica un número de puerto.
  • Tipo de concordancia del contenido de la respuesta: especifica cómo se compara la string ingresada en el contenido de la respuesta con los datos reales que se muestran. Por ejemplo, si el contenido de la respuesta es abcd y seleccionas un tipo de concordancia de contenido de Contiene, la verificación de tiempo de actividad se realiza correctamente si los datos de respuesta contienen abcd. La verificación de tiempo de actividad falla si la respuesta no contiene abcd.
  • Contenido de la respuesta: ingresa una string (1024 bytes como máximo). En la API, este es el objeto ContentMatcher.

  • Ubicaciones: selecciona las regiones geográficas aplicables en donde se encuentra tu verificación para recibir solicitudes. La configuración predeterminada es Global con 6 verificadores. Debes tener al menos 3 verificadores. Hay 3 verificadores en la región Estados Unidos. Todas las demás regiones tienen 1 verificador.

  • Encabezados personalizados: proporciona encabezados personalizados y encriptados si es necesario. La encriptación oculta los valores de los encabezados en el formulario. Usa la encriptación para los encabezados relacionados con la autenticación que no quieres que vean otros miembros de tu equipo.

  • Tiempo de espera de la verificación de estado: especifica un tiempo de espera de 1 a 60 segundos. Una verificación de tiempo de actividad falla si las verificaciones de estado de más de una ubicación no obtienen una respuesta dentro del tiempo de espera configurado. Si solo un healthcheck no recibe una respuesta, entonces la verificación del tiempo de actividad no falla.

  • Autenticación: Proporciona un nombre de usuario y contraseña únicos. Estos valores se envían como un encabezado de autorización. Si estableces valores aquí, no establezcas un encabezado de Autorización por separado; Si estableces un encabezado de autorización, no establezcas valores aquí. Las contraseñas siempre están ocultas en el formulario. Este campo no está disponible para las verificaciones de TCP.

  • Validación del certificado SSL: selecciona la casilla de verificación Validar certificados SSL. Una verificación de tiempo de actividad falla si una URL tiene un certificado no válido. Las razones para un certificado no válido incluyen un certificado vencido, un certificado con una discrepancia de nombres de dominio o un certificado autofirmado. La validación del certificado SSL solo está disponible para las verificaciones de HTTPS en recursos de URL.

    Los certificados SSL que usan la extensión de acceso de información de autoridad (AIA) no son compatibles y fallan la secuencia de validación. Por lo general, el mensaje de error es "Respondió con error de protocolo de enlace SSL en 10,000 ms". Si tienes este tipo de certificado SSL, asegúrate de que la casilla de verificación Validar certificados SSL esté desactivada.

    Puedes usar la métrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires para crear una alerta que te notifique antes de que venza el certificado. Consulta Políticas de ejemplo: política de verificación del tiempo de actividad.

Identificadores para verificaciones de tiempo de actividad

Cuando se crea tu verificación de tiempo de actividad, Monitoring le asigna un identificador denominado ID de la verificación de tiempo de actividad. Este identificador está incorporado en el nombre del recurso para la nueva verificación de tiempo de actividad:

projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]

Puedes obtener este ID de la respuesta de una invocación a un método para crear o generar listas de verificaciones de tiempo de actividad. También puedes encontrar el ID de la verificación de tiempo de actividad en la ventana Detalles del tiempo de actividad en la sección titulada Configuración.

Verifica tu tiempo de actividad

Cuando creas una verificación de tiempo de actividad en Cloud Console, puedes probar la configuración antes de guardarla.

Comprueba que sea correcta

Una verificación de tiempo de actividad es correcta si dos condiciones son verdaderas:

  • El estado HTTP es Success.
  • La respuesta no tiene contenido obligatorio o, una búsqueda de la respuesta para el contenido obligatorio es correcto.

Verifica la falla

Las siguientes son algunas de las posibles causas de una falla en la verificación de tiempo de actividad:

  • Error de conexión: rechazado: si utilizas el tipo de conexión HTTP predeterminado, verifica que tengas instalado un servidor web que responda a las solicitudes HTTP. Esto puede suceder en una instancia nueva si no instalaste un servidor web. Consulta la Guía de inicio rápido para Compute Engine. Si usas un tipo de conexión HTTPS, es posible que debas realizar pasos de configuración adicionales. Con el fin de obtener información sobre problemas de firewall, consulta Cómo obtener direcciones IP para la verificación del tiempo de actividad.
  • Nombre o servicio no encontrado: el nombre de host puede ser incorrecto.
  • 403 Prohibido: el servicio muestra un código de error al verificador de tiempo de actividad. Por ejemplo, la configuración predeterminada de Apache Web Server muestra este código en Amazon Linux, pero aparece el código 200 (Success) en algunas otras versiones de Linux. Consulta el instructivo de LAMP para Amazon Linux o la documentación de tu servidor web.
  • 404 No encontrado: la ruta de acceso podría ser incorrecta.
  • 408 Tiempo de espera de solicitud o no hay respuesta: el número de puerto puede ser incorrecto, el servicio puede no estar ejecutándose, no se puede acceder al servicio o el tiempo de espera puede ser demasiado bajo. Verifica que tu firewall permita el tráfico de los servidores de tiempo de actividad. Consulta Cómo obtener direcciones IP para la verificación del tiempo de actividad. El límite de tiempo de espera se especifica en la parte Verificación de estado de Opciones avanzadas.

Ve una verificación de tiempo de actividad

Para ver una verificación de tiempo de actividad, sigue estos pasos:

Console

Para ver el estado detallado de una sola verificación de tiempo de actividad, sigue estos pasos:

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

  3. Para ver la ventana Detalles del tiempo de actividad (Uptime details), busca la verificación de tiempo de actividad que deseas ver y haz clic en el nombre de la verificación de tiempo de actividad.

    En la siguiente captura de pantalla, se muestran los detalles del tiempo de actividad de una verificación con el nombre "Mi tiempo de actividad":

    Panel de la verificación de tiempo de actividad de muestra.

    En la ventana Detalles del tiempo de actividad, se encuentra la siguiente información:

    • El intervalo de tiempo seleccionado. De forma predeterminada, el intervalo es de 1 hora.
    • El nombre de la verificación de tiempo de actividad. En la muestra, el nombre es Mi verificación de tiempo de actividad.
    • El porcentaje de tiempo de actividad y la latencia promedio. El valor Porcentaje de tiempo de actividad (Percent uptime) es un porcentaje calculado como (S/T)*100, en el que S es el número de respuestas correctas y T es el número total de respuestas de verificación de todas las ubicaciones. En las verificaciones de grupo, se calcula la suma de los valores de S y T de todos los miembros actuales del grupo.

      Por ejemplo, durante un período de 25 minutos, una verificación de tiempo de actividad con un período de un minuto que se ejecute desde todas las regiones obtendrá 25 solicitudes de cada una de las 6 ubicaciones, es decir, un total de 150 solicitudes. Si el panel informa un 83.3% de tiempo de actividad, entonces 125 de 150 solicitudes se completaron correctamente.

    • En los paneles Aprobado (Passed checks) y Latencia de la verificación de tiempo de actividad (Uptime check latency), se muestra gráficamente la cantidad de verificaciones aprobadas y la latencia de cada verificación como una función de tiempo.

    • En el panel Estado actual (Current status), se muestra el estado de las verificaciones más recientes. Un círculo verde con una marca de verificación junto a una región indica que la última ejecución de la verificación en esa región se realizó correctamente; un círculo rojo con una x indica falla.

    • En el panel Configuración (Configuration), se muestra la configuración de la verificación de tiempo de actividad. Estos datos se asignan cuando se crea la verificación de tiempo de actividad. El valor ID de la verificación (Check ID) corresponde al valor [UPTIME_CHECK_ID] en las llamadas a la API.

    • En el panel Políticas de alertas (Alert Policies), se incluye información sobre las políticas de alertas asociadas. En el panel de muestra, se configura una política de alertas.

C#

public static object GetUptimeCheckConfig(string configName)
{
    var client = UptimeCheckServiceClient.Create();
    UptimeCheckConfig config = client.GetUptimeCheckConfig(configName);
    if (config == null)
    {
        Console.Error.WriteLine(
            "No configuration found with the name {0}", configName);
        return -1;
    }
    Console.WriteLine("Name: {0}", config.Name);
    Console.WriteLine("Display Name: {0}", config.DisplayName);
    Console.WriteLine("Http Path: {0}", config.HttpCheck.Path);
    return 0;
}

Java

private static void getUptimeCheckConfig(String projectId, String checkName) throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    String fullCheckName = UptimeCheckConfigName.format(projectId, checkName);
    UptimeCheckConfig config = client.getUptimeCheckConfig(fullCheckName);
    if (config != null) {
      System.out.println(config.toString());
    } else {
      System.out.println(
          "No uptime check config found with name " + checkName + " in project " + projectId);
    }
  } catch (Exception e) {
    usage("Exception getting uptime check: " + e.toString());
    throw e;
  }
}

Go


// get is an example of getting an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func get(w io.Writer, resourceName string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.GetUptimeCheckConfigRequest{
		Name: resourceName,
	}
	config, err := client.GetUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("GetUptimeCheckConfig: %v", err)
	}
	fmt.Fprintf(w, "Config: %v", config)
	return config, nil
}

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const uptimeCheckConfigId = 'YOUR_UPTIME_CHECK_CONFIG_ID';

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.projectUptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Retrieving ${request.name}`);

// Retrieves an uptime check config
const [uptimeCheckConfig] = await client.getUptimeCheckConfig(request);
console.log(`ID: ${uptimeCheckConfig.name}`);
console.log(`Display Name: ${uptimeCheckConfig.displayName}`);
console.log('Resource: %j', uptimeCheckConfig.monitoredResource);
console.log('Period: %j', uptimeCheckConfig.period);
console.log('Timeout: %j', uptimeCheckConfig.timeout);
console.log(`Check type: ${uptimeCheckConfig.check_request_type}`);
console.log(
  'Check: %j',
  uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
);
console.log(
  `Content matchers: ${uptimeCheckConfig.contentMatchers
    .map(matcher => matcher.content)
    .join(', ')}`
);
console.log(`Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * get_uptime_check($projectId, $configName);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $configName
 */
function get_uptime_check($projectId, $configName)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $uptimeCheck = $uptimeCheckClient->getUptimeCheckConfig($configName);

    print('Retrieved an uptime check:' . PHP_EOL);
    print($uptimeCheck->serializeToJsonString() . PHP_EOL);
}

Python

def get_uptime_check_config(config_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    config = client.get_uptime_check_config(config_name)
    pprint.pprint(config)

Ruby

def get_uptime_check_config config_name
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  config = client.get_uptime_check_config name: config_name
  pp config.to_h
  config
end

Edita una verificación de tiempo de actividad

El protocolo de verificación de tiempo de actividad, el tipo de recurso y el recurso que se está supervisando no se pueden cambiar. Si deseas modificar estos campos, debes crear una verificación de tiempo de actividad con la configuración adecuada. Sin embargo, todos los demás campos de una verificación de tiempo de actividad se pueden modificar después de que se crea la verificación.

Para editar una política de alertas asociada con una verificación de tiempo de actividad, en el panel de navegación de Monitoring, haz clic en Alertas, selecciona la política que deseas editar y haz clic en Editar.

Para editar una verificación de tiempo de actividad, sigue estos pasos:

Console

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

  3. Busca la verificación de tiempo de actividad que deseas editar y, luego, realiza una de las siguientes acciones:

    • Haz clic en Más y selecciona Editar.
    • Ve los detalles de la verificación de tiempo de actividad y haz clic en Editar.
  4. Cambia los valores de los campos según sea necesario. No puedes modificar todos los campos. Si los valores de encabezado personalizados de una verificación están ocultos, no podrás hacerlos visibles.

  5. Para comprobar si la verificación funciona, haz clic en Probar. Si la prueba falla, consulta Verifica fallas para ver las posibles causas.

  6. Haz clic en Guardar.

API

Realiza una llamada al método projects.uptimeCheckConfigs.patch. Establece los parámetros en el método de la siguiente manera:

  • uptimeCheckConfig.name: obligatorio. Esto forma parte de la URL de REST. Es el nombre del recurso de la verificación de tiempo de actividad para editar:

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Puedes obtener el [UPTIME_CHECK_ID] de la respuesta de un método create o list. El ID no se muestra en Cloud Console.

  • updateMask: opcional. Este es un parámetro de búsqueda: ?updateMask=[FIELD_LIST]. [FIELD_LIST] es una lista de campos separados por comas en el objeto UptimeCheckConfig que se debe cambiar. Por ejemplo:

    "resource.type,httpCheck.path"
    
  • El cuerpo de la solicitud debe contener un UptimeCheckConfig con los valores de campo nuevos.

Si se configura updateMask, solo los campos enumerados en updateMask reemplazarán los campos correspondientes en la configuración existente. Si un campo tiene subcampos, y el campo aparece en la máscara, pero ninguno de sus subcampos aparece, entonces todos los subcampos de ese campo reemplazan los campos correspondientes.

Si updateMask no está establecido, la configuración en el cuerpo de la solicitud reemplaza toda la configuración existente.

El método patch muestra el objeto UptimeCheckConfig para la configuración modificada.

C#

public static object UpdateUptimeCheck(string configName,
    string newHttpPath, string newDisplayName)
{
    var client = UptimeCheckServiceClient.Create();
    var config = client.GetUptimeCheckConfig(configName);
    var fieldMask = new FieldMask();
    if (newDisplayName != null)
    {
        config.DisplayName = newDisplayName;
        fieldMask.Paths.Add("display_name");
    }
    if (newHttpPath != null)
    {
        config.HttpCheck.Path = newHttpPath;
        fieldMask.Paths.Add("http_check.path");
    }
    client.UpdateUptimeCheckConfig(config);
    return 0;
}

Java

private static void updateUptimeCheck(
    String projectId, String displayName, String hostName, String pathName) throws IOException {
  String fullCheckName = UptimeCheckConfigName.format(projectId, displayName);

  UpdateUptimeCheckConfigRequest request =
      UpdateUptimeCheckConfigRequest.newBuilder()
          .setUpdateMask(FieldMask.newBuilder().addPaths("http_check.path"))
          .setUptimeCheckConfig(
              UptimeCheckConfig.newBuilder()
                  .setName(fullCheckName)
                  .setMonitoredResource(
                      MonitoredResource.newBuilder()
                          .setType("uptime_url")
                          .putLabels("host", hostName))
                  .setHttpCheck(HttpCheck.newBuilder().setPath(pathName).setPort(80))
                  .setTimeout(Duration.newBuilder().setSeconds(10))
                  .setPeriod(Duration.newBuilder().setSeconds(300)))
          .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    UptimeCheckConfig config = client.updateUptimeCheckConfig(request);
    System.out.println("Uptime check updated: \n" + config.toString());
  } catch (Exception e) {
    usage("Exception updating uptime check: " + e.toString());
    throw e;
  }
}

Go


// update is an example of updating an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func update(w io.Writer, resourceName, displayName, httpCheckPath string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	getReq := &monitoringpb.GetUptimeCheckConfigRequest{
		Name: resourceName,
	}
	config, err := client.GetUptimeCheckConfig(ctx, getReq)
	if err != nil {
		return nil, fmt.Errorf("GetUptimeCheckConfig: %v", err)
	}
	config.DisplayName = displayName
	config.GetHttpCheck().Path = httpCheckPath
	req := &monitoringpb.UpdateUptimeCheckConfigRequest{
		UpdateMask: &field_mask.FieldMask{
			Paths: []string{"display_name", "http_check.path"},
		},
		UptimeCheckConfig: config,
	}
	config, err = client.UpdateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("UpdateUptimeCheckConfig: %v", err)
	}
	fmt.Fprintf(w, "Successfully updated %v", resourceName)
	return config, nil
}

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const uptimeCheckConfigId = 'YOUR_UPTIME_CHECK_CONFIG_ID';
// const displayName = 'A New Display Name';
// const path = '/some/path';

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.projectUptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Updating ${request.name} to ${displayName}`);

// Updates the display name and path on an uptime check config
request.uptimeCheckConfig = {
  name: request.name,
  displayName: displayName,
  httpCheck: {
    path: path,
  },
};

request.updateMask = {
  paths: ['display_name', 'http_check.path'],
};

const [response] = await client.updateUptimeCheckConfig(request);
console.log(`${response.name} config updated.`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;
use Google\Protobuf\FieldMask;

/**
 * Example:
 * ```
 * update_uptime_checks($projectId);
 * ```
 */
function update_uptime_checks($projectId, $configName, $newDisplayName = null, $newHttpCheckPath = null)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $uptimeCheck = $uptimeCheckClient->getUptimeCheckConfig($displayName);
    $fieldMask = new FieldMask();
    if ($newDisplayName) {
        $fieldMask->getPaths()[] = 'display_name';
        $uptimeCheck->setDisplayName($newDisplayName);
    }
    if ($newHttpCheckPath) {
        $fieldMask->getPaths()[] = 'http_check.path';
        $uptimeCheck->getHttpCheck()->setPath($newHttpCheckPath);
    }

    $uptimeCheckClient->updateUptimeCheckConfig($uptimeCheck, $fieldMask);

    print($uptimeCheck->serializeToString() . PHP_EOL);
}

Python

def update_uptime_check_config(
    config_name, new_display_name=None, new_http_check_path=None
):
    client = monitoring_v3.UptimeCheckServiceClient()
    config = client.get_uptime_check_config(config_name)
    field_mask = monitoring_v3.types.FieldMask()
    if new_display_name:
        field_mask.paths.append("display_name")
        config.display_name = new_display_name
    if new_http_check_path:
        field_mask.paths.append("http_check.path")
        config.http_check.path = new_http_check_path
    client.update_uptime_check_config(config, field_mask)

Ruby

def update_uptime_check_config config_name:         nil,
                               new_display_name:    nil,
                               new_http_check_path: nil
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  config = { name: config_name }
  field_mask = { paths: [] }
  unless new_display_name.to_s.empty?
    field_mask[:paths].push "display_name"
    config[:display_name] = new_display_name
  end
  unless new_http_check_path.to_s.empty?
    field_mask[:paths].push "http_check.path"
    config[:http_check] = { path: new_http_check_path }
  end
  client.update_uptime_check_config uptime_check_config: config,
                                    update_mask:         field_mask
end

Puede haber un retraso de hasta 5 minutos antes de que veas los resultados nuevos de la verificación de tiempo de actividad. Durante ese tiempo, los resultados de la verificación de tiempo de actividad anterior se muestran en los paneles y se usan para política de alertas.

Borra una verificación de tiempo de actividad

Si intentas borrar una verificación de tiempo de actividad con Cloud Console y existe una política de alertas que depende de la verificación de tiempo de actividad, la operación de eliminación fallará. Vuelve a intentar borrar la eliminación después de quitar la verificación de tiempo de actividad de todas las políticas de alertas que usan la verificación.

Si intentas borrar una verificación de tiempo de actividad con la API de Cloud Monitoring, la verificación de tiempo de actividad se borrará incluso si hay políticas de alertas que dependen de la verificación. No se genera ningún error. No se crea ningún incidente para la verificación faltante. Antes de borrar una verificación de tiempo de actividad, asegúrate de que no haya ninguna aplicación de alertas que dependa de esta verificación.

Para borrar una verificación de tiempo de actividad, sigue los pasos a continuación:

Console

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

  3. Busca la verificación de tiempo de actividad que deseas editar y, luego, realiza una de las siguientes acciones:

    • Haga clic en Más y seleccione Borrar.
    • Consulte los detalles de la verificación de tiempo de actividad y haga clic en Borrar

API

Realiza una llamada al método projects.uptimeCheckConfigs.delete. Completa el parámetro de la siguiente manera:

  • nombre: Obligatorio. Este es el nombre de recurso de la configuración de verificación de tiempo de actividad para borrar:

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Puedes obtener el [UPTIME_CHECK_ID] de la respuesta de un método create o list. El ID no se muestra en Cloud Console.

C#

public static object DeleteUptimeCheckConfig(string configName)
{
    var client = UptimeCheckServiceClient.Create();
    client.DeleteUptimeCheckConfig(configName);
    Console.WriteLine($"Deleted {configName}");
    return 0;
}

Java

private static void deleteUptimeCheckConfig(String projectId, String checkName)
    throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    client.deleteUptimeCheckConfig(UptimeCheckConfigName.format(projectId, checkName));
  } catch (Exception e) {
    usage("Exception deleting uptime check: " + e.toString());
    throw e;
  }
}

Go


// delete is an example of deleting an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func delete(w io.Writer, resourceName string) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.DeleteUptimeCheckConfigRequest{
		Name: resourceName,
	}
	if err := client.DeleteUptimeCheckConfig(ctx, req); err != nil {
		return fmt.Errorf("DeleteUptimeCheckConfig: %v", err)
	}
	fmt.Fprintf(w, "Successfully deleted %q", resourceName)
	return nil
}

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const uptimeCheckConfigId = 'YOUR_UPTIME_CHECK_CONFIG_ID';

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.projectUptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Deleting ${request.name}`);

// Delete an uptime check config
await client.deleteUptimeCheckConfig(request);
console.log(`${request.name} deleted.`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * delete_uptime_check($projectId, $configName);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $configName
 */
function delete_uptime_check($projectId, $configName)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $uptimeCheckClient->deleteUptimeCheckConfig($configName);

    printf('Deleted an uptime check: ' . $configName . PHP_EOL);
}

Python

# `config_name` is the `name` field of an UptimeCheckConfig.
# See https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.uptimeCheckConfigs#UptimeCheckConfig.
def delete_uptime_check_config(config_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    client.delete_uptime_check_config(config_name)
    print("Deleted ", config_name)

Ruby

def delete_uptime_check_config config_name
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  client.delete_uptime_check_config name: config_name
  puts "Deleted #{config_name}"
end

Qué sigue