• Vous pouvez consulter un aperçu du contenu du livre.
  Aperçu

Chapitre 0.
introduction

0.1 Structure de ce livre
0.2 Public cible de ce livre
0.3 Prérequis
0.4 Démarrage rapide
0.5 Remerciements
Site web 0.6

Chapitre 1.
Microservices

1.1 Microservices : Définition
1.2 Pourquoi utiliser des microservices ?
1.3 Défis
1.4 Variante
1.5 Conclusion

Chapitre 2.
Microarchitecture et macroarchitecture

2.1 Contexte délimité et conception stratégique
2.2 Architecture technique micro et macro
2.3 Fonctionnement : Microarchitecture ou Macroarchitecture
2.4 Privilégiez la microarchitecture !
2.5 Aspects organisationnels
2.6 Principes d'architecture système indépendante
2.7 Variante
2.7 Conclusion

Chapitre 3.
Migration

3.1 Raisons de la migration
3.2 Stratégies générales de migration
3.3 Stratégies alternatives
3.4 Construire, exploiter et organiser
3.5 Variante
3.6 Conclusion

Chapitre 4.
Docker

4.1 Pourquoi utiliser Docker dans les microservices ?
4.2 Notions de base de Docker
4.3 Installation de Docker et commandes Docker
4.4 Installation d'un hôte Docker avec Docker Machine
4.5 Dockerfile
4.6 Docker Compose
4.7 Variante
4.8 Conclusion

Chapitre 5.
La microarchitecture d'un point de vue technique

5.1 Exigences
5.2 Réactif
5.3 Spring Boot
5.4 Go
Variante 5.5
5.6 Conclusion

Chapitre 6.
système indépendant

6.1 Fondements des systèmes indépendants
6.2 Définition
6.3 Exemple
6.4 SCS et microservices
6.5 Défis
6.6 Avantages
6.7 Variante
6.8 Conclusion

Chapitre 7.
Concept : Intégration front-end

7.1 Interface utilisateur : monolithique ou modulaire
7.2 Options
7.3 Architecture client orientée ressources
Défi 7.4
7.5 Avantages
7.6 Variante
7.7 Conclusion

Chapitre 8.
Recette : Intégration des liens et des clients

8.1 Vue d'ensemble
8.2 Exemple
8.3 Variante
8.4 Expérience
8.5 Conclusion

Chapitre 9.
Recette : Intégration côté serveur avec ESI

9.1 ESI : Concept
9.2 Exemple
9.3 Vernis
9.4 Variantes de recettes
9.5 Expérience
9.6 Conclusion

Chapitre 10.
Concept : Microservices asynchrones

10.1 Définition
10.2 Événement
10.3 Défis
10.4 Avantages
Variante 10.5
10.6 Conclusion

Chapitre 11.
Recette : Messagerie et Kafka

11.1 Intergiciel orienté messages
11.2 L'architecture de Kafka
11.3 Événements Kafka
11.4 Exemple
11.5 Variantes de recettes
11.6 Expérience
11.7 Conclusion

Chapitre 12.
Recette : Communication asynchrone avec Atom et REST

12.1 Format Atom
12.2 Exemple
12.3 Variantes de recettes
12.4 Expérience
12.5 Conclusion

Chapitre 13.
Concept : Microservices synchrones

13.1 Définition
13.2 Avantages
13.3 Défis
13.4 Variante
13.5 Conclusion

Chapitre 14.
Recette : REPOS Inspiré de la pile Netflix

14.1 Exemple
14.2 Eurêka : Exploration des services
14.3 Routeur : Joule
14.4 Équilibrage de charge : Ripbone
14.5 Résilience : Hystrix
14.6 Variantes de recettes
14.7 Expérience
14.8 Conclusion

Chapitre 15.
Recette : Serveur REST et Apache httpd avec Consul

15.1 Exemple
15.2 Exploration des services : Conseil
15.3 Routage : Serveur Apache httpd
15.4 Consulter le modèle
15.5 Consult et Spring Boot
15.6 DNS et bureaux d'enregistrement
15.7 Variantes de recettes
15.8 Expérience
15.9 Conclusion

Chapitre 16.
Concept : Plateforme de microservices

16.1 Définition
16.2 Variante
16.3 Conclusion

