Esta página foi traduzida pela API Cloud Translation.

Criar verificações de tempo de atividade públicas

Este documento descreve como criar uma verificação de tempo de atividade pública. Uma verificação de disponibilidade pública pode emitir solicitações de vários locais em todo o mundo para URLs disponíveis publicamente ou recursos do Google Cloud para saber se o recurso responde. Para saber como criar verificações de tempo de atividade para redes particulares, consulte Criar verificações de tempo de atividade privadas.

As verificações de tempo de atividade público podem determinar a disponibilidade dos seguintes recursos monitorados:

Encontre links para informações sobre como gerenciar e monitorar suas verificações de tempo de atividade: consulte a seção Próximas etapas deste documento.

Sobre as verificações de tempo de atividade

Para HTTP e HTTPS, todos os redirecionamentos de URL são seguidos e a resposta final recebida pela verificação de tempo de atividade é usada para avaliar todos os critérios de sucesso. Para verificações HTTPS, o prazo de validade do certificado SSL é calculado com base no certificado do servidor recebido na resposta final.

Para que uma verificação de tempo de atividade seja bem-sucedida, as seguintes condições precisam ser atendidas:

O status HTTP precisa corresponder aos critérios especificados.
Os dados da resposta não podem ter conteúdo obrigatório, ou o conteúdo obrigatório precisa estar presente.

As verificações de tempo de atividade não carregam recursos da página nem executam JavaScript, e a configuração padrão de uma verificação de tempo de atividade não inclui autenticação.

Antes de começar

Para ter as permissões necessárias para criar verificações de tempo de atividade, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:
- Editor do Monitoring (roles/monitoring.editor): usuários do console do Google Cloud
- Editor de configurações de verificação de tempo de atividade do Monitoring (roles/monitoring.uptimeCheckConfigEditor): usuários da API
- Editor de políticas de alertas do Monitoring (roles/monitoring.alertPolicyEditor): usuários da API
- Editor do canal de notificação do Monitoring (roles/monitoring.notificationChannelEditor): usuários da API
Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias por meio de papéis personalizados ou de outros papéis predefinidos.
Confirme se o recurso que você quer verificar tem um endpoint público ou está atrás de um firewall configurável.

Para todas as outras configurações, você precisa criar uma verificação de tempo de atividade particular. Para mais informações, consulte Criar verificações de tempo de atividade privadas.
Quando o recurso estiver protegido por um firewall, configure esse firewall para permitir o tráfego de entrada dos endereços IP dos servidores de verificação de tempo de atividade. Para mais informações, consulte Listar endereços IP do servidor de verificação de tempo de atividade.
Configure os canais de notificação que você quer usar para receber notificações. Recomendamos que você crie vários tipos de canais de notificação. Para mais informações, consulte Criar e gerenciar canais de notificação.
Identifique pelo menos três verificadores para a verificação de tempo de atividade. A região de verificação de tempo de atividade USA inclui USA_OREGON, USA_IOWA e USA_VIRGINIA regiões. Cada um dos USA_* tem um verificador, e USA inclui todos os três. As outras regiões de verificação de tempo de atividade, EUROPE, SOUTH_AMERICA e ASIA_PACIFIC, cada uma com um verificador.

Se você selecionar Global ao usar o Console do Google Cloud ou REGION_UNSPECIFIED ao usar a API, as verificações de tempo de atividade serão emitidas em todas as regiões de verificação de tempo de atividade.

Crie uma verificação de tempo de atividade

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

Para criar uma verificação de tempo de atividade para um balanceador de carga externo que tenha pelo menos uma porta TCP ou HTTP/s configurada, siga estas instruções. Como alternativa, acesse a página Detalhes do serviço do serviço e clique em Criar verificação de disponibilidade. Quando você começa na página Detalhes do serviço, os campos específicos do serviço são preenchidos automaticamente.

Console

Para criar uma verificação de tempo de atividade usando o console do Google Cloud, faça o seguinte:

