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

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Neste documento, descrevemos como criar uma verificação pública de tempo de atividade. Uma verificação pública de tempo de atividade pode emitir solicitações de vários locais ao redor do mundo para URLs disponíveis publicamente ou recursos do Google Cloud para ver se o recurso responde. Para informações sobre como criar verificações de tempo de atividade para redes privadas, consulte Criar verificações de tempo de atividade particulares.

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

Para ver links para informações sobre como gerenciar e monitorar as verificações de tempo de atividade, consulte a seção Próximas etapas deste documento.

Antes de começar

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

  • A verificação de tempo de atividade não carrega recursos da página nem executa JavaScript, e a configuração padrão de uma verificação de tempo de atividade não inclui autenticação.

    Para HTTP e HTTPS, 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 ter sucesso, estas condições devem ser atendidas:

    • O status HTTP é Success.
    • Os dados não podem ter conteúdo obrigatório, ou o conteúdo obrigatório precisa estar presente.
  • Ao criar uma verificação de tempo de atividade, você precisa especificar pelo menos três verificadores.

    A região de verificação de tempo de atividade USA tem três verificadores. As regiões de verificação de tempo de atividade EUROPE, SOUTH_AMERICA e ASIA_PACIFIC têm um verificador.

    Se você selecionar Global ao usar o console do Google Cloud ou selecionar REGION_UNSPECIFIED ao usar a API, as verificações de tempo de atividade serão emitidas de todas as regiões da 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.

Console

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

  1. No Console do Google Cloud, selecione Monitoring ou clique no seguinte botão:
    Acessar o Monitoring
  2. No painel de navegação, selecione Verificações de tempo de atividade.

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

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

  4. Digite um título descritivo para a verificação de tempo de atividade.

  5. Opcional: para adicionar rótulos definidos pelo usuário à sua verificação de tempo de atividade, faça o seguinte:

    1. Clique em Mais opções de metadados.
    2. Clique em Chave e digite um nome para o rótulo. Os nomes de rótulos precisam começar com uma letra minúscula e podem conter letras minúsculas, numerais, sublinhados e traços. Por exemplo, insira severity.
    3. Clique em Valor e insira um valor para o rótulo. Os valores de identificador podem conter letras minúsculas, numerais, sublinhados e traços. Por exemplo, insira critical.
    4. Para cada rótulo adicional, clique em Adicionar rótulo de usuário e insira o valor e a chave do rótulo.
  6. Clique em Próxima e especifique o destino da verificação de tempo de atividade:

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

    2. Escolha um dos seguintes tipos de recursos:

      • URL: qualquer nome de host ou endereço IPv4. O caminho e a porta são inseridos separadamente.
      • 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.
    3. Insira os campos específicos do protocolo:

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

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

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

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

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

    4. Insira os campos específicos do recurso:

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

      • Nos recursos de serviço LoadBalancer do Kubernetes, insira o nome do serviço no campo Serviço do Kubernetes.

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

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

        • Para emitir uma verificação de tempo de atividade para uma única instância ou balanceador de carga, no campo Aplicável a, selecione Única e use o menu para selecionar a instância ou o balanceador de carga específico.
        • Para emitir uma verificação de tempo de atividade para um grupo do Monitoring, no campo Aplica-se a, selecione Grupo e use o menu para selecionar o nome do grupo.
    5. Opcional: defina com que frequência a verificação de tempo de atividade é executada usando o campo Frequência de verificação.

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

      • Regiões: selecione as regiões em que as verificações de tempo de atividade devem receber solicitações. Uma verificação de tempo de atividade precisa ter pelo menos três verificadores. Há um verificador em todas as regiões, exceto nos Estados Unidos, que tem três verificadores. A configuração padrão, Global, inclui todas as regiões.
      • Método de solicitação: para verificações HTTP, selecione o método de solicitação.
      • Corpo: para verificações POST HTTP, insira o corpo codificado do URL. Você precisa fazer a codificação por conta própria. Para todas as outras verificações, deixe esse campo em branco.
      • General: preencha este campo para verificar hosts virtuais. Ele não está disponível para verificações TCP.
      • Port: especifique um número de porta.
      • Cabeçalhos personalizados: forneça cabeçalhos personalizados e criptografe-os, se desejar. Os valores dos cabeçalhos ficam ocultos nos formulários pela criptografia. Use a criptografia para cabeçalhos relacionados à autenticação que você não quer que outras pessoas vejam.

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

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

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

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

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

        É possível usar a métrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires para criar um alerta que notifique você antes que o certificado expire. Para mais informações, consulte Políticas de amostra: política de verificação de tempo de atividade.

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

    7. Clique em Próxima.

  7. Configure os requisitos de resposta:

    • Opcional: defina um tempo limite para a verificação de tempo de atividade usando o campo Tempo limite de resposta. Uma verificação de tempo de atividade falhará se nenhuma resposta for recebida de mais de um local nesse período.

    • Opcional: 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, se o conteúdo da resposta for abcd e o tipo de correspondência de conteúdo for Contém, a verificação de tempo de atividade será bem-sucedida se os dados da resposta contiverem abcd. A verificação de tempo de atividade falhará se a resposta não tiver abcd. Para mais informações, consulte Validar dados de resposta.
      • Digite o Conteúdo da resposta. Precisa ser uma string com até 1024 bytes. Na API, esse é o objeto ContentMatcher.
    • Opcional: para evitar entradas de registro devido a verificações de tempo de atividade, limpe as falhas na verificação de registro.

    • 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 marcam qualquer resposta 2xx como uma resposta bem-sucedida.

    • Clique em Próximo.

  8. Crie uma política de alertas. Quando uma política de alertas monitora sua verificação de tempo de atividade, se ela falha, um incidente é criado e uma notificação é enviada para todos os canais de notificação anexados à política. Por exemplo, se você adicionar um endereço de e-mail à política, um e-mail será enviado a esse endereço. É possível criar a política de alertas nesta etapa ou criar uma política de alertas depois que a verificação for criada.

    Recomendamos que você crie uma política de alertas para a verificação de tempo de atividade. No entanto, para pular esta etapa, verifique se o texto do botão de alternância é Do not create a alert. Clique no botão para mudar o estado.

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

    1. Verifique se o texto do botão de alternância é Criar um alerta. Clique no botão, se necessário.

    2. No campo de nome, insira um nome para a política de alertas ou use o nome padrão.

    3. Para adicionar um ou mais canais de notificação à política de alertas, na caixa de texto Canais de notificação, clique em Menu . Selecione os canais a serem adicionados e clique em OK. Os canais de notificação são agrupados em ordem alfabética para cada tipo de canal.

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

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

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

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

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

  9. Para verificar a configuração da verificação de tempo de atividade, clique em Test. Se o resultado não for o esperado, consulte Verificar falhas, corrija a configuração e repita a etapa de verificação.

  10. Clique em Criar. Uma mensagem de erro é exibida quando você salva uma verificação de tempo de atividade e um campo obrigatório não é preenchido. Depois de salvar as alterações, a caixa de diálogo Verificação de tempo de atividade criada será exibida.

