Crea verificaciones de tiempo de actividad públicas

Console

Para crear una verificación de tiempo de actividad con la consola de Google Cloud, haz lo siguiente:

1. En la consola de Google Cloud, ve a la página  Verificaciones de tiempo de actividad:

   Ve a Verificaciones de tiempo de actividad

   Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Monitoring.

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 LoadBalancer el tipo de letra.
      • 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, puedes 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/.

        Por ejemplo, para emitir una verificación de tiempo de actividad en el recurso de URL example.com/tester, establece el campo Nombre de host en example.com y el campo Ruta de acceso 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 Ruta de acceso vacío. Para emitir la verificación de tiempo de actividad al controlador /hello, establece el valor del campo Ruta de acceso 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.

      • 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 Elastic Load Balancer y Instancia, completa el campo Aplica a de la siguiente manera:

        • Para emitir una verificación de tiempo de actividad a una única instancia o balanceador de cargas, selecciona Single y, luego, usa 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 para seleccionar el nombre del grupo.

   5. Opcional: Para configurar la frecuencia con la que se ejecuta la verificación de tiempo de actividad, usa el Campo Comprueba la frecuencia.

   6. Opcional: Para seleccionar regiones del verificador o configurar SSL certificados, autenticación, encabezados y puertos para HTTP y HTTPS haz clic en More target options:

      • 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 ICMP: Configura la verificación de tiempo de actividad para que envíe hasta tres pings. Para obtener más información, consulta Usa pings de ICMP.
      • Método de solicitud: Para las verificaciones HTTP, selecciona el método de solicitud.
      • Cuerpo: Para las verificaciones POST de HTTP, ingresa el cuerpo codificado de URL. tú debes codificar por tu cuenta. 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: Estos valores se envían como un encabezado de autorización. Este campo no está disponible para verificaciones TCP.

        Selecciona alguna de las siguientes opciones:

        • Autenticación básica: Proporciona un nombre de usuario y contraseña únicos. Las contraseñas siempre están ocultas en el formulario.
        • Autenticación de agente de servicio: Cuando se habilita, se genera un token de identidad para el agente de servicio de supervisión. Esta opción solo está disponible para verificaciones HTTPS.

      • Validación del certificado SSL: si seleccionaste HTTPS para una URL. recurso, entonces, de forma predeterminada, el servicio intentará conectarse mediante HTTPS y valida el certificado SSL. Las verificaciones de tiempo de actividad fallan cuando una URL tiene un certificado no válido. Algunos de los motivos para tener un certificado no válido son los siguientes:

        • Un certificado vencido
        • Un certificado autofirmado
        • Un certificado con una discrepancia de nombres de dominio
        • Un certificado que use el acceso a la información de la autoridad (AIA) .

        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 del certificado SSL, borra Valida certificados SSL.

        Si tienes certificados SSL con extensiones de 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 política de alertas que te notifique que el certificado venza. 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 respuesta de más de una ubicación en este período.

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

     • Selecciona el Tipo de coincidencia 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, 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 se realiza correctamente 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 cadena no debe superar los 1,024 bytes. En la API, este campo es el Objeto ContentMatcher.

   • Para evitar que se creen entradas de registro debido a verificaciones de tiempo de actividad, Borra Errores de verificación de registros.

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

5. Haz clic en Continuar y configura las notificaciones.

   Para recibir una notificación cuando falle una verificación de tiempo de actividad, crea un política de alertas y configurar 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 ejecutarse las verificaciones de tiempo de actividad. debe fallar antes de que se envíen las notificaciones. De forma predeterminada, las notificaciones se se envían cuando al menos dos regiones informan errores en las verificaciones de tiempo de actividad de un de al menos un minuto.

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

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

   Si no quieres crear una política de alertas, asegúrate que el texto del botón de activación sea Do not create an alert.

6. Haz clic en Continuar y completa la verificación del 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 la verificación de tiempo de actividad, haz lo siguiente:

      1. Haz clic en expand_more 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 minúsculas, números, guiones bajos y guiones. Por ejemplo, ingresa severity.
      3. En el campo Valor, ingresa un valor para tu etiqueta. Valores de etiquetas puede 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 que esperabas, consulta Verifica fallas. corregir tu configuración y, luego, repetir el paso de verificación.

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

