Tutorials > HandsOn Go : Microservices With Protocol Buffers & Grpc

HandsOn Go : Microservices With Protocol Buffers & Grpc


Date: 28 February 2026 | Posted by: AD-TEAM

HandsOn Go : Microservices With Protocol Buffers & Grpc
Hands-On Go : Microservices With Protocol Buffers & Grpc
Published 4/2023
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
Language: English | Size: 3.54 GB | Duration: 9h 12m


Protocol buffers (protobuf) & gRPC implementation using Go programming language (Golang) on microservice architecture

What you'll learn

What is Protocol Buffers (Protobuf) and how to use it for data communication

Protocol Buffers Schema Definition : data types, list, syntax, etc

Protocol Buffers Schema Evolution

Implement Protocol Buffers with Go programming language

Implement 4 types of gRPC API using Golang : unary, server streaming, client streaming, and bi-directional

Use PostgreSQL database with gorm : Go Object Relational Mapping (ORM)

Use Hexagon Software Architecture (Port & Adapters) to build bank application on top of gRPC API with Golang

Building resilient gRPC : using timeout / deadline, retry, and circuit breaker

gRPC error handling, status codes, metadata, interceptor

gRPC - REST API gateway

Generate OpenAPI documentation for gRPC API

Requirements

Basic Go programming language is required. This is NOT a fundamental Go course. You need to know about Go syntax, module, and package

Basic git and github knowledge is required : create repository, branch, pull, push, and merge. This is NOT basic git course

Familiarity with REST API and JSON will helps, but not mandatory

Description

This course is designed to help learners understand and implement Protocol Buffers (protobuf) and gRPC using the Go programming language on microservice architecture.The course is structured in a step-by-step manner, starting with an introduction to protobuf, its style guide, and course file structure. You will learn the theory behind various aspects of protobuf such as scalar types, repeated enum comments, protobuf JSON, nested message type, package, any, oneof, map, and schema evolution.The course also covers the implementation of gRPC and its integration with protobuf. You will learn about the grpc repository, grpc status, and error handling, resiliency server, timeout, retry, and circuit breaker. Additionally, the course covers the implementation of metadata server and client, server interceptor, client interceptor, gRPC gateway, and securing gRPC.Throughout the course, you will work on various hands-on codes that involve creating a banking application using gRPC and protobuf, as well as using PostgreSQL dataabse and Go Object Relational Mapper (ORM) to works with database. By the end of this course, you will have the skills and knowledge required to create microservices using gRPC and protobuf with the Go programming language.Requirements (must-have):Basic knowledge of the Go programming languageFamiliarity with git commands (push, pull, pull request, merge, branch)Tools:Go programming languageProtocol Buffers (protobuf)gRPCGithubVisual Studio Code (or any editor you like)The course delivered in lab-style teaching, where you are assigned with a task tobe solved. There will be a guidance for each task so you can try hands-on. If you stuck, you can jump to the full solution.The course contains 130+ lectures, which cover the following topics:Introduction to protobufWriting a protobuf (style guide)Scalar types, repeated enums, and Protobuf JSONOther message types, multiple files and import messages, nested message types, and packagesAny, oneof, and mapsReading and writing Protobuf to disk and JSONSchema evolution and additional data typesOption, field validation, and field number effect tipsIntroduction to gRPC and whether to use it or notProtobuf and gRPC repositoriesImplementing a unary server and client, server streaming, client streaming, and bidirectional streamingImplementing a bank gRPC application with database preparation, fetching exchange rates, and summarizing transactionsHandling gRPC status and errors, error handling on the client side, and resiliency techniques such as timeout, retry, and circuit breakerImplementing metadata, server and client interceptors, and a gRPC gatewaySecuring gRPC with server, client, and REST gatewayBy the end of the course, you will have gained a thorough understanding of how to implement Protocol Buffers and gRPC using the Go programming language. You will learned how to write Protobuf style guides, organize Protobuf course file structures, and work with scalar types, repeated enums, maps, any, oneof, and nested message types. They will also have learned how to read and write Protobuf to disk and JSON, handle schema evolution, and use additional data types.Furthermore, students will have gained hands-on experience in implementing various types of gRPC services, including unary, server streaming, client streaming, and bidirectional streaming. They will also have learned how to handle gRPC status and errors, implement resiliency techniques such as timeout, retry, and circuit breaker, and secure gRPC with server, client, and REST gateway.In other words, you will have gained practical skills and knowledge that you can apply to building robust and scalable microservices using Protocol Buffers and gRPC with the Go programming language.