Chapitre 17.
Recette : Kubernetes et conteneurs Docker

17.1 Kubernetes
17.2 Exemple Kubernetes
17.3 Exemples détaillés
17.4 Fonctionnalités Kubernetes supplémentaires
17.5 Variantes de recettes
17.6 Variante
17.7 Conclusion

Chapitre 18.
Recette : PaaS de Cloud Foundry

18.1 PaaS : Définition
18.2 Cloud Foundry
18.3 Exemple Cloud Foundry
18.4 Variantes de recettes
18.5 Expérience
18.6 Sans serveur
18.7 Conclusion

Chapitre 19.
Concept : Opération

19.1 Pourquoi les opérations sont importantes
19.2 Approches d'exploitation des microservices
19.3 L'efficacité de la technologie examinée
19.4 Conclusion

Chapitre 20.
Recette : Surveillance avec Prometheus

20.1 Contenu de base
20.2 Métriques pour les microservices
20.3 Statistiques Prometheus
20.4 Exemple de Prométhée
20.5 Variantes de recettes
20.6 Expérience
20.7 Conclusion

Chapitre 21.
Recette : Analyse des journaux avec Elastic Stack

21.1 Contenu de base
21.2 Stockage des journaux à l'aide d'Elastic Stack
21.3 Exemple
21.4 Variantes de recettes
Expérience 21.5
21.6 Conclusion

Chapitre 22.
Recette : Suivi avec Zipkin

22.1 Notions de base
22.2 Suivi avec Zipkin
22.3 Exemple
22.4 Variantes de recettes
22.5 Conclusion

Chapitre 23.
Recette : Service Mesh, Istio

23.1 Qu'est-ce qu'un maillage de services ?
23.2 Exemple
23.3 Fonctionnement d'Istio
23.4 Surveillance avec Prometheus et Grafana
23.5 Suivi avec Jagger
23.6 Enregistrement
23.7 Résilience
23.8 Défis
23.9 Avantages
Variante 23.10
Expérience 23.11
23.12 Conclusion

Chapitre 24.
organiser

Annexe A.
Installation environnementale
Annexe B.
Commande Maven
Annexe C.
Commandes Docker et Docker Compose

* Public cible de ce livre *

Il expliquera les principes fondamentaux et les aspects techniques des microservices, ce qui le rendra intéressant pour un large public.

■ Développeurs : La partie 2 sera utile car elle fournit des indications pour choisir la pile technologique appropriée.
Les exemples de projets fournis servent de base à l'apprentissage des principes fondamentaux de cette technologie.
Les microservices inclus dans l'exemple de projet sont écrits en Java à l'aide du framework Spring.
Cependant, la technologie utilisée dans cet exemple intègre des microservices.
Par conséquent, des microservices supplémentaires peuvent être écrits dans d'autres langages.
La troisième partie aborde des sujets opérationnels que les développeurs jugent de plus en plus importants à l'avenir.
La première partie explique les principes de base des concepts architecturaux.

■ Architecte : La partie 1 fournit des connaissances de base sur les microservices.
Les parties 2 et 3 seront utiles, car elles présentent des recettes et des techniques pratiques pour mettre en œuvre une architecture de microservices.
Veuillez noter que le sujet des microservices se concentre sur l'architecte mais n'entre pas dans les détails techniques.


■ Professionnels DevOps et des opérations : les recettes de la partie 3 seront utiles car elles fournissent une base solide pour l’évaluation technique des aspects opérationnels tels que l’analyse des journaux, la surveillance et le traçage des microservices.
La deuxième partie présente les technologies de déploiement telles que Docker, Kubernetes et Cloud Foundry, et explique également comment résoudre certains problèmes opérationnels.
La première partie explique le contexte de l'approche architecturale des microservices.

■ Administrateur : Présente partiellement les avantages et les défis spécifiques de l’approche architecturale des microservices.
Si les détails techniques vous intéressent, je vous recommande de lire les parties 2 et 3.

Il est supposé que le lecteur possède des connaissances de base en architecture logicielle et en développement logiciel.
La plupart des exemples de ce livre sont documentés de manière à pouvoir être exécutés sans connaissances préalables.
Et nous nous concentrons sur les technologies qui peuvent être utilisées pour les microservices utilisant différents langages de programmation.
Cependant, cet exemple est écrit en Java et utilise les frameworks Spring Boot et Spring Cloud.

