Course Overview:

Java microservices are a collection of software programmers with a restricted scope that collaborate with one another to create a larger solution. They are developed in the Java programming language and often make use of the extensive ecosystem of Java tools and frameworks.

Course Syllabus:

Introduction to Microservices Architecture

• Introduction to the Course & Agenda
• Details of Source Code, PDF Content & other instructions for the course
• Evolution of Microservices Architecture
• Deepdive of Monolithic architecture
• Deepdive of SOA architecture
• Deepdive of Microservices architecture
• Comparisons between Monolithic, SOA & Microservices architecture
• Definition of Microservices

[Optional] Microservices & spring (Match Made in Heaven)

• Why Spring is the best framework for building microservices
• Using Spring Boot for microservices development
• Creating a Hello World service using Spring Boot
• Using Spring Cloud for microservices development

[Optional] Right Sizing Microservices & Identifying boundaries (Challenge1)

• Approaches to identify boundaries & right sizing for building microservices
• Sizing & identifying boundaries with a Bank App use case
• Sizing & identifying boundaries with a Ecommerce migration use case

Getting started with creation of accounts, loan & cards microservices

• Introduction to the microservices that we are going to build
• Creating Bank Accounts Microservices using SpringBoot
• Creating Bank Loans Microservices using SpringBoot
• Creating Bank Cards Microservices using SpringBoot

[optional] How do we build, deploy, scale our microservices using Docker (challenge2)

• Introduction to challenges while building, deploying microservices

• What is Containerization technology?
• Definition of containers
• Introduction to Docker & its architecture
• Understanding Docker Hub & Installing Docker
• Creating Docker image definition using a Dockerfile09:54
• Create Accounts microservice Docker image from the Dockerfile
• Start and deploy Accounts microservice using Docker image & containers
• Deep dive of important Docker commands
• Introduction to Buildpacks

• Creating docker image of Loans microservice using Buildpacks
• Creating docker image of Cards microservice using Buildpacks
• Pushing Docker images from your local to remote Docker hub repository
• Deep dive on docker-compose
• Tips & Tricks around Docker Desktop Dashboard & Logs explorer

[Optional] Deep Dive on Cloud Native Apps & 12factorsIntroduction to Cloud-native applications

• Differences between cloud-native Apps & Traditional enterprise Apps
• Twelve factor App Deepdive 1
• Twelve factor App Deepdive 2
• Twelve factor App Deepdive 3

Configuration Management in Microservices (Challenge3)

• Introduction to Configurations Management challenges inside microservices
• Configuration Management architecture inside microservices
• Deep dive of Spring Cloud Config for Configuration management
• Building Config Server service and load all the configurations from classpath
• Reading configurations from a file system location
• Reading configurations from a Github repository
• Updating Accounts Microservice to read properties from Config Server
• Updating Loans Microservice to read properties from Config Server
• Updating Cards Microservice to read properties from Config Server
• Generating Docker images after Config Server changes
• Pushing all the latest Docker images with Config server changes to DockerHub
• Updating Docker Compose file to adapt Config Server changes
• Starting all the microservices using docker compose files based on the env
• Refreshing properties with @RefreshScope
• Encryption & Decryption of your properties inside Config server

Service Discovery & Registration (Challengr4)

• Introduction to the Service Discovery & Registration inside microservices
• Why not traditional load balancers for Microservices
• Architecture of Service Discovery inside microservices
• Client Side load balancing between microservices
• Spring Cloud support for Service Discovery & Registration
• Setup Service Discovery agent using Eureka server
• Make changes for Accounts microservice to connect Eureka Server
• Make changes for Loans & Cards microservice to connect Eureka Server
• Degistration from Eureka server when microservices shutdown
• Demo of heartbeats mechanism to Eureka server from client
• Feign Client to invoke other microservices

• Generating Docker images after Service Discovery changes
• Pushing all the latest Docker images with Eureka changes to Docker Hub
• Updating Docker Compose file to adapt Service Discovery changes
• Starting all the microservices using docker compose file
• Running docker compose with 2 instances of Accounts microservice
• Eureka Self-Preservation mode to avoid network trap issues

Making Microservices Resilient (Challenges 5)

• Introduction to the need of Resiliency inside microservices
• Typical use case or scenario for the need of Resiliency
• Deep dive on Circuit Breaker patter in microservices
• Implementing Circuit Breaker pattern - Part 1
• Implementing Circuit Breaker pattern - Part 2
• Implementing Circuit Breaker pattern - Part 3
• Deep dive on Retry pattern in microservices
• Implementing Retry Pattern in microservices
• Deep dive on Rate Limiter pattern in microservices
• Implementing Rate Limiter Pattern in microservices
• Deep dive on Bulk head pattern in microservices

