# Tonic — Native gRPC Framework for Rust

> A Rust implementation of gRPC built on top of Hyper and Tower, providing async client and server stubs, streaming, TLS, interceptors, and load balancing out of the box.

## Install

Save as a script file and run:

# Tonic — Native gRPC Framework for Rust

## Quick Use
```bash
# Add to Cargo.toml
cargo add tonic tonic-build prost
# In build.rs, compile .proto files
# tonic_build::compile_protos("proto/service.proto").unwrap();
cargo build
```

## Introduction
Tonic is an async-first gRPC framework for Rust that generates client and server code from Protocol Buffer definitions. Built on Hyper for HTTP/2 and Tower for middleware, it gives Rust developers a type-safe, high-performance RPC layer that integrates naturally with the Tokio async ecosystem.

## What Tonic Does
- Generates strongly typed client and server stubs from `.proto` files at compile time
- Supports unary, server-streaming, client-streaming, and bidirectional-streaming RPCs
- Provides built-in TLS via rustls or native-tls for encrypted connections
- Integrates with Tower middleware for interceptors, timeouts, rate limiting, and load balancing
- Handles gRPC metadata, status codes, and error details following the gRPC specification

## Architecture Overview
Tonic uses tonic-build (wrapping prost) to generate Rust types and service traits from Protobuf definitions during `cargo build`. The server side implements generated traits with async functions, and Tonic serves them over HTTP/2 via Hyper. The client side returns strongly typed futures. The Tower service abstraction allows stacking middleware layers for cross-cutting concerns like tracing, authentication, and compression.

## Self-Hosting & Configuration
- Add `tonic`, `prost`, and `tonic-build` as dependencies in `Cargo.toml`
- Place `.proto` files in a `proto/` directory and configure `build.rs` to compile them
- Enable TLS by configuring `ServerTlsConfig` with certificate and key paths
- Enable gzip or zstd compression with `.send_compressed()` and `.accept_compressed()`
- Deploy as a standard Rust binary behind a load balancer or within a Kubernetes pod

## Key Features
- Compile-time code generation ensures type safety between client and server
- Full HTTP/2 support with multiplexed streams and flow control
- Tower compatibility enables reuse of the broad middleware ecosystem
- gRPC-Web support via tonic-web for browser clients
- Reflection support via tonic-reflection for runtime service discovery

## Comparison with Similar Tools
- **grpc-go** — Go gRPC library; Tonic provides similar functionality with Rust's memory safety guarantees
- **grpc-node** — Node.js gRPC; Tonic offers lower latency and no garbage collection pauses
- **tarpc** — Rust RPC without Protobuf; Tonic uses the standard gRPC protocol for cross-language interop
- **Cap'n Proto RPC** — alternative serialization with RPC; Tonic uses the widely adopted Protobuf/gRPC ecosystem
- **Connect-Go** — simplified gRPC for Go; Tonic stays closer to the full gRPC spec with streaming

## FAQ
**Q: Does Tonic require Tokio?**
A: Yes. Tonic is built on Tokio and Hyper for async I/O and HTTP/2 transport.

**Q: Can I use Tonic without Protobuf?**
A: Tonic is designed around Protobuf code generation. For Protobuf-free RPC in Rust, consider tarpc.

**Q: Does it support gRPC health checking?**
A: Yes. The `tonic-health` crate implements the standard gRPC health checking protocol.

**Q: How do I add authentication?**
A: Use Tower interceptors or layers to inspect metadata and validate tokens before requests reach service handlers.

## Sources
- https://github.com/hyperium/tonic
- https://docs.rs/tonic

---
Source: https://tokrepo.com/en/workflows/asset-54c0e532
Author: Script Depot