CF

Spring Boot Microservices and Spring Cloud. Build & Deploy.

20h 33m 14s
English
Paid

Spring Boot Microservices and Spring Cloud. Build & Deploy. is a 259-lesson 20 hours 33 minutes self-paced course by Udemy. This course helps you build simple RESTful microservices from scratch.

Course facts

Lessons
259
Duration
20 hours 33 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

This course helps you build simple RESTful microservices from scratch. You follow clear steps. You run your services on your own machine and in Docker on AWS EC2. You move from the basics to a full Spring Boot and Spring Cloud setup.

What You Build

  • RESTful microservices
  • Eureka Discovery Service
  • Zuul API Gateway
  • Spring Cloud API Gateway
  • Load balancer
  • Spring Cloud Config Server

Tools You Use

  • Spring Cloud Bus with RabbitMQ
  • Spring Boot Actuator

API Security

You add security to your REST API. You build login and user signup features.

  • Spring Security with JWT

Data and Storage

  • Spring Data JPA for user data
  • H2 in-memory database with console
  • MySQL database server
  • Postman for API calls
  • Spring Tool Suite
  • Spring Initializr

Tracing and Logs

  • Trace HTTP requests with Spring Cloud Sleuth and Zipkin
  • Use the ELK stack for central logs: Logstash, Elasticsearch, Kibana

Deploy on AWS

  • Start an EC2 Linux server
  • Install Docker
  • Create Docker images
  • Run microservices in Docker on several EC2 machines

Who teaches Spring Boot Microservices and Spring Cloud. Build & Deploy.? 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 Spring Boot Microservices and Spring Cloud. Build & Deploy.?

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Course Overview
All Course Lessons (259)
#Lesson TitleDurationAccess
1
Course Overview Demo
07:24
2
A few suggestions
03:30
3
What is a Microservice?
07:12
4
Sample Microservices Architecture
07:21
5
Download and Install Postman HTTP Client
04:49
6
Postman Overview
09:10
7
Resource and Collection URIs
11:13
8
HTTP Methods: GET, POST, DELETE and PUT
03:45
9
HTTP Headers: Accept and Content Type
04:13
10
Install Java Platform(JDK)
05:49
11
Download and Install Spring Tool Suite(STS)
03:27
12
Introduction
00:42
13
Creating a New Project
06:13
14
Creating a new Spring project using Spring Boot Initializr
04:43
15
Create Users Rest Controller class
02:46
16
Adding Methods to Handle POST, GET, PUT, DELETE HTTP requests
03:14
17
Running Web Service Application
04:37
18
Reading Path Variables with @PathVariable annotaion
03:32
19
Reading Query String Request Parameters
04:52
20
Making Parameters Optional or Required
04:36
21
Returning Java Object as Return Value
04:12
22
Returning Object as JSON or XML Representation
05:36
23
Set Response Status Code
04:59
24
Reading HTTP POST Request Body. The @RequestBody annotation.
08:14
25
Validating HTTP POST Request Body
08:57
26
Store Users Temporary
04:51
27
Handle HTTP PUT Request
09:07
28
Handle HTTP Delete Request
04:53
29
Handle an Exception
07:45
30
Return Custom Error Message Object
05:36
31
Handle a Specific Exception
03:07
32
Throw and Handle You Own Custom Exception
04:14
33
Catch More Than One Exception with One Method
02:55
34
Dependency Injection: Create and Autowire a Service Layer Class
10:55
35
Constructor Based Dependency Injection
06:26
36
Run Web Service as a Standalone Application
04:53
37
Introduction to Eureka Discovery Service
04:30
38
Startup Eureka Service Discovery
05:40
39
Introduction to Building a Users Microservice
02:11
40
Users Microservice - Create new Spring Boot Project
03:41
41
Enable Eureka Client
03:02
42
Create Users Rest Controller
02:05
43
Access Users Web Service Endpoint via Eureka Discovery Service
03:00
44
Introduction to Building an Account Management Microservice
01:35
45
Create a new Spring Boot Project
04:00
46
Access Account Management Microservice via Eureka Discovery Service
02:57
47
Important note
01:49
48
Introduction to Zuul API Gateway
03:25
49
Create a ZUUL API Gateway Project
03:38
50
Access Microservices via API Gateway
04:15
51
Load Balancer - Introduction
00:51
52
Starting Up More Microservices
08:59
53
Trying How Load Balancer Works
04:48
54
Important Note
01:44
55
Introduction
06:28
56
Creating API Gateway Project
05:05
57
Automatic Mapping of Gateway Routes
06:50
58
Manually Configuring API Gateway Routes
07:50
59
Trying how it works
04:09
60
Rewriting URL Path
05:07
61
Automatic & Manual Routing
01:58
62
Starting Up More Microservices
08:59
63
Trying How Load Balancer Works
03:54
64
H2 In-memory Database. Introduction.
03:20
65
H2 Database Console Overview
07:41
66
Adding Support for the H2 Database
04:45
67
Introduction
00:42
68
Adding method to handle HTTP Post Request
01:15
69
Implementing the Create User Request Model class
03:18
70
Validating HTTP Request Body
04:17
71
Application Layers
02:49
72
Implementing Service Layer Class
02:11
73
Create a Shared DTO Class
03:16
74
Generate Unique Public User Id
02:17
75
Adding Support for Spring Data JPA
02:02
76
Implementing User Entity Class
06:08
77
Implementing Spring Data JPA CRUD Repository
02:35
78
Save User Details in Database
11:16
79
Return Http Status Code
02:30
80
Implementing Create User Response Model
04:31
81
Add Spring Security to Users Microservice
01:16
82
[Updated] Add WebSecurity Configuration
08:44
83
[Updated] Encrypt User Password
06:27
84
[Updated] Allow Requests from API Gateway Only
04:51
85
Trying how it works
04:16
86
[Updated] Adding Support to Return XML
04:18
87
Introduction
01:11
88
Implementing LoginRequestModel
01:22
89
[Updated]AuthenticationFilter. Implementing attemptAuthentication()
05:27
90
Register Authentication Filter with HTTP Security
03:07
91
Implementing loadUserByUsername() method
10:32
92
successfullAuthentication(): Get User Details.
07:11
93
successfullAuthentication(): Adding JWT Dependencies
02:15
94
sucessfullAuthentication(): Generate JWT
07:06
95
Configure API Gateway route to /login
02:41
96
[Updated] Trying how /login works
04:54
97
[Updated] Customize User Authentication URL
04:37
98
Introduction to Spring Security on API Gateway
01:54
99
Adding Support for Spring Security and JWT Tokens
01:18
100
Enable Web Security in Zuul
04:30
101
Allow Access to Registration and Login Urls
05:07
102
Implementing Authorization Filter
08:44
103
Accessing Protected Microservices with Access Token
05:23
104
Introduction
03:11
105
Using Header Predicate
04:05
106
[Updated]Adding Support for JWT Token Validation
02:28
107
Creating AuthorizationFilter class
03:50
108
Assign Custom Filter to a Gateway Route
01:13
109
Signup and Login Routes
03:06
110
Reading Authorization HTTP Header
07:43
111
[Updated] Validating JWT Access Token
08:40
112
Accessing Protected Microservices with Access Token
06:40
113
Introduction
01:03
114
Creating Global Pre Filter
03:52
115
Accessing Request Path and HTTP Headers
03:33
116
Trying how Pre Filter Works
03:50
117
Creating Global Post Filter
03:06
118
Trying how the Post Filter works
02:39
119
Defining Filters in a Single Class
06:42
120
Ordering Global Filters
06:43
121
Trying how ordered filters work
02:23
122
Introduction to Spring Cloud Config Server
04:04
123
Create Your Own Config Server
02:54
124
Create Private GitHub Repository
02:25
125
Naming Property Files Served by Config Server
02:33
126
Configure Config Server to Access Private GitHub Repository
02:47
127
Adding Properties File to Git Repository
03:17
128
Configure Users Microservice to be a Client of Config Server
07:25
129
Make Zuul Gateway a Client of Config Server
02:19
130
Introduction to Spring Cloud Bus
03:53
131
Add Spring Cloud Bus & Actuator Dependencies
02:28
132
Enable the /busrefresh URL Endpoint
01:48
133
Download and Run Rabbit MQ
03:21
134
Rabbit MQ Default Connection Details
02:16
135
Trying how Spring Cloud Bus Works
08:38
136
Change default Rabbit MQ Password
03:30
137
Introduction to Spring Cloud Config File System as a Backend
00:46
138
Setting up File System Backend
04:52
139
Previewing Values Returned by Config Server
01:42
140
Trying how Microservices work
02:39
141
Introduction
02:32
142
Shared and a Microservice specific properties
07:02
143
Introduction to Spring Boot Actuator
02:46
144
[Updated] Add Spring Boot Actuator to Spring Cloud Gateway
02:01
145
Enable Actuator's /gateway and /mappings endpoints
03:47
146
View Spring Cloud API Gateway Routes using Actuator
03:27
147
Enable Actuator for Users Microservice
04:02
148
Trying how Actuator works in Users Microservice
03:03
149
Actuator /httpexchanges endpoint
05:26
150
Introduction
01:01
151
Download and Install MySQL
03:17
152
Start MySQL Server and Login
06:15
153
Create MySQL Database And a New User
06:26
154
Downloading and Installing MySQL Workbench
03:03
155
Connect to MySQL Database using MySQL WorkBench
05:28
156
MySQL WorkBench brief overview
04:16
157
Configure MySQL Database Access Details
09:49
158
Use H2 Console to Access MySQL Database
02:49
159
Copy MySQL properties to a Config Server
01:41
160
Introduction to Encryption and Decryption of Configuration Properties
02:44
161
Add Java Cryptography Extension
06:15
162
Symmetric Encryption of Properties
08:51
163
Creating a Keystore for Asymmetric Encryption
05:06
164
Asymmetric Encryption of Properties
05:26
165
Introduction to Microservices Communication
03:49
166
Clone Source Code of Albums Microservice
02:12
167
A walk through an Albums Microservice
05:38
168
Implementing Get User Details
05:45
169
Make Users Microservice call Albums Microservice
10:27
170
Trying how it works
04:00
171
Feign Web Service Client - Introduction
01:33
172
Enable Feign in Spring Boot Project
01:56
173
Create Feign Client
05:08
174
Using Feign Client
01:48
175
Trying How Feign Client Works
03:13
176
Enable HTTP Requests Logging in Feign Client
05:42
177
Handle FeignException
04:37
178
Handle Response Errors with Feign Error Decoder
12:58
179
Introduction
02:56
180
Configure Project to use Hystrix Circuit Breaker
04:29
181
Trying How Hystrix Circuit Breaker & Feign work
03:11
182
Error Handling with Feign Hystrix FallbackFactory
11:06
183
Introduction
07:55
184
Removing Hystrix Circuit Breaker
02:42
185
Adding Resilience4j
03:17
186
Actuator /health Endpoint
02:33
187
Feign Client & Circuit Breaker Fallback method
04:23
188
Circuit Breaker configuration properties
07:06
189
Configure Access to Actuator endpoints
04:51
190
Monitoring Circuit Breaker events in Actuator
07:27
191
@Retry annotation
01:37
192
Aspect Order
03:14
193
Configuration properties
03:03
194
Trying how it works
03:53
195
[Updated]Introduction to Distributed Tracing with Micrometer and Zipkin
03:44
196
[Updated] Starting up Zipkin
03:19
197
[Updated]Add Micrometer and Zipkin dependencies
04:36
198
Micrometer Tracing Sampling Probability
02:17
199
Logging TraceId and SpanId
03:33
200
Configure Micrometer to work with Feign
01:49
201
View traces in Zipkin Dashboard
06:19
202
Trace Requests Sent with RestTemplate
05:33
203
Introduction to Aggregating Log Files with ELK Stack
02:05
204
Configure Microservices to Log into a File
02:56
205
Download Logstash
01:40
206
Configure Logstash to Read Log Files
09:12
207
[New]Download and Run Elasticsearch with Security Enabled
05:57
208
[New]Configure Elasticsearch Security in Logstash
05:05
209
Run Search Query
06:51
210
[Updated]Download, Install and Run Kibana
04:59
211
[Updated]View Aggregated Logs in Kibana
05:32
212
Configure Spring Security to Eureka Server
02:16
213
[Updated] Enable Web Security
05:24
214
Configure Eureka Clients to use Username and Password
03:11
215
Configure Eureka Service URL in Config Server
04:21
216
Move Username and Password to Config Server
04:01
217
Encrypting Username and Password
06:04
218
Introduction to Running Microservices in Docker Containers
08:00
219
Start up a new Linux Server on AWS EC2
14:57
220
Connect to EC2 Instance
04:47
221
Install Docker on AWS EC2
01:52
222
Docker Hub Introduction
01:58
223
Run RabbitMQ Docker Container
09:13
224
Basic Docker Commands: Run, Stop, Start, Remove Containers and Images
06:50
225
Create Config Server Docker Image
09:49
226
Publish Config Server Docker Image to Docker Hub
04:28
227
Run Config Server on EC2 from Docker Hub
10:23
228
Start New EC2 Instance for Eureka
03:24
229
Build Docker Image for Eureka Discovery Service
04:02
230
Run Eureka in Docker container
11:21
231
Elastic IP address for EC2 Instance
04:42
232
Create Zuul Api Gateway Docker Image
04:42
233
Run Zuul Api Gateway in Docker Container
08:04
234
Run Elastic Search in Docker container
05:56
235
Run Kibana in Docker Container
06:35
236
Run Kibana and Elastic Search on the same Network
04:32
237
Docker Image for Albums Microservice
04:28
238
Run Albums Microservice Docker Image on EC2
10:50
239
Logstash Docker Image for Albums Microservice
08:51
240
Run Logstash in Docker container
04:35
241
Run MySQL in Docker Container
08:38
242
Make MySQL Docker Container Persist Data on EC2
03:20
243
Build Users Microservice Docker Image
04:23
244
Run Users Microservice in Docker container
10:00
245
Run Logstash for Users Microservice
07:52
246
Introduction
05:10
247
Preparing Configuration for another environment
08:32
248
Creating Beans Based on Spring Boot @Profile used
11:33
249
Running Docker Container for Different Environments
01:03
250
Introduction
06:31
251
Pass Authorization Header to Downstream Microservice
01:23
252
[Updated] Create and register the AuthorizationFilter
09:25
253
[Updated]Register Authorization Filter with HTTP Security
02:54
254
[Updated] Trying how it works
04:29
255
Introduction to Method-Level security
04:56
256
[Updated] Enable Method Level Security
02:28
257
@PreAuthorize annotation example
03:31
258
Trying how @PreAuthorize annotation works
03:03
259
@PostAuthorize annotation example
07:12
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to Spring Boot Microservices and Spring Cloud. Build & Deploy.?

More courses by Udemy

Frequently asked questions

What prerequisites do I need to start this course?
Before starting this course, you should have a basic understanding of Java programming and familiarity with the Java Development Kit (JDK). The course will guide you through installing the necessary tools such as the Spring Tool Suite and Postman, but prior experience with these tools can be beneficial. Understanding HTTP methods and RESTful principles will also help, as you will be building and interacting with RESTful microservices.
What kind of projects will I build during the course?
In this course, you'll build several projects including RESTful microservices, a Eureka Discovery Service, and API gateways using Zuul and Spring Cloud. You will also set up a Spring Cloud Config Server and a load balancer. These projects will help you understand microservices architecture, service discovery, and API management.
Who is the target audience for this course?
This course is designed for Java developers interested in learning how to build and deploy microservices using Spring Boot and Spring Cloud. It is suitable for those who want to understand microservices architecture and implement it with a hands-on approach. Developers looking to enhance their skills in API security, data storage, and cloud deployment will find this course particularly useful.
What specific tools and platforms are covered in the course?
The course covers a variety of tools and platforms essential for building microservices. You'll use Spring Boot, Spring Cloud, and Spring Data JPA for developing services. Postman is used for API testing, and RabbitMQ with Spring Cloud Bus is used for messaging. For deployment, you'll work with Docker on AWS EC2, and for security, Spring Security with JWT is covered.
What is not covered in this course that I might need to learn separately?
The course does not cover front-end development or client-side technologies in detail. While it touches on API security and data storage, it does not delve into advanced topics in these areas, such as OAuth2 or advanced database optimization techniques. Additionally, detailed AWS services beyond EC2 and Docker are not explored.
How much time should I expect to commit to this course?
The course consists of 259 lessons, and though the total runtime is listed as 00:00:00, you should be prepared to invest a significant amount of time. This includes not just watching the lessons but also setting up your environment, following along with hands-on exercises, and completing projects. It's advisable to set aside several weeks if you plan to thoroughly absorb the material and practice.
How can the skills gained from this course benefit my career?
The skills you gain in this course are highly applicable in the software development industry, particularly in roles focused on backend development and cloud computing. Understanding how to build and deploy microservices using Spring Boot and Spring Cloud is valuable for positions in companies adopting microservices architecture. Additionally, the knowledge of API security, cloud deployment on AWS, and containerization with Docker is in demand across many tech industries.