Como gerenciar verificações de tempo de atividade

Com o Stackdriver, é possível verificar a disponibilidade do seu serviço acessando-o em locais no mundo todo. Use os resultados dessas verificações de tempo de atividade nas políticas de alerta ou monitore-os diretamente nos painéis do Monitoring específicos para essa finalidade.

Nesta página, você aprende as seguintes ações com relação à verificação de tempo de atividade:

  • Criação
  • Listagem
  • Edição
  • Exclusão

Para ver o status das verificações de tempo de atividade ou conseguir uma lista de endereços IP que podem ser usados para realizar essas verificações, consulte Como receber endereços IP. Para determinar o status das verificações de tempo de atividade usando a API, monitore a métrica monitoring.googleapis.com/uptime_check/check_passed. Consulte a lista de métricas do GCP para saber mais detalhes.

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 ativar a autenticação usando as Opções avançadas.

    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 falhou ou se foi bem-sucedida.

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

    • O status HTTP precisa ser 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 estar especificado nas Opções avançadas.

Como criar verificações de tempo de atividade

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

Console

  1. No console do Stackdriver Monitoring, acesse Verificações de tempo de atividade > Visão geral das verificações de tempo de atividade:

    Acessar "Verificações de tempo de atividade"

  2. No canto superior direito, clique em Adicionar verificação de tempo de atividade.

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

    Criar verificação de tempo de atividade

  4. Também é possível clicar em Opções avançadas para acessar as configurações de porta, cabeçalhos personalizados e autenticação. Para ver os detalhes, consulte Opções avançadas nesta página.

  5. Para ver o resultado da verificação de tempo de atividade, clique em Testar. 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.

  6. Clique em Salvar. Não é possível salvar uma verificação de tempo de atividade quando há algum campo obrigatório ausente. Caso o botão Salvar esteja desativado, verifique os valores ausentes. Insira um valor no campo Nome do host.

API

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

  • parent: obrigatório. Esse precisa ser o nome do projeto em que será criada a verificação de tempo de atividade. Substitua [PROJECT_ID] pelo código do projeto do GCP. O formato é:

    projects/[PROJECT_ID]
    
  • O corpo da solicitação precisa conter um objeto UptimeCheckConfig para a nova verificação de tempo de atividade. Explicamos os campos do objeto nas seções Opções básicas e Opções avançadas nesta página.

    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é 25 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 "nenhum dado disponível".

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 Stackdriver Monitoring, você preenche um formulário. Durante a criação da verificação de tempo de atividade na API, forneça os parâmetros correspondentes para um objeto UptimeCheckConfig.

  1. Título: um nome para identificar sua verificação. Por exemplo, Example.com uptime check.

  2. Tipo de verificação: selecione um protocolo HTTP, HTTPS ou TCP.

    Se você selecionar HTTPS, o serviço tentará se conectar por HTTPS, mas não validará o certificado SSL. Por exemplo, certificados expirados ou autoassinados não farão com que uma verificação falhe.

  3. Tipo de recurso: escolha um dos seguintes tipos de recursos:

    • App Engine: aplicativos do App Engine (módulos).
    • Balanceador de carga elástico: da AWS.
    • Instância: do Compute Engine ou AWS EC2. Na API, isso é dividido 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, de acordo com o tipo de verificação e de recurso:

    • Aplicável a (App Engine, ELB ou Instância): é possível aplicar a verificação de tempo de atividade a um único recurso ou a um grupo de recursos, como todas as instâncias. Se você optar por um único recurso, escolha um dos recursos atuais listados no menu. Se você usar a API, preencha o recurso monitorado com os rótulos dos recursos obrigatórios, conforme descrito na lista de recursos monitorados.

    • Módulo (App Engine): especifique o módulo do aplicativo.

    • Nome do host (todos, exceto para o App Engine): especifique o nome do host do serviço. Por exemplo, insira example.com.

    • Caminho (HTTP, HTTPS): insira um caminho no host ou recurso ou use o padrão. Por exemplo, para sondar example.com, deixe esse campo em branco. Para sondar 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 /.

    • Porta (HTTP, HTTPS, TCP): escolha uma porta para a conexão.

      • Para verificações HTTP e HTTPS, essa alternativa está em Opções avançadas.
      • Na API, deixe esse campo em branco para usar o valor padrão, que é 80 para verificações de TCP ou HTTP e 443 para verificações HTTPS.
    • Conteúdo de resposta inclui o texto (HTTP, HTTPS, TCP): preencha uma string (máximo de 1.024 bytes) com uma presença na resposta de verificação que indica êxito. A verificação falhará se a string não for exibida em nenhum lugar na resposta.

      • Para verificações HTTP e HTTPS, esse campo é exibido em Opções avançadas.
      • Na API, esse é o objeto ContentMatcher.
  5. Verificar a cada: 1, 5, 10 ou 15 minutos. Por exemplo, se você selecionar 5 minutos, em todos os locais geográficos haverá uma tentativa de alcançar o serviço uma vez a cada intervalo de 5 minutos. Usando os seis locais padrão e verificando a cada 5 minutos, o serviço recebe uma média de 1,2 solicitações por minuto. Verificando a cada 1 minuto, o serviço recebe em média 6 solicitações por minuto.