No console do Google Cloud, acesse a página Verificações de tempo de atividade:
Acesse Verificações de tempo de atividade

Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoramento.
Clique em Criar verificação de tempo de atividade.
Especifique o destino da verificação de tempo de atividade:
1. Selecione o protocolo. Você pode selecionar HTTP, HTTPS ou 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.
  - Serviço LoadBalancer do Kubernetes: serviço do tipo LoadBalancer do Kubernetes.
  - Instance: do Compute Engine ou AWS EC2.
  - App Engine: aplicativos do App Engine (módulos).
  - Balanceador de carga elástico: da AWS.
  Observação :não selecione IP interno porque esse tipo de recurso não pode ser um destino de uma verificação de tempo de atividade pública.
3. Insira os campos específicos do protocolo:
  - Para verificações de TCP, digite a porta.
  - Para verificações HTTP e HTTPS, insira um caminho no seu host ou 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/.
    
    Por exemplo, para emitir uma verificação de tempo de atividade para o recurso de URL example.com/tester, defina o campo Nome do host como example.com e o campo Caminho como /tester.
    
    Suponha que você tenha implantado um servidor no App Engine com um agente compatível com / e /hello. Para emitir a verificação de tempo de atividade para o gerenciador "/", deixe o campo Caminho vazio. Para emitir o verificação de tempo de atividade para o gerenciador /hello, defina o valor do Caminho para /hello.
4. Insira os campos específicos do recurso:
  - Para recursos URL, insira o nome do host no campo Nome do host. Por exemplo, insira example.com.
    
    Observação: crie verificações em URLs diretos quando possível.
  - Para recursos do App Engine, insira o nome do serviço no campo Serviço.
  - Para os recursos Elastic Load Balancer e Instance, conclua as no campo Aplica-se a da seguinte forma:
    - Para emitir uma verificação de tempo de atividade para uma única instância ou balanceador de carga, selecione Único e use o 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, selecione Group e use o menu para selecionar o nome do grupo.
5. Opcional: para definir a frequência de execução da verificação de tempo de atividade, use o método Verificar frequência.
6. Opcional: para selecionar as regiões do verificador ou configurar o SSL certificados, autenticação, cabeçalhos e portas para HTTP e HTTPS verificações, clique em Mais opções de segmentação:
  - 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.
  - Pings ICMP: configurar a verificação de tempo de atividade para enviar até três pings. Para mais informações, consulte Usar pings ICMP.
  - Método da solicitação: para verificações HTTP, selecione o método da solicitação.
  - Corpo: para verificações HTTP POST, insira o corpo codificado do URL. Você precisa fazer a codificação. Para todas as outras verificações, deixe este campo em branco.
  - Cabeçalho do host: preencha este campo para verificar hosts virtuais. Esse campo 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. A criptografia oculta os valores do cabeçalho no formulário. Use a criptografia para cabeçalhos relacionados à autenticação que você não quer que outras pessoas vejam.
  - Autenticação: esses valores são enviados como um cabeçalho de autorização. Esse campo não está disponível para verificações TCP.
    
    Observação :não defina os campos de Autenticação ao enviar e Cabeçalho de autorização. Se você definir os campos de Autenticação e enviar um cabeçalho de autorização, depois um erro Invalid Argument ocorrer.
    
    Escolha entre as opções a seguir:
    - Autenticação básica: forneça um único nome de usuário e senha. As senhas sempre estarão ocultas no formulário.
    - Autenticação do agente de serviço: quando ativada, um token de identidade é gerado para o agente de serviço de monitoramento. Essa opção está disponível apenas para verificações HTTPS.
  - Validação do certificado SSL: se você selecionou HTTPS para um URL recurso, por padrão, o serviço tenta se conectar por HTTPS e validar o certificado SSL. As verificações de tempo de atividade falham quando um URL tem um certificado inválido. Os motivos para um certificado inválido incluem:
    - Um certificado expirado
    - Um certificado autoassinado
    - Um certificado com uma incompatibilidade de nome de domínio
    - Um certificado que usa o Authority Information Access (AIA) .
    Observação: uma certificação SSL revogada não é considerada inválida.
    
    Para forçar uma verificação de tempo de atividade HTTPS a fim de validar o certificado SSL, selecione Validar certificados SSL.
    
    Para desativar a validação do certificado SSL, limpe Valide certificados SSL.
    
    Se você tem certificados SSL Extensões AIA, desative 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 uma política de alertas que notifique você antes que certificado expirar. 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.
