Como gerenciar verificações de tempo de atividade

Com o Stackdriver, você pode verificar a disponibilidade do seu serviço acessando-o em locais no mundo todo. Também pode usar os resultados dessas verificações de tempo de atividade nas políticas de alertas ou monitorá-los diretamente nos painéis do Monitoring específicos para essa finalidade.

Nesta página, são exibidos os seguintes processos relacionados às verificações 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 ver os detalhes.

Antes de começar

Verificações de tempo de atividade e firewalls

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

Firewalls. Se o recurso que você está verificando não estiver disponível publicamente, será necessário configurar o firewall dele para permitir o tráfego recebido dos servidores de verificação de tempo de atividade. Consulte Como receber endereços IP para fazer o download de uma lista de endereços IP.

Se o recurso que você estiver verificando não tiver um endereço IP externo, as verificações de tempo de atividade não poderão acessá-lo.

Políticas de alertas para verificações de tempo de atividade

É necessário criar a verificação de tempo de atividade antes de desenvolver uma política de alertas. Nesta página, descrevemos a criação da verificação de tempo de atividade. Consulte Como programar alertas para verificações de tempo de atividade para ver os detalhes sobre como criar uma política de alertas de uma verificação existente.

Ações de verificação de tempo de atividade

A verificação de tempo de atividade não carrega recursos da página nem executa o JavaScript. A configuração padrão de uma verificação 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 de GET for um redirecionamento para outro URL, a verificação recuperará os dados desse URL. Por fim, a verificação avalia os dados para determinar se ela foi bem-sucedida ou se falhou. É 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. Ele é especificado usando as 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 Uptime checks > Uptime checks overview:

    Acesse "Visão geral das verificações de tempo de atividade"

  2. Clique em Add uptime check na parte superior à direita da página. Você verá o painel New uptime check:

    Criar verificação de tempo de atividade

  3. Preencha as informações básicas da verificação, conforme descrito em Opções básicas nesta página.

  4. Como alternativa, clique em Advanced options na parte inferior do formulário para acessar a configuração de porta, cabeçalhos personalizados, autenticação etc. Para ver os detalhes, consulte Opções avançadas nesta página.

  5. Como alternativa, clique em Test para saber o resultado da verificação de tempo de atividade. Se ele não for o esperado, consulte a seção Verificar falhas abaixo, corrija a configuração e repita o teste.

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

API

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

  • parent: obrigatório. Precisa ser o nome do projeto em que você quer criar a verificação de tempo de atividade. 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.

    O campo name do objeto de configuração precisa ficar em branco. Ele será 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 que você criou 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
  return 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 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. Na criação com o uso da API, você fornece os parâmetros correspondentes para um objeto UptimeCheckConfig.

  1. Título: o nome da verificação. Por exemplo: Example.com uptime check.

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

    Escolher HTTPS significa que o serviço tenta se conectar via HTTPS, mas não valida 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 tipos de recurso a seguir. Por exemplo, URL:

    • App Engine: aplicativos (módulos) do Google App Engine.
    • Balanceador de carga elástico: da AWS.
    • Instância: do Compute Engine ou do 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. Consulte os campos Caminho e Porta abaixo.
  4. Preencha as informações de conexão, dependendo do tipo de verificação e de recurso:

    • Aplica-se a (App Engine, balanceador de carga elástico ou instância): é possível aplicar a verificação de tempo de atividade a um único recurso ou a um grupo de recursos, como por exemplo "Todas as instâncias". Se você optar por um único recurso, escolha um dos listados no menu. Se estiver usando a API, preencha o recurso monitorado com os rótulos obrigatórios, conforme descrito na Lista de recursos monitorados.

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

    • Nome do host (todos, exceto App Engine): especifique o nome de 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 TCP ou HTTP e 443 para 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 aparecer em nenhum lugar na resposta.

      • Para verificações HTTP e HTTPS, esse campo aparece em Opções avançadas.
      • Na API, esse é o objeto ContentMatcher.
  5. Verificar a cada: 1, 5, 10 ou 15 minutos. Por exemplo, escolher 5 minutos fará com que haja uma tentativa de entrar em contato com o serviço uma vez a cada intervalo de 5 minutos em todos os locais geográficos. Usando os seis locais padrão e verificando a cada 5 minutos, o serviço recebe uma média de 1,2 solicitação 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. As configurações a seguir são opcionais e variam de acordo com o tipo de verificação:

  • Cabeçalho HTTP do host: preencha para verificar hosts virtuais. Esse campo não está disponível em verificações de TCP.

  • Porta: especifique um número de porta. Para verificações de TCP, esse campo aparece 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 ela é encontrada na resposta da verificação. Para verificações de TCP, esse campo aparece em Opções básicas.

  • Locais: selecione as regiões geográficas aplicáveis em que a verificação receberá solicitações. Escolha regiões suficientes para ter três locais ativos no mínimo. Ao criar 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 o valor padrão "Global". Para enviar solicitações de todos os locais nas regiões existentes, mas não de novos locais em novas regiões, escolha todas as regiões existentes, e não selecione "Global".

  • Cabeçalhos personalizados: forneça cabeçalhos personalizados e, se necessário, criptografe-os. A criptografia faz com que os valores dos cabeçalhos fiquem ocultos no formulário. Use a criptografia nos cabeçalhos relacionados à autenticação que você não quer exibir a outros membros da equipe. Esse campo não está disponível em verificações de TCP.

  • Tempo limite da verificação de integridade: especifique de 1 a 60 segundos. A verificação de tempo de atividade falhará se as verificações de integridade de mais de um local não conseguirem uma resposta dentro do período de tempo limite configurado. Se apenas uma verificação de integridade não receber resposta, a verificação de tempo de atividade não falhará.

  • Autenticação: forneça um único nome de usuário e/ou senha. Os valores fornecidos nesse campo são enviados como um cabeçalho de "Autorização". Ao definir valores, não configure um cabeçalho de "Autorização" separado. Se você 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 em verificações de TCP.

