Sıfırdan gRPC Servisi
Python ile Uçtan Uca

mkdir grpc-demo
cd grpc-demo

python3 -m venv .venv
source .venv/bin/activate

pip install grpcio grpcio-tools

syntax = "proto3";

package chat;

service Chat {

  // Unary: tek istek gönder, tek yanıt al
  rpc SayHello (HelloRequest) returns (HelloReply);

  // Server streaming: tek istek gönder, birden fazla yanıt al
  rpc ListGreetings (HelloRequest) returns (stream HelloReply);

  // Client streaming: birden fazla istek gönder, tek yanıt al
  rpc SendManyGreetings (stream HelloRequest) returns (HelloReply);

  // Bidirectional streaming: her iki yönde de akış
  rpc ChatStream (stream HelloRequest) returns (stream HelloReply);

}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

python -m grpc_tools.protoc \
  -I. \
  --python_out=. \
  --grpc_python_out=. \
  chat.proto

import grpc
from concurrent import futures
import chat_pb2
import chat_pb2_grpc


class ChatServicer(chat_pb2_grpc.ChatServicer):

    def SayHello(self, request, context):
        # Unary: tek request, tek response döndür
        return chat_pb2.HelloReply(message=f"Merhaba, {request.name}!")

    def ListGreetings(self, request, context):
        # Server streaming: yield ile birden fazla mesaj gönder
        diller = ["Türkçe: Merhaba", "İngilizce: Hello", "Japonca: Konnichiwa"]
        for dil in diller:
            yield chat_pb2.HelloReply(message=f"{dil}, {request.name}!")

    def SendManyGreetings(self, request_iterator, context):
        # Client streaming: request_iterator'dan tüm isimleri topla
        isimler = [req.name for req in request_iterator]
        return chat_pb2.HelloReply(
            message=f"Hepsine selam: {', '.join(isimler)}"
        )

    def ChatStream(self, request_iterator, context):
        # Bidi streaming: her isteğe karşılık bir yanıt yield'la
        for request in request_iterator:
            yield chat_pb2.HelloReply(message=f"Echo: {request.name}")


def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    chat_pb2_grpc.add_ChatServicer_to_server(ChatServicer(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    print("gRPC sunucu :50051 portunda başladı")
    server.wait_for_termination()


if __name__ == '__main__':
    serve()

import grpc
import sys
import chat_pb2
import chat_pb2_grpc


def run_unary(stub):
    # Tek istek, tek yanıt — en basit RPC tipi
    reply = stub.SayHello(chat_pb2.HelloRequest(name="Dünya"))
    print(f"[unary] {reply.message}")


def run_server_stream(stub):
    # Sunucu birden fazla yanıt akıtır, for ile tüketilir
    for reply in stub.ListGreetings(chat_pb2.HelloRequest(name="Ali")):
        print(f"[server-stream] {reply.message}")


def run_client_stream(stub):
    # Generator ile birden fazla istek gönderilir, tek yanıt alınır
    isimler = ["Ali", "Veli", "Ayşe"]
    istekler = (chat_pb2.HelloRequest(name=n) for n in isimler)
    reply = stub.SendManyGreetings(istekler)
    print(f"[client-stream] {reply.message}")


def run_bidi(stub):
    # Her iki yönde de akış: generator → iterator
    def istekler():
        for isim in ["Ali", "Veli", "Ayşe"]:
            yield chat_pb2.HelloRequest(name=isim)
    for reply in stub.ChatStream(istekler()):
        print(f"[bidi] {reply.message}")


def main():
    mod = sys.argv[1] if len(sys.argv) > 1 else "unary"
    with grpc.insecure_channel("localhost:50051") as channel:
        stub = chat_pb2_grpc.ChatStub(channel)
        if mod == "unary":
            run_unary(stub)
        elif mod == "server-stream":
            run_server_stream(stub)
        elif mod == "client-stream":
            run_client_stream(stub)
        elif mod == "bidi":
            run_bidi(stub)
        else:
            print(f"Bilinmeyen mod: {mod}")
            print("Kullanım: python client.py [unary|server-stream|client-stream|bidi]")


if __name__ == '__main__':
    main()

python server.py

python client.py unary

python client.py server-stream

python client.py client-stream

python client.py bidi

# ca.crt, client.crt, client.key mTLS tutorial'ından geliyor
with open('../mtls/ca.crt', 'rb') as f: ca_cert = f.read()
with open('../mtls/client.crt', 'rb') as f: client_cert = f.read()
with open('../mtls/client.key', 'rb') as f: client_key = f.read()

creds = grpc.ssl_channel_credentials(
    root_certificates=ca_cert,
    private_key=client_key,
    certificate_chain=client_cert,
)
with grpc.secure_channel('localhost:50051', creds) as channel:
    stub = chat_pb2_grpc.ChatStub(channel)
    # ... aynı çağrılar