Filtros de estado de funcionamento dos processos

Este guia descreve como contabilizar 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 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 comando 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 comando 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 é unido 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 conta 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")