Visão Geral

O Curso Microservices with SpringBoot Docker Kubernetes, ajudará na compreensão da arquitetura de microsserviços e como construí-la usando SpringBoot, componentes Spring Cloud, Docker e Kubernetes. Ao final deste curso, os alunos compreenderão todos os tópicos abaixo,

• O que é arquitetura de microsserviços e como ela difere das arquiteturas monolíticas e SOA
• Como construir microsserviços prontos para produção usando  Java, Spring , SpringBoot e Spring Cloud
• Como documentar microsserviços usando Open API Specification e Swagger
• Como dimensionar microsserviços corretamente e identificar limites de serviço
• Papel do Docker em microsserviços e como construir imagens e contêineres do Docker
• Função do Docker compose e como usá-lo para executar todos os microsserviços dentro de um aplicativo
• O que são aplicativos nativos da nuvem e metodologia de 15 fatores por trás deles
• Gerenciamento de configuração em microsserviços usando Spring Cloud Config Server
• Padrão de descoberta e registro de serviço dentro de microsserviços e como implementar usando o servidor Spring Eureka
• Lidando com preocupações transversais e roteamento dentro de microsserviços usando Spring Cloud Gateway
• Construindo microsserviços resilientes usando a estrutura RESILIENCE4J
• Implementando observabilidade e monitoramento usando Prometheus , Loki , Promtail , Tempo e Grafana
• Protegendo microsserviços usando OAuth2 , OpenID connect e Spring Security
• Como construir microsserviços orientados a eventos usando RabbitMQ , Kafka , Spring Cloud Functions e Spring Cloud Stream
• Papel do Kubernetes em microsserviços como estrutura de orquestração de contêineres.
• Como configurar um cluster Kubernetes dentro do GCP usando o Google Kubernetes Engine e implantar microsserviços dentro dele
• O que é Helm e seu papel no mundo dos microsserviços
• Comandos Docker, Kubernetes e Helm mais comumente usados

Objetivo

Após realizar este Curso Microservices with SpringBoot Docker Kubernetes, você será capaz de:

• O que é arquitetura de microsserviços e como ela difere das arquiteturas monolíticas e SOA
• Como construir microsserviços prontos para produção usando Java, Spring, Spring Boot e Spring Cloud
• O que são aplicativos nativos da nuvem e metodologia de 15 fatores por trás deles
• Gerenciamento de configuração em microsserviços usando Spring Cloud Config Server
• Padrão de descoberta e registro de serviço dentro de microsserviços e como implementar usando o servidor Spring Eureka
• Construindo microsserviços resilientes usando a estrutura RESILIENCE4J
• Lidando com preocupações transversais e roteamento dentro de microsserviços usando Spring Cloud Gateway
• Implementando observabilidade e monitoramento usando Prometheus, Loki, Promtail, Tempo e Grafana
• Protegendo microsserviços usando OAuth2, OpenID connect e Spring Security
• Papel do Docker em microsserviços e como construir imagens e contêineres do Docker
• Papel do Kubernetes em microsserviços como estrutura de orquestração de contêineres
• Como construir microsserviços orientados a eventos usando RabbitMQ, Kafka, Spring Cloud Functions e Spring Cloud Stream

Publico Alvo

• Alunos iniciantes que estão aprendendo o framework Spring e também interessados ​​em microsserviços
• Desenvolvedores que já conhecem o desenvolvimento de aplicações web usando o framework Spring
• Arquitetos Java

Pre-Requisitos

Curso Microservices with SpringBoot Docker Kubernetes

• Java
• Noções básicas da estrutura Spring

Materiais

Conteúdo Programatico

Introduction to Microservices Architecture

1. Introduction to the course & Agenda
2. Details of Source Code, PDF Content & other instructions for the course
3. Evolution of Microservices architecture
4. Comparisons between Monolithic, SOA & Microservices architecture
5. Definition of Microservices

