Como gerenciar verificações de tempo de atividade

O Cloud Monitoring pode verificar a disponibilidade do seu serviço, acessando-o de locais ao redor do mundo. Use os resultados dessas verificações de tempo de atividade nas políticas de alertas ou monitore-os diretamente nos painéis do Monitoring específicos para essa finalidade.

Esta página mostra como fazer o seguinte:

  • Criação
  • Visualização
  • Edição
  • Exclusão

Além disso, as informações a seguir podem ser úteis para você:

Antes de começar

  1. Os firewalls que protegem seu serviço afetam o uso das verificações de tempo de atividade.

    • Se o recurso que você está verificando não estiver disponível publicamente, configure o firewall dele para permitir o tráfego de entrada dos servidores de verificação de tempo de atividade. Consulte Como receber endereços IP para fazer o download de uma lista dos endereços IP.
    • Se o recurso que você está verificando não tiver um endereço IP externo, as verificações de tempo de atividade não poderão acessá-lo.
  2. A verificação de tempo de atividade não carrega os recursos da página nem executa o JavaScript. A configuração padrão de uma verificação de tempo de atividade não inclui autenticação. É possível usar as Opções avançadas para ativar a autenticação.

    Para HTTP e HTTPS, a verificação de tempo de atividade emite um comando GET e recupera dados brutos. Se a resposta GET for um redirecionamento para outro URL, a verificação recuperará os dados desse URL. Por fim, a verificação de tempo de atividade avalia os dados para determinar se ela falhou ou foi bem-sucedida.

    É necessário atender a duas condições para que a verificação seja bem-sucedida:

    • O status HTTP é Success.
    • Os dados não podem ter conteúdo obrigatório, ou o conteúdo obrigatório precisa estar presente. O conteúdo obrigatório precisa ser especificado usando as Opções avançadas.

Como criar uma verificação do tempo de atividade

Nesta seção, você vê como criar e configurar verificações de tempo de atividade.

Console

  1. No Console do Cloud, selecione Monitoring:

    Acessar Monitoring

  2. Clique em Uptime checks.

  3. Clique em Criar verificação de tempo de atividade.

  4. Na janela Nova verificação de tempo de atividade, preencha os campos da verificação, conforme descrito em Opções básicas.

    Crie uma caixa de diálogo da verificação de tempo de atividade.

  5. Opcional: clique em Show advanced options. Para mais informações sobre as opções avançadas, consulte esta seção.

  6. Para verificar a configuração da verificação de tempo de atividade, clique em Test. Se o resultado não for o esperado, consulte a seção Falhas na verificação abaixo, corrija a configuração e repita o teste.

  7. Clique em Salvar. Se faltarem dados obrigatórios, o salvamento falhará e uma lista de campos que exigem dados será exibida ao lado dos botões da caixa de diálogo. Depois de salvar as alterações, a caixa de diálogo Verificação de tempo de atividade criada será exibida.

  8. Opcional: para receber notificações sobre falhas no tempo de atividade, clique em Criar política de alerta. Se você não quiser criar uma política de alertas agora, clique em Cancelar. É possível criar uma política de alertas para uma verificação de tempo de atividade a qualquer momento. Para mais informações, consulte Como receber alertas sobre verificações de tempo de atividade.

    Caixa de diálogo

API

Chame o método projects.uptimeCheckConfigs.create. Defina os parâmetros dele da seguinte maneira:

  • parent: obrigatório. Precisa ser o nome do projeto em que você quer criar a verificação de tempo de atividade. Substitua [PROJECT_ID] pelo ID do seu projeto do Google Cloud. O formato é:

    projects/[PROJECT_ID]
        
  • O corpo da solicitação precisa conter um objeto UptimeCheckConfig da nova verificação de tempo de atividade. Nas seções Opções básicas e Opções avançadas desta página, você encontra explicações sobre os campos no objeto.

    Deixe o campo name do objeto de configuração em branco, conforme definido no objeto de configuração retornado.

O método create retorna o objeto UptimeCheckConfig da nova configuração.

Se a configuração de tempo de atividade criada não funcionar como esperado, consulte a seção Falhas na verificação nesta 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

Pode haver um atraso de até cinco minutos antes que os resultados da verificação de tempo de atividade comecem a ser transmitidos para o Monitoring. Durante esse tempo, o painel da verificação de tempo de atividade informa o status como "no data available".

Opções básicas

