diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..cc3a7e4 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,34 @@ +name: CI Pipeline - Doodle Quarkus + +on: + push: + branches: [ main, master ] + pull_request: + branches: [ main, master ] + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - name: Set up Java 17 + uses: actions/setup-java@v3 + with: + java-version: '17' + distribution: 'temurin' + + - name: Build with Maven + run: ./mvnw clean package -DskipTests + working-directory: ./api + + - name: Build Docker Compose + run: docker compose -f api/docker-compose.yaml up -d --build + + - name: Check services + run: docker compose -f api/docker-compose.yaml ps + + - name: Teardown + run: docker compose -f api/docker-compose.yaml down \ No newline at end of file diff --git a/api/README.md b/api/README.md new file mode 100644 index 0000000..57164e3 --- /dev/null +++ b/api/README.md @@ -0,0 +1,53 @@ +# code-with-quarkus project + +This project uses Quarkus, the Supersonic Subatomic Java Framework. + +If you want to learn more about Quarkus, please visit its website: https://quarkus.io/ . + +## Running the application in dev mode + +You can run your application in dev mode that enables live coding using: +```shell script +docker-compose up --detach +# Wait the correct start of the docker services and then +./mvnw compile quarkus:dev +``` + +To stop the application and its dependencies, type `ctrl+c` in the bash session and run `docker-compose down`. + +## Packaging and running the application + +The application can be packaged using: +```shell script +./mvnw package +``` +It produces the `code-with-quarkus-1.0.0-SNAPSHOT-runner.jar` file in the `/target` directory. +Be aware that it’s not an _über-jar_ as the dependencies are copied into the `target/lib` directory. +If you want to build an _über-jar_, execute the following command: +```shell script +./mvnw clean package -Dquarkus.package.type=uber-jar +``` + +The application is now runnable using `java -jar target/code-with-quarkus-1.0.0-SNAPSHOT-runner.jar`. + +## Creating a native executable + +You can create a native executable using: +```shell script +./mvnw package -Pnative +``` + +Or, if you don't have GraalVM installed, you can run the native executable build in a container using: +```shell script +./mvnw package -Pnative -Dquarkus.native.container-build=true +``` + +You can then execute your native executable with: `./target/code-with-quarkus-1.0.0-SNAPSHOT-runner` + +If you want to learn more about building native executables, please consult https://quarkus.io/guides/maven-tooling.html. + +# RESTEasy JAX-RS + +Guide: https://quarkus.io/guides/rest-json + + diff --git a/api/docker-compose.yaml b/api/docker-compose.yaml new file mode 100644 index 0000000..35fdffa --- /dev/null +++ b/api/docker-compose.yaml @@ -0,0 +1,84 @@ +version: "3.8" +services: + db: + image: mysql + ports: + - "3307:3306" + environment: + - MYSQL_ROOT_PASSWORD=root + - MYSQL_DATABASE=tlc + - MYSQL_USER=tlc + - MYSQL_PASSWORD=tlc + etherpad: + image: etherpad/etherpad + ports: + - "9001:9001" + environment: + AUTHENTICATION_METHOD: "apikey" + volumes: + - ./APIKEY.txt:/opt/etherpad-lite/APIKEY.txt:ro + mail: + image: bytemark/smtp + restart: always + ports: + - "2525:25" + frontend: + image: node:18-alpine + working_dir: /app + volumes: + - ../front:/app + ports: + - "4200:4200" + command: sh -c "npm install && npx ng serve --host 0.0.0.0 --port 4200 --proxy-config proxy.conf.json" + depends_on: + - db + + prometheus: + image: prom/prometheus:latest + ports: + - "9090:9090" + volumes: + - ./prometheus.yml:/etc/prometheus/prometheus.yml + extra_hosts: + - "host.docker.internal:host-gateway" + depends_on: + - db + + grafana: + image: grafana/grafana:latest + ports: + - "3000:3000" + environment: + - GF_SECURITY_ADMIN_PASSWORD=admin + - GF_PATHS_PROVISIONING=/etc/grafana/provisioning + volumes: + - grafana_data:/var/lib/grafana + - ./grafana/provisioning:/etc/grafana/provisioning:ro + depends_on: + - prometheus + - loki + + loki: + image: grafana/loki:2.9.0 + ports: + - "3100:3100" + volumes: + - ./loki-config.yaml:/etc/loki/local-config.yaml:ro + - loki_data:/loki + command: -config.file=/etc/loki/local-config.yaml + restart: unless-stopped + + promtail: + image: grafana/promtail:2.9.0 + volumes: + - /var/log:/var/log:ro + - /var/lib/docker/containers:/var/lib/docker/containers:ro + - ./promtail-config.yaml:/etc/promtail/config.yaml:ro + command: -config.file=/etc/promtail/config.yaml + restart: unless-stopped + depends_on: + - loki + +volumes: + grafana_data: + loki_data: \ No newline at end of file diff --git a/api/docs/Readme.md b/api/docs/Readme.md new file mode 100644 index 0000000..5af1952 --- /dev/null +++ b/api/docs/Readme.md @@ -0,0 +1,417 @@ +# Issue #11 — Cloud-native applications and microservice architecture + +## Présentation du groupe + +**Cours** : DevOps — ESIR2 S8 +**Sujet** : Issue #11 — Cloud-native applications and microservice architecture +**Référence** : [mfornos/awesome-microservices](https://github.com/mfornos/awesome-microservices) +**Repo du projet** : [yassminechiha-bot/DoodleProjetDevops](https://github.com/yassminechiha-bot/DoodleProjetDevops) + +**Groupe** : Yassmine CHIHA, Mariem Zeineb DHOUIB, Aymen SAHOURI et Ouiam ZEROUAL + +--- + +## Ce que nous avons mis en place + +### 1. GitHub Actions — Pipeline CI/CD + +**Fichier** : `.github/workflows/ci.yml` + +Nous avons créé un pipeline CI/CD qui s'exécute automatiquement à chaque push ou pull request sur `main`/`master`. Il enchaîne les étapes suivantes : + +1. Checkout du code +2. Installation de Java 17 (Temurin) +3. Build Maven avec `./mvnw clean package -DskipTests` +4. Build + démarrage de Docker Compose +5. Vérification de l'état des services +6. Teardown propre + +```yaml +name: CI Pipeline - Doodle Quarkus +on: + push: + branches: [ main, master ] + pull_request: + branches: [ main, master ] +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-java@v3 + with: + java-version: '17' + distribution: 'temurin' + - name: Build with Maven + run: ./mvnw clean package -DskipTests + working-directory: ./api + - name: Build Docker Compose + run: docker compose -f api/docker-compose.yaml up -d --build + - name: Check services + run: docker compose -f api/docker-compose.yaml ps + - name: Teardown + run: docker compose -f api/docker-compose.yaml down +``` + +Pipeline opérationnel et passant au vert sur GitHub Actions. + +> **Capture 1 — Pipeline GitHub Actions** +> ![CI Pipeline](api/docs/screenshots/01-github-actions.png) + +On observe ici l'exécution du pipeline CI/CD sur GitHub Actions. +Un premier run échoue à cause d'une erreur de configuration (docker-compose mal nommé), puis une correction est appliquée. +Le second run passe avec succès, ce qui valide le bon fonctionnement du pipeline : build Maven, lancement des services Docker et vérification. + +--- + +### 2. Docker Compose — Ajout des services manquants + +**Fichier** : `api/docker-compose.yaml` + +Le docker-compose existant contenait uniquement `db`, `etherpad` et `mail`. Nous avons ajouté : + +- Le service **frontend** (Angular) pour lancer l'interface utilisateur +- Les services d'**observabilité** : Prometheus, Grafana, Loki, Promtail + +Nous avons également mis à jour `application.yml` pour pointer les URLs vers les bons services locaux : + +```yaml +doodle: + internalPadUrl: "http://localhost:9001/" + externalPadUrl: "http://localhost:9001/" +quarkus: + mailer: + host: localhost + port: 2525 + smallrye-metrics: + path: /q/metrics +``` + +Le backend Quarkus est lancé sur la machine hôte avec `./mvnw quarkus:dev` et expose ses métriques sur `http://localhost:8080/q/metrics`. + +> **Capture 2 — docker compose : services en cours d'exécution** +> ![Docker services](api/docs/screenshots/02-docker.png) + +Cette capture montre les conteneurs Docker en cours d'exécution. +Tous les services sont démarrés correctement : MySQL, Etherpad, SMTP, frontend Angular, ainsi que les outils d'observabilité (Prometheus, Grafana, Loki, Promtail). +L'environnement applicatif est donc entièrement opérationnel. + +--- + +### 3. Prometheus — Collecte de métriques + +**Fichier** : `api/prometheus.yml` + +Référencé dans `mfornos/awesome-microservices` → section **Monitoring & Debugging**. + +Prometheus scrape toutes les 10 secondes l'endpoint `/q/metrics` de Quarkus via `host.docker.internal`. + +```yaml +global: + scrape_interval: 15s + +scrape_configs: + - job_name: 'quarkus' + static_configs: + - targets: ['host.docker.internal:8080'] + metrics_path: '/q/metrics' + scrape_interval: 10s + + - job_name: 'prometheus' + static_configs: + - targets: ['localhost:9090'] +``` + +Les métriques exposées par Quarkus sont au format MicroProfile : +- `base_memory_committedHeap_bytes` +- `base_cpu_processCpuLoad_percent` +- `base_jvm_uptime_seconds` +- `base_gc_total` + +> **Capture 3 — Prometheus : état des targets** +> ![Prometheus targets](api/docs/screenshots/03-prometheus.png) + +On observe ici les targets configurés dans Prometheus. +Les deux services (Prometheus lui-même et l'application Quarkus) sont en état **UP**. +Cela confirme que Prometheus collecte correctement les métriques via l'endpoint `/q/metrics`. + +--- + +### 4. Grafana — Visualisation des métriques + +**Fichier** : `api/grafana/provisioning/datasources/datasources.yaml` + +Référencé dans `mfornos/awesome-microservices` → section **Monitoring & Debugging**. + +Grafana est configuré avec provisioning automatique : les datasources Prometheus et Loki sont déclarées via des fichiers YAML versionnés dans Git, sans configuration manuelle. + +```yaml +apiVersion: 1 +datasources: + - name: Prometheus + type: prometheus + url: http://prometheus:9090 + isDefault: true + - name: Loki + type: loki + url: http://loki:3100 +``` + +> **Capture 4 — Grafana : sources de données** +> ![Grafana datasources](api/docs/screenshots/04-grafana-datasources.png) + +Cette capture montre que Grafana est correctement configuré avec deux sources de données : Prometheus pour les métriques et Loki pour les logs. +Ces sources sont automatiquement provisionnées via des fichiers YAML versionnés dans le projet. +Cela permet d'éviter toute configuration manuelle et garantit la reproductibilité. + +> **Capture 5 — Grafana Explore : mémoire JVM** +> ![Grafana mémoire](api/docs/screenshots/05-memory.png) + +On observe ici la métrique `base_memory_committedHeap_bytes`, qui représente la mémoire heap utilisée par la JVM. +Le graphique permet de suivre l'évolution de la consommation mémoire dans le temps. +Cela est utile pour détecter d'éventuelles fuites mémoire ou une surcharge. + +> **Capture 5 bis — Grafana Explore : utilisation CPU** +> ![Grafana CPU](api/docs/screenshots/06-cpu.png) + +Cette capture montre la métrique `base_cpu_processCpuLoad_percent`, qui représente la charge CPU du processus Quarkus. +On peut observer les variations de charge et identifier d'éventuels pics liés à certaines requêtes. + +> **Capture 5 ter — Grafana Explore : uptime JVM** +> ![Grafana uptime](api/docs/screenshots/07-uptime.png) + +Cette capture montre la métrique `base_jvm_uptime_seconds`, qui représente le temps de fonctionnement de l'application depuis son démarrage. +Cela permet de vérifier la stabilité du service et de détecter d'éventuels redémarrages. + +--- + +### 5. Loki + Promtail — Centralisation des logs + +**Fichiers** : `api/loki-config.yaml`, `api/promtail-config.yaml` + +Référencé dans `mfornos/awesome-microservices` → section **Logging** : *"Like Prometheus, but for logs."* + +Loki stocke les logs de tous les conteneurs Docker. Promtail est l'agent qui les collecte et les envoie à Loki. Les logs sont consultables directement dans Grafana via `{job="docker-logs"}`. + +> **Capture 6 — Grafana Explore Loki : logs globaux** +> ![Loki logs](api/docs/screenshots/08-logs.png) + +On observe ici les logs collectés par Loki via Promtail. +La requête `{job="docker-logs"}` permet de récupérer les logs de tous les conteneurs Docker. +Cela fournit une vue centralisée de l'activité de l'ensemble des services. + +> **Capture 6 bis — Grafana Explore Loki : détail des logs** +> ![Loki logs détail](api/docs/screenshots/09-logs-details.png) + +Cette vue détaillée montre les messages de logs avec leur niveau (INFO, etc.), les timestamps et les informations internes des services. +Cela permet d'analyser précisément le comportement de l'application et facilite le debugging. + +## Analyse des métriques après utilisation de l'application + +Afin de générer des métriques exploitables, nous avons simulé une activité utilisateur via le frontend (création de plusieurs sondages, ajout de participants, interactions et commentaires). + +Cette activité permet d’observer le comportement réel de l’application à travers les métriques et les logs. + +--- + +### Charge CPU + +> **Capture — Grafana : utilisation CPU** +> ![CPU](api/docs/screenshots/processuscpuapresutilisationdeapp.png) + +On observe ici la métrique `base_cpu_processCpuLoad_percent`. + +Après une phase initiale sans activité, des pics apparaissent suite aux interactions réalisées sur l’application (création de sondages, ajout de participants, commentaires). + +Ces variations confirment que le système de monitoring capte correctement l’activité réelle de l’application. + +--- + +### Mémoire JVM + +> **Capture — Grafana : mémoire JVM** +> ![Memory](api/docs/screenshots/basememoryapresutilisationdeapp.png) + +On observe ici la métrique `base_memory_committedHeap_bytes`, représentant la mémoire heap utilisée par la JVM. + +La mémoire reste globalement stable, avec de légères variations liées à l’activité de l’application. Ce comportement est normal, la JVM allouant une quantité de mémoire relativement constante tout en ajustant dynamiquement son utilisation. + +--- + +### Uptime de l'application + +> **Capture — Grafana : uptime JVM** +> ![Uptime](api/docs/screenshots/uptimeapresutilisation.png) + +Cette capture montre la métrique `base_jvm_uptime_seconds`, qui représente le temps de fonctionnement de l’application depuis son démarrage. + +Son évolution linéaire confirme que l’application reste stable et qu’aucun redémarrage n’a eu lieu pendant la période observée. + +--- + +## Analyse des logs + +> **Capture — Grafana Loki : volume des logs** +> ![Logs volume](api/docs/screenshots/logsapresutilisation1.png) + +On observe ici une augmentation du volume de logs lors de l’utilisation de l’application. + +Les pics correspondent aux interactions effectuées via le frontend, ce qui montre que les événements applicatifs sont bien enregistrés. + +--- + +> **Capture — Grafana Loki : logs détaillés** +> ![Logs details](api/docs/screenshots/logsapresutilisation2.png) + +Les logs détaillés contiennent des informations telles que les timestamps, les niveaux de log (INFO) et les messages internes des services. + +Ils permettent de suivre précisément l’activité du système et facilitent le debugging. + +--- + +## Corrélation métriques / logs + +On observe une corrélation entre les pics de logs et les variations de la charge CPU. + +Cela confirme la cohérence du système d’observabilité mis en place : les actions utilisateur génèrent à la fois des logs et une augmentation de la charge système. + +--- + +## Conclusion sur l'observabilité + +Ces différentes métriques (CPU, mémoire, uptime) combinées aux logs permettent d’avoir une vision complète du comportement de l’application. + +L’utilisation conjointe de Prometheus, Grafana et Loki permet : +- de surveiller les performances +- d’analyser les événements applicatifs +- de faciliter le debugging + +Le système d’observabilité mis en place est donc pleinement fonctionnel et adapté à une architecture cloud-native. +--- + +## Architecture finale + +``` +Machine hôte +│ +├── Quarkus :8080 (./mvnw quarkus:dev) +│ │ +│ └── /q/metrics ─────────────────────┐ +│ │ +└── Docker Compose │ + │ │ + ├── MySQL :3307 │ + ├── Etherpad :9001 │ + ├── SMTP :2525 │ + ├── Angular :4200 │ + │ │ + ├── Prometheus :9090 ◄────────────────┘ + │ │ + ├── Grafana :3000 ◄── Loki :3100 ◄── Promtail + │ (logs Docker) + └── GitHub Actions CI/CD + (push → build Maven → docker compose → check) +``` + +--- + +## Étapes de lancement + +```bash +# 1. Cloner le projet +git clone https://github.com/yassminechiha-bot/DoodleProjetDevops.git +cd DoodleProjetDevops + +# 2. Démarrer tous les services Docker +docker compose -f api/docker-compose.yaml up -d + +# 3. Lancer le backend Quarkus +cd api +./mvnw quarkus:dev +``` + +| Service | URL | +|---------|-----| +| Frontend Doodle | http://localhost:4200 | +| Métriques Quarkus | http://localhost:8080/q/metrics | +| Prometheus | http://localhost:9090 | +| Grafana | http://localhost:3000 | +| Etherpad | http://localhost:9001 | + +--- + +## Difficultés rencontrées + +### `host.docker.internal` sous WSL2 +Sous Linux/WSL2, Docker ne résout pas automatiquement `host.docker.internal`. Sans ça, Prometheus ne peut pas joindre Quarkus sur l'hôte. + +**Solution** : +```yaml +extra_hosts: + - "host.docker.internal:host-gateway" +``` + +### Format MicroProfile des métriques +Quarkus expose les métriques au format MicroProfile et non Prometheus standard. Les métriques sont préfixées par `base_` : +- `process_cpu_usage` → n'existe pas +- `base_cpu_processCpuLoad_percent` → format réel + +### Fichiers de config créés comme dossiers (WSL2) +Docker Compose sous WSL2 crée parfois les fichiers montés en volume comme des dossiers s'ils n'existent pas. Cela a bloqué le démarrage de Loki et Promtail. + +**Solution** : supprimer le dossier et recréer le fichier manuellement avant de relancer le conteneur. + +--- + +## Fichiers ajoutés/modifiés + +``` +api/ +├── docker-compose.yaml ← modifié : + frontend, prometheus, grafana, loki, promtail +├── prometheus.yml ← ajouté +├── loki-config.yaml ← ajouté +├── promtail-config.yaml ← ajouté +├── grafana/ +│ └── provisioning/ +│ └── datasources/ +│ └── datasources.yaml ← ajouté +└── src/main/resources/ + └── application.yml ← modifié : URLs localhost + +.github/ +└── workflows/ + └── ci.yml ← ajouté + +docs/ +└── screenshots/ ← captures d'écran + ├── 01-github-actions-success.png + ├── 02-docker-compose-ps.png + ├── 03-prometheus-targets-up.png + ├── 04-grafana-datasources.png + ├── 05-grafana-metrics-quarkus.png + └── 06-grafana-loki-logs.png +``` + +--- + +L'ensemble des captures démontre que l'architecture mise en place offre une observabilité complète du système, en combinant métriques et logs dans un environnement cloud-native, tout en intégrant une chaîne d’intégration continue automatisée via GitHub Actions. + +Cette architecture met en œuvre les principes fondamentaux du cloud-native : +- découplage des services (approche microservices) +- conteneurisation avec Docker +- observabilité complète (métriques et logs) +- automatisation des processus via CI/CD + +Elle permet ainsi de faciliter le déploiement, la supervision et le debugging d'une application distribuée. + + + +## Conclusion + +Nous avons mis en place une architecture cloud-native complète intégrant les pratiques DevOps essentielles : intégration continue, conteneurisation et observabilité. + +Grâce à l’utilisation conjointe de Prometheus, Grafana et Loki, nous sommes en mesure de superviser l’application en temps réel, tant au niveau des performances que des logs applicatifs. + +L’analyse des métriques et des logs après utilisation réelle de l’application confirme la pertinence de cette architecture et démontre l’efficacité des outils mis en place. + +Ce projet illustre concrètement les bonnes pratiques DevOps modernes pour le déploiement, le monitoring et la gestion d’une architecture distribuée basée sur des microservices. diff --git a/api/docs/screenshots/01-github-actions.png b/api/docs/screenshots/01-github-actions.png new file mode 100644 index 0000000..8795ede Binary files /dev/null and b/api/docs/screenshots/01-github-actions.png differ diff --git a/api/docs/screenshots/02-docker.png b/api/docs/screenshots/02-docker.png new file mode 100644 index 0000000..c824e34 Binary files /dev/null and b/api/docs/screenshots/02-docker.png differ diff --git a/api/docs/screenshots/03-prometheus.png b/api/docs/screenshots/03-prometheus.png new file mode 100644 index 0000000..5c99c19 Binary files /dev/null and b/api/docs/screenshots/03-prometheus.png differ diff --git a/api/docs/screenshots/04-grafana-datasources.png b/api/docs/screenshots/04-grafana-datasources.png new file mode 100644 index 0000000..d69cdda Binary files /dev/null and b/api/docs/screenshots/04-grafana-datasources.png differ diff --git a/api/docs/screenshots/05-memory.png b/api/docs/screenshots/05-memory.png new file mode 100644 index 0000000..59bde83 Binary files /dev/null and b/api/docs/screenshots/05-memory.png differ diff --git a/api/docs/screenshots/06-cpu.png b/api/docs/screenshots/06-cpu.png new file mode 100644 index 0000000..397c35c Binary files /dev/null and b/api/docs/screenshots/06-cpu.png differ diff --git a/api/docs/screenshots/07-uptime.png b/api/docs/screenshots/07-uptime.png new file mode 100644 index 0000000..636cab6 Binary files /dev/null and b/api/docs/screenshots/07-uptime.png differ diff --git a/api/docs/screenshots/08-logs.png b/api/docs/screenshots/08-logs.png new file mode 100644 index 0000000..d76ccff Binary files /dev/null and b/api/docs/screenshots/08-logs.png differ diff --git a/api/docs/screenshots/09-logs-details.png b/api/docs/screenshots/09-logs-details.png new file mode 100644 index 0000000..3b20981 Binary files /dev/null and b/api/docs/screenshots/09-logs-details.png differ diff --git a/api/docs/screenshots/basememoryapresutilisationdeapp.png b/api/docs/screenshots/basememoryapresutilisationdeapp.png new file mode 100644 index 0000000..35320b7 Binary files /dev/null and b/api/docs/screenshots/basememoryapresutilisationdeapp.png differ diff --git a/api/docs/screenshots/logsapresutilisation1.png b/api/docs/screenshots/logsapresutilisation1.png new file mode 100644 index 0000000..7592f53 Binary files /dev/null and b/api/docs/screenshots/logsapresutilisation1.png differ diff --git a/api/docs/screenshots/logsapresutilisation2.png b/api/docs/screenshots/logsapresutilisation2.png new file mode 100644 index 0000000..883b5e2 Binary files /dev/null and b/api/docs/screenshots/logsapresutilisation2.png differ diff --git a/api/docs/screenshots/processuscpuapresutilisationdeapp.png b/api/docs/screenshots/processuscpuapresutilisationdeapp.png new file mode 100644 index 0000000..2c54ef1 Binary files /dev/null and b/api/docs/screenshots/processuscpuapresutilisationdeapp.png differ diff --git a/api/docs/screenshots/uptimeapresutilisation.png b/api/docs/screenshots/uptimeapresutilisation.png new file mode 100644 index 0000000..fe9ae28 Binary files /dev/null and b/api/docs/screenshots/uptimeapresutilisation.png differ diff --git a/api/grafana/provisioning/datasources/datasources.yaml b/api/grafana/provisioning/datasources/datasources.yaml new file mode 100644 index 0000000..f4f7002 --- /dev/null +++ b/api/grafana/provisioning/datasources/datasources.yaml @@ -0,0 +1,15 @@ +apiVersion: 1 + +datasources: + - name: Prometheus + type: prometheus + access: proxy + url: http://prometheus:9090 + isDefault: true + editable: true + + - name: Loki + type: loki + access: proxy + url: http://loki:3100 + editable: true diff --git a/api/loki-config.yaml b/api/loki-config.yaml new file mode 100644 index 0000000..43a7c77 --- /dev/null +++ b/api/loki-config.yaml @@ -0,0 +1,30 @@ +auth_enabled: false + +server: + http_listen_port: 3100 + grpc_listen_port: 9096 + +common: + instance_addr: 127.0.0.1 + path_prefix: /loki + storage: + filesystem: + chunks_directory: /loki/chunks + rules_directory: /loki/rules + replication_factor: 1 + ring: + kvstore: + store: inmemory + +schema_config: + configs: + - from: 2020-10-24 + store: tsdb + object_store: filesystem + schema: v12 + index: + prefix: index_ + period: 24h + +limits_config: + allow_structured_metadata: false diff --git a/api/pom.xml b/api/pom.xml new file mode 100644 index 0000000..ad79fd8 --- /dev/null +++ b/api/pom.xml @@ -0,0 +1,266 @@ + + + 4.0.0 + fr.istic + tlcdemoApp + 1.0.0-SNAPSHOT + + 3.11.0 + 17 + UTF-8 + UTF-8 + quarkus-bom + io.quarkus.platform + 3.7.1 + true + 3.0.0 + + + + + ${quarkus.platform.group-id} + ${quarkus.platform.artifact-id} + ${quarkus.platform.version} + pom + import + + + + + + io.quarkus + quarkus-arc + + + io.quarkus + quarkus-junit5 + test + + + io.rest-assured + rest-assured + test + + + + + io.quarkus + quarkus-hibernate-orm + + + io.quarkus + quarkus-config-yaml + + + io.quarkus + quarkus-hibernate-orm-rest-data-panache + + + io.quarkus + quarkus-resteasy + + + io.quarkus + quarkus-scheduler + + + io.quarkus + quarkus-jdbc-mysql + + + io.quarkus + quarkus-smallrye-metrics + + + io.quarkus + quarkus-smallrye-opentracing + + + io.quarkus + quarkus-hibernate-validator + + + io.quarkus + quarkus-smallrye-openapi + + + io.quarkus + quarkus-jackson + + + io.quarkus + quarkus-resteasy-jackson + + + io.quarkus + quarkus-mailer + + + io.quarkus + quarkus-spring-web + + + io.quarkus + quarkus-flyway + + + net.sourceforge.jexcelapi + jxl + 2.6.12 + + + net.gjerull.etherpad + etherpad_lite_client + 1.2.13 + + + + org.mnode.ical4j + ical4j + 3.0.20 + + + + org.apache.httpcomponents + httpasyncclient + + + commons-logging + commons-logging + + + + + + javax.cache + cache-api + 1.1.1 + + + + + org.jsr107.ri + cache-ri-impl + 1.1.1 + + + + org.jboss.logging + commons-logging-jboss-logging + 1.0.0.Final + + + + org.jboss.logmanager + log4j-jboss-logmanager + 1.2.0.Final + + + + org.jboss.slf4j + slf4j-jboss-logging + 1.2.1.Final + + + org.flywaydb + flyway-mysql + + + + + + + ${quarkus.platform.group-id} + quarkus-maven-plugin + ${quarkus.platform.version} + true + + + + build + generate-code + generate-code-tests + + + + + + maven-compiler-plugin + ${compiler-plugin.version} + + + -parameters + + + + + maven-surefire-plugin + ${surefire-plugin.version} + + + org.jboss.logmanager.LogManager + ${maven.home} + + + + + maven-failsafe-plugin + ${surefire-plugin.version} + + + + integration-test + verify + + + + ${project.build.directory}/${project.build.finalName}-runner + org.jboss.logmanager.LogManager + ${maven.home} + + + + + + + + + + native + + + native + + + + + + maven-failsafe-plugin + ${surefire-plugin.version} + + + + integration-test + verify + + + + ${project.build.directory}/${project.build.finalName}-runner + org.jboss.logmanager.LogManager + ${maven.home} + + + + + + + + + --initialize-at-run-time=org.apache.http.impl.auth.NTLMEngineImpl,-H:ReflectionConfigurationFiles=reflection-config.json,-H:IncludeResourceBundles=sun.util.resources.TimeZoneNames + false + native + + + + diff --git a/api/prometheus.yml b/api/prometheus.yml new file mode 100644 index 0000000..cbda3bd --- /dev/null +++ b/api/prometheus.yml @@ -0,0 +1,12 @@ +global: + scrape_interval: 15s + +scrape_configs: + - job_name: 'quarkus' + static_configs: + - targets: ['host.docker.internal:8080'] + metrics_path: '/q/metrics' + + - job_name: 'prometheus' + static_configs: + - targets: ['localhost:9090'] \ No newline at end of file diff --git a/api/promtail-config.yaml b/api/promtail-config.yaml new file mode 100644 index 0000000..77373da --- /dev/null +++ b/api/promtail-config.yaml @@ -0,0 +1,33 @@ +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: docker + static_configs: + - targets: + - localhost + labels: + job: docker-logs + __path__: /var/lib/docker/containers/*/*-json.log + pipeline_stages: + - json: + expressions: + output: log + stream: stream + - output: + source: output + + - job_name: system + static_configs: + - targets: + - localhost + labels: + job: system-logs + __path__: /var/log/*.log