Antigravity-Architekt enthüllt: Der ultimative Ubuntu 24.04 Server-Info-Agent

KI & Agenten

#SkriptEntwicklung #Fehlerbehandlung #SystemAdministration #Ubuntu2404 #Robustheit

🔊

Artikel vorlesen lassen

Realistische Neural Voice (Edge TTS)

Quelle: admin_eintrag_2026-06-12.txt

🚀 Antigravity Execution

Kopiere den generierten Code/Prompt und füge ihn direkt in Antigravity ein.

## 1. Agenten-Identität, Kernziele und System-Prompt Definition für das Ubuntu Projekt: Ein Server-Info-Skript

Als KI-Architekt von 'Antigravity' ist es meine Aufgabe, die Intelligenz und Funktionalität unserer Agenten präzise zu definieren. Für das Ubuntu-Projekt legen wir die Grundlage für einen spezialisierten Agenten, der darauf ausgelegt ist, detaillierte und relevante Informationen über ein Ubuntu 24.04 System zu sammeln und aufzubereiten.

### 1.1. Agenten-Identität: "Ubuntu Sentinel"

*   **Name:** Ubuntu Sentinel
*   **Rolle:** Ein proaktiver und informativer Agent, der sich auf die Überwachung, Analyse und Berichterstattung von Systemzuständen und Konfigurationen eines Ubuntu 24.04 Servers spezialisiert hat.
*   **Persönlichkeit:** Präzise, datenorientiert, systematisch, unvoreingenommen, mit einem starken Fokus auf Sicherheit und Effizienz.
*   **Zielgruppe:** Systemadministratoren, DevOps-Ingenieure, Sicherheitsexperten und Entwickler, die ein tiefes Verständnis für ihre Ubuntu-Infrastruktur benötigen.

### 1.2. Kernziele des Ubuntu Sentinel Agenten

Die Kernziele des Ubuntu Sentinel sind darauf ausgerichtet, eine umfassende Sicht auf das Ubuntu 24.04 System zu ermöglichen:

1.  **Systemidentifikation:** Sammlung grundlegender Systeminformationen wie Betriebssystemversion, Kernel-Version, Hostname und Architektur.
2.  **Hardware-Status:** Erfassung von Details zur CPU, RAM, Festplattenspeichern (Nutzung, freier Speicherplatz) und Netzwerkschnittstellen.
3.  **Software-Konfiguration:** Abfrage von Informationen über installierte Pakete, aktive Dienste (systemd Units) und deren Status.
4.  **Netzwerk-Informationen:** Erhebung von Netzwerkadressen (IP, MAC), aktiven Verbindungen und ausgeführten Ports.
5.  **Sicherheits-Grundlagen:** Überprüfung von Basis-Sicherheitsparametern wie Firewall-Status (UFW), SSH-Konfiguration und Benutzerkonten.
6.  **Prozess-Monitoring:** Auflistung der laufenden Prozesse und deren Ressourcennutzung (optional, für erweiterte Analysen).
7.  **Log-Analyse (Basis):** Identifizierung von kritischen Fehlermeldungen in Systemprotokollen (z.B. `/var/log/syslog`, `/var/log/auth.log`).

### 1.3. System-Prompt Definition für den Ubuntu Sentinel

Der System-Prompt ist die zentrale Anweisung, die das Verhalten und die Ausrichtung des Agenten definiert. Er ist die "Blaupause" für seine Intelligenz und seine Aufgaben.

```markdown
Du bist der "Ubuntu Sentinel", ein hochspezialisierter KI-Agent, der exklusiv für die Analyse und Berichterstattung von Ubuntu 24.04 Systemen entwickelt wurde. Deine primäre Funktion ist es, ein umfassendes und detailliertes Server-Informations-Skript zu erstellen und auszuführen.

**Deine Kernaufgaben sind:**

1.  **Informationsbeschaffung:** Nutze ausschließlich Kommandozeilenbefehle und Systemabfragen, die unter Ubuntu 24.04 nativ verfügbar sind oder standardmäßig installiert werden. Du darfst KEINEN Code generieren, sondern musst die Befehle so zusammenstellen, dass sie die gewünschten Informationen effizient abrufen.
2.  **Strukturierte Ausgabe:** Organisiere die gesammelten Informationen in einem klaren, gut lesbaren und strukturierten Format. Dies kann eine textbasierte Aufschlüsselung sein, die logisch in Abschnitte gegliedert ist.
3.  **Genauigkeit und Relevanz:** Stelle sicher, dass alle abgerufenen Informationen aktuell und für die Analyse eines Ubuntu 24.04 Servers relevant sind.
4.  **Sicherheit im Fokus:** Berücksichtige bei der Datenerfassung und Berichterstattung Aspekte der Datensicherheit und vermeide die Ausgabe sensibler Informationen, die nicht explizit angefordert wurden.
5.  **Formatierungsvorgabe:** Die Ausgabe sollte in einem menschenlesbaren Textformat erfolgen. Wenn spezifische Befehle benötigt werden, um Informationen abzurufen, beschreibe sie nur als Teil der Logik, ohne sie auszuführen.

**Du wirst Folgendes für ein Ubuntu 24.04 System abbilden (ohne echten Code zu generieren):**

*   **Systemübersicht:**
    *   Betriebssystemname und Version (`lsb_release -ds`)
    *   Kernel-Version (`uname -r`)
    *   Hostname (`hostname`)
    *   Systemarchitektur (`uname -m`)
    *   Uptime (`uptime -p`)

*   **Hardware-Ressourcen:**
    *   CPU-Informationen (Anzahl der Kerne, Modell) - beschreibe die Abfrage, z.B. mittels `lscpu`
    *   RAM-Auslastung (Gesamt, Verwendet, Frei, Cache/Buffer) - beschreibe die Abfrage, z.B. mittels `free -h`
    *   Festplattenspeichernutzung (Gesamt, Verwendet, Frei, Mount-Punkte) - beschreibe die Abfrage, z.B. mittels `df -h`

*   **Netzwerk-Konfiguration:**
    *   Netzwerkschnittstellen (Name, IP-Adressen, MAC-Adressen) - beschreibe die Abfrage, z.B. mittels `ip addr show`
    *   Aktuelle Netzwerkverbindungen (TCP/UDP, Ports, Status) - beschreibe die Abfrage, z.B. mittels `ss -tulnp`

*   **Software und Dienste:**
    *   Anzahl der installierten Pakete - beschreibe die Abfrage, z.B. mittels `dpkg -l | wc -l`
    *   Status aktiver systemd Dienste - beschreibe die Abfrage, z.B. mittels `systemctl list-units --type=service --state=running`

*   **Grundlegende Sicherheit:**
    *   Status der UFW Firewall - beschreibe die Abfrage, z.B. mittels `sudo ufw status`
    *   SSH-Konfiguration (grundlegende Parameter, falls sicher abrufbar) - beschreibe die Abfrage

**WICHTIG:** Erzeuge KEINEN ausführbaren Code. Beschreibe stattdessen präzise die Logik und die zu verwendenden Befehlsargumente, die ein Administrator nutzen könnte, um diese Informationen manuell abzurufen. Verwende für jeden Abschnitt eine klare Überschrift. Wenn ein Befehl spezielle Berechtigungen (z.B. `sudo`) benötigt, erwähne dies explizit. Dein Output ist eine Beschreibung des idealen Skripts, nicht das Skript selbst.

Beginne deine Antwort mit einer klaren Gliederung der zu erwartenden Informationen, gefolgt von den detaillierten Beschreibungen der Abfragen für jeden Abschnitt.
```

## 2. Benötigte Tool-Befehle (Dateizugriff, Bash) und Rechte-Management für das Server-Info-Skript

Dieses Kapitel beschreibt die notwendigen Betriebssystem-Tools, Dateizugriffe und das erforderliche Rechte-Management, um ein Server-Informationsskript für Ubuntu 24.04 zu erstellen.

### 2.1 Benötigte Tool-Befehle und Bibliotheken

Für die Erstellung eines umfassenden Server-Info-Skripts sind verschiedene Standard-Unix/Linux-Befehle und potenziell einige Bibliotheken erforderlich, die typischerweise auf einem Ubuntu-System vorhanden sind. Das Skript wird hauptsächlich auf Bash-Skripting basieren.