Para criar uma nova verificação de tempo de atividade, especifique os valores da configuração dela. Ao criar a verificação de tempo de atividade no Console do Cloud, você preenche um formulário. Ao fazer isso na API, você fornece os parâmetros correspondentes a um objeto UptimeCheckConfig.

  1. Title: um nome para identificar a verificação. Por exemplo, Example.com uptime check.

  2. Check Type: selecione um protocolo HTTP, HTTPS ou TCP.

    Se você selecionar HTTPS, o serviço tentará se conectar por HTTPS e valida o certificado SSL. Por padrão, um certificado expirado ou autoassinado causa falha na verificação do tempo de atividade.

    Para desativar a validação do certificado SSL, desmarque Validar certificados SSL.

  3. Tipo de recurso: escolha um dos tipos de recurso a seguir:

    • App Engine: aplicativos do App Engine (módulos).
    • Balanceador de carga elástico: da AWS.
    • Instance: do Compute Engine ou AWS EC2. Na API, ela é dividida em gce_instance e aws_ec2_instance.
    • URL: qualquer nome de host ou endereço IPv4. O caminho e a porta são inseridos separadamente.
  4. Preencha as informações de conexão, dependendo do tipo de verificação e de recurso:

    • Se você selecionar TCP como Check Type, preencha o seguinte:

      • Port: especifique um número de porta.
      • Response content match type: especifica como a string inserida no conteúdo da resposta é comparada com os dados retornados reais. Por exemplo, se o conteúdo da resposta for abcd, e você selecionar Contains como o tipo de correspondência do conteúdo, a verificação de tempo de atividade será bem-sucedida se os dados da resposta tiverem abcd. A verificação de tempo de atividade falhará se a resposta não tiver abcd.
      • Substitua Response Content por uma string com até 1.024 bytes.
    • Se você selecionar URL ou App Engine como Resource Type, faça o seguinte:

      • Hostname: insira o nome do host do serviço. Por exemplo, insira example.com.

      • Path (HTTP, HTTPS): insira um caminho no host ou recurso ou use o padrão. Por exemplo, para analisar example.com, deixe esse campo em branco. Para analisar example.com/tester, insira /tester. Não inclua o prefixo example.com. Na API, deixe esse campo em branco para usar o valor padrão /.

    • Se você selecionar Elastic Load Balancer ou Instance como Resource Type, faça o seguinte:

      • Applies to: selecione Single ou Group. Para aplicar a verificação de tempo de atividade a uma instância ou balanceador de carga, selecione Single e escolha a opção pretendida. Para aplicar a verificação de tempo de atividade a um grupo de instâncias ou de balanceadores de carga, selecione Group e escolha a opção pretendida. Se você usar a API, preencha o recurso monitorado com os rótulos dos recursos obrigatórios, conforme descrito na lista de recursos monitorados.

      • Path (HTTP, HTTPS): insira um caminho no host ou recurso ou use o padrão.

  5. Check every: escolha 1, 5, 10 ou 15 minutos. Esse valor determina a frequência das verificações de tempo de atividade. Por exemplo, se você selecionar cinco minutos, cada local geográfico emitirá uma verificação de tempo de atividade nesse tempo.

Opções avançadas

Clique em Show Advanced Options para ver todas elas. As configurações avançadas disponíveis dependem do tipo de verificação:

  • General: preencha este campo para verificar hosts virtuais. Ele não está disponível para verificações TCP.
  • Port: especifique um número de porta.
  • Response content match type: especifica como a string inserida no conteúdo da resposta é comparada com os dados retornados reais. Por exemplo, se o conteúdo da resposta for abcd, e você selecionar Contains como o tipo de correspondência do conteúdo, a verificação de tempo de atividade será bem-sucedida se os dados da resposta tiverem abcd. A verificação de tempo de atividade falhará se a resposta não tiver abcd.
  • Response Content: insira uma string com até 1.024 bytes. Na API, esse é o objeto ContentMatcher.

  • Locais: selecione as regiões geográficas aplicáveis em que a verificação receberá solicitações. A configuração padrão é Global com seis verificadores. Você precisa ter pelo menos três. A região United States inclui três verificadores. Todas as outras têm apenas um.

  • Custom Headers: forneça cabeçalhos personalizados e, se necessário, criptografe-os. Os valores dos cabeçalhos ficam ocultos nos formulários pela criptografia. Use a criptografia nos cabeçalhos relacionados à autenticação que você não quer exibir a outros membros da equipe.

  • Healthcheck Timeout: especifique de 1 a 60 segundos. Uma verificação de tempo de atividade falhará se as verificações de integridade de mais de um local não receberem uma resposta dentro do período de tempo limite configurado. Se apenas uma verificação de integridade não conseguir resposta, a verificação de tempo de atividade não falhará.

  • Autenticação: forneça um único nome de usuário e senha. Esses valores são enviados como um cabeçalho de autorização. Se for definir valores, não configure um cabeçalho de autorização separado. Se for definir um cabeçalho de autorização, não defina valores no campo. As senhas sempre estarão ocultas no formulário. Esse campo não está disponível para verificações TCP.

  • SSL Certificate Validation: marque a caixa de seleção Validate SSL certifications. Uma verificação de tempo de atividade falhará se um URL tiver um certificado inválido. O certificado é inválido quando ele está expirado, tem uma discrepância de nome de domínio, é autoassinado, dentre outros motivos. A validação do certificado SSL está disponível apenas para verificações HTTPS em recursos de URL.

    Você pode usar a métrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires para criar um alerta que notifique você antes que o certificado expire. Consulte Políticas de exemplo: política de verificação de tempo de atividade.

