[MICROSERVICES] Files d'attente de messages et REST – Une approche avec Go, NodeJS et Clean Architecture

目錄

• 1.簡要背景
• 2.技術與總體架構
• 2.1。微服務架構
• 2.2。微服務之間的通信
• 2.2.1。訊息隊列（非同步通訊）
• 2.2.2。 REST API（同步通訊）
• 2.3。乾淨的架構
• 3.專案生態系統
• 4.挑戰與最終考慮因素
• 4.1。實施中的挑戰
• 4.2。下一步
• 4.3。結論
• 5.參考
• 6.免責聲明

1. 簡要背景

近年來，微服務架構已成為建立可擴展、靈活和可維護系統的熱門選擇。透過將應用程式劃分為更小的獨立服務，可以自主維護、測試和升級每個服務，從而促進可擴展性和新技術的融入。

在本文中，我們將探索使用 Go 和 NodeJS 這兩種廣泛使用的語言創建微服務架構，並且在這種情況下具有互補的特性。此外，我們將應用清潔架構的原則，這是一種旨在保持程式碼清潔、模組化且易於維護和測試的設計方法，確保業務邏輯與基礎設施問題和/或依賴項隔離。

這個計畫的目標是練習Go（我最近在學習的語言），並重新檢視微服務的基本概念。同時，我們將在服務開發中使用TypeScript，應用清潔架構的原則來強化良好的軟體設計實踐。

基於這些前提，我們將有機會探討這種方法的優點和挑戰。畢竟，並不是每個業務都需要如此複雜的結構，而實際的專案是了解其真正需求和影響的最佳方式。

2. 技術與總體架構

2.1 微服務架構

微服務架構將應用程式劃分為更小的、獨立的服務，每個服務負責功能的特定部分。這些服務透過定義明確的 API 進行通信，這有利於維護、可擴展性和新技術的採用。

好處：

模組化：方便各個服務的維護和獨立開發。
可擴展性：允許根據需求單獨擴展每個服務。
彈性：隔離故障並減少一項服務中的問題對其他服務的影響。
與整體式比較：

單體：整合到單一程式碼庫中的應用程式。雖然最初很簡單，但隨著時間的推移，它們可能會變得難以維護和擴展。

微服務：它們提供了更大的靈活性和可擴展性，但可能會增加服務之間的管理和通訊的複雜性。

2.2 微服務之間的通信

在微服務架構中，服務之間的通訊可以透過兩種主要方式完成：非同步通訊（例如使用訊息佇列）和同步通訊（透過 REST API）。值得強調的是，除了排隊和休息之外，還有其他形式的交流

2.2.1 訊息佇列（非同步通訊）

訊息佇列用於實現微服務之間的非同步通訊。它們允許服務發送和接收訊息而無需立即回應，這有助於提高系統的彈性和可擴展性。

訊息隊列的作用：

非同步通訊：促進服務之間的資訊交換，無需即時回應。
彈性：管理負載尖峰和臨時故障，確保訊息最終得到處理。

實作：

工具：RabbitMQ 和 Kafka 是管理訊息佇列的熱門選項。
整合：實作訊息佇列，用於 Go 和 NodeJS 編寫的服務之間的通信，確保高效且可擴展的資料交換。

2.2.2 REST API（同步通訊）

RESTful API 用於服務之間的同步通訊。它們基於 HTTP 原則，允許服務以標準化、高效的方式互動。

2.3 簡潔的架構

清潔架構是一種設計方法，旨在創建具有易於維護和/或測試的組織良好的程式碼庫的系統。它強調關注點分離和層獨立性。

清潔架構原則：

Séparation des couches : divisez le code en couches distinctes (domaine, application, infrastructure) pour isoler la logique métier des problèmes techniques.
Indépendance des frameworks et des bibliothèques : assurez-vous que la logique métier ne dépend pas de frameworks ou de technologies spécifiques.
Application en microservices :

Organisation du code : structurez chaque microservice selon les principes de l'architecture propre pour garantir un code modulaire, testable et facile à maintenir.
Maintenance et évolution : Facilitez l'ajout de nouvelles fonctionnalités et la modification de celles existantes sans compromettre l'intégrité du système.