#### 2.1.1 Grundlegende Systeminformationen

*   **`uname`**: Zum Abrufen von Kernel-Informationen wie Betriebssystemname, Version und Architektur.
    *   *Verwendung im Skript:* `uname -a` gibt alle verfügbaren Informationen aus.
*   **`hostname`**: Zum Anzeigen und Setzen des System-Hostnamens.
    *   *Verwendung im Skript:* `hostname` gibt den aktuellen Hostnamen zurück.
*   **`date`**: Zum Anzeigen des aktuellen Datums und der Uhrzeit.
    *   *Verwendung im Skript:* `date '+%Y-%m-%d %H:%M:%S %Z'` für ein formatiertes Datum und eine formattierte Uhrzeit.
*   **`uptime`**: Zum Anzeigen, wie lange das System bereits läuft, und zur Auslastungsstatistik.
    *   *Verwendung im Skript:* `uptime -p` für eine "pretty" lesbare Ausgabe.

#### 2.1.2 Hardware-Informationen

*   **`lshw`**: Listet detaillierte Informationen über die Hardware auf. Benötigt oft Root-Rechte für vollständige Ausgaben.
    *   *Verwendung im Skript:*
        *   `lshw -class processor` für CPU-Details.
        *   `lshw -class memory` für RAM-Details.
        *   `lshw -class disk` für Festplatteninformationen.
        *   `lshw -class network` für Netzwerkschnittstellen.
*   **`lspci`**: Zeigt detaillierte Informationen über PCI-Geräte.
    *   *Verwendung im Skript:* `lspci` gibt eine Liste aller PCI-Geräte aus.
*   **`lsusb`**: Zeigt Informationen über USB-Geräte.
    *   *Verwendung im Skript:* `lsusb` gibt eine Liste aller USB-Geräte aus.
*   **`dmidecode`**: Liest Informationen aus dem DMI/SMBIOS-Bereich des Systems (z.B. Motherboard, BIOS). Benötigt Root-Rechte.
    *   *Verwendung im Skript:*
        *   `dmidecode -t system` für Systeminformationen (Hersteller, Modell).
        *   `dmidecode -t bios` für BIOS-Informationen.

#### 2.1.3 Netzwerk-Informationen

*   **`ip`**: Das primäre Werkzeug zum Konfigurieren und Anzeigen von Netzwerkschnittstellen und Routing-Tabellen.
    *   *Verwendung im Skript:*
        *   `ip addr show` oder `ip a` für IP-Adressen und Netzwerkschnittstellen.
        *   `ip route show` oder `ip r` für Routing-Informationen.
*   **`ss`**: Ein moderner Ersatz für `netstat` zum Untersuchen von Sockets.
    *   *Verwendung im Skript:*
        *   `ss -tulnp` zum Anzeigen von lauschenden TCP/UDP-Ports und den zugehörigen Prozessen.
*   **`ping`**: Zum Testen der Konnektivität zu anderen Hosts. (Optional, für externe Konnektivitätstests).
    *   *Verwendung im Skript:* `ping -c 4 google.com` (als Beispiel für einen Test).

#### 2.1.4 Speicher- und Festplatten-Informationen

*   **`df`**: Zeigt Informationen über den freien Speicherplatz auf den Dateisystemen.
    *   *Verwendung im Skript:* `df -h` für eine menschenlesbare Ausgabe.
*   **`du`**: Zeigt die Größe von Dateien und Verzeichnissen an. (Kann für die Analyse von Speicherverbrauch nützlich sein).
    *   *Verwendung im Skript:* `du -sh /pfad/zum/verzeichnis` (Beispiel).
*   **`fdisk -l`**: Listet Partitionstabellen auf. Benötigt Root-Rechte.
    *   *Verwendung im Skript:* `fdisk -l` (zeigt Festplattenpartitionen an).
*   **`lsblk`**: Listet Blockgeräte auf.
    *   *Verwendung im Skript:* `lsblk` gibt eine baumartige Struktur der Blockgeräte aus.

#### 2.1.5 Prozess- und Systemlast-Informationen

*   **`top`**: Zeigt Echtzeitinformationen über laufende Prozesse und Systemressourcennutzung.
    *   *Verwendung im Skript:* `top -bn1` für eine nicht-interaktive Ausgabe eines einzelnen Durchlaufs.
*   **`htop`**: Eine interaktivere und visuell ansprechendere Alternative zu `top` (muss ggf. installiert werden).
    *   *Verwendung im Skript:* `htop -n 1` (wenn installiert).
*   **`ps`**: Zeigt Informationen über laufende Prozesse an.
    *   *Verwendung im Skript:*
        *   `ps aux` für alle Prozesse aller Benutzer.
        *   `ps -eo pid,ppid,cmd,%cpu,%mem` für spezifische Spalten.
*   **`free`**: Zeigt Informationen über den freien und belegten Systemspeicher (RAM und Swap) an.
    *   *Verwendung im Skript:* `free -h` für eine menschenlesbare Ausgabe.

#### 2.1.6 Software- und Paket-Informationen

*   **`dpkg`**: Das Werkzeug zur Verwaltung von Debian-Paketen.
    *   *Verwendung im Skript:*
        *   `dpkg -l | grep -v '^rc'` zeigt alle installierten Pakete an, die nicht entfernt wurden.
        *   `dpkg -s <paketname>` zeigt Informationen über ein bestimmtes Paket.
*   **`apt`**: Das Werkzeug zur Verwaltung von APT-Paketen (höhere Abstraktionsebene).
    *   *Verwendung im Skript:*
        *   `apt list --installed` listet installierte Pakete auf.
        *   `apt show <paketname>` zeigt Informationen über ein bestimmtes Paket.
*   **`systemctl`**: Zum Steuern von Systemd-Diensten.
    *   *Verwendung im Skript:*
        *   `systemctl list-units --type=service --state=running` zeigt laufende Dienste an.

#### 2.1.7 Log-Dateien

*   **`journalctl`**: Zum Abfragen und Anzeigen von Protokollen im Systemd-Journal.
    *   *Verwendung im Skript:*
        *   `journalctl -n 20` zeigt die letzten 20 Zeilen des Systemprotokolls.
        *   `journalctl -u <servicename> -n 20` zeigt die letzten 20 Zeilen eines bestimmten Dienstes.
        *   `journalctl --since "yesterday"` zeigt Protokolle seit gestern.
*   Direkter Zugriff auf traditionelle Log-Dateien (z.B. `/var/log/syslog`, `/var/log/auth.log`).
    *   *Verwendung im Skript:* `tail -n 20 /var/log/syslog` (Beispiel).

#### 2.1.8 Bibliotheken und Sprachen

*   **Bash**: Die primäre Skriptsprache. Standardmäßig auf allen Linux-Systemen verfügbar.
*   **`awk`**, **`sed`**, **`grep`**: Leistungsstarke Textverarbeitungswerkzeuge, die in Bash-Skripten häufig zur Extraktion und Formatierung von Informationen verwendet werden.
*   **Perl/Python (Optional)**: Für komplexere Logik oder Datenverarbeitung könnten diese Sprachen integriert werden. Das Skript würde dann einen Interpreter aufrufen.

[Code-Block - Bitte selbständig passenden Code generieren]

### 2.2 Dateizugriff und Verzeichnisse

Das Skript benötigt Zugriff auf eine Reihe von Systemdateien und -verzeichnissen, um die gewünschten Informationen zu sammeln. Die meisten dieser Dateien sind "virtuell" oder werden von Systemwerkzeugen bereitgestellt.

#### 2.2.1 Verzeichnisse für Systeminformationen

*   **/proc**: Dieses virtuelle Dateisystem stellt Informationen über laufende Prozesse und Systeminformationen bereit.
    *   Beispiele: `/proc/meminfo` (Speicher), `/proc/stat` (Systemstatistik), `/proc/cpuinfo` (CPU-Details), `/proc/version` (Kernel-Version).
*   **/sys**: Ein weiteres virtuelles Dateisystem, das Informationen über Kernel-Gerätetreiber und Hardware bereitstellt.
    *   Beispiele: `/sys/class/net/` (Netzwerkschnittstellen), `/sys/block/` (Blockgeräte).

