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

Homepage

https://www.udemy.com/course/hands-on-go-programming-microservices-with-protocol-buffers-grpc/