All right.
So next up, I'm going to show you how we can refactor our microservices instead of using TCP as our
transport layer for all of our microservices, we're instead going to use gRPC.
Now, if you're unfamiliar with gRPC, I'm going to provide links to both a introduction to gRPC where
you can quickly read up on what gRPC is, as well as the language guide for it, where you can learn
more about Proto, which is the language that runs gRPC.
So I'll include links to both of these later on in the course.
However, just for a brief overview, we can see a great description of what gRPC is.
So we can see here that gRPC is going to allow our client applications to call methods on our server
as if they were a local object, which makes it really easy for us to build distributed applications.
So in gRPC we define a service, the methods that the service can be called and all of the data that
is involved with those services.
So the parameters, the return types, all of this is going to be defined in these proto files that
we're going to build.
So we can see here that regardless of the client we're using, whether it's a Ruby client, an Android
client or any other client, the gRPC stub is going to be exactly the same.
We're going to talk to the server as if it was a local in-memory process and get a response back.
So this makes it super easy to write our code once to define what our services look like, and then
any number of our clients can reuse this, which cuts down on duplication.
So as I said before, gRPC runs on protocol buffers, which we are going to work on building next in
our microservices.
So let's go ahead and jump right in.
I'll leave links to both this introduction and the language guide for protocol buffers if you'd like
to learn more.
Otherwise, let's jump right in and see how we can implement gRPC in our microservice.