Como gerenciar verificações de tempo de atividade

Uma verificação de tempo de atividade é uma solicitação enviada a um recurso para ver se ele responde. É possível usar verificações de tempo de atividade para determinar a disponibilidade de uma instância de VM, um serviço do App Engine, um URL ou um balanceador de carga da AWS.

Monitore a disponibilidade de um recurso criando uma política de alertas que crie um incidente se a verificação de tempo de atividade falhar. A política de alertas pode ser configurada para notificar você por e-mail ou por meio de um canal diferente, e essa notificação pode incluir detalhes sobre o recurso que não respondeu. Você também tem a opção de observar os resultados das verificações de tempo de atividade nos painéis de verificação de tempo de atividade do Monitoring.

Esta página mostra como fazer o seguinte:

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

Consulte a seção Próximos passos para ver links para páginas de preços e páginas que descrevem o monitoramento das verificações de tempo de atividade.

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 recursos da página nem executa JavaScript, e a configuração padrão de uma verificação de tempo de atividade não inclui autenticação.

    Para HTTP e HTTPS, se a resposta 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.

    Para ter sucesso, estas condições devem ser atendidas:

    • O status HTTP é Success.
    • Os dados não podem ter conteúdo obrigatório, ou o conteúdo obrigatório precisa estar presente.

Como criar uma verificação do tempo de atividade

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

Na API

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 será criada 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 para a nova verificação de tempo de atividade. Esta página fornece informações sobre apenas alguns campos. Para ver a documentação completa sobre esse objeto e seus campos, consulte UptimeCheckConfig:

    • Deixe o campo name do objeto de configuração em branco. O sistema define esse campo quando constrói o objeto de configuração de resposta.

    • Se você estiver configurando uma verificação HTTP ou HTTPS, preencha o campo HttpCheck do objeto UptimeCheckConfig. Nesse objeto, defina o campo requestMethod como GET ou POST. Se esse campo for omitido ou definido como METHOD_UNSPECIFIED, uma solicitação GET será emitida.

      Se você estiver configurando uma solicitação POST, preencha os campos contentType e body.

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();
    ProjectName projectName = new ProjectName(projectId);
    // Create the config.
    var newConfig = client.CreateUptimeCheckConfig(
        projectName,
        config,
        CallSettings.FromExpiration(
            Expiration.FromTimeout(
                TimeSpan.FromMinutes(2))));
    Console.WriteLine(newConfig.Name);
    return 0;
}

Java

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

Ver no GitHub (em inglês) Feedback

