Skip to content
BranchesTags

Repository files navigation

Cloud-Design - Infrastructure de Microservices sur AWS

Vue d'ensemble

Ce projet déploie une application de microservices sur AWS en utilisant Terraform pour l'infrastructure as code. L'architecture comprend quatre services principaux :

  • API Gateway : Point d'entrée unique pour les requêtes clients
  • Service d'Inventaire : Gestion du catalogue de films avec base de données PostgreSQL
  • Service de Facturation : Traitement asynchrone des commandes avec RabbitMQ
  • Base de données : Deux bases PostgreSQL (inventaire et facturation)

Architecture

Architecture AWS

┌───────────────────┐    HTTPS/TLS    ┌───────────────────┐    HTTP/HTTPS   ┌───────────────────┐
│   Client Web   │───────────────────▼───────────────────│   Service API  │───────────────▼───────────────────│
│                │                 │   Amazon API Gateway    │                 │   Service Inventaire │
│                │                 │                         │                 │   (ECS/Fargate)      │
│                │                 │                         │                 │                      │
│                │                 │                         │                 │                      │
└───────────────────┘                 └───────────────────┘                 └───────────────────┘
                                     │                                                 │
                                     ▼                                                 ▼
                              ┌───────────────────┐                         ┌───────────────────┐
                              │   Application Facturation   │                         │   Base de données     │
                              │   (ECS/Fargate)             │                         │   Inventaire (RDS)    │
                              │                              │                         │                      │
                              │                              │                         │                      │
                              └───────────────────┘                         └───────────────────┘
                                     │                                                 │
                                     ▼                                                 ▼
                              ┌───────────────────┐                         ┌───────────────────┐
                              │   RabbitMQ (ElastiCache)     │                         │   Base de données     │
                              │                              │                         │   Facturation (RDS)   │
                              │                              │                         │                      │
                              │                              │                         │                      │
                              └───────────────────┘                         └───────────────────┘
                                     │                                                 │
                                     ▼                                                 ▼
                              ┌───────────────────┐                         ┌───────────────────┐
                              │   CloudWatch (Monitoring)     │                         │   CloudWatch Logs      │
                              │                              │                         │                      │
                              │                              │                         │                      │
                              └───────────────────┘                         └───────────────────┘

Réseau et Sécurité

  • VPC : Réseau privé isolé avec sous-réseaux publics et privés
  • Security Groups : Contrôle d'accès granulaire
  • ALB : Application Load Balancer pour le trafic externe
  • Private Subnets : Bases de données et services internes
  • Public Subnets : Services accessibles publiquement

Composants Techniques

Services AWS

  • ECS/Fargate : Exécution des conteneurs sans gestion de serveurs
  • RDS : Bases de données PostgreSQL gérées
  • ElastiCache : RabbitMQ pour la messagerie
  • CloudWatch : Monitoring et logging
  • Cognito : Authentification gérée
  • ACM : Certificats SSL/TLS
  • IAM : Gestion des permissions

Patterns Architecturaux

  • API Gateway : Point d'entrée unique avec routage intelligent
  • Circuit Breaker : Gestion des pannes de service
  • Async Processing : Traitement asynchrone des commandes
  • Database per Service : Chaque service a sa propre base
  • Event-Driven : Communication via messages RabbitMQ

Prérequis

Outils requis

  • AWS CLI : Version 2.x ou supérieure
  • Terraform : Version 1.5.x ou supérieure
  • Docker : Version 20.x ou supérieure
  • Git : Version 2.x ou supérieure

Configuration AWS

# Configurer AWS CLI
aws configure

# Vérifier la configuration
aws sts get-caller-identity

Déploiement

Étape 1: Cloner le dépôt

git clone https://github.com/aniasse/Cloud-Design.git
cd Cloud-Design

Étape 2: Configurer les variables

# Copier le fichier de variables d'exemple
cp variables.tf.example variables.tf

# Modifier les variables selon vos besoins
nano variables.tf

Étape 3: Construire les images Docker

# Construire l'image du service d'inventaire
./build-inventory.sh

# Construire l'image du service de facturation
./build-billing.sh

# Construire l'image de l'API Gateway
./build-api-gateway.sh

Étape 4: Déployer l'infrastructure

# Initialiser Terraform
./deploy.sh

# Choisir l'option 1 pour initialiser
# Choisir l'option 4 pour déployer

Étape 5: Configurer le DNS (optionnel)

# Configurer un domaine personnalisé
# Mettre à jour les enregistrements DNS
# Configurer ACM pour le certificat SSL

Utilisation

API Endpoints

Service Endpoint Description
API Gateway https://api.cloud-design.com Point d'entrée principal
Inventaire /api/movies Gestion du catalogue
Facturation /api/billing Traitement des commandes
Health /health Vérification de santé

Exemples de requêtes

# Créer un film
curl -X POST https://api.cloud-design.com/api/movies \
  -H "Content-Type: application/json" \
  -d '{"title": "The Matrix", "description": "Un hacker informatique..."}'

# Obtenir tous les films
curl https://api.cloud-design.com/api/movies

# Publier une commande de facturation
curl -X POST https://api.cloud-design.com/api/billing \
  -H "Content-Type: application/json" \
  -d '{"user_id": "usr_123", "number_of_items": 3, "total_amount": 99.97}'

Monitoring

  • CloudWatch Dashboard : Accéder via AWS Console
  • CloudWatch Logs : Groupes de logs centralisés
  • CloudWatch Alarms : Notifications d'alertes
  • CloudWatch Metrics : Métriques de performance

