Microservices Architecture training course

What are Microservices?

• Small and focused                                                  
• Loosely coupled                                                     
• Language-neutral                                                   
• Bounded context    
• Domain-driven design                                               
• Comparing microservices and monolithic architectures                  

Benefits from Microservices

• Enterprise solutions context                                
• Challenges with monolithic architecture      
• Developer perspective                                              
• Tester perspective                                                  
• Business owner perspective                                 
• Service management perspective   
• Exercise: Try out a SOAP and REST service using Postman          

Analysing and Designing microservices

• What is a microservice application?
• Scaling through Decomposition
• Key Principles
• Who uses microservices?
• Domain-driven Design
• Service Analysis, Design and implementation
• Exercise: Analyse course case study and use Domain driven design

API Management                        

• API Economy in Numbers
• API-Led Architecture
• Hypermedia
• API Gateway
• API Micro Gateways
• Sidecar pattern
• Exercise: Write OpenAPI or Swagger contract

Microservices today                  

• Microservices at Robinhood
• The contents of an Event
• Exposing Services to the World
• Exercise: Build a service using java, maven and Spring boot

Architecture of a Microservices Application

• Role of the Architect
• A microservice platform
• Services layer          
• Communication
• Locating Services
• The application boundary
• Client layer
• Exercise: Configure a services registry such as Eureka

Architectural Modularity

• Technical Drivers
• Business Drivers
• How Much Modularity is enough?
• Sacrificial Architecture
• Exercise: Build a Micro Frontend with Node.js and Angular spa

Service Design

• Micro Hexagonal Service Design Pattern 
• Service Taxonomy
• Identifying Taxonomy

Service Granularity

• Purpose and Service Scope
• Transactions
• Data Dependencies
• Workflow and Choreography
• Code Structure and Reuse
• Exercise: Configure an API gateway

Share Nothing Architecture

• Bounded Context
• Shared Libraries
• Sharing a Database and Schema

Inter-service communication Using gRPC

• Using gRPC Between Services
• How gRPC Works
• Load Balancing gRPC Servers 
• Exercise: Configure an API gateway (example Nginx) to load balance request

Orchestration and Choreography

• Defining Orchestration
• Defining Choreography
• Service Orchestration
• Issues with Gateway Orchestration
• Using Microservice Orchestrators
• Orchestration and Loose Coupling
• Exercise: Walk through some Saga code

Service Aggregation

• Aggregation vs. Orchestration
• Issues with Orchestration
• Using Service Aggregation
• Aggregation Use Cases

Deploying Microservices                                

• Why is Deployment important?
• A microservice production environment
• Serverless Computing
• Building Service Artefacts
• Securing the Services
• Service to Host models
• Containerizing a Service
• Deploying to a Cluster
• Deploying services without downtime
• Exercise: Deploy a service to a Docker container

Transactions and Queries with Microservices

• Consistent transactions
• Event-based communication
• Sagas
• CQRS
• Event Sourcing
• CAP Theorem
• Exercise: Configure MongoDB and H2 for command and query side to test CQRS pattern

Microservices and Distributed Data

• Change Control Issues
• Connection Issues
• Bounded Context and Data
• Exercise: Using polyglot persistence