Building microservices using Spring Boot

1. How to build microservices
2. Introduction to SpringBoot framework
3. Funny memes of SpringBoot framework
4. Introduction to REST APIs & best practices
5. Creating a Spring Boot project
6. Creating Hello World REST API using @RestController
7. Configuring H2 DB & YAML properties
8. Writing Spring Data JPA entities & repositories to interact with DB tables
9. Introduction to DTO (Data Transfer Object) pattern
10. Creating DTOs inside accounts microservice
11. CREATE API inside accounts microservice - Part 1
12. CREATE API inside accounts microservice - Part 2
13. READ API inside accounts microservice
14. UPDATE API inside accounts microservice
15. DELETE API inside accounts microservice
16. Handle all types of runtime exceptions using global logic inside accounts
17. Perform input data validations inside accounts microservice
18. Update audit columns using Spring Data
19. Introduction to documentation of REST APIs using springdoc openapi
20. Enhancing documentation of REST APIs using @OpenAPIDefinition
21. Enhancing documentation of REST APIs using @Tag, @Operation, @ApiResponse
22. Enhancing documentation of REST APIs using @Schema & example data - Part 1
23. Enhancing documentation of REST APIs using @Schema & example data - Part 2
24. Important Annotations & Classes that supports building REST services
25. Assignment to build Loans & Cards microservices
26. Deep dive and demo of Loans microservice
27. Deep dive and demo of Cards microservice

How do we right size our microservices & identify boundaries

1. Approaches to identify boundaries & right size microservices
2. Sizing & identifying boundaries with a Bank App use case
3. Sizing & identifying boundaries with a ecommerce migration use case
4. Handle deployment, portability & scalability of microservices using Docker
5. Introduction to challenges while building, deploying microservices
6. What are Containers & how they are different from VMs
7. Definition of Containers, Containerization, Docker
8. Introduction to Docker components & its architecture
9. Docker installation & docker hub introduction
10. Introduction to the three approaches for Docker image generation
11. Generate Docker Image of Accounts microservice with Dockerfile - Part 1
12. Generate Docker Image of Accounts microservice with Dockerfile - Part 2
13. Generate Docker Image of Accounts microservice with Dockerfile - Part 3
14. Running accounts microservice as a Docker container
15. Challenges with Dockerfile approach to generate a Docker image
16. Generate Docker Image of Loans microservice with Buildpacks
17. Generate Docker Image of Cards microservice with Google Jib
18. Compare Dockerfile, Buildpacks, Jib approaches
19. Pushing Docker images from your local to remote Docker hub repository
20. Introduction to Docker Compose
21. Running all microservice containers using Docker Compose command
22. Demo of docker compose commands
23. Deep dive on Docker commands
24. Introduction to Docker extensions and LogsExplorer
25. Funny memes of Docker

Deep Dive on Cloud Native Apps & 15-Factor methodology

1. Introduction to Cloud-native applications
2. Important characteristics of cloud-native applications
3. Differences between cloud-native Apps & Traditional enterprise Apps
4. Introduction to 12-factor & 15-factor methodologies
5. Deepdive on 15-factor methodology - Part 1
6. Deepdive on 15-factor methodology - Part 2
7. Deepdive on 15-factor methodology - Part 3

Configurations Management in Microservices

