Filtros de integridade do processo

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

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

A estrutura de filtro do Monitoring, quando usada para contar processos, é semelhante à usada quando esses filtros são usados para especificar recursos monitorados ou tipos de métricas. 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 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 é conferir 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 para o processo não serão disponível e, portanto, o processo não é contabilizado.

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 informações sobre como acessar o modo de filtro direto ao usar o Metrics Explorer ou ao criar políticas ou gráficos 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 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 e 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 é mesclado a command por um OR lógico. Um processo é contabilizado quando ele corresponde a um dos filtros.
  • user é mesclado 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 código 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")

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 cuja linha de comando era /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")