Clique em Continuar e configure os requisitos de resposta. Todas as configurações nesta seção têm valores padrão:
- Para alterar o tempo limite da verificação de tempo de atividade, use o Tempo limite de resposta. Uma verificação de tempo de atividade falha quando nenhuma resposta é recebida de mais de um local dentro desse período.
  
  Observação :se você criar verificações em URLs de redirecionamento, aumente o Tempo limite de resposta como 30 segundos ou mais.
- Para configurar a verificação de tempo de atividade para realizar a correspondência de conteúdo, verifique se o rótulo de alternância é 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, suponha que o conteúdo da resposta seja abcd e o tipo de correspondência de conteúdo seja Contains. A verificação de tempo de atividade só é bem-sucedida quando os dados da resposta contêm abcd. Para mais informações, consulte Validar os dados de resposta.
  - Digite o Conteúdo da resposta. O conteúdo da resposta precisa ser uma string não pode ter mais de 1.024 bytes. Na API, esse campo é o objeto ContentMatcher.
  Observação: ative a correspondência de conteúdo de resposta ao selecionar o protocolo TCP.
- Para impedir que as entradas de registro sejam criadas devido a verificações de tempo de atividade, limpe Falhas de registro de verificação.
- Para as verificações de tempo de atividade HTTP, configure os códigos de resposta aceitáveis. Por padrão, as verificações de tempo de atividade HTTP 2xx como uma resposta bem-sucedida.
Clique em Continuar e configure as notificações.

Para receber uma notificação quando uma verificação de tempo de atividade falhar, crie uma política de alertas e configure canais de notificação relacionados a essa política:
1. Opcional: atualize o nome da política de alertas.
2. Opcional: no campo Duração, selecione a duração das verificações de tempo de atividade. devem falhar antes do envio das notificações. Por padrão, as notificações são enviado quando pelo menos duas regiões relatam falhas na verificação de tempo de atividade para um duração mínima de um minuto.
3. Na caixa Canais de notificação, clique em Menu, selecione os canais a serem adicionados e clique em OK.
  
  No menu, os canais de notificação são agrupados em ordem alfabética para cada tipo de canal.
Se você não quiser criar uma política de alertas, verifique se o texto do botão de alternância é Não criar um alerta.
Clique em Continuar e conclua a verificação de tempo de atividade:
1. Digite um título descritivo para a verificação de tempo de atividade.
2. Opcional: para adicionar rótulos definidos pelo usuário à verificação de tempo de atividade, faça o seguinte:
  1. Clique em Mostrar rótulos de usuário.
  2. No campo Chave, insira um nome para o rótulo. Os nomes dos rótulos precisam começar com uma letra minúscula e podem conter letras minúsculas, números, sublinhados e traços. Por exemplo, insira severity.
  3. No campo Valor, insira um valor para o rótulo. Valores de rótulo pode conter letras minúsculas, numerais, sublinhados e traços. Por exemplo, insira critical.
  4. Para cada rótulo adicional, clique em Adicionar rótulo do usuário e insira a chave e o valor do rótulo.
3. Para verificar a configuração da verificação de tempo de atividade, clique em Test. Se o resultado não for o esperado, consulte Verificar falhas, corrija a configuração e repita a etapa de verificação.
4. Clique em Criar. Se você selecionar Criar e um campo obrigatório não for preenchida, uma mensagem de erro será exibida.

gcloud

Para criar a verificação de tempo de atividade, execute o comando gcloud monitoring uptime create:

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

Antes de executar o comando anterior, faça o seguinte:

Substitua DISPLAY_NAME pelo nome da verificação de tempo de atividade.
Configure o REQUIRED_FLAGS para especificar o recurso analisado pela verificação de tempo de atividade. Por exemplo, o comando a seguir cria uma verificação de tempo de atividade que testa o URL EXAMPLE.com para um um projeto específico:
```
gcloud monitoring uptime create DISPLAY_NAME \
--resource-labels=host=EXAMPLE.com,project_id=PROJECT_ID \
--resource-type=uptime-url
```
O comando anterior especifica valores para cada rótulo exigido pelo tipo de recurso uptime-url.

