Administra verificaciones de tiempo de actividad

Stackdriver puede verificar la disponibilidad de tu servicio si accedes a él desde ubicaciones en todo el mundo. Puedes usar los resultados de estas verificaciones de tiempo de actividad en tus políticas de alertas, o puedes supervisar directamente los resultados en los paneles Monitoring de verificación de tiempo de actividad.

En esta página, se te muestra cómo hacer lo siguiente:

  • Crea una nueva verificación de tiempo de actividad.
  • Enumera tus verificaciones de tiempo de actividad existentes.
  • Edita una verificación de tiempo de actividad
  • Borra una verificación de tiempo de actividad

Para ver el estado de tus verificaciones de tiempo de actividad, o bien obtener una lista de las direcciones IP que podrían usarse para realizar las verificaciones de tiempo de actividad, consulta Obtén direcciones IP. Para determinar el estado de tus verificaciones de tiempo de actividad mediante el uso de la API, supervisa la métrica monitoring.googleapis.com/uptime_check/check_passed. Para más detalles consulta Lista de métricas GCP.

Antes de comenzar

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

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

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

    Para que sea correcto, se deben cumplir dos condiciones:

    • El estado HTTP es Success.
    • Los datos no tienen contenido requerido o el contenido obligatorio está presente. El contenido obligatorio se especifica con las Opciones avanzadas.

Crea verificaciones de tiempo de actividad

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

Consola

  1. En la consola de Stackdriver Monitoring, ve a Verificaciones de tiempo de actividad > Descripción general de verificaciones de tiempo de actividad:

    Ir a descripción general de verificaciones de tiempo de actividad

  2. En la esquina superior derecha, haz clic en Agregar verificaciones de tiempo de actividad.

  3. En la ventana verificación de tiempo de actividad nueva, completa los campos para la verificación, como se describe en Opciones básicas en esta página.

    Crea una verificación de tiempo de actividad

  4. Opcionalmente, para acceder a la configuración de puertos, encabezados personalizados y autenticación, haz clic en Opciones avanzadas. Para más detalles, consulta Opciones avanzadas en esta página.

  5. Para ver el resultado de tu verificación de tiempo de actividad, haz clic en Prueba. Si el resultado no es el que esperabas, consulta la sección Verifica fallas a continuación, corrige tu configuración y repite la prueba.

  6. Haz clic en Guardar. No puedes guardar una verificación de tiempo de actividad si falta algún campo requerido. Si el botón Guardar está inhabilitado, verifica los valores faltantes. Debes ingresar un valor en el campo Nombre de host.

API

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

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

    projects/[PROJECT_ID]
    
  • El cuerpo de la solicitud debe contener un objeto UptimeCheckConfig para la verificación de tiempo de actividad nueva. Los campos en el objeto se explican en las Opciones básicas y en la sección Opciones avanzadas en esta página.

    Deja el campo name del objeto de configuración en blanco, ya que se establece en el objeto de configuración mostrado.

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

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

C#

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

Java

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

Go

// create creates an example uptime check.
func create(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 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{
					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: %v", err)
	}
	fmt.Fprintf(w, "Successfully created 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(project_name, host_name=None,
                               display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or 'New uptime check'
    config.monitored_resource.type = 'uptime_url'
    config.monitored_resource.labels.update(
        {'host': host_name or 'example.com'})
    config.http_check.path = '/'
    config.http_check.port = 80
    config.timeout.seconds = 10
    config.period.seconds = 300

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

Ruby

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

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  project_name = Google::Cloud::Monitoring::V3::UptimeCheckServiceClient.project_path(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 }
  }
  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  new_config = client.create_uptime_check_config(project_name, config)
  puts new_config.name
  return new_config
end

Puede haber un retraso de hasta 25 minutos antes de que los resultados de la verificación del tiempo de actividad comiencen a fluir hacia Monitoring. Durante ese tiempo, el panel de verificación de tiempo de actividad informa el estado como "sin datos disponibles".

Opciones básicas

Para crear una verificación de tiempo de actividad nueva, especifica valores de la configuración de la verificación de tiempo de actividad. Cuando crees la verificación de tiempo de actividad en la consola Stackdriver Monitoring, rellena un formulario. Cuando crees la verificación del tiempo de actividad en la API, suministras los parámetros correspondientes a un objeto UptimeCheckConfig.

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

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

    Si seleccionas HTTPS, el servicio intenta conectarse a través de HTTPS, pero no valida el certificado SSL. Por ejemplo, los certificados caducados o autofirmados no harán que la verificación falle.

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

    • App Engine: Aplicaciones de App Engine (módulos).
    • Elastic Load Balancer: Balanceador de cargas AWS.
    • Instancia: Instancias de Compute Engine o AWS EC2. En la API, esto se divide en gce_instance y aws_ec2_instance.
    • URL: Cualquier dirección IPv4 o nombre de host. La ruta de acceso y el puerto se ingresan por separado.
  4. Completa la información de conexión, según tu tipo de verificación y tipo de recurso:

    • Se aplica a (App Engine, ELB, or Instancia): Puedes aplicar tu verificación de tiempo de actividad a un solo recurso o a un grupo de recursos, como Todas las instancias. Si eliges un solo recurso, elige uno de tus recursos existentes que figuran en el menú. Si usas la API, completa el recurso supervisado con las etiquetas de recursos requeridas, como se describe en la Lista de recursos Supervisados.

    • Módulo (App Engine): Especifica tu módulo de aplicación.

    • Nombre de host (todos excepto App Engine): Especifica el nombre de host de tu servicio. Por ejemplo, ingresa example.com.

    • Ruta de acceso (HTTP, HTTPS): Ingresa una ruta dentro de tu host o recurso o usa la ruta de acceso predeterminada. Por ejemplo, para sondear example.com, deja este campo en blanco. Para sondear example.com/tester, ingresa /tester. No incluyas el prefijo example.com. En la API, deja este campo en blanco para usar el valor predeterminado, /.

    • Puerto (HTTP, HTTPS, TCP): Elige un puerto para la conexión.

      • Para las verificaciones de HTTP y HTTPS, esta opción se encuentra en Opciones avanzadas.
      • En la API, deja este campo en blanco para usar el valor predeterminado: 80 en las verificaciones de TCP o HTTP y 443 en las verificaciones de HTTPS.
    • El contenido de la respuesta contiene el texto (HTTP, HTTPS, TCP): Rellena una string (máx. 1024 bytes) cuya presencia en la respuesta de verificación indica que es correcto. La verificación fallará si la string no aparece en ninguna parte de la respuesta.

      • Para la verificación de HTTP y HTTPS, este campo aparece en Opciones avanzadas.
      • En la API, este es el objeto ContentMatcher.
  5. Verifica cada: 1, 5, 10, o 15 minutos. Por ejemplo, si seleccionas 5 minutos, cada ubicación geográfica intenta alcanzar tu servicio una vez en cada período de 5 minutos. Mediante el uso las 6 ubicaciones predeterminadas y verificando cada 5 minutos, tu servicio ve un promedio de 1.2 solicitudes por minuto. Si revisas cada 1 minuto, tu servicio ve un promedio de 6 solicitudes por minuto.

Opciones avanzadas

La sección de Opciones avanzadas se aplica a los tipos de verificación HTTP, HTTPS y TCP.

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

Para que sea correcto, se deben cumplir dos condiciones:

  1. El estado HTTP es Success.
  2. Los datos no tienen contenido requerido o el contenido obligatorio está presente. El contenido obligatorio se especifica con las Opciones avanzadas.

Estas configuraciones son opcionales y varían según el tipo de verificación:

  • Encabezado de host HTTP: Rellena este campo para verificar los hosts virtuales. Este campo no está disponible para verificaciones TCP.

  • Puerto: Especifica un número de puerto. Para las verificaciones de TCP, este campo aparece en Opciones básicas.

  • El contenido de la respuesta contiene el texto: Rellena una string (máx. 1024 bytes) cuya presencia en la respuesta de verificación sea una condición correcta. Para las comprobaciones de TCP, este campo aparece en Opciones básicas.

  • Ubicaciones: Selecciona las regiones geográficas aplicables en donde se encuentra tu verificación para recibir solicitudes. Debe seleccionar suficientes regiones para tener al menos tres ubicaciones activas. Cuando crees una verificación, las ubicaciones en cada región se enumeran debajo del nombre de la región. Las ubicaciones nuevas de los verificadores en las regiones seleccionadas envían solicitudes automáticamente a los destinos configurados. Para enviar siempre solicitudes desde todas las ubicaciones disponibles, selecciona Global. Para enviar solicitudes desde todas las ubicaciones en regiones existentes, pero no a ubicaciones nuevas en regiones nuevas, selecciona todas las regiones existentes, pero no selecciones Global.

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

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

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

Verifica tu tiempo de actividad

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

Comprueba que sea correcta

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

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

Verifica el fallo

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 usas el tipo de configuración HTTP predeterminado, verifica que tengas un servidor web instalado que responda a las solicitudes HTTP. Esto puede suceder en una instancia nueva si no has instalado un servidor web; vea el Inicio rápido para Compute Engine. Si usas una conexión de tipo HTTPS, es posible que debas realizar pasos de configuración adicionales. Para problemas de firewall, consulta Obtén dirección IP.
  • 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 Obtén direcciones IP. El límite de tiempo de espera se especifica en la parte Healthcheck de Opciones avanzadas.

Crea una política de alertas

Si deseas recibir notificaciones de fallas en el tiempo de actividad, crea una política de alertas para tu verificación de tiempo de actividad nueva. Para obtener más detalles, consulta Alerta de verificaciones de tiempo de actividad.

Enumera verificaciones de tiempo de actividad

Para enumerar tus verificaciones de tiempo de actividad actuales, haz lo siguiente:

Consola

  1. Para ver una lista de tus verificaciones de tiempo de actividad, en la consola de Stackdriver Monitoring, ve a Verificaciones de tiempo de actividad > Descripción general de verificaciones de tiempo de actividad. Tus verificaciones de tiempo de actividad pueden aparecer en varias páginas.

    Ir a descripción general de verificaciones de tiempo de actividad

  2. Para filtrar la lista de verificaciones, realiza una de las siguientes acciones:

    • Ingresa texto en el campo Filtrar para limitar la lista a verificaciones con ese texto en tus títulos.
    • Usa el botón a la izquierda del campo Filtro para filtrar los miembros de un grupo específico.

    Haz clic en una verificación de tiempo de actividad para mostrar más detalles sobre la verificación.

API

Para obtener una lista de tus configuraciones de tiempo de actividad, llama al método projects.uptimeCheckConfigs.list. Especifica los siguientes parámetros:

  • parent: El proyecto del que se va a verificar el tiempo de actividad. El formato es:

    projects/[PROJECT_ID]
    

Para obtener una verificación de tiempo de actividad especifica, llama al método projects.uptimeCheckConfigs.get. Especifica el siguiente parámetro:

  • nombre: El nombre completo de la configuración de verificación de tiempo de actividad.

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Puedes obtener [UPTIME_CHECK_ID] de la respuesta de un método create o list. El ID no se muestra en la consola de Stackdriver Monitoring.

C#

public static object ListUptimeCheckConfigs(string projectId)
{
    var client = UptimeCheckServiceClient.Create();
    var configs = client.ListUptimeCheckConfigs(
        new ProjectName(projectId).ToString());
    foreach (UptimeCheckConfig config in configs)
    {
        Console.WriteLine(config.Name);
    }
    return 0;
}

Java

private static void listUptimeChecks(String projectId) throws IOException {
  ListUptimeCheckConfigsRequest request = ListUptimeCheckConfigsRequest
      .newBuilder()
      .setParent(ProjectName.format(projectId))
      .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    ListUptimeCheckConfigsPagedResponse response = client.listUptimeCheckConfigs(request);
    for (UptimeCheckConfig config : response.iterateAll()) {
      System.out.println(config.getDisplayName());
    }
  } catch (Exception e) {
    usage("Exception listing uptime checks: " + e.toString());
    throw e;
  }
}

