Faire votre propre serveur Luanti avec monitoring

Objectifs pédagogiques

Comprendre la différence entre build-time et run-time
Comprendre ce que fait réellement un Dockerfile généré par une IA
Savoir intégrer une application dans une stack observable
Être capable d’expliquer sa stack à l’oral

L’objectif de ce TP est de construire une stack Docker complète autour d’un serveur Luanti : - serveur de jeu compilé avec support Prometheus, - monitoring Prometheus + Grafana, - landing page web servant de point d’entrée.

Ce que vous devez livrer

Un repository Git contenant :

Dockerfile
compile Luanti avec le support Prometheus activé
embarque un game à choisir en amont
docker-compose.yml
Luanti + Prometheus + Grafana + Nginx
minetest/minetest.conf
prometheus/prometheus.yml
grafana/provisioning/datasources/datasource.yml
grafana/provisioning/dashboards/dashboards.yml
grafana/dashboards/luanti-minimal.json (à faire générer)
web/index.html (landing page générée par une IA)

Rendu attendu

Lien vers le repository Git contenant tous les fichiers demandés.
Captures d’écran ou extraits montrant :
docker compose ps avec les 4 services en UP.
Prometheus avec la cible luanti en état UP (Targets) et une requête up{job="luanti"}.
Grafana affichant votre dashboard « luanti » avec au moins up{job="luanti"} et scrape_duration_seconds.
La landing page Nginx accessible sur http://localhost:8080.

Contraintes techniques

Luanti doit écouter en UDP 30000
Luanti doit exposer des métriques Prometheus sur /metrics
Prometheus doit scrapper ces métriques
Grafana doit être automatiquement configuré (datasource + dashboard)
La landing page doit être accessible via Nginx (HTTP 8080)

Tableau des ports et services

Service	Protocole/Port	Publication hôte	Accès attendu
Luanti jeu	UDP/30000	Oui (`30000/udp`)	Joueurs (client Luanti)
Luanti métriques	TCP/30000	Non	Prometheus via réseau Docker
Prometheus	TCP/9090	Oui (`9090`)	Navigateur: http://localhost:9090
Grafana	TCP/3000	Oui (`3000`)	Navigateur: http://localhost:3000
Landing Nginx	TCP/8080	Oui (`8080`)	Navigateur: http://localhost:8080

Attention - Les identifiants admin/admin pour Grafana ne conviennent qu’en développement.

Arborescence attendue

luanti-stack/
  docker-compose.yml
  Dockerfile
  minetest/
    minetest.conf
  prometheus/
    prometheus.yml
  grafana/
    dashboards/
      luanti-minimal.json
    provisioning/
      datasources/
        datasource.yml
      dashboards/
        dashboards.yml
  web/
    index.html

1) Dockerfile : compilation de Luanti avec Prometheus

Vous devez écrire vous-même le Dockerfile, en vous aidant d’une IA de votre choix.

Objectif

Construire une image Docker qui :

Clone le dépôt Luanti
Compile Luanti avec le support Prometheus activé
Installe le binaire luantiserver
Embarque un game dans l’image
Lance le serveur Luanti au démarrage du conteneur

Contraintes imposées

La compilation doit activer explicitement Prometheus :

-DENABLE_PROMETHEUS=1

* Le game doit être présent dans :

/var/lib/minetest/games/<gameid>/

* Le serveur doit être lancé avec :

un fichier de configuration
un gameid
un worldname

Commande de lancement attendue

CMD ["luantiserver", "--config", "/etc/minetest/minetest.conf", "--gameid", "<votre_gameid>", "--worldname", "world"]

Le support Prometheus ne peut pas être activé au runtime via une variable d’environnement. Il doit être présent au moment de la compilation du binaire Luanti.

Questions

Vous devez être capables d’expliquer :

pourquoi une compilation est nécessaire
à quoi sert ENABLE_PROMETHEUS
pourquoi une IA est capable d’écrire ce Dockerfile, mais pourquoi vous devez le comprendre

2) Configuration Luanti (`minetest.conf`)

# Server identity
server_name = Lorem Ipsum
server_description = Serveur Luanti dockerisé + monitoring
motd = Bienvenue ! Lisez la landing page sur http://localhost:8080

# Gameplay network
port = 30000

# Prometheus metrics listener (HTTP)
prometheus_listener_address = 0.0.0.0:30000

3) docker-compose.yml

Le port UDP 30000 est exposé à l’hôte pour les joueurs
Le port TCP des métriques n’est pas publié
Prometheus accède aux métriques via le réseau Docker

services:
  luanti:
    build:
      context: .
    container_name: luanti
    restart: unless-stopped
    ports:
      - "30000:30000/udp"
    expose:
      - "30000"
    volumes:
      - ./minetest/minetest.conf:/etc/minetest/minetest.conf:ro
      - luanti_data:/var/lib/minetest
    networks:
      - backend

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
    ports:
      - "9090:9090"
    networks:
      - backend
    depends_on:
      - luanti

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - ./grafana/provisioning:/etc/grafana/provisioning:ro
      - ./grafana/dashboards:/var/lib/grafana/dashboards:ro
    ports:
      - "3000:3000"
    networks:
      - backend
    depends_on:
      - prometheus

  web:
    image: nginx:alpine
    container_name: landing
    volumes:
      - ./web/index.html:/usr/share/nginx/html/index.html:ro
    ports:
      - "8080:80"
    networks:
      - backend

networks:
  backend:

volumes:
  luanti_data:

4) Prometheus : configuration de scrape

global:
  scrape_interval: 5s

scrape_configs:
  - job_name: "luanti"
    metrics_path: "/metrics"
    static_configs:
      - targets: ["luanti:30000"]

Quelle URL Prometheus appelle-t-il exactement ?
Pourquoi luanti:30000 fonctionne sans IP ?
À quoi sert scrape_interval ?

5) Grafana : provisioning automatique

Datasource

apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true

Provisioning des dashboards

apiVersion: 1

providers:
  - name: default
    orgId: 1
    type: file
    options:
      path: /var/lib/grafana/dashboards

Dashboard minimal

Un dashboard Grafana doit être automatiquement chargé et afficher au minimum :

le statut du scrape (up{job="luanti"})
la durée de scrape (scrape_duration_seconds)

Toutes les autres données que vous trouvez intéressantes.

6) Landing page

Vous devez créer une landing page à l’aide d’une IA de votre choix.

Contraintes

Framework CSS libre
Doit afficher :
IP / hostname
Port UDP
Nom du serveur
Nom et description du game
Un bloc How to join en 3 étapes
Liens vers :
Grafana (http://localhost:3000)
Prometheus (http://localhost:9090)
Au moins une image générée par IA

Conclusion

Vous avez construit une stack observable (Luanti + Prometheus + Grafana + Nginx).
Vous avez appliqué la distinction build-time/run-time et automatisé le provisioning Grafana.
Vous savez exposer des services aux bons ports et limiter l’exposition des métriques.