CF

Microservices and Distributed Systems

11h 18m
English
Paid

Microservices and Distributed Systems is a 166-lesson 11 hours 18 minutes self-paced course by Nelson Djalo (Amigoscode). Microservices are an architectural and organisational approach to software development where software is composed of small independent services that communicate over well-defined APIs.

Course facts

Lessons
166
Duration
11 hours 18 minutes
Level
All levels
Language
English
Updated
Instructor
Nelson Djalo (Amigoscode)
Price
Premium

Microservices are an architectural and organisational approach to software development where software is composed of small independent services that communicate over well-defined APIs. These services are owned by small, self-contained teams.

Microservices architectures make applications easier to scale and faster to develop, enabling innovation and accelerating time-to-market for new features.

In this course you will learn how to build Microservices from scratch using Spring Cloud which provides tools for developers to quickly build some of the common patterns in distributed systems such configuration management, service discovery, circuit breakers, intelligent routing, micro-proxy, control bus, one-time tokens, global locks, leadership election, distributed sessions, cluster state

You will also learn about Docker and Kubernetes allowing you to containerise your Microservices and deployment to the most popular open-source container orchestration engine called Kubernetes. Kubernetes offers the ability to schedule and manage containers at scale.

Topics Covered

  • Spring Boot Microservices
  • Maven (Including Multi Module, Builds and Profiles)
  • Spring Data JPA
  • Message Queue with RabbitMQ and Kafka
  • Spring Cloud (OpenFeign, Service Discovery, Distributed Tracing)
  • Configuration and Secrets management
  • Packing Jars with Jib
  • Docker
  • Kubernetes
  • Plenty of Exercise


Additional

https://github.com/amigoscode/microservices 

Diagram https://raw.githubusercontent.com/amigoscode/microservices/78d93c2caa7274951ff5258e5414a59b870f50a9/diagrams.drawio and save with .drawio file extension then open it with https://www.diagrams.net/

Who teaches Microservices and Distributed Systems? Nelson Djalo (Amigoscode)

Nelson Djalo (Amigoscode) thumbnail

Nelson Djalo publishes the Amigoscode YouTube channel and standalone course platform — one of the largest independent Java / Spring Boot tutorial sources online, with several million subscribers and a multi-year track record of weekly back-end engineering tutorials.

The course catalog covers the full Java back-end stack: Java fundamentals, Spring Boot for production web services, Spring Security and OAuth, Spring Data and JPA, microservices patterns with Spring Cloud, Kafka and event-driven architecture, Docker and Kubernetes for the deployment layer, AWS for cloud infrastructure, and the database side (PostgreSQL, MongoDB, Redis). Material is project-oriented — most courses build a working microservice or full application end-to-end.

The CourseFlix listing under this source carries over 13 Amigoscode courses spanning that range. Material is paid; Amigoscode runs on per-course or membership pricing on the original platform. Courses are aimed at Java developers building production back-end services.