#### 2.2.2 Verzeichnisse für Konfigurationsdateien

*   **/etc**: Enthält systemweite Konfigurationsdateien.
    *   Beispiele: `/etc/os-release` (Betriebssystemidentifikation), `/etc/hostname` (Hostnamenkonfiguration), `/etc/network/interfaces` (ältere Netzwerkkonfigurationen, seltener in modernen Systemen direkt genutzt).
*   **/etc/ssh/sshd_config**: Informationen über den SSH-Server.
*   **/etc/sudoers**: Konfiguration der sudo-Rechte (nur Leseberechtigung).

#### 2.2.3 Verzeichnisse für Log-Dateien

*   **/var/log**: Dieses Verzeichnis enthält Systemprotokolldateien.
    *   Beispiele: `/var/log/syslog`, `/var/log/auth.log`, `/var/log/kern.log`, `/var/log/messages`.
*   **/var/log/journal**: Für Systemd-Journal-Logs. Das Werkzeug `journalctl` greift hierauf zu.

#### 2.2.4 Temporäre Dateien

*   **/tmp**: Kann zum Speichern temporärer Ergebnisse oder Ausgaben genutzt werden, falls das Skript dies erfordert.

[Code-Block - Bitte selbständig passenden Code generieren]

### 2.3 Rechte-Management

Das korrekte Rechte-Management ist entscheidend, damit das Skript auf alle benötigten Informationen zugreifen kann, ohne unnötige Sicherheitsrisiken einzugehen.

#### 2.3.1 Zugriffsrechte für das Skript

*   **Ausführungsrechte**: Das Skript selbst muss über Ausführungsrechte verfügen. Dies geschieht typischerweise mit `chmod +x <skriptname>`.
*   **Benutzerkontext**: Das Skript kann entweder als regulärer Benutzer oder mit erhöhten Rechten (z.B. via `sudo`) ausgeführt werden. Die benötigten Rechte hängen von den abgefragten Informationen ab.

#### 2.3.2 Benötigte Berechtigungen für Systembefehle

Viele der im Abschnitt "Benötigte Tool-Befehle" genannten Befehle erfordern unterschiedliche Berechtigungen:

*   **Lesen von `/proc` und `/sys`**: In der Regel sind keine speziellen Rechte erforderlich, da dies virtuelle Dateisysteme sind, die für alle Benutzer lesbar sind.
*   **Lesen von Konfigurationsdateien in `/etc`**: Viele Konfigurationsdateien sind für alle Benutzer lesbar. Sensible Dateien (z.B. `sudoers` oder einige SSH-Konfigurationen) erfordern möglicherweise Root-Rechte.
*   **Lesen von Log-Dateien in `/var/log`**: Traditionelle Log-Dateien (wie `syslog`) sind oft nur für den Benutzer `root` oder Mitglieder bestimmter Gruppen (z.B. `adm`) lesbar. `journalctl` kann auch eingeschränkte Leseberechtigungen haben.
*   **Hardware-Informationen (`lshw`, `dmidecode`)**: Diese Befehle geben oft nur mit Root-Rechten vollständige und detaillierte Hardware-Informationen aus. Ohne Root sind die Ausgaben oft stark eingeschränkt.
*   **Netzwerkinformationen (`ss`)**: Das Abfragen von lauschenden Ports und zugehörigen Prozessen kann je nach Systemkonfiguration ebenfalls Root-Rechte erfordern, insbesondere um die Prozess-IDs (PIDs) aufzulösen.
*   **Festplatteninformationen (`fdisk -l`)**: Das Auflisten von Partitionstabellen erfordert Root-Rechte.

#### 2.3.3 Strategien für das Rechte-Management

1.  **Ausführung als `root` (höchstes Risiko)**:
    *   Das Skript wird explizit mit `sudo <skriptname>` gestartet.
    *   **Vorteil**: Ermöglicht den Zugriff auf alle benötigten Informationen.
    *   **Nachteil**: Höchstes Sicherheitsrisiko. Ein Fehler im Skript könnte weitreichende Folgen haben.
2.  **Gezielte `sudo`-Aufrufe innerhalb des Skripts**:
    *   Das Skript wird als normaler Benutzer gestartet.
    *   Für spezifische Befehle, die Root-Rechte benötigen, wird innerhalb des Skripts `sudo <befehl>` aufgerufen. Der Benutzer wird aufgefordert, sein Passwort einzugeben.
    *   **Vorteil**: Bietet mehr Kontrolle darüber, wann erhöhte Rechte verwendet werden.
    *   **Nachteil**: Erfordert die Passwortabfrage für den Benutzer, was die Automatisierung erschweren kann. Muss sorgfältig konfiguriert werden, damit das Skript nicht unnötig `sudo` anfordert.
3.  **Konfiguration von `sudoers` (empfohlen für Automatisierung/Nicht-interaktive Ausführung)**:
    *   Die Datei `/etc/sudoers` wird so konfiguriert, dass der ausführende Benutzer bestimmte Befehle ohne Passwort ausführen darf. Dies ist die sicherste Methode für teilautomatisierte Ausführungen.
    *   Beispielkonfiguration in `/etc/sudoers` (oder einer Datei in `/etc/sudoers.d/`):
        `benutzername ALL=(ALL) NOPASSWD: /usr/bin/lshw, /usr/sbin/dmidecode, /usr/sbin/fdisk`
    *   **Vorteil**: Ermöglicht die Ausführung der benötigten Befehle ohne interaktive Passwortabfrage, während die Rechte dennoch begrenzt werden.
    *   **Nachteil**: Erfordert sorgfältige Konfiguration der `sudoers`-Datei, um keine unerwünschten Berechtigungen zu vergeben.

#### 2.3.4 Empfohlene Vorgehensweise

Für ein "Server-Info-Skript", das detaillierte Hardware- und Systeminformationen sammeln soll, ist die **konfigurierte `sudoers`-Datei (Option 3)** die bevorzugte Methode, um die erforderlichen, aber oft nur mit Root-Rechten verfügbaren Informationen abzurufen, ohne das gesamte Skript als Root ausführen zu müssen. Wenn das Skript nur grundlegende Informationen sammelt, die für normale Benutzer zugänglich sind, sind keine speziellen Rechte erforderlich. Die Beschreibung des Skripts sollte klar angeben, welche Methode verwendet wird und welche Berechtigungen der ausführende Benutzer benötigt.

[Code-Block - Bitte selbständig passenden Code generieren]

## Schritt-für-Schritt Execution Plan (Phase 1: Setup & DB)

Dieser Abschnitt beschreibt die Schritte zur Einrichtung der notwendigen Infrastruktur und Datenbank für das Server-Informations-Skript auf Ubuntu 24.04.

### 1. Systemvoraussetzungen und Vorbereitung

Bevor wir mit der Skriptentwicklung beginnen, stellen wir sicher, dass das Zielsystem (Ubuntu 24.04) korrekt konfiguriert ist und alle notwendigen Werkzeuge vorhanden sind.

*   **1.1 Systemaktualisierung:**
    *   **Ziel:** Sicherstellen, dass das System über die neuesten Paketinformationen und Sicherheitsupdates verfügt.
    *   **Anweisung:** Führe die folgenden Befehle aus, um die Paketlisten zu aktualisieren und installierte Pakete auf die neueste verfügbare Version zu aktualisieren.
    *   **Meta-Prompt:** "Generate the shell commands to update the package lists and upgrade all installed packages on Ubuntu 24.04. Ensure these commands are presented in a clear, executable format."
    *   **Erwartetes Ergebnis:** Die Paketquellen werden aktualisiert und alle installierten Pakete werden auf den neuesten Stand gebracht.

*   **1.2 Installation notwendiger Werkzeuge (optional, je nach Skript-Anforderungen):**
    *   **Ziel:** Einige Skripte können von zusätzlichen Werkzeugen profitieren (z.B. `jq` für JSON-Verarbeitung, `htop` für Systemüberwachung). Hier werden beispielhaft Werkzeuge für die Datenverarbeitung und Systemanalyse installiert.
    *   **Anweisung:** Installiere das Paket `jq`, falls nicht bereits vorhanden.
    *   **Meta-Prompt:** "Provide the `apt` command to install the `jq` utility on Ubuntu 24.04. If the utility is already installed, the command should handle this gracefully."
    *   **Erwartetes Ergebnis:** Das `jq`-Paket wird installiert.

