Filtros de estado de funcionamento do processo

Este guia descreve como contar o número de processos em execução nas suas máquinas virtuais (VMs) que cumprem as condições de filtro especificadas. Pode criar políticas de alerta e gráficos que contabilizam processos através da API Cloud Monitoring ou da Google Cloud consola.

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

A estrutura do filtro de monitorização quando é usado para contar processos é semelhante à estrutura usada quando usa estes filtros para especificar recursos monitorizados ou tipos de métricas. Para informações gerais, consulte o artigo Monitorizar filtros.

Antes de começar

Se não estiver familiarizado com métricas, séries cronológicas e recursos monitorizados, consulte o artigo Métricas, séries cronológicas e recursos.

Processos que são contabilizados

A monitorização conta os processos aplicando uma expressão regular à linha de comandos que invocou o processo. Se um processo não tiver um campo de linha de comandos disponível, esse processo não é contabilizado.

Uma forma de determinar se um processo pode ser contabilizado é ver o resultado 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 parênteses retos, por exemplo, [nfsd], as informações da linha de comandos para o processo não estão disponíveis e, por isso, o processo não é contabilizado.

Estrutura do filtro de estado de funcionamento do processo

Um filtro de estado de funcionamento do processo identifica os processos a contabilizar e um ou mais recursos cujos processos devem ser contabilizados. Por exemplo, o JSON seguinte descreve uma política de alertas que envia uma notificação se o número de processos for inferior a 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 declaração filter é uma string com duas cláusulas. A primeira cláusula, select_process_count(\"*\"), especifica que todos os processos são contabilizados. A segunda cláusula, resource.type=\"gce_instance\", identifica que as VMs do Compute Engine devem ser monitorizadas.

Se usar a Google Cloud consola, use o modo de filtro direto para introduzir o valor de um filtro de monitorização. No entanto, certifique-se de que remove todas as sequências de escape que protegem uma substring. Por exemplo, para contabilizar todos os processos das VMs do Compute Engine, introduza o seguinte:

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

Para obter informações sobre como aceder ao modo de filtro direto quando usa o explorador de métricas ou quando cria políticas de alerta ou gráficos em painéis de controlo, consulte os seguintes documentos:

Identificador de recursos

Um filtro de estado de funcionamento do processo tem de definir o campo resource.type para especificar as VMs cujos processos são contabilizados. O valor deste filtro tem de ser um dos seguintes:

  • gce_instance
  • aws_ec2_instance

Se especificar apenas o campo resource.type, são contabilizados os processos em todas as VMs:

  • 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 o artigo Monitorizar filtros.

Identificador do processo

Um filtro process-health tem de chamar a função select_process_count. Os argumentos desta função identificam os processos a serem contabilizados.

Existem três objetos de filtro que pode especificar numa chamada para select_process_count:

  • command_line (ou metric.labels.command_line): este filtro aplica-se à linha de comandos usada para iniciar o processo. As linhas de comandos são truncadas após 1024 carateres, pelo que não é possível fazer a correspondência com texto numa linha de comandos que ultrapasse esse limite.

  • command (ou metric.labels.command): este filtro aplica-se à linha de comandos usada para iniciar o processo. Os comandos são truncados após 1024 carateres, pelo que não é possível fazer a correspondência com o texto num comando que ultrapasse esse limite.

  • user (ou metric.labels.user): este filtro aplica-se ao utilizador que iniciou o processo.

Pode usar argumentos posicionais ou argumentos com nome na chamada para select_process_count. Se usar argumentos com nome, tem de especificar o objeto de filtro, uma declaração de igualdade, =e um valor. Se usar argumentos posicionais, especifica apenas o valor. Um teste de string sensível a 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)
  • * (caráter universal)
  • has_substring(string)
  • starts_with(string)
  • ends_with(string)
  • monitoring.regex.full_match(string)

Se especificar vários filtros, aplicam-se as seguintes regras:

  • command_line é associado a command por um OU lógico. Um processo é contabilizado quando corresponde a qualquer um dos filtros.
  • user é unido a command_line (command) por um E lógico. Um processo só é uma correspondência quando corresponde ao filtro user e ao filtro command_line (command).
  • Se aplicar todos os filtros, um processo é contabilizado quando corresponde ao filtro user e quando corresponde ao filtro command_line ou command.

Argumentos com nome

Para usar argumentos com nome, especifique o nome do filtro, uma declaração de igualdade, = e, em seguida, o valor do filtro. Pode especificar argumentos com nome em qualquer ordem.

Por exemplo, o seguinte corresponde a todos os processos iniciados pelo utilizador root quando a linha de comandos incluía 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 comandos:

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

Este exemplo contabiliza todos os processos cuja linha de comandos foi /bin/bash:

     select_process_count("command=/bin/bash")

Este exemplo contabiliza todos os processos iniciados pelo utilizador www cuja linha de comandos começa com /bin/bash:

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

Argumentos posicionais

Para usar argumentos posicionais, fornece apenas o valor do filtro. As seguintes regras aplicam-se aos argumentos posicionais:

  • Se for fornecido um único argumento, esse argumento é interpretado como um objeto de filtro de linha de comandos:
        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 forem fornecidos dois argumentos, o primeiro argumento é interpretado como um filtro de linha de comandos e o segundo é um filtro de utilizador. Um processo é contabilizado quando corresponde a ambos os objetos de filtro:
        select_process_count("/sbin/init", "root")