CF

Complete Microservices with Go

18h 31m 16s
English
Paid

Learn how real microservices work in Go. You build a small ride‑sharing app step by step. You use Go, Docker, and Kubernetes to design, build, and run each service.

You also work through a short advanced Go module. It gives you the tools you need to follow the project, even if you are still growing your Go skills.

By the end, you deploy a scalable ride‑sharing app. You also get a clean service template that you can reuse in your own projects.

The system uses several services that run under Kubernetes. Users can pick a route, set a rate, and book a driver from a shared pool.

What You Learn

You learn how to design and build backend systems with many services. You follow clear steps that show how to use common tools and patterns. You ship a setup that is stable, fast, and easy to update.

Key Skills

  • Plan services and set clear roles for each one.
  • Write clean and testable Go code.
  • Build and run services with Docker.
  • Deploy services on Kubernetes.
  • Use logs, metrics, and traces to debug issues.

How the Course Helps You

This course does more than walk you through steps. It helps you think like a backend engineer. You face real problems and learn simple ways to solve them with proven tools.

What You Gain

  • A clear workflow for building microservices.
  • Practice with real service boundaries and data flow.
  • Hands‑on skill with Docker and Kubernetes.
  • Experience making services that are safe to deploy and easy to fix.

About the Author: 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.

Watch Online 90 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Introduction
All Course Lessons (90)
#Lesson TitleDurationAccess
1
Introduction Demo
01:53
2
Project Overview
04:14
3
Tech Stack Overview
06:22
4
Coming from a Monolith
12:21
5
Microservices Guiding Design Principles
13:35
6
Communication Styles
15:23
7
Architecture Definition Process
11:24
8
Effective Error Handling
15:29
9
Interfaces
16:17
10
Testing
06:18
11
Pointers
12:16
12
Goroutines
10:14
13
Context and Timeouts
13:30
14
Concurrency with Channels
13:21
15
Maps
06:21
16
Map Concurrency & Mutexes
12:07
17
Windows Users Setup
12:06
18
Mac/Linux Setup
07:35
19
Structuring a Microservice project
12:11
20
Theory: Clean Architecture & Repository Pattern
09:31
21
Part 1: Layered Architecture
07:54
22
Part 2: Repository Pattern
23:23
23
Why Kubernetes and Tilt
09:31
24
Role of the API Gateway
07:24
25
Implementing an HTTP Server
25:09
26
External API communication (OSRM)
20:15
27
Preparing for External API Failures
02:57
28
Gracefull shutdown
14:44
29
Understanding WebSockets
09:10
30
Implementing WebSocket connections
22:29
31
Handling CORS
16:08
32
gRPC Introduction
08:54
33
Protocol Buffer file generation process
05:31
34
Defining the Trip Proto
15:49
35
Implementing the Gateway Trip gRPC Client
16:55
36
gRPC Server implementation on Trip Service
12:22
37
Preview Trip Handler - Part #1
12:44
38
Preview Trip Handler - Part #2
20:49
39
Why & What are Ride Fares
05:56
40
Ride Pricing Estimation
32:51
41
Implementing the TripStart gRPC handler
21:31
42
Introduction to Kubernetes
06:15
43
Kubernetes Under the Hood
14:12
44
Kubernetes Components
16:38
45
Creating Deployment Files
22:57
46
Doing our first production deployment
19:29
47
Bootstrapping the Service
16:22
48
Small Tiltfile Compilation Fix
01:21
49
Final Adjustments to the Route
03:10
50
Introduction to Async communication
12:33
51
Setting up RabbitMQ
11:48
52
Connecting to RabbitMQ
13:06
53
RabbitMQ Services Dependency
03:32
54
Publishing the First Message
21:54
55
Message Durability
08:01
56
Consuming Messages
11:34
57
Message Distribution & Acknowledgment
14:57
58
Fair Dispatch
06:12
59
The Pub/Sub Pattern
17:11
60
Implementing the Exchange & Topics flow
21:19
61
JSON Message Sending & Consuming
13:20
62
Finding a Suitable Driver
18:04
63
Understanding how to notify our users
06:40
64
WebSocket Connection Manager
08:52
65
Queue Consumer
14:11
66
Handling incoming messages from the driver
11:02
67
Listening for Trip Accept event
26:39
68
Declining a Trip Request
04:31
69
Payment Flow Overview
04:44
70
Payment Service setup
05:46
71
Adding the Stripe secret key
06:15
72
Stripe Processor Implementation
18:45
73
Listening to the Payment Event
14:57
74
Stripe Payment Webhook
20:17
75
Intro to Distributed Tracing
09:33
76
Setting up Tracing
13:54
77
Jeager Exporter
13:13
78
HTTP Instrumentation
13:57
79
gRPC Instrumentation
11:36
80
RabbitMQ Instrumentation
14:57
81
Understanding DLQ and Retries
07:30
82
Implementing Message Retries
13:04
83
Implementing DLQ and DLX
10:25
84
Introduction to MongoDB
10:25
85
MongoDB Connection
14:23
86
MongoDB Repository
07:25
87
Adding BSON to the Domain Structs
03:42
88
Dockerizing our project for production
10:19
89
Kubernetes Cluster Deployment
14:08
90
Port Forwarding
01:17
Unlock unlimited learning

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

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites are needed before starting this course?
Before starting the course, you should have a basic understanding of programming with Go. The course includes an advanced Go module to help you follow the project even if you are still developing your Go skills. Familiarity with general programming concepts and some experience with development environments on Windows, Mac, or Linux will also be beneficial.
What will I build during the course?
You will build a small ride-sharing app using microservices architecture. The project is developed step-by-step, covering various aspects such as service design, clean architecture, and repository patterns. By the end, you will have a scalable app deployed on Kubernetes, along with a reusable service template for future projects.
Who is the target audience for this course?
The course is designed for developers interested in backend engineering and microservices. It is suitable for those wanting to deepen their Go programming skills and learn how to deploy scalable applications using Docker and Kubernetes. The course also benefits developers transitioning from monolithic architectures to microservices.
How does the depth of this course compare to similar courses?
This course provides a comprehensive look at building microservices with Go. Unlike some courses that might focus solely on the basics, this one covers advanced topics such as gRPC, Kubernetes, and RabbitMQ for async communication. You gain practical experience by handling real-world problems and deploying a production-ready application.
What tools and platforms are specifically covered in this course?
The course covers essential tools and platforms for building microservices, including Go for programming, Docker for containerization, and Kubernetes for deployment. You also learn about RabbitMQ for asynchronous communication and various communication protocols such as HTTP, WebSockets, and gRPC.
Are there any topics not covered in this course?
While the course covers a wide range of topics related to microservices and backend development, it does not focus on frontend development aspects or user interface design. The primary focus is on backend services, clean code practices, and deployment techniques.
How much time should I expect to commit to this course?
The course consists of 90 lessons. Although the total runtime is not specified, you should expect to dedicate time to both the video content and the hands-on exercises. Completing the course successfully will require a commitment to actively engaging with the material and applying the concepts in practical projects.