gcloud

Para crear la verificación de tiempo de actividad, ejecuta el comando gcloud monitoring uptime create:

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

Antes de ejecutar el comando anterior, haz lo siguiente:

• Reemplaza DISPLAY_NAME por el nombre de tu verificación de tiempo de actividad.

• Configura REQUIRED_FLAGS para especificar el recurso que sondea el la verificación de tiempo de actividad. Por ejemplo, el siguiente comando crea una verificación de tiempo de actividad que prueba la URL EXAMPLE.com para un proyecto en particular:

  gcloud monitoring uptime create DISPLAY_NAME \
  --resource-labels=host=EXAMPLE.com,project_id=PROJECT_ID \
  --resource-type=uptime-url
  

  El comando anterior especifica los valores para cada etiqueta que requiere la tipo de recurso uptime-url.

• Configura las marcas OPTIONAL_FLAGS para anular el valor predeterminado de salida. Por ejemplo, debes establecer la marca --protocol cuando el protocolo no sea http.

API

Para crear una verificación de tiempo de actividad, llama al 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 quieres configurar una solicitud POST, completa el contentType, opcional customContentType 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#

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.

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.

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.

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

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

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

/**
 * 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')
{
    $projectName = 'projects/' . $projectId;
    $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);
    $createUptimeCheckConfigRequest = (new CreateUptimeCheckConfigRequest())
        ->setParent($projectName)
        ->setUptimeCheckConfig($uptimeCheckConfig);

    $uptimeCheckConfig = $uptimeCheckClient->createUptimeCheckConfig($createUptimeCheckConfigRequest);

    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.

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.

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

Terraform

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform. Para obtener más información, consulta la documentación de referencia del proveedor de Terraform.

Para crear una verificación de tiempo de actividad y una política de alertas para supervisar esa verificación, haz lo siguiente:

1. Edita el archivo de configuración de Terraform y agrega un recurso google_monitoring_uptime_check_config y, luego, aplica el archivo de configuración.

   En el siguiente ejemplo, se ilustra una configuración que verifica una URL pública:

   resource "google_monitoring_uptime_check_config" "example" {
       display_name = "example"
       timeout      = "60s"
   
       http_check {
           port = "80"
           request_method = "GET"
       }
   
       monitored_resource {
           type = "uptime_url"
           labels = {
               project_id = "PROJECT_ID"
               host="EXAMPLE.com"
           }
       }
   
       checker_type = "STATIC_IP_CHECKERS"
   }
   

2. Opcional: Crea un canal de notificaciones y una política de alertas:

   En los siguientes pasos, se usa la consola de Google Cloud para crear el canal de notificaciones y la política de alertas. Este enfoque garantiza que la política de alertas solo supervise los datos generados por la verificación de tiempo de actividad.

   1. Para crear un canal de notificaciones, sigue estos pasos:

      1. En la consola de Google Cloud, ve a la página notifications Alertas.

         Ir a las Alertas

         Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Monitoring.

      2. Selecciona Administrar canales de notificaciones.
      3. Ve al tipo de canal que quieres agregar, haz clic en Agregar y y, luego, completarás el cuadro de diálogo.

   2. Para crear una política de alertas, sigue estos pasos:

      1. En la consola de Google Cloud, ve a la página  Verificaciones de tiempo de actividad:

         Ve a Verificaciones de tiempo de actividad

         Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es Monitoring.

      2. Ubica tu verificación de tiempo de actividad y selecciona more_vert Más. y, luego, selecciona Agregar política de alertas.
      3. En el diálogo, ve a la sección Notificaciones y nombre, expande Canales de notificaciones y realiza tus selecciones.
      4. Asigna un nombre a la política de alertas y, luego, haz clic en Crear política.

   Para crear una política de alertas, agrega un recurso google_monitoring_alert_policy a tu archivo de configuración y aplica la configuración nueva.