1. Introduction to Configurations Management challenges inside microservices
2. How Configurations work in Spring Boot
3. Reading configurations using @Value annotation
4. Reading configurations using Environment interface
5. Reading configurations using @ConfigurationProperties
6. Introduction to Spring Boot profiles
7. Demo of Spring Boot profiles inside accounts microservice
8. Externalizing configurations using command-line, JVM & environment options
9. Activating the profile using command-line, JVM & environment options
10. Assignment to make SpringBoot profile changes inside loans & cards microservices
11. Demo of Spring Boot profile changes inside loans & cards microservices
12. Drawbacks of externalized configurations using SpringBoot alone
13. Introduction to Spring Cloud Config
14. Building Config Server using Spring Cloud Config
15. Reading configurations from the class path location of Config Server
16. Updating Accounts Microservice to read properties from Config Server
17. Updating Loans & Cards Microservice to read properties from Config Server
18. Reading configurations from a file system location
19. Reading configurations from a GitHub repository
20. Encryption & Decryption of properties inside Config server
21. Refresh configurations at runtime using refresh actuator path
22. Refresh configurations at runtime using Spring Cloud Bus
23. Refresh config at runtime using Spring Cloud Bus & Spring Cloud Config monitor
24. Updating Docker Compose file to adapt Config Server changes - Part 1
25. Introduction to Liveness and Readiness probes
26. Updating Docker Compose file to adapt Config Server changes - Part 2
27. Optimizing Docker Compose file
28. Generating Docker images and pushing them into Docker Hub
29. Testing Config Server changes end to end using Docker compose & default profile
30. Preparing Docker Compose files for QA & prod profiles

Using MySQL Database inside microservices

1. Create MySQL DB containers for microservices
2. Update microservices code to replace H2 DB with MySQL DB
3. Update docker compose file to create & use MySQL DB
4. Running microservices & MySQL DB containers using docker compose file
5. Demo of Docker network concept

Service Discovery & Service Registration in microservices

1. Brief introduction about microservices traffic
2. Introduction to the Service Discovery & Registration inside microservices
3. Why not traditional load balancers for Microservices
4. Service Discovery & Registration inside microservices
5. How Client side Service Discovery & Load-balancing works
6. Spring Cloud support for Service Discovery & Registration
7. Setup Service Discovery agent using Eureka server
8. Make code changes in Accounts microservice to connect Eureka Server
9. Make code changes in Loans & Cards microservice to connect Eureka Server
10. De-registration from Eureka server when microservices shutdown
11. Demo of heartbeats mechanism to Eureka server from clients
12. Feign Client code changes to invoke other microservices - Part 1
13. Feign Client code changes to invoke other microservices - Part 2
14. Eureka Self-Preservation mode to avoid network trap issues
15. Generating Docker images with Service Discovery changes & push them into Dock
16. Updating Docker Compose file to adapt Service Discovery changes
17. Starting all the microservices using docker compose file
18. Demo of Client Side Service Discovery & Load balancing

Gateway, Routing & Cross cutting concerns in Microservices

1. Challenges while dealing external communication in microservices
2. Why we need a Edge Server or API Gateway inside microservices
3. Introduction to Spring Cloud Gateway
4. Deep dive on Spring Cloud Gateway internal architecture
5. Building Edge Server using Spring Cloud Gateway
6. Demo of Edge Server with default routing configs
7. Make changes inside Gateway server to accept service names with lower case
8. Implementing Custom Routing using Spring Cloud Gateway
9. Demo of addResponseHeader filter
10. Implementing Cross cutting concerns Tracing & Logging using Gateway - Part 1
11. Implementing Cross cutting concerns Tracing & Logging using Gateway - Part 2
12. Generating and pushing Docker images with Spring Cloud Gateway changes
13. Updating Docker Compose file to adapt Spring Cloud Gateway changes

Making Microservices Resilient

1. Introduction to the need of Resiliency inside microservices
2. Typical use case or scenario for the need of Resiliency
3. Deepdive on Circuit Breaker pattern
4. Three states of Circuit Breaker pattern
5. Implementing Circuit Breaker pattern in Gateway - Part 1
6. Implementing Circuit Breaker pattern in Gateway - Part 2
7. Implementing Circuit Breaker pattern with Feign Client - Part 1
8. Implementing Circuit Breaker pattern with Feign Client - Part 2
9. Http timeout configurations
10. Introduction to Retry pattern
11. Implementing Retry pattern in Gateway
12. Implementing Retry pattern in accounts - Part 1
13. Implementing Retry pattern in accounts - Part 2
14. Introduction to Rate Limitter pattern
15. Introduction to Redis RateLimiter in Gateway Server
16. Implementing Redis RateLimiter in Gateway Server
17. Implementing RateLimiter pattern in accounts
18. Introduction to Bulkhead pattern
19. Aspect order of Resiliency patterns
20. Demo of Resiliency patterns using Docker containers & Docker compose

Observability and monitoring of microservices

1. Introduction to Observability And Monitoring Of Microservices
2. Observability vs. Monitoring
3. Introduction to centralized logging or Log Aggregation in microservices
4. Introduction to managing logs with Grafana, Loki & Promtail
5. Sample demo of logging using Grafana, Loki & promotail - Theory
6. Implementing logging using Grafana, Loki & promotail - Part 1
7. Implementing logging using Grafana, Loki & promotail - Part 2
8. Implementing logging using Grafana, Loki & promotail - Part 3
9. Managing metrics & monitoring with Actuator, Micrometer, Prometheus & Grafana
10. Setup of micrometer inside microservices
11. Setup of prometheus inside microservices
12. Demo of Prometheus
13. Demo of Prometheus & Grafana integration
14. Demo of Grafana inbuilt & custom Dashboards
15. Create Alerts & Send notifications using Grafana - Approach 1
16. Create Alerts & Send notifications using Grafana - Approach 2
17. Introduction to Distributed Tracing in microservices
18. Introduction to OpenTelemetry
19. Implement OpenTelemetry changes inside microservices
20. Implementing Tracing using Grafana, Tempo & OpenTelemetry - Part 1
21. Implementing Tracing using Grafana, Tempo & OpenTelemetry - Part 2
22. Implementing Tracing using Grafana, Tempo & OpenTelemetry - Part 3
23. Navigating to Tempo from Loki logs
24. Conclusion of Observability and Monitoring

Microservices Security

1. Introduction to Microservices Security
2. Problems that OAuth2 solves
3. Introduction to OAuth2
4. OAuth2 jargons or terminologies or roles
5. What is OpenID Connect & why it is important
6. Introduction to IAM products & why KeyCloak
7. Deep dive of Client Credentials grant type flow
8. Securing Gateway server using Client Credentials grant type flow - Theory
9. Setup Auth server using KeyCloak
10. Register client details inside KeyCloak for Client credentials grant flow
11. Getting Access token from Auth Server in Client credentials grant flow
12. Securing Gateway server as a Resource server - Part 1
13. Securing Gateway server as a Resource server - Part 2
14. Implement Authorization inside Gateway server using Roles - Part 1
15. Implement Authorization inside Gateway server using Roles - Part 2
16. Deep dive of Authorization Code grant type flow
17. Securing Gateway server using Authorization Code grant type flow - Theory
18. Register client & end user inside KeyCloak for Authorization code grant flow
19. Demo of Authorization code grant type flow
20. Demo of Microservices Security using Docker containers & Docker compose - Part 1
21. Demo of Microservices Security using Docker containers & Docker compose - Part 2

Event Driven microservices using RabbitMQ,Spring Cloud Functions & Stream

1. Introduction to Event-driven microservices
2. Introduction to Event-driven models
3. What we are going to build using a pub sub model
4. Introduction to RabbitMQ
5. Why to use Spring Cloud Function
6. Develop message microservice using Spring Cloud Functions - Part 1
7. Develop message microservice using Spring Cloud Functions - Part 2
8. Develop message microservice using Spring Cloud Functions - Part 3
9. Why to use Spring Cloud Stream
10. Update message & accounts microservices to stream & process the events - Part 1
11. Demo of Async communication or event streaming using Rabbit MQ - Part 1
12. Update message & accounts microservices to stream & process the events - Part 2
13. Demo of Async communication or event streaming using Rabbit MQ - Part 2
14. Demo of Async comm or event streaming using Docker containers & Docker compose

