Udemy – HandsOn Go – Microservices With Protocol Buffers gRPC

Udemy – HandsOn Go – Microservices With Protocol Buffers gRPC
English | Tutorial | Size: 3.54 GB

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

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 how to manage the gRPC repository using github, gRPC status, error handling, resiliency server, timeout, retry, and circuit breaker. Additionally, the course covers the implementation of metadata server and client, server interceptor, client interceptor, and gRPC-REST gateway.

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 database 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 language

Familiarity with git commands (push, pull, pull request, merge, branch)

Tools:

Go programming language

Protocol Buffers (protobuf)

gRPC

Github

Visual 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 protobuf

Writing a protobuf (style guide)

Scalar types, repeated, enums, and Protobuf JSON

Other message types, multiple files and import messages, nested message types, and packages

Any, oneof, and maps

Reading and writing Protobuf to disk and JSON

Schema evolution and additional data types

Option, field validation, and field number effect tips

Introduction to gRPC and whether to use it or not

Managing & automating Protobuf and gRPC github repositories with github action

Implementing a unary server and client, server streaming, client streaming, and bidirectional streaming

Implementing a bank gRPC application with PostgrSQL database preparation, fetching exchange rates, and summarizing transactions

Handling gRPC status and errors, error handling on the client side, and resiliency techniques such as timeout, retry, and circuit breaker

Implementing metadata, server and client interceptors

gRPC-REST gateway

By 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 follow Protobuf style guides, organize Protobuf 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 (forward / backward compatibility), and use additional data types.

Furthermore, you will have gained hands-on experience in implementing various types of gRPC services, including unary, server streaming, client streaming, and bidirectional streaming. You will also have learned how to handle gRPC status and errors, implement resiliency techniques such as timeout, retry, and circuit breaker. You will learn how to convert your gRPC API to REST API, using gRPC-REST gateway. You will also learn how to generate OpenAPI / swagger documentation for gRPC.

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.

NITROFLARE
nitroflare.com/view/E3DB2523A7C346F/Udemy_-_HandsOn_Go_Microservices_With_Protocol_Buffers_gRPC.part1.rar
nitroflare.com/view/37BF2A6676C7843/Udemy_-_HandsOn_Go_Microservices_With_Protocol_Buffers_gRPC.part2.rar
nitroflare.com/view/591E0480B642065/Udemy_-_HandsOn_Go_Microservices_With_Protocol_Buffers_gRPC.part3.rar
nitroflare.com/view/280BAE361A6EAE4/Udemy_-_HandsOn_Go_Microservices_With_Protocol_Buffers_gRPC.part4.rar
nitroflare.com/view/BE88CE714BFC6E9/Udemy_-_HandsOn_Go_Microservices_With_Protocol_Buffers_gRPC.part5.rar
nitroflare.com/view/418B345F97D6F12/Udemy_-_HandsOn_Go_Microservices_With_Protocol_Buffers_gRPC.part6.rar