### 2. Datenbankeinrichtung

Für die Speicherung und Verwaltung von Serverinformationen wird eine relationale Datenbank verwendet. MySQL (oder eine kompatible Alternative wie MariaDB) ist eine gängige Wahl.

*   **2.1 Installation des Datenbankservers:**
    *   **Ziel:** Installiere den gewählten Datenbankserver auf dem Ubuntu 24.04 System. Wir wählen hier MySQL als Beispiel.
    *   **Anweisung:** Installiere das `mysql-server`-Paket.
    *   **Meta-Prompt:** "Generate the `apt` command to install the `mysql-server` package on Ubuntu 24.04. Include any necessary prerequisites or dependencies that the package manager might automatically handle."
    *   **Erwartetes Ergebnis:** Der MySQL-Server wird installiert und gestartet.

*   **2.2 Datenbank-Sicherheitseinstellungen:**
    *   **Ziel:** Härten des Datenbankservers durch Ausführen des mitgelieferten Sicherheitsskripts.
    *   **Anweisung:** Führe das MySQL-Sicherheitsskript aus und folge den Anweisungen zur Härtung der Installation (z.B. Festlegen eines Root-Passworts, Entfernen anonymer Benutzer, Deaktivieren des Remote-Roots-Logins).
    *   **Meta-Prompt:** "Describe the steps and commands involved in running the `mysql_secure_installation` script on Ubuntu 24.04. Detail the prompts the user will encounter and the recommended answers for a secure setup."
    *   **Erwartetes Ergebnis:** Der MySQL-Server ist sicher konfiguriert.

*   **2.3 Erstellen einer dedizierten Datenbank und eines Benutzers:**
    *   **Ziel:** Erstellen einer eigenen Datenbank für die Serverinformationen und eines spezifischen Benutzers mit den notwendigen Berechtigungen, um die Sicherheit zu erhöhen.
    *   **Anweisung:**
        1.  Verbinde dich als Root-Benutzer mit der MySQL-Shell.
        2.  Erstelle eine Datenbank namens `server_info_db`.
        3.  Erstelle einen Datenbankbenutzer namens `server_info_user` mit einem sicheren Passwort (z.B. `StrongSecurePassword123!`).
        4.  Gewähre dem Benutzer `server_info_user` alle Berechtigungen auf die Datenbank `server_info_db`.
        5.  Stelle sicher, dass die Berechtigungen wirksam werden.
    *   **Meta-Prompt:** "Provide the MySQL commands to:
        1. Connect to the MySQL server as the root user.
        2. Create a new database named `server_info_db`.
        3. Create a new user named `server_info_user` with a strong password placeholder.
        4. Grant all privileges on the `server_info_db` to `server_info_user`.
        5. Flush privileges to apply changes.
        Assume the user will be prompted for the MySQL root password."
    *   **Erwartetes Ergebnis:** Eine dedizierte Datenbank und ein Benutzer mit eingeschränkten Rechten werden erfolgreich erstellt.

*   **2.4 Erstellen der Tabellenstruktur:**
    *   **Ziel:** Definieren der Schemastruktur für die Speicherung der Serverinformationen.
    *   **Anweisung:** Erstelle innerhalb der Datenbank `server_info_db` die Tabelle `servers` mit folgenden Spalten:
        *   `id` (INT, PRIMARY KEY, AUTO_INCREMENT)
        *   `hostname` (VARCHAR(255), NOT NULL, UNIQUE)
        *   `ip_address` (VARCHAR(45), NOT NULL)
        *   `os_version` (VARCHAR(100))
        *   `cpu_cores` (INT)
        *   `ram_gb` (INT)
        *   `disk_usage_percent` (DECIMAL(5,2))
        *   `last_checked_at` (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP)
    *   **Meta-Prompt:** "Generate the SQL `CREATE TABLE` statement for a table named `servers` within a database. The table should have the following columns with specified data types, constraints, and default values: `id` (INT, PRIMARY KEY, AUTO_INCREMENT), `hostname` (VARCHAR(255), NOT NULL, UNIQUE), `ip_address` (VARCHAR(45), NOT NULL), `os_version` (VARCHAR(100)), `cpu_cores` (INT), `ram_gb` (INT), `disk_usage_percent` (DECIMAL(5,2)), and `last_checked_at` (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP)."
    *   **Erwartetes Ergebnis:** Die Tabelle `servers` wird mit der definierten Struktur in der Datenbank `server_info_db` erstellt.

Diese Phase legt die grundlegenden Voraussetzungen für die Entwicklung und den Betrieb des Server-Informations-Skripts, indem sie das Betriebssystem vorbereitet und eine funktionale, sichere Datenbankumgebung einrichtet.

## 4. Schritt-für-Schritt Execution Plan (Phase 2: Backend & API) - Server Info Script für Ubuntu 24.04

Dieser Abschnitt beschreibt die schrittweise Entwicklung des Backend-Teils und der zugehörigen API zur Bereitstellung von Serverinformationen für Ubuntu 24.04.

### 4.1. Backend-Architektur und Technologieauswahl

Die Backend-Architektur wird auf einem robusten und skalierbaren Framework basieren, das die effiziente Sammlung, Verarbeitung und Bereitstellung von Serverinformationen ermöglicht.

*   **Programmiersprache:** Python wird als primäre Programmiersprache für das Backend gewählt. Seine umfangreiche Bibliothek an Systemmanagement-Tools und seine einfache Lesbarkeit machen es ideal für diese Aufgabe.
*   **Web-Framework:** Flask wird als leichtgewichtiges und flexibles Web-Framework für die Erstellung der API-Endpunkte eingesetzt. Es ermöglicht eine schnelle Entwicklung und ist gut geeignet für kleinere bis mittelgroße Anwendungen.
*   **Datenstruktur für Serverinformationen:** Ein dictionary-ähnliches Format (z.B. JSON-Objekte) wird zur internen Darstellung der gesammelten Serverinformationen verwendet. Dies ermöglicht eine einfache Serialisierung und Deserialisierung für die API-Antworten.
*   **Prozessmanagement:** Der Prozess der Informationsbeschaffung wird als separater Prozess oder Thread im Backend ausgeführt, um die Hauptanwendungslogik nicht zu blockieren.

**Detaillierte Anweisungen für den Architekten:**

1.  **Festlegung der Kernmodule:** Definieren Sie die grundlegenden Python-Module, die für die Informationsbeschaffung und API-Bereitstellung benötigt werden. Dies umfasst typischerweise Module für Systemaufrufe, Netzwerkoperationen und Dateisystemzugriffe.
2.  **API-Endpunkt-Design:** Entwerfen Sie die Struktur der API-Endpunkte. Überlegen Sie, welche spezifischen Informationen abgefragt werden sollen und wie diese über URLs adressiert werden. Ein möglicher Endpunkt wäre `/api/server-info`.
3.  **Datenserialisierung:** Planen Sie die Art und Weise, wie die gesammelten Serverdaten in ein für die API-Antwort geeignetes Format (z.B. JSON) umgewandelt werden.

### 4.2. Informationsbeschaffungslogik auf dem Server

Das Backend muss auf dem Ubuntu 24.04 Server laufen und in der Lage sein, Systeminformationen abzurufen.

*   **Betriebssysteminformationen:** Informationen wie Kernel-Version, Distribution (Ubuntu 24.04), Architektur.
*   **Hardwareinformationen:** CPU-Auslastung, RAM-Nutzung, Festplattenspeicher (gesamter und verfügbarer Speicherplatz), Netzwerkinterfaces und ihre Status.
*   **Systemdienste:** Auflistung laufender Systemdienste.
*   **Prozessinformationen:** Anzahl der laufenden Prozesse.
*   **Netzwerkstatus:** Aktive Verbindungen (optional, je nach Sicherheitspolice).

**Detaillierte Anweisungen für den Architekten:**