Observação: no comando anterior, defina o campo resource-type como uptime-url, não use uptime_url. Os comandos da CLI do Google Cloud seguem as mesmas convenções de nomenclatura do Cloud Monitoring. Para acessar uma lista de valores válidos para o campo resource-type, consulte a Documentação do gcloud monitoring uptime create.
Configure as flags OPTIONAL_FLAGS para substituir os valores padrão. Por exemplo, é necessário definir a flag --protocol quando o protocolo não for http.

API

Para criar uma verificação de tempo de atividade, 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 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, conclua o contentType (opcional) customContentType 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#

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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.getName());
  } catch (Exception e) {
    usage("Exception creating uptime check: " + e.toString());
    throw e;
  }
}

Go

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


// 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: %w", 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: %w", 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: %w", 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: %w", err)
	}
	fmt.Fprintf(w, "Successfully created POST uptime check %q\n", config.GetDisplayName())
	return config, nil
}

Node.js

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

use Google\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\Client\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\CreateUptimeCheckConfigRequest;
use Google\Cloud\Monitoring\V3\UptimeCheckConfig;

/**
 * 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')
{
    $projectName = 'projects/' . $projectId;
    $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);
    $createUptimeCheckConfigRequest = (new CreateUptimeCheckConfigRequest())
        ->setParent($projectName)
        ->setUptimeCheckConfig($uptimeCheckConfig);

    $uptimeCheckConfig = $uptimeCheckClient->createUptimeCheckConfig($createUptimeCheckConfigRequest);

    printf('Created an uptime check: %s' . PHP_EOL, $uptimeCheckConfig->getName());
}

Python

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def create_uptime_check_config_get(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    config = monitoring_v3.UptimeCheckConfig()
    config.display_name = display_name or "New GET uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"},
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.GET,
        "path": "/",
        "port": 80,
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(
        request={"parent": project_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config


def create_uptime_check_config_post(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    config = monitoring_v3.UptimeCheckConfig()
    config.display_name = display_name or "New POST uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"},
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.POST,
        "content_type": monitoring_v3.UptimeCheckConfig.HttpCheck.ContentType.URL_ENCODED,
        "body": "foo=bar".encode("utf-8"),
        "path": "/",
        "port": 80,
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(
        request={"parent": project_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config

Ruby

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Terraform

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform. Para mais informações, consulte a documentação de referência do provedor Terraform.

Para criar uma verificação de tempo de atividade e uma política de alertas para monitorar essa verificação, faça o seguinte:

Edite o arquivo de configuração do Terraform e adicione um recurso google_monitoring_uptime_check_config. Em seguida, aplique o arquivo de configuração.

O exemplo a seguir ilustra uma configuração que verifica URL público:

resource "google_monitoring_uptime_check_config" "example" {
    display_name = "example"
    timeout      = "60s"

    http_check {
        port = "80"
        request_method = "GET"
    }

    monitored_resource {
        type = "uptime_url"
        labels = {
            project_id = "PROJECT_ID"
            host="EXAMPLE.com"
        }
    }

    checker_type = "STATIC_IP_CHECKERS"
}

Opcional: crie um canal de notificação e uma política de alertas:

As etapas a seguir usam o console do Google Cloud para criar o canal de notificação e a política de alertas. Essa abordagem garante que a política de alertas monitore apenas os dados gerados pela verificação de tempo de atividade.
1. Para criar um canal de notificação, faça o seguinte:
  1. No console do Google Cloud, acesse a página Alertas:
    Acessar Alertas
    
    Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoramento.
  2. Selecione Gerenciar canais de notificação.
  3. Acesse o tipo de canal que você quer adicionar, clique em Adicionar e preencha a caixa de diálogo.
2. Para criar uma política de alertas, siga estas etapas:
  1. No console do Google Cloud, acesse a página Verificações de tempo de atividade:
    Acesse Verificações de tempo de atividade
    
    Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoramento.
  2. Localize a verificação de tempo de atividade, selecione Mais e Adicionar política de alerta.
  3. Na caixa de diálogo, acesse a seção Notifications and name, expanda Notification Channels e faça suas seleções.
  4. Nomeie a política de alertas e clique em Criar política.
Para criar uma política de alertas, adicione um recurso google_monitoring_alert_policy ao arquivo de configuração e aplique a nova configuração.

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

Usar pings ICMP

Para ajudar a resolver problemas de falhas nas verificações de tempo de atividade público, é possível configurar as verificações de tempo de atividade para enviar até três pings ICMP durante a verificação. Os pings podem ajudar a distinguir entre falhas causadas, por exemplo, por problemas de conectividade de rede e tempos limite no aplicativo.

Por padrão, as verificações de tempo de atividade não enviam pings. Cada ping adiciona uma latente à verificação de tempo de atividade. As verificações de tempo de atividade particulares não enviam pings.

Quando uma verificação de tempo de atividade pública falha, os resultados dos pings são gravados em registros do Cloud Logging. Se o ping falhar, os campos a seguir serão adicionados ao campo httpRequest na entrada de registro:

rtt_usec: tempo de retorno para cada solicitação de ping com falha.
unreachable_count: número de solicitações de ping que retornaram o código de status ICMP_DEST_UNREACH.
no_answer_count: número de solicitações de pinging que expiraram e não retornaram nenhuma resposta.

Os resultados dos pings para verificações de tempo de atividade bem-sucedidas não são registrados.

Configurar pings

Cada configuração de verificação de tempo de atividade inclui um objeto HttpCheck ou um objeto TcpCheck. Ambos os objetos incluem um campo pingConfig. Use este campo para especificar o número de pings ICMP a serem incluídos em cada verificação, até três. Por padrão, nenhum ping é enviado.

Para configurar pings, faça o seguinte:

Ao usar o console do Google Cloud, abra Mais opções de destino e insira um valor no campo ICMP Pings.
Ao usar a API Cloud Monitoring, use o objeto PingConfig, que tem a seguinte estrutura:
```
{
  "pingsCount": integer
}
```
Para mais informações sobre como usar a API Monitoring para de verificação de tempo de atividade, consulte Criar uma verificação de tempo de atividade: API ou Editar uma verificação de tempo de atividade: API.

Testar verificação de tempo de atividade

Ao criar uma verificação de tempo de atividade no console do Google Cloud, teste a configuração antes de salvá-la.

Verificações concluídas

Uma verificação de tempo de atividade é bem-sucedida quando as seguintes condições são verdadeiras:

O status HTTP corresponde aos critérios selecionados.
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.

Verificações com falha

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. Um erro de conexão 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 Compute Engine. Se você usa um tipo de conexão HTTPS, talvez tenha que executar mais algumas etapas de configuração. Para problemas de firewall, consulte Listar endereços IP do servidor de verificação de tempo de atividade.
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 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 Não encontrado: 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 Listar endereços IP do servidor de verificação de tempo de atividade. O tempo limite é especificado como parte das opções de Validação de resposta.

Um tempo limite de solicitação pode ocorrer devido ao congestionamento da rede. Por exemplo, devido devido a congestionamento temporário da rede, um verificador falha, mas todos os outros são bem-sucedidos. A falha de um único verificador não gera uma notificação quando a política de alerta usa a configuração padrão.

Se a verificação de tempo de atividade estiver configurada para enviar pings, os resultados dos pings para verificações de tempo de atividade com falha serão gravados no Cloud Logging. Para mais informações, consulte Usar pings ICMP.

Criar verificações de tempo de atividade públicas

Sobre as verificações de tempo de atividade

Antes de começar

Crie uma verificação de tempo de atividade

Console

gcloud

API

C#

Java

Go

Node.js

PHP

Python

Ruby

Terraform

Usar pings ICMP

Configurar pings

Testar verificação de tempo de atividade

Verificações concluídas

Verificações com falha

A seguir