Overview

Section 1: Welcome to The Course

Lecture 1 Welcome

Lecture 2 Course Structure & Coverage

Lecture 3 How To Get Maximum Value From This Course

Section 2: Requirements & Source Code

Lecture 4 Requirements & Tools

Lecture 5 Download Script & Source Code

Section 3: Introduction to Protocol Buffers

Lecture 6 Introducing Protocol Buffers

Lecture 7 Writing Protobuf - Style Guide & Conventions

Lecture 8 Writing Protobuf - Course File Structure

Section 4: Learning Method

Lecture 9 Learning Method

Section 5: Hello Protobuf

Lecture 10 Theory : Hello Protobuf

Lecture 11 Task : Hello Protobuf

Lecture 12 Guided Challenge : Hello Protobuf

Lecture 13 Solution : Hello Protobuf

Section 6: Scalar Types

Lecture 14 Theory : Scalar Types

Lecture 15 Task : Scalar Types

Lecture 16 Guided Challenge : Scalar Types

Lecture 17 Solution : Scalar Types

Section 7: Tips : Makefile

Lecture 18 Tips : Makefile

Section 8: Repeated Field, Enumerations, Comments

Lecture 19 Theory : Repeated Field, Enumerations, Comments

Lecture 20 Task : Repeated Field, Enumerations, Comments

Lecture 21 Guided Challenge : Repeated Field, Enumerations, Comments

Lecture 22 Solution : Repeated Field, Enumerations, Comments

Section 9: Protobuf - JSON

Lecture 23 Theory : Protobuf - JSON

Lecture 24 Task : Protobuf - JSON

Lecture 25 Guided Challenge : Protobuf - JSON

Lecture 26 Solution : Protobuf - JSON

Section 10: Using Other Message As Type

Lecture 27 Theory : Using Other Message As Type

Lecture 28 Task : Using Other Message As Type

Lecture 29 Guided Challenge : Using Other Message As Type

Lecture 30 Solution : Using Other Message As Type

Section 11: Multiple Files & Import Message

Lecture 31 Theory : Multiple Files & Import Message

Lecture 32 Task : Multiple Files & Import Message

Lecture 33 Guided Challenge : Multiple Files & Import Message

Lecture 34 Solution : Multiple Files & Import Message

Section 12: Nested Message Type

Lecture 35 Theory : Nested Message Type

Lecture 36 Task : Nested Message Type

Lecture 37 Guided Challenge : Nested Message Type

Lecture 38 Solution : Nested Message Type

Section 13: Package

Lecture 39 Theory : Package

Lecture 40 Task : Package

Lecture 41 Guided Challenge : Package

Lecture 42 Solution : Package

Section 14: Any

Lecture 43 Theory : Any

Lecture 44 Task : Any

Lecture 45 Guided Challenge : Any

Lecture 46 Solution : Any

Section 15: Oneof

Lecture 47 Theory : Oneof

Lecture 48 Task : Oneof

Lecture 49 Guided Challenge : Oneof

Lecture 50 Solution : Oneof

Section 16: Map

Lecture 51 Theory : Map

Lecture 52 Task : Map

Lecture 53 Guided Challenge : Map

Lecture 54 Solution : Map

