Quando si sviluppa codice bash multi-thread, gestire i processi del server o creare controlli di processo, una delle sfide principali è di solito finire correttamente, processi bash esistenti efficienti e accurati. Questo post ti mostrerà come.
Che cos'è un? Bash procedura?
Una procedura bash è semplicemente un eseguibile in esecuzione. Come esempio, quando avvii la calcolatrice nell'ambiente desktop, viene creata una procedura bash. Tale bash ha due identificatori di procedura principali, vale a dire, il PID e il PPID, il Identificatore della procedura, e il Identificatore della procedura principale.
In sintesi, il PID contiene un ID univoco basato su un numero per una determinata applicazione in esecuzione (In altre parole, Una procedura), Nel frattempo lui PPID per qualsiasi applicazione in esecuzione (In altre parole, processi) memorizza il PID padre della procedura che ha avviato questa nuova applicazione, da qui il termine "Padre".
Inoltre puoi vedere immediatamente come questo forma una struttura ad albero, tessere tutti i processi fino alla radice / prima procedura che ha un PPID a partire dal 0.
Per un post correlato che fornisce ulteriori informazioni e un esempio pratico di PID e PPID, È possibile che tu voglia rivedere il nostro post Esportazione di variabili in Bash: perché e come.
L'amministrazione della procedura Bash sembra facile a prima vista (corri ps -ef nella riga di comando del terminale per vedere tutti i processi in esecuzione sul sistema, con il prefisso PID e PPID identificatori.
Anche terminare una procedura sembra facile, pero pronto comienzan a aparecer advertencias y trampas cuando maneja sistemas de administración de procesos más complejos.
Terminar un procedimiento de Bash
Comencemos de manera simple comenzando el gnome-calculator en la línea de comando y posteriormente terminando el procedimiento.
gnome-calculator & ps -ef | grep gnome-calculator kill -9 $RELEVANT_PID
Empezamos gnome-calculator en modo de fondo (usando & alla fine del comando), in modo che possiamo riavere immediatamente il nostro prompt del terminale senza dover avviare un'altra sessione del terminale.
Prossimo, noi usiamo ps -ef in combinazione con un tubo|) e il grep comando per individuare l'ID della procedura (PID) dal nostro calcolatore. Prossimo, finiamo con un segno 9 kill comando. Sostituire $RELEVANT_PID nel codice con il PID segnalato da ps se provi questo codice.
Nota che la procedura in background termina immediatamente kill -9 istruzione. Nonostante questo, il prompt dei comandi bash ritorna così velocemente che ritorna anche prima che lo scheduler del processo possa segnalare che la procedura in background è terminata.
E lo farà solo quando quella notifica sarà in linea con il lavoro esistente, In altre parole, si basa più sull'estrazione che sull'inserimento. Quando premiamo invio, il sistema verifica e ci notifica che la prima procedura in background è terminata, o meglio era finito / RIMOSSO; [1]+ Killed gnome-calculator.
Tornando al nostro kill command, un segnale 9 kill è una delle morti più distruttive che esistano. Semplicemente, terminare lo spettacolo sul posto senza essere gentile. Puoi rivedere la sezione "Numero dei segni per i segnali standard"’ raggiungibile da man signal.7 comando eseguito al prompt dei comandi del terminale per ottenere un elenco di tutti i token disponibili e i relativi numeri corrispondenti.
Ai fini di questo post, noi useremo cartello 9 terminare sempre immediatamente ed efficacemente una procedura. Nonostante questo, anche quando si utilizza a cartello 9 uccidere / finire la procedura, a volte una procedura può rimanere in a deceduto stato.
Non succede spesso in generale nel lavoro DevOps, e se lo fa, generalmente significa che c'erano dei seri problemi nel codice del programma (la procedura in corso) iniziare, o con hardware di sistema o sistema operativo.
Evita errori e scegli i tuoi processi
Ricominciare con la procedura precedente, C'è un modo per automatizzare il PID selezione in modo da non dover digitare manualmente, e quindi possiamo usarlo da uno script? c'è di sicuro;
gnome-calculator & ps -ef | grep 'calcolatrice di gnomi' | grep -v 'grep' | imbarazzante '{Stampa $2}' ps -ef | grep 'calcolatrice di gnomi' | grep -v 'grep' | imbarazzante '{Stampa $2}' | xargs kill -9
Aquí empezamos de nuevo nuestro gnome-calculator en modo de fondo, y nuevamente usado ps e grep para hallar nuestro procedimiento. Ahí es donde termina la similitud. En la próxima instrucción dentro del conjunto de tuberías Bash (pasando información del comando anterior al siguiente usando un símbolo de tubería: |) excluimos el grep procedimiento en sí (además enumerado como parte del ps output poiché viene eseguito durante il nostro script e, perché, è auto-raccolto dal grep), usando il -v opzione a grep ed escludendo la parola 'grep'.
Finire, stampiamo il PID (ID procedura) di qualsiasi procedura scoperta utilizzando awk e stampando il secondo ($2) solo colonna di output. Lo vediamo solo uno PID È tornato, che coincide con il fatto che ne abbiamo solo uno gnome-calculator cominciato.
Il nostro comando finale aggiunge a xargs comando con a kill -9 istruzioni per finire il nostro (S) processi (S). xargs funziona in modo simile a una pipe stessa, ma è più in grado di gestire le informazioni di input e di passarle correttamente, consentendo determinati programmi come kill (che non puoi capire nativamente quando è semplice PIDti sono stati inviati) accettare input diretti, o meglio opzioni, come l'ID della procedura che viene trasmesso qui. Nota che xargs è preceduto da una pipe.
La nostra inclusione di a grep -v 'grep' evitare non solo l'errore dell'eventuale kill il comando non riesce a trovare il PID associato all'originale grep comando (da allora è finita, avendo adempiuto al suo dovere di grepping per il 'gnome-calculator' testo), al secondo posto, evita anche il rischio di terminare un altro comando / procedura più recente che potrebbe essere stata avviata dall'originale. grep finito, con la stessa procedura ID! Anche se la possibilità che ciò accada è piccola, è fattibile.
Lavorare queste cose nel nostro comando sembra migliore, ma ancora non perfetto. Cos'è questo è un server con? 10 utenti e 10 hanno avviato una calcolatrice? Supponendo di avere privilegi simili a sudo, Vogliamo davvero terminare i processi di calcolatrice degli altri utenti?? Probabilmente no. Quindi, possiamo fare un ulteriore passo avanti e impostare il nostro comando come segue:
gnome-calculator & ps -ef | grep 'calcolatrice di gnomi' | grep -v 'grep' | grep "$(chi sono)" | imbarazzante '{Stampa $2}' ps -ef | grep 'calcolatrice di gnomi' | grep -v 'grep' | grep "$(chi sono)" | imbarazzante '{Stampa $2}' | xargs kill -9
In questo esempio inseriamo un piccolo comando aggiuntivo, vale a dire grep "$(whoami)", che gestiva un sottolivello ($(...)) e poi esegue whoami all'interno di quel sottostrato. il whoami Il comando riporterà gli utenti registrati oggi al terminale. ¡Bingo! Ora finiamo solo i nostri processi.
Perfetto? No, sfortunatamente gli errori sono ancora possibili anche con una riga di comando così dettagliata e stretta. Come esempio, se l'elenco dei processi contiene caratteri locali o dispari, Nostro grep potenzialmente ancora fallire. Forse la versione più sicura sarebbe qualcosa del tipo:
gnome-calculator &
ps -ef | grep -Ei --binary-files = text "^$(chi sono) [0-9 ]+:.*gnome-calcolatrice$" | grep --binary-files = text -v 'grep' | imbarazzante '{Stampa $2}' | grep --binary-files=testo -o '[0-9]+' | xargs -I{} uccisione -9 "{}"
In questo esempio, definiamo il nostro grep comando molto più restrittivo con un'espressione regolare: inizio (indicato da ^) con nome utente (usando whoami in un sottostrato), seguito da uno spazio richiesto, seguito solo dai caratteri 0-9 e spazio, almeno uno o più (come indicato +), seguito da due punti obbligatori (parte del tempo), seguito da qualsiasi carattere fino al nome del nostro programma, che deve essere riempito fino alla fine della riga (come indicato $). il grep usa espressioni regolari estese (-E) e non fa distinzione tra maiuscole e minuscole (-i opzione, o semplicemente i quando aggiunto a esistente -E opzione)
Proteggiamo anche il nostro grep dalla strana opportunità di locale o strani personaggi che usano --binary-files=text, e scriviamo i nostri xargs in modo più sicuro indicando una stringa di sostituzione e citando la stringa di sostituzione.
Finire, inseriamo un ulteriore grep -o con un'espressione regolare che trova i numeri 0-9 soltanto. Perché, anche se qualche programma tenta di imbrogliare questa procedura uccidendo la riga di comando, sarebbe più difficile da fare.
Come alternativa interessante alla definizione di una riga di comando di analisi, potresti anche dare un'occhiata a killall comando:
gnome-calculator &
killall 'calcolatrice di gnomi'
Per ulteriori informazioni su questo comando, puoi inserire il manuale usando man killall. il killall Il comando consente anche di configurare opzioni come --user per uccidere solo i processi di proprietà dell'utente specificato, eccetera.
Fine
La gestione dei processi in vari modi ci consente di scrivere script watchdog del processo, automatizzare la gestione dei processi, sviluppare un codice bash multi-thread migliore, gestire meglio e di più i processi. Goditi le tue nuove abilità di bash!!