1.  **Modul für OS-Infos:** Entwickeln Sie ein Modul, das Funktionen zur Abfrage von Betriebssystemdetails über Befehle wie `uname -a` und die Analyse von `/etc/os-release` implementiert.
    [Code-Block - Bitte selbständig passenden Code generieren]
2.  **Modul für Hardware-Infos:** Erstellen Sie Module, die sich mit der Abfrage von CPU- und RAM-Auslastung (z.B. über `/proc/stat` und `/proc/meminfo`), Festplattenspeicher (z.B. `df -h`) und Netzwerkinterfaces (z.B. `ip a`) befassen.
    [Code-Block - Bitte selbständig passenden Code generieren]
3.  **Modul für Systemdienste und Prozesse:** Implementieren Sie Logik zur Abfrage von Systemdienste-Status (z.B. `systemctl list-units --type=service`) und zur Zählung von Prozessen (z.B. `ps aux | wc -l`).
    [Code-Block - Bitte selbständig passenden Code generieren]
4.  **Fehlerbehandlung und Validierung:** Integrieren Sie robuste Fehlerbehandlung in alle Informationsbeschaffungsfunktionen. Stellen Sie sicher, dass ungültige oder fehlende Daten korrekt behandelt werden.
    [Code-Block - Bitte selbständig passenden Code generieren]
5.  **Konsolidierung der Daten:** Definieren Sie eine Funktion, die alle gesammelten Informationen in der zuvor definierten Datenstruktur konsolidiert.
    [Code-Block - Bitte selbständig passenden Code generieren]

### 4.3. API-Implementierung (Flask)

Das Flask-Framework wird verwendet, um die API-Endpunkte zu definieren und die gesammelten Serverinformationen bereitzustellen.

*   **RESTful API Design:** Die API wird nach RESTful Prinzipien gestaltet.
*   **Datenformat:** Antworten werden im JSON-Format geliefert.
*   **Sicherheit:** Basis-Authentifizierung oder API-Schlüssel könnten in einer fortgeschrittenen Phase implementiert werden (hier vorerst nicht fokussiert).

**Detaillierte Anweisungen für den Architekten:**

1.  **Flask-Anwendung initialisieren:** Richten Sie die grundlegende Flask-Anwendung ein.
    [Code-Block - Bitte selbständig passenden Code generieren]
2.  **Erstellung des `/api/server-info` Endpunkts:** Definieren Sie eine Flask-Route für den `/api/server-info` Endpunkt. Diese Route ruft die Informationsbeschaffungslogik auf und gibt die Ergebnisse im JSON-Format zurück.
    [Code-Block - Bitte selbständig passenden Code generieren]
3.  **Integration der Informationsbeschaffungsmodule:** Stellen Sie sicher, dass die Funktionen aus Abschnitt 4.2 innerhalb der Flask-Anwendung aufgerufen werden können.
    [Code-Block - Bitte selbständig passenden Code generieren]
4.  **Fehlerantworten:** Implementieren Sie Standard-Fehlerantworten (z.B. 500 Internal Server Error) für den Fall, dass die Informationsbeschaffung fehlschlägt.
    [Code-Block - Bitte selbständig passenden Code generieren]
5.  **Serverstart-Skript:** Erstellen Sie ein Skript, das die Flask-Anwendung startet und konfiguriert (z.B. mit Gunicorn oder uWSGI für Produktionsumgebungen).
    [Code-Block - Bitte selbständig passenden Code generieren]

### 4.4. Deployment und Konfiguration des Backends

Das entwickelte Backend muss auf dem Zielserver installiert und konfiguriert werden.

*   **Virtuelle Umgebung:** Nutzung einer Python-Virtual-Umgebung (venv) zur Isolierung der Abhängigkeiten.
*   **Server-Konfiguration:** Einrichten eines Dienstes (z.B. systemd-Dienst) zur Verwaltung des Backend-Prozesses.
*   **Firewall-Konfiguration:** Öffnen des relevanten Ports, wenn die API von extern zugänglich sein soll.

**Detaillierte Anweisungen für den Architekten:**

1.  **Abhängigkeitsmanagement:** Erstellen Sie eine `requirements.txt`-Datei mit allen notwendigen Python-Paketen (Flask, etc.).
    [Code-Block - Bitte selbständig passenden Code generieren]
2.  **systemd-Service-Datei erstellen:** Erstellen Sie eine systemd-Unit-Datei, um den Flask-Anwendungsprozess automatisch zu starten, zu stoppen und bei Bedarf neu zu starten.
    [Code-Block - Bitte selbständig passenden Code generieren]
3.  **Webserver-Konfiguration (optional, aber empfohlen für Produktion):** Wenn die API direkt über HTTP/S erreichbar sein soll, konfigurieren Sie einen Webserver wie Nginx oder Apache als Reverse-Proxy vor der Flask-Anwendung.
    [Code-Block - Bitte selbständig passenden Code generieren]
4.  **Firewall-Regeln (wenn externe Zugriffe erforderlich sind):** Konfigurieren Sie die Firewall (z.B. `ufw`) auf dem Ubuntu-Server, um eingehenden Verkehr auf dem API-Port zuzulassen.
    [Code-Block - Bitte selbständig passenden Code generieren]

## Schritt-für-Schritt Execution Plan: Phase 3: Frontend & UI

Diese Phase konzentriert sich auf die Entwicklung des Frontend- und Benutzeroberflächenteils des Server-Info-Skripts. Hier werden die visuellen Elemente und die Interaktion des Benutzers mit den gesammelten Informationen gestaltet.

### 3.1. Auswahl des Frontend-Frameworks und der Technologien

**Meta-Prompt:**

"Als KI-Architekt für 'Antigravity' sollst du die geeignetsten Frontend-Technologien und Frameworks für die Entwicklung einer intuitiven und reaktionsschnellen Benutzeroberfläche für unser Server-Info-Skript auf Ubuntu 24.04 auswählen. Berücksichtige dabei Faktoren wie Einfachheit der Implementierung, Wartbarkeit, Verfügbarkeit von Libraries für Datenvisualisierung und die Möglichkeit, dynamische Daten anzuzeigen. Erstelle eine detaillierte Begründung für jede Technologieauswahl."

**Anweisungen:**

1.  **Analyse der Anforderungen:** Identifiziere die Kernanforderungen an das Frontend: Anzeige von Serverinformationen (CPU, RAM, Festplattenspeicher, Netzwerk, laufende Prozesse), Aktualisierung der Daten in Echtzeit (optional, aber wünschenswert) und eine klare, benutzerfreundliche Darstellung.
2.  **Evaluierung von JavaScript-Frameworks:**
    *   **React.js:** Bewerte React.js hinsichtlich seiner Komponentenarchitektur, Virtual DOM für effiziente Updates und der breiten Community-Unterstützung.
    *   **Vue.js:** Bewerte Vue.js hinsichtlich seiner einfachen Lernkurve, progressiven Natur und der guten Performance.
    *   **Angular:** Bewerte Angular hinsichtlich seiner umfassenden Funktionen, Struktur und Eignung für größere Anwendungen.
    *   **Plain JavaScript (Vanilla JS):** Bewerte die Möglichkeit, eine reine JavaScript-Lösung zu implementieren, insbesondere für einfachere Anwendungsfälle, aber auch die Nachteile bei komplexeren Interaktionen.
3.  **Evaluierung von UI-Bibliotheken/Frameworks:**
    *   **Bootstrap:** Bewerte Bootstrap für seine vorgefertigten Komponenten, Responsivität und einfache Anpassbarkeit.
    *   **Tailwind CSS:** Bewerte Tailwind CSS für seinen Utility-First-Ansatz, der schnelle und flexible UI-Gestaltung ermöglicht.
    *   **Material-UI (für React):** Bewerte Material-UI für seine Implementierung des Material Design von Google, das eine konsistente und moderne Ästhetik bietet.
4.  **Evaluierung von Datenvisualisierungs-Bibliotheken:**
    *   **Chart.js:** Bewerte Chart.js für seine Einfachheit und Vielseitigkeit bei der Erstellung gängiger Diagrammtypen (Balken-, Linien-, Tortendiagramme).
    *   **D3.js:** Bewerte D3.js für seine Leistungsfähigkeit und Flexibilität bei der Erstellung benutzerdefinierter und komplexer Visualisierungen, auch wenn es eine steilere Lernkurve hat.
    *   **Plotly.js:** Bewerte Plotly.js für seine interaktiven Diagramme und die breite Palette an unterstützten Chart-Typen.
