LO3IN403 - Projet OPsci - S2-25

OpsCI_filmfinder — Docker + Kubernetes
Une application web entièrement conteneurisée avec un frontend, une API REST et PostgreSQL — orchestrée avec Docker Compose et Kubernetes (Minikube).

github.com/Gullaliko/OpsCI_filmfinder

Présentation:

OpsCI_filmfinder est une application web trois-tiers entièrement conteneurisée, conçue pour démontrer une approche DevOps moderne. Elle permet de consulter et rechercher des films via une API REST, le tout déployable localement avec Docker Compose ou sur un cluster Kubernetes via Minikube.

Objectifs du projet

Conteneuriser une application multi-services avec Docker
Orchestrer les déploiements avec Kubernetes (Minikube)
Mettre en place un pipeline CI/CD (GitLab CI & GitHub Actions)
Introduire l'event streaming avec Apache Kafka
Automatiser les opérations via scripts Bash et Makefile

Stack Technique

Composant	Technologie
Frontend	Nginx (HTML / JS / CSS)
Backend	Python — FastAPI (API REST)
Base de données	PostgreSQL 15
Messagerie	Apache Kafka + ZooKeeper
Conteneurisation	Docker + Docker Compose
Orchestration	Kubernetes — Minikube
CI/CD	GitLab CI/CD + GitHub Actions
Automatisation	Scripts Bash + Makefile + CRON

Justifications techniques

FastAPI — haute performance (ASGI), documentation automatique via /docs, syntaxe Python simple et productive.
Nginx — léger, idéal pour servir du contenu statique et jouer le rôle de reverse proxy.
PostgreSQL — fiable, robuste, adapté aux données structurées.
Kafka — introduction à l'event streaming et simulation d'architecture distribuée.

Architecture

┌─────────────────────────────────────────────┐
│            Cluster Kubernetes               │
│                                             │
│  ┌──────────────────┐  ┌─────────────────┐  │
│  │    Frontend      │  │    Backend      │  │
│  │   (Nginx:80)     │◄─┤  (FastAPI:8000) │  │
│  └──────────────────┘  └───────┬─────────┘  │
│                                │            │
│                                ▼            │
│                      ┌──────────────────┐   │
│                      │   PostgreSQL     │   │
│                      │    (5432)        │   │
│                      └──────────────────┘   │
└─────────────────────────────────────────────┘
        ▲                       ▲
   NodePort:80            ClusterIP:8000
        │                       │
   ┌────┴────┐           ┌──────┴──────┐
   │Navigateur│          │  /docs API  │
   └─────────┘           └─────────────┘

Services Kubernetes

Service	Type	Port	Rôle
frontend	NodePort	80	Interface web
backend	ClusterIP	8000	Serveur API
postgres-service	ClusterIP	5432	Base de données

Flux de données

JSON (movies.json) → Backend → PostgreSQL → API REST → Frontend

Structure du Projet

workplace@Gul-2 OpsCI_filmfinder % tree -L 3
.
├── Makefile
├── README.md
├── backend
│   ├── Dockerfile
│   ├── app
│   │   ├── config.py
│   │   ├── database.py
│   │   ├── kafka_init.py
│   │   ├── kafka_routes.py
│   │   ├── kafka_service.py
│   │   ├── main.py
│   │   └── services.py
│   ├── data/
│   ├── exports
│   └── requirements.txt
├── docker-compose.yml
├── docs
│   ├── CI-CD-integration_raport.md
│   ├── Conception_backend_frontend.md
│   ├── Database_Integration.md
│   ├── Dockerisation.md
│   ├── Kafka & Event.md
│   └── Kubernettes.md
├── frontend
│   ├── Dockerfile
│   ├── __tests__
│   │   └── app.test.js
│   ├── images/
│   ├── index.html
│   ├── nginx.conf
│   ├── package.json
│   ├── script.js
│   └── style.css
├── init.sql
├── k8s
│   ├── k8s-deploy.yaml
│   └── postgres-deploy.yaml
└── scripts
    ├── deploy
    │   ├── docker-deploy.sh
    │   └── k8s-deploy.sh
    ├── dev
    │   └── run.sh
    ├── test
    │   └── time-sender-test.sh
    └── utils
        ├── auto-sender.sh
        ├── cleanup.sh
        ├── parallel-sender.sh
        ├── sender-with-logs.sh
        └── time-sender.sh