Opções avançadas

As Opções avançadas se aplicam aos tipos de verificação HTTP, HTTPS e TCP.

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 falhou ou se foi bem-sucedida.

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

  1. O status HTTP precisa ser Success.
  2. 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 estar especificado nas Opções avançadas.

As configurações a seguir são opcionais e variam de acordo com o tipo de verificação:

  • Cabeçalho de Host HTTP: preencha este campo para verificar hosts virtuais. Este campo não está disponível para verificações de TCP.

  • Porta: especifique um número de porta. Para verificações de TCP, esse campo é exibido em Opções básicas.

  • O conteúdo da resposta contém o texto: preencha com uma string (máximo de 1.024 bytes) que indica êxito se for exibida na resposta da verificação. Para verificações de TCP, esse campo é exibido em Opções básicas.

  • Locais: selecione as regiões geográficas aplicáveis em que a verificação receberá solicitações. Você precisa selecionar regiões suficientes para ter, no mínimo, três locais ativos. Durante a criação de uma verificação, os locais em cada região são listados abaixo do nome da região. Os novos locais dos verificadores nas regiões selecionadas enviam solicitações automaticamente aos destinos configurados. Para sempre enviar solicitações de todos os locais disponíveis, selecione Global. Para enviar solicitações de todos os locais nas regiões atuais, mas não para novos locais em novas regiões, selecione todas as regiões atuais e não selecione Global.

  • Cabeçalhos personalizados: 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 deseja exibir a outros membros da equipe. Este campo não está disponível para verificações de TCP.

  • Tempo limite da verificação de integridade: 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. Este campo não está disponível para verificações de TCP.

Identificadores para verificações de tempo de atividade

Durante a criação da verificação de tempo de atividade, o Stackdriver atribui um identificador, chamado de código de verificação de tempo de atividade. Esse identificador é incorporado no nome do recurso para a nova verificação de tempo de atividade:

projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]

É possível receber o código de verificação de tempo de atividade da resposta de uma chamada de método para criar ou listar verificações de tempo de atividade. Também é possível encontrar o código de verificação na página do console do Stackdriver Monitoring para verificação de tempo de atividade, no campo Código de verificação do painel Verificar configuração.

Testar verificação de tempo de atividade

Ao criar uma verificação de tempo de atividade no console do Stackdriver Monitoring, é possível testar a configuração antes de salvá-la.

Sucesso na verificação

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

  • O status HTTP precisa ser 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:

  • Erro de conexão - recusada: se você usa o tipo de conexão HTTP padrão, verifique se há um servidor da Web instalado 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.
  • Nome ou serviço não encontrado: 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 Não encontrado: 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.