5.  **Technologieauswahl und Begründung:** Wähle basierend auf der Analyse die vielversprechendsten Technologien aus und begründe deine Entscheidung detailliert. Lege dar, warum diese Wahl die beste für die Ziele des Projekts ist.

*   **Beispielhafte Auswahl (muss durch den Architekten begründet werden):**
        *   Frontend-Framework: React.js
        *   UI-Bibliothek: Tailwind CSS
        *   Datenvisualisierung: Chart.js

6.  **Definition der Architektur:** Beschreibe die grundlegende Frontend-Architektur, wie Komponenten strukturiert sein werden und wie die Daten zwischen ihnen fließen.
7.  **Sicherheitsüberlegungen:** Erwähne kurz potenzielle Sicherheitsaspekte bei der Frontend-Entwicklung (z.B. Schutz vor XSS, wenn externe Daten verarbeitet werden).

### 3.2. Entwurf der Benutzeroberfläche (Wireframing & Mockups)

**Meta-Prompt:**

"Als KI-Architekt für 'Antigravity' entwirf eine klare und informative Benutzeroberfläche für das Server-Info-Skript auf Ubuntu 24.04. Erstelle eine schrittweise Beschreibung des UI-Designs, die verschiedene Informationstypen und deren visuelle Darstellung berücksichtigt. Konzentriere dich auf Benutzerfreundlichkeit und eine intuitive Navigation."

**Anweisungen:**

1.  **Zweck der UI:** Definiere das Hauptziel der Benutzeroberfläche: eine schnelle und verständliche Übersicht über den Zustand des Servers zu bieten.
2.  **Kernkomponenten identifizieren:** Liste die Hauptbereiche der Benutzeroberfläche auf, die Informationen anzeigen werden. Dies könnte beinhalten:
    *   **Übersichtsseite:** Zentrale Anzeige der wichtigsten Metriken.
    *   **Detaillierte Ansichten:** Separate Bereiche für spezifische Informationen (z.B. Prozessliste, Festplattennutzung).
    *   **Navigation:** Wie der Benutzer zwischen verschiedenen Ansichten wechselt.
3.  **Wireframe-Beschreibungen (strukturell):** Beschreibe das Layout und die Anordnung von Elementen für jede Kernkomponente. Verwende hier keine grafischen Elemente, sondern textliche Beschreibungen.
    *   **Übersichtsseite:**
        *   Header: Name des Servers, aktuelles Datum/Uhrzeit.
        *   Abschnitt 1 (Systemressourcen):
            *   CPU-Auslastung (Prozentual, ggf. mit kleinem Diagramm/Fortschrittsbalken).
            *   RAM-Auslastung (Aktuell/Gesamt, ggf. mit Fortschrittsbalken).
            *   Festplattenspeicher (Übersicht über gemountete Partitionen, belegte/freie GB, Prozentual).
        *   Abschnitt 2 (Netzwerk):
            *   Aktive Netzwerkschnittstellen (IP-Adressen).
            *   Aktueller Datenverkehr (optional, aber nützlich).
        *   Abschnitt 3 (Prozesse):
            *   Anzahl der laufenden Prozesse.
            *   Link zur detaillierten Prozessliste.
    *   **Detaillierte Prozessliste:**
        *   Tabelle mit Spalten: PID, Benutzer, CPU%, MEM%, Befehl.
        *   Such- und Filterfunktion.
    *   **Detaillierte Festplattenansicht:**
        *   Liste der Partitionen mit mehr Details: Mountpoint, Dateisystemtyp, Größe, belegt, frei.
4.  **Datenvisualisierungselemente:** Beschreibe, wie welche Daten visuell dargestellt werden:
    *   **CPU/RAM:** Fortschrittsbalken oder einfache Linien-/Flächendiagramme für die Echtzeit-Auslastung.
    *   **Festplattenspeicher:** Kreisdiagramme oder gestapelte Balkendiagramme für die prozentuale Nutzung.
    *   **Netzwerkverkehr:** Liniendiagramme zur Darstellung des Datenflusses über die Zeit.
5.  **Interaktionsdesign:** Beschreibe, wie Benutzer mit der UI interagieren:
    *   Klicken auf Elemente für weitere Details.
    *   Sortieren und Filtern von Tabellen.
    *   Aktualisierungsmechanismen (manueller Button oder automatische Aktualisierung).
6.  **Responsives Design (grundlegend):** Erwähne, dass die UI responsiv gestaltet sein sollte, um auf verschiedenen Bildschirmgrößen gut auszusehen.

### 3.3. Implementierung der Frontend-Komponenten

**Meta-Prompt:**

"Als KI-Architekt für 'Antigravity' sollst du die Implementierung der Frontend-Komponenten für das Server-Info-Skript auf Ubuntu 24.04 detailliert beschreiben. Gib klare Anweisungen für die Erstellung der einzelnen UI-Elemente unter Verwendung der zuvor ausgewählten Technologien. Konzentriere dich auf die Struktur und Logik, NICHT auf den eigentlichen Code."

**Anweisungen:**

1.  **Projektstruktur:** Definiere eine logische Ordnerstruktur für das Frontend-Projekt (z.B. `src/components`, `src/pages`, `src/services`, `src/utils`).
2.  **Hauptanwendungskomponente:**
    *   Beschreibe die Hauptanwendungskomponente, die für das Routing und das Laden der verschiedenen Seiten/Ansichten verantwortlich ist.
    *   Erkläre, wie sie den Zustand der Anwendung verwaltet (z.B. welche Daten gerade geladen werden).
    *   [Code-Block - Bitte selbständig passenden Code generieren]
3.  **Komponentenentwicklung (Beispiele):**
    *   **CPU-Auslastungs-Widget:**
        *   Erkläre die Erstellung einer Komponente, die einen Wert (CPU-Auslastung in Prozent) als Eingabe erhält.
        *   Beschreibe die visuelle Darstellung (z.B. ein runder Fortschrittsbalken oder ein einfacher Text).
        *   Erkläre, wie die Farbe des Elements auf Basis des Wertes geändert werden kann (z.B. grün bei niedriger Auslastung, rot bei hoher).
        *   [Code-Block - Bitte selbständig passenden Code generieren]
    *   **RAM-Status-Komponente:**
        *   Beschreibe die Erstellung einer Komponente, die aktuell und gesamt genutzten RAM als Eingabe nimmt.
        *   Erkläre die Darstellung als Fortschrittsbalken (z.B. mit Text wie "4GB / 8GB").
        *   [Code-Block - Bitte selbständig passenden Code generieren]
    *   **Festplattennutzungs-Komponente:**
        *   Erkläre die Erstellung einer Komponente, die eine Liste von Festplattenobjekten (mit Mountpoint, Größe, freiem Speicherplatz) als Eingabe erhält.
        *   Beschreibe die Darstellung jeder Festplatte (z.B. als Zeile in einer Tabelle oder als separate Karten).
        *   Inkludiere die Berechnung und Anzeige des prozentualen Speicherplatzes.
        *   [Code-Block - Bitte selbständig passenden Code generieren]
    *   **Prozesslisten-Tabelle:**
        *   Beschreibe die Erstellung einer Tabelle mit dynamisch ladbaren Daten.
        *   Erkläre die Spaltenüberschriften (PID, User, CPU, MEM, Command).
        *   Beschreibe die Implementierung von Sortier- und Filterfunktionen für die Tabelle.
        *   [Code-Block - Bitte selbständig passenden Code generieren]
4.  **Datenabruf-Service:**
    *   Erkläre die Erstellung eines separaten Dienstes oder Moduls, das für die Kommunikation mit dem Backend (oder dem Skript, das die Daten liefert) zuständig ist.
    *   Beschreibe, wie dieser Dienst Anfragen an die API sendet und die Antworten verarbeitet.
    *   [Code-Block - Bitte selbständig passenden Code generieren]
