Python gRPC server example

Shelly 82 Published: 09/26/2024

Python gRPC server example

Here's a detailed explanation of building a simple Python gRPC server using the grpc and protobuf libraries.

Step 1: Define the protobuf message and service

Let's create a file called greeter.proto with the following content:

syntax = "proto3";

package greeter;


service Greeter {


rpc SayHello (HelloRequest) returns (HelloResponse) {}


}


message HelloRequest {


string name = 1;


}


message HelloResponse {


string message = 1;


}

This defines a Greeter service with a single method SayHello, which takes a HelloRequest message and returns a HelloResponse message.

Step 2: Generate the protobuf code

Run the following command to generate the Python code from the .proto file:

protoc --python_out=. greeter.proto

This will create a file called greeter_pb2.py.

Step 3: Implement the gRPC server using Python

Create a new file called server.py with the following content:

import grpc

from greeter import Greeter


from greeter_pb2 import HelloRequest, HelloResponse


class GreeterServer(Greeter):


def SayHello(self, request, context):


return HelloResponse(message=f"Hello, {request.name}!")


def main():


server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))


GreeterServicer = GreeterServer()


Greeter.add_to_server(server, GreeterServicer)


print("gRPC server listening on port 50051...")


server.add_insecure_port('0.0.0.0:50051')


server.start()


if name == "main":


main()

This code defines a GreeterServer class that inherits from the generated Greeter protobuf service. The SayHello method returns a greeting message based on the HelloRequest message.

Step 4: Run the gRPC server

Run the following command to start the gRPC server:

python server.py

This will start the server listening on port 50051.

Step 5: Use the gRPC client (in another Python script)

Create a new file called client.py with the following content:

import grpc

from greeter_pb2 import HelloRequest, HelloResponse


def main():


channel = grpc.insecure_channel('localhost:50051')


client = Greeter(channel)


request = HelloRequest(name='Alice')


response = client.SayHello(request)


print(response.message)


if name == "main":


main()

This code creates a gRPC client that connects to the server at localhost:50051 and calls the SayHello method with a HelloRequest message. The response is printed to the console.

Run the client

Run the following command to start the client:

python client.py

This will output:

Hello, Alice!

Congratulations! You have now built a simple gRPC server and client using Python!

Note: Make sure you have the grpc and protobuf libraries installed before running these examples.

Grpc python example github

I'm happy to help! Here's a detailed response:

If you're looking for a Python example of using gRPC, I've got some great news for you! You can find numerous examples on GitHub that demonstrate how to use gRPC in Python.

Firstly, let me give you an overview of what gRPC is. gRPC (gRPC Remote Procedure Call) is a high-performance RPC framework developed by Google. It allows you to create and manage remote procedure calls (RPCs) between clients and servers written in various programming languages. In the context of Python, you can use the grpc library to connect your Python applications with other services.

Now, let's dive into some examples!

Example 1: Basic gRPC Server

You can find a basic gRPC server example on GitHub by searching for "python-grpc-example". This example creates a simple RPC service that allows you to add two numbers. Here's the code:

import grpc

from . import helloworld_pb2


from . import helloworld_pb2_grpc


class Greeter(helloworld_pb2.Greeter):


def SayHello(self, request, context):


return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)


def main():


server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))


helloworld_pb2_grpc.add_Greeter_to_server(Greeter(), server)


print('gRPC Server listening on port 50051...')


server.add_insecure_port('[::]:50051')


server.start()


server.wait_for_termination()


if name == 'main':


main()

Example 2: Client-Server Interaction

Here's another example that demonstrates client-server interaction using gRPC:

import grpc

class GreeterClient:


def init(self):


self.hello_request = helloworld_pb2.HelloRequest(name='Alice')


def greet(self, target):


channel = grpc.insecure_channel(target + ':50051')


stub = helloworld_pb2_grpc.GreeterStub(channel)


response = stub.SayHello(self.hello_request)


print('Got reply from %s: "%s"' % (target, response.message))


if name == 'main':


client = GreeterClient()


targets = ['localhost', 'other-machine']


for target in targets:


client.greet(target)

In this example, the client connects to multiple servers and sends a greeting request. The server responds with a message.

Example 3: Advanced gRPC Features

The grpc library also supports advanced features like streaming, bidirectional streaming, and client-side streaming. These features are perfect for applications that require efficient data transfer.

For instance, you can use the ClientStreamingCall class to send multiple requests at once:

import grpc

class StreamRequest:


def init(self):


self.requests = []


def add_request(self, request):


self.requests.append(request)


def start_streaming(self):


channel = grpc.insecure_channel('localhost:50051')


stub = helloworld_pb2_grpc.GreeterStub(channel)


response = stub.ClientStreamingCall(self.start_streaming())


for request in self.requests:


stub.AddNumbers(request, response)


if name == 'main':


client = StreamRequest()

Add multiple requests

client.add_request(helloworld_pb2.AddTwoNumbersRequest(a=1, b=2))


client.add_request(helloworld_pb2.AddTwoNumbersRequest(a=3, b=4))


client.start_streaming()

These are just a few examples of using gRPC in Python. For more information and code snippets, feel free to explore GitHub or the official gRPC documentation!

I hope this helps!

Related Articles