gRPC & gRPC Gateway development in Go Training

Day One

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. Download Protocol Buffer Compiler [https://github.com/google/protobuf/releases](https://github.com/google/protobuf/releases) You will need to choose the file that is most appropriate for your operating system and architecture.

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. From Google: > Protocol buffers are Google's language-neutral, platform-neutral, extensible > mechanism for serializing structured data – think XML, but smaller, faster, and

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. a `Remote Procedure Call` is when a computer program makes a call to another address space (commonly on another computer) across a network. .footnote[[Remote Procedure Call Wikipedia](https://en.wikipedia.org/wiki/Remote_procedure_call)]

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 module will cover client streaming, server streaming, and bi-directional streaming. Synchronous RPC calls are calls that block until a response arrives from the server are the closest approximation to the abstraction of a procedure call that RPC aspires to. On the other hand, networks are inherently asynchronous and in many scenarios it’s useful to be able to start RPCs without blocking the

Day Two

GRPC Metadata

Similar to how HTTP protocol can send headers, gRPC allows you to send key/value pairs via metadata. This module shows how to set and retrieve metadata, and guidelines around when to use it. [Metadata](https://godoc.org/google.golang.org/grpc/metadata) is information about a particular RPC call (such as [authentication details](https://grpc.io/docs/guides/auth.html)) in the form of a list of key-value pairs, where the keys are strings and the values are typically strings (but can be binary data). Metadata is opaque to gRPC itself - it lets

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. Go supports deadlines in gRPC via the `context`. The context is passed from the client to the server. There are a few best practices for setting deadlines:

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`. To secure a channel you will need to generate a certificate. In this example, we will use `lvh.me` to generate

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. Testing a client usually involves stubbing out the server so you can connect the client to a "stub" service, without having to spin up the entire server framework. This allows you to effectively unit test your client. We'll need to create our `stub` server for the client to access. This will allow us to have fine tuned control over specific server method behavior. It

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. gRPC has support for interceptors in which the interceptor is executed on the server or the client, before the call is passed on to the program's application logic. This allows for a clean way to implement concepts such as auth, logging, message validation,

Day Three

GRPC Telemetry

gRPC Telemetry consists of two pieces: metrics and traces. This chapter will cover how to enable modern observability in your distributed gRPC applications using OpenTelemetry, the industry-standard unified observability framework. `Metrics` are any quantifiable piece of data that you would like to track, such as latency in a service or database, request content length, or number of open file descriptors. Viewing graphs of your metrics can help you understand and gauge the performance and overall quality of your application and set of services.

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. One of the first things you want to do when working with any new API is send requests to it and see responses come back from it. Let's look at a few tools that allow us to experiment with our gRPC APIs. [grpcurl](https://github.com/fullstorydev/grpcurl) aims to be a cURL replacement for gRPC APIs. You might recognize some flags from cURL, but others

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. gRPC is great, but sometimes you may need to: * Maintain backwards-compatibility * Support other languages or clients that aren't well supported in the gRPC ecosystem

Prerequisites

Introduction to Go Web Development: Building a Simple HTTP Server and Web Services

In this chapter, you will dive into the basics of web development using Go. You’ll learn how to build a simple web server, create HTTP handlers, and set up routing using Go’s powerful `net/http` package. Starting with a basic "Hello, World!" web application, we will guide you through key concepts such as routing, serving static files, handling headers, and securing your server with TLS. By the end of this chapter, you’ll have a solid foundation for developing web services in Go, complete with the ability to handle multiple routes and build reliable HTTP applications.

Advanced Routing and Muxing in Go: Building Robust Web Application Routes

This chapter dives deep into the implementation of routing and multiplexing for advanced web development in Go. It covers the basics of using Go’s built-in `http.ServeMux` for simple routing, along with the limitations of this default multiplexer. The chapter then transitions into constructing more complex routing setups, including: - **Using Multiple Muxers:** Learn how to handle and mount multiple muxers, how path stripping works, and the importance of proper path handling. - **Custom Muxer Development:** A step-by-step guide to building a custom muxer from scratch using Go’s `http.Handler` interface, illustrating how you can gain full control over your routing logic.

Building HTTP Handlers for Web Applications: Handling Routes, Processing Requests, and Sending Responses

In this chapter, we explore the fundamentals of building HTTP handlers in Go, which are the backbone of any web application. You will learn about the `http.Handler` interface, `HandlerFunc`, and how to implement them effectively to process requests and send responses. We’ll also delve into how middleware can extend your handlers by adding functionalities such as logging, authentication, and more. By the end of this chapter, you’ll be equipped to create robust and reusable HTTP handlers for your web services, complete with middleware for pre- and post-processing requests.

Testing Basics: Writing and Running Unit Tests

This chapter introduces the fundamentals of testing in Go, with a focus on writing and running unit tests using the built-in `testing` package. You'll learn how to structure tests, the importance of naming conventions, and how to utilize the `*testing.T` type to create effective test cases. Key concepts such as the difference between `Error` and `Fatal`, crafting meaningful failure messages, and organizing internal vs. external tests are explored. Additionally, we'll cover useful helper functions, alternative testing packages, and provide practical examples to help you develop reliable, maintainable tests for your Go applications.

Testing HTTP Handlers with Net/HTTP: Writing Tests for HTTP Services and Utilizing the net/http/httptest Package

In this chapter, we dive into testing HTTP handlers in Go, leveraging the `net/http/httptest` package. Testing HTTP handlers can be approached in two distinct styles: Unit Style Testing and Integration Style Testing. Each style serves different purposes in ensuring that your web applications work as expected. We will explore both approaches, demonstrating how to mock HTTP requests, simulate responses, and write efficient tests for your web services. Additionally, you'll learn how to create test servers, utilize middleware, and handle request bodies and form data. By the end of this module, you’ll have the skills to write comprehensive and reliable tests for Go-based web applications.