Filtros de integridade do processo

É possível contar os processos em execução nas máquinas virtuais (VMs) que correspondem a critérios específicos usando filtros de integridade de processos no Cloud Monitoring. Use esses filtros em políticas de alertas e gráficos pela API Cloud Monitoring ou pelo modo de filtro direto no console do Google Cloud .

Para monitorar o consumo de recursos, como a utilização da CPU para processos específicos, consulte Monitorar processos em VMs. Os filtros de integridade do processo compartilham a sintaxe com os filtros padrão de recursos e métricas. Para regras gerais de sintaxe, consulte Filtros do Monitoring.

Antes de começar

Se você não conhece métricas, série temporal e recursos monitorados, consulte Métricas, série temporal e recursos.

Processos que são contabilizados

O Monitoring conta os 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, ele não será contabilizado.

Uma maneira de determinar se um processo pode ser contado é 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 a entrada na coluna COMMAND está entre colchetes, por exemplo, [nfsd], as informações da linha de comando do processo não estão disponíveis e, portanto, o processo não é contado.

Estrutura de filtros de integridade do processo

Um filtro de integridade do processo identifica quais processos serão contados e um ou mais recursos dos quais os 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ê usa o console do Google 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 protegem uma substring. Por exemplo, para contar todos os processos das VMs do Compute Engine, digite o seguinte:

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

Para saber como acessar o modo de filtro direto ao usar o Metrics Explorer ou ao criar políticas de alertas ou gráficos em painéis, consulte os seguintes documentos:

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 destes:

  • gce_instance
  • aws_ec2_instance

Se você apenas especificar 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.

Identificador do processo

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

Há três objetos de filtro que você pode especificar 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. Dessa maneira, o texto em uma linha de comando além desse limite não pode ser comparado.

  • 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, não é possível corresponder o texto em um comando além desse limite.

  • 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, especifique o objeto de filtro, uma instrução de igualdade (=) 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 corresponde ao filtro.

O valor de um objeto de filtro pode ser qualquer um dos seguintes:

  • 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á contado quando corresponder ao filtro user e ao filtro command_line ou command.

Argumentos nomeados

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

Por exemplo, o seguinte corresponde a todos os processos iniciados pelo root quando a linha de comando inclui a string nginx:

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

Neste exemplo, usamos 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 com a linha de comando /bin/bash:

     select_process_count("command=/bin/bash")

Este exemplo conta todos os processos iniciados pelo usuário www com uma linha de comando que 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 seguintes regras se aplicam a argumentos posicionais:

  • Se um único argumento for fornecido, ele será interpretado como um objeto de filtro de 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 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")