Section 17: Read / Write Protobuf to Disk

Lecture 55 Theory : Read / Write Protobuf to Disk Theory

Lecture 56 Task : Read / Write Protobuf to Disk Theory

Lecture 57 Guided Challenge : Read / Write Protobuf to Disk Theory

Lecture 58 Solution : Read / Write Protobuf to Disk Theory

Section 18: Read / Write Protobuf as JSON

Lecture 59 Theory : Read / Write Protobuf as JSON

Lecture 60 Task : Read / Write Protobuf as JSON

Lecture 61 Guided Challenge : Read / Write Protobuf as JSON

Lecture 62 Solution : Read / Write Protobuf as JSON

Section 19: Schema Evolution

Lecture 63 Theory : Schema Evolution

Lecture 64 Task : Schema Evolution

Lecture 65 Guided Challenge : Schema Evolution

Lecture 66 Solution : Schema Evolution

Section 20: Tips : Field Number Effect

Lecture 67 Tips : Field Number Effect

Section 21: Additional Data Types

Lecture 68 Theory : Additional Data Types

Lecture 69 Task : Additional Data Types

Lecture 70 Guided Challenge : Additional Data Types

Lecture 71 Solution : Additional Data Types

Section 22: Tips : Protobuf Option

Lecture 72 Protobuf Option

Section 23: Introducing gRPC

Lecture 73 Theory : Introducing gRPC

Lecture 74 Opinion : Use gRPC or Not?

Lecture 75 Theory : Protocol Buffers & gRPC

Section 24: Protocol Buffers Repository

Lecture 76 Theory : Protocol Buffers Repository

Lecture 77 Task : Protocol Buffers Repository

Lecture 78 Guided Challenge : Protocol Buffers Repository

Lecture 79 Solution : Protocol Buffers Repository

Section 25: Hello gRPC (Unary Server)

Lecture 80 Theory : Hello gRPC (Unary Server)

Lecture 81 Task : Hello gRPC (Unary Server)

Lecture 82 Guided Challenge : Hello gRPC (Unary Server)

Lecture 83 Solution : Hello gRPC (Unary Server)

Section 26: Hello gRPC (Unary Client)

Lecture 84 Theory : Hello gRPC (Unary Client)

Lecture 85 Task : Hello gRPC (Unary Client)

Lecture 86 Guided Challenge : Hello gRPC (Unary Client)

Lecture 87 Solution : Hello gRPC (Unary Client)

Section 27: Hello gRPC (Server Stream)

Lecture 88 Theory : Hello gRPC (Server Stream)

Lecture 89 Task : Hello gRPC (Server Stream)

Lecture 90 Guided Challenge : Hello gRPC (Server Stream)

Lecture 91 Solution : Hello gRPC (Server Stream)

Section 28: Hello gRPC (Client Stream)

Lecture 92 Theory : Hello gRPC (Client Stream)

Lecture 93 Task : Hello gRPC (Client Stream)

Lecture 94 Guided Challenge : Hello gRPC (Client Stream)

Lecture 95 Solution : Hello gRPC (Client Stream)

Section 29: Hello gRPC (Bi-Directional Stream)

Lecture 96 Theory : Hello gRPC (Bi-Directional Stream)

Lecture 97 Task : Hello gRPC (Bi-Directional Stream)

Lecture 98 Guided Challenge : Hello gRPC (Bi-Directional Stream)

Lecture 99 Solution : Hello gRPC (Bi-Directional Stream)

Section 30: Bank - gRPC Preparation

Lecture 100 Theory : Bank - gRPC Preparation

Lecture 101 Task : Bank - gRPC Preparation

Lecture 102 Guided Challenge : Bank - gRPC Preparation

Lecture 103 Solution : Bank - gRPC Preparation

Section 31: Bank - Database Preparation

Lecture 104 Theory : Bank - Database Preparation

Lecture 105 Task : Bank - Database Preparation