* Structure de ce livre *

Partie 1 - Principes fondamentaux de l'architecture
La première partie présente les principes de base de l'architecture basée sur les microservices.
■ Le chapitre 1 définit le terme microservices.
■ L’architecture de microservices comporte deux niveaux : la microarchitecture et la macroarchitecture.
Elle représente des décisions globales et locales.
Le chapitre 2 explique cela.

■ Il est parfois nécessaire de migrer les systèmes existants vers des microservices.
Nous aborderons la migration au chapitre 3.

Partie 2 - Pile technologique
La deuxième partie est consacrée à la pile technologique.
■ Docker est la technologie de base de nombreuses architectures de microservices.
Il facilite également le déploiement des logiciels et l'exploitation des services.
Ceci est expliqué au chapitre 4.

■ Le chapitre 5 décrit les technologies qui peuvent être utilisées lors de la mise en œuvre de microservices.
■ Le chapitre 6 décrit les systèmes autonomes (SCS), une approche particulièrement utile pour les microservices. Les SCS se concentrent sur les microservices qui contiennent à la fois une logique et une interface utilisateur.
■ L'intégration du front-end web est une possibilité offerte par l'intégration dans SCS.
L'intégration frontale réduit le couplage entre les microservices et offre un haut degré de flexibilité.
Pour plus de détails, veuillez consulter le chapitre 7.
■ La recette d'intégration front-end web présentée au chapitre 8 utilise des liens et JavaScript pour le chargement dynamique du contenu.
Cette méthode d'intégration est facile à mettre en œuvre et utilise des technologies web bien conçues.
■ Les serveurs peuvent être intégrés à l'aide d'Edge Side Includes (ESI). L'ESI est implémentée dans les caches Web afin de garantir des performances et une fiabilité élevées du système.
Ceci est expliqué au chapitre 9.
■ Le concept de communication asynchrone est abordé au chapitre 10.
La communication asynchrone améliore la fiabilité et réduit le couplage au sein du système.
■ Le chapitre 11 présente Apache Kafka.
Apache Kafka est un exemple de technologie asynchrone pour l'envoi de messages.
Kafka permet de stocker les messages de manière persistante et offre diverses approches pour le traitement asynchrone.
■ Le chapitre 12 explique Atom comme une alternative à la communication asynchrone.
Atom utilise l'infrastructure REST et est très facile à mettre en œuvre et à exploiter.
■ Le chapitre 13 explique comment mettre en œuvre le concept de microservices synchrones.
Bien que les méthodes de communication synchrone puissent poser des problèmes en termes de temps de réponse et de fiabilité, la communication synchrone entre microservices est souvent utilisée en pratique.
■ La pile Netflix, qui sera présentée au chapitre 14, fournit non seulement Eureka pour la découverte de services, mais aussi Ribbon pour l'équilibrage de charge, Hystrix pour la résilience et Zuul pour le routage.
La suite Netflix est particulièrement populaire dans la communauté Java.
■ Consul, qui sera présenté au chapitre 15, est l'une des alternatives de découverte de services.
La console possède de nombreuses fonctionnalités et peut être utilisée avec diverses technologies.
■ Le chapitre 16 explique le concept de plateforme de microservices qui prend en charge le fonctionnement et la communication des microservices.
■ Kubernetes, présenté au chapitre 17, est une plateforme de microservices qui peut exécuter des conteneurs Docker et fournit également des solutions pour la découverte de services et l'équilibrage de charge.
Les microservices sont indépendants de Kubernetes.
■ Chapitre 18 PaaS (Platform as a Service) est une autre plateforme de microservices.
Prenons Cloud Foundry comme exemple.
Cloud Foundry est extrêmement flexible et peut fonctionner aussi bien sur des clouds publics que sur des centres de calcul appartenant à l'entreprise.

