Monitore

Was sind Monitore?

Monitore sind das Herzstück von UptimeEye: Mit ihnen prüfst du Verfügbarkeit und Performance deiner Websites, APIs und Services. Jeder Monitor besteht aus einem oder mehreren Schritten, die festlegen, was geprüft wird und wie das Ergebnis validiert wird.

Monitor-Typen

UptimeEye unterstützt diese Monitor-Typen:

• HTTP – Überwacht HTTP/HTTPS-Endpoints mit anpassbaren Requests und Validierung der Antwort
• DNS – Prüft DNS-Einträge und validiert ihre Werte
• ICMP – Pingt Server an, um ihre Erreichbarkeit und Antwortzeit zu prüfen
• TCP – Prüft, ob ein Port (host:port, z. B. eines Datenbank-, SSH- oder SMTP-Servers) Verbindungen annimmt, und wie schnell

Monitor erstellen

Monitore erstellst und bearbeitest du im Monitor-Builder. So legst du einen neuen Monitor an:

1. Öffne Monitore in der Seitenleiste und klick auf „Neuer Monitor“
2. Gib die URL oder den Host ein, der geprüft werden soll. Der Chip Schritt darunter legt den Typ fest (HTTP(s), DNS, Ping oder TCP-Port) und bei HTTP die Methode. Der Name ist optional: Bleibt er leer, wird der Monitor nach seiner Domain benannt
3. Klick auf „Test“. Die Live-Antwort zeigt Statuscode, Antwortzeit, SSL-Zertifikat, Headers und Body. Klick auf einen Wert darin, um ihn als Assertion hinzuzufügen
4. Füge unter Gilt als online, wenn die Assertions hinzu oder bearbeite sie. Die Schnell-Assertions fügen gängige hinzu (Status 2xx, Body enthält…, Antwortzeit < 10 s, SSL > 14 Tage, DNS-Eintrag enthält…). Ohne Assertions gilt der Monitor als online, sobald irgendeine Antwort ankommt
5. Leg Zeitplan und Alerts mit den Chips unter der URL fest: alle (Check-Intervall), von (Regionen und wie viele davon ausfallen müssen, bevor ein Alert kommt), Alert an (Benachrichtigungskanal und wie viele Fehler in Folge vor einem Alert) und Tags
6. Klick auf „Monitoring starten“. Der erste Check startet nach etwa 30 Sekunden

Für mehrere Requests hintereinander, oder um Werte aus einer Antwort an den nächsten Request weiterzugeben, klickst du auf Zum mehrstufigen Modus wechseln. Dort ist jeder Schritt eine Karte mit eigener URL, eigenen Headers, eigenem Body, eigenen Assertions und Variablen (siehe Monitor-Schritte). „Schritt hinzufügen“ fügt einen Schritt hinzu, per Drag-and-drop änderst du die Reihenfolge, und „Alle Schritte testen“ führt sie der Reihe nach mit den extrahierten Variablen aus. Die Karte Monitor-Einstellungen unter den Schritten enthält Benachrichtigungskanal, Check-Intervall, Regionen und Tags; Erweitert (Timeout, Schwellenwerte) darin enthält den Timeout, beide Schwellenwerte und „Weiterleitungen folgen“. Klick auf „Monitor erstellen“, um zu speichern.

Um einen Monitor später zu ändern, öffnest du seinen Tab Einstellungen: Das ist derselbe Builder, gespeichert wird mit „Monitor speichern“.

Monitor-Optionen

Beim Erstellen oder Bearbeiten eines Monitors kannst du diese Optionen einstellen:

• Check-Intervall – Die Zeit zwischen zwei Checks des Monitors (30s, 1m, 2m, 3m, 5m, 10m, 30m, 6h, 12h oder 24h). Das kürzeste Intervall hängt von deinem Plan ab: 5 Minuten bei Free, 30 Sekunden bei Pro und Agentur.
• Timeout – Wie lange auf eine Antwort gewartet wird, bevor der Check als fehlgeschlagen gilt, in Sekunden. Die App bietet 5–60 Sekunden (Standard 15); API und Terraform akzeptieren jeden Wert ab 5 Sekunden.
• Weiterleitungen folgen – Ob der Monitor HTTP-Weiterleitungen automatisch folgt (standardmäßig an)
• Fehler-Schwellenwert – Wie viele Fehler in Folge nötig sind, bis ein Monitor als offline gilt (Standard 2). Die App bietet 1–5, API und Terraform akzeptieren 1–10.
• Regionen-Schwellenwert – Wie viele Regionen einen Fehler melden müssen, bevor ein Alert ausgelöst wird (Standard 1). Die App bietet 1 bis zur Zahl der ausgewählten Regionen, API und Terraform akzeptieren 1–10.
• Regionen – Aus welchen Regionen geprüft wird (siehe Regionen). Wie viele ein Monitor nutzen kann, ist ein Limit des Plans: 1 bei Free, 3 bei Pro, 6 bei Agentur. Die IP-Adressen der Probes für Firewall-Allowlists stehen auf der Seite Vertrauen & Sicherheit.

Die Zahl der Schritte pro Monitor ist ein Limit des Plans: 5 bei Free, 10 bei Pro, 20 bei Agentur. Im mehrstufigen Modus importiert „cURL einfügen…“ in einem HTTP-Schritt Methode, URL, Headers und Body eines cURL-Befehls.

Regionen

Monitore prüfen aus diesen Regionen. Die App zeigt den Namen; API, Terraform und MCP nutzen die ID, wie GET /v1/locations sie auflistet. Neue Monitore starten in der App mit Europa (Deutschland).

Was sind Monitor-Schritte?

Schritte sind die einzelnen Abfragen, die ein Monitor ausführt. Jeder Schritt kann eigene Einstellungen, Assertions und extrahierte Variablen haben. Die Schritte laufen nacheinander, und Variablen, die ein Schritt extrahiert, kannst du in den folgenden Schritten verwenden.

Schritte konfigurieren

Jeden Schritt konfigurierst du im Monitor-Builder; im mehrstufigen Modus ist jeder Schritt eine Karte mit diesen Teilen:

• Typ und Ziel – HTTP(s), DNS, Ping (ICMP) oder TCP-Port und die URL oder der Host, der geprüft wird. Klick auf den Namen des Schritts, um ihn umzubenennen
• Headers und Body – Die Request-Details eines HTTP-Schritts: Methode, Headers und ein Body für POST und PUT
• Assertions – Die Bedingungen, die die Antwort validieren. Teste den Schritt und klick auf einen Wert in der Live-Antwort, oder nutze die Schnell-Assertions
• Variablen für spätere Schritte – Werte aus der Antwort, die die Schritte danach verwenden können

Assertions

Mit Assertions validierst du die Antwort des überwachten Endpoints; so heißen sie auch im Monitor-Builder. Je nach Monitor-Typ gibt es unterschiedliche Arten von Assertions:

HTTP-Assertions

• Statuscode – Prüft, ob der Statuscode einem bestimmten Wert entspricht oder nicht
• Antwortzeit – Prüft, ob die Antwortzeit unter einem bestimmten Wert liegt
• Body – Prüft, ob der Body der Antwort einen bestimmten Wert enthält, nicht enthält, ihm entspricht oder nicht entspricht
• Body-JSON-Pfad – Prüft, ob ein bestimmter JSON-Pfad im Body der Antwort bestimmte Kriterien erfüllt
• Header – Prüft, ob ein bestimmter Header einen bestimmten Wert enthält, nicht enthält, ihm entspricht oder nicht entspricht
• SSL-Zertifikat – Validiert Eigenschaften des SSL-Zertifikats:
  • Aussteller – Name des Ausstellers (Issuer) des Zertifikats
  • Inhaber – Name des Inhabers (Subject) des Zertifikats
  • Läuft ab in – Tage bis zum Ablauf des Zertifikats (z. B. Alert, wenn es weniger als 30 Tage sind)
  • DNS-Namen – Die Subject Alternative Names (SANs) des Zertifikats

