Aller au contenu principal

TP 2

C'est la suite du prototype développé dans le TP 1, mais on va creuser uniquement la partie architecture.

Durée : 15 minutes

Contexte​

Le client réfléchit à restituer dans une interface web des documents issus de son socle big data pour des données RH (salaires, temps de travail, etc.) .

Les fonctionnalités attendues ne sont pas encore claires, le client sait que la demande va évoluer mais il veut une première version.

On vous demande de proposer une architecture logicielle qui réponde aux besoins du client et qui soit évolutive.

Le client prévoit ces évolutions à terme :

  • plusieurs types d'utilisateurs avec des habilitations différentes (responsable de départements, responsable de l'entreprise, etc.)
  • plusieurs types de données (Excel, JSON, CSV, etc.)
  • plusieurs protocoles d'accès aux données (NFS, S3, etc.)
  • plusieurs types de restitution : tableaux, graphiques, textes synthétiques via LLM

Contraintes​

Vous êtes libres d'utiliser l'interface / IDE de votre choix.

Il est recommandé d'utiliser un modèle avancé avec une capacité de réflexion.

Vous n'avez pas à fournir le code final.

Vous devez fournir une proposition d'architecture pour répondre au besoin sous forme d'un document qui respecte ce plan:

Est-ce un monolithe, des micro-services, de l'événementiel ?

Quels sont les langages et frameworks à utiliser (frontend / backend) ?

Quel est le socle technique à utiliser ? VM ? Docker ? Cloud ? Serverless ?

Etape 1​

Définir avec l'aide du modèle de bonnes contraintes d'architecture pour le logiciel.

Prendre en compte :

  • les fonctionnalités attendues et les contraintes d'évolutivité / industrialisation
  • vos orientation techniques
Indice

Utiliser en mode discursif ? Du metaprompting ? Du templating ?

Etape 2​

Utiliser vos échanges pour générer une architecture pour le projet.

Indice

Travailler en mode in-place ?

Solution​

Afficher

Document d'architecture : Application [Nom de l'Application]

1. Introduction​

