gRPC [Golang] Master Class: Build Modern API & Microservices

Explore how HTTP/2 enables faster, safer gRPC communication through multiplexed, binary, compressed headers and single persistent connections, outperforming HTTP/1.1 in real-world API calls.

Explore the four gRPC API types: unary, server streaming, client streaming, and bidirectional streaming, and see how http2 enables streaming modes and protocol buffer usage.

Explore how gRPC scales with asynchronous server processing that keeps the main thread unblocked, and client choice between asynchronous or synchronous responses; Google's 10 billion requests per second illustrate capacity.

gRPC uses binary, schema-based serialization as a first layer of security. It supports easy tls encryption for client–server connections, while interceptors offer an additional authentication layer.

Compare gRPC and REST to choose the right tool, noting protocol buffers versus JSON, HTTP/2 versus HTTP/1, and gRPC streaming with bi-directional options, plus strict schemas and freer API design.

Define your API with Protocol Buffers; gRPC generates code and secures data via binary serialization with TLS support and authentication interceptors. Enable client, server, and bi-directional streaming beyond REST.

Install and configure the gRPC go environment from grpc.io: install Go, the ProtoBuff compiler, and VSCode, verify protoc, and initialize your module with go mod init.

Create a greet project with server, client, and proto folders, define dummy.proto, and generate Go and gRPC code using protoc with proper module settings.

Use a makefile to build protobufs and Go binaries, view commands with make help, and build or clean per project or for all on Linux, macOS, and Windows.

Develop a Go gRPC server by creating greet.proto with the greet service and messages, generating Go code, and launching a listening server on 0.0.0.0:50051.

Create a basic go gRPC client by dialing localhost:50051, handle connection errors, and defer closing, then use insecure credentials to test client-server communication before unary API tasks.

Create a go gRPC client, instantiate the greet service client, and call greet rpc. Log the invocation and print the greeting to verify the unary API flow on port 5051.

Define and implement a server streaming gRPC endpoint GreetManyTimes in Go, generating code, and streaming ten GreetResponse messages from a GreetRequest with formatted greetings.

Build a Go gRPC client for the GreetManyTimes streaming RPC, implement doGreetManyTimes, process the server stream until EOF, and print each Hello Clement result.

Define a primes RPC in calculator.proto, stream prime responses for a prime request, and implement server and client code to factor a number and publish each prime as it's found.

Learn to implement the server-side client streaming for the LongGreet RPC in Go using gRPC, where the server concatenates multiple GreetRequest first names into a single GreetResponse.

Implement a Go gRPC client for the LongGreet streaming RPC, sending multiple GreetRequest messages and receiving the final response via CloseAndReceive.

Define avg.proto with AverageRequest and AverageResponse, implement the Avg client-streaming RPC, generate code, and run the server and client to compute the average of sent numbers.

Implement bidirectional streaming on the server with a new GreetEveryone RPC, generating code and looping to receive greetings and send back 'Hello' plus first name responses.

Build a max rpc endpoint in a gRPC golang calculator service by defining max.proto with MaxRequest and MaxResponse, enabling bidirectional streaming between server and client.

Implement a gRPC Golang sqrt endpoint in a calculator app, returning InvalidArgument for negative inputs and demonstrating client-side error handling of grpc status codes.

Implement a greetWithDeadline gRPC endpoint in Go; the server waits three seconds, the client timeout is five seconds to succeed. A one-second timeout triggers a deadline exceeded.

This hands-on lecture teaches wiring a TLS-enabled gRPC connection by using OpenSSL to generate certificates, configuring server TLS, and updating the client to trust the CA for secure communication.

Enable gRPC server reflection with Evans CLI, then explore services, show packages, messages, and call RPCs like Sum, Primes, Avg, Max, and Sqrt.

Install docker and docker compose to set up your environment, verify versions, and ensure the docker daemon is running across macOS, Windows, and Linux.

Set up a docker-compose environment to spin up a mongo db and a mongo express UI for the blog project, exposing ports 27017 and 8081, and test locally.

Set up the blog service by installing the Go MongoDB driver, defining Blog.proto with Blog and BlogService RPCs, generating Go code, and mapping BlogItem to pb.Blog.

Learn to scaffold a gRPC blog server in Go by copying boilerplate, wiring a MongoDB collection, and implementing the create blog RPC that inserts documents and returns a BlogId.

implement the readblog server rpc in go by creating read.go, parse the id into a mongodb objectid, query with findone, decode into blogitem, and return a pb.blog via documenttoblog.

Build the readBlog client by using BlogServiceClient to call readBlog with a valid and an invalid ID, logging outcomes and printing the blog or error.

Implement the update blog RPC endpoint on the server, parsing the blog ID to an object ID and updating MongoDB with the $set data, handling not found and internal errors.

Implement the list.blogs server-side gRPC endpoint in Go by streaming each MongoDB document as a blog to the client, with proper error handling.

Write a gRPC Go client to call the ListBlogs RPC, stream blog records, and print results from the server while handling EOF and errors.

Implement the DeleteBlog server RPC to parse the blog id, delete the document from MongoDB, handle errors (invalid argument, internal, not found), and return empty on success.

Implement a client-side delete blog by adding delete.go, calling the DeleteBlog RPC with the given ID, handling errors, and confirming deletion via listing and Mongo Express.