Partie 3 - Opérations
Exploiter un grand nombre de microservices de manière sécurisée représente un défi majeur.
La troisième partie aborde les moyens de remédier à ce problème.
■ Le chapitre 19 explique les principes de base du fonctionnement et pourquoi l'exploitation des microservices est difficile.
■ Le chapitre 20 traite de la surveillance et présente l'outil Prometheus.
Prometheus prend en charge les structures de données multidimensionnelles et peut analyser les métriques provenant de nombreuses instances de microservices.
■ Le chapitre 21 est consacré à l'analyse des données de journalisation.
Décrit Elastic Stack comme un outil d'analyse de données.
La suite Elastic est très populaire et constitue une bonne base pour l'analyse de grandes quantités de données de journalisation.
■ Le chapitre 22 utilise Zipkin, une technologie de traçage qui trace les appels entre les microservices.
Zipkin prend en charge un large éventail de plateformes et constitue la norme de facto en matière de suivi.
■ La technologie de maillage de services ajoute un proxy au trafic réseau entre les microservices.
Les proxys prennent en charge la surveillance, l'analyse des journaux, le traçage et d'autres fonctionnalités de résilience et de sécurité.
Le chapitre 23 explique Istio comme exemple de maillage de services.

Conclusion et annexe
Dans le dernier chapitre, le chapitre 24, nous examinons l'avenir des microservices.
L'annexe A explique comment installer le logiciel, l'annexe B explique comment exécuter l'environnement d'exemple à l'aide de l'outil de construction Maven et l'annexe C explique comment exécuter l'environnement d'exemple à l'aide de Docker et Docker Compose.

* Note de l'auteur *

Les microservices constituent l'une des tendances les plus importantes en matière d'architecture logicielle de ces dernières années.
Bien qu'il existe déjà de nombreux livres et documents expliquant les microservices, j'ai publié un livre sur ce sujet.
Pourquoi avons-nous besoin d'un livre sur les microservices ?

Définir une architecture spécifique et implémenter cette architecture sont deux choses différentes.
Cet ouvrage présente des techniques de mise en œuvre des microservices et met en lumière leurs avantages et inconvénients respectifs.

Ce livre se concentre spécifiquement sur la technologie globale des systèmes de microservices.
Chaque microservice peut être implémenté à l'aide de technologies différentes.
Ainsi, la décision technique relative au choix d'un framework pour un microservice individuel n'est pas aussi importante que la décision prise au niveau du système global.
Pour chaque microservice individuel, les décisions relatives au framework peuvent être facilement modifiées.
Cependant, la technologie appliquée à l'ensemble du système est difficile à modifier.

Comparé à d'autres ouvrages sur les microservices, celui-ci traite principalement de la technologie, expliquant brièvement l'architecture des microservices et les raisons de leur utilisation.

Chaque recette est accompagnée d'un exemple pratique basé sur une technique spécifique.
Les exemples peuvent être exécutés individuellement.
Les exemples sont indépendants les uns des autres ; vous pouvez donc ignorer ceux qui ne sont pas pertinents pour votre travail et consulter uniquement les exemples qui vous seront utiles.

Cette approche offre aux lecteurs un moyen facile d'obtenir une vue d'ensemble des technologies pertinentes et de choisir la pile technologique qui leur convient.
Les liens fournis dans le livre permettent d'acquérir des connaissances approfondies sur les technologies connexes.

*Note du traducteur*

Chez Alticast, ma première entreprise, j'ai participé au développement de logiciels intermédiaires pour décodeurs.
Le middleware crée un seul fichier binaire composé de divers modules, dont une couche de portage qui relie les interfaces du système d'exploitation ou du fournisseur de matériel, une JVM, une couche de gestion d'applications, une couche de communication et une couche de gestion des informations de service, puis le stocke dans la mémoire flash ROM du matériel pour exécuter des applications Java sur le décodeur.
Il s'agissait d'une structure monolithique, et nous avons visé une forte cohésion et un faible couplage pour chaque module, et nous avons augmenté la productivité en assignant une personne responsable de chaque module.
L'inconvénient était que même un seul problème pouvait dégrader la qualité globale.

Durant mon séjour chez NHN, j'ai expérimenté, développé et exploité les plateformes Naver et Hangame d'une manière similaire à une architecture de microservices (MSA).
Nous avons également utilisé nos propres IDL pour nos services, tels que l'épargne.
Nous avons donc construit un serveur API pour chaque service et l'avons exploité de manière organique et interconnectée.
J'y ai également participé et j'ai développé un module commun avec mes collègues.

