Administra verificaciones de tiempo de actividad

Cloud Monitoring puede verificar la disponibilidad de tu servicio al acceder a él desde ubicaciones de 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 de verificación de tiempo de actividad de Monitoring.

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

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

Es posible que también te interesen los siguientes datos:

Antes de comenzar

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

    • Si el recurso que verificas no está disponible públicamente, debes configurar su firewall para permitir el tráfico entrante de los servidores de verificación de tiempo de actividad. Consulta Obtén direcciones IP para descargar una lista de las direcciones IP.
    • Si el recurso que verificas no tiene una dirección IP externa, las verificaciones de tiempo de actividad no podrán acceder a él.
  2. La verificación de tiempo de actividad no carga los elementos de la página ni ejecuta JavaScript. 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 las Opciones avanzadas.

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

    Para que sea correcta, se deben cumplir dos condiciones:

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

Crea una verificación de tiempo de actividad

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

Console

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

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

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

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

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

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

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

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

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

API

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

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

    projects/[PROJECT_ID]
        
  • El cuerpo de la solicitud debe contener un objeto UptimeCheckConfig para la verificación de tiempo de actividad nueva. Los campos en el objeto se explican en las secciones Opciones básicas y 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 nueva configuración.

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

C#

public static object CreateUptimeCheck(string projectId, string hostName,
        string displayName)
    {
        // Define a new config.
        var config = new UptimeCheckConfig()
        {
            DisplayName = displayName,
            MonitoredResource = new MonitoredResource()
            {
                Type = "uptime_url",
                Labels = { { "host", hostName } }
            },
            HttpCheck = new UptimeCheckConfig.Types.HttpCheck()
            {
                Path = "/",
                Port = 80,
            },
            Timeout = TimeSpan.FromSeconds(10).ToDuration(),
            Period = TimeSpan.FromMinutes(5).ToDuration()
        };
        // Create a client.
        var client = UptimeCheckServiceClient.Create();
        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
      new_config
    end

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

Opciones básicas

Para crear una verificación de tiempo de actividad nueva, especifica los valores de la configuración. Cuando creas la verificación de tiempo de actividad en Cloud Console, completas un formulario. Cuando creas la verificación de 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 selecciona HTTPS, el servicio intentará conectarse a través de HTTPS y validará el certificado SSL. De forma predeterminada, un certificado vencido o autofirmado hace que falle la verificación de tiempo de actividad.

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

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

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

    • Si seleccionas un tipo de verificación de TCP, completa los siguientes datos:

      • Puerto: especifica un número de puerto.
      • Tipo de concordancia del contenido de la respuesta: especifica cómo se compara la string ingresada en el contenido de la respuesta con los datos reales que se muestran. Por ejemplo, si el contenido de la respuesta es abcd y seleccionas un tipo de concordancia de contenido de Contiene, la verificación de tiempo de actividad se realiza correctamente si los datos de respuesta contienen abcd. La verificación de tiempo de actividad falla si la respuesta no contiene abcd.
      • Reemplaza el contenido de la respuesta con una string (1024 bytes como máximo).
    • Si seleccionas un tipo de recurso de URL o App Engine, sigue estos pasos:

      • Nombre de host: ingresa el nombre de host del 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 probar example.com, deja este campo en blanco. Para probar example.com/tester, ingresa /tester. No incluyas el prefijo example.com. En la API, deja este campo en blanco para usar el valor predeterminado, /.

    • Si seleccionas un tipo de recurso de Elastic Load Balancer o Instancia, sigue estos pasos:

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

      • Ruta de acceso (HTTP, HTTPS): ingresa una ruta dentro de tu host o recurso o usa la ruta de acceso predeterminada.

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

Opciones avanzadas

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

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

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

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

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

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

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

    Puede usar la métrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires para crear una alerta que le notifique antes de que venza su certificado. Consulta Políticas de muestra: Política de verificación de tiempo de actividad.

Identificadores para verificaciones de tiempo de actividad

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

projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

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

Verifica tu tiempo de actividad

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

Comprueba que sea correcta

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

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

Verifica la falla

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

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

Ve una verificación de tiempo de actividad

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

Console

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

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

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

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

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

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

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

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

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

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

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

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

C#

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

Java

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

Go


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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

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

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

Python

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

Ruby

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

      client = Google::Cloud::Monitoring::V3::UptimeCheck.new
      config = client.get_uptime_check_config config_name
      pp config.to_h
      config
    end

Edita una verificación de tiempo de actividad

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

Console

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

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

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

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

  6. Haga clic en Save.

API

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

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

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
        

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

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

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

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

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

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

C#

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

Java

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

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

Go


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

Node.js

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

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

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

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

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

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

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

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

PHP

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

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

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

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

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

Python

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

Ruby

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

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

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

Borra una verificación de tiempo de actividad

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:

Console

  1. En Cloud Console, selecciona Monitoring:

    Ir a Monitoring

  2. Haz clic en Verificaciones de tiempo de actividad.

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

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

API

Realiza una llamada al método projects.uptimeCheckConfigs.delete. 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:

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
        

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

C#

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

Java

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

Go


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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

        $uptimeCheckClient->deleteUptimeCheckConfig($configName);

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

Python

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