Introduction to Microservices Architecture

Introduction to Microservices Architecture

This Introduction to Microservices Architecture training course will help the attendees understand the value proposition and technical aspects of microservices. You will learn about the pros and cons of breaking up the monolithic type of applications prevalent in the enterprise space and converting them into microservices-based solutions. Details analysis of some of the common patterns and motivation for using them in microservices architecture is also provided.

Benefits

• Understand and work with monoliths.
• Learn to design, develop, and integrate microservices.
• Learn common design patterns.

Outline

1. Breaking Up Monoliths – Pros and Cons
2. Traditional Monolithic Applications and Their Place
3. Disadvantages of Monoliths
4. Developer's Woes
5. Architecture Modernization
6. Architecture Modernization Challenges
7. Microservices Architecture is Not a Silver Bullet!
8. What May Help?
9. In-Class Discussion
10. Summary
11. Microservices
12. What is a "Microservice"?
13. Unix Analogy
14. Principles of Microservices
15. Services within an SOA vs Microservices
16. Properties and Attributes of Microservices
17. Benefits of Using Microservices
18. The Two-Pizza Teams
19. Beware of Microservices Cons
20. Anti-Pattern: Nanoservices
21. The Twelve-Factor App Methodology
22. The Select Factors
23. Serverless Computing
24. Microservices – Operational Aspects
25. Summary
26. Microservices Architecture Defined
27. The Microservices Architecture
28. SOA Promises and Expectations
29. Microservices Architecture vs SOA
30. The ESB Connection
31. Microservices Architecture Benefits
32. Microservices Architecture Choices and Attributes
33. Example: On-Line Banking Solution Based on MsA
34. Distributed Computing Challenges
35. Replaceable Component Architecture
36. The Actor Model
37. MapReduce Distributed Computing Framework
38. Hadoop's MapReduce Word Count Job Example
39. What Can Make a Microservices Architecture Brittle?
40. 4+1 Architectural View Model
41. Summary
42. Containerization Systems for Microservices
43. Infrastructure as Code
44. Why Not Just Deploy My Code Manually?
45. What is Docker
46. Docker Containers vs Traditional Virtualization
47. Docker is a Platform-as-a-Service
48. Docker Integration
49. Docker Services
50. Docker Application Container Public Repository
51. Container Registries
52. Your Own Docker Image Registry
53. Starting, Inspecting, and Stopping Docker Containers
54. One Process per Container
55. The Dockerfile
56. Kubernetes
57. What is OpenShift
58. Summary
59. Commonly Used Patterns
60. Why Use Patterns?
61. Performance-Related Patterns
62. More Performance-Related Patterns
63. Pagination vs. Infinite Scrolling - UX Lazy Loading
64. Integration Patterns
65. More Integration Patterns
66. The Service Mesh Integration Pattern
67. Mesh Pros and Cons
68. Service-to-Service Communication with Mesh
69. Resilience-Related Patterns
70. Summary
71. API Management
72. API Management Defined
73. The Traditional Point-to-point Integration Example
74. It Raises Some Questions …
75. The Facade Design Pattern
76. API Management Conceptual Diagram
77. Complimentary Services for Microservices
78. What Else is Needed?
79. The Driving Forces
80. API Management Offerings
81. The Mashery API Management System Overview
82. AWS API Gateway Call Flow
83. Summary
84. Designing and Implementing Microservices
85. Two Types of IT Projects
86. What is In Scope for a Robust Microservices Design?
87. Scoping Your Microservice via the Bounded Context
88. Scoping Your Solution's Microservices Architecture
89. External / Shared and Internal Service Models
90. General Architectural and Software Process Organizational Principles
91. Loose Coupling, the OOD Perspective
92. Crossing Process Boundary is Expensive!
93. Cross Cutting Concerns
94. More Cross Cutting Concerns
95. To Centralize or Decentralize Client Access?
96. Decentralized Client Access
97. Centralized Client Access
98. The Facade Pattern
99. The Facade Service Conceptual Diagram
100. The Naked Objects Architectural Pattern
101. When to Use Naked Objects Pattern
102. Dealing with the State
103. How Can I Maintain State?
104. Micro Front-ends (a.k.a. MicroUI)
105. How can MicroUI Help Me?
106. Your Clients Are Diverse
107. The "Rich Client" - "Thin Server" Paradigm
108. The "Rich Client" - "Thin Server" Architecture
109. RIA as a Driving Force to Turn the "Thin Server" into a Set of Microservices
110. Design for Failure
111. Managing Failures Effectively
112. The Immutable Infrastructure Principle
113. Implementing Microservices
114. JAX-RS
115. Microservice-Oriented Application Frameworks and Platforms
116. Embedding Databases
117. Embedded Java Databases
118. Summary
119. Microservices Integration
120. One Common Observation
121. The “One Service - One Host” Deployment
122. Things to Consider when Integrating
123. Technology Options
124. The Data Exchange Interoperability Options
125. The Correlation ID
126. Enterprise Integration Patterns
127. Asynchronous Communication
128. Benefits of Message-Oriented Middleware (MOM)
129. Asynchronous Communication Models
130. Message Brokers
131. A Message Broker Diagram
132. Asynchronous Message Consumption Patterns
133. Popular Messaging Systems
134. Challenges of Managing Microservices
135. Options for Managing Microservices
136. In-Class Discussion
137. Summary
138. Working with Data in Microservices
139. Monolithic Databases
140. The Traditional Two-phase Commit (2PC) Protocol
141. Table Sharding and Partitioning
142. The CAP Theorem
143. Mechanisms to Guarantee a Single CAP Property
144. The CAP Triangle
145. Eventual Consistency
146. Handling Transactions in Microservices Architecture
147. The Event-Driven Data Sharing Diagram
148. The Saga Pattern
149. The Saga Log and Execution Coordinator
150. The Saga Happy Path
151. A Saga Compensatory Request Example
152. In-Class Discussion
153. The Need for Micro Databases
154. Migrating Data from Existing Databases (Breaking up the Monolith Database)
155. One Data Migration Approach
156. One Data Migration Approach (Cont'd)
157. In-Class Discussion
158. Command Query Responsibility Segregation (CQRS)
159. The CQRS Communications Diagram
160. A Word of Caution
161. The Event Sourcing Pattern
162. Event Sourcing Example
163. Applying Efficiencies to Event Sourcing
164. Summary
165. Robust Microservices
166. What Can Make a Microservices Architecture Brittle?
167. Making it Resilient – Mechanisms
168. Techniques and Patterns for Making Your Microservices Robust
169. Fail Fast or Quiesce?
170. Synchronous Communication Timeouts / Retries
171. Asynchronous Communication Timeouts / Retries
172. In-Class Discussion
173. The Circuit Breaker Pattern
174. The Circuit Breaker Pattern Diagram
175. The Bulkhead Pattern
176. Factor IX of the 12 App Methodology
177. Feature Enablement
178. Designing for Test and Failure
179. Making Microservices Testable
180. Test for Failure
181. Continuous Testing and Integration
182. Continuous Release and Deployment
183. SLAs
184. Where and What to Monitor
185. Logging and Monitoring
186. Summary
187. Lab Exercises
     Monolith vs Microservices Design
     Using Databases with Microservices
     The Event Sourcing Pattern

Required Prerequisites

• Foundational knowledge of programming and software design principles.

‍