Cependant, avec autant de nœuds de serveur, il arrive que des paquets soient perdus et il devient difficile de localiser l'origine du problème.
Avec la diminution progressive du nombre de personnes, l'exploitation des modules ou des services est devenue difficile, et une architecture monolithique utilisant Spring a été privilégiée.
Les coûts de communication des systèmes autonomes, leurs performances relativement faibles, leurs protocoles complexes, les pertes de paquets inexpliquées et le manque de personnel de maintenance ont conduit à une accélération du recours aux architectures monolithiques.

Dans une architecture monolithique, un seul langage est utilisé et un référentiel de code est partagé.
Il est donc facile d'identifier le problème et le coût de communication est quasi nul.
La communication entre les modules internes se fait par appels, et les protocoles ne sont utilisés que pour la communication externe, ce qui la rend simple et efficace.
Par conséquent, elle devient une structure qui peut être gérée par un petit nombre de développeurs car les problèmes y sont plus faciles à résoudre.
Cependant, cela présente l'inconvénient de réduire la liberté du développeur et d'allonger les délais de maintenance et de déploiement du code en raison de sa complexité croissante (faible couplage des modules).

Aujourd'hui, l'architecture de microservices fait son grand retour grâce à des tendances telles que SOA (architecture orientée services), Agile, DDD (conception pilotée par le domaine), la renaissance des langages fonctionnels, le cloud, Apache Kafka, Polyglot, DevOps et les technologies Docker (Kubernetes, Istio).

Avec l'émergence de nombreuses fonctionnalités telles que Docker, les technologies de communication asynchrone, les disjoncteurs, le traçage, la découverte de services et les maillages de services qui peuvent surmonter les lacunes de l'architecture de microservices, et la publication continue d'outils DevOps open source, le développement et les opérations deviennent plus faciles.
Aujourd'hui, le développement et l'exploitation d'entreprises complexes comme Netflix et Amazon à l'aide d'une architecture de microservices sont en passe de devenir une réussite.

Parallèlement, il existe des cas, comme celui de Segment, où les lacunes de l'architecture de microservices étaient trop nombreuses et où l'entreprise est revenue à l'architecture monolithique (http://www.ciokorea.com/news/39258).
De nombreux inconvénients peuvent survenir, comme l'impossibilité de savoir quel projet se trouve dans quel dépôt de code en raison du grand nombre de services, la dispersion de code similaire due à la diversité des langages utilisés dans les microservices et à l'implémentation du même code dans chacun d'eux, et l'incapacité à gérer parfaitement les bibliothèques pour de nombreux services connexes lors de la mise à niveau de bibliothèques de code similaires.

La traduction de ce livre m'a amenée à repenser l'essence même du logiciel.
Nous avons également appris que, quelle que soit l'architecture (monolithique ou microservices), la stratégie relative aux modules, aux personnes et aux politiques est cruciale.
Le passage d'une architecture monolithique à une architecture de microservices nécessite une réflexion approfondie et une approche stratégique, car il modifie complètement l'architecture du système.
Ce livre explique très bien les stratégies et les technologies des microservices.
Si l'on y regarde de plus près, chaque équipe de développement possède l'autorité et la responsabilité appropriées en tant que dirigeant d'un gouvernement local, tout comme dans un pays doté d'un système décentralisé.
Par conséquent, le simple fait de développer des microservices en utilisant n'importe quel langage choisi par l'équipe de développement sans tenir compte de la direction n'est pas conforme à ce principe.
De même que nous respectons l'autorité d'un chef d'État, nos équipes de développement doivent respecter et suivre les politiques relatives à l'architecture de microservices.

Ce livre ne se contente pas de lister les architectures de microservices et les différentes technologies.
Il met en lumière ce que sont les modules logiciels et quelles sont les parties importantes d'une architecture de microservices.
Nous expliquerons ensuite les outils présentés ci-dessus à l'aide d'exemples basés sur Spring Framework, Docker et Docker Compose.

Ce livre est une excellente ressource pour les développeurs, les architectes, les spécialistes DevOps et les administrateurs.
Ce livre sera très utile car il présente les excellentes techniques et les préoccupations que le traducteur a récemment utilisées.