gRPC is awesome but this post isn't going to delve too deep there. Plenty of resources out there to learn more (definitely check out https://github.com/grpc-ecosystem/awesome-grpc).
I first learned about gRPC about five years go. Since that moment in time when an engineer at PubNub introduced me to the framework, I have let the idea of gRPC simmer more in the background, especially since I was already rather steeped in REST, Open API, Swagger, and other sundries seen in the broader API space (miss you, Mashery. There seemed to be plenty of great tooling, documentation and technologies supporting "traditional" API development. Why break new ground and learn something new?
Well, when I joined my new company, Lightbend, I quickly learned that gRPC was a big part of my future! We use that framework as a big part of our new Platform-as-a-Service (PaaS), Akka Serverless, that makes it as easy to build a real-time data application as it is to build a web page (well, a simple HTML one!). Now you might be thinking, "well, gRPC isn't so easy..." but you'd be wrong, or at least ripe for disruption. It takes a bit of learning, for sure, but there are plenty of great resources to help you out. And I'm going to dig into one of these in this post. A tool that makes it easy to try out those wonderful gRPC services that I know you're going to build!
Using Evans to try out a gRPC service
Given my background in the API management space, and with not so distant memories of Mashery, Apigee and 3scale duking it out with their various flavors of API test consoles (kudos to Apigee for using their console to get ahead in the market!), one would think that I'm a sucker for UI. And yes, I do like the modern take on API test-and-try consoles; Postman being quite a great example. I was excited about their beta announcement for gRPC support! But as I dove into that tool and the other quite excellent API test-and-try tool, Kong's Insomnia, I realized that a critical feature - at least in my opinion - that was missing was server reflection, which allows for dynamic clients to be used; no necessary gathering and loading of various protobuf files. For more simplistic, single proto file implementations, not a problem. But with Akka Serverless, one can start to create rather elaborate gRPC based APIs and microservices, including those that span over event brokers. The protobuf files and structure become more sophisticated, with 3rd party library imports and the like. You can gather up all the protos and sometimes that is indeed needed. But for quick testing, especially by those who aren't gRPC experts, server reflection makes it much easier to get going.
And who am I kidding? I'm a CLI-type person. Which is why I was super excited to stumble about Evans. Within minutes, I had gone from installation to trying out TLS-secured APIs and microservices running in the cloud on Lightbend's new serverless offering.
So let's try it out!
First, Install Evans!
Following the instructions from the Github repo, install the great gRPC CLI tool, Evans. For MacOS users, it is as simple as:
$ brew tap ktr0731/evans
$ brew install evans
Now take it out for a spin!
For a terminal window, type in the following:
$ evans --tls --host nameless-thunder-9740.us-east1.akkaserverless.app --port 443 -r repl
The above command will create an Evans CLI session, connected to a demo gRPC service running in Lightbend's Akka Serverless Platform-as-a-Service (PaaS). The demo service in question is a simple counter API by which we can increment and decrement arbitrary counters. But don't take my word for it...
First, get a list of packages available in the gRPC service, and then select the com.example one. This is setting the context for further CLI commands.
nameless-thunder-9740.us-east1.akkaserverless.app:443> show package
+-------------------------+
| PACKAGE |
+-------------------------+
| com.example |
| com.example.actions |
| grpc.reflection.v1alpha |
+-------------------------+
nameless-thunder-9740.us-east1.akkaserverless.app:443> package com.example
Now, get the list of services exposed in the package. And select the CounterService service; further defining the context, like selecting the package above.
com.example@nameless-thunder-9740.us-east1.akkaserverless.app:443> show service
+----------------+-------------------+---------------+----------------+
| SERVICE | RPC | REQUEST TYPE | RESPONSE TYPE |
+----------------+-------------------+---------------+----------------+
| CounterService | Increase | IncreaseValue | Empty |
| CounterService | Decrease | DecreaseValue | Empty |
| CounterService | Reset | ResetValue | Empty |
| CounterService | GetCurrentCounter | GetCounter | CurrentCounter |
+----------------+-------------------+---------------+----------------+
com.example@nameless-thunder-9740.us-east1.akkaserverless.app:443> service CounterService
Make an API call, to get the current state of the foo counter. The Evans CLI will prompt you for the counter_id.
com.example.CounterService@nameless-thunder-9740.us-east1.akkaserverless.app:443> call GetCurrentCounter
counter_id (TYPE_STRING) => foo
{
"value": 23
}
Increase the value of the counter by some amount, say 10. Again, the Evans CLI will ask you for the counter_id and the value by which the counter should be increased.
com.example.CounterService@nameless-thunder-9740.us-east1.akkaserverless.app:443> call Increase
counter_id (TYPE_STRING) => foo
value (TYPE_INT32) => 10
{}
Finally, make another request to see the updated counter value.
com.example.CounterService@nameless-thunder-9740.us-east1.akkaserverless.app:443> call GetCurrentCounter
counter_id (TYPE_STRING) => foo
{
"value": 33
}
Where to go next
Definitely check out Awesome gRPC for tons of great resources, even beyond the tooling like the Evans CLI. Also, if you want to start building gRPC services in a streamlined fashion, without spinning up servers and figuring out deploys and operations, then you should sign-up for an account at Akka Serverless.
Top comments (0)