Lecture 106 Guided Challenge : Bank - Database Preparation

Lecture 107 Solution : Bank - Database Preparation

Section 32: Bank - Database Structure

Lecture 108 Theory : Bank - Database Structure

Lecture 109 Task : Bank - Database Structure

Lecture 110 Guided Challenge : Bank - Database Structure

Lecture 111 Solution : Bank - Database Structure

Section 33: Bank - Get Current Balance

Lecture 112 Theory : Bank - Get Current Balance

Lecture 113 Task : Bank - Get Current Balance

Lecture 114 Guided Challenge : Bank - Get Current Balance

Lecture 115 Solution : Bank - Get Current Balance

Section 34: Bank - Fetch Exchange Rates

Lecture 116 Theory : Bank - Fetch Exchange Rates

Lecture 117 Task : Bank - Fetch Exchange Rates

Lecture 118 Guided Challenge : Bank - Fetch Exchange Rates

Lecture 119 Solution : Bank - Fetch Exchange Rates

Section 35: Bank - Summarize Transactions

Lecture 120 Theory : Bank - Summarize Transactions

Lecture 121 Task : Bank - Summarize Transactions

Lecture 122 Guided Challenge : Bank - Summarize Transactions

Lecture 123 Solution : Bank - Summarize Transactions

Section 36: Bank - Multiple Transfers

Lecture 124 Theory : Bank - Multiple Transfers

Lecture 125 Task : Bank - Multiple Transfers

Lecture 126 Guided Challenge : Bank - Multiple Transfers

Lecture 127 Solution : Bank - Multiple Transfers

Section 37: gRPC Status & Errors - Part 1

Lecture 128 Theory : gRPC Status & Errors - Part 1

Lecture 129 Task : gRPC Status & Errors - Part 1

Lecture 130 Guided Challenge : gRPC Status & Errors - Part 1

Lecture 131 Solution : gRPC Status & Errors - Part 1

Section 38: gRPC Status & Errors - Part 2

Lecture 132 Theory : gRPC Status & Errors - Part 2

Lecture 133 Task : gRPC Status & Errors - Part 2

Lecture 134 Guided Challenge : gRPC Status & Errors - Part 2

Lecture 135 Solution : gRPC Status & Errors - Part 2

Section 39: gRPC Status & Errors - Part 3

Lecture 136 Theory : gRPC Status & Errors - Part 3

Lecture 137 Task : gRPC Status & Errors - Part 3

Lecture 138 Guided Challenge : gRPC Status & Errors - Part 3

Lecture 139 Solution : gRPC Status & Errors - Part 3

Section 40: Error Handling on gRPC Client

Lecture 140 Theory : Error Handling on gRPC Client

Lecture 141 Task : Error Handling on gRPC Client

Lecture 142 Guided Challenge : Error Handling on gRPC Client

Lecture 143 Solution : Error Handling on gRPC Client

Section 41: Resiliency - Server

Lecture 144 Theory : Resiliency - Server

Lecture 145 Task : Resiliency - Server

Lecture 146 Guided Challenge : Resiliency - Server

Lecture 147 Solution : Resiliency - Server

Section 42: Resiliency - Timeout (Deadline)

Lecture 148 Theory : Resiliency - Timeout (Deadline)

Lecture 149 Task : Resiliency - Timeout (Deadline)

Lecture 150 Guided Challenge : Resiliency - Timeout (Deadline)

Lecture 151 Solution : Resiliency - Timeout (Deadline)

Section 43: Resiliency - Retry

Lecture 152 Theory : Resiliency - Retry

Lecture 153 Task : Resiliency - Retry

Lecture 154 Guided Challenge : Resiliency - Retry

Lecture 155 Solution : Resiliency - Retry

Section 44: Resiliency - Circuit Breaker

Lecture 156 Theory : Resiliency - Circuit Breaker

Lecture 157 Task : Resiliency - Circuit Breaker