Handling Routing & Cross cutting concerns in Microservices (Challenge6)

• Introduction to the challenges with Routing & Cross cutting concerns
• Introduction to Spring Cloud Gateway
• Deep dive on Spring Cloud Gateway internal architecture
• Building Spring Cloud Gateway service
• Implementing Custom Routing using Spring Cloud Gateway
• Implementing Cross cutting concern Tracing & Logging using Gateway Server
• Generating and pushing Docker images with Spring Cloud Gateway changes
• Updating Docker Compose file to adapt Spring Cloud Gateway changes

Distributed tracing & Log aggregation in Microservices (challenge 7)

• Introduction to the challenges related to Distributed tracing & Log aggregation
• Introduction to Spring Cloud Sleuth & Zipkin
• Deep dive on Spring Cloud Sleuth & it's tracing format
• Deep dive on Zipkin internal architecture
• Implementing Distributed tracing with Spring Cloud Sleuth
• Implementing Log aggregation with Zipkin Server
• Pushing Sleuth message into RabbitMQ
• Generate, Push Docker images with Sleuth & Zipkin changes

Monitoring Microservices Metrics & Health (Challenge 8)

• Introduction to the challenges related to monitoring microservices
• Different approaches to monitor microservices
• Setup of micrometer inside microservices
• Setup of Prometheus to monitor microservices
• Setup of Grafana to monitor microservices with inbuilt dashboards
• Building custom dashboards inside Grafana
• Sending alerts using Grafana when service is down

Automatic self-healing, scaling, deployments using Kubernetes

• Introduction to the challenges related to container orchestration
• Introduction to Kubernetes
• Dee dive of Kubernetes internal architecture
• Cloud providers support for Kubernetes
• GCP Account Setup and creating a K8s cluster
• Exploring K8S cluster and establish connection with it
• Deep dive on Kubernetes YAML configurations
• Kubernetes YAML configurations for applicable microservices
• Create environment variables inside K8S cluster using ConfigMap
• Deploying our microservices to Kubernetes cluster
• Validating our microservices deployed into K8s cluster
• Automatic Self-healing inside Kubernetes cluster
• Automatic Rollout & Rollback inside Kubernetes cluster
• Logging & Monitoring inside Kubernetes cluster
• Autoscaling inside Kubernetes cluster using HPA
• Deleting Kubernetes cluster inside GCP

Deploying all microservices into K8s cluster

• Deploying all the microservices into K8s cluster - Theory
• Creating the K8s yaml config files for all microservices
• How Deployment and Service are tied together inside K8s
• Deploying all the microservices into K8s cluster
• Validating microservices deployed into K8s cluster
• Problems with manually created Kubernetes manifest files

Deep Dive on Helm

• Introduction to Helm
• Problems that Helm solves
• Installing Helm
• Creating our first Helm Chart
• Installing the Default Helm chart into K8s cluster
• Exploring the default Helm chart content
• Creating our own Helm template files
• Creating Helm chart for Accounts microservice
• Creating Helm chart for other microservice
• Creating Helm chart for Dev and Prod environment
• Demo of helm template command
• Installing Helm charts into K8s cluster
• Demo of helm upgrade command
• Demo of helm history and rollback commands
• Demo of helm uninstall command
• Revision of important helm commands

Securing Microservices using K8s Services

• Problem with Kubernetes LoadBalancer Service
• Problem with Kubernetes LoadBalancer Service-Demo
• Introduction to types of K8s Services
• Deep dive on ClusterIP Service - Theory
• Deep dive on ClusterIP Service - Demo
• Deep dive on NodePort Service - Theory
• Deep dive on NodePort Service - Demo
• Deep dive on LoadBalancer Service - Theory
• Deep dive on LoadBalancer Service - Demo Securing Microservices using OAuth2 client credentials grants flow
• Introduction to securing Spring Cloud Gateway with OAuth2
• Quick intro to OAuth2 framework
• Deep dive onAuth2 client Credentials grant flow
• KeyCloak Auth Server installation and setup using Docker command
• Register Client details inside KeyCloak Auth server
• Getting Access token from Auth Server using Client details
• Making code changes inside Spring Cloud Gateway to secure the APIs
• Demo of Spring Cloud Gateway security inside local system
• Generating and Pushing latest docker image of Gateway into Docker Hub
• Installation of KeyCloak into K8s cluster using Helm chart