Criar uma política de alerta

Caso você queria ser notificado sobre falhas no tempo de atividade, crie uma política de alerta para a nova verificação de tempo de atividade. Consulte este link para ver os detalhes.

Como listar verificações de tempo de atividade

Basta seguir estas etapas:

Console

  1. Para visualizar uma lista das verificações de tempo de atividade no console do Stackdriver Monitoring, acesse Verificações de tempo de atividade > Visão geral das verificações de tempo de atividade. As verificações de tempo de atividade podem ser listadas em várias páginas.

    Acessar "Verificações de tempo de atividade"

  2. Para filtrar a lista de verificações execute um dos seguintes procedimentos:

    • Digite um texto no campo Filtro para limitar a lista a verificações com esse texto nos títulos.
    • Use o botão à esquerda do campo Filtro para filtrar membros de um grupo específico.

    Clique em uma verificação de tempo de atividade para ver mais detalhes sobre ela.

API

Para ver uma lista das configurações de tempo de atividade, chame o método projects.uptimeCheckConfigs.list. Especifique os parâmetros a seguir:

  • parent: o projeto com as verificações de tempo de atividade que você quer listar. O formato é:

    projects/[PROJECT_ID]
    

Para ver uma verificação de tempo de atividade específica, chame o método projects.uptimeCheckConfigs.get. Especifique o parâmetro a seguir:

  • name: o nome completo da configuração da verificação de tempo de atividade.

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    É possível receber o [UPTIME_CHECK_ID] da resposta de um método create ou list. O código não é exibido no console do Stackdriver Monitoring.

C#

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

Java

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

Go

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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

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

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

Python

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

    for config in configs:
        pprint.pprint(config)

Ruby

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

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

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

Também é possível recuperar uma única verificação de tempo de atividade:

C#

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

Java

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

Go

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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

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

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

Python

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

Ruby

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

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

Como editar verificações de tempo de atividade

Basta fazer o seguinte:

Console

  1. No console do Stackdriver Monitoring, acesse Verificações de tempo de atividade > Visão geral das verificações de tempo de atividade. As verificações de tempo de atividade podem ser listadas em várias páginas.

    Acessar "Verificações de tempo de atividade"

  2. Em Visão Geral das Verificações de Tempo de Atividade, à direita do resumo da verificação, clique em Editar.

  3. 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 é possível deixá-los visíveis.

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

  5. 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 da REST e é o nome do recurso da verificação de tempo de atividade a ser editada:

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    É possível receber o [UPTIME_CHECK_ID] da resposta de um método create ou list. O código não é exibido no console do Stackdriver Monitoring.

  • 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 alteradas. Exemplo:

    "resource.type,httpCheck.path"
    
  • O corpo da solicitação precisa conter uma 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 ele estiver listado na máscara, mas nenhum dos subcampos estiver, todos os subcampos dele substituirão os campos correspondentes.

Se updateMask não for 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.uptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

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

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

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

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

PHP

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

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

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

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

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

Python

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

Ruby

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

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  config = { name: config_name }
  field_mask = { paths: [] }
  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é 25 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 verificações 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 Stackdriver Monitoring, acesse Verificações de tempo de atividade > Visão geral das verificações de tempo de atividade.

    Acessar "Verificações de tempo de atividade"

  2. Em Visão geral das verificações de tempo de atividade, à direita da sua verificação, 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]
    

    É possível receber o [UPTIME_CHECK_ID] da resposta de um método create ou list. O código não é exibido no console do Stackdriver Monitoring.

C#

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

Java

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

Go

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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

    $uptimeCheckClient->deleteUptimeCheckConfig($configName);

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

Python

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

Ruby

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

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

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Stackdriver Monitoring
Precisa de ajuda? Acesse nossa página de suporte.