Infrastruktur als Code (IaC)

Automatisierte Überwachung:
WatchGrid-Agenten per Ansible verteilen.

Wer eine wachsende Serverlandschaft verwaltet, verzichtet auf manuelle Installationsschritte. Die Bereitstellung von Monitoring-Agenten gehört direkt in die Provisionierungs-Pipeline. Dank seiner minimalen Anforderungen und der Architektur als statisch kompiliertes Go-Binary lässt sich der WatchGrid-Agent nahtlos und in Sekundenschnelle via Ansible ausrollen.

Kostenlos starten Direkt zum Playbook

Warum sich WatchGrid hervorragend für die Automatisierung eignet

Klassische Monitoring-Lösungen fordern beim automatischen Deployment oft einen hohen Konfigurationsaufwand. Sie müssen Ports in der Firewall öffnen, Zertifikate verteilen oder komplexe VPN-Tunnel aufbauen, damit ein zentraler Server Metriken abfragen kann.

WatchGrid geht einen moderneren Weg. Der Go-Agent arbeitet nach dem Push-Modell. Er sammelt die Systemmetriken lokal und sendet sie verschlüsselt über eine ausgehende HTTPS-Verbindung an das WatchGrid-Backend. Ihre Firewalls können eingehende Verbindungen somit weiterhin vollständig blockieren. Das minimiert die Angriffsfläche Ihrer Server und reduziert die Ansible-Netzwerkkonfiguration auf null.

Zudem belegt der Agent im laufenden Betrieb weniger als 15 Megabyte Arbeitsspeicher und unter ein Prozent CPU-Leistung. Das macht ihn auch auf kleinen VPS-Instanzen zur idealen Wahl, bei denen schwerere Agents (wie die von Datadog oder Checkmk) wertvolle Ressourcen beanspruchen würden.

Schritt 1: Inventar und Variablen strukturieren

Da jeder überwachte Host eine eindeutige Agent-ID im WatchGrid-Dashboard benötigt, strukturieren wir die Ansible-Variablen hierarchisch. Das globale Organisationstoken hinterlegen wir als Gruppenvariable, während wir die spezifischen Agenten-IDs den jeweiligen Hosts zuordnen.

Im folgenden Beispiel zeigt die Inventardatei eine saubere Zuweisung der individuellen Agenten-IDs für ein Web- und ein Datenbanksystem.

inventory.ini

# Host-spezifische Definitionen im Inventar
[servers]
web-prod-01 watchgrid_agent_id="agent_abc123"
db-prod-01  watchgrid_agent_id="agent_xyz456"

# Gemeinsame Variablen für alle überwachten Hosts
[servers:vars]
watchgrid_token="org_token_secure_value_here"

Schritt 2: Das idempotente Ansible-Playbook

Dieses Playbook ist vollkommen idempotent aufgebaut. Es ermittelt zunächst die CPU-Architektur (x86_64 vs. ARM64), um das passende Binärpaket zu beziehen. Anschließend legt es die Konfigurationsdatei an, installiert den Agenten in einer versionierten Datei mit Symlink und konfiguriert den systemd-Daemon.

deploy-watchgrid.yml

