Crear verificaciones de tiempo de actividad públicas

En este documento, se describe cómo crear una verificación de tiempo de actividad pública. Una verificación de tiempo de actividad pública puede emitir solicitudes desde varias ubicaciones en todo el mundo a URL disponibles de forma pública o recursos de Google Cloud para ver si el recurso responde. Si quieres 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:

• URL de verificación de tiempo de actividad
• Instancia de VM
• Aplicación de App Engine
• Servicio de Kubernetes
• Instancia de Amazon Elastic Compute Cloud (EC2)
• Balanceador de cargas de Amazon Elastic
• Revisión de Cloud Run

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

Acerca de las verificaciones de tiempo de actividad

Para HTTP y HTTPS, se siguen todos los redireccionamientos de URL, y la respuesta final que recibe la verificación de tiempo de actividad se usa para evaluar cualquier criterio de éxito. Para las verificaciones de HTTPS, el hora de vencimiento del certificado SSL se calcula en función del certificado de servidor que se recibió en la respuesta final.

Para que una verificación de tiempo de actividad tenga éxito, se deben cumplir las siguientes condiciones:

• El estado HTTP debe coincidir con los criterios que especifiques.
• Los datos de respuesta no tienen contenido obligatorio o el contenido obligatorio está presente.

Las verificaciones de tiempo de actividad no cargan elementos de la página ni ejecutan JavaScript. Además, la configuración predeterminada de una verificación de tiempo de actividad no incluye la autenticación.

Antes de comenzar

1. A fin de obtener los permisos que necesitas para crear verificaciones de tiempo de actividad, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

   • Editor de Monitoring (roles/monitoring.editor): Usuarios de la consola de Google Cloud
   • Editor de configuración de verificaciones de tiempo de actividad de Monitoring (roles/monitoring.uptimeCheckConfigEditor): usuarios de la API
   • Editor de política de alertas de Monitoring (roles/monitoring.alertPolicyEditor): Usuarios de la API
   • Editor de canal de notificaciones de Monitoring (roles/monitoring.notificationChannelEditor): usuarios de la API

   Si quieres obtener más información para otorgar roles, consulta Administra el acceso.

   Es posible que también puedas obtener los permisos necesarios mediante funciones personalizadas, o bien otras funciones predefinidas.

2. Verifica que el recurso que quieres verificar tenga un extremo público o esté detrás de un firewall configurable.

   Para todas las demás opciones de configuración, debes crear una verificación de tiempo de actividad privada. Para obtener más información, consulta Crea verificaciones de tiempo de actividad privadas.

3. Cuando tu recurso esté detrás de un firewall, configúralo para permitir el tráfico entrante de las direcciones IP de los servidores de verificación de tiempo de actividad. Para obtener más información, consulta Enumera las direcciones IP del servidor con verificación de tiempo de actividad.

4. Configura los canales de notificaciones que deseas usar para recibir alertas. Te recomendamos que crees varios tipos de canales de notificaciones. Para obtener más información, consulta Cómo crear y administrar canales de notificaciones.

5. Identifica al menos tres verificadores para tu verificación de tiempo de actividad. La región de verificación de tiempo de actividad USA incluye las regiones USA_OREGON, USA_IOWA y USA_VIRGINIA. Cada una de las regiones USA_* tiene un verificador, y USA incluye las tres. Las otras regiones de verificación de tiempo de actividad, EUROPE, SOUTH_AMERICA y ASIA_PACIFIC, tienen un verificador.

   Si seleccionas Global cuando usas la consola de Google Cloud 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.

Crea una verificación de tiempo de actividad

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

A fin de crear una verificación de tiempo de actividad para un balanceador de cargas externo que tenga configurado al menos un puerto TCP o HTTP/s, puedes seguir estas instrucciones. Una alternativa es ir a la página Detalles del servicio del servicio y, luego, hacer clic en Crear una verificación de tiempo de actividad. Cuando comienzas desde la página Detalles del servicio, los campos específicos del servicio se propagan previamente.

Nota: Todas las verificaciones de tiempo de actividad usan solicitudes HTTP GET o POST, o solicitudes TCP.

Consola

Para crear una verificación de tiempo de actividad con la consola de Google Cloud, sigue estos pasos:

1. En la consola de Google Cloud, selecciona Monitoring y, luego, selecciona  Verificaciones de tiempo de actividad o haz clic en el siguiente botón:

   Ir a Verificaciones de tiempo de actividad

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

   

