gRPC & gRPC Gateway development in Go Training

Day One

Welcome

This chapter covers general information about your instructor and course materials.

Install And Configure Protobuf

Installing all the tools you need to make protocol buffers work can be challenging. This chapter lays out in detail the steps needed to properly install and configure your development environment for protocol buffers. It also includes specific steps for each operating system when necessary.

Protocol Buffers

Protocol Buffers are the next step in data formats for high performance distributed systems. In comparison to JSON or XML, protobufs can encode and decode faster, have a smaller encoded size, and allow for use across platforms and languages.

In this chapter, we will cover how to create and use protocol buffers, as well as how to extend them.

Break

Tea/Coffee Break.

Introduction To GRPC

gRPC is a modern open source high performance RPC framework that can run in any environment. In this chapter we will cover the basic concepts used in gRPC, as well as create some simple RPC calls using protocol buffers and implement them with gRPC. We'll also cover how to create specific errors and codes with gRPC.

Streaming With GPRC

Streaming in gRPC allows for the client or server to send and receive more than one message. This allows for asynchronous processing and bi-directional communication. This chapter will cover client streaming, server streaming, and bi-directional streaming.

Day Two

GRPC Metadata

Similar to how HTTP protocol can send headers, gRPC allows you to send key/value pairs via metadata. This chapter shows how to set and retrieve metadata, and guidelines around when to use it.

Observing SLA's With GRPC

Service Level Agreements (SLA's) are an important part of your API. This chapter will discuss how to implement them on the client and server, and best practices to follow.

Contexts are the mechanism that is used to control SLA's in the gRPC ecosystem. As such, we'll also cover additional characteristics of how context works with gRPC beyond SLA's.

Break

Tea/Coffee Break.

Securing GRPC Services

gRPC provides a simple authentication API based around the unified concept of Credentials objects, which can be used when creating an entire gRPC channel or an individual call.

Credentials can be of two types:

• Channel credentials, which are attached to a Channel, such as SSL credentials.
• Call credentials, which are attached to a call.

This chapter will cover how to secure a channel and how to secure a call.

Testing And Stubbing GRPC

This chapter will show how to approach testing for both client and server services. We will also cover how to stub out specific parts of the stack to enable easy unit testing.

GRPC Middleware

Middleware is a common way to handle many concepts such as logging, tracing, and more. You can implement middleware in your gRPC stack with "interceptors".

This chapter will show how to create basic interceptors and cover existing third party interceptors, as well as setting up retry logic, and load balancing.

Day Three

GRPC Tracing

This chapter will cover how to enable tracing across your distributed gRPC stack, as well as cover popular concepts such as OpenTrace and OpenCensus.

GRPC Tooling

This chapter will cover many useful tools for working with a gRPC API. You will learn how to use common "curl" tools to interact with your API, set up load testing, run a protobuf linter, and more. examining their responses, and working with Protocol Buffers.

Break

Tea/Coffee Break.

GRPC Gateway

The grpc-gateway is a plugin of the Google protocol buffers compiler protoc. It reads protobuf service definitions and generates a reverse-proxy server which translates a RESTful HTTP API into gRPC.

This chapter will cover how to specify the proper definitions in your proto files to generate the RESTful endpoints. It will also cover how to use OpenAPI to quickly test your endpoints.

Finalize

This chapter covers where to get more support on Go, recommends books and videos, and list the contact information for our instructors.

Prerequisites

Introduction To Go Web Development

This chapter will cover some basic concepts of web development in Go. We'll cover how to create handlers, set up routing, and launch a basic web server.

Routing And Muxing

Routing in Go requires the use of a "muxer". In this chapter, we'll explore how to properly set up a muxer to route traffic properly in your web application.

HTTP Handlers

Understanding how Go web applications work means understanding the HTTP.Handler interface. This chapter will cover how Handler, HandlerFunc and ServeHTTP all work together to create the basic building blocks of a Go web service. We will also cover how to create and implement middleware, such as a basic logger and authentication.

Testing Basics

Testing in Go is easy, and simple to use. There is a strong emphasis on testing in Go. The compiler will catch a lot of bugs for you, but it can not ensure your business logic is sound or bug-free.

While the testing package isn't large, there are some features that are not properly understood. In this chapter we will cover the following concepts:

• *testing.T
• Error vs. Fatal
• Failure Messages
• Helpers
• Testing Packages

Testing Net/HTTP

In the standard library there are two mechanisms for us to use to test web applications.

• Unit Style Testing
• Integration Style Testing

These are not their "official" names, but we believe they do a good job of describing the styles of testing. In this chapter, we will cover both styles of testing and how to use them.