Go

// list is an example of listing the uptime checks in projectID.
func list(w io.Writer, projectID string) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.ListUptimeCheckConfigsRequest{
		Parent: "projects/" + projectID,
	}
	it := client.ListUptimeCheckConfigs(ctx, req)
	for {
		config, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListUptimeCheckConfigs: %v", err)
		}
		fmt.Fprintln(w, config)
	}
	fmt.Fprintln(w, "Done listing uptime checks")
	return nil
}

Node.js

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

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

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

const request = {
  parent: client.projectPath(projectId),
};

// Retrieves an uptime check config
const [uptimeCheckConfigs] = await client.listUptimeCheckConfigs(request);

uptimeCheckConfigs.forEach(uptimeCheckConfig => {
  console.log(`ID: ${uptimeCheckConfig.name}`);
  console.log(`  Display Name: ${uptimeCheckConfig.displayName}`);
  console.log(`  Resource: %j`, uptimeCheckConfig.monitoredResource);
  console.log(`  Period: %j`, uptimeCheckConfig.period);
  console.log(`  Timeout: %j`, uptimeCheckConfig.timeout);
  console.log(`  Check type: ${uptimeCheckConfig.check_request_type}`);
  console.log(
    `  Check: %j`,
    uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
  );
  console.log(
    `  Content matchers: ${uptimeCheckConfig.contentMatchers
      .map(matcher => matcher.content)
      .join(', ')}`
  );
  console.log(`  Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);
});

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * list_uptime_checks($projectId);
 * ```
 */
function list_uptime_checks($projectId)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $pages = $uptimeCheckClient->listUptimeCheckConfigs(
        $uptimeCheckClient->projectName($projectId)
    );

    foreach ($pages->iteratePages() as $page) {
        foreach ($page as $uptimeCheck) {
            print($uptimeCheck->getName() . PHP_EOL);
        }
    }
}

Python

def list_uptime_check_configs(project_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    configs = client.list_uptime_check_configs(project_name)

    for config in configs:
        pprint.pprint(config)

Ruby

def list_uptime_check_configs(project_id)
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  project_name = Google::Cloud::Monitoring::V3::UptimeCheckServiceClient.project_path(project_id)
  configs = client.list_uptime_check_configs(project_name)

  configs.each { |config| puts config.name }
end

También puedes recuperar una sola verificación de tiempo de actividad:

C#

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

Java

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

Go

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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

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

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

Python

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

Ruby

def get_uptime_check_config(config_name)
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  config = client.get_uptime_check_config(config_name)
  pp config.to_hash
  return config
end

Edita verificaciones de tiempo de actividad

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

Consola

  1. En la consola de Stackdriver Monitoring, ve a Verificaciones de tiempo de actividad > Descripción general de verificaciones de tiempo de actividad. Tus verificaciones de tiempo de actividad pueden aparecer en varias páginas.

    Ir a descripción general de verificaciones de tiempo de actividad

  2. En la descripción general de verificaciones de tiempo de actividad, a la derecha del resumen de verificación de tiempo de actividad, haz clic en Editar.

  3. Cambia los valores de los campos según sea necesario. No puedes modificar todos los campos. Si los valores de encabezado personalizados de una verificación están ocultos, no podrás hacerlos visibles.

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

  5. Haz clic en Guardar.

API

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

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

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Puedes obtener [UPTIME_CHECK_ID] de la respuesta de un método create o list. El ID no se muestra en la consola de Stackdriver Monitoring.

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

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

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

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

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

C#

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

Java

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

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

Go

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

Node.js

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

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

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

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

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

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

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

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

PHP

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

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

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

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

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

Python

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

Ruby

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

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  config = { name: config_name }
  field_mask = { paths: []}
  if not new_display_name.to_s.empty? then
    field_mask[:paths].push('display_name')
    config[:display_name] = new_display_name
  end
  if not new_http_check_path.to_s.empty? then
    field_mask[:paths].push('http_check.path')
    config[:http_check] = {path: new_http_check_path }
  end
  client.update_uptime_check_config(config, update_mask:field_mask)
end

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

Borra verificaciones de tiempo de actividad

Antes de borrar una verificación de tiempo de actividad, quita la verificación de cualquier política de alertas que la use. Si no quitas la verificación del tiempo de actividad, no puedes borrarla a través de la consola de Monitoring. Si borras la verificación de tiempo de actividad a través de la API, la política de alertas ignora la verificación de tiempo de actividad que falta. La política no crea un incidente para la verificación faltante.

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

Consola

  1. En la consola de Stackdriver Monitoring, ve a Verificaciones de tiempo de actividad > Descripción general de verificaciones de tiempo de actividad.

    Ir a descripción general de verificaciones de tiempo de actividad

  2. En la descripción general de verificaciones de tiempo de actividad, a la derecha de tu comprobación de disponibilidad, haz clic en Borrar.

API

Llama al método projects.uptimeCheckConfigs.delete. Llena el parámetro de la siguiente manera:

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

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Puedes obtener [UPTIME_CHECK_ID] de la respuesta de un método create o list. El ID no se muestra en la consola de Stackdriver Monitoring.

C#

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

Java

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

Go

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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

    $uptimeCheckClient->deleteUptimeCheckConfig($configName);

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

Python

def delete_uptime_check_config(config_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    client.delete_uptime_check_config(config_name)
    print('Deleted ', config_name)

Ruby

def delete_uptime_check_config(config_name)
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  client.delete_uptime_check_config(config_name)
  puts "Deleted #{config_name}"
end

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Stackdriver Monitoring
¿Necesitas ayuda? Visita nuestra página de asistencia.