Sécurité

  • Cognito : Authentification gérée
  • IAM Roles : Permissions granulaires
  • Security Groups : Contrôle d'accès réseau
  • Encryption : Chiffrement au repos et en transit

Modules Terraform

Structure des modules

modules/
├── vpc/                    # Configuration du VPC
├── security-groups/        # Security Groups
├── ecr/                    # Registre Docker ECR
├── iam/                    # Rôles et permissions
├── rds/                    # Bases de données PostgreSQL
├── elasticache/            # Cache Redis/RabbitMQ
├── ecs/                    # Cluster ECS
├── ecs-service/            # Services ECS
├── alb/                    # Application Load Balancer
├── api-gateway/            # API Gateway
├── cloudwatch/             # Monitoring et logging
├── cognito/                # Authentification
└── acm/                    # Certificats SSL

Variables de configuration

Variables principales

Variable Description Type Défaut
aws_region Région AWS string eu-west-3
project_name Nom du projet string cloud-design
env Environnement string prod
vpc_cidr CIDR du VPC string 10.0.0.0/16

Variables des services

Variable Description Type Défaut
ecs_service_cpu CPU par tâche ECS number 256
ecs_service_memory Mémoire par tâche ECS number 512
rds_db_instance_class Classe d'instance RDS string db.t3.micro
elasticache_node_type Type de nœud ElastiCache string cache.t3.micro

Sécurité

Meilleures pratiques

  1. Zero Trust Network : Accès restreint par défaut
  2. Encryption : Chiffrement au repos et en transit
  3. Monitoring : Audit logging complet
  4. Backup : Stratégie de backup/restauration
  5. Compliance : GDPR, SOC 2, ISO 27001

Configuration de sécurité

  • VPC : Isolation réseau complète
  • Security Groups : Contrôle d'accès granulaire
  • IAM Roles : Permissions minimales
  • Cognito : Authentification forte
  • Encryption : KMS pour les données sensibles

Monitoring et Alerting

Métriques surveillées

  • ECS : CPU, mémoire, nombre d'instances
  • RDS : Connexions, requêtes, performances
  • ElastiCache : Hit ratio, latence, mémoire
  • API Gateway : Latence, taux d'erreur, trafic
  • ALB : Santé, trafic, erreurs

Alarmes configurées

  • High CPU : >80% pendant 10 minutes
  • High Memory : >80% pendant 10 minutes
  • Error Rate : >5% des requêtes
  • Latency : >500ms moyenne
  • Database Connection : >80% des connexions

Scalabilité

Auto Scaling

  • ECS : Scaling basé sur CPU/mémoire
  • RDS : Read replicas pour la lecture
  • ElastiCache : Clustering automatique
  • ALB : Load balancing intelligent

Patterns de scalabilité

  • Horizontal : Plus d'instances
  • Vertical : Plus de ressources par instance
  • Database : Read replicas, sharding
  • Cache : Distributed caching

Coûts

Estimation des coûts

  • ECS/Fargate : ~$0.04-0.10 par vCPU-heure
  • RDS PostgreSQL : ~$0.12-0.25 par heure
  • ElastiCache : ~$0.04-0.08 par heure
  • CloudWatch : ~$0.01-0.05 par million de métriques

Optimisation des coûts

  • Reserved Instances : Pour les charges stables
  • Spot Instances : Pour les charges variables
  • Auto Scaling : Scaling automatique
  • Monitoring : Identification des ressources inutilisées

Dépannage

Problèmes courants

  1. Permissions IAM : Vérifier les rôles et permissions
  2. Network Connectivity : Vérifier les Security Groups
  3. Database Connection : Vérifier les endpoints RDS
  4. Container Issues : Vérifier les logs CloudWatch
  5. Scaling Issues : Vérifier les configurations d'auto scaling

Commandes utiles

# Vérifier les logs des conteneurs
aws logs tail /aws/ecs/inventory-app --follow

# Vérifier l'état du cluster ECS
aws ecs describe-clusters --clusters cloud-design-cluster

# Vérifier les métriques CloudWatch
aws cloudwatch get-metric-statistics --namespace AWS/ECS --metric-name CPUUtilization

# Vérifier les Security Groups
aws ec2 describe-security-groups --filters Name=vpc-id,Values=vpc-xxxxxxxx

Maintenance

Tâches régulières

  • Backup : Planifier les backups des bases de données
  • Updates : Maintenir les images Docker à jour
  • Monitoring : Vérifier les alertes et métriques
  • Security : Appliquer les patchs de sécurité
  • Cost : Optimiser les ressources inutilisées

Procédures de maintenance

  1. Blue-Green Deployment : Déploiements sans interruption
  2. Canary Releases : Déploiements progressifs
  3. Rolling Updates : Mises à jour progressives
  4. Rollback : Procédures de retour arrière

Support

Documentation

  • README : Documentation principale
  • ARCHITECTURE : Documentation d'architecture
  • MODULES : Documentation des modules Terraform
  • API : Documentation des endpoints API

Ressources

  • AWS Documentation : Documentation officielle AWS
  • Terraform Docs : Documentation Terraform
  • GitHub Issues : Suivi des problèmes
  • Community : Support communautaire

Licence

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.

Contributions

Les contributions sont les bienvenues ! Veuillez lire les guidelines de contribution avant de soumettre une pull request.

Projet Cloud-Design - Infrastructure de microservices sur AWS avec Terraform et ECS

About

Infrastructure de microservices déployée sur AWS avec Terraform et ECS

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages