CF

Master Microservices with Java, Spring, Docker, Kubernetes

23h 57m 28s
English
Paid

Master Microservices with Java, Spring, Docker, Kubernetes is a 179-lesson 23 hours 57 minutes self-paced course by Udemy. 'Master Microservices with Spring, Docker, Kubernetes' course is designed to provide a comprehensive understanding of microservices architecture and how to build it using SpringBoot, Spring Cloud components, Docker, and Kubernetes.

Course facts

Lessons
179
Duration
23 hours 57 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

'Master Microservices with Spring, Docker, Kubernetes' course is designed to provide a comprehensive understanding of microservices architecture and how to build it using SpringBoot, Spring Cloud components, Docker, and Kubernetes.

Course Objectives

By the end of this course, students will have mastered the following topics:

  1. Understanding microservices architecture and its differences from monolithic and SOA architectures.

  2. Building production-ready microservices using Spring, SpringBoot, and Spring Cloud.

  3. Concepts of cloud-native applications and the 12-factor principles behind them.

  4. Implementing configuration management in microservices with Spring Cloud Config Server.

  5. Exploring Service Discovery and Registration pattern using Spring Eureka Server.

  6. Building resilient microservices with the RESILIENCE4J framework.

  7. Managing cross-cutting concerns and routing in microservices via Spring Cloud Gateway.

  8. Implementing distributed tracing and log aggregation with Spring Sleuth and Zipkin.

  9. Monitoring microservices using Prometheus and Grafana.

  10. Understanding the role of Docker in microservices and how to build Docker images and containers.

  11. Utilizing Docker Compose to run all microservices within an application.

  12. Mastering the most commonly used Docker commands.

  13. Learning about the role of Kubernetes as a container orchestration framework in microservices.

  14. Setting up a Kubernetes cluster in GCP using GKE (Google Kubernetes Engine) and deploying microservices in it.

  15. Familiarizing with the most commonly used Kubernetes commands.

  16. Enhancing Microservices Security using OAuth2.

  17. Exploring what Helm is and its role in the microservices ecosystem.

Prerequisites

The only prerequisite for this course is a basic knowledge of Java, Spring, and a keen interest in learning about microservices.

Who teaches Master Microservices with Java, Spring, Docker, Kubernetes? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Master Microservices with Java, Spring, Docker, Kubernetes?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 179 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction to the course & Agenda
All Course Lessons (179)
#Lesson TitleDurationAccess
1
Introduction to the course & Agenda Demo
05:33
2
Details of Source Code, PDF Content & other instructions for the course
07:09
3
Evolution of Microservices architecture
07:56
4
Deepdive of Monolithic architecture
10:08
5
Deepdive of SOA architecture
06:35
6
Deepdive of Microservices architecture
11:01
7
Comparisons between Monolithic, SOA & Microservices architecture
07:37
8
Definition of Microservices
03:08
9
Why Spring is the best framework for building microservices
05:17
10
Using Spring Boot for microservices development
07:48
11
Creating a Hello World service using Spring Boot
10:28
12
Using Spring Cloud for microservices development
09:53
13
Approaches to identify boundaries & right sizing for building microservices
09:52
14
Sizing & identifying boundaries with a Bank App use case
05:26
15
Sizing & identifying boundaries with a Ecommerce migration use case
06:58
16
Introduction to the microservices that we are going to build
01:40
17
Creating Bank Accounts Microservices using SpringBoot
17:04
18
Creating Bank Loans Microservices using SpringBoot
05:46
19
Creating Bank Cards Microservices using SpringBoot
05:55
20
Introduction to challenges while building, deploying microservices
04:40
21
What is Containerization technology?
08:36
22
Definition of containers
05:51
23
Introduction to Docker & its architecture
08:12
24
Understanding Docker Hub & Installing Docker
05:47
25
Creating Docker image definition using a Dockerfile
09:55
26
Create Accounts microservice Docker image from the Dockerfile
04:52
27
Start and deploy Accounts microservice using Docker image & containers
06:39
28
Deep dive of important Docker commands
10:31
29
Introduction to Buildpacks
04:34
30
Creating docker image of Loans microservice using Buildpacks
06:03
31
Creating docker image of Cards microservice using Buildpacks
06:46
32
Pushing Docker images from your local to remote Docker hub repository
06:11
33
Deep dive on docker-compose
14:07
34
Tips & Tricks around Docker Desktop Dashboard & Logs explorer
05:51
35
Introduction to Cloud-native applications
08:03
36
Differences between cloud-native Apps & Traditional enterprise Apps
06:58
37
Twelve factor App Deepdive 1
08:14
38
Twelve factor App Deepdive 2
06:56
39
Twelve factor App Deepdive 3
08:39
40
Introduction to Configurations Management challenges inside microservices
04:51
41
Configuration Management architecture inside microservices
06:53
42
Deep dive of Spring Cloud Config for Configuration management
06:16
43
Building Config Server service and load all the configurations from classpath
16:01
44
Reading configurations from a file system location
04:00
45
Reading configurations from a GitHub repository
04:42
46
Updating Accounts Microservice to read properties from Config Server
12:21
47
Updating Loans Microservice to read properties from Config Server
03:49
48
Updating Cards Microservice to read properties from Config Server
04:25
49
Generating Docker images after Config Server changes
07:22
50
Pushing all the latest Docker images with Config server changes to DockerHub
04:28
51
Updating Docker Compose file to adapt Config Server changes
16:11
52
Starting all the microservices using docker compose files based on the env
13:13
53
Refreshing properties with @RefreshScope
12:34
54
Encryption & Decryption of your properties inside Config server
07:54
55
Introduction to the Service Discovery & Registration inside microservices
08:20
56
Why not traditional load balancers for Microservices
08:33
57
Architecture of Service Discovery inside microservices
12:51
58
Client Side load balancing between microservices
06:23
59
Spring Cloud support for Service Discovery & Registration
04:26
60
Setup Service Discovery agent using Eureka server
09:37
61
Make changes for Accounts microservice to connect Eureka Server
07:16
62
Make changes for Loans & Cards microservice to connect Eureka Server
07:40
63
Degistration from Eureka server when microservices shutdown
04:43
64
Demo of heartbeats mechanism to Eureka server from clients
02:29
65
Feign Client to invoke other microservices
12:13
66
Generating Docker images after Service Discovery changes
05:02
67
Pushing all the latest Docker images with Eureka changes to Docker Hub
02:22
68
Updating Docker Compose file to adapt Service Discovery changes
04:19
69
Starting all the microservices using docker compose file
04:29
70
Running docker compose with 2 instances of Accounts microservice
05:26
71
Eureka Self-Preservation mode to avoid network trap issues
12:40
72
Introduction to the need of Resiliency inside microservices
10:03
73
Typical use case or scenario for the need of Resiliency
07:05
74
Deep dive on Circuit Breaker pattern in microservices
13:32
75
Implementing Circuit Breaker pattern - Part 1
07:30
76
Implementing Circuit Breaker pattern - Part 2
07:16
77
Implementing Circuit Breaker pattern - Part 3
05:29
78
Deep dive on Retry pattern in microservices
03:30
79
Implementing Retry Pattern in microservices
06:57
80
Deep dive on Rate Limiter pattern in microservices
03:17
81
Implementing Rate Limiter Pattern in microservices
03:33
82
Deep dive on Bulk head pattern in microservices
07:23
83
Introduction to the challenges with Routing & Cross cutting concerns
05:14
84
Introduction to Spring Cloud Gateway
11:03
85
Deep dive on Spring Cloud Gateway internal architecture
06:19
86
Building Spring Cloud Gateway service
15:26
87
Implementing Custom Routing using Spring Cloud Gateway
10:08
88
Implementing Cross cutting concern Tracing & Logging using Gateway Server
15:24
89
Generating and pushing Docker images with Spring Cloud Gateway changes
08:42
90
Updating Docker Compose file to adapt Spring Cloud Gateway changes
07:32
91
Introduction to the challenges related to Distributed tracing & Log aggregation
08:42
92
Introduction to Spring Cloud Sleuth & Zipkin
04:32
93
Deep dive on Spring Cloud Sleuth & it's tracing format
07:06
94
Deep dive on Zipkin internal architecture
07:27
95
Implementing Distributed tracing with Spring Cloud Sleuth
10:05
96
Implementing Log aggregation with Zipkin Server
14:28
97
Pushing Sleuth message into RabbitMQ
10:25
98
Generate, Push Docker images with Sleuth & Zipkin changes
12:51
99
Introduction to the challenges related to monitoring microservices
02:52
100
Different approaches to monitor microservices
10:27
101
Setup of micrometer inside microservices
10:19
102
Setup of Prometheus to monitor microservices
15:31
103
Setup of Grafana to monitor microservices with inbuilt dashboards
10:07
104
Building custom dashboards inside Grafana
05:44
105
Sending alerts using Grafana when service is down
08:46
106
Introduction to the challenges related to container orchestration
05:28
107
Introduction to Kubernetes
08:22
108
Dee dive of Kubernetes internal architecture
17:10
109
Cloud providers support for Kubernetes
07:40
110
GCP Account Setup and creating a K8s cluster
04:46
111
Exploring K8S cluster and establish connection with it
11:26
112
Deep dive on Kubernetes YAML configurations
09:03
113
Kubernetes YAML configurations for applicable microservices
13:18
114
Create environment variables inside K8S cluster using ConfigMap
09:17
115
Deploying our microservices to Kubernetes cluster
12:14
116
Validating our microservices deployed into K8s cluster
04:08
117
Automatic Self healing inside Kubernetes cluster
06:34
118
Automatic Rollout & Rollback inside Kubernetes cluster
10:50
119
Logging & Monitoring inside Kubernetes cluster
05:12
120
Autoscaling inside Kubernetes cluster using HPA
04:06
121
Deleting Kubernetes cluster inside GCP
01:27
122
Deploying all the microservices into K8s cluster - Theory
05:13
123
Creating the K8s yaml config files for all microservices
10:23
124
How Deployment and Service are tied together inside K8s
05:41
125
Deploying all the microservices into K8s cluster
08:05
126
Validating microservices deployed into K8s cluster
03:18
127
Problems with manually created Kubernetes manifest files
07:41
128
Introduction to Helm
05:50
129
Problems that Helm solves
09:24
130
Installing Helm
06:18
131
Creating our first Helm Chart
06:16
132
Installing the Default Helm chart into K8s cluster
14:48
133
Exploring the default Helm chart content
09:12
134
Creating our own Helm template files
15:47
135
Creating Helm chart for Accounts microservice
11:12
136
Creating Helm chart for other microservice
13:07
137
Creating Helm chart for Dev and Prod environment
13:06
138
Demo of helm template command
06:01
139
Installing Helm charts into K8s cluster
11:44
140
Demo of helm upgrade command
06:03
141
Demo of helm history and rollback commands
03:41
142
Demo of helm uninstall command
02:33
143
Revision of important helm commands
06:50
144
Problem with Kubernetes LoadBalancer Service
05:02
145
Problem with Kubernetes LoadBalancer Service-Demo
05:33
146
Introduction to types of K8s Services
04:21
147
Deep dive on ClusterIP Service - Theory
04:27
148
Deep dive on ClusterIP Service - Demo
11:43
149
Deep dive on NodePort Service - Theory
04:38
150
Deep dive on NodePort Service - Demo
12:04
151
Deep dive on LoadBalancer Service - Theory
04:28
152
Deep dive on LoadBalancer Service - Demo
07:06
153
Introduction to securing Spring Cloud Gateway with OAuth2
02:59
154
Quick intro to OAuth2 framework
11:04
155
Deep dive on OAuth2 Client Credentials grant flow
10:42
156
KeyCloak Auth Server installation and setup using Docker command
07:55
157
Register Client details inside KeyCloak Auth server
05:24
158
Getting Access token from Auth Server using Client details
08:32
159
Making code changes inside Spring Cloud Gateway to secure the APIs
13:10
160
Demo of Spring Cloud Gateway security inside local system
09:03
161
Generating and Pushing latest docker image of Gateway into Docker Hub
03:11
162
Installation of KeyCloak into K8s cluster using Helm chart
12:43
163
Updating Helm charts of microservices
07:46
164
Deploying all microservices into K8s and validating security changes
05:53
165
Introduction to Authorization
04:38
166
Demo of Authorization changes using Spring Security - Part 1
10:42
167
Demo of Authorization changes using Spring Security - Part 2
06:36
168
Introduction to OAuth2 Authorization code grant flow
06:02
169
Deep dive of OAuth2 Authorization code grant flow
07:36
170
Making code changes inside Accounts microservice to secure the APIs
12:25
171
Register Client details inside KeyCloak Auth server for Spring Cloud Gateway
05:57
172
Making code changes inside Spring Cloud Gateway
12:42
173
Demo of OAuth2 Authorization code grant flow inside local system
11:37
174
Updating Helm charts of microservices
14:03
175
Deploy all microservices into K8s cluster and demo of Authorization code flow
13:15
176
Introduction to Kubernetes Ingress
09:51
177
Introduction to Service mesh
07:03
178
Deep dive on Service mesh and Istio
10:52
179
Thank You & Congratulations
01:58
Unlock unlimited learning