---
- name: WatchGrid Agent installieren und konfigurieren
  hosts: servers
  become: true
  vars:
    # Pfade und Konfigurationen definieren
    watchgrid_bin_dir: "/usr/local/bin"
    watchgrid_config_dir: "/etc/watchgrid"

  tasks:
    - name: Architektur des Zielsystems ermitteln
      ansible.builtin.set_fact:
        watchgrid_arch: "{{ 'amd64' if ansible_architecture in ['x86_64', 'amd64'] else 'arm64' if ansible_architecture in ['aarch64', 'arm64'] else 'arm' }}"

    - name: Konfigurationsverzeichnis erstellen
      ansible.builtin.file:
        path: "{{ watchgrid_config_dir }}"
        state: directory
        mode: '0755'
        owner: root
        group: root

    - name: Konfigurationsdatei agent.json erstellen
      ansible.builtin.copy:
        dest: "{{ watchgrid_config_dir }}/agent.json"
        content: |
          {
              "agent_id": "{{ watchgrid_agent_id }}",
              "token": "{{ watchgrid_token }}",
              "base_url": "https://wgri.de/api"
          }
        mode: '0600'
        owner: root
        group: root
      notify: Restart watchgrid

    - name: Aktuelle Versionsnummer abfragen
      ansible.builtin.uri:
        url: "https://wgri.de/packages/changelog/VERSION.txt"
        return_content: true
      register: watchgrid_version_response
      changed_when: false

    - name: Versionsnummer als Fact setzen
      ansible.builtin.set_fact:
        watchgrid_version: "{{ watchgrid_version_response.content | trim }}"

    - name: WatchGrid-Agent herunterladen
      ansible.builtin.get_url:
        url: "https://wgri.de/packages/linux/{{ watchgrid_arch }}/watchgrid"
        dest: "{{ watchgrid_bin_dir }}/watchgrid-{{ watchgrid_version }}"
        mode: '0755'
        owner: root
        group: root
      register: download_agent

    - name: Symlink auf die aktuelle Version setzen
      ansible.builtin.file:
        src: "{{ watchgrid_bin_dir }}/watchgrid-{{ watchgrid_version }}"
        dest: "{{ watchgrid_bin_dir }}/watchgrid"
        state: link
        force: true
      notify: Restart watchgrid

    - name: Systemd Service-Datei erstellen
      ansible.builtin.copy:
        dest: /etc/systemd/system/watchgrid.service
        content: |
          [Unit]
          Description=WatchGrid Agent
          After=network.target

          [Service]
          ExecStart={{ watchgrid_bin_dir }}/watchgrid
          Type=simple
          Restart=always
          RestartSec=10

          [Install]
          WantedBy=multi-user.target
        mode: '0644'
        owner: root
        group: root
      notify: Reload systemd

    - name: Veralteten Systemd-Timer entfernen
      ansible.builtin.file:
        path: /etc/systemd/system/watchgrid.timer
        state: absent
      notify: Reload systemd

    - name: WatchGrid-Service aktivieren und starten
      ansible.builtin.systemd:
        name: watchgrid.service
        state: started
        enabled: true

  handlers:
    - name: Reload systemd
      ansible.builtin.systemd:
        daemon_reload: true

    - name: Restart watchgrid
      ansible.builtin.systemd:
        name: watchgrid.service
        state: restarted

Schritt 3: Playbook ausführen und verifizieren

Führen Sie das Playbook von Ihrem Management-Host aus:

ansible-playbook -i inventory.ini deploy-watchgrid.yml

Nach dem erfolgreichen Durchlauf können Sie den Status des Agenten direkt auf einem der Zielserver prüfen. Der Agent meldet sich als standardmäßiger systemd-Dienst.

systemctl status watchgrid.service

Sobald der Dienst aktiv ist, baut er die gesicherte HTTPS-Verbindung auf und sendet die ersten Telemetriedaten. Auf Ihrem WatchGrid-Dashboard erscheinen die Systemauslastung, Festplattenkapazitäten und Systemd-Status-Metriken innerhalb von wenigen Sekunden.

Tipp: Schneller Ad-hoc-Befehl für Testzwecke

Falls Sie den Agenten ohne Erstellung eines Playbooks testweise auf mehreren Hosts ausrollen möchten, können Sie das offizielle Installationsskript auch über ein ad-hoc-Kommando ausführen lassen:

ansible servers -m shell -a "curl -sfL https://wgri.de/install | WG_AGENT={{ watchgrid_agent_id }} WG_TOKEN={{ watchgrid_token }} sh -"

Hinweis: Das native Ansible-Playbook ist für den Produktivbetrieb vorzuziehen, da es Idempotenz bietet und das manuelle Herunterladen von Skripten per Pipe umgeht.

Bereit für automatisiertes Monitoring?

Der kostenlose Tarif von WatchGrid erlaubt die Überwachung von bis zu drei Agenten mit unbegrenzten Alarmen. Richten Sie Ihre Testumgebung ein und testen Sie das Playbook direkt.

Kostenloses Konto erstellen Dokumentation lesen

Automatisierte Überwachung: WatchGrid-Agenten per Ansible verteilen.