Testar verificação de tempo de atividade

Ao criar uma verificação de tempo de atividade no console do Stackdriver Monitoring, você tem a opção de testar a configuração antes de salvá-la.

Sucesso da 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 uma 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 você não tiver instalado um servidor da Web. Consulte o Guia de início rápido do Google 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 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 alertas

Para receber notificações sobre falhas de tempo de atividade, crie uma política de alertas para a nova verificação. Consulte Como programar alertas para verificações de tempo de atividade para ver os detalhes.

Como listar verificações de tempo de atividade

Basta seguir estas etapas:

Console

Na página Uptime Checks Overview, você encontra uma lista de verificações, possivelmente dividida em várias páginas.

Digite o texto no campo Filter para limitar a lista a verificações com esse texto nos títulos. Também é possível usar o botão à esquerda do campo Filter para filtrar os membros de um grupo específico.

Clique em uma das verificações 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 é mostrado 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
  return config
end

Como editar verificações de tempo de atividade

Basta fazer o seguinte:

Console

  1. Na Visão geral das verificações de tempo de atividade, clique em Editar no menu ao lado direito do resumo da verificação.

    Como alternativa, no painel da verificação, escolha Editar verificação de tempo de atividade no menu no canto superior direito da página.

  2. Altere os campos conforme necessário.

    Nem todos os campos podem ser modificados. Os valores deles são exibidos em caixas cinza no console e não podem ser alterados. Se os valores de cabeçalho personalizados de uma verificação estiverem ocultos, não é possível torná-los visíveis.

  3. Clique em Test para confirmar se a verificação funciona. Se o teste falhar, consulte as possíveis causas em Falhas na verificação.

  4. 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 é mostrado 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 alterados. Por 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 existente. 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 estiver definido, a configuração no corpo da solicitação substituirá toda a configuração existente.

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: []}
  if not new_display_name.to_s.empty? then
    field_mask[:paths].push('display_name')
    config[:display_name] = new_display_name
  end
  if not new_http_check_path.to_s.empty? then
    field_mask[:paths].push('http_check.path')
    config[:http_check] = {path: new_http_check_path }
  end
  client.update_uptime_check_config(config, update_mask:field_mask)
end

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

Na Visão geral das verificações de tempo de atividade, selecione Excluir no menu ao lado direito da verificação.

Como alternativa, na página de detalhes da verificação, escolha Excluir verificação de tempo de atividade no menu do canto superior direito da página.

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