Les microservices divisent le système en petits services indépendants. Pour les applications mobiles, cela signifie des API évolutives et évolutives. Ce guide présente comment implémenter et exploiter les microservices pour les applications.
Que sont les microservices
Définition
Architecture où l'application est composée de petits services indépendants.
Fonctionnalités
- Indépendance de déploiement
- Seul responsable du domaine -Communication via réseau
- Peut avoir différentes technologies
Différence monolithique
Monolithe : tous ensemble. Microservices : séparés par responsabilité.
Avantages
Évolutivité indépendante
Chaque service évolue en fonction de la demande.
Déploiement indépendant
La mise à jour de l’un n’affecte pas les autres.
Résilience
En échouer un ne fait pas tout tomber.
Technologies multiples
Utilisez le meilleur outil pour chaque tâche.
Équipes indépendantes
Propriété claire, moins de dépendances.
Inconvénients
Complexité opérationnelle
Plus de pièces à gérer.
Latence du réseau
La communication entre les services ajoute de la latence.
Débogage dur
Suivez les problèmes dans tous les services.
Cohérence des données
Les transactions distribuées sont complexes.
Frais généraux
Pour les petits systèmes, cela peut être trop.
Quand l'utiliser
Bon pour
- Grandes équipes
- Domaines complexes
- Nécessité d'une échelle indépendante
- Evolutions fréquentes
Éviter
- Petites équipes
- MVP
- Domaines simples
Décomposition
Par domaine
Contextes DDD limités.
Par fonctionnalité
Authentification, paiements, catalogue, etc.
Par cas d'utilisation
Flux d'utilisateurs indépendants.
Passerelle API
Fonction
Point d'entrée unique pour les clients.
Responsabilités
Routage, authentification, limitation de débit, agrégation.
Outils
Kong, passerelle API AWS, Nginx.
BFF (Backend pour Frontend)
###Concept
Passerelle spécifique au type de client.
Utilisation
BFF pour mobile, un autre pour le web.
Avantages
Optimisé pour chaque client.
##Communication
Synchrone
REPOS, gRPC. Demande/réponse.
Asynchrone
Files d'attente de messages. Événements.
Compromis
Le synchrone est simple, l’asynchrone est résilient.
Découverte de services
Problème
Comment les services se retrouvent-ils ?
###Solutions
Consul, Kubernetes DNS, AWS Cloud Map.
Observabilité
Journalisation
Journaux centralisés avec ID de corrélation.
Traçage
Traçage distribué avec Jaeger, X-Ray.
Métriques
Par service et agrégat.
Résilience
Disjoncteur
Arrêtez d'appeler le service défaillant.
Réessayer
Réessayez avec recul.
Délai d'expiration
N'attendez pas éternellement.
###Clôture
Isoler les ressources.
Gestion des données
Base de données par service
Chaque service avec sa banque.
Cohérence éventuelle
Transactions distribuées évitées.
Événements
Communiquer les changements via des événements.
Sagas
Transactions longues via clearing.
Déploiement
Conteneurs
Docker pour encapsuler les services.
###Orchestration
Kubernetes à gérer.
### CI/CD
Pipeline par service.
Bleu-Vert/Canari
Déploiements sécurisés.
Pour mobile
API optimisée
Moins d'appels, données agrégées.
###Cache
Mise en cache CDN et API.
###Hors ligne
Résilience en cas de panne du réseau.
Gestion des versions
API versionnées pour la compatibilité.
Tests
###Unité
Pour le service.
Intégration
Communication entre services.
###Contrat
Le consommateur et le fournisseur conviennent du contrat.
De bout en bout
Des flux complets via les services.
Migration
Modèle d'étrangleur
Remplace progressivement monolithe.
Commencez petit
Commencez par un service.
###Extrait
Identifiez des domaines bien définis.
Erreurs courantes
Distribution prématurée
Microservices avant d’en avoir besoin.
Nano-services
Services trop petits.
Aucune observabilité
Impossible à déboguer.
Ignorer la latence
Plusieurs appels réseau.
Conclusion
Les microservices offrent évolutivité et flexibilité, mais avec complexité. Évaluez si nécessaire votre contexte, investissez dans l’observabilité et opérez avec discipline. Pour les applications mobiles, concentrez-vous sur les API optimisées et la résilience.
##FAQ
1) Ai-je besoin de Kubernetes pour les microservices ? Pas nécessairement. Mais cela aide beaucoup à grande échelle.
2) Combien de services, c'est trop ? Il n’y a pas de chiffre magique. Si l’équipe n’y parvient pas, c’est trop.
3) Le mobile doit appeler directement microservices ? Généralement non. Utilisez API Gateway ou BFF.
4) Les microservices sont-ils toujours meilleurs ? Non. Un monolithe bien conçu peut être meilleur dans de nombreux cas.
5) Comment démarrer avec les microservices ? Démarrez monolithe modulaire. Extraire si nécessaire.
A lire aussi
-Backend pour les applications : architecture, technologies et bonnes pratiques
- Monolith vs Microservices : quelle architecture choisir
- Architecture logicielle évolutive : Comment créer des systèmes qui se développent
- Architecture logicielle évolutive - Meilleures pratiques de mise à l'échelle -Architecture logicielle évolutive - Meilleures pratiques pour les startups -Architecture logicielle évolutive - Meilleures pratiques pour les petites équipes