What lessons are included in Microservices and Distributed Systems?

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: 1 - Few Words Before We Begin
All Course Lessons (166)
#Lesson TitleDurationAccess
1
1 - Few Words Before We Begin Demo
01:08
2
2 - Join The Community
00:52
3
3 - Course Overview
03:38
4
1 - Maven
02:39
5
2 - IntelliJ
02:07
6
3 - Open The Project with IntelliJ
01:41
7
4 - Maven Parent Module
07:01
8
Intro
00:42
9
1 - Spring Cloud
03:36
10
2 - Create Your First Microservice
07:58
11
3 - Model Controller and Service
05:32
12
4 - Postgres and PGAdmin on Docker
04:30
13
5 - Connecting to DB
08:07
14
6 - Databases
01:18
15
1 - Intro
01:15
16
2 - Fraud Microservice
04:46
17
3 - Database Setup for Fraud
04:42
18
4 - Fraud Controller Service and Repository
07:42
19
5 - RestTemplate
05:24
20
6 - Testing Microservice Communication
03:10
21
1 - Service Discovery
04:09
22
2 - Spring Cloud Dependency
03:38
23
3 - Setting up Eureka Server
05:37
24
4 - Dashboard
01:55
25
5 - Eureka Clients
07:40
26
6 - @LoadBalanced
06:53
27
1 - Open Feign
02:33
28
2 - Feign client Feign
06:31
29
3 - Using Fegin Client
04:59
30
4 - Microservice Communication With Feign
02:57
31
1 - Exercise
01:53
32
2 - Solution
04:13
33
1 - Distributed Tracing
03:42
34
2 - Adding Sleuth
03:47
35
3 - Zipkin
01:05
36
4 - Zipkin Container
02:58
37
5 - Spring Cloud Sleuth Zipkin
03:26
38
6 - Zipkin Dashboard
06:39
39
1 - What are Load Balencers
09:58
40
2 - Load Balancer Algorithms
02:54
41
3 - Load Balancer Health Checks
02:05
42
4 - Spring Cloud Gateway
02:57
43
5 - Bootstrap API Gateway
04:14
44
6 - Configuring API Gateway
02:45
45
7 - API Gateway in Action
03:07
46
1 - Why a message queue
03:53
47
2 - Simulate Slow Response
04:31
48
3 - AMQP & RabbitMQ
06:28
49
4 - Kafka RabbitMQ and SQS
04:20
50
5 - AMQP Exchange Types
04:56
51
1 - Rabbit MQ Container
03:32
52
2 - AMQPTemplate and JacksonConverter
06:27
53
3 - SimpleRabbitListenerContainerFactory
04:37
54
4 - Notification Queue Configuration
04:29
55
5 - Queue Topic and Binding
04:01
56
6 - Message Producer
03:45
57
7 - Publishing Messages
09:17
58
8 - Customer Microservice Publishing Messages To Queue
05:50
59
9 - @RabbitListener
07:09
60
12 - We made it. Our code is Asynchronous
02:16
61
1 - Intro
00:54
62
2 - Maven Compiler Plugin
07:23
63
3 - Spring Boot Maven Plugin
06:20
64
4 - Installing Root and Individual Modules with Maven
06:35
65
5 - Running all Jars
09:15
66
1 - Intro
01:08
67
2 - What is Docker
01:32
68
3 - Docker Images and Containers
03:18
69
4 - Docker Architecture
02:43
70
5 - Docker Registries
04:13
71
6 - Docker Login
05:49
72
7 - Spring Boot Maven Plugin and Jib
02:34
73
8 - Jib Maven Plugin
08:39
74
9 - Jib Sub Module Configuration
04:38
75
10 - Build and Push
05:17
76
11 - Exercise
01:43
77
12 - Exercise Solution
03:09
78
13 - Adding Eureka Server and ApiGW to Docker Compose
02:49
79
14 - Docker Network
02:12
80
15 - Spring Profiles
03:43
81
16 - ApiGW and Eureka Server Docker Containers
03:57
82
17 - Exercise 2
00:34
83
18 - Exercise 2 Solution
08:20
84
1 - Intro
00:50
85
2 - What is Kubernetes
04:17
86
3 - Master and Control Plane
08:30
87
4 - Worker Nodes
06:22
88
5 - Running Kubernetes Clusters
04:45
89
6 - Minikube
06:41
90
7 - Installing Kubectl
05:53
91
8 - Kubernetes Hello World
07:13
92
9 - Pods
03:03
93
10 - Deployments
04:11
94
11 - Services
03:01
95
12 - Service Discovery
06:32
96
1 - IntelliJ k8s Plugin
02:33
97
2 - Never Deploy Postgres on k8s. Only for local testing
02:38
98
3 - Postgres YAMLs
09:46
99
4 - Postgres Running in k8s
05:26
100
5 - Exercise
00:48
101
6 - Exercise Sol
07:51
102
1 - Intro
01:32
103
3 - Disabling Eureka
01:52
104
4 - Refactor Feign Clients
07:14
105
5 - Adding SPRING_PROFILES_ACTIVE=default
06:08
106
6 - Kube Profile
04:41
107
7 - Building new Images and Testing Docker Compose
04:34
108
1 - Section Overview
00:21
109
2 - Customer YAMLs
06:36
110
3 - Customer Up in Running in k8s
03:38
111
5 - Exercise Solution
04:01
112
6 - We done it. Microservices running in k8s
04:48
113
2 - Linode
02:23
114
3 - Create K8s Cluster
04:39
115
4 - Dashboard Overview
02:30
116
5 - Kubernetes Dashboard
03:02
117
6 - Connect To Cluster Using kubectl
03:02
118
7 - Postgres
05:37
119
8 - Zipkin and LoadBalancers
05:33
120
9 - RabbitMQ
01:30
121
10 - Deploying Microservices
04:06
122
11 - Testing deployment
02:53
123
13 - Managed Postgres Database
02:34
124
14 - Connecting to Managed Database
06:31
125
15 - Override DB Connection Details with Env Variabales
04:52
126
16 - Apply Customer yaml
02:45
127
17 - Apply Notification and Fraud
05:47
128
18 - Testing everything
03:08
129
19 - Destroy resources
05:02
130
1 - Intro
00:34
131
2 - What is Kafka
07:56
132
3 - Kafka Broker
04:54
133
4 - Bootstrap Project
02:04
134
5 - Topic
02:58
135
6 - Kafka Producer Config
05:56
136
7 - Kafka Template Send
03:39
137
8 - Kafka Consumer
03:59
138
9 - ConsumerConfig
05:20
139
10 - @KafkaListener
03:57
140
11 - Restful Api and Kafka Integration
04:30
141
12 - Custom Objects
08:32
142
13 - Trusted Packages
03:57
143
14 - Deployment and Managed Kafka
02:00
144
15 - Spring for Apache Kafka Documetation
01:07
145
16 - Outro
00:26
146
Bring Back APIW and Eureka Server
00:47
147
Enabling Eureka Client
00:57
148
Starting All Services
05:15
149
Testing POST request
03:19
150
API Key Authentication
03:15
151
Key and Applications Overview
02:47
152
ApiKeyAuthorization Filter
03:52
153
Ordering the Filter
01:15
154
Testing the Filter
02:37
155
Api Key Validation Overview
01:01
156
Extracting the Route
04:29
157
Attaching ApiKey to request
01:43
158
Accesing Key From Request Header
03:40
159
FakeApiAuthorizationChecker
03:58
160
Testing API Authentication Flow
03:40
161
1 - Don't Use Spring Cloud Config Server
05:49
162
2 - Vault and Secrets Management
01:15
163
3 - Reporting Service
01:57
164
4 - Security
02:07
165
5 - Deployment
06:11
166
6 - Outro
01:59
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to Microservices and Distributed Systems?