DNS-Assertions

• DNS-Eintrag – Prüft, ob ein bestimmter DNS-Eintrag (A, AAAA, MX usw.) einen bestimmten Wert enthält, nicht enthält, ihm entspricht oder nicht entspricht

ICMP-Assertions

• Antwortzeit – Prüft, ob die Antwortzeit des Pings unter einem bestimmten Wert liegt

TCP-Assertions

Ein TCP-Schritt schlägt fehl, wenn der Port die Verbindung ablehnt oder sie nicht innerhalb des Timeouts annimmt. Private, Loopback- und Link-Local-Adressen lassen sich nicht prüfen.

• Antwortzeit – Prüft, ob die Verbindungszeit unter einem bestimmten Wert liegt

Globale Variablen

Mit globalen Variablen erzeugt UptimeEye dynamische Werte in deinen Requests. Du kannst sie in URLs, Headers, Bodys und Assertions verwenden.

Die Syntax folgt dem Muster: {{ variable(args) }}

Verfügbare globale Variablen:

Diese dynamischen Variablen sind besonders nützlich für Lasttests, um eindeutige Nutzer oder Sessions zu simulieren und um Caching-Effekte zu vermeiden.

Beispiel in einem Request-Body:

{
  "email": "user+{{ numeric 5 }}@example.com",
  "password": "{{ alphanumeric 12 }}"
}

Variablen extrahieren

Mit Variablen übernimmst du Werte aus der Antwort eines Schritts in die folgenden Schritte. Das ist nützlich, wenn du zum Beispiel ein Authentifizierungs-Token aus der Antwort eines Logins extrahierst und es in den folgenden API-Aufrufen verwendest. Im Monitor-Builder testest du einen Schritt, klickst in der Live-Antwort auf einen Wert aus Body oder Header und wählst „Als Variable extrahieren“; der Schritt listet die Variable unter Variablen für spätere Schritte.

Du kannst Variablen extrahieren aus:

• Body der Antwort – Den gesamten Body oder einen bestimmten JSON-Pfad extrahieren
• Headers – Den Wert eines bestimmten Headers extrahieren
• Statuscode – Den Statuscode als Variable extrahieren

Um eine Variable in einem folgenden Schritt zu verwenden, schreib {{variableName}} in URL, Headers oder Body des Schritts.

Was sind geheime Variablen?

In geheimen Variablen speicherst du sensible Informationen wie API-Keys, Passwörter oder Tokens sicher in UptimeEye. Du kannst sie dann in deinen Monitoren verwenden, ohne dass die eigentlichen Werte in der UI oder in Logs sichtbar werden.

Geheime Variablen erstellen

So erstellst du eine neue geheime Variable:

1. Öffne Variablen in der Seitenleiste
2. Klick auf „Neue Variable“
3. Gib einen Schlüssel (Namen) für deine Variable ein
4. Gib den Wert ein, den du speichern willst
5. Aktiviere die Checkbox „Geheim“, um die Variable als geheim zu markieren
6. Klick auf „Variable erstellen“, um zu speichern

Geheime Variablen in Monitoren verwenden

Um eine geheime Variable in einem Schritt zu verwenden, schreib {{variableName}} in URL, Headers oder Body des Schritts. UptimeEye ersetzt diesen Platzhalter beim Check automatisch durch den echten Wert.

So verwendest du sensible Informationen in deinen Monitoren, ohne sie in der UI oder in Logs offenzulegen. Geheime Variablen eignen sich zum Beispiel für:

• API-Keys in Request-Headers
• Passwörter in Requests zur Authentifizierung
• Tokens in Request-Parametern
• Sensible Daten in Request-Bodys

Verwandte Seiten