Objectif du document :
Définir l'architecture technique de l'application [Nom de l'Application], basée sur les technologies Java, Angular, Docker, Kubernetes et AWS. Ce document vise à expliquer les choix techniques, les composants clés et la structure globale de l'infrastructure, tout en garantissant la sécurité, la scalabilité et la conformité aux normes de l'industrie.

Public cible :

  • Développeurs
  • Ingénieurs en DevOps
  • Architectes système
  • Équipes de sécurité

2. Choix techniques et justifications​

2.1 Langage backend : Java (Spring Boot)

  • Avantages :
    • Prise en charge native des API RESTful et GraphQL.
    • Intégration facile avec des bases de données relationnelles (ex : PostgreSQL).
    • Support des bonnes pratiques de conception (ex : injection de dépendances, SOLID).
  • Avantages par rapport à d'autres langages :
    • Adéquation avec les standards de l'industrie (ex : Java EE, Jakarta EE).
    • Ecosystème riche de bibliothèques et outils (ex : Spring Security, Spring Data JPA).

2.2 Frontend : Angular (v16+)

  • Avantages :
    • Performance optimisée via le moteur de rendu de Angular.
    • Gestion avancée des composants et des formulaires.
    • Intégration facile avec des services backend RESTful.
  • Avantages par rapport à d'autres frameworks :
    • Support des directives et des templates pour une UI dynamique.
    • Compilateur de code TypeScript pour le type-checking.

2.3 Conteneurisation : Docker

  • Avantages :
    • Isolation des dépendances et environnements.
    • Facilité de déploiement et de test.
    • Compatibilité avec les orchestrateurs (Kubernetes).
  • Avantages par rapport à d'autres outils :
    • Standardisation des environnements de développement et de production.
    • Gestion simplifiée des images et volumes.

2.4 Orchestration : Kubernetes (EKS)

  • Avantages :
    • Automatisation de la gestion des conteneurs (déploiements, scalabilité).
    • Surveillance et résilience (ex : auto-réplique des pods).
    • Gestion de services et de traçabilité (ex : Istio, Prometheus).
  • Avantages par rapport à d'autres systèmes :
    • Scalabilité horizontale pour les pics de charge.
    • Gestion des ressources (CPU, mémoire) avec des politiques de priorité.

2.5 Infrastructure cloud : AWS

  • Avantages :
    • Services complets (ex : EC2, RDS, S3, CloudFront).
    • Intégration native avec des outils de DevOps (ex : CodePipeline, CloudFormation).
    • Conformité aux normes (ex : ISO 27001, GDPR).
  • Avantages par rapport à d'autres fournisseurs :
    • Gestion des coûts via des groupes de réservation et des instances spot.
    • Support de la sécurité (ex : IAM, VPC, KMS).

3. Architecture système​

3.1 Composants clés

  • Backend :
    • Application Java Spring Boot avec API RESTful/GraphQL.
    • Base de données relationnelle (ex : PostgreSQL).
    • Services de sécurité (OAuth2, JWT, Spring Security).
  • Frontend :
    • Application Angular avec composants et services pour l'interface utilisateur.
    • Intégration avec le backend via des appels HTTP/HTTPS.

3.2 Déploiement

  • Docker :
    • Images conteneurisées pour backend et frontend.
    • Utilisation de Docker Compose pour les tests locaux.
  • Kubernetes (EKS) :
    • Déploiement de pods pour chaque service (ex : backend, frontend, base de données).
    • Services Kubernetes pour la communication inter-services.
    • Ingress pour le routage du trafic HTTP.
  • AWS :
    • Cluster EKS pour l'orchestration.
    • S3 pour le stockage de fichiers (ex : uploads).
    • RDS pour la base de données.
    • CloudFront pour le CDN des ressources statiques.

4. Intégration et communication​

4.1 Communication backend-frontend

  • Protocole : HTTP/HTTPS avec des appels RESTful ou GraphQL.
  • Gestion des erreurs :
    • Codes d'erreur HTTP (ex : 404, 500).
    • Messages d'erreur structurés (ex : JSON avec code et message).

4.2 Communication inter-services

  • API RESTful :
    • Utilisation de Swagger/Redoc pour la documentation.
    • Gestion des tokens JWT pour l'authentification.

5. Sécurité​

5.1 Authentification et autorisation

  • OAuth2 + JWT :
    • Authentification via des tokens signés.
    • Autorisation via des rôles (ex : Spring Security).
  • SSL/TLS :
    • Communication chiffrée entre les services et les clients.

5.2 Protection des données

  • Conformité :
    • Audit des accès via des logs (ex : CloudTrail).

5.3 Gestion des risques

  • IDS/IPS :
    • Surveillance des accès inauthentiques.
  • WAF (Web Application Firewall) :
    • Protection contre les attaques (ex : XSS, SQL injection).

6. Scalabilité et performance​

6.1 Scalabilité horizontale

  • Kubernetes :
    • Auto-scaling basé sur les métriques (CPU, mémoire).
    • Réplication des pods pour la haute disponibilité.
  • AWS :
    • Utilisation de groupes de réservation et de instances spot.

6.2 Optimisation de la performance

  • Caching :
    • Utilisation de Redis pour le stockage temporaire des données.

7. Opérations et maintenance​

7.1 Surveillance

  • Kubernetes :
    • Prometheus + Grafana pour la métrique.
    • Istio pour le monitoring des services.
  • AWS :
    • CloudWatch pour les logs et les métriques.
    • CloudTrail pour l'audit des accès.

7.2 Gestion des erreurs

  • Logs centralisés :
    • Utilisation de Elasticsearch + Kibana.
  • Backups :
    • Sauvegarde des fichiers uploadés (ex : S3).

7.3 CI/CD

  • Pipeline :
    • GitHub Actions pour la compilation, la test et le déploiement.
    • Tests unitaires et d'intégration (ex : JUnit, Cypress).
  • Versionnage :
    • Utilisation de Git tags et de Docker images taggées.

8. Synthèse des choix techniques et des avantages de l'architecture​

L'architecture proposée permet une délivrance rapide et sécurisée de l'application, avec une scalabilité optimale et une gestion des erreurs robuste. Elle s'adapte aux besoins de sécurité et de conformité, tout en offrant une expérience utilisateur fluide et performante.

Avantages clés :

  • Sécurité renforcée : Grâce à OAuth2, JWT, SSL/TLS et des normes de conformité.
  • Scalabilité : Kubernetes permet une expansion facile des ressources.
  • Performance : Optimisation des requêtes SQL, caching et gestion des ressources.
  • Gestion des erreurs : Surveillance active, logs centralisés et politiques de réplication.
  • Conformité : Respect des normes GDPR et ISO 27001 via AWS et des bonnes pratiques.

Conclusion :
Cette architecture assure une solution robuste, sécurisée et scalable, adaptée à un déploiement cloud via AWS, tout en facilitant la maintenance et la mise à jour continue.