Frequently asked questions

What are the prerequisites for enrolling in this course?
Before enrolling in the Microservices and Distributed Systems course, students should have a foundational understanding of Java programming and basic knowledge of software development practices. Familiarity with tools like Maven and IntelliJ, as covered in the early lessons, will be beneficial. Additionally, a basic understanding of databases will aid in sections that involve Postgres and PGAdmin on Docker.
What specific projects or systems will I build during the course?
Throughout the course, students will build several microservices, such as the Fraud Microservice, and integrate them using tools like Spring Cloud and Eureka for service discovery. The course also includes setting up message queues with RabbitMQ and creating an API Gateway using Spring Cloud Gateway. These projects provide hands-on experience with real-world applications of microservices architecture.
Who is the target audience for this course?
This course is designed for software developers and engineers who are interested in learning about microservices architecture and distributed systems. It is particularly useful for those working on, or planning to work on, projects that require the decomposition of monolithic applications into smaller, manageable services.
What specific tools and platforms does the course cover?
The course covers a variety of tools and platforms integral to microservices architecture, including Spring Cloud, Docker, Eureka for service discovery, and RabbitMQ for messaging. It also involves the use of IntelliJ as the primary IDE and Maven for project management. Students will also explore distributed tracing with Sleuth and Zipkin.
What topics are not covered in this course?
The course does not delve into frontend development or the user interface aspects of software applications. It is focused primarily on backend architecture, communication between services, and the infrastructure required to support distributed systems. Advanced topics in security and performance optimization may also not be covered extensively.
How much time should I expect to commit to complete this course?
While the total runtime of the course is not specified, students should anticipate dedicating several weeks to complete all 166 lessons, especially if they engage deeply with the practical exercises and projects. The time commitment will vary based on prior experience and how thoroughly students work through each module.
How does knowledge from this course apply to careers in software development?
Knowledge gained from this course is highly applicable to careers in software development, particularly in roles focusing on backend development, cloud computing, and scalable architecture. Understanding microservices and distributed systems is valuable for positions that involve designing and maintaining complex software systems, making this course a strong foundation for further specialization in these areas.