Get instant access to all 178 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Master Microservices with Java, Spring, Docker, Kubernetes?

More courses by Udemy

Frequently asked questions

What prerequisites are needed for this course?
A foundational understanding of Java programming is essential for this course, as the microservices will be built using Java-based frameworks like Spring and Spring Boot. Familiarity with basic web development concepts will also be beneficial. Prior experience with containerization technologies such as Docker is not mandatory but will help in understanding the course content more easily.
What projects will I build during the course?
You will build several microservices throughout the course, including a Bank Accounts Microservice, a Bank Loans Microservice, and a Bank Cards Microservice. These projects will utilize Spring Boot for development and Docker for containerization. You will also engage in setting up configuration management, service discovery, and other microservices architecture components.
Who is the target audience for this course?
This course is targeted at Java developers who are interested in microservices architecture and cloud-native technologies. It is also suitable for software architects who want to transition from monolithic or SOA architectures to microservices, as well as DevOps engineers looking to expand their knowledge of Docker and Kubernetes in managing microservices.
How does this course compare in depth to other microservices courses?
This course offers an extensive exploration of microservices architecture using Java, with detailed segments on Spring Boot, Spring Cloud, Docker, and Kubernetes. It covers not only the basics of building microservices but also advanced topics like distributed tracing, log aggregation, service discovery, and deployment using Kubernetes on GCP. It is comprehensive compared to courses that may focus solely on one technology.
Which specific tools and platforms will I learn to use?
The course covers a range of tools and platforms including Spring Boot and Spring Cloud for microservices development, Docker for containerization, and Kubernetes for orchestration. You will also use Spring Cloud Config Server for configuration management, Spring Eureka Server for service discovery, and tools like Prometheus and Grafana for monitoring.
What topics are not covered in this course?
The course does not cover non-Java based microservices frameworks or other container orchestration systems beyond Kubernetes. It focuses specifically on Java and Spring-based microservices, and does not delve into alternative programming languages or platforms for microservices development.
How much time should I expect to dedicate to this course?
The course consists of 179 lessons, and while the total runtime is not specified, students should anticipate a significant time commitment to work through the detailed topics and hands-on projects. The depth of content, including exercises in Docker and Kubernetes, suggests that consistent study and practice over several weeks may be necessary to fully grasp all concepts.