Démarrage Rapide

1. Cloner le dépôt

git clone https://github.com/Gullaliko/OpsCI_filmfinder
cd OpsCI_filmfinder

2. Lancer via le menu interactif

make run

=============================================
      OpsCI FilmFinder
=============================================

1) Docker
2) Kubernetes
3) Status
4) Exit
Choice :

Option	Description
Docker	Build et lancement avec Docker Compose
Kubernetes	Déploiement sur le cluster Minikube
Status	Vérification des services en cours

Commandes Makefile disponibles

make run      # Lancer le mode développement interactif
make docker   # Démarrer avec Docker Compose
make k8s      # Déployer sur Kubernetes
make test     # Exécuter les tests
make status   # Afficher l'état du système
make logs     # Afficher les logs
make clean    # Nettoyage complet

URLs d'accès

Service	URL
Frontend	http://localhost:3000
API Backend	http://localhost:8000/movies
Swagger Docs	http://localhost:8000/docs

Déploiement Docker

Avec Docker Compose

# Construire et démarrer tous les services
docker-compose up --build

# Arrêter les services
docker-compose down

# Réinitialisation complète (supprime les volumes)
docker-compose down -v
docker system prune -a --volumes

Installation manuelle (sans Docker Compose)

# Créer le réseau partagé
docker network create films-net

# Backend
cd backend
docker build -t films-backend .
docker run -d --name backend --network films-net -p 8000:8000 films-backend

# Frontend
cd ../frontend
docker build -t films-frontend .
docker run -d --name frontend --network films-net -p 8080:80 films-frontend

Nettoyage Docker

docker stop $(docker ps -aq)
docker rm $(docker ps -aq)
docker volume rm opsci_filmfinder_postgres_data

Déploiement Kubernetes (Minikube)

Étape 1 — Démarrer Minikube

minikube start --driver=docker
minikube status

Étape 2 — Construire les images dans Minikube

eval $(minikube docker-env)

docker build -t filmfinder-backend:latest ./backend
docker build -t filmfinder-frontend:latest ./frontend

docker images | grep filmfinder   # vérification

Étape 3 — Déployer PostgreSQL

kubectl apply -f k8s/postgres-deploy.yaml
kubectl wait --for=condition=ready pod -l app=postgres --timeout=60s
kubectl get pods | grep postgres

Étape 4 — Déployer le backend et le frontend

kubectl apply -f k8s/k8s-deploy.yaml

kubectl set env deployment/backend \
  DATABASE_URL="postgresql://filmfinder:filmfinder123@postgres-service:5432/filmfinder"

kubectl delete pod -l app=backend   # redémarrage pour prendre en compte la variable

Étape 5 — Accéder à l'application

# Frontend
minikube service frontend
minikube service frontend --url

# Backend (terminal séparé)
kubectl port-forward deployment/backend 8000:8000
curl http://localhost:8000/movies

Script de déploiement automatisé

chmod +x scripts/deploy/k8s-deploy.sh
./scripts/deploy/k8s-deploy.sh

Le script prend en charge : démarrage de Minikube, construction des images, déploiement PostgreSQL, déploiement backend/frontend, configuration des variables d'environnement et vérification de l'état des pods.

Base de Données

Le projet utilise PostgreSQL comme base de données principale. Les données sont initialement chargées depuis backend/data/movies.json (30 films), puis insérées automatiquement dans PostgreSQL au démarrage.

Source de données contrôlée par variable d'environnement

Valeur	Mode
`DATA_SOURCE=json`	Prototype — données depuis `movies.json`
`DATA_SOURCE=db`	Production — données depuis PostgreSQL

Endpoints API

