Crea verificaciones de tiempo de actividad públicas

En este documento, se describe cómo crear una verificación pública de tiempo de actividad. Una verificación de tiempo de actividad pública puede emitir solicitudes de varias ubicaciones en todo el mundo a URL o recursos de Google Cloud disponibles de forma pública para ver si el recurso responde. Para obtener información sobre cómo crear verificaciones de tiempo de actividad para redes privadas, consulta Crea verificaciones de tiempo de actividad privadas.

Las verificaciones de tiempo de actividad públicas pueden determinar la disponibilidad de los siguientes recursos supervisados:

Para obtener vínculos a información sobre cómo administrar y supervisar tus verificaciones de tiempo de actividad, consulta la sección Pasos siguientes de este documento.

Antes de comenzar

  • Los firewalls que protegen tu servicio afectan el uso de las verificaciones de tiempo de actividad.

  • 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, se siguen todos los redireccionamientos de URL y se usa la respuesta final que recibe la verificación de tiempo de actividad para evaluar los criterios de éxito. Para las verificaciones de HTTPS, el tiempo de vencimiento del certificado SSL se calcula en función del certificado del servidor que se recibió en la respuesta final.

    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.
  • Cuando creas una verificación de tiempo de actividad, debes especificar al menos tres verificadores.

    La región de verificación de tiempo de actividad USA tiene tres verificadores. Las regiones de verificación de tiempo de actividad EUROPE, SOUTH_AMERICA y ASIA_PACIFIC tienen un verificador.

    Si seleccionas Global cuando usas Google Cloud Console o REGION_UNSPECIFIED cuando usas la API, las verificaciones de tiempo de actividad se emiten desde todas las regiones de verificación de tiempo de actividad.

Cree una verificación de tiempo de actividad

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

Console