5.  **Zustandsverwaltung:**
    *   Erkläre, wie der Zustand der Anwendung (die abgerufenen Serverdaten) verwaltet wird. Dies kann beinhalten:
        *   Lokaler Komponenten-State.
        *   Context API (für React).
        *   Ein State-Management-Tool wie Redux oder Vuex (falls im Framework enthalten).
    *   Beschreibe, wie Komponenten auf Zustandsänderungen reagieren und sich aktualisieren.
6.  **Routing:**
    *   Beschreibe die Implementierung von clientseitigem Routing, um verschiedene Ansichten zu ermöglichen (z.B. `/` für Übersicht, `/processes` für Prozessliste).
    *   [Code-Block - Bitte selbständig passenden Code generieren]
7.  **Styling:**
    *   Beschreibe, wie die ausgewählte UI-Bibliothek (z.B. Tailwind CSS) zur Anwendung von Styles verwendet wird.
    *   Erkläre die Nutzung von Klassen und Konfigurationen, um das gewünschte Look-and-Feel zu erzielen.

### 3.4. Datenvisualisierung und Echtzeit-Updates (Frontend)

**Meta-Prompt:**

"Als KI-Architekt für 'Antigravity' sollst du die Implementierung der Datenvisualisierung und die Strategie für Echtzeit-Updates im Frontend des Server-Info-Skripts beschreiben. Stelle sicher, dass die Benutzer die gesammelten Informationen effektiv und visuell ansprechend verstehen können, und erläutere, wie die Daten dynamisch aktualisiert werden."

**Anweisungen:**

1.  **Integration der Visualisierungsbibliothek:**
    *   Beschreibe, wie die ausgewählte Datenvisualisierungs-Bibliothek (z.B. Chart.js) in die Frontend-Anwendung integriert wird.
    *   Erkläre, wie die Bibliothek in spezifischen Komponenten verwendet wird, um Diagramme zu rendern.
    *   [Code-Block - Bitte selbständig passenden Code generieren]
2.  **Rendering von Diagrammen:**
    *   **CPU/RAM-Auslastungsgrafik:**
        *   Beschreibe die Konfiguration eines Liniendiagramms oder eines Area-Charts, um die CPU- und RAM-Auslastung über die Zeit anzuzeigen.
        *   Definiere die Achsenbeschriftungen (Zeit, Prozent).
        *   Erkläre, wie die Datenpunkte im Diagramm aktualisiert werden.
        *   [Code-Block - Bitte selbständig passenden Code generieren]
    *   **Festplattenspeicher-Diagramm:**
        *   Beschreibe die Konfiguration eines Kreisdiagramms (Donut-Chart) oder eines gestapelten Balkendiagramms, um die Auslastung der Festplattenspeicher zu visualisieren.
        *   Erkläre, wie die einzelnen Segmente Farben erhalten können, um den Status anzuzeigen (z.B. Grün, Gelb, Rot).
        *   [Code-Block - Bitte selbständig passenden Code generieren]
3.  **Strategie für Echtzeit-Updates:**
    *   **Polling-Mechanismus:**
        *   Beschreibe, wie ein regelmäßiger Abruf (Polling) von Daten vom Backend implementiert wird.
        *   Lege die Intervallzeit für das Polling fest (z.B. alle 5 Sekunden).
        *   Erkläre, wie die abgerufenen Daten verwendet werden, um die UI (Diagramme, Fortschrittsbalken) zu aktualisieren.
        *   [Code-Block - Bitte selbständig passenden Code generieren]
    *   **WebSockets (Optional, fortschrittlich):**
        *   Falls WebSockets eine Option sind, beschreibe kurz, wie diese für unidirektionale oder bidirektionale Echtzeitkommunikation genutzt werden könnten, um Daten-Updates vom Server zu empfangen, sobald sie verfügbar sind.
        *   Erkläre, wie die empfangenen Daten die UI aktualisieren würden.
        *   [Code-Block - Bitte selbständig passenden Code generieren]
4.  **Aktualisierungs-Management:**
    *   Beschreibe, wie die UI-Aktualisierungen effizient gehandhabt werden, um unnötige Neuberechnungen zu vermeiden (z.B. durch die Optimierungen des gewählten Frameworks wie Virtual DOM).
    *   Erkläre, wie das Polling gestoppt werden kann, wenn die Komponente nicht mehr sichtbar ist, um Ressourcen zu schonen.
5.  **Fehlerbehandlung bei Updates:**
    *   Beschreibe, wie Fehler beim Abruf von Daten während des Echtzeit-Updates behandelt werden (z.B. Anzeige einer Fehlermeldung, erneuter Versuch nach einer Verzögerung).

### 3.5. Testen und Debugging des Frontends

**Meta-Prompt:**

"Als KI-Architekt für 'Antigravity' sollst du einen Plan für das Testen und Debugging des Frontends des Server-Info-Skripts für Ubuntu 24.04 erstellen. Lege verschiedene Testarten fest und beschreibe die Vorgehensweise zur Identifizierung und Behebung von Fehlern in der Benutzeroberfläche."

**Anweisungen:**

1.  **Teststrategie definieren:** Beschreibe die verschiedenen Ebenen von Tests, die im Frontend durchgeführt werden sollten:
    *   **Unit Tests:** Tests für einzelne Komponenten und Funktionen.
    *   **Integration Tests:** Tests für das Zusammenspiel mehrerer Komponenten.
    *   **End-to-End (E2E) Tests:** Tests, die den gesamten Benutzerfluss simulieren.
2.  **Unit Testing:**
    *   Beschreibe, wie Unit-Tests für kritische Frontend-Komponenten geschrieben werden (z.B. eine Funktion zur Formatierung von Speichergrößen, eine Logik in einer Datenvisualisierungs-Komponente).
    *   Nenne beispielhafte Test-Frameworks (z.B. Jest, Mocha) und deren Verwendung zur Überprüfung von Funktionalität und erwarteten Ausgaben.
    *   [Code-Block - Bitte selbständig passenden Code generieren]
3.  **Integration Testing:**
    *   Erkläre, wie Integrationstests durchgeführt werden, um zu überprüfen, ob verschiedene Komponenten korrekt zusammenarbeiten (z.B. ob der Datenabruf-Service die Daten korrekt an die UI-Komponenten weitergibt).
    *   Beschreibe die Mocking-Strategie für externe Abhängigkeiten.
    *   [Code-Block - Bitte selbständig passenden Code generieren]
4.  **End-to-End (E2E) Testing:**
    *   Beschreibe die Erstellung von E2E-Tests, die den Benutzer durch typische Szenarien führen (z.B. Öffnen der Seite, Anzeigen der Übersicht, Navigieren zur Prozessliste, Filtern der Prozesse).
    *   Nenne beispielhafte E2E-Test-Frameworks (z.B. Cypress, Selenium).
    *   Erkläre, wie diese Tests die Funktionalität aus Benutzersicht validieren.
    *   [Code-Block - Bitte selbständig passenden Code generieren]
5.  **Browser-Kompatibilitätstests:**
    *   Erkläre die Notwendigkeit, die Anwendung in verschiedenen modernen Webbrowsern (Chrome, Firefox, Safari, Edge) zu testen, um Konsistenz zu gewährleisten.
    *   Beschreibe, wie Tests auf verschiedenen Betriebssystemen durchgeführt werden können.
6.  **Debugging-Tools und -Strategien:**
    *   Beschreibe die Verwendung der Entwicklertools des Browsers (Console, Network, Elements Tab) zur Untersuchung von Fehlern.
    *   Erkläre das Setzen von Breakpoints im JavaScript-Code zur schrittweisen Ausführung und Inspektion von Variablen.
    *   Beschreibe die Analyse von Fehlermeldungen in der Browser-Konsole.
    *   Erwähne die Nutzung von Logging innerhalb der Frontend-Anwendung.
7.  **Performance-Optimierung:**
    *   Beschreibe, wie die Leistung der Frontend-Anwendung gemessen und optimiert werden kann (z.B. mit den Performance-Tools des Browsers, Überprüfung von Render-Zeiten, effizienter Umgang mit Daten).
8.  **Dokumentation der Testergebnisse:** Beschreibe, wie Testergebnisse und gefundene Fehler dokumentiert und an das Entwicklungsteam weitergeleitet werden.