Endpoint	Description
`GET /movies`	Liste paginée des films
`GET /movies/{id}`	Détail d'un film
`GET /movies/{id}/similar`	Recommandations par réalisateur
`GET /movies/search?query=`	Recherche par titre

Kafka — Event Streaming

Kafka est intégré pour simuler une architecture orientée événements et gérer la communication asynchrone entre les services.

Composants

ZooKeeper (port 2181) — gestion des métadonnées et coordination du cluster
Kafka Broker (9093 interne / 9092 externe) — broker de messages
Producer — backend FastAPI publie des événements sur les topics
Consumers / Consumer Groups — traitement asynchrone des messages

Topics créés

film-events — événements liés aux appels API films
topic-1 / topic-2 — topics de test
reply-events — pattern Request/Reply (ACK)

Architecture Kafka

ZooKeeper (2181)
      ↓
Kafka Broker (9093 interne / 9092 externe)
      ↓
Backend Producer → Consumer Groups → reply-events (ACK)

Fichiers Kafka

Fichier	Rôle
`kafka_init.py`	Initialisation du broker
`kafka_service.py`	Logique métier
`kafka_routes.py`	Endpoints API Kafka

CI/CD — GitLab & GitHub Actions

Pipeline GitLab CI/CD

validate → test → build → deploy

Stage	Jobs
validate	`lint-backend` — analyse Flake8
test	`test-backend`, `test-frontend-files`, `unit-test` (Jest)
build	Construction des images Docker
deploy	Déploiement GitLab Pages (branche `main`)

Workflow Git

feature branch → développement → push → MR → CI/CD → merge

Branche main protégée — aucun push direct
Merge Request obligatoire avec validation des pipelines

GitHub Actions

Workflow couvrant : lint backend, build images Docker, exécution des tests, vérification de l'application.

Automatisation DevOps

Scripts Bash

Script	Catégorie	Description
`docker-deploy.sh`	deploy	Lancement via Docker Compose
`k8s-deploy.sh`	deploy	Déploiement Kubernetes complet
`run.sh`	dev	Mode développement local
`auto-sender.sh`	utils	Envoi continu aléatoire vers Kafka
`time-sender.sh`	utils	Envoi planifié à heure précise
`sender-with-logs.sh`	utils	Envoi Kafka avec horodatage et logs
`parallel-sender.sh`	utils	Envoi simultané multi-producteurs
`cleanup.sh`	utils	Nettoyage complet de l'environnement

Planification CRON

# Exécution quotidienne à 10h
0 10 * * * /bin/bash scripts/utils/time-sender.sh

# Exécution chaque minute (mode test)
* * * * * /bin/bash scripts/utils/auto-sender.sh

Variables d'Environnement

Backend

Variable	Valeur
`DATABASE_URL`	`postgresql://filmfinder:filmfinder123@postgres-service:5432/filmfinder`
`DATA_SOURCE`	`json` ou `db`

Base de données

Variable	Valeur
`POSTGRES_USER`	`filmfinder`
`POSTGRES_PASSWORD`	`filmfinder123`
`POSTGRES_DB`	`filmfinder`

Tests & Monitoring

Tester l'API

curl http://localhost:8000/movies
curl "http://localhost:8000/movies?page=1"
curl "http://localhost:8000/movies/search?query=matrix"
open http://localhost:8000/docs

Tester la base de données

kubectl exec -it deployment/postgres -- psql -U filmfinder -d filmfinder

# Dans psql :
SELECT COUNT(*) FROM movies;
SELECT * FROM movies LIMIT 5;
\q

Monitoring des pods

kubectl get pods
kubectl get pods -w          # temps réel
kubectl top pods             # consommation ressources
kubectl get services
minikube service list

Logs

kubectl logs -f deployment/backend
kubectl logs -l app=backend

Debugging

kubectl describe pod <nom-du-pod>
kubectl exec -it deployment/backend -- /bin/bash
kubectl get events

Résolution de Problèmes

`ImagePullBackOff`

Les images doivent être construites dans le daemon Docker de Minikube :

eval $(minikube docker-env)
docker images | grep filmfinder

