gRPC [Node.js] MasterClass: Build Modern API & Microservices

Learn how gRPC relies on protocol buffers to define messages and services, enabling code generation and compact binary payloads. Explore language interoperability and four main implementations across languages.

Explore how http2 revolutionizes web communication by enabling a single long‑lived connection, multiplexing, and server push, with binary headers and SSL by default, pairing seamlessly with gRPC and protocol buffers.

Explore the four types of gRPC APIs: unary, server streaming, client streaming, and bidirectional streaming, and how to implement them with protocol buffers over http2.

gRPC scales with asynchronous server processing that keeps the main thread unblocked and handles requests in parallel; clients can choose asynchronous or synchronous responses, as Google's 10 billion rps shows.

Explore how gRPC secures communication through binary, schema-based serialization, easy TLS connections with SSL encryption, and interceptors for authentication, making gRPC a secure framework.

Compare gRPC and Rest to choose the right tool for the job, highlighting protocol buffers vs json, http2 versus http1, streaming, bidirectional support, and strict versus flexible API design.

See how gRPC generates code from Protocol Buffers, letting you define the API freely while TLS security and authentication interceptors protect data, with client, server, and bidirectional streaming beyond rest.

Initialize a Node.js project with npm init, install protobuf and grpc-js, add grpc-tools as a dev dependency, and generate protobuf artifacts using grpc tools protoc for dummy.proto.

Automate code generation for gRPC projects by configuring an npm script, pulling a generation script from GitHub, and running it to generate grid__pbjs from greet.proto.

Create a node.js gRPC server boilerplate by building a server folder with index.js, implementing main and cleanup, binding on localhost with insecure credentials, and handling ctrl-c for clean shutdown.

Create the client boilerplate in the grid directory, add an index.js, generate grid.pb code from grid.proto, and instantiate a greet service client with insecure credentials.

Define the unitary api in the grid proto file with grid request, grid response messages, and a grid rpc; compile with npm run pb gen to prepare for server-side implementation.

Implement the unary gRPC server by creating a service file, importing the generated greet service and pb definitions, and binding the service to the server.

Learn to implement a unary gRPC client in node.js that calls the grid greet endpoint, constructs a greet request with a first name, and handles the client.greet response.

Define a calculator proto for sum request and sum response, implement a node.js gRPC server and client, and run npm scripts to compute the sum of 1 and 1.

Define a server streaming endpoint in greet.proto with greet many times, accepting a greet request and returning a stream of greet responses, then generate code with npm run pb gen.

Develop a Node.js gRPC server that streams ten greeting responses per request, using a server streaming endpoint with call.write and call.end to implement the grid endpoint.

Implement a server streaming gRPC client that calls the greet many times endpoint, processes data events from the server, and prints each hello response like hello Clement number 0.

Define a gRPC primes api endpoint in node, stream prime responses from server to client, implement using primes proto, and run a full prime decomposition pipeline.

Define the long greet client streaming RPC in greet.proto, receiving a stream of greet requests and returning a greet response, then generate code with npm run pb gen.

Implement the long read RPC server in node by handling data and end events in the grid server to build greetings, then return a single grid response via callback.

Implement a client for a long read rpc by streaming names, handling the server callback, and printing hello responses such as hello Clement, hello Mary, and hello test.

Create avg.proto with int32 request and double response, implement a client streaming endpoint that computes total and count to return the average.

Define the bi directional streaming endpoint grid everyone in the grid proto, streaming grid requests and responses, then run npm run pb gen to verify protobuf correctness.

Implement bi-directional streaming api on the server by exporting greet everyone. Handle data and end events, log requests, send a hello response with the first name, and end the stream.

Implement a bidirectional streaming client for the greet everyone endpoint in a gRPC Node.js microservices setup, using a data event stream and client streaming patterns to print hello messages.

Explore building a gRPC Node.js max api using a bidirectional streaming proto, with max request and max response messages, and a client that streams numbers to receive new max values.

Implement a unary gRPC square root API with input validation that returns an invalid argument error for negative numbers, illustrating end-to-end error handling from proto definitions to client.

Implement a gRPC unary endpoint called grid with deadline, simulate processing delays, and demonstrate client-side deadlines by canceling requests when the server exceeds the deadline.

Generate certificates and enable mutual tls by configuring a server and client with ca, server certs, and private keys in an ssl directory. Use the provided script to generate and load these credentials to establish a secure grpc connection.

Set up blog boilerplate by configuring docker-compose with mongo and mongo express, creating blog server and client, defining blog proto, and adding scripts to spin up database and generate pb.

Configure your node server to connect to MongoDB by installing the MongoDB driver, creating a Mongo client, and connecting to blog DB and the blog collection, with a cleanup routine.

Define a blog proto with blog and blog_id messages, implement create, read, update, delete, and list RPCs, import google.protobuf.empty, and return empty for update/delete and a blog stream for list.

Create a gRPC node.js blog client to call the create blog endpoint using author id, title, and content. Return the blog id via a promise and await in main flow.

Define the read blog server endpoint and a reusable check_id helper for MongoDB ObjectID. Query by id and return the blog or report not found with gRPC status.

Implement a read blog client in Node.js to call the read blog API via gRPC, handling responses, errors, and invalid IDs with promise-based logic.

Build the update blog endpoint on the server using an async lambda, map the blog id to MongoDB _id, perform $set update, and handle errors and not found via callback.

Write a blog update client that calls update blog RPC, builds a request with id, author, title, and content, handles errors, and verifies the update via logs and browser view.

Define the list blogs endpoint on the server in a Node.js gRPC masterclass. Implement a server streaming flow that finds blogs, maps them to messages, and writes to the client.

Write a node client for the list blogs rpc, sending an empty request, consuming the server stream, and subscribing to data, error, and end events while logging results.

Implement the delete blog endpoint on the server side, map blog id to an object id, delete by id, handle not found and acknowledged writes, and return an empty response.

Demonstrates building a delete blog client in node.js, calling the gRPC delete endpoint with a blog ID. It handles success or error and verifies deletion via Mongo Express.