Lecture 158 Guided Challenge : Resiliency - Circuit Breaker

Lecture 159 Solution : Resiliency - Circuit Breaker

Section 45: Metadata - Server

Lecture 160 Theory : Metadata - Server

Lecture 161 Task : Metadata - Server

Lecture 162 Guided Challenge : Metadata - Server

Lecture 163 Solution : Metadata - Server

Section 46: Metadata - Client

Lecture 164 Theory : Metadata - Client

Lecture 165 Task : Metadata - Client

Lecture 166 Guided Challenge : Metadata - Client

Lecture 167 Solution : Metadata - Client

Section 47: Interceptor

Lecture 168 Theory : Interceptor

Lecture 169 Task : Interceptor (Server)

Lecture 170 Guided Challenge : Interceptor (Server)

Lecture 171 Solution : Interceptor (Server)

Lecture 172 Task : Interceptor (Client)

Lecture 173 Guided Challenge : Interceptor (Client)

Lecture 174 Solution : Interceptor (Client)

Section 48: gRPC-REST Gateway

Lecture 175 Theory : gRPC-REST Gateway

Lecture 176 Task : gRPC-REST Gateway (Preparation)

Lecture 177 Guided Challenge : gRPC-REST Gateway (Preparation)

Lecture 178 Solution : gRPC-REST Gateway (Preparation)

Lecture 179 Task : gRPC-REST Gateway (Default Mapping)

Lecture 180 Guided Challenge : gRPC-REST Gateway (Default Mapping)

Lecture 181 Solution : gRPC-REST Gateway (Default Mapping)

Lecture 182 Task : gRPC-REST Gateway (Annotation Mapping)

Lecture 183 Guided Challenge : gRPC-REST Gateway (Annotation Mapping)

Lecture 184 Solution : gRPC-REST Gateway (Annotation Mapping)

Lecture 185 Task : gRPC-REST Gateway (External Mapping)

Lecture 186 Guided Challenge : gRPC-REST Gateway (External Mapping)

Lecture 187 Solution : gRPC-REST Gateway (External Mapping)

Section 49: Securing gRPC

Lecture 188 Theory : Securing gRPC

Lecture 189 Task : Securing gRPC (Server)

Lecture 190 Guided Challenge : Securing gRPC (Server)

Lecture 191 Solution : Securing gRPC (Server)

Lecture 192 Task : Securing gRPC (Client)

Lecture 193 Guided Challenge : Securing gRPC (Client)

Lecture 194 Solution : Securing gRPC (Client)

Lecture 195 Task : Securing gRPC (REST Gateway)

Lecture 196 Guided Challenge : Securing gRPC (REST Gateway)

Lecture 197 Solution : Securing gRPC (REST Gateway)

Section 50: Resources & References

Lecture 198 Download Source Code, Scripts, and References

Lecture 199 Bonus Lecture

Software engineer, technical architects, technical manager who wants to know how to implement Protocol Buffers using Go programming language,Golang enthusiast





RapidGator

https://rapidgator.net/file/97d78dd3f5be52eee09f6ef30f990585/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part1.rar
https://rapidgator.net/file/31edb0abb68de1c5f3f3b3ee1033e280/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part2.rar
https://rapidgator.net/file/d59895865b32630ea6a728b5e09be727/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part3.rar

DDownload

https://ddownload.com/dghwvtsqwb00/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part1.rar
https://ddownload.com/4mikt6nrqcwh/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part2.rar
https://ddownload.com/a8wx4afk59d0/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part3.rar

NitroFlare

https://nitroflare.com/view/D0654C8C99BCD10/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part1.rar
https://nitroflare.com/view/1D042999B854103/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part2.rar
https://nitroflare.com/view/E0EC2F5D4FEFEE4/yxusj..-.Hands-On.Go..Microservices.With.Protocol.Buffers..gRPC.part3.rar


See full article