771 lines
21 KiB
Markdown
771 lines
21 KiB
Markdown
# 🧪 Fake Log Generator for Loki
|
||
|
||
Ce projet génère de faux logs réalistes dans plusieurs formats (`apache`, `json`, `ltsv`, `custom`) et les envoie à Grafana Loki via Promtail.
|
||
|
||
## 🔧 Démarrage rapide
|
||
|
||
```bash
|
||
docker compose up -d
|
||
./fake_logs.sh 0 json --loop >> logs/access.log
|
||
```
|
||
|
||
## 🔗 Accès
|
||
|
||
- Grafana : http://localhost:3000 (admin / admin)
|
||
- Loki : http://localhost:3100
|
||
|
||
## 🔍 Requête exemple (Grafana Explore)
|
||
|
||
```logql
|
||
{job="fake_logs"}
|
||
```
|
||
|
||
## 📦 Contenu
|
||
|
||
- `fake_logs.sh` : générateur de logs
|
||
- `promtail-config.yml` : config pour envoyer vers Loki
|
||
- `docker-compose.yml` : stack Loki + Promtail + Grafana
|
||
|
||
|
||
|
||
FROM AI
|
||
Exemple de script Bash : fake_logs.sh
|
||
#!/bin/bash
|
||
|
||
# Nombre de lignes de log à générer (par défaut : 100)
|
||
LINES=${1:-100}
|
||
|
||
# Listes de données factices
|
||
METHODS=("GET" "POST" "PUT" "DELETE" "PATCH")
|
||
PATHS=("/" "/login" "/dashboard" "/api/data" "/settings" "/products" "/checkout")
|
||
CODES=(200 201 204 301 302 400 401 403 404 500 503)
|
||
AGENTS=(
|
||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
|
||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
|
||
"curl/7.68.0"
|
||
"PostmanRuntime/7.29.0"
|
||
"Mozilla/5.0 (iPhone; CPU iPhone OS 13_5_1 like Mac OS X)"
|
||
)
|
||
|
||
# Fonction pour générer une IP aléatoire
|
||
random_ip() {
|
||
echo "$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256))"
|
||
}
|
||
|
||
# Fonction pour générer une date au format Apache
|
||
random_date() {
|
||
date -d "$((RANDOM % 30 + 1)) days ago" "+%d/%b/%Y:%H:%M:%S %z"
|
||
}
|
||
|
||
# Boucle de génération de log
|
||
for ((i=0; i<LINES; i++)); do
|
||
IP=$(random_ip)
|
||
DATE=$(random_date)
|
||
METHOD=${METHODS[$RANDOM % ${#METHODS[@]}]}
|
||
PATH=${PATHS[$RANDOM % ${#PATHS[@]}]}
|
||
CODE=${CODES[$RANDOM % ${#CODES[@]}]}
|
||
SIZE=$((RANDOM % 5000 + 200))
|
||
AGENT=${AGENTS[$RANDOM % ${#AGENTS[@]}]}
|
||
|
||
echo "$IP - - [$DATE] \"$METHOD $PATH HTTP/1.1\" $CODE $SIZE \"$AGENT\""
|
||
done
|
||
🔧 Utilisation
|
||
Rends le script exécutable :
|
||
chmod +x fake_logs.sh
|
||
Exécute-le :
|
||
./fake_logs.sh 500 > access.log
|
||
(Cela générera 500 lignes de logs dans un fichier access.log)
|
||
🔄 Exemple de sortie :
|
||
92.123.44.222 - - [15/May/2025:14:23:01 +0000] "GET /api/data HTTP/1.1" 200 3412 "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
|
||
14.56.222.1 - - [10/May/2025:18:43:51 +0000] "POST /login HTTP/1.1" 401 834 "curl/7.68.0"
|
||
Souhaites-tu qu’on ajoute la prise en charge de plusieurs formats de log (JSON, Apache, LTSV, etc.) comme le fait flog ?
|
||
|
||
|
||
Vous avez dit :
|
||
oui
|
||
ChatGPT a dit :
|
||
Parfait ! Voici une version étendue du script Bash fake_logs.sh qui permet de générer des logs en plusieurs formats comme le fait mingrammer/flog : apache, json, ltsv, ou custom.
|
||
|
||
✅ Script Bash : fake_logs.sh (multi-formats)
|
||
|
||
#!/bin/bash
|
||
|
||
# Nombre de lignes à générer
|
||
LINES=${1:-100}
|
||
FORMAT=${2:-apache} # apache | json | ltsv | custom
|
||
|
||
METHODS=("GET" "POST" "PUT" "DELETE" "PATCH")
|
||
PATHS=("/" "/login" "/dashboard" "/api/data" "/settings" "/products" "/checkout")
|
||
CODES=(200 201 204 301 302 400 401 403 404 500 503)
|
||
AGENTS=(
|
||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
|
||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
|
||
"curl/7.68.0"
|
||
"PostmanRuntime/7.29.0"
|
||
"Mozilla/5.0 (iPhone; CPU iPhone OS 13_5_1 like Mac OS X)"
|
||
)
|
||
|
||
random_ip() {
|
||
echo "$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256))"
|
||
}
|
||
|
||
random_date() {
|
||
date -d "$((RANDOM % 30 + 1)) days ago" "+%d/%b/%Y:%H:%M:%S %z"
|
||
}
|
||
|
||
iso_date() {
|
||
date -d "$((RANDOM % 30 + 1)) days ago" --iso-8601=seconds
|
||
}
|
||
|
||
# Fonction principale de génération de logs
|
||
generate_log() {
|
||
IP=$(random_ip)
|
||
DATE=$(random_date)
|
||
ISO_DATE=$(iso_date)
|
||
METHOD=${METHODS[$RANDOM % ${#METHODS[@]}]}
|
||
PATH=${PATHS[$RANDOM % ${#PATHS[@]}]}
|
||
CODE=${CODES[$RANDOM % ${#CODES[@]}]}
|
||
SIZE=$((RANDOM % 5000 + 200))
|
||
AGENT=${AGENTS[$RANDOM % ${#AGENTS[@]}]}
|
||
|
||
case "$FORMAT" in
|
||
apache)
|
||
echo "$IP - - [$DATE] \"$METHOD $PATH HTTP/1.1\" $CODE $SIZE \"$AGENT\""
|
||
;;
|
||
json)
|
||
echo "{\"ip\":\"$IP\",\"timestamp\":\"$ISO_DATE\",\"method\":\"$METHOD\",\"path\":\"$PATH\",\"code\":$CODE,\"size\":$SIZE,\"agent\":\"$AGENT\"}"
|
||
;;
|
||
ltsv)
|
||
echo "host:$IP\ttime:$ISO_DATE\tmethod:$METHOD\tpath:$PATH\tstatus:$CODE\tsize:$SIZE\tagent:$AGENT"
|
||
;;
|
||
custom)
|
||
echo "[$ISO_DATE] $IP | $METHOD $PATH => $CODE ($SIZE bytes)"
|
||
;;
|
||
*)
|
||
echo "Format inconnu : $FORMAT" >&2
|
||
exit 1
|
||
;;
|
||
esac
|
||
}
|
||
|
||
# Boucle de génération
|
||
for ((i=0; i<LINES; i++)); do
|
||
generate_log
|
||
done
|
||
🔧 Utilisation
|
||
|
||
Rends-le exécutable :
|
||
chmod +x fake_logs.sh
|
||
Utilisation de base :
|
||
./fake_logs.sh 100 apache # format apache (par défaut)
|
||
./fake_logs.sh 50 json # format JSON
|
||
./fake_logs.sh 20 ltsv # format LTSV
|
||
./fake_logs.sh 10 custom # format personnalisé
|
||
Rediriger vers un fichier :
|
||
./fake_logs.sh 100 json > logs.json
|
||
🧪 Exemples
|
||
|
||
Format apache
|
||
173.29.44.102 - - [17/May/2025:12:04:10 +0000] "GET /dashboard HTTP/1.1" 200 2641 "curl/7.68.0"
|
||
Format json
|
||
{"ip":"244.51.138.41","timestamp":"2025-05-06T13:32:01+00:00","method":"POST","path":"/login","code":403,"size":876,"agent":"Mozilla/5.0 (iPhone; CPU iPhone OS 13_5_1 like Mac OS X)"}
|
||
Format ltsv
|
||
host:201.34.118.72 time:2025-05-22T08:17:14+00:00 method:GET path:/api/data status:200 size:2123 agent:PostmanRuntime/7.29.0
|
||
Format custom
|
||
[2025-05-14T07:10:33+00:00] 102.144.33.111 | PUT /checkout => 201 (4321 bytes)
|
||
Souhaites-tu que j'ajoute aussi :
|
||
|
||
la génération en continu (mode --loop)
|
||
des logs dans des fichiers séparés (erreur/access)
|
||
une version Dockerisée ?
|
||
Je peux aussi écrire une version Python plus puissante si tu veux aller plus loin.
|
||
|
||
Vous avez dit :
|
||
Souhaites-tu que j'ajoute aussi :
|
||
|
||
la génération en continu (mode --loop)
|
||
des logs dans des fichiers séparés (erreur/access)
|
||
une version Dockerisée ? oui
|
||
ChatGPT a dit :
|
||
Parfait ! Voici une version complète de fake_logs.sh avec génération continue (--loop), fichiers séparés (access.log / error.log), et image Docker.
|
||
|
||
📜 Script Bash complet : fake_logs.sh
|
||
|
||
#!/bin/bash
|
||
|
||
# Nombre de lignes par défaut
|
||
LINES=${1:-100}
|
||
FORMAT=${2:-apache}
|
||
MODE=$3
|
||
|
||
METHODS=("GET" "POST" "PUT" "DELETE" "PATCH")
|
||
PATHS=("/" "/login" "/dashboard" "/api/data" "/settings" "/products" "/checkout")
|
||
CODES_OK=(200 201 204 301 302)
|
||
CODES_ERR=(400 401 403 404 500 503)
|
||
AGENTS=(
|
||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
|
||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
|
||
"curl/7.68.0"
|
||
"PostmanRuntime/7.29.0"
|
||
"Mozilla/5.0 (iPhone; CPU iPhone OS 13_5_1 like Mac OS X)"
|
||
)
|
||
|
||
random_ip() {
|
||
echo "$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256))"
|
||
}
|
||
|
||
random_date() {
|
||
date "+%d/%b/%Y:%H:%M:%S %z"
|
||
}
|
||
|
||
iso_date() {
|
||
date --iso-8601=seconds
|
||
}
|
||
|
||
generate_log() {
|
||
IP=$(random_ip)
|
||
DATE=$(random_date)
|
||
ISO_DATE=$(iso_date)
|
||
METHOD=${METHODS[$RANDOM % ${#METHODS[@]}]}
|
||
PATH=${PATHS[$RANDOM % ${#PATHS[@]}]}
|
||
AGENT=${AGENTS[$RANDOM % ${#AGENTS[@]}]}
|
||
SIZE=$((RANDOM % 5000 + 200))
|
||
|
||
# Choix entre code OK ou erreur (20% erreurs)
|
||
if (( RANDOM % 10 < 2 )); then
|
||
CODE=${CODES_ERR[$RANDOM % ${#CODES_ERR[@]}]}
|
||
FILE="error.log"
|
||
else
|
||
CODE=${CODES_OK[$RANDOM % ${#CODES_OK[@]}]}
|
||
FILE="access.log"
|
||
fi
|
||
|
||
case "$FORMAT" in
|
||
apache)
|
||
LOG="$IP - - [$DATE] \"$METHOD $PATH HTTP/1.1\" $CODE $SIZE \"$AGENT\""
|
||
;;
|
||
json)
|
||
LOG="{\"ip\":\"$IP\",\"timestamp\":\"$ISO_DATE\",\"method\":\"$METHOD\",\"path\":\"$PATH\",\"code\":$CODE,\"size\":$SIZE,\"agent\":\"$AGENT\"}"
|
||
;;
|
||
ltsv)
|
||
LOG="host:$IP time:$ISO_DATE method:$METHOD path:$PATH status:$CODE size:$SIZE agent:$AGENT"
|
||
;;
|
||
custom)
|
||
LOG="[$ISO_DATE] $IP | $METHOD $PATH => $CODE ($SIZE bytes)"
|
||
;;
|
||
*)
|
||
echo "Format inconnu : $FORMAT" >&2
|
||
exit 1
|
||
;;
|
||
esac
|
||
|
||
echo "$LOG" >> "$FILE"
|
||
echo "$LOG"
|
||
}
|
||
|
||
# Fonction de génération continue
|
||
generate_loop() {
|
||
while true; do
|
||
generate_log
|
||
sleep 0.5
|
||
done
|
||
}
|
||
|
||
# Exécution
|
||
if [[ "$MODE" == "--loop" ]]; then
|
||
generate_loop
|
||
else
|
||
for ((i=0; i<LINES; i++)); do
|
||
generate_log
|
||
done
|
||
fi
|
||
🐳 Dockerfile
|
||
|
||
Voici un Dockerfile pour exécuter ton générateur de logs dans un conteneur :
|
||
|
||
FROM bash:5.2
|
||
|
||
WORKDIR /app
|
||
COPY fake_logs.sh .
|
||
RUN chmod +x fake_logs.sh
|
||
|
||
CMD ["./fake_logs.sh", "100", "apache"]
|
||
🔧 Construction et Exécution avec Docker
|
||
|
||
1. Construire l'image :
|
||
docker build -t fake-logs .
|
||
2. Lancer une génération simple :
|
||
docker run --rm fake-logs
|
||
3. Lancer en boucle continue (utile pour tests de pipelines, ELK, etc.) :
|
||
docker run --rm fake-logs ./fake_logs.sh 0 apache --loop
|
||
4. Monter un volume pour récupérer les fichiers :
|
||
docker run --rm -v $(pwd)/logs:/app/logs -w /app fake-logs ./fake_logs.sh 100 json
|
||
📁 Résultat
|
||
|
||
access.log : requêtes réussies (200, 201, etc.)
|
||
error.log : requêtes échouées (404, 500, etc.)
|
||
Supporte :
|
||
4 formats : apache, json, ltsv, custom
|
||
Mode boucle avec --loop
|
||
Séparation access/error
|
||
Souhaites-tu aussi :
|
||
|
||
Un script pour envoyer ces logs vers un serveur (syslog, fluentd, etc.) ?
|
||
Un service systemd pour générer des logs sur une VM ?
|
||
Une interface Web pour déclencher/paramétrer la génération ?
|
||
Je peux aussi t’aider à l’intégrer à une stack ELK, Loki, etc.
|
||
|
||
Vous avez dit :
|
||
loki
|
||
ChatGPT a dit :
|
||
Parfait ! Intégrer tes faux logs générés en Bash à Grafana Loki est une excellente idée pour tester une stack d’observabilité.
|
||
|
||
Voici un guide complet pour envoyer tes logs générés par fake_logs.sh vers Loki, avec ou sans Docker, et visualiser dans Grafana.
|
||
|
||
🧱 Architecture cible
|
||
|
||
[fake_logs.sh] --> [Promtail] --> [Loki] --> [Grafana]
|
||
✅ Étapes
|
||
|
||
1. ⚙️ Lancer une stack Loki + Grafana + Promtail via Docker Compose
|
||
Crée un fichier docker-compose.yml :
|
||
|
||
version: '3.7'
|
||
|
||
services:
|
||
loki:
|
||
image: grafana/loki:2.9.4
|
||
ports:
|
||
- "3100:3100"
|
||
command: -config.file=/etc/loki/local-config.yaml
|
||
|
||
promtail:
|
||
image: grafana/promtail:2.9.4
|
||
volumes:
|
||
- ./logs:/var/log/fake
|
||
- ./promtail-config.yml:/etc/promtail/promtail.yml
|
||
command: -config.file=/etc/promtail/promtail.yml
|
||
|
||
grafana:
|
||
image: grafana/grafana:10.2.0
|
||
ports:
|
||
- "3000:3000"
|
||
environment:
|
||
- GF_SECURITY_ADMIN_PASSWORD=admin
|
||
volumes:
|
||
- grafana-storage:/var/lib/grafana
|
||
|
||
volumes:
|
||
grafana-storage:
|
||
2. 📝 Fichier promtail-config.yml
|
||
server:
|
||
http_listen_port: 9080
|
||
grpc_listen_port: 0
|
||
|
||
positions:
|
||
filename: /tmp/positions.yaml
|
||
|
||
clients:
|
||
- url: http://loki:3100/loki/api/v1/push
|
||
|
||
scrape_configs:
|
||
- job_name: fake_logs
|
||
static_configs:
|
||
- targets:
|
||
- localhost
|
||
labels:
|
||
job: fake_logs
|
||
__path__: /var/log/fake/*.log
|
||
Ce fichier dit à Promtail de lire les fichiers dans ./logs/*.log et de les pousser vers Loki.
|
||
|
||
3. 🚀 Lancer la stack
|
||
docker compose up -d
|
||
Grafana sera sur http://localhost:3000 (login: admin / admin)
|
||
Loki sur port 3100
|
||
Promtail lit les fichiers dans ./logs
|
||
4. 🛠 Lancer ton script fake_logs.sh
|
||
Assure-toi que les logs sont bien écrits dans ./logs/ :
|
||
mkdir -p logs
|
||
./fake_logs.sh 100 json > logs/access.log
|
||
./fake_logs.sh 50 json > logs/error.log
|
||
Ou en continu :
|
||
./fake_logs.sh 0 json --loop >> logs/access.log
|
||
Tu peux aussi Dockeriser la génération de logs :
|
||
Monte ./logs comme volume dans le conteneur du générateur.
|
||
5. 📊 Visualiser dans Grafana
|
||
Va dans Grafana : http://localhost:3000
|
||
Ajoute Loki comme source de données :
|
||
URL : http://loki:3100
|
||
Va dans Explore
|
||
Exécute une requête comme :
|
||
{job="fake_logs"}
|
||
Tu verras tous les logs poussés par Promtail !
|
||
|
||
🔁 Automatiser tout ça (bonus)
|
||
|
||
Tu peux créer un Dockerfile pour fake_logs.sh comme générateur, et l’exécuter dans le même réseau que Promtail/Loki, pour simuler une vraie application.
|
||
|
||
✅ Résumé
|
||
|
||
Composant Rôle
|
||
fake_logs.sh Génère des logs réalistes
|
||
Promtail Lit les fichiers .log et les envoie à Loki
|
||
Loki Stocke et indexe les logs
|
||
Grafana Visualise et interroge les logs
|
||
Souhaites-tu un repo GitHub prêt à cloner avec tout ça dedans ? Je peux te générer une structure complète immédiatement.
|
||
|
||
Vous avez dit :
|
||
oui mais sur https://gitweb.dyndns.org
|
||
ChatGPT a dit :
|
||
Merci pour la précision !
|
||
|
||
🚧 Contexte
|
||
https://gitweb.dyndns.org semble être un serveur Git auto-hébergé utilisant GitWeb. Ce type d'interface web ne permet pas directement de pousser des dépôts, comme le fait GitHub ou GitLab. Au lieu de cela, tu dois :
|
||
|
||
Créer un dépôt Git sur ton serveur
|
||
Pousser ton projet localement ou via SSH
|
||
Ensuite, GitWeb affichera le contenu automatiquement
|
||
🛠 Étapes pour déployer ton projet sur gitweb.dyndns.org
|
||
|
||
✅ 1. Prépare le projet en local
|
||
Structure du projet :
|
||
|
||
fake-log-generator/
|
||
├── fake_logs.sh
|
||
├── logs/ # (vides, ignorés)
|
||
├── Dockerfile
|
||
├── promtail-config.yml
|
||
├── docker-compose.yml
|
||
└── .gitignore
|
||
.gitignore
|
||
|
||
logs/
|
||
*.log
|
||
Initialise Git :
|
||
|
||
cd fake-log-generator
|
||
git init
|
||
git add .
|
||
git commit -m "Initial commit of fake log generator for Loki"
|
||
✅ 2. Connecte-toi à ton serveur Git
|
||
Si ton serveur GitWeb est bien configuré en tant que serveur Git SSH, il te faut une ligne comme :
|
||
|
||
git remote add origin ssh://user@gitweb.dyndns.org:/srv/git/fake-log-generator.git
|
||
Ou si tu utilises git-shell :
|
||
|
||
git remote add origin user@gitweb.dyndns.org:fake-log-generator.git
|
||
✅ 3. Pousse ton projet
|
||
git push -u origin master
|
||
⚠️ Vérifie que tu as bien les droits en écriture sur le répertoire Git distant (/srv/git/…).
|
||
✅ 4. Configure GitWeb (si pas déjà fait)
|
||
Assure-toi que :
|
||
|
||
Ton dépôt est bien placé dans le répertoire lu par GitWeb (souvent /srv/git/)
|
||
Le fichier description existe :
|
||
echo "Fake log generator for Loki" > /srv/git/fake-log-generator.git/description
|
||
Le dépôt est en mode bare :
|
||
git init --bare /srv/git/fake-log-generator.git
|
||
✅ Bonus : contenu complet prêt à copier
|
||
|
||
Souhaites-tu que je te génère un .zip de ce projet prêt à envoyer, ou que je t’affiche le contenu de chaque fichier ici pour que tu le copies facilement ?
|
||
|
||
Je peux aussi t’aider à :
|
||
|
||
Automatiser les tests via GitHub Actions ou autre
|
||
Générer un tag/version
|
||
Ajouter un README.md avec les instructions
|
||
Souhaites-tu tout ça ?
|
||
|
||
Vous avez dit :
|
||
oui
|
||
ChatGPT a dit :
|
||
Parfait ! Voici le projet complet du générateur de logs pour Loki, prêt à être copié et poussé sur ton dépôt GitWeb (gitweb.dyndns.org).
|
||
|
||
📁 Structure du projet : fake-log-generator
|
||
|
||
fake-log-generator/
|
||
├── fake_logs.sh
|
||
├── docker-compose.yml
|
||
├── Dockerfile
|
||
├── promtail-config.yml
|
||
├── .gitignore
|
||
└── README.md
|
||
📜 1. fake_logs.sh
|
||
|
||
#!/bin/bash
|
||
|
||
LINES=${1:-100}
|
||
FORMAT=${2:-apache}
|
||
MODE=$3
|
||
|
||
METHODS=("GET" "POST" "PUT" "DELETE" "PATCH")
|
||
PATHS=("/" "/login" "/dashboard" "/api/data" "/settings" "/products" "/checkout")
|
||
CODES_OK=(200 201 204 301 302)
|
||
CODES_ERR=(400 401 403 404 500 503)
|
||
AGENTS=(
|
||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
|
||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
|
||
"curl/7.68.0"
|
||
"PostmanRuntime/7.29.0"
|
||
"Mozilla/5.0 (iPhone; CPU iPhone OS 13_5_1 like Mac OS X)"
|
||
)
|
||
|
||
mkdir -p logs
|
||
|
||
random_ip() {
|
||
echo "$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256))"
|
||
}
|
||
|
||
random_date() {
|
||
date "+%d/%b/%Y:%H:%M:%S %z"
|
||
}
|
||
|
||
iso_date() {
|
||
date --iso-8601=seconds
|
||
}
|
||
|
||
generate_log() {
|
||
IP=$(random_ip)
|
||
DATE=$(random_date)
|
||
ISO_DATE=$(iso_date)
|
||
METHOD=${METHODS[$RANDOM % ${#METHODS[@]}]}
|
||
PATH=${PATHS[$RANDOM % ${#PATHS[@]}]}
|
||
AGENT=${AGENTS[$RANDOM % ${#AGENTS[@]}]}
|
||
SIZE=$((RANDOM % 5000 + 200))
|
||
|
||
if (( RANDOM % 10 < 2 )); then
|
||
CODE=${CODES_ERR[$RANDOM % ${#CODES_ERR[@]}]}
|
||
FILE="logs/error.log"
|
||
else
|
||
CODE=${CODES_OK[$RANDOM % ${#CODES_OK[@]}]}
|
||
FILE="logs/access.log"
|
||
fi
|
||
|
||
case "$FORMAT" in
|
||
apache)
|
||
LOG="$IP - - [$DATE] \"$METHOD $PATH HTTP/1.1\" $CODE $SIZE \"$AGENT\""
|
||
;;
|
||
json)
|
||
LOG="{\"ip\":\"$IP\",\"timestamp\":\"$ISO_DATE\",\"method\":\"$METHOD\",\"path\":\"$PATH\",\"code\":$CODE,\"size\":$SIZE,\"agent\":\"$AGENT\"}"
|
||
;;
|
||
ltsv)
|
||
LOG="host:$IP time:$ISO_DATE method:$METHOD path:$PATH status:$CODE size:$SIZE agent:$AGENT"
|
||
;;
|
||
custom)
|
||
LOG="[$ISO_DATE] $IP | $METHOD $PATH => $CODE ($SIZE bytes)"
|
||
;;
|
||
*)
|
||
echo "Format inconnu : $FORMAT" >&2
|
||
exit 1
|
||
;;
|
||
esac
|
||
|
||
echo "$LOG" >> "$FILE"
|
||
echo "$LOG"
|
||
}
|
||
|
||
if [[ "$MODE" == "--loop" ]]; then
|
||
while true; do
|
||
generate_log
|
||
sleep 0.5
|
||
done
|
||
else
|
||
for ((i=0; i<LINES; i++)); do
|
||
generate_log
|
||
done
|
||
fi
|
||
🐳 2. Dockerfile
|
||
|
||
FROM bash:5.2
|
||
|
||
WORKDIR /app
|
||
COPY fake_logs.sh .
|
||
RUN chmod +x fake_logs.sh
|
||
|
||
CMD ["./fake_logs.sh", "100", "json"]
|
||
🧱 3. docker-compose.yml
|
||
|
||
version: '3.7'
|
||
|
||
services:
|
||
loki:
|
||
image: grafana/loki:2.9.4
|
||
ports:
|
||
- "3100:3100"
|
||
command: -config.file=/etc/loki/local-config.yaml
|
||
|
||
promtail:
|
||
image: grafana/promtail:2.9.4
|
||
volumes:
|
||
- ./logs:/var/log/fake
|
||
- ./promtail-config.yml:/etc/promtail/promtail.yml
|
||
command: -config.file=/etc/promtail/promtail.yml
|
||
|
||
grafana:
|
||
image: grafana/grafana:10.2.0
|
||
ports:
|
||
- "3000:3000"
|
||
environment:
|
||
- GF_SECURITY_ADMIN_PASSWORD=admin
|
||
volumes:
|
||
- grafana-storage:/var/lib/grafana
|
||
|
||
volumes:
|
||
grafana-storage:
|
||
📦 4. promtail-config.yml
|
||
|
||
server:
|
||
http_listen_port: 9080
|
||
grpc_listen_port: 0
|
||
|
||
positions:
|
||
filename: /tmp/positions.yaml
|
||
|
||
clients:
|
||
- url: http://loki:3100/loki/api/v1/push
|
||
|
||
scrape_configs:
|
||
- job_name: fake_logs
|
||
static_configs:
|
||
- targets:
|
||
- localhost
|
||
labels:
|
||
job: fake_logs
|
||
__path__: /var/log/fake/*.log
|
||
📁 5. .gitignore
|
||
|
||
logs/
|
||
*.log
|
||
📘 6. README.md
|
||
|
||
# 🧪 Fake Log Generator for Loki
|
||
|
||
Ce projet génère de faux logs réalistes dans plusieurs formats (`apache`, `json`, `ltsv`, `custom`) et les envoie à Grafana Loki via Promtail.
|
||
|
||
## 🔧 Démarrage rapide
|
||
|
||
```bash
|
||
docker compose up -d
|
||
./fake_logs.sh 0 json --loop >> logs/access.log
|
||
🔗 Accès
|
||
|
||
Grafana : http://localhost:3000 (admin / admin)
|
||
Loki : http://localhost:3100
|
||
🔍 Requête exemple (Grafana Explore)
|
||
|
||
{job="fake_logs"}
|
||
📦 Contenu
|
||
|
||
fake_logs.sh : générateur de logs
|
||
promtail-config.yml : config pour envoyer vers Loki
|
||
docker-compose.yml : stack Loki + Promtail + Grafana
|
||
|
||
---
|
||
|
||
## 🚀 Étapes suivantes pour GitWeb
|
||
|
||
1. Initialise Git dans le dossier :
|
||
```bash
|
||
git init
|
||
git remote add origin ssh://user@gitweb.dyndns.org:/srv/git/fake-log-generator.git
|
||
git add .
|
||
git commit -m "Initial fake log project for Loki"
|
||
git push -u origin master
|
||
Vérifie que description, HEAD, etc. sont bien en place sur le serveur (mode bare repo).
|
||
Souhaites-tu que je te prépare une archive .zip contenant tout ce projet ? Je peux aussi générer les fichiers individuellement si tu le souhaites.
|
||
|
||
Vous avez dit :
|
||
oui
|
||
ChatGPT a dit :
|
||
📦 Ton projet est prêt !
|
||
|
||
Tu peux télécharger l’archive contenant le générateur de faux logs pour Loki ici :
|
||
|
||
👉 fake-log-generator.zip
|
||
|
||
Cette archive contient :
|
||
|
||
fake_logs.sh (le générateur de logs)
|
||
Dockerfile + docker-compose.yml
|
||
promtail-config.yml
|
||
.gitignore
|
||
README.md
|
||
Tu peux maintenant le décompresser, le tester localement ou le pousser directement sur ton dépôt GitWeb.
|
||
|
||
Souhaites-tu aussi un exemple de configuration pour intégrer ça dans un dashboard Grafana ?
|
||
|
||
Vous avez dit :
|
||
oui
|
||
ChatGPT a dit :
|
||
Parfait ! Voici un exemple complet de tableau de bord Grafana pour visualiser les logs générés par ton script fake_logs.sh via Loki.
|
||
|
||
📊 Dashboard Grafana pour les logs fake_logs
|
||
|
||
📌 Méthode 1 : Import manuel via JSON
|
||
Tu peux importer le JSON suivant dans Grafana :
|
||
|
||
📝 JSON de Dashboard (extrait)
|
||
Voici un extrait (je peux te fournir le .json complet si tu préfères en fichier) :
|
||
|
||
{
|
||
"dashboard": {
|
||
"title": "Fake Log Generator Dashboard",
|
||
"panels": [
|
||
{
|
||
"type": "logs",
|
||
"title": "Logs récents (Loki)",
|
||
"targets": [
|
||
{
|
||
"expr": "{job=\"fake_logs\"}",
|
||
"refId": "A"
|
||
}
|
||
],
|
||
"options": {
|
||
"dedupStrategy": "none",
|
||
"showTime": true,
|
||
"showLabels": true
|
||
},
|
||
"gridPos": { "x": 0, "y": 0, "w": 24, "h": 10 }
|
||
},
|
||
{
|
||
"type": "stat",
|
||
"title": "Nombre total de logs",
|
||
"targets": [
|
||
{
|
||
"expr": "count_over_time({job=\"fake_logs\"}[1m])",
|
||
"refId": "B"
|
||
}
|
||
],
|
||
"gridPos": { "x": 0, "y": 10, "w": 6, "h": 6 }
|
||
},
|
||
{
|
||
"type": "piechart",
|
||
"title": "Répartition par code HTTP",
|
||
"targets": [
|
||
{
|
||
"expr": "count_over_time({job=\"fake_logs\"} |= \"HTTP\" | regexp \"\\\" ([0-9]{3}) \" | unwrap code [1m]) by (code)",
|
||
"refId": "C"
|
||
}
|
||
],
|
||
"gridPos": { "x": 6, "y": 10, "w": 9, "h": 6 }
|
||
}
|
||
],
|
||
"schemaVersion": 36,
|
||
"version": 1
|
||
}
|
||
}
|
||
📥 Importer dans Grafana
|
||
|
||
Ouvre Grafana : http://localhost:3000
|
||
Va dans Dashboards > New > Import
|
||
Colle le JSON ci-dessus ou charge un fichier .json
|
||
Sélectionne ta source Loki comme "data source"
|
||
🔍 Astuces LogQL utiles pour Grafana Explore
|
||
|
||
Tous les logs :
|
||
{job="fake_logs"}
|
||
Logs d'erreurs :
|
||
{job="fake_logs"} |= " 5" or |= " 4"
|
||
Filtrer par méthode HTTP :
|
||
{job="fake_logs"} |= "POST"
|