Filtres d'état de processus

Ce guide explique comment compter le nombre de processus exécutés sur vos machines virtuelles (VM) qui répondent aux conditions de filtre que vous spécifiez. Vous pouvez créer des graphiques et des règles d'alerte qui comptabilisent les processus à l'aide de l'API Cloud Monitoring ou de la console Google Cloud.

Si vous souhaitez obtenir des informations sur l'exécution de processus, par exemple, connaître l'utilisation du processeur pour des processus spécifiques, consultez la page Métriques de processus.

La structure du filtre Monitoring lorsqu'il est utilisé pour compter des processus est semblable à celle utilisée lorsque vous utilisez ces filtres pour spécifier des ressources surveillées ou des types de métriques. Pour obtenir des informations générales, consultez la page Filtres de surveillance

Avant de commencer

Si vous ne connaissez pas bien les métriques, les séries temporelles et les ressources surveillées, consultez la page Métriques, séries temporelles et ressources.

Processus comptabilisés

Monitoring compte les processus en appliquant une expression régulière à la ligne de commande qui a appelé le processus. Si un processus n'a pas de champ de ligne de commande disponible, il n'est pas compté.

Pour déterminer si un processus peut être compté, vous pouvez afficher le résultat de la commande Linux ps:

    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]

Lorsque l'entrée de la colonne COMMAND est entre crochets (par exemple, [nfsd]), les informations de ligne de commande pour le processus ne sont pas disponibles et le processus n'est donc pas comptabilisé.

Structure des filtres d'état de processus

Un filtre d'état de processus identifie les processus à compter et une ou plusieurs ressources dont les processus doivent être comptés. Par exemple, le code JSON suivant décrit une règle d'alerte qui envoie une notification si le nombre de processus est inférieur à 30 sur une instance de VM 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
          }
        }
     }

Dans cet exemple, la valeur de l'instruction filter est une chaîne avec deux clauses. La première clause, select_process_count(\"*\"), spécifie que tous les processus sont comptés. La deuxième clause, resource.type=\"gce_instance\", identifie les VM Compute Engine qui doivent être surveillées.

Si vous utilisez la console Google Cloud, saisissez la valeur d'un filtre Monitoring à l'aide du mode de filtrage direct. Cependant, assurez-vous de supprimer tous les échappements qui protègent une sous-chaîne. Par exemple, pour compter tous les processus des VM Compute Engine, saisissez la commande suivante:

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

Pour en savoir plus sur l'accès au mode de filtrage direct lorsque vous utilisez Metrics Explorer ou lorsque vous créez des règles d'alerte ou des graphiques sur des tableaux de bord, consultez les documents suivants :

Alertes : Mode de filtrage direct
Graphiques : Mode de filtrage direct
Metrics Explorer : Mode de filtrage direct

Identifiant de ressource

Un filtre d'état de processus doit définir le champ resource.type pour spécifier les VM dont les processus sont comptés. La valeur de ce filtre doit être l'une des suivantes:

gce_instance
aws_ec2_instance

Si vous ne spécifiez que le champ resource.type, les processus de toutes les VM sont comptés:

Pour sélectionner une seule instance de VM, ajoutez un objet de filtre metric.labels.instance_name.
Pour sélectionner un groupe de VM, ajoutez un objet de filtre group.id.

Pour en savoir plus sur le champ resource.type, consultez la page Filtres de surveillance.

Identifiant de processus

Un filtre d'état de processus doit appeler la fonction select_process_count. Les arguments de cette fonction identifient les processus à compter.

Vous pouvez spécifier trois objets de filtre dans un appel de select_process_count:

command_line (ou metric.labels.command_line): ce filtre s'applique à la ligne de commande utilisée pour démarrer le processus. Notez que les lignes de commande sont limitées à 1 024 caractères. Le texte d'une ligne de commande dépassant cette limite ne peut donc pas être mis en correspondance.
command (ou metric.labels.command): ce filtre s'applique à la ligne de commande utilisée pour démarrer le processus. Les commandes sont tronquées après 1 024 caractères. Le texte d'une commande dépassant cette limite ne peut donc pas être mis en correspondance.
user (ou metric.labels.user): ce filtre s'applique à l'utilisateur qui a lancé le processus.

Vous pouvez utiliser des arguments positionnels ou des arguments nommés dans l'appel de select_process_count. Si vous utilisez des arguments nommés, vous devez spécifier l'objet de filtre, une instruction de correspondance (=), ainsi qu'une valeur. Si vous utilisez des arguments positionnels, vous ne spécifiez que la valeur. Un test de chaîne sensible à la casse détermine si un processus correspond à un filtre.

La valeur d'un objet de filtre peut être l'une des suivantes:

chaîne (correspondance exacte)
* (caractère générique)
has_substring(string)
starts_with(string)
ends_with(string)
monitoring.regex.full_match(string)

Si vous spécifiez plusieurs filtres, les règles suivantes s'appliquent:

command_line est jointe à command par un opérateur logique "OR". Un processus est compté lorsqu'il correspond à l'un des filtres.
user est jointe à command_line (command) par un opérateur logique "AND". Un processus est mis en correspondance uniquement lorsqu'il correspond aux filtres user et command_line (command).
Si vous appliquez tous les filtres, un processus est compté lorsqu'il correspond au filtre user et au filtre command_line ou command.

Arguments nommés

Pour utiliser des arguments nommés, spécifiez le nom du filtre, une instruction de correspondance (=), puis la valeur du filtre. Vous pouvez spécifier des arguments nommés dans n'importe quel ordre.

Par exemple, les éléments suivants correspondent à tous les processus démarrés par racine lorsque la ligne de commande inclut la chaîne nginx:

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

Cet exemple utilise une expression régulière sur la ligne de commande:

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

Cet exemple compte tous les processus dont la ligne de commande était /bin/bash:

     select_process_count("command=/bin/bash")

Cet exemple compte tous les processus démarrés par l'utilisateur www dont la ligne de commande commence par /bin/bash:

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

Arguments positionnels

Pour utiliser des arguments positionnels, vous ne devez fournir que la valeur du filtre. Les règles suivantes s'appliquent aux arguments positionnels:

Si un seul argument est fourni, il est interprété comme un objet de filtre de ligne de commande:

        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.*\")")

Si deux arguments sont fournis, le premier est interprété comme un filtre de ligne de commande et le second est un filtre d'utilisateur. Un processus est compté lorsqu'il correspond aux deux objets de filtre:

        select_process_count("/sbin/init", "root")