Event Driven microservices using Kafka, Spring Cloud Functions & Stream

1. Apache Kafka Vs RabbitMQ
2. Introduction to Apache Kafka
3. Producer and Consumer side stories
4. Installation of Apache Kafka
5. Implement & Demo of Async communication or event streaming using Kafka
6. Demo of Async comm or event streaming using Docker containers & Docker Compose

Container Orchestration using Kubernetes

1. Introduction to the challenges related to container orchestration
2. ​​​​​​​Introduction to Kubernetes
3. Deep dive on Kubernetes internal architecture
4. Setup a local Kubernetes cluster using Docker Desktop
5. Deploying the Kubernetes Dashboard UI
6. Deep dive on Kubernetes YAML configurations to deploy a microservice
7. Deploying ConfigServer into Kubernetes Cluster
8. Create environment variables inside Kubernetes Cluster using ConfigMap
9. Preparing Kubernetes manifest files for remaining microservices
10. Deploying remaining microservices into Kubernetes Cluster
11. Automatic Self healing inside Kubernetes cluster
12. Automatic Rollout & Rollback inside Kubernetes cluster
13. Introduction to Kubernetes Service types
14. Demo of Kubernetes Service types
15. Problems with manually created Kubernetes manifest files

Deep dive on Helm

1. Introduction to Helm & the problems that it solves
2. Installing Helm
3. Installing a sample Helm Chart
4. Understanding Helm Chart structure
5. Creating our own Helm chart & template files
6. Creating Helm chart for Accounts microservice
7. Creating Helm charts for other microservices
8. Creating Helm charts for Dev, QA and Prod environment
9. Demo of helm template command
10. Install KeyCloak in Kubernetes Cluster using Helm Chart
11. Install Kafka in Kubernetes Cluster using Helm Chart
12. Install Prometheus in Kubernetes Cluster using Helm Chart
13. Install Grafana Loki & Tempo in Kubernetes Cluster using Helm Chart
14. Install Grafana in Kubernetes Cluster using Helm Chart
15. Install eazybank microservices in Kubernetes Cluster using Helm Chart
16. Demo of helm upgrade command
17. Demo of helm history and rollback commands
18. Demo of helm uninstall command
19. Quick revision of important helm commands

Server-side service discovery and load balancing using Kubernetes

1. Introduction to Server-side service discovery and load balancing
2. ​​​​​​​How to setup discovery server in K8s cluster using spring cloud kubernetes
3. Install spring cloud kubernetes discovery server in K8s cluster
4. Making Kubernetes Discovery Client changes in microservices - Part 1
5. Making Kubernetes Discovery Client changes in microservices - Part 2
6. Updating Helm charts for Kubernetes Discovery Server changes

Demo of Server-side service discovery and load balancing

Deploying microservices into cloud Kubernetes cluster

1. Kubernetes support by Cloud providers
2. Set up Google Cloud account & install Google Cloud SDK
3. Create a Kubernetes cluster in Google Cloud
4. Installing all our microservices and supporting components in Google Cloud K8s
5. Demo of eazybank microservices using Google Cloud Kubernetes Cluster
6. Validate Grafana components in Google Cloud Kubernetes Cluster
7. Deleting the Google Cloud Kubernetes Cluster

Introduction to Kubernetes Ingress, Service Mesh (Istio) & mTLS

1. Quick introduction to Kubernetes Ingress
2. Deep dive on Kubernetes Ingress & Ingress Controller
3. Benefits of Kubernetes Ingress & the kind of traffic it handles
4. Introduction to Service Mesh & it's capabilities
5. Introduction to Service mesh components
6. Introduction to mTLS & deep dive on how TLS works
7. How does mTLS works
8. Quiz related to "Introduction to K8s Ingress & Service Mesh (Istio)"