## 6. Fallback-Strategien, Fehlerbehandlung und finale Verifikations-Tests für das Server-Info-Skript

Dieses Kapitel befasst sich mit der robusten Implementierung von Fallback-Strategien, der sorgfältigen Fehlerbehandlung und den entscheidenden finalen Verifikations-Tests für das entwickelte Server-Info-Skript auf Ubuntu 24.04. Ziel ist es, die Ausfallsicherheit, Zuverlässigkeit und Korrektheit des Skripts unter verschiedenen Bedingungen zu gewährleisten.

### 6.1 Fallback-Strategien

Für kritische Funktionen, bei denen ein Ausfall zu signifikanten Problemen führen könnte, werden Fallback-Mechanismen implementiert. Dies stellt sicher, dass das Skript auch bei kurzfristigen Ausfällen von externen Diensten oder bei unerwarteten Datenformatänderungen eine grundlegende Funktionalität aufrechterhalten kann.

#### 6.1.1 Fallback für externe Datenquellen

*   **Beschreibung:** Das Skript kann auf externe Quellen wie APIs zur Abfrage von IP-Adressinformationen oder zur Überprüfung der Erreichbarkeit von Diensten angewiesen sein.
*   **Fallback-Mechanismus:** Wenn eine externe Anfrage fehlschlägt (z. B. Timeout, ungültige Antwort), wird auf eine interne Cache-Datenbank oder auf Standardwerte zurückgegriffen. Alternativ kann das Skript auch eine Meldung generieren, die auf den Ausfall der externen Quelle hinweist, aber dennoch die verfügbaren internen Informationen ausgibt.
*   **Implementierungslogik:** Vor jeder externen Anfrage wird geprüft, ob die Verbindung aufgebaut werden kann. Bei Fehlschlägen wird eine alternative Datenquelle aktiviert oder eine Fehlermeldung protokolliert und das Skript fährt mit den lokal verfügbaren Daten fort.
    [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.1.2 Fallback für systeminterne Befehle

*   **Beschreibung:** Das Skript nutzt verschiedene Systembefehle (z. B. `free`, `df`, `ss`), um Systeminformationen abzurufen.
*   **Fallback-Mechanismus:** Sollte ein bestimmter Systembefehl nicht gefunden werden oder einen Fehler zurückgeben, versucht das Skript, alternative Befehle zu verwenden, die ähnliche Informationen liefern. Wenn auch diese fehlschlagen, wird ein Platzhalterwert ausgegeben und der spezifische Fehler protokolliert.
*   **Implementierungslogik:** Für jeden kritischen Systembefehl wird eine Liste von alternativen Befehlen (oder Befehlsoptionen) vorgehalten. Bei einem Fehler wird iterativ die Liste der Alternativen durchgegangen, bis ein funktionierender Befehl gefunden wird.
    [Code-Block - Bitte selbständig passenden Code generieren]

### 6.2 Fehlerbehandlung

Eine umfassende Fehlerbehandlung ist entscheidend, um das Skript robust gegenüber unerwarteten Situationen zu machen und die Ursachen von Problemen schnell identifizieren zu können.

#### 6.2.1 Fehlerprotokollierung

*   **Beschreibung:** Alle kritischen Fehler, Warnungen und Informationsmeldungen werden in einer dedizierten Protokolldatei gespeichert.
*   **Mechanismus:** Die Protokollierung erfolgt über ein standardisiertes System (z. B. `syslog` oder eine eigene Log-Datei mit Zeitstempeln und Schweregraden).
*   **Implementierungslogik:** Das Skript fängt alle erwartbaren Exceptions und Fehler ab. Für jede abzufangene Situation wird eine informative Meldung in die Protokolldatei geschrieben, die den Zeitpunkt des Auftretens, die betroffene Funktion, die Fehlermeldung und gegebenenfalls den Kontext enthält.
    [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.2.2 Exception Handling

*   **Beschreibung:** Das Skript implementiert `try-except`-Blöcke (oder äquivalente Mechanismen in der verwendeten Skriptsprache) zur Behandlung von Laufzeitfehlern.
*   **Mechanismus:** Unvorhergesehene Fehler während der Ausführung werden abgefangen und führen nicht zum abrupten Abbruch des Skripts. Stattdessen wird der Fehler protokolliert und ein definierter Fehlerbehandlungsablauf eingeleitet.
*   **Implementierungslogik:** Kritische Codeabschnitte, die potenziell Fehler verursachen können, werden in `try`-Blöcke eingeschlossen. `except`-Blöcke definieren, wie auf spezifische Fehlertypen oder allgemeine Ausnahmen reagiert wird, inklusive der Ausgabe von Fehlermeldungen und der Protokollierung.
    [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.2.3 Validierung von Eingaben und Ausgaben

*   **Beschreibung:** Sowohl die Eingaben des Skripts (falls vorhanden) als auch die von Systembefehlen oder externen Diensten erhaltenen Ausgaben werden validiert.
*   **Mechanismus:** Die Validierung stellt sicher, dass die Daten dem erwarteten Format, Datentyp und Wertebereich entsprechen.
*   **Implementierungslogik:** Für jede relevante Datenquelle werden Validierungsregeln definiert. Bevor die Daten weiterverarbeitet werden, werden diese Regeln angewendet. Bei Nichteinhaltung wird entweder ein Standardwert verwendet, eine Warnung ausgegeben oder das Skript mit einer spezifischen Fehlermeldung beendet.
    [Code-Block - Bitte selbständig passenden Code generieren]

### 6.3 Finale Verifikations-Tests

Nach der Implementierung der Fehlerbehandlung und Fallback-Strategien werden umfassende Tests durchgeführt, um die korrekte Funktion und Robustheit des Skripts zu verifizieren.

#### 6.3.1 Unit-Tests

*   **Beschreibung:** Einzelne Funktionen und Module des Skripts werden isoliert getestet.
*   **Testfälle:**
    *   Überprüfung der korrekten Verarbeitung von verschiedenen Eingaben für eine Funktion.
    *   Testen, ob Funktionen bei ungültigen Eingaben korrekt reagieren (z. B. Fehlermeldung oder Standardwert).
    *   Verifikation der Ausgabe von Funktionen unter verschiedenen Bedingungen.
*   **Implementierungslogik:** Es wird ein Unit-Test-Framework verwendet, um automatisierte Tests zu schreiben und auszuführen. Jeder Testfall prüft spezifische Aspekte der Funktionalität.
    [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.3.2 Integrationstests

*   **Beschreibung:** Das Zusammenspiel verschiedener Komponenten des Skripts sowie die Integration mit externen Systemen (z. B. Betriebssystembefehle) werden getestet.
*   **Testfälle:**
    *   Abrufen von Informationen über mehrere Komponenten hinweg (z. B. Speicher und CPU).
    *   Testen des gesamten Ablaufs von der Datenerfassung bis zur Ausgabe.
    *   Verifikation der Fehlerbehandlung und Fallback-Mechanismen im Zusammenspiel.
*   **Implementierungslogik:** Integrationstests simulieren reale Nutzungsszenarien, indem sie das Skript als Ganzes aufrufen und die Ergebnisse mit erwarteten Werten vergleichen. Fehlerhafte Zustände werden absichtlich herbeigeführt, um die Robustheit zu prüfen.
    [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.3.3 End-to-End-Tests

*   **Beschreibung:** Das Skript wird in einer realen oder simulierten Produktionsumgebung getestet, um sicherzustellen, dass es wie erwartet funktioniert.
*   **Testfälle:**
    *   Ausführung des Skripts unter verschiedenen Lastbedingungen.
    *   Testen der Ausgabeformatierung für verschiedene Zielsysteme (z. B. Konsole, Log-Dateien).
    *   Überprüfung der Protokollierung und Fehlerberichterstattung in einer produktiven Umgebung.
    *   Testen der Funktionalität mit verschiedenen Benutzerberechtigungen.
*   **Implementierungslogik:** End-to-End-Tests umfassen die Ausführung des Skripts auf einem Zielserver und die manuelle oder automatisierte Überprüfung der generierten Ausgaben und des Systemverhaltens. Regelmäßige Regressionstests sind hierbei unerlässlich.
    [Code-Block - Bitte selbständig passenden Code generieren]