One place for hosting & domains

      Anzeigen

      Verwenden von Journalctl zum Anzeigen und Manipulieren von Systemd-Protokollen


      Einführung

      Einige der überzeugendsten Vorteile von systemd sind diejenigen, die mit der Prozess- und Systemprotokollierung verbunden sind. Bei der Verwendung anderer Tools werden Protokolle normalerweise im gesamten System verteilt, von verschiedenen Daemons und Prozessen bearbeitet und können ziemlich schwer zu interpretieren, wenn sie sich über mehrere Anwendungen erstrecken. Systemd versucht, diese Probleme zu lösen, indem es eine zentralisierte Verwaltungslösung zur Protokollierung aller Kernel- und Userland-Prozesse bereitstellt. Das System, das diese Protokolle sammelt und verwaltet, wird als Journal bezeichnet.

      Das Journal wird mit dem Daemon journald implementiert, der alle vom Kernel, initrd, services etc. erzeugten Nachrichten verarbeitet. In diesem Leitfaden besprechen wir die Verwendung des Dienstprogramms journalctl, mit dem Sie auf die in dem Journal gespeicherten Daten zugreifen und diese manipulieren können.

      Allgemeiner Gedanke

      Eine der Triebfedern hinter dem Journal systemd ist die Zentralisierung der Verwaltung von Protokollen, unabhängig davon, woher die Nachrichten stammen. Da ein Großteil des Boot-Prozesses und der Verwaltung von Diensten durch den Prozess systemd abgewickelt wird, ist es sinnvoll, die Art und Weise, wie Protokolle gesammelt und darauf zugegriffen wird, zu standardisieren. Der Daemon journald sammelt Daten aus allen verfügbaren Quellen und speichert sie in einem Binärformat für einfache und dynamische Manipulation.

      Dies bringt eine Reihe von bedeutenden Vorteilen mit sich. Durch die Interaktion mit den Daten über ein einziges Dienstprogramm sind Administratoren in der Lage, Protokolldaten dynamisch nach ihren Bedürfnissen anzuzeigen. Dies kann so einfach sein, wie das Anzeigen der Boot-Daten von vor drei Boot-Vorgängen oder das Kombinieren der Protokolleinträge von zwei verwandten Diensten nacheinander, um ein Kommunikationsproblem zu beheben.

      Das Speichern der Protokolldaten in einem Binärformat bedeutet auch, dass die Daten in beliebigen Ausgabeformaten angezeigt werden können, je nachdem, was Sie gerade benötigen. Für die tägliche Protokollverwaltung sind Sie eventuell daran gewöhnt, die Protokolle im Standard-Format syslog anzuzeigen, aber wenn Sie sich später entscheiden, Dienstunterbrechungen grafisch darzustellen, können Sie jeden Eintrag als JSON-Objekt ausgeben, um ihn für Ihren grafischen Dienst konsumierbar zu machen. Da die Daten nicht im Klartext auf die Festplatte geschrieben werden, ist keine Konvertierung erforderlich, wenn Sie ein anderes On-Demand-Format benötigen.

      Das Journal systemd kann entweder mit einer vorhandenen syslog-Implementierung verwendet werden oder es kann die Funktionalität syslog ersetzen, je nach Ihren Bedürfnissen. Während das Journal systemd die meisten Protokollierungsanforderungen von Administratoren abdeckt, kann es auch bestehende Protokollierungsmechanismen ergänzen. Sie haben vielleicht einen zentralisierten syslog-Server, den Sie verwenden, um Daten von mehreren Servern zu kompilieren, aber Sie möchten die Protokolle auch von mehreren Diensten auf einem einzigen System mit dem Journal systemd zusammenführen. Sie können beides tun, indem Sie diese Technologien kombinieren.

      Einstellen der Systemzeit

      Einer der Vorteile der Verwendung eines binären Journals für die Protokollierung ist die Fähigkeit, Protokolldatensätze in UTC oder lokaler Zeit anzuzeigen. Standardmäßig zeigt systemd Ergebnisse in der lokalen Zeit an.

      Aus diesem Grund stellen wir, bevor wir mit dem Journal beginnen, sicher, dass die Zeitzone korrekt eingestellt ist. Die Suite systemd verfügt über ein Tool namens timedatectl, das dabei helfen kann.

      Sehen Sie zuerst nach, welche Zeitzonen mit der Option list-timezones verfügbar sind:

      timedatectl list-timezones

      Dadurch werden die auf Ihrem System verfügbaren Zeitzonen aufgelistet. Wenn Sie diejenige gefunden haben, die dem Standort Ihres Servers entspricht, können Sie sie mit der Option set-timezone einstellen:

      sudo timedatectl set-timezone zone

      Um sicherzustellen, dass Ihr Rechner jetzt die richtige Zeit verwendet, verwenden Sie den Befehl timedatectl allein oder mit der Option status. Die Anzeige wird die gleiche sein:

      timedatectl status

            Local time: Thu 2015-02-05 14:08:06 EST
  Universal time: Thu 2015-02-05 19:08:06 UTC
        RTC time: Thu 2015-02-05 19:08:06
       Time zone: America/New_York (EST, -0500)
     NTP enabled: no
NTP synchronized: no
 RTC in local TZ: no
      DST active: n/a

      In der ersten Zeile sollte die korrekte Zeit angezeigt werden.

      Grundlegendes Anzeigen von Protokollen

      Um die Protokolle zu sehen, die der Daemon journald gesammelt hat, verwenden Sie den Befehl journalctl.

      Bei alleiniger Verwendung wird jeder im System vorhandene Journaleintrag innerhalb eines Pager (normalerweise less) angezeigt, damit Sie durchsuchen können. Die ältesten Einträge werden oben angezeigt:

      journalctl

      -- Logs begin at Tue 2015-02-03 21:48:52 UTC, end at Tue 2015-02-03 22:29:38 UTC. --
