Crie 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 pública do tempo de atividade pode emitir pedidos de várias localizações em todo o mundo para URLs ou recursos disponíveis publicamente para ver se o recurso responde. Google Cloud Para obter informações sobre como criar verificações de tempo de atividade para redes privadas, consulte o artigo Crie verificações de tempo de atividade privadas.

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

• URL de verificação do tempo de atividade
• Instância de VM
• Aplicação do App Engine
• Serviço do Kubernetes
• Instância do Amazon Elastic Compute Cloud (EC2)
• Amazon Elastic load balancer
• Revisão do Cloud Run

Para ver links para informações sobre a gestão e a monitorização das verificações de tempo de atividade, consulte a secção O que fazer a seguir deste documento.

Esta funcionalidade só é suportada para projetos do Google Cloud . Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas.

Acerca das 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 os critérios de êxito. Para as verificações HTTPS, o tempo de expiração 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, têm de ser cumpridas as seguintes condições:

• O estado HTTP tem de corresponder aos critérios especificados.
• Os dados de resposta não têm conteúdo obrigatório ou o conteúdo obrigatório está presente.

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

Antes de começar

Conclua os seguintes passos no Google Cloud projeto que vai armazenar a verificação de tempo de atividade:

1. Para receber as autorizações de que precisa para criar verificações de tempo de atividade, peça ao seu administrador que lhe conceda as seguintes funções de IAM no seu projeto:

   • Editor de monitorização (roles/monitoring.editor) – Google Cloud utilizadores da consola
   • Editor de configurações de verificação de tempo de atividade da monitorização (roles/monitoring.uptimeCheckConfigEditor) – Utilizadores da API
   • Editor de AlertPolicy de monitorização (roles/monitoring.alertPolicyEditor) – Utilizadores da API
   • Monitorização do editor de NotificationChannel (roles/monitoring.notificationChannelEditor) – Utilizadores da API

   Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

   Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

2. Verifique se o recurso que quer verificar tem um ponto final público ou está protegido por uma firewall configurável.

   Para todas as outras configurações, tem de criar uma verificação do tempo de atividade privada. Para mais informações, consulte o artigo Crie verificações de tempo de atividade privadas.

3. Quando o seu recurso está protegido por uma firewall, configure essa 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 o artigo Liste os endereços IP do servidor de verificação de tempo de atividade.

4. Configure os canais de notificação que quer usar para receber notificações. Recomendamos que crie vários tipos de canais de notificação. Para mais informações, consulte o artigo Crie e faça a gestão de canais de notificação.

5. Identifique, pelo menos, três verificadores para a sua verificação de tempo de atividade. A região de verificação de tempo de atividade USA inclui as regiões USA_OREGON, USA_IOWA e USA_VIRGINIA. Cada uma das USA_* regiões tem um verificador e USA inclui os três. As outras regiões de verificação do tempo de atividade, EUROPE, SOUTH_AMERICA e ASIA_PACIFIC, têm cada uma um verificador.

   Se selecionar Global quando usar a Google Cloud consola ou selecionar REGION_UNSPECIFIED quando usar a API, as verificações de tempo de atividade são emitidas a partir de todas as regiões de verificação de tempo de atividade.