# Reconstruire si absent :
docker build -t filmfinder-backend:latest ./backend
docker build -t filmfinder-frontend:latest ./frontend

Backend en crash

kubectl logs -l app=backend
kubectl exec -it deployment/postgres -- psql -U filmfinder -d filmfinder -c "\dt"

Images frontend non affichées

curl -I http://127.0.0.1:<PORT>/images/image_1.jpeg
kubectl exec deployment/frontend -- ls -la /usr/share/nginx/html/images/

Redémarrer les déploiements

kubectl rollout restart deployment/backend
kubectl rollout restart deployment/frontend
# Ou redémarrer tous les pods
kubectl delete pods --all

Limitations Connues

Pas de Kubernetes Secrets — le mot de passe de la base est en clair dans les manifests
Déploiement local uniquement — Minikube n'est pas adapté à la production
Base de données éphémère — les volumes emptyDir perdent les données au redémarrage du pod ; utiliser un PersistentVolume en production
Pas d'outil de monitoring — Prometheus/Grafana non intégrés

Nettoyage

Docker

docker-compose down -v
docker system prune -af
docker volume rm opsci_filmfinder_postgres_data

Kubernetes

kubectl delete -f k8s/postgres-deploy.yaml
kubectl delete -f k8s/k8s-deploy.yaml
# Ou tout supprimer dans le namespace
kubectl delete all --all

minikube stop
minikube delete   # optionnel — supprime le cluster entièrement

Documentation

La documentation détaillée est disponible dans le dossier /docs :

Fichier	Description
`Conception_backend_frontend.md`	TME2: Conception backend & frontend
`Database_Integration.md`	TME3: Intégration de la base de données
`CI-CD-integration_raport.md`	TME4: d'intégration CI/CD
`Dockerisation.md`	TME5/6: Configuration Docker
`Kubernettes.md`	TME7 de déploiement Kubernetes
`Kafka & Event.md`	TME10/11: Streaming d'événements Kafka
`RAPPORT.md`	Rapport complet du projet

FilmFinder — Projet DevOps OpsCI · Sorbonne Université · 2025–2026

Name		Name	Last commit message	Last commit date
Latest commit History 158 Commits
backend		backend
docs		docs
frontend		frontend
k8s		k8s
scripts		scripts
.gitignore		.gitignore
.gitlab-ci.yml		.gitlab-ci.yml
Makefile		Makefile
README.md		README.md
docker-compose.yml		docker-compose.yml
init.sql		init.sql

Folders and files

Latest commit

History

Repository files navigation

LO3IN403 - Projet OPsci - S2-25

Présentation:

Objectifs du projet

Stack Technique

Justifications techniques

Architecture

Services Kubernetes

Flux de données

Structure du Projet

Démarrage Rapide

1. Cloner le dépôt

2. Lancer via le menu interactif

Commandes Makefile disponibles

URLs d'accès

Déploiement Docker

Avec Docker Compose

Installation manuelle (sans Docker Compose)

Nettoyage Docker

Déploiement Kubernetes (Minikube)

Étape 1 — Démarrer Minikube

Étape 2 — Construire les images dans Minikube

Étape 3 — Déployer PostgreSQL

Étape 4 — Déployer le backend et le frontend

Étape 5 — Accéder à l'application

Script de déploiement automatisé

Base de Données

Source de données contrôlée par variable d'environnement

Endpoints API

Kafka — Event Streaming

Composants

Topics créés

Architecture Kafka

Fichiers Kafka

CI/CD — GitLab & GitHub Actions

Pipeline GitLab CI/CD

Workflow Git

GitHub Actions

Automatisation DevOps

Scripts Bash

Planification CRON

Variables d'Environnement

Backend

Base de données

Tests & Monitoring

Tester l'API

Tester la base de données

Monitoring des pods

Logs

Debugging

Résolution de Problèmes

ImagePullBackOff

Backend en crash

Images frontend non affichées

Redémarrer les déploiements

Limitations Connues

Nettoyage

Docker

Kubernetes

Documentation

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`ImagePullBackOff`

Packages