The Complete Production SOP: How to Deploy and Run Tonic Pure Rust gRPC Server & Client Implementation in Autonomous AI Agents

[package]
name = "tonic-service-demo"
version = "0.1.0"
edition = "2021"

[dependencies]
tonic = { version = "0.12", features = ["tls", "transport"] }
prost = "0.13"
tokio = { version = "1.0", features = ["macros", "rt-multi-thread", "sync"] }
tokio-stream = "0.1"
futures-core = "0.3"

[build-dependencies]
tonic-build = "0.12"

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("cargo:rerun-if-changed=proto/echo.proto");
    tonic_build::configure()
        .build_server(true)
        .build_client(true)
        .compile_protos(&["proto/echo.proto"], &["proto"])?;
    Ok(())
}

use std::net::SocketAddr;
use std::pin::Pin;
use tokio::sync::mpsc;
use tokio_stream::{wrappers::ReceiverStream, Stream, StreamExt};
use tonic::{transport::Server, Request, Response, Status, Streaming};

pub mod echo {
    tonic::include_proto!("echo");
}

use echo::echo_server::{Echo, EchoServer};
use echo::{EchoRequest, EchoResponse};

#[derive(Debug, Default)]
pub struct EchoService;

type EchoResult<T> = Result<Response<T>, Status>;
type ResponseStream = Pin<Box<dyn Stream<Item = Result<EchoResponse, Status>> + Send + 'static>>;

#[tonic::async_trait]
impl Echo for EchoService {
    async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResult<EchoResponse> {
        let req = request.into_inner();
        Ok(Response::new(EchoResponse { message: req.message }))
    }

    type BidirectionalEchoStream = ResponseStream;

    async fn bidirectional_echo(
        &self,
        request: Request<Streaming<EchoRequest>>,
    ) -> EchoResult<Self::BidirectionalEchoStream> {
        let mut in_stream = request.into_inner();
        let (tx, rx) = mpsc::channel(128);

        tokio::spawn(async move {
            while let Some(result) = in_stream.next().await {
                match result {
                    Ok(item) => {
                        let reply = EchoResponse { message: format!("Echo: {}", item.message) };
                        if tx.send(Ok(reply)).await.is_err() {
                            break;
                        }
                    }
                    Err(err) => {
                        let _ = tx.send(Err(Status::internal(err.to_string()))).await;
                        break;
                    }
                }
            }
        });

        let out_stream = ReceiverStream::new(rx);
        Ok(Response::new(Box::pin(out_stream) as Self::BidirectionalEchoStream))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr: SocketAddr = "[::1]:50051".parse()?;
    let service = EchoService::default();

    println!("Tonic gRPC Server listening on {}", addr);
    Server::builder()
        .add_service(EchoServer::new(service))
        .serve(addr)
        .await?;

    Ok(())
}

use tonic_service_demo::echo::echo_client::EchoClient;
use tonic_service_demo::echo::EchoRequest;

#[tokio::test]
async fn test_client_connection() -> Result<(), Box<dyn std::error::Error>> {
    // Verifies client endpoint binding logic and type safety
    let channel = tonic::transport::Endpoint::from_static("http://[::1]:50051");
    assert_eq!(channel.uri().to_string(), "http://[::1]:50051");
    Ok(())
}