3. Especifica el destino de la verificación de tiempo de actividad:

   1. Selecciona el protocolo. Puedes seleccionar HTTP, HTTPS o 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.
      Nota: No selecciones IP interna, ya que este tipo de recurso no puede ser un destino de una verificación de tiempo de actividad pública.

   3. Ingresa los campos específicos del protocolo:

      • Ingresa el puerto para las verificaciones de TCP.

      • Para las verificaciones de HTTP y HTTPS, puedes ingresar una ruta de acceso 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/.

        Por ejemplo, para emitir una verificación de tiempo de actividad al recurso de URL example.com/tester, establece el campo Nombre de host en example.com y el campo Ruta en /tester.

        Supongamos que implementaste un servidor en App Engine con un despachador que admite / y /hello. Para emitir la verificación de tiempo de actividad al controlador "/", deja el campo Path vacío. Para emitir la verificación de tiempo de actividad al controlador /hello, establece el valor del campo Path en /hello.

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

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

        Nota: Crea verificaciones en URLs directas cuando sea posible.

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

      • En los recursos Instancia y Elastic Load Balancer, completa el campo Se aplica a de la siguiente manera:

        • A fin de emitir una verificación de tiempo de actividad a una sola instancia o balanceador de cargas, selecciona Único y, luego, usa el menú para seleccionar la instancia o el balanceador de cargas específico.
        • Para emitir una verificación de tiempo de actividad a un grupo de Monitoring, selecciona Grupo y, luego, usa el menú para seleccionar el nombre del grupo.

   5. Opcional: Para establecer la frecuencia con la que se ejecuta la verificación de tiempo de actividad, usa el campo Verificar frecuencia.

   6. Opcional: Si quieres seleccionar regiones de verificador o configurar certificados SSL, autenticación, encabezados y puertos para las verificaciones de 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 tres verificadores. Hay un verificador en todas las regiones, excepto en Estados Unidos, que tiene tres verificadores. La configuración predeterminada, Global, incluye todas las regiones.
      • Pings de ICMP: Configura la verificación de tiempo de actividad para enviar hasta tres pings. Para obtener más información, consulta Cómo utilizar pings ICMP.
      • Método de solicitud: Para las verificaciones de HTTP, selecciona el método de solicitud.
      • Cuerpo: Para las verificaciones de HTTP POST, ingresa el cuerpo de la URL codificado. Debes realizar la codificación tú mismo. Para todas las demás verificaciones, deja este campo vacío.
      • Encabezado del host: Completa este campo para verificar los hosts virtuales. Este campo no está disponible para verificaciones 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 del encabezado del 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 validar el certificado SSL. Las verificaciones de tiempo de actividad fallan cuando una URL tiene un certificado no válido. A continuación, se indican algunos de los motivos por los que se puede obtener un certificado no válido:

        • Un certificado vencido
        • Un certificado autofirmado
        • Un certificado con un nombre de dominio que no coincide
        • Un certificado que use la extensión de acceso a la información de la autoridad (AIA).
        Nota: Una certificación SSL revocada no se considera válida.

        Para forzar una verificación de tiempo de actividad de HTTPS a fin de validar el certificado SSL, selecciona Validar certificados SSL.

        Para inhabilitar la validación de certificados SSL, desmarca Validar certificados SSL.

        Si tienes certificados SSL con extensiones AIA, debes inhabilitar la validación de certificados 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.

4. Haz clic en Continuar y configura los requisitos de respuesta. Todos los parámetros de configuración de esta sección tienen valores predeterminados:

   • Para cambiar el tiempo de espera de la verificación de tiempo de actividad, usa el campo Tiempo de espera de respuesta. Una verificación de tiempo de actividad falla cuando no se recibe ninguna respuesta de más de una ubicación dentro de este período.

     Nota: Si creas verificaciones de URLs de redireccionamiento, aumenta el Tiempo de espera de respuesta a 30 segundos o más.

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

     • Selecciona Response Content Match Type 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, supongamos que el contenido de la respuesta es abcd y el tipo de concordancia de contenido es Contiene. La verificación de tiempo de actividad solo es exitosa cuando los datos de respuesta contienen abcd. Para obtener más información, consulta Valida los datos de respuesta.
     • Ingresa el Contenido de la respuesta. El contenido de la respuesta debe ser una string de hasta 1,024 bytes. En la API, este campo es el objeto ContentMatcher.
     Nota: Habilita la coincidencia del contenido de la respuesta cuando selecciones el protocolo TCP.

   • Para evitar que se creen entradas de registro debido a verificaciones de tiempo de actividad, borra la opción Fallas de verificación de registros.

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

5. Haz clic en Continuar y configura las alertas y notificaciones.

   Si deseas recibir notificaciones cuando una verificación de tiempo de actividad falle, crea una política de alertas y configura los canales de notificaciones para esa política:

   1. Opcional: Actualiza el nombre de la política de alertas.
   2. Opcional: En el campo Duración, selecciona por cuánto tiempo deben fallar las verificaciones de tiempo de actividad antes de que se envíen las notificaciones. De forma predeterminada, las notificaciones se envían cuando al menos dos regiones informan fallas en las verificaciones de tiempo de actividad durante un período de al menos un minuto.

   3. En el cuadro Canales de notificaciones, haz clic en Menú , selecciona los canales que quieres agregar y, luego, haz clic en Aceptar.

      En el menú, los canales de notificaciones se agrupan alfabéticamente para cada tipo de canal.

   Si no deseas crear una política de alertas, asegúrate de que el texto del botón de activación sea No crear una alerta.

