Einfaches Monitoring für Server, Anwendungen und Skripte
Aufgesetzt in unter 3 Minuten, damit Sie sich auf Ihr Business und nicht auf Ausfälle konzentrieren können.
Funktionen
Server, APIs und Cron überwachen. Alerts per Mail, SMS oder Telegram.
Überwachung
Server
Docker Agent mit minütlichen Metriken
Anwendungen
Healthcheck jede Minute von außen
Cron und Skripte
Ping URL nach jedem Skriptlauf
Benachrichtigungen
Mail bei jedem Statuswechsel
SMS
SMS bei Ausfall oder kritisch
Telegram
Nachricht an Bot oder Gruppe
An alles gedacht
Provisionierung mit IaC
Ziele per Terraform oder Ansible
App für unterwegs
Status auch auf dem Handy
Teams und Rollen
Mehrere Nutzer pro Projekt
Infrastructure as Code ist für uns kein Fremdwort sondern Praxis
Applikation und Server legen Sie im gleichen Stack wie Ihr Deployment an – mit Terraform, Pulumi oder Ansible.
Terraform
Eine Applikation und ein Server als Ressourcen im selben Modul – reproduzierbar in jeder Umgebung.
Pulumi
Typisierte SDKs: Applikation und Server als Code in TypeScript, Python oder Go.
Ansible
Playbooks für Applikation und Server-Agent – idempotent und gut für bestehende Hosts.
resource "simple_monitoring_project" "production" {
name = "production"
}
resource "simple_monitoring_application" "checkout_api" {
project_id = simple_monitoring_project.production.id
name = "checkout-api"
health_url = "https://api.example.com/health"
}
resource "simple_monitoring_server" "api_prod" {
project_id = simple_monitoring_project.production.id
name = "api-prod-01"
register_key = "sm_server_xxx"
}import * as sm from "@doppelt-digital/simple-monitoring";
const production = new sm.Project("production", {
name: "production",
});
new sm.Application("checkout-api", {
projectId: production.id,
healthUrl: "https://api.example.com/health",
});
new sm.Server("api-prod-01", {
projectId: production.id,
registerKey: "sm_server_xxx",
});---
- name: Simple Monitoring targets
hosts: localhost
vars:
sm_project: production
register_key: "sm_server_xxx"
tasks:
- name: Register checkout-api application
doppelt_digital.simple_monitoring.application:
project: "{{ sm_project }}"
name: checkout-api
health_url: https://api.example.com/health
- name: Install server agent on api-prod-01
doppelt_digital.simple_monitoring.server:
project: "{{ sm_project }}"
name: api-prod-01
register_key: "{{ register_key }}"
docker_sock_mount: /var/run/docker.sockEinfache Preise
Server-Monitoring kostenlos testen: 1 Server, 3 Apps. Team ab 10 €, Business ab 29 €, Enterprise auf Anfrage.
Free
Kostenlos
- 1 Server
- 3 Applikationen
- 3 Cronjobs
Team
10 € pro Monat
- 3 Server
- 20 Applikationen
- 20 Cronjobs
Business
29 € pro Monat
- 10 Server
- 100 Applikationen
- 100 Cronjobs
Enterprise
Individuell
- Server nach Ihrem Bedarf
- Limits passend zum Vertrag
- Cronjobs nach Vertrag
Applikation einbinden
HTTP-Healthcheck für NestJS, Express, FastAPI, Symfony oder Gin – ein GET-Endpoint, Simple Monitoring prüft die Uptime jede Minute.
NestJS
Ein schlanker Health-Controller reicht – Simple Monitoring prüft die Route jede Minute per HTTP.
Express
Eine Health-Route in Express reicht – Simple Monitoring ruft sie jede Minute per GET ab.
FastAPI
Ein Endpoint in FastAPI – ideal für moderne Python-APIs mit klarem JSON-Response.
Symfony
Mit einem dedizierten Controller bleibt der Healthcheck von Ihrer Geschäftslogik getrennt.
Gin
Ein Health-Handler in Gin – Simple Monitoring prüft die Route jede Minute per GET.
import { Controller, Get } from '@nestjs/common';
@Controller()
export class HealthController {
@Get('health')
health() {
return {
status: 'ok',
timestamp: new Date().toISOString(),
};
}
}import express from 'express';
const app = express();
app.get('/health', (_req, res) => {
res.status(200).json({
status: 'ok',
timestamp: new Date().toISOString(),
});
});from datetime import datetime, timezone
from fastapi import FastAPI
app = FastAPI()
@app.get('/health')
def health():
return {
'status': 'ok',
'timestamp': datetime.now(timezone.utc).isoformat(),
}<?php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;
final class HealthController extends AbstractController
{
#[Route('/health', name: 'health', methods: ['GET'])]
public function __invoke(): JsonResponse
{
return $this->json([
'status' => 'ok',
'timestamp' => (new \DateTimeImmutable())->format(\DateTimeInterface::ATOM),
]);
}
}package main
import (
"net/http"
"time"
"github.com/gin-gonic/gin"
)
func main() {
r := gin.New()
r.GET("/health", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"status": "ok",
"timestamp": time.Now().UTC().Format(time.RFC3339),
})
})
r.Run()
}Server-Agent einrichten
Server-Monitoring mit Docker-Agent: Register Key aus dem Portal, Docker Socket Mount, Healthchecks und Metriken.
Docker (CLI)
Ein Container per docker run – Register Key, Backend-URL und Mount des Docker Sockets.
Docker Compose
Wiederholbare Setups – Register Key, Backend-URL und Docker Socket als Volume.
Kubernetes
Deployment im Cluster mit Docker-Socket-Mount – Registrierung per Register Key.
docker run -d \
--name simple-monitoring-agent \
-v /var/run/docker.sock:/var/run/docker.sock \
-e REGISTER_KEY="sm_server_xxx" \
-e BACKEND_URL="https://api.example.com" \
registry.example/simple-monitoring-agent:placeholderservices:
simple-monitoring-agent:
image: registry.example/simple-monitoring-agent:placeholder
volumes:
- /var/run/docker.sock:/var/run/docker.sock
environment:
REGISTER_KEY: "sm_server_xxx"
BACKEND_URL: "https://api.example.com"
restart: unless-stoppedapiVersion: apps/v1
kind: Deployment
metadata:
name: simple-monitoring-agent
spec:
replicas: 1
selector:
matchLabels:
app: simple-monitoring-agent
template:
metadata:
labels:
app: simple-monitoring-agent
spec:
containers:
- name: agent
image: registry.example/simple-monitoring-agent:placeholder
env:
- name: REGISTER_KEY
value: "sm_server_xxx"
- name: BACKEND_URL
value: "https://api.example.com"
volumeMounts:
- name: docker-sock
mountPath: /var/run/docker.sock
volumes:
- name: docker-sock
hostPath:
path: /var/run/docker.sock
type: SocketCron-Jobs & Skripte
Cron-Job-Monitoring per Ping-URL: Skripte und Crontab-Einträge melden jeden erfolgreichen Lauf – ohne Ping gibt es einen Alert.
Crontab
Am Ende des Cron-Eintrags einmal curl auf die Ping-URL aus dem Web-Portal – kein Agent nötig.
GET /api/heartbeat/<token> · Prüfung jede Minute
Bash-Skript
Backup, Reports oder Deploy-Skripte rufen am Ende dieselbe Ping-URL auf – auch ohne Crontab.
GET /api/heartbeat/<token> · Prüfung jede Minute
systemd
Timer und Oneshot-Service: Aufgabe ausführen, danach per ExecStartPost den Ping senden.
GET /api/heartbeat/<token> · Prüfung jede Minute
# Ping-URL aus dem Web-Portal (z. B. alle 5 Min.)
*/5 * * * * curl -fsS "https://api.example.com/api/heartbeat/<token-from-portal>"#!/usr/bin/env bash
set -euo pipefail
# … Backup oder Report ausführen
tar -czf /var/backups/app.tgz /data/app
# Ping nach erfolgreichem Lauf
curl -fsS "https://api.example.com/api/heartbeat/<token-from-portal>"# /etc/systemd/system/nightly-backup.timer
[Unit]
Description=Backup und Ping an Simple Monitoring
[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true
[Install]
WantedBy=timers.target
# /etc/systemd/system/nightly-backup.service
[Unit]
Description=Nächtliches Backup
[Service]
Type=oneshot
ExecStart=/usr/local/bin/nightly-backup.sh
ExecStartPost=/usr/bin/curl -fsS https://api.example.com/api/heartbeat/<token-from-portal>Überwache jetzt alles
Aufgesetzt in unter 3 Minuten, damit Sie sich auf Ihr Business und nicht auf Ausfälle konzentrieren können.