Feb 03 21:48:52 localhost.localdomain systemd-journal[243]: Runtime journal is using 6.2M (max allowed 49.
Feb 03 21:48:52 localhost.localdomain systemd-journal[243]: Runtime journal is using 6.2M (max allowed 49.
Feb 03 21:48:52 localhost.localdomain systemd-journald[139]: Received SIGTERM from PID 1 (systemd).
Feb 03 21:48:52 localhost.localdomain kernel: audit: type=1404 audit(1423000132.274:2): enforcing=1 old_en
Feb 03 21:48:52 localhost.localdomain kernel: SELinux: 2048 avtab hash slots, 104131 rules.
Feb 03 21:48:52 localhost.localdomain kernel: SELinux: 2048 avtab hash slots, 104131 rules.
Feb 03 21:48:52 localhost.localdomain kernel: input: ImExPS/2 Generic Explorer Mouse as /devices/platform/
Feb 03 21:48:52 localhost.localdomain kernel: SELinux:  8 users, 102 roles, 4976 types, 294 bools, 1 sens,
Feb 03 21:48:52 localhost.localdomain kernel: SELinux:  83 classes, 104131 rules

. . .

      Sie werden wahrscheinlich seitenweise Daten durchblättern müssen, die zehn- oder hunderttausende Zeilen lang sein können, wenn sich systemd schon lange auf Ihrem System befindet. Dies demonstriert, wie viele Daten in der Journal-Datenbank vorhanden sind.

      Das Format wird denjenigen vertraut sein, die an die Standard-Protokollierung syslog gewöhnt sind. Allerdings werden hier tatsächlich Daten aus mehr Quellen gesammelt als traditionelle syslog-Implementierungen in der Lage sind. Es beinhaltet Protokolle des frühen Boot-Prozesses, des Kernel, der initrd und der Anwendungsstandardfehler und -ausgänge. Diese sind alle im Journal verfügbar.

      Vielleicht fällt Ihnen auf, dass alle angezeigten Zeitstempel in lokaler Zeit sind. Dies ist für jeden Protokolleintrag verfügbar, da die lokale Zeit auf unserem System korrekt eingestellt ist. Alle Protokolle werden mit dieser neuen Information angezeigt.

      Wenn Sie die Zeitstempel in UTC anzeigen möchten, können Sie das Flag --utc verwenden:

      journalctl --utc

      Journal-Filterung nach Zeit

      Obwohl der Zugriff auf eine so große Datensammlung durchaus nützlich ist, kann es schwierig oder unmöglich sein, eine so große Menge mental zu untersuchen und zu verarbeiten. Aus diesem Grund ist eine der wichtigsten Funktionen von journalctl seine Filteroptionen.

      Anzeigen von Protokollen aus dem aktuellen Boot

      Die grundlegendste dieser Optionen, die Sie möglicherweise täglich verwenden, ist das Flag -b. Damit werden Ihnen alle Journaleinträge angezeigt, die seit dem neuesten Neustart gesammelt wurden.

      journalctl -b

      Dies hilft Ihnen, Informationen zu identifizieren und zu verwalten, die für Ihre aktuelle Umgebung relevant sind.

      In Fällen, in denen Sie diese Funktion nicht verwenden und mehr als einen Tag von Bootvorgängen anzeigen, werden Sie sehen, dass journalctl eine Zeile eingefügt hat, die so aussieht, wann immer das System heruntergefahren wurde:

      . . .

-- Reboot --

. . .

      Dies kann verwendet werden, um Ihnen dabei zu helfen, die Informationen logisch in Boot-Sitzungen aufzuteilen.

      Vergangene Bootvorgänge

      Während Sie in der Regel die Informationen aus dem aktuellen Bootvorgang anzeigen möchten, gibt es sicherlich Zeiten, in denen auch vergangene Bootvorgänge hilfreich sind. Das Journal kann Informationen von vielen vorherigen Bootvorgängen speichern, sodass journalctl eingestellt werden kann, um Informationen einfacher anzuzeigen.

      Bei einigen Distributionen ist das Speichern von Informationen zu früheren Bootvorgängen standardmäßig aktiviert, bei anderen ist diese Funktion deaktiviert. Um persistente Boot-Informationen zu aktivieren, können Sie entweder das Verzeichnis zum Speichern des Journals erstellen, indem Sie Folgendes eingeben:

      • sudo mkdir -p /var/log/journal

      Oder Sie können die Journal-Konfigurationsdatei bearbeiten:

      • sudo nano /etc/systemd/journald.conf

      Setzen Sie unter dem Abschnitt [Journal] die Option Storage= auf „persistent“, um die persistente Protokollierung zu aktivieren:

      /etc/systemd/journald.conf

      . . .
[Journal]
Storage=persistent

      Wenn das Speichern von vorherigen Bootvorgängen auf Ihrem Server aktiviert ist, stellt journalctl einige Befehle bereit, um Ihnen die Arbeit mit Bootvorgängen als Einheit der Division zu erleichtern. Um die Bootvorgänge zu sehen, von denen journald weiß, verwenden Sie die Option --list-boots mit journalctl:

      journalctl --list-boots

      -2 caf0524a1d394ce0bdbcff75b94444fe Tue 2015-02-03 21:48:52 UTC—Tue 2015-02-03 22:17:00 UTC
-1 13883d180dc0420db0abcb5fa26d6198 Tue 2015-02-03 22:17:03 UTC—Tue 2015-02-03 22:19:08 UTC
 0 bed718b17a73415fade0e4e7f4bea609 Tue 2015-02-03 22:19:12 UTC—Tue 2015-02-03 23:01:01 UTC

      Dies zeigt eine Zeile für jeden Bootvorgang an. Die erste Spalte ist der Offset für den Bootvorgang, der verwendet werden kann, um den Bootvorgang mit journalctl einfach zu referenzieren. Wenn Sie eine absolute Referenz benötigen, steht die Boot-ID in der zweiten Spalte. Die Zeit, auf die sich die Boot-Sitzung bezieht, erkennen Sie an den beiden Zeitangaben, die am Ende aufgeführt sind.

      Um Informationen von diesen Bootvorgängen anzuzeigen, können Sie entweder Informationen aus der ersten oder zweiten Spalte verwenden.

      Um beispielsweise das Journal von dem vorherigen Boot zu sehen, verwenden Sie den relativen Zeiger -1 mit dem Flag -b:

      journalctl -b -1

      Zum Abrufen von Daten aus einem Boot können Sie auch die Boot-ID verwenden:

      journalctl -b caf0524a1d394ce0bdbcff75b94444fe

      Zeitfenster

      Während es unglaublich nützlich ist, Protokolleinträge nach Bootvorgang zu sehen, möchten Sie vielleicht oft Zeitfenster abfragen, die nicht gut mit Systemstarts übereinstimmen. Dies kann besonders bei lang laufenden Servern mit erheblicher Betriebszeit der Fall sein.

      Sie können nach beliebigen Zeitgrenzen filtern, indem Sie die Optionen --since und --until verwenden, die die angezeigten Einträge auf diejenigen nach bzw. vor der angegebenen Zeit einschränken.

      Die Zeitwerte können in einer Vielzahl von Formaten vorliegen. Für absolute Zeitwerte sollten Sie das folgende Format verwenden:

      YYYY-MM-DD HH:MM:SS

      Beispielsweise können wir alle Einträge seit dem 10. Januar 2015 um 17:15 Uhr sehen, indem wir eingeben:

      journalctl --since "2015-01-10 17:15:00"

      Wenn Komponenten des obigen Formats weggelassen werden, werden einige Standardwerte angewendet. Wenn beispielsweise das Datum weggelassen wird, wird das aktuelle Datum angenommen. Wenn die Zeitkomponente fehlt, wird „00:00:00“ (Mitternacht) ersetzt. Das Sekundenfeld kann auch weggelassen werden, sodass standardmäßig „00“ verwendet wir:

      journalctl --since "2015-01-10" --until "2015-01-11 03:00"

      Das Journal versteht auch einige relative Werte und benannte Abkürzungen. Beispielsweise können Sie die Wörter „gestern“, „heute“, „morgen“ oder „jetzt“ verwenden. Relative Zeiten geben Sie an, indem Sie einem nummerierten Wert ein „-“ oder „+“ voranstellen oder Wörter wie „vor“ in einem Satzbau verwenden.

      Um die Daten von gestern zu erhalten, könnten Sie eingeben:

      journalctl --since yesterday

      Wenn Sie Berichte über eine Dienstunterbrechung erhalten haben, die um 9:00 Uhr begann und bis vor einer Stunde andauerte, könnten Sie eingeben:

      journalctl --since 09:00 --until "1 hour ago"

      Wie Sie sehen können, ist es relativ einfach, flexible Zeitfenster zu definieren, um die Einträge zu filtern, die Sie sehen möchten.

      Filtern nach Nachrichteninteresse

      Wir haben vorstehend einige Möglichkeiten kennengelernt, wie Sie die Journaldaten anhand von Zeiteinschränkungen filtern können. In diesem Abschnitt werden wir besprechen, wie Sie basierend auf dem Dienst oder der Komponente filtern können, an der Sie interessiert sind. Das Journal systemd bietet eine Vielzahl von Möglichkeiten, dies zu tun.

      Nach Einheit

      Die vielleicht nützlichste Art der Filterung ist nach der Einheit, an der Sie interessiert sind. Wir können die Option -u verwenden, um auf diese Weise zu filtern.

      Um beispielsweise alle Protokolle einer Nginx-Einheit auf unserem System zu sehen, können wir eingeben:

      journalctl -u nginx.service

      Normalerweise würden Sie wahrscheinlich auch nach der Zeit filtern wollen, um die Zeilen anzuzeigen, an denen Sie interessiert sind. Um beispielsweise zu überprüfen, wie der Dienst heute ausgeführt wird, können Sie eingeben:

      journalctl -u nginx.service --since today

      Diese Art der Fokussierung wird extrem hilfreich, wenn Sie die Fähigkeit des Journals nutzen, Datensätze aus verschiedenen Einheiten zusammenzuführen. Wenn Ihr Nginx-Prozess beispielsweise mit einer PHP-FPM-Einheit verbunden ist, um dynamischen Inhalt zu verarbeiten, können Sie die Einträge von beiden in chronologischer Reihenfolge zusammenführen, indem Sie beide Einheiten angeben:

      journalctl -u nginx.service -u php-fpm.service --since today

      Dies kann es wesentlich einfacher machen, die Interaktionen zwischen verschiedenen zu erkennen und System zu debuggen, anstatt einzelne Prozesse.

      Nach Prozess, Benutzer oder Gruppen-ID

      Einige Dienste spawnen eine Vielzahl von untergeordneten Prozesse, um die Arbeit zu erledigen. Wenn Sie die genaue PID des Prozesses, an dem Sie interessiert sind, ausgekundschaftet haben, können Sie auch nach dieser filtern.

      Dazu können wir durch Angabe des Feldes _PID filtern. Wenn die PID, an der wir interessiert sind, beispielsweise 8088 ist, könnten wir eingeben:

      journalctl _PID=8088

      Zu anderen Zeiten möchten Sie möglicherweise alle Einträge anzeigen, die von einem bestimmten Benutzer oder einer Gruppe protokolliert wurden. Dies kann mit den Filtern _UID oder _GID geschehen. Wenn Ihr Webserver beispielsweise unter dem Benutzer www-data läuft, können Sie die Benutzer-ID finden, indem Sie eingeben:

      id -u www-data

      33

      Anschließend können Sie die zurückgegebene ID verwenden, um die Journalergebnisse zu filtern:

      journalctl _UID=33 --since today

      Das Journal systemd hat viele Felder, die für die Filterung verwendet werden können. Einige davon werden von dem zu protokollierenden Prozess übergeben und einige werden von journald anhand von Informationen angewendet, die es zum Zeitpunkt der Protokollierung aus dem System sammelt.

      Der führende Unterstrich gibt an, dass das Feld _PID von dem letzteren Typ ist. Das Journal zeichnet automatisch die PID des protokollierenden Prozesses auf und indexiert sie für spätere Filterungen. Sie können sich über alle verfügbaren Journalfelder informieren, indem Sie eingeben:

      man systemd.journal-fields

      Wir werden einige davon in diesem Leitfaden besprechen. Für den Moment werden wir jedoch eine weitere nützliche Option bespreche, die mit der Filterung nach diesen Feldern zu tun hat. Die Option -F kann verwendet werden, um alle verfügbaren Werte für ein bestimmtes Journalfeld anzuzeigen.

      Um beispielsweise zu sehen, für welche Gruppen-IDs das Journal systemd Einträge aufweist, können Sie eingeben:

      journalctl -F _GID

      32
99
102
133
81
84
100
0
124
87

      Dies zeigt Ihnen alle Werte, die das Journal für das Feld Gruppen-ID gespeichert hat. Dies kann Ihnen beim Erstellen Ihrer Filter helfen.

      Nach Komponentenpfad

      Wir können auch filtern, indem wir eine Pfadposition bereitstellen.

      Wenn der Pfad zu einer ausführbaren Datei führt, zeigt journalctl alle Einträge an, die die betreffende ausführbare Datei betreffen. Um beispielsweise die Einträge zu finden, die die ausführbare Datei bash betreffen, können Sie eingeben:

      journalctl /usr/bin/bash

      Wenn eine Einheit für die ausführbare Datei verfügbar ist, ist diese Methode sauberer und bietet bessere Informationen (Einträge aus zugehörigen untergeordneten Prozessen usw.). Manchmal ist dies jedoch nicht möglich.

      Anzeigen von Kernel-Meldungen

      Kernel-Meldungen, die normalerweise in der Ausgabe dmesg zu finden sind, können ebenfalls aus dem Journal abgerufen werden.

      Um nur diese Meldungen anzuzeigen, können wir die Flags -k oder --dmesg zu unserem Befehl hinzufügen:

      journalctl -k

      Standardmäßig werden damit die Kernel-Meldungen des aktuellen Bootvorgangs angezeigt. Sie können einen alternativen Bootvorgang angeben, indem Sie die zuvor besprochenen Boot-Auswahl-Flags verwenden. Um beispielsweise die Meldungen von vor fünf Bootvorgängen zu erhalten, könnten Sie eingeben:

      journalctl -k -b -5

      Nach Priorität

      Ein Filter, an dem Systemadministratoren oft interessiert sind, ist die Meldungspriorität. Während es oft nützlich ist, Informationen auf einem sehr ausführlichen Niveau zu protokollieren, können Protokolle mit niedriger Priorität beim tatsächlichen Verarbeiten der verfügbaren Informationen ablenken und verwirrend sein.

      Sie können journalctl verwenden, um nur Meldungen einer bestimmten Priorität oder höher anzuzeigen, indem Sie die Option -p verwenden. Dadurch können Sie Meldungen mit niedrigerer Priorität herausfiltern.

      Um beispielsweise nur Einträge anzuzeigen, die auf der Fehlerebene oder höher protokolliert wurden, können Sie eingeben:

      journalctl -p err -b

      Dies zeigt Ihnen alle Meldungen an, die als Fehler, kritisch, Alarm oder Notfall gekennzeichnet sind. Das Journal implementiert die Standard-syslog-Meldungsebenen. Sie können entweder den Namen der Priorität oder den entsprechenden numerischen Wert verwenden. In der Reihenfolge von höchster bis niedrigster Priorität sind dies:

      • 0: emerg (Notfall)
      • 1: alert (Alarm)
      • 2: crit (kritisch)
      • 3: err (Fehler)
      • 4: warning (Warnung)
      • 5: notice (Hinweis)
      • 6: info (Information)
      • 7: debug (Fehlersuche)

      Die vorstehenden Zahlen oder Namen können austauschbar mit der Option -p verwendet werden. Wenn Sie die Priorität auswählen, werden Meldungen angezeigt, die auf der angegebenen Ebene markiert sind, und solche, die darüber liegen.

      Ändern der Journalanzeige

      Vorstehend haben wir die Auswahl von Einträgen durch Filterung demonstriert. Es gibt jedoch noch andere Möglichkeiten, die Ausgabe zu ändern. Wir können die Anzeige journalctl an verschiedene Bedürfnisse anpassen.

      Kürzen oder Erweitern der Ausgabe

      Wir können anpassen, wie journalctl Daten anzeigt, indem wir ihn anweisen, die Ausgabe zu verkürzen oder zu erweitern.

      Standardmäßig zeigt journalctl den gesamten Eintrag in dem Pager an und lässt die Einträge rechts am Bildschirm auslaufen. Auf diese Informationen können Sie durch Drücken der rechten Pfeiltaste zugreifen.

      Wenn Sie die Ausgabe lieber gekürzt haben möchten, wobei an den Stellen, an denen Informationen entfernt wurden, eine Ellipse eingefügt wird, können Sie die Option --no-full verwenden:

      journalctl --no-full

      . . .

Feb 04 20:54:13 journalme sshd[937]: Failed password for root from 83.234.207.60...h2
Feb 04 20:54:13 journalme sshd[937]: Connection closed by 83.234.207.60 [preauth]
Feb 04 20:54:13 journalme sshd[937]: PAM 2 more authentication failures; logname...ot

      Sie können damit auch in die entgegengesetzte Richtung gehen und journalctl anweisen, alle Informationen anzuzeigen, unabhängig davon, ob sie nicht druckbare Zeichen enthält. Wir können dies mit dem Flag -a tun:

      journalctl -a

      Ausgabe auf Standardausgabe

      Standardmäßig zeigt journalctl die Ausgabe in einem Pager an, um den Konsum zu erleichtern. Wenn Sie jedoch vorhaben, die Daten mit Textmanipulationswerkzeugen zu verarbeiten, möchten Sie wahrscheinlich in der Lage sein, auf die Standardausgabe auszugeben.

      Sie können dies mit der Option --no-pager tun:

      journalctl --no-pager

      Dies kann direkt in ein Verarbeitungsprogramm geleitet oder in eine Datei auf der Festplatte umgeleitet werden, je nach Ihren Bedürfnissen.

      Ausgabeformate

      Wenn Sie, wie oben erwähnt, Journaleinträge verarbeiten, wird es Ihnen die Analyse der Daten wahrscheinlich leichter fallen, wenn sie in einem besser konsumierbaren Format vorliegen. Glücklicherweise kann das Journal in einer Vielzahl von Formaten angezeigt werden, wenn es erforderlich ist. Dazu können Sie die Option -o mit einem Formatbezeichner verwenden.

      Sie können die Journaleinträge beispielsweise in JSON ausgeben, indem Sie eingeben:

      journalctl -b -u nginx -o json

      { "__CURSOR" : "s=13a21661cf4948289c63075db6c25c00;i=116f1;b=81b58db8fd9046ab9f847ddb82a2fa2d;m=19f0daa;t=50e33c33587ae;x=e307daadb4858635", "__REALTIME_TIMESTAMP" : "1422990364739502", "__MONOTONIC_TIMESTAMP" : "27200938", "_BOOT_ID" : "81b58db8fd9046ab9f847ddb82a2fa2d", "PRIORITY" : "6", "_UID" : "0", "_GID" : "0", "_CAP_EFFECTIVE" : "3fffffffff", "_MACHINE_ID" : "752737531a9d1a9c1e3cb52a4ab967ee", "_HOSTNAME" : "desktop", "SYSLOG_FACILITY" : "3", "CODE_FILE" : "src/core/unit.c", "CODE_LINE" : "1402", "CODE_FUNCTION" : "unit_status_log_starting_stopping_reloading", "SYSLOG_IDENTIFIER" : "systemd", "MESSAGE_ID" : "7d4958e842da4a758f6c1cdc7b36dcc5", "_TRANSPORT" : "journal", "_PID" : "1", "_COMM" : "systemd", "_EXE" : "/usr/lib/systemd/systemd", "_CMDLINE" : "/usr/lib/systemd/systemd", "_SYSTEMD_CGROUP" : "/", "UNIT" : "nginx.service", "MESSAGE" : "Starting A high performance web server and a reverse proxy server...", "_SOURCE_REALTIME_TIMESTAMP" : "1422990364737973" }

. . .

      Dies ist nützlich für das Parsen mit Dienstprogrammen. Sie könnten das Format json-pretty verwenden, um die Datenstruktur besser in den Griff zu bekommen, bevor Sie sie an den JSON-Verbraucher übergeben:

      journalctl -b -u nginx -o json-pretty

      {
    "__CURSOR" : "s=13a21661cf4948289c63075db6c25c00;i=116f1;b=81b58db8fd9046ab9f847ddb82a2fa2d;m=19f0daa;t=50e33c33587ae;x=e307daadb4858635",
    "__REALTIME_TIMESTAMP" : "1422990364739502",
    "__MONOTONIC_TIMESTAMP" : "27200938",
    "_BOOT_ID" : "81b58db8fd9046ab9f847ddb82a2fa2d",
    "PRIORITY" : "6",
    "_UID" : "0",
    "_GID" : "0",
    "_CAP_EFFECTIVE" : "3fffffffff",
    "_MACHINE_ID" : "752737531a9d1a9c1e3cb52a4ab967ee",
    "_HOSTNAME" : "desktop",
    "SYSLOG_FACILITY" : "3",
    "CODE_FILE" : "src/core/unit.c",
    "CODE_LINE" : "1402",
    "CODE_FUNCTION" : "unit_status_log_starting_stopping_reloading",
    "SYSLOG_IDENTIFIER" : "systemd",
    "MESSAGE_ID" : "7d4958e842da4a758f6c1cdc7b36dcc5",
    "_TRANSPORT" : "journal",
    "_PID" : "1",
    "_COMM" : "systemd",
    "_EXE" : "/usr/lib/systemd/systemd",
    "_CMDLINE" : "/usr/lib/systemd/systemd",
    "_SYSTEMD_CGROUP" : "/",
    "UNIT" : "nginx.service",
    "MESSAGE" : "Starting A high performance web server and a reverse proxy server...",
    "_SOURCE_REALTIME_TIMESTAMP" : "1422990364737973"
}

. . .

      Die folgenden Formate können für die Anzeige verwendet werden:

      • cat: Zeigt nur das Meldungsfeld selbst an.
      • export: Ein Binärformat, das sich zum Übertragen oder Sichern eignet.
      • json: Standard-JSON mit einem Eintrag pro Zeile.
      • json-pretty: JSON, das für eine bessere menschliche Lesbarkeit formatiert ist.
      • json-sse: JSON-formatierte Ausgabe, die eingehüllt ist, um das Hinzufügen von vom Server gesendeten Ereignissen zu ermöglichen.
      • short: Die Standardausgabe im syslog-Stil.
      • short-iso: Das Standardformat, das zum Anzeigen von ISO-8601 Wallclock-Zeitstempeln erweitert wurde.
      • short-monotonic: Das Standardformat mit monotonen Zeitstempeln.
      • short-precise: Das Standardformat mit Mikrosekundengenauigkeit.
      • verbose: Zeigt jedes für den Eintrag verfügbare Journalfeld an, einschließlich derjenigen, die normalerweise intern verborgen sind.

      Mit diesen Optionen können Sie die Journaleinträge in dem Format anzeigen, das Ihren aktuellen Bedürfnissen am besten entspricht.

      Aktive Prozessüberwachung

      Der Befehl journalctl imitiert, wie viele Administratoren tail zur Überwachung der aktiven oder jüngsten Aktivität verwenden. Diese Funktionalität ist in journalctl eingebaut, sodass Sie auf diese Funktionen zugreifen können, ohne eine Pipe zu einem anderen Tool verwenden zu müssen.

      Anzeigen aktueller Protokolle

      Um eine bestimmte Anzahl von Datensätzen anzuzeigen, können Sie die Option -n verwenden, die genau wie tail -n funktioniert.

      Sie zeigt standardmäßig die letzten 10 Einträge an:

      journalctl -n

      Sie können die Anzahl der Einträge, die Sie sehen möchten, mit einer Zahl nach dem -n angeben:

      journalctl -n 20

      Verfolgen von Protokollen

      Um die Protokolle aktiv zu verfolgen, während sie geschrieben werden, können Sie das Flag -f verwenden. Auch dies funktioniert so, wie Sie es vielleicht erwarten, wenn Sie Erfahrung mit der Verwendung von tail -f haben:

      journalctl -f

      Journalwartung

      Vielleicht fragen Sie sich, was es kostet, all die Daten zu speichern, die wir bisher gesehen haben. Außerdem sind Sie vielleicht daran interessiert, einige ältere Protokolle aufzuräumen und Speicherplatz freizugeben.

      Ermitteln der aktuellen Festplattenbelegung

      Sie können herausfiden, wie viel Platz das Journal derzeit auf der Festplatte belegt, indem Sie das Flag --disk-usage verwenden:

      journalctl --disk-usage

      Journals take up 8.0M on disk.

      Löschen alter Protokolle

      Wenn Sie Ihr Journal verkleinern möchten, können Sie dies auf zwei verschiedene Arten tun (verfügbar mit systemd Version 218 und höher).

      Wenn Sie die Option --vacuum-size verwenden, können Sie Ihr Journal durch Angabe einer Größe verkleinern. Dadurch werden alte Einträge entfernt, bis der gesamte auf der Festplatte belegte Journal-Speicherplatz die angeforderte Größe erreicht hat:

      sudo journalctl --vacuum-size=1G

      Eine weitere Möglichkeit, das Journal zu verkleinern, ist die Angabe einer Sperrzeit mit der Option --vacuum-time. Alle Einträge, die über diese Zeit hinausgehen, werden gelöscht. Dadurch können Sie die Einträge behalten, die nach einer bestimmten Zeit erstellt wurden.

      Um beispielsweise Einträge aus dem letzten Jahr zu behalten, können Sie eingeben:

      sudo journalctl --vacuum-time=1years

      Begrenzen der Journal-Erweiterung

      Sie können Ihren Server so konfigurieren, dass er den Speicherplatz, den das Journal einnehmen kann, begrenzt. Dies kann durch die Bearbeitung der Datei /etc/systemd/journald.conf erfolgen.

      Die folgenden Einträge können verwendet werden, um das Wachstum des Journals zu begrenzen:

      • SystemMaxUse=: Gibt den maximalen Festplattenplatz an, den das Journal im permanenten Speicher belegen kann.
      • SystemKeepFree=: Gibt den Speicherplatz an, den das Journal beim Hinzufügen von Journaleinträgen im permanenten Speicher frei lassen soll.
      • SystemMaxFileSize=: Kontrolliert, wie große einzelne Journaldateien im persistenten Speicher werden können, bevor sie rotiert werden.
      • RuntimeMaxUse=: Gibt den maximalen Festplattenspeicher an, der im flüchtigen Speicher (innerhalb des Dateisystems /run) verwendet werden kann.
      • RuntimeKeepFree=: Gibt an, wie viel Speicherplatz beim Schreiben von Daten in den flüchtigen Speicher (innerhalb des Dateisystems /run) für andere Verwendungen freigehalten werden soll.
      • RuntimeMaxFileSize=: Gibt an, wie viel Speicherplatz eine einzelne Journaldatei im flüchtigen Speicher (innerhalb des Dateisystems /run) einnehmen kann, bevor sie rotiert wird.

      Durch die Einstellung dieser Werte können Sie kontrollieren, wie journald den Speicherplatz auf Ihrem Server verbraucht und bewahrt. Denken Sie daran, dass SystemMaxFileSize und RuntimeMaxFileSize darauf abzielen, dass archivierte Dateien die angegebenen Grenzen erreichen. Dies ist wichtig zu bedenken, wenn Sie Dateizählungen nach einer Vakuum-Operation interpretieren.

      Zusammenfassung

      Wie Sie sehen können, ist das Journal systemd unglaublich nützlich für das Erfassen und Verwalten Ihrer System- und Anwendungsdaten. Die meiste Flexibilität ergibt sich aus den umfangreichen Metadaten, die automatisch aufgezeichnet werden, und der zentralisierten Natur des Protokolls. Der Befehl journalctl macht es einfach, die erweiterten Funktionen des Journals zu nutzen und umfangreiche Analysen und relationales Debugging verschiedener Anwendungskomponenten durchzuführen.



      Source link

      Anzeigen von Daten aus der DigitalOcean-API mit Django


      Der Autor hat die Mozilla Foundation dazu ausgewählt, im Rahmen des Programms Write for DOnations eine Spende zu erhalten.

      Einführung

      Da der Bedarf nach einer Full-Stack-Entwicklung weiter wächst, sorgen Web-Frameworks für Entwicklungsabläufe, die einfacher und effizienter sind; Django ist eines dieser Frameworks. Django kommt bei bekannten Websites wie Mozilla, Pinterest und Instagram zum Einsatz. Im Gegensatz zu Flask, das ein neutrales Mikro-Framework ist, enthält das Django PyPI-Paket alles, was Sie zur Full-Stack-Entwicklung benötigen; eine Datenbank oder Kontrolltafel für die Entwicklung muss nicht eingerichtet werden.

      Ein verbreitetes Anwendungsbeispiel für Django besteht in der Anzeige von Informationen aus APIs (wie Instagram-Posts oder GitHub-Repositorys) in Ihren eigenen Websites und Web-Apps. Zwar ist dies auch mit anderen Frameworks möglich, doch bedeutet das Motto “Batterien inbegriffen” von Django, dass der Aufwand geringer ist und weniger Pakete benötigt werden, um dasselbe Ergebnis zu erzielen.

      In diesem Tutorial erstellen Sie ein Django-Projekt, das die Droplet-Informationen Ihres DigitalOcean-Kontos mit der DigitalOcean v2 API anzeigt. Genauer gesagt werden Sie eine Website erstellen, die eine Tabelle mit Droplets anzeigt, in der ihre jeweiligen IP-Adressen, IDs, Hosting-Regionen und Ressourcen aufgeführt werden. Ihre Website wird BulmaCSS verwenden, um die Seite so zu gestalten, dass Sie sich auf die Entwicklung konzentrieren können und die Seite am Ende trotzdem gut aussieht.

      Nach Abschluss dieses Tutorials werden Sie über ein Django-Projekt verfügen, das eine Webseite erstellen kann, die wie folgt aussieht:

      Vorlage mit Tabelle von Droplet-Daten

      Voraussetzungen

      Bevor Sie diese Anleitung beginnen, benötigen Sie Folgendes:

      • Ein DigitalOcean-Konto mit mindestens einem Droplet und einem persönlichen Zugriffstoken. Stellen Sie sicher, dass Sie das Token an einem sicheren Ort aufbewahren; Sie werden es später in dem Tutorial noch benötigen.
      • Vertrautheit mit dem Richten von Anfragen an APIs. Ein umfassendes Tutorial zur Arbeit mit APIs finden Sie unter Verwenden von Web-APIs in Python3.
      • Eine lokale virtuelle Umgebung für Python zur Aufrechterhaltung von Abhängigkeiten. In diesem Tutorial verwenden wir den Namen do_django_api für unser Projektverzeichnis und env für unsere virtuelle Umgebung.
      • Vertrautheit mit der Vorlagenlogik von Django beim Rendern von Seiten mit API-Daten.
      • Vertrautheit mit der Anzeigelogik von Django bei der Handhabung von Daten, die von der API empfangen werden, und Übergabe an eine Vorlage für das Rendering.

      Schritt 1 — Einrichten eines einfachen Django-Projekts

      Installieren Sie Django aus der virtuellen Umgebung env heraus:

      Jetzt können Sie ein Django-Projekt starten und einige anfängliche Einrichtungsbefehle ausführen.

      Verwenden Sie django-admin startproject <name>, um im Projektordner, der den Namen Ihres Django-Projekts trägt, ein Unterverzeichnis zu erstellen; wechseln Sie anschließend in dieses Verzeichnis.

      • django-admin startproject do_django_project

      • cd do_django_project

      Nach der Erstellung finden Sie in diesem Unterverzeichnis manage.py; das ist die übliche Methode, um mit Django zu interagieren und Ihr Projekt auszuführen. Verwenden Sie migrate, um die Entwicklungsdatenbank von Django zu aktualisieren:

      • python3 manage.py migrate

      Sie werden eine Ausgabe sehen, die folgendermaßen aussieht, während die Datenbank aktualisiert wird:

      Output
      Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying sessions.0001_initial... OK

      Verwenden Sie als Nächstes den Befehl runserver, um das Projekt auszuführen, damit Sie es testen können:

      • python3 manage.py runserver

      Die Ausgabe sieht wie folgt aus, während der Server gestartet wird:

      Output
      Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
September 22, 2019 - 22:57:07
Django version 2.2.5, using settings 'do_django_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

      Sie verfügen nun über ein einfaches Django-Projekt und einen Entwicklungsserver, der ausgeführt wird. Um Ihren ausgeführten Entwicklungsserver anzuzeigen, rufen Sie in einem Browser 127.0.0.1:8000 auf. Damit wird die Startseite von Django angezeigt:

      Allgemeine Django-Startseite

      Als Nächstes erstellen Sie eine Django-App und konfigurieren Ihr Projekt, um eine Ansicht von dieser App auszuführen, damit Sie etwas Aufregenderes als die Standardseite sehen.

      Schritt 2 — Einrichten einer einfachen Django-App

      In diesem Schritt schaffen Sie das Fundament für die App, die Ihre Droplet-Ergebnisse enthalten wird. Sie werden später wieder zu dieser App zurückkehren, sobald Sie den API-Aufruf eingerichtet haben, um die App mit Daten zu füllen.

      Stellen Sie sicher, dass Sie sich im Verzeichnis do_django_project befinden, und erstellen Sie mit dem folgenden Befehl eine Django-App:

      • python3 manage.py startapp display_droplets

      Jetzt müssen Sie die neue App INSTALLED_APPS in der Datei settings.py hinzufügen, damit Django sie erkennen kann. settings.py ist eine Django-Konfigurationsdatei, die sich im Django-Projekt in einem anderen Unterverzeichnis befindet und den gleichen Namen trägt wie der Projektordner (do_django_project). Django hat beide Ordner für Sie erstellt. Wechseln Sie zum Verzeichnis do_django_project:

      Bearbeiten Sie settings.py in einem Editor Ihrer Wahl:

      Fügen Sie Ihre neue App dem Abschnitt INSTALLED_APPS der Datei hinzu:

      do_django_api/do_django_project/do_django_project/settings.py

      INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # The new app
    'display_droplets',
]

      Speichern und schließen Sie die Datei, wenn Sie fertig sind.

      Anzeigefunktion GetDroplets

      Als Nächstes erstellen Sie eine Funktion namens GetDroplets in der Datei views.py der App display_droplets. Diese Funktion rendert die Vorlage,die Sie zur Anzeige von Droplet-Daten verwenden werden, als context von der API. context ist ein Wörterbuch, das es erlaubt, Daten aus Python-Code zu übernehmen und an eine HTML-Vorlage zu senden, damit sie sich in einer Webseite anzeigen lassen.

      Wechseln Sie zum Verzeichnis display_droplets:

      • cd ..

      • cd display_droplets

      Öffnen Sie views.py, um die Datei zu bearbeiten:

      Fügen Sie den folgenden Code zur Datei hinzu:

      do_django_api/do_django_project/display_droplets/views.py

      from django.views.generic import TemplateView

class GetDroplets(TemplateView):
    template_name = 'droplets.html'
    def get_context_data(self, *args, **kwargs):
        pass

      Speichern und schließen Sie die Datei.

      Später werden Sie diese Funktion ausfüllen und die Datei droplets.html erstellen. Zuerst konfigurieren wir aber urls.py, um diese Funktion anzurufen, wenn Sie das Stammverzeichnis des Entwicklungsservers (127.0.0.1:8000) aufrufen.

      Wechseln Sie wieder zum Verzeichnis do_django_project:

      • cd ..

      • cd do_django_project

      Öffnen Sie urls.py, um die Datei zu bearbeiten:

      Fügen Sie eine import-Anweisung für GetDroplets und dann einen zusätzlichen Pfad zu urlpatterns hinzu, der auf die neue Ansicht verweist.

      do_django_api/do_django_project/do_django_project/urls.py

      from django.contrib import admin
from django.urls import path
from display_droplets.views import GetDroplets

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', GetDroplets.as_view(template_name='droplets.html'), name='Droplet View'),
]

      Wenn Sie Ihre eigenen Pfade einrichten möchten, ist der erste Parameter die URL (wie z. B. example.com/**admin**), der zweite Parameter die Funktion, die zum Erstellen der Webseite aufgerufen wird, und der dritte nur ein Name für den Pfad.

      Speichern und schließen Sie die Datei.

      Droplets-Vorlage

      Als Nächstes arbeiten Sie mit Vorlagen. Vorlagen sind HTML-Dateien, die Django zur Erstellung von Webseiten verwendet. In diesem Fall verwenden Sie eine Vorlage, um eine HTML-Seite zu erstellen, die die API-Daten anzeigt.

      Wechseln Sie wieder zum Verzeichnis display_droplets:

      • cd ..

      • cd display_droplets

      Erstellen Sie in diesem Verzeichnis einen Ordner template und wechseln Sie in dieses Verzeichnis:

      • mkdir templates

      • cd templates

      Erstellen Sie droplets.html und öffnen Sie die Datei, um sie zu bearbeiten:

      Um kein CSS für dieses Projekt schreiben zu müssen, verwenden wir Bulma CSS, da es sich dabei um ein kostenloses und schlankes CSS-Framework für die Erstellung von übersichtlichen Webseiten handelt. Sie müssen der HTML lediglich einige Klassenattribute hinzufügen.

      Jetzt erstellen wir eine Vorlage mit einer einfachen Navigationsleiste. Fügen Sie der Datei droplets.html den folgenden Code hinzu:

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>DigitalOcean Droplets</title>
    <link crossorigin="anonymous"
          href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.7.4/css/bulma.min.css"
          integrity="sha256-8B1OaG0zT7uYA572S2xOxWACq9NXYPQ+U5kHPV1bJN4="
          rel="stylesheet"/>
    <link rel="shortcut icon" type="image/png" href="https://assets.digitalocean.com/logos/favicon.png"/>
</head>
<body>
<nav aria-label="main navigation" class="navbar is-light" role="navigation">
    <div class="navbar-brand">
        <div class="navbar-item">
            <img atl="DigitalOcean" src="https://assets.digitalocean.com/logos/DO_Logo_icon_blue.png"
                 style="margin-right: 0.5em;">Droplets
        </div>
    </div>
</nav>
</body>
</html>

      Speichern und schließen Sie die Datei.

      Dieser Code sorgt dafür, dass Bulma in den HTML-Baustein importiert und eine nav-Leiste zur Anzeige von “Droplets” erstellt wird.

      Aktualisieren Sie Ihren Browser-Tab, um die Änderungen, die Sie an der Vorlage vorgenommen haben, anzuzeigen.

      Vorlage mit einfacher Kopfzeile

      Bisher haben Sie noch keine APIs verwendet; Sie haben vielmehr ein Fundament für das Projekt geschaffen. Als Nächstes nutzen Sie diese Seite sinnvoll, indem Sie einen API-Aufruf einrichten und die Droplet-Daten bereitstellen.

      Schritt 3 — Einrichten des API-Aufrufs

      In diesem Schritt richten Sie einen API-Aufruf ein und senden die Droplet-Daten als Kontext an die Vorlage, um in einer Tabelle angezeigt zu werden.

      Abrufen von Droplet-Daten

      Navigieren Sie zurück zum App-Verzeichnis display_droplets:

      Installieren Sie die Bibliothek requests, damit Sie mit der API kommunizieren können:

      Mithilfe der Bibliothek requests kann Ihr Code Daten von APIs anfordern und Kopfzeilen hinzufügen (zusätzliche Daten, die mit unserer Anfrage gesendet werden).

      Als Nächstes erstellen Sie eine Datei services.py, über die Sie den API-Aufruf vornehmen. Diese Funktion verwendet requests, um mit https://api.digitalocean.com/v2/droplets zu kommunizieren und jedes Droplet in der JSON-Datei anzufügen, das an eine Liste zurückgegeben wird.

      Öffnen Sie services.py, um die Datei zu bearbeiten:

      Fügen Sie den folgenden Code zur Datei hinzu:

      do_django_api/do_django_project/display_droplets/services.py

      import os
import requests

def get_droplets():
    url = 'https://api.digitalocean.com/v2/droplets'
    r = requests.get(url, headers={'Authorization':'Bearer %s' % 'access_token'})
    droplets = r.json()
    droplet_list = []
    for i in range(len(droplets['droplets'])):
        droplet_list.append(droplets['droplets'][i])
    return droplet_list

      Innerhalb der Funktion get_droplets passieren zwei Dinge: Es wird eine Anfrage vorgenommen und Daten werden analysiert. url enthält die URL, die Droplet-Daten von der DigitalOcean-API anfordert. r speichert die angeforderten Daten.

      requests übernimmt in diesem Fall zwei Parameter: url und headers. Wenn Sie Daten von einer anderen API nutzen möchten, ersetzen Sie den Wert url durch die entsprechende URL. headers sendet DigitalOcean Ihr Zugriffstoken, damit das Unternehmen weiß, dass Sie die Anfrage vornehmen dürfen und für welches Konto die Anfrage vorgenommen wird.

      droplets enthält die Informationen aus der Variable r, wurde nun jedoch von JSON, dem Format, in dem die API Informationen sendet, in ein Wörterbuch konvertiert, das bequem in einer for-Schleife zu verwenden ist.

      Die nächsten drei Zeilen erstellen ein Array namens droplet_list[]. Dann iteriert eine for-Schleife über die Informationen in droplets und fügt jedes Element der Liste hinzu. Alle von der API übernommenen und in droplets gespeicherten Informationen finden Sie in der Entwicklerdokumentation von DigitalOcean.

      Anmerkung: Vergessen Sie nicht, access_token durch Ihr Zugriffstoken zu ersetzen. Bewahren Sie das Token außerdem sicher auf und veröffentlichen Sie es niemals online.

      Speichern und schließen Sie die Datei.

      Schutz Ihres Zugriffstokens

      Sie sollten Ihr Zugriffstoken stets verstecken. Wenn aber auch andere Personen das Projekt ausführen dürfen, sollten Sie ihnen eine einfache Möglichkeit bieten, um eigene Zugriffstoken hinzuzufügen, ohne dass Python-Code bearbeitet werden muss. DotENV ist die Lösung, wenn Variablen in einer .env-Datei aufbewahrt werden, die bequem bearbeitet werden kann.

      Wechseln Sie wieder zum Verzeichnis do_django_project:

      Um mit Umgebungsvariablen zu arbeiten, installieren Sie python-dotenv:

      • pip install python-dotenv

      Nach der Installation müssen Sie Django für den Umgang mit Umgebungsvariablen konfigurieren, damit Sie in Code auf sie verweisen können. Dazu müssen Sie einige Codezeilen zu manage.py und wsgi.py hinzufügen.

      Öffnen Sie manage.py, um die Datei zu bearbeiten:

      Fügen Sie folgenden Code hinzu:

      do_django_api/do_django_project/manage.py

      
"""Django's command-line utility for administrative tasks."""
import os
import sys
import dotenv

def main():
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)

if __name__ == '__main__':
    main()

dotenv.load_dotenv(
    os.path.join(os.path.dirname(__file__), '.env')
)

      Das Hinzufügen von dem Code in manage.py bedeutet, dass bei der Ausgabe von Befehlen an Django in der Entwicklung Umgebungsvariablen von Ihrer .env-Datei verarbeitet werden.

      Speichern und schließen Sie die Datei.

      Wenn Sie in Ihren Produktionsprojekten Umgebungsvariablen bearbeiten müssen, können Sie dies mit der Datei wsgi.py tun. Wechseln Sie zum Verzeichnis do_django_project:

      Öffnen Sie anschließend wsgi.py, um die Datei zu bearbeiten:

      Fügen Sie wsgi.py folgenden Code hinzu:

      do_django_api/do_django_project/do_django_project/wsgi.py

      
import os
import dotenv

from django.core.wsgi import get_wsgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')

dotenv.load_dotenv(
    os.path.join(os.path.dirname(os.path.dirname(__file__)), '.env')
)

application = get_wsgi_application()

      Dieser Codeausschnitt weist einen zusätzlichen os.path.dirname() auf, weil wsgi.py zwei Verzeichnisse zurückgehen muss, um die Datei .env zu finden. Dieser Ausschnitt ist nicht identisch mit dem, der für manage.py verwendet wird.

      Speichern und schließen Sie die Datei.

      Nun können Sie anstelle Ihres Zugriffstokens eine Umgebungsvariable in services.py verwenden. Wechseln Sie wieder zum Verzeichnis display_droplets:

      • cd ..

      • cd display_droplets

      Öffnen Sie services.py, um die Datei zu bearbeiten:

      Ersetzen Sie nun Ihr Zugriffstoken durch eine Umgebungsvariable:

      do_django_api/display_droplets/services.py

      import os
import requests

def get_droplets():
    url = "https://api.digitalocean.com/v2/droplets"
    r = requests.get(url, headers={'Authorization':'Bearer %s' % os.getenv('DO_ACCESS_TOKEN')})
    droplets = r.json()
    droplet_list = []
    for i in range(len(droplets['droplets'])):
        droplet_list.append(droplets['droplets'][i])
    return droplet_list

      Speichern und schließen Sie die Datei.

      Der nächste Schritt besteht aus der Erstellung einer .env-Datei. Wechseln Sie wieder zum Verzeichnis do_django_project:

      Erstellen Sie eine .env-Datei und öffnen Sie die Datei, um sie zu bearbeiten:

      Fügen Sie in .env Ihr Token als Variable DO_ACCESS_TOKEN hinzu:

      do_django_api/do_django_project/.env

      DO_ACCESS_TOKEN=access_token

      Speichern und schließen Sie die Datei.

      Anmerkung: Fügen Sie .env zu Ihrer .gitignore-Datei hinzu, damit sie nie in Ihren Commits enthalten ist.

      Die API-Verbindung ist nun eingerichtet und konfiguriert; zudem haben Sie Ihr Zugriffstoken geschützt. Es ist an der Zeit, die Informationen, die Sie für den Benutzer abgerufen haben, bereitzustellen.

      Schritt 4 — Umgang mit Droplet-Daten in Ansichten und Vorlagen

      Nachdem Sie nun API-Aufrufe vornehmen können, müssen Sie die Droplet-Daten zum Rendern an die Vorlage senden. Kehren wir zum Stub der Funktion GetDroplets zurück, die Sie zuvor in views.py erstellt haben. In der Funktion senden Sie droplet_list als Kontext an die Vorlage droplets.html.

      Wechseln Sie zum Verzeichnis display_droplets:

      Öffnen Sie views.py, um die Datei zu bearbeiten:

      Fügen Sie views.py folgenden Code hinzu:

      do_django_api/do_django_project/display_droplets/views.py

      from django.shortcuts import render
from django.views.generic import TemplateView
from .services import get_droplets

class GetDroplets(TemplateView):
    template_name = 'droplets.html'
    def get_context_data(self, *args, **kwargs):
        context = {
            'droplets' : get_droplets(),
        }
        return context

      Die an die Vorlage droplets.html gesendeten Informationen werden mit dem Wörterbuch context verwaltet. Aus diesem Grund dient droplets als Schlüssel, während das von get_droplets() zurückgegebene Array als Wert fungiert.

      Speichern und schließen Sie die Datei.

      Bereitstellen der Daten in der Vorlage

      In der Vorlage droplets.html erstellen Sie eine Tabelle und befüllen sie mit den Droplet-Daten.

      Wechseln Sie zum Verzeichnis templates:

      Öffnen Sie droplets.html, um die Datei zu bearbeiten:

      Fügen Sie nach dem Element nav in droplets.html folgenden Code hinzu:

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <table class="table is-fullwidth is-striped is-bordered">
    <thead>
    <tr>
        <th>Name</th>
        <th>IPv4 Address(es)</th>
        <th>Id</th>
        <th>Region</th>
        <th>Memory</th>
        <th>CPUs</th>
        <th>Disk Size</th>
    </tr>
    </thead>
    <tbody>
    {% for droplet in droplets %}
    <tr>
        <th>{{ droplet.name }}</th>
        {% for ip in droplet.networks.v4 %}
        <td>{{ ip.ip_address }}</td>
        {% endfor %}
        <td>{{ droplet.id }}</td>
        <td>{{ droplet.region.name }}</td>
        <td>{{ droplet.memory }}</td>
        <td>{{ droplet.vcpus }}</td>
        <td>{{ droplet.disk }}</td>
    </tr>
    {% endfor %}
    </tbody>
</table>

      {% for droplet in droplets %} ... {% endfor %} ist eine Schleife, die durch das Array von Droplets, die aus views.py abgerufen wurden, iteriert. Jedes Droplet wird in eine Tabellenzeile eingefügt. Die verschiedenen {{ droplet.<attribute> }}-Zeilen rufen dieses Attribut für jedes Droplet in der Schleife ab und fügen es in eine Tabellenzelle ein.

      Speichern und schließen Sie die Datei.

      Aktualisieren Sie Ihren Browser; es wird eine Liste von Droplets angezeigt.

      Vorlage mit Tabelle an Droplet-Daten

      Nun können Sie die DigitalOcean-API in Ihren Django-Projekten verwenden. Sie haben die von der API abgerufenen Daten übernommen und in die zuvor erstellte Vorlage eingespeist, um die Informationen auf lesbare und flexible Weise anzuzeigen.

      Zusammenfassung

      In diesem Artikel haben Sie ein Django-Projekt erstellt, das Droplet-Daten aus der DigitalOcean-API im Bulma CSS-Stil anzeigen kann. In diesem Tutorial haben Sie drei wichtige Fähigkeiten erlernt:

      • Verwalten von API-Anfragen in Python mit den Modulen requests und json.
      • Anzeigen von API-Daten in einem Django-Projekt unter Verwendung der Logiken view und template.
      • Sicheres Verwalten Ihrer API-Token in Django mit dotenv.

      Nachdem Sie eine Einführung in die Handhabung von APIs in Django erhalten haben, können Sie nun ein eigenes Projekt erstellen: entweder mit einer anderen Funktion aus der DigitalOcean-API oder einer ganz anderen API. Zudem können Sie andere Django-Tutorials bzw. ein ähnliches Tutorial mit dem React-Framework konsultieren.





      Source link

      Forgot Your Password ?