Lors du développement de code bash multi-thread, gérer les processus du serveur ou créer des contrôles de processus, l'un des principaux défis est généralement de terminer correctement, processus bash existants efficaces et précis. Cet article vous montrera comment.
Qu'est-ce qu'un Procédure Bash?
Une procédure bash est simplement un exécutable en cours d'exécution. Par exemple, lorsque vous démarrez la calculatrice dans votre environnement de bureau, une procédure bash est créée. Un tel bash a deux identifiants de procédure principaux, a savoir, les PID et le PPID, Les Identifiant de la procédure, et le Identifiant de la procédure principale.
En résumé, les PID contient un identifiant unique basé sur un numéro pour une application en cours d'exécution donnée (En d'autres termes, Une procédure), Pendant ce temps, il PPID pour n'importe quelle application en cours d'exécution (En d'autres termes, traiter) stocke le PID parent de la procédure qui a démarré cette nouvelle demande, d'où le terme "Père".
Vous pouvez également voir immédiatement comment cela forme une structure arborescente, tisser tous les processus jusqu'à la racine / première procédure qui a un PPID de 0.
Pour un article connexe qui fournit des informations supplémentaires et un exemple pratique de PID et PPID, Il est possible que vous souhaitiez consulter notre article Exporter des variables dans Bash: pourquoi et comment.
L'administration de la procédure Bash semble facile à première vue (juste courir ps -ef dans la ligne de commande de votre terminal pour voir tous les processus en cours d'exécution sur votre système, avec le préfixe PID et PPID identifiants.
Même mettre fin à une procédure semble facile, mais bientôt des avertissements et des pièges commencent à apparaître lorsque vous gérez des systèmes de gestion de processus plus complexes.
Fin d’une procédure Bash
Commençons simplement par démarrer le gnome-calculator sur la ligne de commande, puis en terminant la procédure.
gnome-calculatrice & ps -ef | grep gnome-calculator kill -9 $RELEVANT_PID
Commencé gnome-calculator en mode arrière-plan (à l'aide de & à la fin de la commande), afin que nous puissions récupérer notre invite de terminal immédiatement sans avoir à démarrer une autre session de terminal.
Ensuite, nous utilisons ps -ef en combinaison avec un tuyau|) et le grep commande pour localiser l'ID de procédure (PID) de notre calculateur. Ensuite, nous terminons par un signe 9 kill commander. Remplacer $RELEVANT_PID dans le code avec le PID rapporté par ps si vous essayez ce code.
Notez que la procédure d'arrière-plan se termine immédiatement kill -9 instruction. Malgré cela, l'invite de commande bash revient si vite qu'elle revient avant même que le planificateur de processus puisse signaler que la procédure d'arrière-plan est terminée.
Et il ne le fera que lorsque cette notification est conforme au travail existant, En d'autres termes, il est plus basé sur l'extraction que sur l'insertion. Lorsque nous appuyons sur Entrée, le système vérifie et nous informe que la première procédure d'arrière-plan est terminée, ou plutôt c'était fini / supprimé; [1]+ Killed gnome-calculator.
De retour dans notre kill command, signal 9 kill c'est l'une des morts les plus destructrices qui existent. Simplement, terminer le spectacle sur place sans être gentil avec ça. Vous pouvez consulter la section « Numérotation des signes pour les signaux standard’ joignable de man signal.7 commande exécutée à l'invite de commande de votre terminal pour obtenir une liste de tous les jetons disponibles et leurs numéros correspondants.
Aux fins de ce poste, nous utiliserons signe 9 de toujours mettre fin immédiatement et efficacement à une procédure. Malgré cela, même en utilisant un signe 9 tuer / terminer la procédure, parfois une procédure peut rester dans un décédé Etat.
Cela n'arrive pas souvent dans le travail DevOps général, et si c'est le cas, cela signifie généralement qu'il y a eu de sérieux problèmes dans le code du programme (la procédure en cours) pour commencer, ou avec le matériel système ou le système d'exploitation.
Évitez les erreurs et choisissez vos propres processus
Recommencer avec la procédure précédente, Existe-t-il un moyen d'automatiser le PID sélection afin que nous n'ayons pas besoin de taper manuellement, et donc nous pouvons l'utiliser à partir d'un script? Il y a bien sûr;
gnome-calculatrice &
ps -ef | grep 'gnome-calculateur' | grep -v 'grep' | ah '{imprimer $2}'
ps -ef | grep 'gnome-calculateur' | grep -v 'grep' | ah '{imprimer $2}' | xargs tue -9
Ici, nous recommençons notre gnome-calculator en mode arrière-plan, et à nouveau utilisé ps et grep pour trouver notre procédure. C'est là que s'arrête la similitude. Dans la déclaration suivante à l'intérieur du jeu de tuyaux Bash (transmettre des informations de la commande précédente à la suivante à l'aide d'un symbole de tuyau: |) nous excluons le grep procédure elle-même (en outre répertorié dans le cadre de la ps sortie car elle s'exécute pendant notre script et, pour cela, est collecté par le grep), en utilisant le -v option une grep et en excluant le mot 'grep'.
Pour terminer, nous imprimons le PID (Identifiant de la procédure) de toute procédure découverte à l'aide awk et l'impression du deuxième ($2) colonne de sortie uniquement. On voit qu'un seul PID il est retourné, ce qui coïncide avec le fait que nous n'avons qu'un seul gnome-calculator commencé.
Notre dernière commande ajoute un xargs commande avec un kill -9 instruction pour terminer notre (s) traiter (s). xargs fonctionne de la même manière qu'un tube lui-même, mais il est plus capable de gérer les informations d'entrée et de les transmettre correctement, permettant à certains programmes comme kill (qu'on ne comprend pas nativement quand c'est simple PIDils vous sont envoyés) accepter les entrées directes, ou plutôt des options, comme ID de procédure qui est transmis ici. Notez que xargs est préfixé par un tube.
Notre inclusion d'un grep -v 'grep' éviter non seulement l'erreur de l'éventuelle kill la commande ne peut pas trouver le PID associé à l'original grep commander (depuis, c'est fini, ayant rempli son devoir de s'occuper de la 'gnome-calculator' texte), en second lieu, évite également le risque de terminer une autre commande / procédure plus récente qui peut avoir été lancée à partir de l'original. grep fini, avec le même identifiant de procédure! Même si la chance que cela se produise est faible, c'est faisable.
Travailler ces choses dans notre commande semble mieux, mais toujours pas parfait. Qu'est-ce que c'est un serveur avec 10 utilisateurs et 10 ils ont commencé une calculatrice? En supposant que nous ayons des privilèges similaires à sudo, Voulons-nous vraiment mettre fin aux processus de calcul des autres utilisateurs ?? Probablement non. Ensuite, nous pouvons aller plus loin et définir notre commande comme suit:
gnome-calculatrice &
ps -ef | grep 'gnome-calculateur' | grep -v 'grep' | grep "$(qui suis je)" | ah '{imprimer $2}'
ps -ef | grep 'gnome-calculateur' | grep -v 'grep' | grep "$(qui suis je)" | ah '{imprimer $2}' | xargs tue -9
Dans cet exemple, nous insérons une petite commande supplémentaire, a savoir grep "$(whoami)", qui a exécuté une sous-couche ($(...)) et exécute plus tard whoami dans cette sous-couche. Les whoami La commande renverra les utilisateurs enregistrés aujourd'hui au terminal. Bingo! Maintenant, nous venons de terminer nos propres processus.
Parfait? Non, malheureusement des erreurs sont toujours possibles même avec une ligne de commande aussi détaillée et précise. Par exemple, si la liste des processus contient des paramètres régionaux ou des caractères impairs, notre grep potentiellement encore échouer. Peut-être que la version la plus sûre serait quelque chose comme:
gnome-calculatrice &
ps -ef | grep -Ei --binary-files = texte "^$(qui suis je) [0-9 ]+:.*gnome-calculateur$" | grep --binary-files = text -v 'grep' | ah '{imprimer $2}' | grep --binary-files=text -o '[0-9]+' | xargs -I{} tuer -9 "{}"
Dans cet exemple, nous définissons notre grep commande beaucoup plus restrictive avec un regex: début (indiqué par ^) avec nom d'utilisateur (à l'aide de whoami dans une sous-couche), suivi d'un espace requis, suivi uniquement des caractères 0-9 et l'espace, au moins un ou plusieurs (comme indiqué +), suivi de deux points obligatoires (une partie du temps), suivi de n'importe quel caractère jusqu'au nom de notre programme, qui doit être rempli jusqu'à la fin de la ligne (comme indiqué $). Les grep utiliser des expressions régulières étendues (-E) et n'est pas sensible à la casse (-i option, ou simplement i lorsqu'il est ajouté à l'existant -E option)
Nous protégeons également notre grep de l'étrange opportunité de la localisation ou des caractères étranges en utilisant --binary-files=text, et nous écrivons nos xargs de manière plus sécurisée en indiquant une chaîne de remplacement et en citant la chaîne de remplacement.
Pour terminer, nous insérons un supplément grep -o avec une expression régulière qui trouve les nombres 0-9 seul. Pour cela, même si un programme essaie de tromper cette procédure en tuant la ligne de commande, ce serait plus difficile à faire.
Comme alternative intéressante à la définition d'une ligne de commande d'analyse, vous pouvez également jeter un oeil à la killall commander:
gnome-calculatrice & killall 'gnome-calculateur'
Pour plus d'informations sur cette commande, vous pouvez entrer dans le manuel en utilisant man killall. Les killall La commande vous permet également de configurer des options telles que --user pour tuer uniquement les processus appartenant à l'utilisateur spécifié, etc.
Fin
La gestion des processus de diverses manières nous permet d'écrire des scripts de surveillance des processus, automatiser la gestion des processus, développer un meilleur code bash multi-thread, mieux et mieux gérer les processus. Profitez de vos nouvelles compétences bash !!