3. L'écosystème du projet

Dans l'écosystème des microservices, un point de terminaison HTTP joue un rôle crucial dans l'orchestration du flux de travail documentaire, dans ce contexte, c'est là que tout commence. Ce point de terminaison est responsable de la réception et du traitement de la demande de création d'un nouveau document. Dès réception d'une demande, il met le document en file d'attente auprès du travailleur Go, qui se chargera de générer et de traiter le document. De plus, le point de terminaison émet une notification au service de documents via une file d'attente de messages, l'informant qu'une nouvelle ressource, c'est-à-dire un document, est entrée dans la file d'attente pour traitement. Cette approche garantit une intégration efficace entre les composants du système, permettant au point final de gérer la création et le suivi des documents de manière coordonnée et asynchrone, tandis que le travailleur Go s'occupe de la création réelle des documents et que le service documentaire est mis à jour sur les nouveaux éléments du système. file d'attente.

En plus du point de terminaison HTTP, le système dispose de deux travailleurs avec des rôles différents. Le premier, implémenté dans Go, se charge de générer les documents. Il consomme les tâches d'une file d'attente de messages, traite les données et, une fois le traitement terminé, informe un point final spécifique de l'achèvement. L'efficacité de Go garantit un traitement rapide et robuste. Le deuxième travailleur, développé en NodeJS, gère la création de l'état initial des documents, en les définissant comme « non traités » une fois insérés dans le système. L'agilité de NodeJS permet une gestion rapide et efficace des états des documents dès le début du workflow.

En résumé, le système décrit démontre un flux bien coordonné pour la gestion des documents. Le point de terminaison HTTP, associé aux Workers Go et NodeJS, fournit une solution intégrée et efficace, garantissant le traitement des documents de la création à la finalisation. L'interaction entre les travailleurs et REST se reflète dans l'image d'architecture ci-dessous, qui illustre comment l'architecture favorise l'évolutivité et la modularité, garantissant un flux de travail robuste et coordonné. Cette approche améliore non seulement l'efficacité opérationnelle, mais peut également être adaptée à différents scénarios d'utilisation, offrant flexibilité et croissance future.

Le dessin final :

Le référentiel du projet : https://github.com/williamMDsilva/microservice-poc

4. Défis et considérations finales

4.1 Défis liés à la mise en œuvre

La mise en œuvre d'une architecture de microservices avec Clean Architecture peut présenter plusieurs défis. L’un des principaux défis est une compréhension approfondie de l’entreprise afin de créer un code véritablement évolutif et préservant l’intégrité de la logique métier. L'architecture propre nécessite que le code soit structuré de manière à séparer clairement les préoccupations, ce qui nécessite une connaissance détaillée du domaine pour que les abstractions et les séparations soient efficaces.

De plus, la connaissance des principes SOLID est cruciale. Ces principes contribuent à créer un code plus cohérent et moins couplé, et une solide compréhension de ceux-ci peut permettre de gagner beaucoup de temps en recherche et en dépannage. L'application des principes SOLID améliore non seulement la qualité du code, mais facilite également la maintenance et l'évolutivité du système.

Dans le cas spécifique de Go, une base solide dans le langage peut améliorer la lisibilité et la maintenabilité du code. Go propose des outils et des pratiques qui aident à maintenir un code propre et efficace, et des connaissances plus approfondies peuvent faire la différence lors de la mise en œuvre de services complexes.

Schließlich kann die Verwendung einer guten Boilerplate äußerst vorteilhaft sein. Gut gestaltete Boilerplates für saubere Architektur beschleunigen nicht nur den Entwicklungsstart, sondern stellen auch sicher, dass neue Funktionen innerhalb des ursprünglich vorgeschlagenen Standards hinzugefügt werden. Sie bieten einen Rahmen, der dabei hilft, die Codekonsistenz und -qualität während des gesamten Projekts aufrechtzuerhalten.

4.2 Nächste Schritte

Um die beschriebene Architektur voranzutreiben und zu verbessern, werden einige nächste Schritte empfohlen:

1. Beziehen Sie Überwachungs- und Beobachtbarkeitsressourcen ein: Die Implementierung von Überwachungs- und Beobachtbarkeitstools ist für die Gewährleistung der Systemgesundheit und -leistung von entscheidender Bedeutung. Die Einbeziehung von Metriken, Protokollen und Ablaufverfolgung hilft, Probleme zu identifizieren und das Systemverhalten in der Produktion zu analysieren.

2. Behandlungen für Nichtverfügbarkeit hinzufügen: Es ist von entscheidender Bedeutung, Mechanismen zum Umgang mit Ausfällen und Nichtverfügbarkeit einzubeziehen, wie z. B. Wiederholungsversuche, Leistungsschalter und Fallback-Strategien, um die Belastbarkeit des Systems zu erhöhen und die Kontinuität der Dienste sicherzustellen.

3. Einheiten- und Integrationstests durchführen: Tests sind unerlässlich, um die Qualität des Codes und die korrekte Integration von Komponenten sicherzustellen. Unit-Tests überprüfen die Funktion isolierter Teile des Codes, während Integrationstests sicherstellen, dass die verschiedenen Komponenten des Systems korrekt zusammenarbeiten.

4. Refactor-Dienste und -Module: Die Überprüfung und Umgestaltung vorhandener Dienste und Module, um sicherzustellen, dass der Code sauber, lesbar und an den Clean Architecture-Prinzipien ausgerichtet bleibt, ist eine fortlaufende Aufgabe, die die Wartbarkeit und Skalierbarkeit des Systems verbessert.

5. Proof of Concept mit Kafka: Die Erwägung eines Proof of Concept zum Ersetzen von RabbitMQ durch Kafka kann Einblicke in die Auswirkungen verschiedener Tools auf das Projekt geben. Die Analyse der Auswirkungen auf das Servicedesign und die Gesamtarchitektur kann wertvolle Erkenntnisse für zukünftige Technologieentscheidungen liefern.

4.3 Fazit

Dieses Projekt demonstrierte die Wirksamkeit gut geplanter Architektur und die Bedeutung der sorgfältigen Umsetzung der Clean Architecture-Prinzipien. Die Verwendung von Go und NodeJS in Kombination mit Praktiken wie SOLID und der Verwendung von Nachrichtenwarteschlangen und REST-APIs trug zu einem robusten und skalierbaren System bei. Die Entwicklung und Wartung einer Microservices-Architektur stellt jedoch Herausforderungen dar, die fundierte Kenntnisse des Geschäfts und der Technologie erfordern. Die Bewältigung dieser Herausforderungen durch angemessene Planung und die Einführung bewährter Verfahren trägt dazu bei, den Aufbau effizienter und nachhaltiger Systeme sicherzustellen. Der Weg nach vorne beinhaltet die Integration kontinuierlicher Verbesserungen, wie z. B. fortschrittlicher Überwachung und neuer Konzeptnachweise, um die Architektur an die Geschäftsanforderungen und -entwicklung anzupassen.

5. Referenzen

Martin, R. C. (2008). Clean Code: Praktische agile Softwarefähigkeiten. Alta Books.

Martin, R. C. (2017). Saubere Architektur: Frameworks und Prinzipien für Software-Design. Alta Books.

RabbitMQ. (o.J.). Tutorial Zwei – JavaScript. Abgerufen von https://www.rabbitmq.com/tutorials/tutorial-two-javascript

RabbitMQ. (o.J.). Tutorial Zwei – Los. Abgerufen von https://www.rabbitmq.com/tutorials/tutorial-two-go

Haftungsausschluss

Aufgrund des akademischen Charakters und des Proof-of-Concept-Charakters dieses Projekts wurden einige Funktionen nicht implementiert und verbleiben als technische Schulden für zukünftige Studien. Bereiche wie automatisierte Tests, Fehlerbehandlung, Ressourcen-Streaming, Service-Authentifizierung und Beobachtbarkeit sind Themen, die noch erforscht werden müssen. Jede konstruktive Kritik ist willkommen und erwünscht, da sie zur kontinuierlichen Verbesserung und Vertiefung des Wissens in diesen wichtigen Bereichen beiträgt.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!