// createGet creates an example uptime check on a GET request.
func createGet(w io.Writer, projectID string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.CreateUptimeCheckConfigRequest{
		Parent: "projects/" + projectID,
		UptimeCheckConfig: &monitoringpb.UptimeCheckConfig{
			DisplayName: "new GET uptime check",
			Resource: &monitoringpb.UptimeCheckConfig_MonitoredResource{
				MonitoredResource: &monitoredres.MonitoredResource{
					Type: "uptime_url",
					Labels: map[string]string{
						"host": "example.com",
					},
				},
			},
			CheckRequestType: &monitoringpb.UptimeCheckConfig_HttpCheck_{
				HttpCheck: &monitoringpb.UptimeCheckConfig_HttpCheck{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_GET,
					Path:          "/",
					Port:          80,
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig GET: %v", err)
	}
	fmt.Fprintf(w, "Successfully created GET uptime check %q\n", config.GetDisplayName())
	return config, nil
}

// createPost creates an example uptime check on a POST request.
func createPost(w io.Writer, projectID string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.CreateUptimeCheckConfigRequest{
		Parent: "projects/" + projectID,
		UptimeCheckConfig: &monitoringpb.UptimeCheckConfig{
			DisplayName: "new POST uptime check",
			Resource: &monitoringpb.UptimeCheckConfig_MonitoredResource{
				MonitoredResource: &monitoredres.MonitoredResource{
					Type: "uptime_url",
					Labels: map[string]string{
						"host": "example.com",
					},
				},
			},
			CheckRequestType: &monitoringpb.UptimeCheckConfig_HttpCheck_{
				HttpCheck: &monitoringpb.UptimeCheckConfig_HttpCheck{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_POST,
					ContentType:   monitoringpb.UptimeCheckConfig_HttpCheck_URL_ENCODED,
					Path:          "/",
					Port:          80,
					Body:          []byte(base64.URLEncoding.EncodeToString([]byte("key: value"))),
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig POST: %v", err)
	}
	fmt.Fprintf(w, "Successfully created POST uptime check %q\n", config.GetDisplayName())
	return config, nil
}

Node.js

Ver no GitHub (em inglês) Feedback
// 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

Ver no GitHub (em inglês) Feedback
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

Ver no GitHub (em inglês) Feedback
def create_uptime_check_config_get(project_name, host_name=None, display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or "New GET uptime check"
    config.monitored_resource.type = "uptime_url"
    config.monitored_resource.labels.update({"host": host_name or "example.com"})
    config.http_check.request_method = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.RequestMethod.GET
    )
    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

def create_uptime_check_config_post(project_name, host_name=None, display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or "New POST uptime check"
    config.monitored_resource.type = "uptime_url"
    config.monitored_resource.labels.update({"host": host_name or "example.com"})
    config.http_check.request_method = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.RequestMethod.POST
    )
    config.http_check.content_type = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.ContentType.URL_ENCODED
    )
    config.http_check.body = "foo=bar".encode("utf-8")
    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"

  client = Google::Cloud::Monitoring.uptime_check_service
  project_name = client.project_path project: project_id
  config = {
    display_name:       display_name.nil? ? "New uptime check" : display_name,
    monitored_resource: {
      type:   "uptime_url",
      labels: { "host" => host_name.nil? ? "example.com" : host_name }
    },
    http_check:         { path: "/", port: 80 },
    timeout:            { seconds: 10 },
    period:             { seconds: 300 }
  }
  new_config = client.create_uptime_check_config \
    parent:              project_name,
    uptime_check_config: config
  puts new_config.name
  new_config
end

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

No Console do Cloud

O processo de criação de uma verificação de tempo de atividade usando o Console do Cloud está sendo atualizado. Esta seção descreve como criar uma verificação de tempo de atividade usando o novo fluxo e o fluxo clássico. As primeiras etapas de ambos os fluxos são idênticas. É possível saber se você está usando o novo fluxo ou o fluxo clássico pelo formulário Criar verificação de tempo de atividade.

Novo fluxo

  1. No Console do Cloud, selecione Monitoring:

    Acesse o Monitoring

  2. Clique em Uptime checks.

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

  4. Se a janela Criar verificação de tempo de atividade for semelhante à captura de tela a seguir, siga estas instruções. Caso contrário, clique na guia Fluxo clássico nesta tabela e continue com estas instruções:

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

  5. Digite um título descritivo para a verificação de tempo de atividade e clique em Avançar.

  6. Especifique o destino da verificação de tempo de atividade:

    1. Selecione o protocolo. Você tem as opções HTTP, HTTPS e TCP.

    2. Escolha um dos seguintes tipos de recursos:

      • URL: qualquer nome de host ou endereço IPv4. O caminho e a porta são inseridos separadamente.
      • App Engine: aplicativos do App Engine (módulos).
      • Instance: do Compute Engine ou AWS EC2.
      • Balanceador de carga elástico: da AWS.
    3. Insira os campos específicos do protocolo:

      • Para verificações de TCP, digite a porta.

      • Para verificações HTTP e HTTPS, você tem a opção de inserir um caminho no host ou no recurso. Todas as verificações de tempo de atividade que usam esses protocolos enviam uma solicitação para http://target/path. Nesta expressão, para um recurso de URL, target é um nome de host ou endereço IP. Para um recurso do App Engine, target é um nome de host derivado do nome do serviço. Para recursos de instância e balanceador de carga, target é um endereço IP derivado do nome fornecido para o recurso ou o grupo de recursos.

        Se você deixar o campo path em branco ou definir o valor como /, a solicitação será emitida como http://target/.

        Para emitir uma verificação de tempo de atividade para o recurso de URL example.com/tester, defina o campo de nome do host como example.com e o campo de caminho como /tester.

        Suponha que você tenha implantado um servidor no App Engine com um agente compatível com / e /hello. Se você deixar o campo de caminho vazio, a verificação de tempo de atividade será enviada ao gerenciador /. Para emitir a verificação de tempo de atividade para o gerenciador /hello, defina o valor do campo de caminho como /hello.

    4. Insira os campos específicos do recurso:

      • Para recursos URL, digite o nome do host no campo Nome do host. Por exemplo, insira example.com.

      • Para recursos do App Engine, insira o nome do serviço no campo Serviço.

      • Para os recursos de Balanceador de carga elástico e Instância, preencha os seguintes campos:

        • Para emitir uma verificação de tempo de atividade para uma única instância ou balanceador de carga, no campo Aplicável a, selecione Única e use o menu para selecionar a instância ou o balanceador de carga específico.
        • Para emitir uma verificação de tempo de atividade para um grupo do Monitoring, no campo Aplica-se a, selecione Grupo e use o menu para selecionar o nome do grupo.
    5. O campo Frequência de verificação controla a frequência com que a verificação de tempo de atividade é executada. É possível manter o valor padrão ou selecionar um valor no menu de opções.

    6. Para configurar regiões do verificador ou configurar certificados SSL, autenticação, cabeçalhos e portas para verificações HTTP e HTTPS, clique em Mais opções de destino:

      • Regiões: selecione as regiões em que as verificações de tempo de atividade devem receber solicitações. Uma verificação de tempo de atividade precisa ter pelo menos três verificadores. Há um verificador em todas as regiões, exceto nos Estados Unidos, que tem três verificadores. A configuração padrão, Global, inclui todas as regiões.
      • 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.
      • Cabeçalhos personalizados: forneça cabeçalhos personalizados e criptografe-os, se desejar. Os valores dos cabeçalhos ficam ocultos nos formulários pela criptografia. Use a criptografia para cabeçalhos relacionados à autenticação que você não quer que outras pessoas vejam.

      • 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 você definir os valores, não configure um cabeçalho de autorização separado. Se definir um cabeçalho de autorização, não configure valores no campo. As senhas sempre estarão ocultas no formulário. Esse campo não está disponível para verificações TCP.

      • Validação do certificado SSL: se você selecionou HTTPS para um recurso de URL, o serviço tentará se conectar por HTTPS e validará o certificado SSL. A verificação de tempo de atividade falhará se um URL tiver um certificado inválido. Os motivos para um certificado inválido incluem um certificado expirado, um certificado autoassinado, um certificado com um nome de domínio e um certificado que usa a extensão AIA.

        Para forçar uma verificação de tempo de atividade HTTPS para validar o certificado SSL, verifique se a opção Validar certificados SSL está selecionada.

        Para desativar a validação do certificado SSL, verifique se a opção Validar certificados SSL está clara.

        Se você tiver certificados SSL com Extensões de acesso a informações de autoridade (AIA, na sigla em inglês), será necessário desativar a validação do certificado SSL. Esses tipos de certificados não são compatíveis e falham na sequência de validação. Normalmente, a mensagem de erro é "Responder com erro de handshake SSL em 10.000 ms".

        É possível 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. Para mais informações, consulte Políticas de amostra: política de verificação de tempo de atividade.

        Marque a caixa de seleção Validar certificados SSL.

    7. Clique em Next.

  7. Preencha o painel Validação de resposta.

    • Selecione o Tempo limite de resposta no menu de opções. É possível escolher qualquer valor entre 1 e 60 segundos. Uma verificação de tempo de atividade falhará se nenhuma resposta for recebida de mais de um local dentro desse tempo limite. A verificação de tempo de atividade será aprovada se algum local responder.
    • Para a correspondência de conteúdo, verifique se o rótulo é A correspondência de conteúdo está ativada:

      • Selecione o Tipo de correspondência de conteúdo de resposta no menu de opções. Esse campo determina como o conteúdo da resposta é comparado aos dados retornados. Por exemplo, se o conteúdo da resposta for abcd e o tipo de correspondência de conteúdo for Contém, a verificação de tempo de atividade será bem-sucedida se os dados da resposta contiverem abcd. A verificação de tempo de atividade falhará se a resposta não tiver abcd.
      • Digite o Conteúdo da resposta. Precisa ser uma string com até 1024 bytes. Na API, esse é o objeto ContentMatcher.
    • Se você não quiser que as verificações de tempo de atividade sejam enviadas ao Cloud Logging, desmarque Falhas na verificação de registro.

    • Clique em Próximo.

  8. Preencha o painel Alerta e notificação:

    Crie uma política de alertas se quiser que sua verificação de tempo de atividade seja monitorada para você. Se você criar uma política de alertas, um incidente será criado quando a verificação de tempo de atividade falhar e uma notificação for enviada a todos os canais de notificação anexados à política. Por exemplo, se você adicionar um endereço de e-mail à política, um e-mail será enviado para esse endereço quando um incidente for criado.

    É possível criar a política de alertas nesta etapa ou adicioná-la após a verificação ser criada. A criação de uma política de alertas para a verificação de tempo de atividade é controlada por um botão:

    • Se o texto do botão for Não criar um alerta, uma política de alertas não será criada e todos os campos serão desativados. Se você quiser criar uma política de alertas, clique no botão.
    • Se o texto do botão for Criar um alerta, uma política de alertas será criada e todos os campos serão ativados. Se você não quiser criar uma política de alertas, clique no botão.

    Para criar uma política de alertas como parte desse fluxo, faça o seguinte:

    1. Verifique se o texto do botão é Criar um alerta.
    2. No campo de nome, insira um nome para a política de alertas ou use o nome padrão.
    3. Para adicionar um ou mais canais de notificação à política de alertas, na caixa de texto Canais de notificação, clique em Menu . Selecione os canais a serem adicionados e clique em OK. Os canais de notificação são agrupados em ordem alfabética para cada tipo de canal.

      Se um canal de notificação que você quer adicionar à política de alertas não estiver listado, clique em Gerenciar canais de notificação.

      Caixa de diálogo de notificação que exibe os botões de atualização e gerenciamento de canais.

      Você será direcionado para a janela Canais de notificação em uma nova guia do navegador. Adicione os canais de notificação e volte a essa guia, clique em Atualizar e selecione os canais de notificação a serem adicionados à política de alertas.

    4. No campo de duração, selecione por quanto tempo as verificações de tempo de atividade precisam falhar antes que um incidente seja criado. Por padrão, a política de alertas é configurada para criar um incidente se pelo menos duas regiões informarem falhas de verificação de tempo de atividade por um minuto.

    Consulte Como gerenciar políticas para informações sobre como desativar, editar e excluir políticas de alertas.

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

  10. Clique em Criar 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 Uptime check created será exibida.

Fluxo clássico

  1. No Console do Cloud, selecione Monitoring:

    Acesse o Monitoring

  2. Clique em Uptime checks.

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

  4. Se a janela Criar verificação de tempo de atividade for semelhante à captura de tela a seguir, siga estas instruções: Caso contrário, clique na guia Novo fluxo nesta tabela e continue com estas instruções:

    Visualização clássica da caixa de diálogo

  5. Na janela New uptime check, preencha os campos da verificação, conforme descrito em Opções básicas.

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

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

  8. Clique em Save. 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 Uptime check created será exibida.

  9. Opcional: para receber notificações sobre falhas no tempo de atividade, clique em Create alert policy. Se você não quiser criar uma política de alertas agora, clique em Não, obrigado. É 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 monitorar verificações de tempo de atividade.

    Caixa de diálogo

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 a interface clássica

Esta seção descreve os campos que você usa ao criar uma verificação de tempo de atividade ao usar a interface clássica do Console do Cloud ou ao usar a API. Ao usar a API, você fornece os valores correspondentes em 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ê estiver usando a API e o tipo de verificação for HTTP ou HTTPS, poderá configurar a verificação para emitir uma solicitação POST. Veja o exemplo de API acima.

    Se você selecionar HTTPS, o serviço tentará se conectar por HTTPS e validará 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. Resource Type: escolha um dos tipos de recursos 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. Insira os campos específicos do protocolo:

    • Para verificações de TCP, digite a porta.

    • Para verificações HTTP e HTTPS, você tem a opção de inserir um caminho no host ou no recurso. Todas as verificações de tempo de atividade que usam esses protocolos enviam uma solicitação para http://target/path. Nesta expressão, para um recurso de URL, target é um nome de host ou endereço IP. Para um recurso do App Engine, target é um nome do host derivado do nome do serviço. Para instâncias e balanceadores de carga, target é um endereço IP derivado do nome fornecido para o recurso ou o grupo de recursos.

      Se você deixar o campo path em branco ou definir o valor como /, a solicitação HTTP será emitida como http://target/.

      Para emitir uma verificação de tempo de atividade para o recurso de URL example.com/tester, defina o campo de nome do host como example.com e o campo de caminho como /tester.

      Suponha que você tenha implantado um servidor no App Engine com um agente compatível com / e /hello. Se você deixar o campo de caminho vazio, a verificação de tempo de atividade será enviada ao gerenciador /. Para emitir a verificação de tempo de atividade para o gerenciador /hello, defina o valor do campo de caminho como /hello.

  5. Insira os campos específicos do recurso:

    • Se você selecionar um Tipo de recurso de URL, digite o nome do host. Por exemplo, insira example.com.

    • Se você selecionar um Tipo de recurso do App Engine, selecione o nome do serviço.

    • Se você selecionar um Tipo de recurso de Balanceador de carga elástico ou Instância, especifique se a verificação de tempo de atividade se aplica a um único recurso ou a um grupo de recursos. 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.

  6. 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 para a interface clássica

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.

    Os certificados SSL que usam a Extensão de acesso à informação da autoridade (AIA, na sigla em inglês) não são compatíveis e falham na sequência de validação. Normalmente, a mensagem de erro é "Responder com erro de handshake SSL em 10.000 ms". Se você tiver esse tipo de certificado SSL, verifique se a caixa de seleção Validar certificados SSL está desmarcada.

    É possível 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 a 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 Forbidden: 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 Apache padrão retorna esse código no Amazon Linux, mas retorna 200 (Success) 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 Request timeout 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 Healthcheck 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 Monitoramento:

    Acesse o 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. Nas verificações de grupo, os valores de S e T são somados em todos os membros atuais do grupo.

      Por exemplo, durante 25 minutos, uma verificação de tempo de atividade com um período de 1 minuto executada em todas as regiões recebe 25 solicitações de cada um dos seis locais. O 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

Ver no GitHub (em inglês) Feedback

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

Ver no GitHub (em inglês) Feedback
// 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

Ver no GitHub (em inglês) Feedback
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

Ver no GitHub (em inglês) Feedback
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"

  client = Google::Cloud::Monitoring.uptime_check_service
  config = client.get_uptime_check_config name: config_name
  pp config.to_h
  config
end

Como editar uma verificação de tempo de atividade

O protocolo de verificação de tempo de atividade, o tipo de recurso e o recurso que está sendo monitorado não podem ser alterados. Se você quiser modificar esses campos, será necessário criar uma verificação de tempo de atividade com a configuração adequada. No entanto, todos os outros campos em uma verificação de tempo de atividade podem ser modificados após a verificação ser criada.

Para editar uma política de alertas associada a uma verificação de tempo de atividade, no painel de navegação do Monitoring, clique em Alerta, selecione a política a ser editada e clique em Editar.

Basta fazer o seguinte:

Console

  1. No Console do Cloud, selecione Monitoring:

    Acesse o 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 Save.

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 é exibido no Console do 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. Por 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

Ver no GitHub (em inglês) Feedback

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

Ver no GitHub (em inglês) Feedback
// 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

Ver no GitHub (em inglês) Feedback
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

Ver no GitHub (em inglês) Feedback
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"

  client = Google::Cloud::Monitoring.uptime_check_service
  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 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

Se você tentar excluir uma verificação de tempo de atividade usando o Console do Cloud e houver uma política de alertas que dependa da verificação, a operação de exclusão falhará. Repita a exclusão depois de remover a verificação de tempo de atividade de todas as políticas de alertas que usam a verificação.

Se você tentar excluir uma verificação de tempo de atividade usando a API Cloud Monitoring, ela será excluída mesmo que haja políticas de alertas que dependam da verificação. Nenhum erro é gerado. Nenhum incidente é criado para a verificação ausente. Antes de excluir uma verificação de tempo de atividade, verifique se não há políticas de alertas que dependam dessa verificação.

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

Console

  1. No Console do Cloud, selecione Monitoring:

    Acesse o 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 é exibido no Console do 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

Ver no GitHub (em inglês) Feedback

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

Ver no GitHub (em inglês) Feedback
// 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

Ver no GitHub (em inglês) Feedback
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

Ver no GitHub (em inglês) Feedback
# `config_name` is the `name` field of an UptimeCheckConfig.
# See https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.uptimeCheckConfigs#UptimeCheckConfig.
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"

  client = Google::Cloud::Monitoring.uptime_check_service
  client.delete_uptime_check_config name: config_name
  puts "Deleted #{config_name}"
end

A seguir