6. Select the tab for how you plan to use the samples on this page:

   Console

   When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

   gcloud

   In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

   Terraform

   Para usar os exemplos do Terraform nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   C#

   Para usar os .NET exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   Go

   Para usar os Go exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   Java

   Para usar os Java exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   Node.js

   Para usar os Node.js exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   PHP

   Para usar os PHP exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   Python

   Para usar os Python exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   Ruby

   Para usar os Ruby exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.

   REST

   Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.

   Instale a CLI Google Cloud.

   Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

   Para mais informações, consulte o artigo Autenticar para usar REST na Google Cloud documentação de autenticação.

   Crie uma verificação de tempo de atividade

   Esta secção explica 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, pode seguir estas instruções. Em alternativa, aceda à página Detalhes do serviço para o serviço e, de seguida, clique em Criar verificação de tempo de atividade. Quando começa na página Detalhes do serviço, os campos específicos do serviço são pré-preenchidos.

   Nota: todas as verificações de tempo de atividade usam pedidos HTTP GET ou POST ou pedidos TCP.

   Consola

   Para criar uma verificação de tempo de atividade através da Google Cloud consola, faça o seguinte:

   1. Na Google Cloud consola, aceda à página  Verificações de tempo de atividade:

      Aceda a Verificações de tempo de atividade

      Se usar a barra de pesquisa para encontrar esta página, selecione o resultado cujo subtítulo é Monitorização.

   2. Na barra de ferramentas da Google Cloud consola, selecione o seu Google Cloud projeto. Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas.

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

      

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

      1. Selecione o protocolo. Pode selecionar HTTP, HTTPS ou TCP.

      2. Escolha um dos seguintes tipos de recursos:

         • URL: qualquer endereço IPv4 ou nome de anfitrião. O caminho e a porta são introduzidos separadamente.
         • Serviço LoadBalancer do Kubernetes: serviço do Kubernetes do tipo LoadBalancer.
         • Instância: instâncias do Compute Engine ou do AWS EC2.
         • App Engine: aplicações (módulos) do App Engine.
         • Elastic Load Balancer: balanceador de carga da AWS.
         Nota: não selecione IP interno, uma vez que este tipo de recurso não pode ser um alvo de uma verificação de tempo de atividade pública.

      3. Introduza os campos específicos do protocolo:

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

         • Para verificações HTTP e HTTPS, pode introduzir um caminho no seu anfitrião ou recurso. Todas as verificações de tempo de atividade que usam estes protocolos enviam um pedido para http://target/path. Nesta expressão, para um recurso de URL, target é um nome de anfitrião ou um endereço IP. Para um recurso do App Engine, target é um nome de anfitrião derivado do nome do serviço. Para recursos de instâncias e equilibradores de carga, target é um endereço IP derivado do nome que forneceu para o recurso ou o grupo de recursos.

           Se deixar o campo path em branco ou definir o valor como /, o pedido é emitido para 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 anfitrião como example.com e o campo Caminho como /tester.

           Suponhamos que implementou um servidor no App Engine com um distribuidor que suporta / e /hello. Para emitir a verificação de tempo de atividade para o controlador "/", deixe o campo Caminho vazio. Para emitir a verificação de tempo de atividade para o controlador /hello, defina o valor do campo Caminho como /hello.

      4. Introduza os campos específicos do recurso:

         • Para recursos de URL, introduza o nome do anfitrião no campo Nome do anfitrião. Por exemplo, introduza example.com.

           Nota: crie verificações em relação a URLs diretos sempre que possível.

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

         • Para recursos do Elastic Load Balancer e da instância, preencha o campo Aplica-se a da seguinte forma:

           • Para emitir uma verificação de tempo de atividade para uma única instância ou um balanceador de carga, selecione Único e, em seguida, 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 de monitorização, selecione Grupo e, de seguida, use o menu para selecionar o nome do grupo.

      5. Opcional: para definir a frequência com que a verificação de tempo de atividade é executada, use o campo Frequência de verificação.

      6. Opcional: para selecionar regiões de verificação 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 onde as verificações de tempo de atividade devem receber pedidos. Uma verificação de tempo de atividade tem de ter, pelo menos, três verificadores. Existe um verificador em todas as regiões, exceto nos Estados Unidos, que tem três verificadores. A predefinição, Global, inclui todas as regiões.
         • Pings ICMP: configure a verificação de tempo de atividade para enviar até três pings. Para mais informações, consulte o artigo Use pings ICMP.
         • Método de pedido: para verificações HTTP, selecione o método de pedido.
         • Corpo: para verificações HTTP POST, introduza o corpo codificado do URL. Tem de fazer a codificação manualmente. Para todas as outras verificações, deixe este campo em branco.
         • Cabeçalho do anfitrião: preencha este campo para verificar anfitriões virtuais. Este campo não está disponível para verificações de TCP.
         • Porta: especifique um número de porta.
         • Cabeçalhos personalizados: forneça cabeçalhos personalizados e encripte-os, se quiser. A encriptação oculta os valores do cabeçalho no formulário. Use a encriptação para cabeçalhos relacionados com a autenticação que não quer que sejam visíveis para outras pessoas.

         • Autenticação: estes valores são enviados como um cabeçalho de autorização. Este campo não está disponível para verificações de TCP.

           Nota: não defina os campos Authentication quando enviar um cabeçalho Authorization. Se definir os campos Authentication e enviar um cabeçalho de autorização, ocorre um erro Invalid Argument.

           Escolha uma das opções seguintes:

           • Autenticação básica: forneça um único nome de utilizador e palavra-passe. As palavras-passe estão sempre ocultas no formulário.
           • Autenticação do agente do serviço: quando ativada, é gerado um token de identidade para o agente do serviço de monitorização. Esta opção só está disponível para verificações HTTPS.

         • Validação do certificado SSL: se selecionou HTTPS para um recurso de URL, por predefinição, o serviço tenta estabelecer ligação através de HTTPS e validar o certificado SSL. As verificações de tempo de atividade falham quando um URL tem um certificado inválido. Seguem-se alguns motivos para um certificado inválido:

           • Um certificado expirado
           • Um certificado autoassinado
           • Um certificado com uma não correspondência do nome de domínio
           • Um certificado que usa a extensão Authority Information Access (AIA).
           Nota: uma certificação SSL revogada não é considerada inválida.

           Para forçar uma verificação de tempo de atividade HTTPS para validar o certificado SSL, selecione Validar certificados SSL.

           Para desativar a validação de certificados SSL, desmarque a opção Validar certificados SSL.

           Se tiver certificados SSL com extensões AIA, tem de desativar a validação do certificado SSL. Estes tipos de certificados não são suportados e falham a sequência de validação. Normalmente, a mensagem de erro é "Responded with SSL handshake Error in 10000 ms" (Resposta com erro de estabelecimento de ligação SSL em 10 000 ms).

           Pode usar a métrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires para criar uma política de alerta que lhe envia uma notificação antes de o certificado expirar. Para mais informações, consulte o artigo Políticas de exemplo: política de verificação de tempo de atividade.

           Selecione a caixa de verificação Validar certificados SSL.

   5. Clique em Continuar e configure os requisitos de resposta. Todas as definições nesta secção têm valores predefinidos:

      • Para alterar o período de limite de tempo da verificação de tempo de atividade, use o campo Limite de tempo de resposta. Uma verificação de tempo de atividade falha quando não é recebida nenhuma resposta de mais de uma localização durante este período.

        Nota: se criar verificações em relação aos URLs de redirecionamento, aumente o Limite de tempo de resposta para 30 segundos ou mais.

      • Para configurar a verificação de tempo de atividade para realizar a correspondência de conteúdo, certifique-se de que a etiqueta do botão está A correspondência de conteúdo está ativada:

        • Selecione o Tipo de correspondência do conteúdo da resposta no menu de opções. Este campo determina como o conteúdo da resposta é comparado com os dados devolvidos. Por exemplo, suponha que o conteúdo da resposta é abcd e o tipo de correspondência de conteúdo é Contém. A verificação do tempo de atividade só é bem-sucedida quando os dados de resposta contêm abcd. Para mais informações, consulte o artigo Valide os dados de respostas.
        • Introduza o Conteúdo da resposta. O conteúdo da resposta tem de ser uma string com um tamanho não superior a 1024 bytes. Na API, este campo é o objeto ContentMatcher.
        Nota: ative a correspondência de conteúdo de resposta quando selecionar o protocolo TCP.

      • Para impedir a criação de entradas de registo devido a verificações de tempo de atividade, limpe as Falhas de verificação de registo.

      • Para as verificações de tempo de atividade HTTP, configure os códigos de resposta aceitáveis. Por predefinição, as verificações de tempo de atividade HTTP marcam qualquer resposta 2xx como uma resposta bem-sucedida.

   6. Clique em Continuar e configure as notificações.

      Para receber uma notificação quando uma verificação de tempo de atividade falha, crie uma política de alertas e configure canais de notificação para essa política:

      1. Opcional: atualize o nome da política de alerta.
      2. Opcional: no campo Duração, selecione durante quanto tempo as verificações de tempo de atividade têm de falhar antes de serem enviadas notificações. Por predefinição, as notificações são enviadas quando, pelo menos, duas regiões comunicam falhas na verificação de tempo de atividade durante, pelo menos, um minuto.

      3. Na caixa com a etiqueta Canais de notificação, clique em Menu, selecione os canais a adicionar e, de seguida, clique em OK.

         No menu, os canais de notificação estão agrupados por ordem alfabética para cada tipo de canal.

      Se não quiser criar uma política de alerta, certifique-se de que o texto do botão de ativação/desativação é Não criar um alerta.

   7. Clique em Continuar e conclua a verificação do tempo de atividade:

      1. Introduza um título descritivo para a verificação de tempo de atividade.

      2. Opcional: para adicionar etiquetas definidas pelo utilizador à verificação de tempo de atividade, faça o seguinte:

         1. Clique em Mostrar etiquetas do utilizador.
         2. No campo Chave, introduza um nome para a etiqueta. Os nomes das etiquetas têm de começar por uma letra minúscula e podem conter letras minúsculas, números, sublinhados e travessões. Por exemplo, introduza severity.
         3. No campo Valor, introduza um valor para a etiqueta. Os valores das etiquetas podem conter letras minúsculas, números, sublinhados e travessões. Por exemplo, introduza critical.
         4. Para cada etiqueta adicional, clique em Adicionar etiqueta do utilizador e, de seguida, introduza a chave e o valor da etiqueta.

      3. Para validar a configuração da verificação de tempo de atividade, clique em Testar. Se o resultado não for o esperado, consulte a secção Verificar falhas, corrija a configuração e, em seguida, repita o passo de validação.

      4. Clique em Criar. Se selecionar Criar e um campo obrigatório não estiver preenchido, é apresentada uma mensagem de erro.

   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 --project=PROJECT_ID
   

   Antes de executar o comando anterior, substitua o seguinte:

   • PROJECT_ID: o identificador do projeto. Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas.

   • DISPLAY_NAME: o nome da verificação de tempo de atividade.

   • REQUIRED_FLAGS: configure para especificar o recurso analisado pela verificação de tempo de atividade. Por exemplo, o seguinte comando cria uma verificação de tempo de atividade que testa o URL EXAMPLE.com para 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 etiqueta exigida pelo tipo de recurso uptime-url.

     Nota: no comando anterior, defina o campo resource-type como uptime-url. Não use uptime_url. Os comandos da CLI do Google Cloud não seguem as mesmas convenções de nomenclatura que o Cloud Monitoring. Para ver uma lista de valores válidos para o campo resource-type, consulte a documentação gcloud monitoring uptime create.

   • OPTIONAL_FLAGS: configure estas flags para substituir os valores predefinidos. Por exemplo, tem de definir a flag --protocol quando o protocolo não for http.

   Terraform

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

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

   1. Instale e configure o Terraform para o seu projeto. Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas.

   2. Edite o ficheiro de configuração do Terraform e adicione um recurso google_monitoring_uptime_check_config e, em seguida, aplique o ficheiro de configuração.

      O exemplo seguinte ilustra uma configuração que verifica um 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"
      }
      

      Na expressão anterior:

      • PROJECT_ID é o ID do seu projeto. Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas.
      • EXAMPLE.com é o URL do anfitrião.

   3. Opcional: crie um canal de notificação e uma política de alerta:

      Os passos seguintes usam a consola Google Cloud para criar o canal de notificação e a política de alertas. Esta abordagem garante que a política de alerta apenas monitoriza os dados gerados pela verificação de tempo de atividade.

      1. Para criar um canal de notificação, faça o seguinte:

         1. Na Google Cloud consola, aceda à página  Alertas:

            Aceder a Alertas

            Se usar a barra de pesquisa para encontrar esta página, selecione o resultado cujo subtítulo é Monitorização.

         2. Na barra de ferramentas da Google Cloud consola, selecione o seu Google Cloud projeto. Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas.
         3. Selecione Gerir canais de notificação.
         4. Aceda ao tipo de canal que quer adicionar, clique em Adicionar e, em seguida, conclua a caixa de diálogo.

      2. Para criar uma política de alertas, faça o seguinte:

         1. Na Google Cloud consola, aceda à página  Verificações de tempo de atividade:

            Aceda a Verificações de tempo de atividade

            Se usar a barra de pesquisa para encontrar esta página, selecione o resultado cujo subtítulo é Monitorização.

         2. Na barra de ferramentas da Google Cloud consola, selecione o seu Google Cloud projeto. Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas.
         3. Localize a verificação de tempo de atividade, selecione Mais> e, de seguida, selecione Adicionar política de alertas.
         4. Na caixa de diálogo, aceda à secção Notificações e nome, expanda Canais de notificação e faça as suas seleções.
         5. Dê um nome à política de alerta e, de seguida, clique em Criar política.

      Pode criar uma política de alerta adicionando um recurso google_monitoring_alert_policy ao ficheiro de configuração e aplicando a nova configuração.

   C#

   Para se autenticar no Monitoring, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 se autenticar no Monitoring, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 se autenticar no Monitoring, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 se autenticar no Monitoring, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 se autenticar no Monitoring, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 se autenticar no Monitoring, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 se autenticar no Monitoring, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

   gem "google-cloud-monitoring"
   require "google/cloud/monitoring"
   
   def create_uptime_check_config project_id: nil, host_name: nil, display_name: nil
     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

   REST

   Para criar uma verificação de tempo de atividade, chame o método projects.uptimeCheckConfigs.create. Defina os parâmetros do método da seguinte forma:

   • parent: obrigatório. O projeto no qual criar a verificação de tempo de atividade. Para configurações do App Hub, selecione o projeto anfitrião do App Hub ou o projeto de gestão da pasta com apps ativadas. Este campo tem o seguinte formato:

     projects/PROJECT_ID
     

   • O corpo do pedido tem de 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 este objeto e os respetivos campos, consulte UptimeCheckConfig:

     • Deixe o campo name do objeto de configuração em branco. O sistema define este campo quando cria o objeto de configuração de resposta.

     • Se estiver a configurar uma verificação HTTP ou HTTPS, tem de preencher o campo HttpCheck do objeto UptimeCheckConfig. Neste objeto, defina o campo requestMethod como GET ou POST. Se este campo for omitido ou definido como METHOD_UNSPECIFIED, é emitido um pedido GET.

       Se estiver a configurar um pedido POST, preencha os campos contentType, customContentType e body opcionais.

   O método create devolve o objeto UptimeCheckConfig para a nova configuração.

   Se a configuração de tempo de atividade criada não funcionar como esperado, consulte a secção Verificar falhas nesta página.

   Pode haver um atraso de até 5 minutos antes de os resultados da verificação de tempo de atividade começarem a fluir para a monitorização. Durante esse período, o painel de controlo da verificação de tempo de atividade indica o estado como "dados não disponíveis".

   Use pings ICMP

   Para ajudar a resolver problemas de verificações de tempo de atividade públicas com falhas, pode configurar as verificações de tempo de atividade para enviar até 3 pings ICMP durante a verificação. Os pings podem ajudar a distinguir entre falhas causadas, por exemplo, por problemas de conetividade de rede e por limites de tempo na sua aplicação.

   Por predefinição, as verificações de tempo de atividade não enviam pings. Cada ping adiciona alguma latência à verificação do 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 escritos nos registos do Cloud Logging. Se o ping falhar, os seguintes campos são adicionados ao campo httpRequest na entrada do registo:

   • rtt_usec: tempo de ida e volta para cada pedido de ping sem êxito.
   • unreachable_count: número de pedidos de ping que devolveram o código de estado ICMP_DEST_UNREACH.
   • no_answer_count: número de pedidos de ping que excederam o limite de tempo e não devolveram nenhuma resposta.

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

   Configure 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 incluir em cada verificação, até 3. Por predefinição, não são enviados pings.

   Para configurar os pings, faça uma das seguintes ações:

   • Quando usar a Google Cloud consola, expanda Mais opções de destino e introduza um valor no campo Pings ICMP.

   • Quando usar a API Cloud Monitoring, use o objeto PingConfig, que tem a seguinte estrutura:

     {
       "pingsCount": integer
     }
     

     Para mais informações sobre a utilização da API Monitoring para configurações de verificação de tempo de atividade, consulte os artigos Crie uma verificação de tempo de atividade: API ou Edite uma verificação de tempo de atividade: API.

   Valide a sua verificação de tempo de atividade

   Quando cria uma verificação de tempo de atividade na Google Cloud consola, pode testar a configuração antes de guardar.

   Verificações bem-sucedidas

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

   • O estado HTTP corresponde aos critérios que selecionou.
   • A resposta não tem conteúdo obrigatório ou uma pesquisa da resposta para o conteúdo obrigatório é bem-sucedida.

   Verificações falhadas

   Seguem-se algumas possíveis causas de uma falha na verificação do tempo de atividade:

   • Erro de ligação – Recusado: se estiver a usar o tipo de ligação HTTP predefinido, verifique se tem um servidor Web instalado que esteja a responder a pedidos HTTP. Pode ocorrer um erro de ligação numa nova instância se não tiver instalado um servidor Web. Consulte o início rápido do Compute Engine. Se usar um tipo de ligação HTTPS, pode ter de realizar passos de configuração adicionais. Para problemas de firewall, consulte o artigo Liste os endereços IP do servidor de verificação de tempo de atividade.
   • Nome ou serviço não encontrado: o nome do anfitrião pode estar incorreto.
   • 403 Forbidden: o serviço está a devolver um código de erro ao verificador de tempo de atividade. Por exemplo, a configuração predefinida do servidor Web Apache devolve este código no Amazon Linux, mas devolve o código 200 (êxito) noutras versões do Linux. Consulte o tutorial LAMP para o Amazon Linux ou a documentação do seu servidor Web.
   • 404 Não encontrado: o caminho pode estar incorreto.

   • 408 Pedido excedeu o limite de tempo ou sem resposta: o número da porta pode estar incorreto, o serviço pode não estar em execução, o serviço pode estar inacessível ou o limite de tempo pode ser demasiado baixo. Verifique se a sua firewall permite o tráfego dos servidores de tempo de atividade. Consulte o artigo Liste os endereços IP dos servidores de verificação de tempo de atividade. O limite de tempo limite é especificado como parte das opções de validação de respostas.

     Pode ocorrer um limite de tempo do pedido devido a congestionamento da rede. Por exemplo, devido a um congestionamento temporário da rede, pode reparar que um verificador falha, mas todos os outros são bem-sucedidos. A falha de um único verificador não causa uma notificação quando a sua política de alertas usa a configuração predefinida.

   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 falhas são escritos no Cloud Logging. Para mais informações, consulte o artigo Use pings ICMP.

   O que se segue?

   • Faça a gestão das verificações de tempo de atividade
   • Crie políticas de alerta para verificações de tempo de atividade
   • Liste os endereços IP do servidor de verificação de tempo de atividade
   • Crie gráficos de métricas de verificação de tempo de atividade
   Envie comentários