Identificadores de verificações de tempo de atividade

Durante a criação da verificação de tempo de atividade, o Monitoring atribui um identificador, chamado de ID de verificação de tempo de atividade. Esse identificador é incorporado ao nome do recurso da nova verificação de tempo de atividade:

projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

É possível receber esse ID a partir da resposta de uma invocação de método para criar ou listar verificações de tempo de atividade. Você também encontra o ID na janela Uptime Details na seção Configuration.

Testar verificação de tempo de atividade

Quando você cria uma verificação de tempo de atividade no Console do Cloud, é possível testar a configuração antes de salvar.

Sucesso na verificação

Para ser bem-sucedida, a verificação de tempo de atividade precisa atender a duas condições:

  • O status HTTP é Success.
  • A resposta não pode ter conteúdo obrigatório, ou uma pesquisa da resposta para o conteúdo obrigatório precisa ser bem-sucedida.

Falha na verificação

Veja a seguir algumas possíveis causas de falha na verificação de tempo de atividade:

  • Connection Error - Refused: se você usa o tipo de conexão padrão HTTP, verifique se há um servidor da Web instalado que esteja respondendo a solicitações HTTP. Isso pode acontecer em uma nova instância se não houver um servidor da Web instalado. Consulte o Guia de início rápido do Compute Engine. Se você usa um tipo de conexão HTTPS, talvez tenha que executar mais algumas etapas de configuração. Se tiver problemas de firewall, consulte Como receber endereços IP.
  • Name or service not found: o nome do host pode estar incorreto.
  • 403 Proibido: o serviço está retornando um código de erro para o verificador de tempo de atividade. Por exemplo, a configuração do servidor da Web padrão Apache retorna esse código no Amazon Linux, mas retorna o código 200 (Êxito) em algumas outras versões do Linux. Consulte o Tutorial de LAMP para Amazon Linux (em inglês) ou a documentação do servidor da Web.
  • 404 Not found: o caminho pode estar incorreto.
  • 408 Tempo esgotado da solicitação ou sem resposta: o número da porta pode estar incorreto, o serviço pode não estar em execução ou estar inacessível ou o tempo limite pode estar muito baixo. Verifique se o firewall permite tráfego proveniente dos servidores de tempo de atividade. Consulte Como receber endereços IP. O tempo limite é especificado em Verificação de integridade nas Opções avançadas.

Como visualizar uma verificação de tempo de atividade

Basta fazer o seguinte:

Console

Para visualizar o status detalhado de uma única verificação de tempo de atividade, faça o seguinte:

  1. No Console do Cloud, selecione Monitoring:

    Acessar Monitoring

  2. Clique em Uptime checks.

  3. Para ver a janela Uptime details, localize a verificação de tempo de atividade que você quer visualizar e clique no nome dela.

    Veja na captura de tela a seguir os detalhes do tempo de atividade de uma verificação chamada "My Uptime Check":

    Amostra de painel da verificação de tempo de atividade.

    A janela Uptime details contém as informações a seguir:

    • O intervalo de tempo selecionado. Por padrão, ele é de uma hora.
    • O nome da verificação de tempo de atividade. Na amostra, ele é My Uptime Check.
    • A porcentagem de tempo de atividade e a latência média. O valor de Percent uptime é uma porcentagem calculada como (S/T)*100, em que S é o número de respostas de verificação bem-sucedidas, e T é o número total de respostas de verificação em todos os locais. Para verificações de grupo, os valores de S e T são somados em todos os membros atuais do grupo.

      Por exemplo, durante um período de 25 minutos, uma verificação de tempo de atividade com um período de 1 minuto sendo executada de todas as regiões receberia 25 solicitações de cada um dos 6 locais, para um total de 150 solicitações. Se o painel informar um tempo de atividade de 83,3%, 125 das 150 solicitações serão bem-sucedidas.

    • Os painéis Passed checks e Uptime check latency exibem gráficos do número de verificações aprovadas e a latência de cada verificação como uma função de tempo.

    • O painel Current Status exibe o status das verificações mais recentes. Um círculo verde com uma marca ao lado de uma região indica que a última execução da verificação nessa região foi bem-sucedida. Já um círculo vermelho com um x indica falha.

    • O painel Configuration mostra a configuração da verificação de tempo de atividade. Esses dados são atribuídos quando a verificação de tempo de atividade é criada. O valor de Check Id corresponde ao [UPTIME_CHECK_ID] das chamadas de API.

    • O painel Alert Policies lista informações sobre as políticas de alertas associadas. Na amostra de painel, uma política de alertas é configurada.

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

