agence66-uptime-kuma/README.md

# Uptime Kuma - Monitoring Service

Déploiement sécurisé d'Uptime Kuma avec Docker Compose et Traefik.

## Description

[Uptime Kuma](https://github.com/louislam/uptime-kuma) est un outil de monitoring open-source self-hosted. Il permet de surveiller la disponibilité de vos sites web, API, serveurs et services.

Cette configuration utilise :
- Image Docker **rootless** pour une sécurité renforcée
- Reverse proxy **Traefik** avec HTTPS automatique (Let's Encrypt)
- Headers de sécurité HTTP
- Limites de ressources et healthchecks

## Fonctionnalités

- Surveillance de sites web (HTTP/HTTPS)
- Monitoring de ports TCP
- Ping de serveurs
- Surveillance de certificats SSL
- Notifications multi-canaux (Email, Slack, Discord, Telegram, etc.)
- Tableau de bord temps réel
- Historique de disponibilité
- Status pages publiques

## Prérequis

- Docker et Docker Compose installés
- Un réseau Traefik externe nommé `traefik-net`
- Traefik configuré avec le resolver Let's Encrypt nommé `letsencrypt`
- Un nom de domaine pointant vers votre serveur

### Vérifier le réseau Traefik

```bash
docker network ls | grep traefik-net
```

Si le réseau n'existe pas :

```bash
docker network create traefik-net
```

## Installation

### 1. Cloner ou créer le projet

```bash
git clone <votre-repo>
cd agence66-uptime-kuma
```

### 2. Configurer les variables d'environnement

```bash
cp .env.example .env
nano .env
```

Définissez votre domaine :

```env
DOMAIN=uptime.votredomaine.com
```

### 3. Créer le répertoire de données

```bash
mkdir -p data
chmod 755 data
```

### 4. Démarrer le service

```bash
docker compose up -d
```

### 5. Vérifier le déploiement

```bash
docker compose ps
docker compose logs -f
```

Accédez à `https://uptime.votredomaine.com` pour configurer votre compte administrateur.

## Configuration

### Variables d'environnement

| Variable | Description | Exemple |
|----------|-------------|---------|
| `DOMAIN` | Nom de domaine pour accéder à Uptime Kuma | `uptime.example.com` |

### Premier démarrage

Lors du premier accès, Uptime Kuma vous demandera de créer un compte administrateur :

1. Définissez un nom d'utilisateur
2. Choisissez un **mot de passe fort** (minimum 12 caractères)
3. Configurez vos notifications

## Sécurité

Cette configuration implémente plusieurs couches de sécurité :

### Docker Security

- **Image rootless** : Le container ne s'exécute pas en tant que root
- **no-new-privileges** : Empêche l'escalade de privilèges
- **Capabilities dropped** : Toutes les capacités kernel sont supprimées
- **Version fixée** : `2.0.2-rootless` (pas de mises à jour automatiques non contrôlées)

### Limites de ressources

```yaml
CPU : 0.5 core maximum (0.25 réservé)
RAM : 512M maximum (256M réservé)
```

### Headers HTTP de sécurité

- **X-Frame-Options** : `SAMEORIGIN` (protection contre clickjacking)
- **X-Content-Type-Options** : `nosniff` (protection contre MIME sniffing)
- **X-XSS-Protection** : Activé (filtre XSS du navigateur)
- **Referrer-Policy** : `strict-origin-when-cross-origin`

### HTTPS / TLS

- Certificats SSL automatiques via Let's Encrypt
- Renouvellement automatique
- Redirection HTTP → HTTPS gérée par Traefik

### Healthcheck

Le container vérifie automatiquement sa santé toutes les 30 secondes :

```bash
# Voir le statut de santé
docker inspect uptime-kuma | grep -A 10 Health
```

## Maintenance

### Sauvegardes

Les données sont stockées dans `./data`. Sauvegardez régulièrement ce répertoire :

```bash
# Backup manuel
tar -czf uptime-kuma-backup-$(date +%Y%m%d).tar.gz data/

# Ou avec docker compose arrêté (recommandé)
docker compose down
tar -czf uptime-kuma-backup-$(date +%Y%m%d).tar.gz data/
docker compose up -d
```

### Restauration

```bash
docker compose down
tar -xzf uptime-kuma-backup-YYYYMMDD.tar.gz
docker compose up -d
```

### Mise à jour

1. Vérifiez les [releases](https://github.com/louislam/uptime-kuma/releases)
2. Modifiez la version dans `docker-compose.yml`
3. Mettez à jour :

```bash
docker compose pull
docker compose up -d
```

### Logs

```bash
# Voir les logs en temps réel
docker compose logs -f

# Logs des 100 dernières lignes
docker compose logs --tail=100

# Les logs sont automatiquement limités (10M max, 3 fichiers)
```

### Redémarrage

```bash
docker compose restart
```

### Arrêt

```bash
docker compose down
```

## Surveillance des ressources

```bash
# Utilisation CPU/RAM
docker stats uptime-kuma

# Espace disque utilisé
du -sh data/
```

## Troubleshooting

### Le container ne démarre pas

```bash
# Vérifier les logs
docker compose logs

# Vérifier les permissions
ls -la data/
```

### Erreur "network traefik-net not found"

```bash
docker network create traefik-net
docker compose up -d
```

### Erreur de certificat SSL

Vérifiez que :
- Votre domaine pointe bien vers le serveur
- Traefik est configuré avec Let's Encrypt
- Le port 443 est ouvert

### Problèmes de permissions

```bash
# Si problème avec le répertoire data
chmod 755 data
docker compose restart
```

### Le healthcheck échoue

```bash
# Vérifier si curl est disponible dans le container
docker exec uptime-kuma curl -f http://localhost:3001 || echo "Healthcheck failed"

# Si curl n'est pas disponible, modifier le healthcheck dans docker-compose.yml
```

## Commandes utiles

```bash
# Accéder au shell du container
docker exec -it uptime-kuma sh

# Voir la configuration Traefik détectée
docker inspect uptime-kuma | grep -A 20 Labels

# Tester la connectivité
curl -I https://uptime.votredomaine.com
```

## Architecture

```
Internet
   ↓
Traefik (HTTPS/Let's Encrypt)
   ↓
Uptime Kuma Container (rootless)
   ↓
./data (persistance)
```

## Ressources

- [Documentation Uptime Kuma](https://github.com/louislam/uptime-kuma/wiki)
- [Uptime Kuma GitHub](https://github.com/louislam/uptime-kuma)
- [Documentation Traefik](https://doc.traefik.io/traefik/)
- [Let's Encrypt](https://letsencrypt.org/)

## Support

Pour signaler un bug ou demander une fonctionnalité :
- Issues Uptime Kuma : https://github.com/louislam/uptime-kuma/issues

## Licence

Ce projet de configuration est libre d'utilisation. Uptime Kuma est sous licence MIT.