API

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

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

    projects/PROJECT_ID
    
  • O corpo da solicitação precisa conter um objeto UptimeCheckConfig para a nova verificação de tempo de atividade. Esta página fornece informações sobre apenas alguns campos. Para ver a documentação completa sobre esse objeto e seus campos, consulte UptimeCheckConfig:

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

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

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

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

Se a configuração do tempo de atividade criada não funcionar como esperado, consulte a seção Falhas na verificação nesta página.

C#

public static object CreateUptimeCheck(string projectId, string hostName,
    string displayName)
{
    // Define a new config.
    var config = new UptimeCheckConfig()
    {
        DisplayName = displayName,
        MonitoredResource = new MonitoredResource()
        {
            Type = "uptime_url",
            Labels = { { "host", hostName } }
        },
        HttpCheck = new UptimeCheckConfig.Types.HttpCheck()
        {
            Path = "/",
            Port = 80,
        },
        Timeout = TimeSpan.FromSeconds(10).ToDuration(),
        Period = TimeSpan.FromMinutes(5).ToDuration()
    };
    // Create a client.
    var client = UptimeCheckServiceClient.Create();
    ProjectName projectName = new ProjectName(projectId);
    // Create the config.
    var newConfig = client.CreateUptimeCheckConfig(
        projectName,
        config,
        CallSettings.FromExpiration(
            Expiration.FromTimeout(
                TimeSpan.FromMinutes(2))));
    Console.WriteLine(newConfig.Name);
    return 0;
}

Java

private static void createUptimeCheck(
    String projectId, String displayName, String hostName, String pathName) throws IOException {
  CreateUptimeCheckConfigRequest request =
      CreateUptimeCheckConfigRequest.newBuilder()
          .setParent(ProjectName.format(projectId))
          .setUptimeCheckConfig(
              UptimeCheckConfig.newBuilder()
                  .setDisplayName(displayName)
                  .setMonitoredResource(
                      MonitoredResource.newBuilder()
                          .setType("uptime_url")
                          .putLabels("host", hostName))
                  .setHttpCheck(HttpCheck.newBuilder().setPath(pathName).setPort(80))
                  .setTimeout(Duration.newBuilder().setSeconds(10))
                  .setPeriod(Duration.newBuilder().setSeconds(300)))
          .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    UptimeCheckConfig config = client.createUptimeCheckConfig(request);
    System.out.println("Uptime check created: " + config.getName());
  } catch (Exception e) {
    usage("Exception creating uptime check: " + e.toString());
    throw e;
  }
}

Go


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

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

Node.js

// 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_get(project_name, host_name=None, display_name=None):
    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_name, "uptime_check_config": config})
    pprint.pprint(new_config)
    return new_config

def create_uptime_check_config_post(project_name, host_name=None, display_name=None):
    config = monitoring_v3.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_name, "uptime_check_config": config})
    pprint.pprint(new_config)
    return new_config

Ruby

def create_uptime_check_config project_id: nil, host_name: nil, display_name: nil
  require "google/cloud/monitoring"

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

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

Usar pings ICMP

Para ajudar a resolver problemas de verificações de tempo de atividade públicas com falha, é possível configurar essas verificações 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 por tempos limite no seu aplicativo.

Por padrão, as verificações de tempo de atividade não enviam pings. Cada ping adiciona alguma latência à verificação de tempo de atividade. As verificações de tempo de atividade privadas não podem enviar pings.

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

  • rtt_usec: tempo de retorno para cada solicitação de ping malsucedida.
  • 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 ping que expiraram e não retornaram resposta.

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

Configurar pings

Para configurar as verificações de tempo de atividade públicas e incluir pings, use a API Cloud Monitoring para criar configurações de verificação de tempo de atividade ou modificar as atuais. Não é possível configurar pings usando o console do Google Cloud.

Cada configuração de verificação de tempo de atividade inclui um objeto HttpCheck ou 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 definir o valor do campo pingConfig, use o objeto PingConfig, que tem a seguinte estrutura:

{
  "pingsCount": integer
}

Para mais informações sobre como usar a API Monitoring para configurações 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 a verificação de tempo de atividade

Ao criar uma verificação de tempo de atividade no console do Google Cloud, é possível testar a configuração antes de salvar.

Verificações concluídas

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

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

Falha nas verificações

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. 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 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 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 como parte das opções de Validação de resposta.

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 ver mais informações, consulte Usar pings ICMP.

A seguir