Como editar uma verificação de tempo de atividade

Basta fazer o seguinte:

Console

  1. No Console do Cloud, selecione Monitoring:

    Acessar Monitoring

  2. Clique em Uptime checks.

  3. Localize a verificação de tempo de atividade que você quer editar e siga um destes procedimentos:

    • Clique em Mais e selecione Editar.
    • Veja os detalhes da verificação de tempo de atividade e clique em Edit.
  4. Altere os valores dos campos conforme necessário. Não é possível modificar todos os campos. Se os valores de cabeçalho personalizados de uma verificação estiverem ocultos, não será possível exibi-los.

  5. Para conferir se a verificação funciona, clique em Test. Se o teste falhar, consulte Falhas na verificação para possíveis causas.

  6. Clique em Salvar.

API

Chame o método projects.uptimeCheckConfigs.patch. Defina os parâmetros do método da seguinte maneira:

  • uptimeCheckConfig.name: obrigatório. Ele faz parte do URL REST. É o nome do recurso da verificação de tempo de atividade a ser editado:

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
        

    Você recebe o valor de [UPTIME_CHECK_ID] da resposta de um método create ou list. O código não é mostrado no Console do Google Cloud.

  • updateMask: opcional. Este é um parâmetro de consulta: ?updateMask=[FIELD_LIST]. [FIELD_LIST] é uma lista separada por vírgulas dos campos no objeto UptimeCheckConfig que precisam ser alterados. Exemplo:

    "resource.type,httpCheck.path"
        
  • O corpo da solicitação precisa conter um objeto UptimeCheckConfig com os novos valores de campo.

Se updateMask estiver definido, somente os campos listados em updateMask substituirão os campos correspondentes na configuração atual. Se um campo tiver subcampos e estiver listado na máscara, mas nenhum dos subcampos estiver, todos os subcampos dele substituirão os campos correspondentes.

Se updateMask não estiver definido, a configuração no corpo da solicitação substituirá toda a configuração atual.

O método patch retorna o objeto UptimeCheckConfig da configuração 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.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

Pode haver um atraso de até cinco minutos antes que você veja os resultados da nova verificação de tempo de atividade. Durante esse tempo, os resultados da verificação anterior são exibidos nos painéis e usados nas políticas de alertas.

Como excluir uma verificação de tempo de atividade

Antes de excluí-la, remova a verificação de tempo de atividade de todas as políticas de alertas em que ela é utilizada. Se não fizer isso, não será possível excluir a verificação de tempo de atividade por meio do console do Monitoring. Se a verificação de tempo de atividade for excluída por meio da API, a política de alertas ignorará a ausência de verificação. A política não cria um incidente para a verificação ausente.

Para excluir uma verificação de tempo de atividade, siga estas etapas:

Console

  1. No Console do Cloud, selecione Monitoring:

    Acessar Monitoring

  2. Clique em Uptime checks.

  3. Localize a verificação de tempo de atividade que você quer editar e siga um destes procedimentos:

    • Clique em Mais e selecione Excluir.
    • Visualize os detalhes da verificação de tempo de atividade e clique em Excluir

API

Chame o método projects.uptimeCheckConfigs.delete. Preencha o parâmetro da seguinte maneira:

  • name: obrigatório. É o nome do recurso da configuração de verificação de tempo de atividade a ser excluída:

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
        

    Você recebe o valor de [UPTIME_CHECK_ID] da resposta de um método create ou list. O código não é mostrado no Console do Google Cloud.

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