One place for hosting & domains

      unter

      So verwenden Sie ps, kill und schön zum Verwalten von Prozessen unter Linux


      Einführung


      Auf einem Linux-Server werden wie auf jedem anderen Computer, mit dem Sie möglicherweise vertraut sind, Anwendungen ausgeführt. Auf dem Computer werden diese als „Prozesse“ bezeichnet.

      Während Linux die Verwaltung auf niedriger Ebene hinter den Kulissen im Lebenszyklus eines Prozesses übernimmt, benötigen Sie eine Möglichkeit zur Interaktion mit dem Betriebssystem, um es von einer höheren Ebene aus zu verwalten.

      In diesem Leitfaden werden wir einige einfache Aspekte der Prozessverwaltung erörtern. Linux bietet eine reichliche Sammlung von Tools für diesen Zweck.

      Wir werden diese Ideen auf einem Ubuntu 12.04 VPS untersuchen, aber jede moderne Linux-Distribution funktioniert auf ähnliche Weise.

      So zeigen Sie laufende Prozesse unter Linux an


      top


      Der einfachste Weg, um herauszufinden, welche Prozesse auf Ihrem Server ausgeführt werden, besteht darin, den Befehl top auszuführen:

      top***
      
      top - 15:14:40 bis 46 min, 1 Benutzer, Lastdurchschnitt: 0,00, 0,01, 0,05 Aufgaben: 56 insgesamt, 1 laufend, 55 inaktiv, 0 gestoppt, 0 Zombie Cpu(s):  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st Mem: 1019600k gesamt, 316576k gebraucht, 703024k frei, 7652k Puffer Swap: 0k insgesamt, 0k verwendet, 0k frei, 258976k zwischengespeichert   PID USER PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND               1 root      20   0 24188 2120 1300 S  0.0  0.2   0:00.56 init                   2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd               3 root      20   0     0    0    0 S  0.0  0.0   0:00.07 ksoftirqd/0            6 root      RT   0     0    0    0 S  0.0  0.0   0:00.00 migration/0            7 root      RT   0     0    0    0 S  0.0  0.0   0:00.03 watchdog/0             8 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 cpuset                 9 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 khelper               10 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kdevtmpfs
      

      Der oberste Informationsblock enthält Systemstatistiken wie die Systemlast und die Gesamtzahl der Aufgaben.

      Sie können leicht erkennen, dass 1 Prozess ausgeführt wird und 55 Prozesse inaktiv sind (auch bekannt als inaktiv/ohne CPU-Ressourcen).

      Der untere Teil enthält die laufenden Prozesse und ihre Nutzungsstatistiken.

      htop


      Eine verbesserte Version von top namens htop ist in den Repositorys verfügbar. Installieren Sie sie mit diesem Befehl:

      sudo apt-get install htop
      

      Wenn wir den Befehl htop ausführen, sehen wir, dass es eine benutzerfreundlichere Anzeige gibt:

      htop***
      
        Mem[|||||||||||           49/995MB]     Durchschnittslast: 0.00 0.03 0.05   CPU[                          0.0%]     Aufgaben: 21, 3 thr; 1 laufend   Swp[                         0/0MB]     Betriebszeit: 00:58:11   PID USER PRI  NI  VIRT   RES   SHR S CPU% MEM%   TIME+  Command  1259 root       20   0 25660  1880  1368 R  0.0  0.2  0:00.06 htop     1 root       20   0 24188  2120  1300 S  0.0  0.2  0:00.56 /sbin/init   311 root       20   0 17224   636   440 S  0.0  0.1  0:00.07 upstart-udev-brid   314 root       20   0 21592  1280   760 S  0.0  0.1  0:00.06 /sbin/udevd --dae   389 messagebu  20   0 23808   688   444 S  0.0  0.1  0:00.01 dbus-daemon --sys   407 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.02 rsyslogd -c5   408 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   409 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   406 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.04 rsyslogd -c5   553 root       20   0 15180   400   204 S  0.0  0.0  0:00.01 upstart-socket-br
      

      Sie können hier mehr über die Verwendung von top und htop erfahren.

      Verwendung von ps zum Auflisten von Prozessen


      Sowohl top als auch htop bieten eine schöne Benutzeroberfläche, um laufende Prozesse zu sehen, die einem grafischen Aufgabenmanager ähneln.

      Diese Tools sind jedoch nicht immer flexibel genug, um alle Szenarien angemessen zu behandeln. Ein leistungsfähiger Befehl namens ps ist oft die Antwort auf diese Probleme.

      Wenn er ohne Argumente aufgerufen wird, kann die Ausgabe etwas fehlerhafter sein:

      ps***
      
        PID TTY          TIME CMD  1017 pts/0    00:00:00 bash  1262 pts/0    00:00:00 ps
      

      Diese Ausgabe zeigt alle mit dem aktuellen Benutzer und der Terminalsitzung verknüpften Prozesse an. Dies ist sinnvoll, da wir derzeit nur bash und ps mit diesem Terminal ausführen.

      Um ein vollständigeres Bild der Prozesse auf diesem System zu erhalten, können wir Folgendes ausführen:

      ps aux***
      
      USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND root         1  0.0  0.2  24188  2120 ?        Ss   14:28   0:00 /sbin/initroot         2  0.0  0.0      0     0 ?        S    14:28   0:00 [kthreadd] root         3  0.0  0.0      0     0 ?        S    14:28   0:00 [ksoftirqd/0] root         6  0.0  0.0      0     0 ?        S    14:28   0:00 [migration/0] root         7  0.0  0.0      0     0 ?        S    14:28   0:00 [watchdog/0] root         8  0.0  0.0      0     0 ?        S<   14:28   0:00 [cpuset] root         9  0.0  0.0      0     0 ?        S<   14:28   0:00 [khelper] . . .
      

      Diese Optionen weisen ps an, Prozesse, die allen Benutzern gehören (unabhängig von ihrer Terminalzuordnung), in einem benutzerfreundlichen Format anzuzeigen.

      Um eine Baumansicht zu sehen, in der hierarchische Beziehungen illustriert werden, können wir den Befehl mit diesen Optionen ausführen:

      ps axjf***
      
       PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND     0     2     0     0 ?           -1 S        0   0:00 [kthreadd]     2     3     0     0 ?           -1 S        0   0:00  _ [ksoftirqd/0]     2     6     0     0 ?           -1 S        0   0:00  _ [migration/0]     2     7     0     0 ?           -1 S        0   0:00  _ [watchdog/0]     2     8     0     0 ?           -1 S<       0   0:00  _ [cpuset]     2     9     0     0 ?           -1 S<       0   0:00  _ [khelper]     2    10     0     0 ?           -1 S        0   0:00  _ [kdevtmpfs]     2    11     0     0 ?           -1 S<       0   0:00  _ [netns] . . .
      

      Wie Sie sehen können, wird der Prozess kthreadd als übergeordnetes Element des Prozesses ksoftirqd/0 und der anderen Prozesse angezeigt.

      Eine Anmerkung zu Prozess-IDs


      In Linux- und Unix-ähnlichen Systemen wird jedem Prozess einer Prozess-ID oder PID zugewiesen. So identifiziert und verfolgt das Betriebssystem Prozesse.

      Eine schnelle Möglichkeit zum Abrufen der PID eines Prozesses ist mit dem Befehl pgrep:

      pgrep bash***
      
      1017
      

      Dadurch wird die Prozess-ID einfach abfragt und zurückgegeben.

      Der erste beim Booten erzeugte Prozess namens init erhält die PID „1“.

      pgrep init***
      
      1
      

      Dieser Prozess ist dann dafür verantwortlich, jeden anderen Prozess auf dem System zu erzeugen. Die späteren Prozesse erhalten größere PID-Nummern.

      Das übergeordnete Element eines Prozesses ist der Prozess, der für das Ablegen verantwortlich war. Übergeordnete Prozesse verfügen über eine PPID, die Sie in den Spaltenüberschriften vieler Prozessverwaltungsanwendungen sehen können, einschließlich top, htop und ps.

      Jede Kommunikation zwischen dem Benutzer und dem Betriebssystem über Prozesse umfasst die Übersetzung zwischen Prozessnamen und PIDs zu einem bestimmten Zeitpunkt während des Vorgangs. Aus diesem Grund teilen Dienstprogramme Ihnen die PID mit.

      Übergeordnete-untergeordnete Beziehungen


      Das Erstellen eines untergeordneten Prozesses erfolgt in zwei Schritten: fork(), das einen neuen Adressraum erstellt und die Ressourcen des übergeordneten Elements per Copy-on-Write kopiert, um dem untergeordneten Prozess zur Verfügung zu stehen; und exec(), das eine ausführbare Datei in den Adressraum lädt und ausführt.

      Für den Fall, dass ein untergeordneter Prozess vor seinem übergeordneten Prozess beendet wird, wird der untergeordnete Prozess zu einem Zombie, bis der übergeordnete Prozess Informationen darüber gesammelt oder dem Kernel angezeigt hat, dass er diese Informationen nicht benötigt. Die Ressourcen aus dem untergeordneten Prozess werden dann freigegeben. Wenn der übergeordnete Prozess jedoch vor dem untergeordneten Prozess beendet wird, wird der untergeordnete Prozess von init übernommen, obwohl er auch einem anderen Prozess neu zugewiesen werden kann.

      So senden Sie Prozesssignale in Linux


      Alle Prozesse in Linux reagieren auf Signale. Signale sind eine Methode auf Betriebssystemebene, mit der Programme angewiesen werden, ihr Verhalten zu beenden oder zu ändern.

      So senden Sie Prozesssignale nach PID


      Die häufigste Art, Signale an ein Programm weiterzuleiten, ist mit dem Befehl kill.

      Wie Sie möglicherweise erwarten, besteht die Standardfunktion dieses Dienstprogramms darin, zu versuchen, einen Prozess zu beenden:

      kill PID_of_target_process

      Dadurch wird das TERM-Signal an den Prozess gesendet. Das TERM-Signal weist den Prozess an, zu beenden. Dadurch kann das Programm Reinigungsvorgänge durchführen und reibungslos beenden.

      Wenn sich das Programm schlecht verhält und bei Erhalt des TERM-Signals nicht beendet wird, können wir das Signal durch Weiterleiten des KILL-Signals eskalieren:

      kill -KILL PID_of_target_process

      Dies ist ein spezielles Signal, das nicht an das Programm gesendet wird.

      Stattdessen wird es dem Betriebssystem-Kernel übergeben, der den Prozess herunterschaltet. Dies wird verwendet, um Programme zu umgehen, die die an sie gesendeten Signale ignorieren.

      Jedem Signal ist eine Nummer zugeordnet, die anstelle des Namens übergeben werden kann. Beispielsweise können Sie „-15“ anstelle von „-TERM“ und „-9“ anstelle von „-KILL“ übergeben.

      So verwenden Sie Signale für andere Zwecke


      Signale werden nicht nur zum Herunterfahren von Programmen verwendet. Sie können auch verwendet werden, um andere Aktionen auszuführen.

      Beispielsweise werden viele Daemons neu gestartet, wenn sie das HUP– oder Auflegesignal erhalten. Apache ist ein Programm, das so funktioniert.

      sudo kill -HUP pid_of_apache

      Der obige Befehl führt dazu, dass Apache seine Konfigurationsdatei neu lädt und Inhalte wiederbelebt.

      Sie können alle Signale auflisten, die mit kill gesendet werden können, indem Sie Folgendes eingeben:

      kill -l***
      
      1) SIGHUP    2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP  6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM . . .
      

      So senden Sie Prozesssignale nach Name


      Obwohl die konventionelle Art des Sendens von Signalen durch die Verwendung von PIDs ist, gibt es auch Methoden, dies mit regulären Prozessnamen zu tun.

      Der Befehl pkill funktioniert fast genau so wie kill, operiert jedoch stattdessen auf einem Prozessnamen:

      pkill -9 ping
      

      Der obige Befehl ist das Äquivalent von:

      kill -9 `pgrep ping`
      

      Wenn Sie ein Signal an jede Instanz eines bestimmten Prozesses senden möchten, können Sie den Befehl killall verwenden:

      killall firefox
      

      Der obige Befehl sendet das TERM-Signal an jede Instanz von Firefox, das auf dem Computer ausgeführt wird.

      So passen Sie Prozessprioritäten an


      Oft möchten Sie anpassen, welchen Prozessen in einer Serverumgebung Priorität eingeräumt wird.

      Einige Prozesse können als geschäftskritisch für Ihre Situation angesehen werden, während andere ausgeführt werden können, wenn Ressourcen übrig bleiben.

      Linux kontrolliert die Priorität durch einen Wert namens niceness.

      Hohe Prioritätsaufgaben werden als weniger nett angesehen, da sie auch keine Ressourcen teilen. Prozesse mit niedriger Priorität sind dagegen nett, weil sie darauf bestehen, nur minimale Ressourcen zu verbrauchen.

      Als wir am Anfang des Artikels top ausgeführt haben, gab es eine Spalte mit der Bezeichnung „NI“. Dies ist der nette Wert des Prozesses:

      top***
      
      Aufgaben: 56 insgesamt, 1 laufend, 55 inaktiv, 0 gestoppt, 0 Zombie Cpu(s):  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st Mem:   1019600k insgesamt,   324496k verwendet,   695104k frei,     8512k Puffer Swap:   0k insgesamt,   0k verwendet,   0k frei,    264812k zwischengespeichert   PID-BENUTZER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            1635 root      20   0 17300 1200  920 R  0.3  0.1   0:00.01 top                    1 root      20   0 24188 2120 1300 S  0,0  0,2   0:00,56 init                   2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd               3 root      20   0     0    0    0 S  0.0  0.0   0:00.11 ksoftirqd/0
      

      Nette Werte können je nach System zwischen „-19/-20“ (höchste Priorität) und „19/20“ (niedrigste Priorität) liegen.

      Um ein Programm mit einem bestimmten netten Wert auszuführen, können wir den Befehl nice verwenden:

      nice -n 15 command_to_execute

      Dies funktioniert nur, wenn ein neues Programm gestartet wird.

      Um den netten Wert eines Programms zu ändern, das bereits ausgeführt wird, verwenden wir ein Tool namens renice:

      renice 0 PID_to_prioritize

      Hinweis: Während nice zwangsläufig mit einem Befehlsnamen funktioniert, ruft renice die Prozess-PID auf

      Zusammenfassung


      Die Prozessverwaltung ist ein Thema, das für neue Benutzer manchmal schwer zu verstehen ist, da sich die verwendeten Tools von ihren grafischen Gegenstücken unterscheiden.

      Die Ideen sind jedoch vertraut und intuitiv und werden mit ein wenig Übung zur Gewohnheit. Da Prozesse an allem beteiligt sind, was Sie mit einem Computersystem tun, ist es eine wesentliche Fähigkeit, zu lernen, wie man sie effektiv steuert.

      Von Justin Ellingwood



      Source link

      Lesen und Einrichten von Umgebungs- und Shell-Variablen unter Linux


      Einführung

      Wenn Sie mit Ihrem Server über eine Shell-Sitzung interagieren, gibt es viele Informationen, die Ihre Shell kompiliert, um ihr Verhalten und den Zugriff auf Ressourcen zu bestimmen. Einige dieser Einstellungen sind innerhalb der Konfigurationseinstellungen enthalten und andere werden durch Benutzereingabe bestimmt.

      Eine Möglichkeit, wie die Shell alle diese Einstellungen und Details verfolgt, ist ein Bereich, den sie als Umgebung bezeichnet. Die Umgebung ist ein Bereich, den die Shell jedes Mal, wenn sie eine Sitzung startet, erstellt und der Variablen enthält, die Systemeigenschaften definieren.

      In diesem Leitfaden besprechen wir, wie Sie mit der Umgebung interagieren und Umgebungs- und Shell-Variablen interaktiv und über Konfigurationsdateien lesen oder einrichten.

      Funktionsweise der Umgebung und Umgebungsvariablen

      Bei jedem Starten einer Shell-Sitzung findet ein Prozess statt, der Informationen sammelt und kompiliert, die dem Shell-Prozess und seinen Unterprozessen verfügbar sein sollen. Die Daten für diese Einstellungen bezieht er aus einer Vielzahl verschiedener Dateien und Einstellungen auf dem System.

      Die Umgebung stellt ein Medium bereit, über das der Shell-Prozess Einstellungen erhalten oder einrichten kann und diese wiederum an seine Unterprozesse weitergibt.

      Die Umgebung ist als Zeichenketten implementiert, die Schlüsselwertpaare darstellen. Werden mehrere Werte übergeben, werden sie typischerweise durch Doppelpunkte (:) getrennt. Jedes Paar sieht allgemein etwa so aus:

      KEY=value1:value2:...
      

      Wenn der Wert signifikante Leerzeichen enthält, werden Anführungszeichen verwendet:

      KEY="value with spaces"
      

      Die Schlüssel in diesen Szenarien sind Variablen. Sie können einer von zwei Typen sein, Umgebungsvariablen oder Shell-Variablen.

      Umgebungsvariablen sind Variablen, die für die aktuelle Shell definiert sind und an alle untergeordneten Shells oder Prozesse vererbt werden. Umgebungsvariablen werden verwendet, um Informationen an Prozesse zu übergeben, die von der Shell gestartet werden.

      Shell-Variablen sind Variablen, die ausschließlich innerhalb der Shell enthalten sind, in der sie festgelegt oder definiert wurden. Sie werden oft verwendet, um kurzlebige Daten wie das aktuelle Arbeitsverzeichnis zu verfolgen.

      Gemäß der Konvention werden diese Arten von Variablen normalerweise mit Großbuchstaben definiert. Dies hilft dem Benutzer, Umgebungsvariablen innerhalb anderer Kontexte zu unterscheiden.

      Ausgeben von Shell- und Umgebungsvariablen

      Jede Shell-Sitzung verfolgt ihre eigenen Shell- und Umgebungsvariablen. Wir können auf diese auf verschiedene Weise zugreifen.

      Wir können eine Liste aller unsere Umgebungsvariablen sehen, indem wir die Befehle env oder printenv verwenden. In ihrem Standardzustand sollten sie genau gleich funktionieren:

      Output

      SHELL=/bin/bash TERM=xterm USER=demouser LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:su=37;41:sg=30;43:ca:... MAIL=/var/mail/demouser PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games PWD=/home/demouser LANG=en_US.UTF-8 SHLVL=1 HOME=/home/demouser LOGNAME=demouser LESSOPEN=| /usr/bin/lesspipe %s LESSCLOSE=/usr/bin/lesspipe %s %s _=/usr/bin/printenv

      Dies ist ziemlich typisch für die Ausgabe sowohl von printenv als auch env. Der Unterschied zwischen den beiden Befehlen ist nur in ihrer spezifischeren Funktionalität sichtbar. Beispielsweise können Sie mit printenv die Werte einzelner Variablen anfordern:

      Output

      /bin/bash

      Mit env hingegen können Sie die Umgebung, in der Programme ausgeführt werden, ändern, indem Sie einen Satz von Variablendefinitionen wie folgt an einen Befehl übergeben:

      • env VAR1="value" command_to_run command_options

      Da, wie wir vorstehend gelernt haben, untergeordnete Prozesse typischerweise die Umgebungsvariablen des übergeordneten Prozesses erben, bietet Ihnen dies die Möglichkeit, Werte zu überschreiben oder zusätzliche Variablen für den untergeordneten Prozess hinzuzufügen.

      Wie Sie in der Ausgabe unseres Befehls printenv sehen können, gibt es eine ganze Reihe von Umgebungsvariablen, die, ohne unsere Eingabe, durch unsere Systemdateien und Prozesse eingerichtet wurden.

      Diese zeigen die Umgebungsvariablen, aber wie sehen wir Shell-Variablen?

      Hierfür kann der Befehl set verwendet werden. Wenn wir set ohne zusätzliche Parameter eingeben, erhalten wir eine Liste aller Shell-Variablen, Umgebungsvariablen, lokalen Variablen und Shell-Funktionen:

      Output

      BASH=/bin/bash BASHOPTS=checkwinsize:cmdhist:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath BASH_ALIASES=() BASH_ARGC=() BASH_ARGV=() BASH_CMDS=() . . .

      Dies ist normalerweise eine riesige Liste. Wahrscheinlich möchten Sie sie in ein Pager-Programm leiten, um die Menge der Ausgabe leichter bewältigen zu können:

      Die Menge zusätzlicher Informationen, die wir zurückerhalten, ist etwas überwältigend. Wahrscheinlich müssen wir nicht alle Bash-Funktionen kennen, die beispielsweise definiert sind.

      Wir können die Ausgabe bereinigen, indem wir angeben, dass set im POSIX-Modus arbeiten soll, wodurch die Shell-Funktionen nicht ausgegeben werden. Wir können dies in einer Unter-Schell ausführen, sodass es unsere aktuelle Umgebung nicht verändert:

      Dies listet alle Umgebungs- und Shell-Variablen auf, die definiert sind.

      Wir können versuchen, diese Ausgabe mit der Ausgabe der Befehle env oder printenv zu vergleichen, um zu versuchen, nur eine Liste der Shell-Variablen zu erhalten, aber dies wird aufgrund der unterschiedlichen Art und Weise, wie diese Befehle Informationen ausgeben, nicht perfekt sein:

      • comm -23 <(set -o posix; set | sort) <(env | sort)

      Es werden wahrscheinlich immer noch einige Umgebungsvariablen enthalten sein, da der Befehl set Werte in Anführungszeichen ausgibt, währen die Befehle printenv und env die Werte von Zeichenketten nicht in Anführungszeichen setzen.

      Dennoch sollte dies Ihnen einen guten Überblick über die Umgebungs- und Shell-Variablen geben, die in Ihrer Sitzung festgelegt sind.

      Diese Variablen werden für alle möglichen Dinge verwendet. Sie bieten einen alternativen Weg, um zwischen Prozessen dauerhafte Werte für die Sitzung zu setzen, ohne Änderungen in eine Datei zu schreiben.

      Häufige Umgebungs- und Shell-Variablen

      Einige Umgebungs- und Shell-Variablen sind sehr nützlich und werden ziemlich oft referenziert. Hier sind einige häufige Umgebungsvariablen, denen Sie begegnen werden:

      • SHELL: Dies beschreibt die Shell, die alle von Ihnen eingegebenen Befehle interpretiert. In den meisten Fällen wird dies standardmäßig Bash sein, jedoch können auch andere Werte festgelegt werden, wenn Sie andere Optionen bevorzugen.
      • TERM: Dies gibt die Art des Terminals an, das bei der Ausführung der Shell emuliert werden soll. Es können verschiedene Hardware-Terminals für unterschiedliche Betriebsanforderungen emuliert werden. Normalerweise müssen Sie sich darüber aber keine Gedanken machen.
      • USER: Der aktuelle angemeldete Benutzer.
      • PWD: Das aktuelle Arbeitsverzeichnis.
      • OLDPWD: Das vorherige Arbeitsverzeichnis. Dieses wird von der Shell beibehalten, um durch Ausführen von cd - wieder in Ihr vorheriges Verzeichnis zu wechseln.
      • LS_COLORS: Dies definiert Farbcodes, die verwendet werden, um dem Befehl Is optional eine farbige Ausgabe hinzuzufügen. Dies wird verwendet, um verschiedene Dateitypen zu unterscheiden und dem Benutzer auf einen Blick mehr Informationen zu bieten.
      • MAIL: Der Pfad zur Mailbox des aktuellen Benutzers.
      • PATH: Eine Liste von Verzeichnissen, die das System bei der Suche nach Befehlen überprüfen wird. Wenn ein Benutzer einen Befehl eingibt, überprüft das System die Verzeichnisse in dieser Reihenfolge auf die ausführbare Datei.
      • LANG: Die aktuelle Sprach- und Lokalisierungseinstellungen, einschließlich der Zeichencodierung.
      • HOME: Das Heimatverzeichnis des aktuellen Benutzers.
      • _: Der letzte zuvor ausgeführte Befehl.

      Zusätzlich zu diesen Umgebungsvariablen gibt es noch einige Shell-Variablen, die Sie oft sehen werden:

      • BASHOPTS: Die Liste der Optionen, die bei der Ausführung von Bash verwendet wurden. Dies kann nützlich sein, um herauszufinden, ob die Shell-Umgebung so funktioniert, wie Sie es wünschen.
      • BASH_VERSION: Die Version von Bash, die ausgeführt wird, in menschenlesbarer Form.
      • BASH_VERSINFO: Die Version von Bash, in maschinenlesbarer Ausgabe.
      • COLUMNS: Die Anzahl der Spaltenbreite, die zur Ausgabe auf dem Bildschirm verwendet wird.
      • DIRSTACK: Der Stack von Verzeichnissen, die mit den Befehlen pushd und popd verfügbar sind.
      • HISTFILESIZE: Anzahl der Zeilen der Befehlshistorie, die in einer Datei gespeichert werden.
      • HISTSIZE: Anzahl der Zeilen der Befehlshistorie, die im Speicher erlaubt sind.
      • HOSTNAME: Der Hostname des Computers zu diesem Zeitpunkt.
      • IFS: Das interne Feldtrennzeichen zur Trennung der Eingabe in der Befehlszeile. Standardmäßig ist dies ein Leerzeichen.
      • PS1: Die primäre Definition der Eingabeaufforderung. Damit wird definiert, wie Ihre Eingabeaufforderung beim Starten einer Shell-Sitzung aussieht. Der PS2 wird verwendet, um sekundäre Eingabeaufforderungen zu deklarieren, wenn sich ein Befehl über mehrere Zeilen erstreckt.
      • SHELLOPTS: Shell-Optionen, die mit der Option set festgelegt werden können.
      • UID: Die UID des aktuellen Benutzers.

      Einstellen von Shell- und Umgebungsvariablen

      Um den Unterschied zwischen Shell- und Umgebungsvariablen besser zu verstehen und die Syntax für die Einstellung dieser Variablen einzuführen, werden wir eine kleine Demonstration durchführen.

      Erstellen von Shell-Variablen

      Wir beginnen mit der Definition einer Shell-Variable innerhalb unserer aktuellen Sitzung. Dies ist einfach zu erreichen; wir müssen nur einen Namen und einen Wert angeben. Wir halten uns an die Konvention, den Variablennamen in Großbuchstaben zu schreiben, und setzen ihn auf eine einfache Zeichenkette.

      Hier haben wir Anführungszeichen verwendet, da der Wert unserer Variable ein Leerzeichen enthält. Außerdem haben wir einfache Anführungszeichen verwendet, weil das Ausrufezeichen ein Sonderzeichen in der Bash-Shell ist, das sich normalerweise in den Bash-Verlauf ausdehnt, wenn es nicht mit einem Escape-Zeichen versehen oder in einfache Anführungszeichen gesetzt wird.

      Wir haben nun eine Shell-Variable. Diese Variable ist in unserer aktuellen Sitzung verfügbar, wird aber nicht an untergeordnete Prozesse übergeben.

      Wir können dies sehen, indem wir mit dem Befehl „grep“ in der Ausgabe set nach unserer neuen Variable suchen:

      Output

      TEST_VAR='Hello World!'

      Wir können überprüfen, dass es sich nicht um eine Umgebungsvariable handelt, indem wir das Gleiche mit printenv versuchen:

      Es sollte keine Ausgabe zurückgegeben werden.

      Nehmen wir dies zum Anlass, eine Möglichkeit zu demonstrieren, wie auf den Wert einer beliebigen Shell- oder Umgebungsvariablen zugegriffen werden kann.

      Output

      Hello World!

      Wie Sie sehen können, referenzieren Sie den Wert einer Variable, indem Sie ihr ein $-Zeichen voranstellen. Die Shell bezeichnet damit, dass sie den Wert der Variable ersetzen soll, wenn sie auf diese stößt.

      Jetzt haben wir eine Shell-Variable. Sie sollte nicht an untergeordnete Prozesse übergeben werden. Wir können zur Demonstration eine neue Bash-Shell aus unserer aktuellen heraus starten:

      Wenn wir bash eingeben, um eine untergeordnete Shell zu starten, und dann versuchen, auf den Inhalt der Variable zuzugreifen, wird nichts zurückgegeben. Das haben wir erwartet.

      Gehen Sie zurück zu unserer ursprünglichen Shell, indem Sie exit eingeben:

      Erstellen von Umgebungsvariablen

      Lassen Sie uns nun unsere Shell-Variable in eine Umgebungsvariable verwandeln. Wir können dies tun, indem wir die Variable exportieren. Der Befehl dazu heiß passenderweise:

      Dadurch wird unsere Variable in eine Umgebungsvariable umgewandelt. Wir können dies überprüfen, indem wir unsere Umgebungsliste erneut überprüfen:

      Output

      TEST_VAR=Hello World!

      Diesmal wird unsere Variable angezeigt. Versuchen wir unser Experiment mit unserer untergeordneten Shell:

      Output

      Hello World!

      Klasse! Unsere untergeordnete Shell hat die Variable, die von ihrer übergeordneten Shell gesetzt wurde, erhalten. Bevor wir diese untergeordnete Shell verlassen, versuchen wir, eine andere Variable zu exportieren. Wir können Umgebungsvariablen in einem einzigen Schritt wie folgt setzen:

      • export NEW_VAR="Testing export"

      Testen Sie, dass sie als Umgebungsvariable exportiert wird:

      Output

      NEW_VAR=Testing export

      Lassen Sie uns nun wieder in unsere ursprüngliche Shell gehen:zurückkehren:

      Sehen wir, ob unsere neue Variable verfügbar ist:

      Es wird nichts zurückgegeben.

      Das liegt daran, dass Umgebungsvariablen nur an untergeordnete Prozesse übergeben werden. Es gibt keine integrierte Möglichkeit, Umgebungsvariablen der übergeordneten Shell zu setzen. Dies ist in den meisten Fällen gut und verhindert, dass Programme die Betriebsumgebung beeinträchtigen, aus der sie aufgerufen wurden.

      Die Variable NEW_VAR wurde in unserer untergeordneten Shell als Umgebungsvariable gesetzt. Diese Variable würde für sie selbst und alle untergeordneten Shells und Prozesse verfügbar sein. Beim Verlassen zurück in unsere Haupt-Shell wurde diese Umgebung zerstört.

      Herunterstufen und Zurücksetzen von Variablen

      Wir haben noch immer unsere Variable TEST_VAR als Umgebungsvariable definiert. Wir können sie wieder in eine Shell-Variable umwandeln, indem wir Folgendes eingeben:

      Sie ist keine Umgebungsvariable mehr:

      Sie ist jedoch noch immer eine Shell-Variable:

      Output

      TEST_VAR='Hello World!'

      Wenn wir eine Variable, egal ob Shell- oder Umgebungsvariable, komplett zurücksetzen möchten, können wir dies mit dem Befehl unset tun:

      Wir können überprüfen, dass sie nicht mehr gesetzt ist:

      Es wird nichts zurückgegeben, da die Variable zurückgesetzt wurde.

      Setzen von Umgebungsvariablen bei der Anmeldung

      Wir haben bereits erwähnt, dass viele Programme Umgebungsvariablen verwenden, um die Besonderheiten der Funktionsweise zu entscheiden. Wir wollen nicht jedes Mal, wenn wir eine neue Shell-Sitzung starten, wichtige Variablen setzen müssen, und wir haben bereits gesehen, wie viele Variablen beim Anmelden bereits gesetzt sind, also wie können wir Variablen automatisch erstellen und definieren?

      Dies ist tatsächlich ein komplexeres Problem, als es auf den ersten Blick scheint, aufgrund der zahlreichen Konfigurationsdateien, die die Bash-Shell liest, je nachdem, wie sie gestartet wird.

      Der Unterschied zwischen Anmelde-, Nicht-Anmelde-, interaktiven und nicht-interaktiven Shell-Sitzungen

      Die Bash-Shell liest verschiedene Konfigurationsdateien, je nachdem, wie die Sitzung gestartet wird.

      Ein Unterschied zwischen verschiedenen Sitzungen ist, ob die Shell als Anmelde- oder Nicht-Anmelde-Sitzung gestartet wird.

      Eine Anmelde-Shell ist eine Shell-Sitzung, die mit der Authentifizierung des Benutzers beginnt. Wenn Sie sich in einer Terminal-Sitzung oder über SSH anmelden und sich authentifizieren, wird Ihre Shell-Sitzung als Anmelde-Shell gesetzt.

      Wenn Sie aus Ihrer authentifizierten Sitzung eine neue Shell-Sitzung starten, wie wir es mit dem Aufruf des Befehls bash über das Terminal getan haben, wird eine Nicht-Anmelde-Shell-Sitzung gestartet. Sie wurden beim Start Ihrer untergeordneten Shell nicht nach Ihren Authentifizierungsdetails gefragt.

      Eine weitere Unterscheidung, die vorgenommen werden kann, ist, ob eine Shell-Sitzung interaktiv oder nicht interaktiv ist.

      Eine interaktive Shell-Sitzung ist eine Shell-Sitzung, die an ein Terminal gebunden ist. Eine nicht interaktive Shell-Sitzung ist eine Shell-Sitzung, die nicht an eine Terminal-Sitzung gebunden ist.

      Jede Shell-Sitzung wird also entweder als Anmelde oder Nicht-Anmelde und interaktiv oder nicht interaktiv klassifiziert.

      Eine normale Sitzung, die mit SSH beginnt, ist normalerweise eine interaktive Anmelde-Shell. Ein Skript, das von der Befehlszeile ausgeführt wird, wird normalerweise in einer nicht interaktiven, Nicht-Anmelde-Shell ausgeführt. Eine Terminal-Sitzung kann eine beliebige Kombination dieser beiden Eigenschaften sein.

      Ob eine Shell-Sitzung als Anmelde- oder Nicht-Anmelde-Shell klassifiziert wird, hat Auswirkungen darauf, welche Dateien zur Initialisierung der Shell-Sitzung gelesen werden.

      Eine als Anmelde-Sitzung gestartete Sitzung liest zuerst die Konfigurationsdetails aus der Datei /etc/profile. Sie sucht nach der ersten Anmelde-Shell-Konfigurationsdatei im Heimatverzeichnis des Benutzers, um benutzerspezifische Konfigurationsdetails zu erhalten.

      Sie liest die erste Datei, die sie aus ~/.bash_profile, ~/.bash_login und ~/.profile finden kann, und liest keine weiteren Dateien.

      Im Gegensatz dazu liest eine als Nicht-Anmelde-Shell definierte Sitzung /etc/bash.bashrc und dann die benutzerspezifische Datei ~/.bashrc, um ihre Umgebung zu erstellen.

      Nicht-interaktive Shells lesen die Umgebungsvariable namens BASH_ENV und lesen die angegebene Datei, um die neue Umgebung zu definieren.

      Implementieren von Umgebungsvariablen

      Wie Sie sehen können, gibt es eine Vielzahl von verschiedenen Dateien, die wir normalerweise für die Platzierung unserer Einstellungen ansehen müssten.

      Dies bietet eine Menge Flexibilität, die in bestimmten Situationen hilfreich sein kann, in denen wir bestimmte Einstellungen in einer Anmelde-Shell und andere Einstellungen in einer Nicht-Anmelde-Shell wünschen. Die meiste Zeit werden jedoch die gleichen Einstellungen in beiden Situationen wünschen.

      Glücklicherweise konfigurieren die meisten Linux-Distributionen die Anmelde-Konfigurationsdateien als Quelle für die Nicht-Anmelde-Konfigurationsdateien. Das bedeutet, dass Sie Umgebungsvariablen, die Sie in beiden Fällen benötigen, in den Nicht-Anmelde-Konfigurationsdateien definieren können. Sie werden dann in beiden Szenarien gelesen.

      Normalerweise werden wir benutzerspezifische Umgebungsvariablen setzen, und wir werden normalerweise wünschen, dass unsere Einstellungen sowohl in Anmelde- als auch Nicht-Anmelde-Shells verfügbar sind. Das bedeutet, dass sich der Ort zur Definition dieser Variablen in der Datei ~/.bashrc befindet.

      Öffnen Sie nun diese Datei:

      Diese wird wahrscheinlich bereits eine ganze Menge Daten enthalten. Die meisten Definitionen hier sind für das Setzen von Bash-Optionen, wobei diese nichts mit Umgebungsvariablen zu tun haben. Sie können Umgebungsvariablen genauso setzen wie Sie es über die Befehlszeile tun würden:

      Neue Umgebungsvariablen können an beliebiger Stelle in der Datei ~/.bashrc eingefügt werden, solange sie nicht in der Mitte eines anderen Befehls oder einer for-Schleife stehen. Anschließend können wir die Datei speichern und schließen. Wenn Sie das nächste Mal eine Shell-Sitzung starten, wird Ihre Umgebungsvariablendeklaration gelesen und an die Shell-Umgebung übergeben. Sie können Ihre aktuelle Sitzung zwingen, die Datei nun zu lesen, indem Sie Folgendes eingeben:

      Wenn Sie systemweite Variablen setzen müssen, sollten Sie darüber nachdenken, diese in /etc/profile, /etc/bash.bashrc oder /etc/environment hinzuzufügen.

      Zusammenfassung

      Umgebungs- und Shell-Variablen sind in Ihren Shell-Sitzungen immer vorhanden und können sehr nützlich sein. Sie sind eine interessante Möglichkeit für einen übergeordneten Prozess, die Konfigurationsdetails für seinen untergeordneten Prozess festzulegen und bieten eine Möglichkeit, Optionen außerhalb von Dateien zu setzen.

      Dies hat in bestimmten Situationen viele Vorteile. Einige Bereitstellungsmechanismen verlassen sich beispielsweise auf Umgebungsvariablen, um Authentifizierungsinformationen zu konfigurieren. Dies ist nützlich, da es nicht erforderlich ist, diese in Dateien zu halten, die von Außenstehenden gesehen werden können.

      Es gibt viele andere, alltäglichere, aber häufigere Szenarien, in denen Sie die Umgebung Ihres Systems auslesen oder ändern müssen. Diese Tools und Techniken sollten Ihnen eine gute Grundlage für die Durchführung dieser Änderungen und die korrekte Verwendung bieten.



      Source link

      Verwenden von Find und Locate zur Suche nach Dateien unter Linux


      Einführung

      Ein Problem, auf das Benutzer stoßen, wenn sie zum ersten Mal mit einem Linux-Rechner arbeiten, ist die Frage, wie Sie die gesuchten Dateien finden können.

      Dieser Leitfaden behandelt die Verwendung des treffend benannten Befehls find Dies hilft Ihnen bei der Suche nach Dateien auf Ihrem VPS unter Verwendung einer Vielzahl von Filtern und Parametern. Wir werden auch kurz auf den Befehl locate eingehen, mit dem Sie auf andere Weise nach Dateien suchen können.

      Suchen nach Name

      Die offensichtlichste Möglichkeit der Suche nach Dateien ist nach Name.

      Um eine Datei anhand ihres Namens zu finden, geben Sie Folgendes ein:

      Dabei wird die Groß- und Kleinschreibung beachtet, d. h. eine Suche nach file unterscheidet sich von einer Suche nach File.

      Um eine Datei nach dem Namen zu suchen, aber die Groß-/Kleinschreibung der Abfrage zu ignorieren, geben Sie Folgendes ein:

      Wenn Sie alle Dateien finden möchten, die sich nicht an ein bestimmtes Muster halten, können Sie die Suche mit -not oder ! umkehren. Wenn Sie ! verwenden, müssen Sie das Zeichen Maskieren, damit die Bash nicht versucht, es zu interpretieren, bevor „find“ agieren kann:

      • find -not -name "query_to_avoid"

      Oder

      • find ! -name "query_to_avoid"

      Suchen nach Typ

      Sie können den Typ der Dateien angeben, die Sie mit dem Parameter -type finden möchten. Es funktioniert wie folgt:

      • find -type type_descriptor query

      Einige der gebräuchlichsten Deskriptoren, die Sie zur Angabe des Dateityps verwenden können, sind:

      • f: reguläre Datei

      • d: Verzeichnis

      • l: symbolischer Link

      • c: Zeichengeräte

      • b: Blockgeräte

      Wenn wir beispielsweise alle Zeichengeräte in unserem System finden möchten, könnten wir diesen Befehl ausgeben:

      Output

      /dev/parport0 /dev/snd/seq /dev/snd/timer /dev/autofs /dev/cpu/microcode /dev/vcsa7 /dev/vcs7 /dev/vcsa6 /dev/vcs6 /dev/vcsa5 /dev/vcs5 /dev/vcsa4 . . .

      Wir können nach allen Dateien suchen, die in .conf enden:

      • find / -type f -name "*.conf"

      Output

      /var/lib/ucf/cache/:etc:rsyslog.d:50-default.conf /usr/share/base-files/nsswitch.conf /usr/share/initramfs-tools/event-driven/upstart-jobs/mountall.conf /usr/share/rsyslog/50-default.conf /usr/share/adduser/adduser.conf /usr/share/davfs2/davfs2.conf /usr/share/debconf/debconf.conf /usr/share/doc/apt-utils/examples/apt-ftparchive.conf . . .

      Filtern nach Zeit und Größe

      „Find“ bietet Ihnen eine Vielzahl von Möglichkeiten, um Ergebnisse nach Größe und Zeit zu filtern.

      Größe

      Sie können mit dem Parameter -size nach Größe filtern.

      Wir fügen ein Suffix am Ende unseres Wertes hinzu, das angibt, wie wir zählen. Dies sind einige beliebte Optionen:

      • c: Bytes

      • k: Kilobytes

      • M: Megabytes

      • G: Gigabytes

      • b: 512-Byte-Blöcke

      Um alle Dateien zu finden, die genau 50 Bytes groß sind, geben Sie Folgendes ein:

      Um alle Dateien zu finden, die kleiner als 50 Bytes sind, können wir stattdessen diese Form verwenden:

      Um alle Dateien zu finden, die größer als 700 Megabytes sind, können wir diesen Befehl verwenden:

      Zeit

      Linux speichert Zeitdaten über Zugriffszeiten, Modifizierungszeiten und Änderungszeiten.

      • Zugriffszeit: Letzter Zeitpunkt, in dem eine Datei gelesen oder geschrieben wurde.

      • Modifizierungszeit: Letzter Zeitpunkt, an dem der Inhalt der Datei modifiziert wurde.

      • Änderungszeit: Letzter Zeitpunkt, an dem die Inode-Metadaten der Datei geändert wurden.

      Wir können diese mit den Parametern -atime, -mtime und -ctime verwenden. Diese können die Plus- und Minus-Symbole verwenden, um größer als oder kleiner als anzugeben, wie wir es bei der Größe getan haben.

      Der Wert dieses Parameters gibt an, wie viele zurückliegende Tage Sie suchen möchten.

      Um Dateien zu finden, die eine Modifizierungszeit von vor einem Tag haben, geben Sie Folgendes ein:

      Wenn wir Dateien möchten, auf die vor weniger als einem Tag zugegriffen wurden, können wir Folgendes eingeben:

      Um Dateien zu erhalten, deren letzte Änderung der Metadaten mehr als 3 Tage zurückliegt, geben Sie Folgendes ein:

      Es gibt auch einige Begleitparameter, mir denen wir Minuten anstelle von Tagen angeben können:

      Dadurch werden die Dateien angegeben, die in der letzten Minute im System modifiziert wurden.

      „Find“ kann auch Vergleiche gegen eine Referenzdatei durchführen und diejenigen zurückgeben, die neuer sind:

      Suchen nach Eigentümern und Berechtigungen

      Sie können auch nach Dateien anhand des Dateieigentümers oder des Gruppeneigentümers suchen.

      Dazu verwenden Sie die Parameter -user bzw. -group. Suchen Sie eine Datei, deren Eigentümer der Benutzer „syslog“ ist, indem Sie Folgendes eingeben:

      Ähnlich können wir Dateien angeben, deren Eigentümer die Gruppe „shadow“ ist, indem wir Folgendes eingeben:

      Wir können auch nach Dateien mit bestimmten Berechtigungen suchen.

      Wenn wir einen genauen Satz von Berechtigungen abgleichen möchten, verwenden wir diese Form:

      Dies gleicht Dateien mit genau den angegebenen Berechtigungen ab.

      Wenn wir etwas mit zumindest diesen Berechtigungen angeben möchten, können Sie diese Form verwenden:

      Dies gleicht alle Dateien ab, die zusätzliche Berechtigungen aufweisen. Eine Datei mit der Berechtigung „744“ würde in diesem Fall gefunden werden.

      Filtern nach Tiefe

      Für diesen Abschnitt erstellen wir eine Verzeichnisstruktur in einem temporären Verzeichnis. Es enthält drei Verzeichnisebenen, mit zehn Verzeichnissen auf der ersten Ebene. Jedes Verzeichnis (einschließlich des temporären Verzeichnisses) enthält zehn Dateien und zehn Unterverzeichnisse.

      Erstellen Sie diese Struktur durch Ausgabe der folgenden Befehle:

      • cd
      • mkdir -p ~/test/level1dir{1..10}/level2dir{1..10}/level3dir{1..10}
      • touch ~/test/{file{1..10},level1dir{1..10}/{file{1..10},level2dir{1..10}/{file{1..10},level3dir{1..10}/file{1..10}}}}
      • cd ~/test

      Sie können sich die Verzeichnisstrukturen mit ls und cd ansehen, um einen Überblick über die Organisation zu erhalten. Wenn Sie fertig sind, kehren Sie in das Testverzeichnis zurück:

      Wir werden uns damit beschäftigen, wie bestimmte Dateien aus dieser Struktur zurückgegeben werden. Versuchen wir zunächst ein Beispiel mit einer regulären Namenssuche, zum Vergleich:

      Output

      ./level1dir7/level2dir8/level3dir9/file1 ./level1dir7/level2dir8/level3dir3/file1 ./level1dir7/level2dir8/level3dir4/file1 ./level1dir7/level2dir8/level3dir1/file1 ./level1dir7/level2dir8/level3dir8/file1 ./level1dir7/level2dir8/level3dir7/file1 ./level1dir7/level2dir8/level3dir2/file1 ./level1dir7/level2dir8/level3dir6/file1 ./level1dir7/level2dir8/level3dir5/file1 ./level1dir7/level2dir8/file1 . . .

      Es gibt eine Menge Ergebnisse. Wenn wir die Ausgabe in einen Zähler leiten, können wir sehen, dass es insgesamt 1111 Ergebnisse gibt:

      Output

      1111

      Das sind wahrscheinlich zu viele Ergebnisse, um für Sie in den meisten Fällen nützlich zu sein. Versuchen wir, dies einzugrenzen.

      Sie können die maximale Tiefe der Suche unter dem Suchverzeichnis auf höchster Ebene festlegen:

      • find -maxdepth num -name query

      Um „file1“ nur in den Verzeichnissen „level1“ und höher zu finden, können Sie eine maximale Tiefe von 2 (1 für das Verzeichnis auf höchster Ebene und 1 für die Verzeichnisse level1) festlegen:

      • find -maxdepth 2 -name file1

      Output

      ./level1dir7/file1 ./level1dir1/file1 ./level1dir3/file1 ./level1dir8/file1 ./level1dir6/file1 ./file1 ./level1dir2/file1 ./level1dir9/file1 ./level1dir4/file1 ./level1dir5/file1 ./level1dir10/file1

      Das ist eine wesentlich besser verwaltbare Liste.

      Sie können auch ein Mindestverzeichnis angeben, wenn Sie wissen, dass alle Dateien ab einem bestimmten Punkt unter dem aktuellen Verzeichnis bestehen:

      • find -mindepth num -name query

      Wir können dies verwenden, um nur die Dateien am Ende der Verzeichniszweige zu finden:

      • find -mindepth 4 -name file

      Output

      ./level1dir7/level2dir8/level3dir9/file1 ./level1dir7/level2dir8/level3dir3/file1 ./level1dir7/level2dir8/level3dir4/file1 ./level1dir7/level2dir8/level3dir1/file1 ./level1dir7/level2dir8/level3dir8/file1 ./level1dir7/level2dir8/level3dir7/file1 ./level1dir7/level2dir8/level3dir2/file1 . . .

      Wiederum wird dies aufgrund unserer verzweigten Verzeichnisstruktur eine große Anzahl von Ergebnissen (1000) zurückgegeben.

      Sie können die Parameter Min- und Max-Tiefe kombinieren, um sich auf einen engen Bereich zu konzentrieren:

      • find -mindepth 2 -maxdepth 3 -name file

      Output

      ./level1dir7/level2dir8/file1 ./level1dir7/level2dir5/file1 ./level1dir7/level2dir7/file1 ./level1dir7/level2dir2/file1 ./level1dir7/level2dir10/file1 ./level1dir7/level2dir6/file1 ./level1dir7/level2dir3/file1 ./level1dir7/level2dir4/file1 ./level1dir7/file1 . . .

      Ausführen und Kombinieren von „Find“-Befehlen

      Sie können einen beliebigen Hilfsbefehl auf alles, was „find“ findet, ausführen, indem Sie den Parameter -exec verwenden. Dieser wird wie folgt aufgerufen:

      • find find_parameters -exec command_and_params {} ;

      Die {} werden als Platzhalter für die Dateien verwendet, die „find“ findet. Das ; wird verwendet, damit „find“ weiß, wo der Befehl endet.

      Wir könnten beispielsweise die Dateien im vorherigen Abschnitt finden, die 644 Berechtigungen aufwiesen, und sie so ändern, dass sie 664 Berechtigungen aufweisen:

      • cd ~/test
      • find . -type f -perm 644 -exec chmod 664 {} ;

      Wir könnten dann die Verzeichnisberechtigungen wie folgt ändern:

      • find . -type d -perm 755 -exec chmod 700 {} ;

      Wenn Sie verschiedene Ergebnisse miteinander verketten möchten, können Sie die Befehle -and oder -or verwenden. Das -and wird angenommen, wenn es weggelassen wird.

      • find . -name file1 -or -name file9

      Suchen von Dateien unter Verwendung von „locate“

      Eine Alternative zur Verwendung von find, ist der Befehl locate. Dieser Befehl ist oft schneller und kann das gesamte Dateisystem mit Leichtigkeit durchsuchen.

      Sie können den Befehl unter Debian oder Ubuntu mit apt installieren:

      Unter CentOS verwenden Sie stattdessen dnf:

      Der Grund, warum locate schneller ist als find, ist, dass er sich auf eine Datenbank der Dateien im Dateisystem verlässt.

      Die Datenbank wird normalerweise einmal täglich mit einem Cron-Skript aktualisiert, aber Sie können sie manuell aktualisieren, indem Sie Folgendes eingeben:

      Führen Sie diesen Befehl nun aus. Denken Sie daran, dass die Datenbank immer aktuell sein muss, wenn Sie kürzlich erworbene oder erstellte Dateien finden möchten.

      Um Dateien mit „locate“ zu finden, verwenden Sie einfach diese Syntax:

      Sie können die Ausgabe auf einige Arten filtern.

      Um beispielsweise nur Dateien zurückzugeben, die die Abfrage selbst enthalten, anstatt jede Datei zurückzugeben, die die Abfrage in den Verzeichnissen aufweist, die zu ihr führen, können Sie das -b verwenden, um nur den „Basisnamen“ zu suchen:

      Wenn „locate“ nur Ergebnisse zurückgeben soll, die noch im Dateisystem vorhanden sind (die nicht zwischen dem letzten Aufruf von updatedb und dem aktuellen Aufruf von locate entfernt wurden), verwenden Sie das Flag -e:

      Um eine Statistik über die Informationen anzuzeigen, die „locate“ katalogisiert hat, verwenden Sie die Option -S:

      Output

      Database /var/lib/mlocate/mlocate.db: 3,315 directories 37,228 files 1,504,439 bytes in file names 594,851 bytes used to store database

      Zusammenfassung

      Sowohl „find“ als auch „locate“ sind gute Methoden, um Dateien auf einem System zu finden. Es ist Ihnen überlassen zu entscheiden, welches dieser Tools in der jeweiligen Situation angemessen ist.

      „Find“ und „locate“ sind leistungsfähige Befehle, die durch die Kombination mit anderen Dienstprogrammen über noch verstärkt werden können. Experimentieren Sie mit der Filterung durch Verwendung von Befehlen wie wc, sort und grep.



      Source link