Filtros de integridade do processo

Neste guia, você verá como contar o número de processos em execução nas máquinas virtuais (VMs) que atendem às condições de filtro especificadas. É possível criar políticas e alertas de alertas que contam processos usando a API Cloud Monitoring ou o Console do Google Cloud.

Se tiver interesse em informações sobre processos em execução, por exemplo, você quer saber a utilização da CPU para processos específicos, consulte Métricas do processo.

A estrutura do filtro do Monitoring quando usada para contar processos é semelhante à usada quando você usa esses filtros para especificar tipos de métricas ou recursos monitorados. Para informações gerais, consulte Filtros do Monitoring.

Antes de começar

Se você não estiver familiarizado com métricas, séries temporais e recursos monitorados, consulte Métricas, séries temporais e recursos.

Processos monitorados

O Monitoring conta processos aplicando uma expressão regular à linha de comando que invocou o processo. Se um processo não tiver um campo de linha de comando disponível, esse processo não será contabilizado.

Uma maneira de determinar se um processo pode ser monitorado é visualizar a saída do comando ps do Linux:

    ps aux | grep nfs
    USER      PID  %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
    root      1598  0.0  0.0      0     0 ?        S<   Oct25   0:00 [nfsd4]
    root      1639  0.0  0.0      0     0 ?        S    Oct25   2:33 [nfsd]
    root      1640  0.0  0.0      0     0 ?        S    Oct25   2:36 [nfsd]

Quando uma entrada COMMAND é ajustada entre colchetes, por exemplo, [nfsd], as informações de linha de comando para o processo não estão disponíveis. Portanto, não é possível usar o Cloud Monitoring para monitorar o processo.

Estrutura do filtro de integridade do processo

Um filtro de integridade do processo identifica quais processos serão contados e um ou mais recursos cujos processos serão contados. Por exemplo, o JSON a seguir descreve uma política de alertas que envia uma notificação se o número de processos for menor que 30 em qualquer instância de VM do Compute Engine:

     {
        "displayName": "Count all processes",
        "conditionThreshold": {
          "aggregations": [],
          "comparison": "COMPARISON_LT",
          "duration": "0s",
          "filter": "select_process_count(\"*\") resource.type=\"gce_instance\"",
          "thresholdValue": 30,
          "trigger": {
            "count": 1
          }
        }
     }

Neste exemplo, o valor da instrução filter é uma string com duas cláusulas. A primeira cláusula, select_process_count(\"*\"), especifica que todos os processos são contados. A segunda cláusula, resource.type=\"gce_instance\", identifica que as VMs do Compute Engine precisam ser monitoradas.

Se você usar o Console do Cloud, use o modo de filtro direto para inserir o valor de um filtro do Monitoring. No entanto, não se esqueça de remover todos os escapes que protejam as substrings. Por exemplo, para contar todos os processos para VMs do Compute Engine, digite o seguinte:

    select_process_count("*") resource.type="gce_instance"

Para informações sobre como acessar o modo de filtro direto ao usar o Metrics Explorer ou ao criar gráficos ou políticas de alertas em painéis, consulte os documentos a seguir.

Identificador de recursos

Um filtro de integridade do processo precisa definir o campo resource.type para especificar as VMs cujos processos são contados. O valor desse filtro precisa ser um dos indicados abaixo:

  • gce_instance
  • aws_ec2_instance

Se você especificar apenas o campo resource.type, os processos em todas as VMs serão contados:

  • Para selecionar uma única instância de VM, adicione um objeto de filtro metric.labels.instance_name.
  • Para selecionar um grupo de VMs, adicione um objeto de filtro group.id.

Para mais informações sobre o campo resource.type, consulte Filtros do Monitoring.

Processar identificador

Um filtro de integridade do processo precisa chamar a função select_process_count. Os argumentos dessa função identificam os processos a serem contados.

Há três objetos de filtro que podem ser especificados em uma chamada para select_process_count:

  • command_line (ou metric.labels.command_line): esse filtro se aplica à linha de comando usada para iniciar o processo. As linhas de comando são truncadas após 1.024 caracteres. Portanto, o texto em uma linha de comando além desse limite não pode ser correspondido.

  • command (ou metric.labels.command): esse filtro se aplica à linha de comando usada para iniciar o processo. Os comandos são truncados após 1.024 caracteres. Portanto, o texto em um comando além desse limite não pode ser correspondido.

  • user (ou metric.labels.user): esse filtro se aplica ao usuário que iniciou o processo.

É possível usar argumentos posicionais ou nomeados na chamada para select_process_count. Se você usar argumentos nomeados, deverá especificar o objeto de filtro, uma instrução equals, = e um valor. Se você usar argumentos posicionais, especifique apenas o valor. Um teste de string que diferencia maiúsculas de minúsculas determina se um processo é uma correspondência com o filtro.

O valor de um objeto de filtro pode ser qualquer um destes:

  • string (correspondência exata)
  • * (caractere curinga)
  • has_substring(string)
  • starts_with(string)
  • ends_with(string)
  • monitoring.regex.full_match(string)

Se você especificar vários filtros, as seguintes regras serão aplicadas:

  • command_line é unido a command por um OR lógico. Um processo é contabilizado quando corresponde a um dos filtros.
  • user é unido a command_line (command) por um AND lógico. Um processo é uma correspondência somente quando corresponde ao filtro user e ao filtro command_line (command).
  • Se você aplicar todos os filtros, um processo será contabilizado quando ele corresponder ao filtro user e ao command_line ou command.

Argumentos nomeados

Para usar argumentos nomeados, especifique o nome do filtro, uma instrução equals, = e o valor do filtro. É possível especificar argumentos nomeados em qualquer ordem.

Por exemplo, o comando a seguir corresponde a todos os processos iniciados pela raiz quando a linha de comando incluiu a string nginx:

     select_process_count("command_line=has_substring(\"nginx\")","user=root")

Este exemplo usa uma correspondência de expressão regular na linha de comando:

     select_process_count("command_line=monitoring.regex.full_match(\".*nginx.*\")","user=starts_with(\"root\")")

Este exemplo conta todos os processos em que a linha de comando era /bin/bash:

     select_process_count("command=/bin/bash")

Este exemplo conta todos os processos iniciados pelo usuário www, cuja linha de comando começa com /bin/bash:

     select_process_count("user=www", "command_line=starts_with(\"/bin/bash \")")

Argumentos posicionais

Para usar argumentos posicionais, forneça apenas o valor do filtro. As regras a seguir se aplicam a argumentos posicionais:

  • Se um único argumento for fornecido, ele será interpretado como um objeto de filtro da linha de comando:
        select_process_count("*")
        select_process_count("/sbin/init")
        select_process_count("starts_with(\"/bin/bash -c\")")
        select_process_count("ends_with(\"--alsologtostderr\")")
        select_process_count("monitoring.regex.full_match(\".*nginx.*\")")
  • Se dois argumentos forem fornecidos, o primeiro argumento será interpretado como um filtro de linha de comando e o segundo será um filtro de usuário. Um processo é contabilizado quando corresponde a ambos os objetos de filtro:
        select_process_count("/sbin/init", "root")