Close Menu

grpc-protorpc

About gRPC-ProtoRPC

gRPC-ProtoRPC is a powerful framework for building HTTP/2-based APIs. It combines the best features of gRPC and ProtoRPC, offering a seamless integration between the two. This documentation serves as a guide for developers who want to utilize the features and capabilities of gRPC-ProtoRPC in their projects.

Features

  • Efficient binary serialization
  • Bi-directional streaming
  • Automatic API generation
  • Service definition with Protocol Buffers
  • Support for multiple programming languages
  • Simplified API design
  • Integration with ProtoRPC

Getting Started

To get started with gRPC-ProtoRPC, follow these steps:

  1. Install the gRPC-ProtoRPC framework by running the following command:
npm install grpc-protorpc
  1. Create a new project directory and navigate into it.
mkdir my-grpc-project
cd my-grpc-project
  1. Initialize your project by running the following command:
grpc-protorpc init
  1. Follow the prompts to configure your project settings.

Once you have completed these steps, you are ready to start building your gRPC-ProtoRPC API.

API Design

gRPC-ProtoRPC allows you to define your API using Protocol Buffers, a language-agnostic format for serializing structured data. By defining your services and message types in a .proto file, gRPC-ProtoRPC can automatically generate the necessary code to handle the API requests and responses.

Follow these steps to design your API:

  1. Create a new .proto file to define your API.
touch my-api.proto
  1. Add your service definitions and message types to the .proto file.
syntax = "proto3";

package myapi;

service MyService {
    rpc GetResult (Request) returns (Response) {}
}

message Request {
    string query = 1;
}

message Response {
    string result = 1;
}
  1. Generate the API code by running the following command:
grpc-protorpc generate my-api.proto

These steps will generate the necessary code for handling API requests and responses based on your defined service and message types.

Server Implementation

To implement the server-side of your gRPC-ProtoRPC API, follow these steps:

  1. Create a new JavaScript file to implement your server logic.
touch server.js
  1. Add the following code to your server.js file:
// Import necessary modules
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');

// Load the API definition
const packageDefinition = protoLoader.loadSync('my-api.proto');
const myapi = grpc.loadPackageDefinition(packageDefinition).myapi;

// Implement the API methods
function getResult(call, callback) {
    const query = call.request.query;
    // Perform necessary computations...
    const result = 'Some result';
  
    // Return the response
    callback(null, { result });
}

// Create gRPC server
const server = new grpc.Server();
server.addService(myapi.MyService.service, { GetResult: getResult });

// Start the server
server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), (err, port) => {
    if (err) {
        console.error('Failed to start the server:', err);
    } else {
        console.log('Server started on port', port);
        server.start();
    }
});

Make sure to replace my-api.proto with the path and name of your generated .proto file.

Client Implementation

To implement the client-side of your gRPC-ProtoRPC API, follow these steps:

  1. Create a new JavaScript file to implement your client logic.
touch client.js
  1. Add the following code to your client.js file:
// Import necessary modules
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');

// Load the API definition
const packageDefinition = protoLoader.loadSync('my-api.proto');
const myapi = grpc.loadPackageDefinition(packageDefinition).myapi;

// Create gRPC client
const client = new myapi.MyService('localhost:50051', grpc.credentials.createInsecure());

// Make API calls
client.GetResult({ query: 'Some query' }, (err, response) => {
    if (err) {
        console.error('Error:', err);
    } else {
        console.log('Result:', response.result);
    }
});

Make sure to replace my-api.proto with the path and name of your generated .proto file.

Conclusion

By utilizing the capabilities of both gRPC and ProtoRPC, gRPC-ProtoRPC offers a flexible and efficient solution for building robust HTTP/2-based APIs. Follow the instructions provided in this documentation to get started with gRPC-ProtoRPC and harness the power of this powerful framework.