6. Haz clic en Continuar y completa la verificación de tiempo de actividad:

   1. Ingresa un título descriptivo para la verificación de tiempo de actividad.

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

      1. Haz clic en Mostrar etiquetas de usuario.
      2. En el campo Clave, ingresa un nombre para la etiqueta. Los nombres de las etiquetas deben comenzar con una letra minúscula y pueden contener letras en minúscula, números, guiones bajos y guiones. Por ejemplo, ingresa severity.
      3. En el campo Valor, ingresa un valor para tu etiqueta. Los valores de etiqueta 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.

   3. 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 Verifica fallas, corrige tu configuración y repite el paso de verificación.

   4. Haz clic en Crear. Si seleccionas Crear y no se propaga un campo obligatorio, aparecerá un mensaje de error.

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 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, customContentType opcionales 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#

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ver en GitHub Comentarios

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ver en GitHub Comentarios

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ver en GitHub Comentarios

// 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: %w", 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: %w", 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: %w", 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: %w", err)
	}
	fmt.Fprintf(w, "Successfully created POST uptime check %q\n", config.GetDisplayName())
	return config, nil
}

Node.js

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ver en GitHub Comentarios

// 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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ver en GitHub Comentarios

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ver en GitHub Comentarios

def create_uptime_check_config_get(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    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_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config

def create_uptime_check_config_post(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    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_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config

Ruby

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Ver en GitHub Comentarios

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".

Cómo usar pings ICMP

A fin de ayudarte a solucionar problemas de verificaciones de tiempo de actividad públicas con errores, puedes configurar tus verificaciones de tiempo de actividad para enviar hasta 3 pings ICMP durante la verificación. Los pings pueden ayudarte a distinguir entre fallas causadas, por ejemplo, por problemas de conectividad de red y tiempos de espera en tu aplicación.

De forma predeterminada, las verificaciones de tiempo de actividad no envían pings. Cada ping agrega latencia a la verificación de tiempo de actividad. Las verificaciones de tiempo de actividad privadas no pueden enviar pings.

Cuando falla una verificación de tiempo de actividad pública, los resultados de los pings se escriben en los registros de Cloud Logging. Si el ping falla, los siguientes campos se agregan al campo httpRequest en la entrada de registro:

• rtt_usec: Tiempo de ida y vuelta para cada solicitud de ping no exitosa.
• unreachable_count: La cantidad de solicitudes de ping que mostraron el código de estado ICMP_DEST_UNREACH.
• no_answer_count: Es la cantidad de solicitudes de ping que agotaron el tiempo de espera y no mostraron ninguna respuesta.

Los resultados de los pings de las verificaciones de tiempo de actividad correctas no se registran.

Configurar pings

Cada configuración de verificación de tiempo de actividad incluye un objeto HttpCheck o un objeto TcpCheck. Ambos objetos incluyen un campo pingConfig. Usa este campo para especificar la cantidad de pings ICMP que se deben incluir con cada verificación, hasta 3. De forma predeterminada, no se envían pings.

Para configurar pings, realiza una de las siguientes acciones:

• Cuando uses la consola de Google Cloud, expande Más opciones de destino y, luego, ingresa un valor en el campo Pings de ICMP.

• Cuando uses la API de Cloud Monitoring, usa el objeto PingConfig, que tiene la siguiente estructura:

  {
    "pingsCount": integer
  }
  

  Si quieres obtener más información sobre el uso de la API de Monitoring para la configuración de la verificación de tiempo de actividad, consulta Crea una verificación de tiempo de actividad: API o Edita una verificación de tiempo de actividad: API.

Verifica tu tiempo de actividad

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

Verificaciones exitosas

Una verificación de tiempo de actividad es correcta cuando se cumplen las siguientes condiciones:

• El estado HTTP coincide con los criterios que seleccionaste.
• 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 del 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. Puede ocurrir un error de conexión 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. Para problemas de firewall, consulta Enumera las direcciones IP del servidor con verificación de 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. Comprueba que tu firewall permita el tráfico de los servidores de tiempo de actividad. Consulta Enumerar las direcciones IP de los servidores de verificación de tiempo de actividad. El límite de tiempo de espera se especifica como parte de las opciones de Validación de respuesta.

Si tu verificación de tiempo de actividad está configurada para enviar pings, los resultados de pings de las verificaciones de tiempo de actividad con errores se escriben en Cloud Logging. Para obtener más información, consulta Cómo usar pings ICMP.

¿Qué sigue?

• Administra verificaciones de tiempo de actividad
• Crea alertas para las verificaciones de tiempo de actividad
• Enumera las direcciones IP del servidor para la verificación de tiempo de actividad
• Gráfico de las métricas de verificación de tiempo de actividad
• Precios y límites