Para crear una verificación de tiempo de actividad mediante Google Cloud Console, haz lo siguiente:

  1. En la consola, selecciona Monitoring o haz clic en el siguiente botón:
    Ir a Monitoring
  2. En el panel de navegación, selecciona Verificaciones de tiempo de actividad.

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

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

  4. Ingrese un título descriptivo para la verificación de tiempo de actividad.

  5. Opcional: Para agregar etiquetas definidas por el usuario a tu verificación de tiempo de actividad, haz lo siguiente:

    1. Haz clic en Más opciones de metadatos.
    2. Haz clic en Clave y, luego, ingresa un nombre para la etiqueta. Los nombres de las etiquetas deben comenzar con una letra minúscula y pueden contener letras minúsculas, números, guiones bajos y guiones. Por ejemplo, ingresa severity.
    3. Haga clic en Valor y, luego, ingrese un valor para su etiqueta. Los valores de las etiquetas pueden contener letras minúsculas, números, guiones bajos y guiones. Por ejemplo, ingresa critical.
    4. Para cada etiqueta adicional, haz clic en Agregar etiqueta de usuario y, luego, ingresa la clave y el valor de la etiqueta.
  6. Haga clic en Siguiente y especifique el destino de la verificación de tiempo de actividad:

    1. Selecciona el protocolo. Tienes las opciones de 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.
      • Servicio LoadBalancer de Kubernetes: servicio de Kubernetes de tipo LoadBalancer.
      • Instancia: instancias de Compute Engine o AWS EC2.
      • App Engine: Aplicaciones de App Engine (módulos).
      • Elastic Load Balancer: Balanceador de cargas AWS.
    3. Ingresa los campos específicos del protocolo:

      • Ingresa el puerto para las verificaciones de TCP.

      • 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 recursos de instancias y 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 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 de acceso 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.

      • Para los recursos de servicio LoadBalancer de Kubernetes, ingresa el nombre del servicio en el campo Servicio de Kubernetes.

      • 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. Opcional: Configura la frecuencia con la que se ejecuta la verificación de tiempo de actividad mediante el campo Verificar frecuencia.

    6. Opcional: Si quieres configurar regiones del 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 las verificaciones de tiempo de actividad son 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.
      • Request Method: Para las verificaciones HTTP, selecciona el método de solicitud.
      • Cuerpo: Para las verificaciones de HTTP POST, ingresa el cuerpo codificado en URL; tú mismo debes realizar la codificación. Para todas las demás verificaciones, deja este campo vacío.
      • 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 encríptalos 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 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 autofirmado, un certificado con una discrepancia de nombres de dominio 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 a la información de la autoridad (AIA), debes inhabilitar la validación del certificado SSL. Estos tipos de certificados no son compatibles y fallan en 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 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 Siguiente.

  7. Configura los requisitos de respuesta:

    • Configura un tiempo de espera para la verificación de tiempo de actividad mediante el campo Tiempo de espera de respuesta (opcional). Una verificación de tiempo de actividad falla si no se recibe respuesta de más de una ubicación dentro de este período.

    • Opcional: Para configurar la verificación de tiempo de actividad a fin de que coincida el contenido, asegúrate de que la etiqueta de activación sea La coincidencia de contenido está habilitada:

      • Seleccione 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 que se muestran. Por ejemplo, si el contenido de la respuesta es abcd y el tipo de coincidencia del contenido es 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. Para obtener más información, consulta Valida los datos de respuesta.
      • 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.
    • Para evitar entradas de registro debido a verificaciones de tiempo de actividad, borra Fallas de verificación de registro (opcional).

    • Para las verificaciones de tiempo de actividad HTTP, configura los códigos de respuesta aceptables. De forma predeterminada, las verificaciones de tiempo de actividad HTTP marcan cualquier respuesta 2xx como respuesta correcta.

    • Haga clic en Siguiente.

  8. Crear una política de alertas. Cuando una política de alertas supervisa tu verificación de tiempo de actividad, si el tiempo de actividad falla, se crea un incidente y se envía una notificación a todos los canales de notificaciones conectados a la política. Por ejemplo, si agregas una dirección de correo electrónico a la política, se enviará un correo electrónico a esa dirección. Puedes crear la política de alertas en este paso o una política de alertas después de que se crea la verificación.

    Te recomendamos que crees una política de alertas para la verificación de tiempo de actividad. Sin embargo, para omitir este paso, asegúrate de que el texto del botón de activación sea No crear una alerta. Haz clic en el botón para cambiar el estado del botón de activació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 para activar o desactivar sea Crear una alerta. Haz clic en el botón si es necesario.

    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, en el cuadro de texto etiquetado Canales de notificaciones, haz clic en Menú . Selecciona los canales que quieres agregar y haz clic en Aceptar. Los canales de notificaciones se agrupan alfabéticamente por cada tipo de canal.

      Si el canal de notificaciones que deseas agregar a la política de alertas no aparece en la lista, 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. Para obtener más información, consulta Canales de notificaciones.

    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 (opcional). De forma predeterminada, la política de alertas está configurada para crear un incidente si al menos 2 regiones informan fallas de verificación de tiempo de actividad durante un minuto.

    Consulta Administra políticas si deseas obtener información para 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 que esperabas, consulta Verifica fallas, corrige tu configuración y repite el paso de verificación.

  10. Haga clic en Crear. Se muestra un mensaje de error cuando guardas una verificación de tiempo de actividad y un campo obligatorio no está propagado. Después de guardar los cambios, se mostrará el cuadro de diálogo Verificación de tiempo de actividad creada.

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 de UptimeCheckConfig para la verificación de tiempo de actividad nueva. En esta página, se proporciona información sobre solo 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 este campo se omite o se establece en 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 se espera, 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.getName());
  } 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.UptimeCheckConfig()
    config.display_name = display_name or "New GET uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"}
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.GET,
        "path": "/",
        "port": 80
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(request={"parent": project_name, "uptime_check_config": 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.UptimeCheckConfig()
    config.display_name = display_name or "New POST uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"}
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.POST,
        "content_type": monitoring_v3.UptimeCheckConfig.HttpCheck.ContentType.URL_ENCODED,
        "body": "foo=bar".encode("utf-8"),
        "path": "/",
        "port": 80
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(request={"parent": project_name, "uptime_check_config": 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 la verificación de tiempo de actividad informa el estado como "sin datos disponibles".

Verifica tu tiempo de actividad

Cuando creas una verificación de tiempo de actividad en la consola, puedes probar la configuración antes de guardar.

Verificaciones exitosas

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.

Verificaciones fallidas

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. Un error de conexión puede ocurrir 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, el servicio puede ser inaccesible 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 como parte de las opciones de Validación de respuesta.

¿Qué sigue?