tonic-build ile Kod Oluşturma

tonic-build runs at compile time and turns your .proto files into Rust source. It wraps prost-build for messages and adds the gRPC service traits and clients on top.

It runs from a Cargo build script (build.rs), so generation happens automatically before your crate compiles.

You need runtime crates and a build-time crate. tonic and prost are normal dependencies; tonic-build goes under [build-dependencies].

tonic relies on tokio as its async runtime, so include it too.

Create build.rs at the crate root. Call tonic_build::compile_protos with the path to your proto file.

This compiles both client and server code by default and writes it to the Cargo OUT_DIR.

For more control use tonic_build::configure(). You can disable client or server generation, set output paths, or add type attributes.

Here we generate the server but skip the client, useful for a pure backend crate.

The second argument to compile_protos is the list of include directories. Imports inside your proto, like google/protobuf/empty.proto, are resolved against these roots.

Always include the directory that contains your proto files so cross-file imports resolve.

Generated files are written to the directory in the OUT_DIR environment variable, named after the proto package, for example greeter.v1.rs.

You bring it into your crate with the include_proto! macro inside a module.

For each service tonic produces a server module with a trait (for example greeter_server::Greeter) and a GreeterServer wrapper, plus a client struct GreeterClient.

Each message becomes a Rust struct deriving Clone, PartialEq, and prost's Message.

You often want extra derives on generated structs, such as serde::Serialize. Use type_attribute to inject attributes onto specific types or all of them with ..

This lets generated messages flow into JSON APIs or test fixtures.

Cargo reruns build.rs only when it thinks inputs changed. Emit cargo:rerun-if-changed lines so edits to proto files force regeneration.

Without this, a changed proto may not regenerate until you touch a Rust file.

Historically tonic-build shelled out to the protoc compiler, which had to be installed. Modern versions can use the pure-Rust protox parser to avoid that dependency.

If you see a missing-protoc error, install protoc or enable a vendored compiler feature.

For reflection or advanced tooling, ask tonic-build to emit a file descriptor set with file_descriptor_set_path.

The resulting bytes can feed tonic-reflection, letting tools like grpcurl discover your services at runtime.

Where does generated tonic code go and how is it loaded?

You set up dependencies, wrote a build.rs, configured client/server generation and include paths, loaded code via include_proto!, added derives, handled rebuild triggers, and learned about protoc and descriptor sets.

Next you will implement the server trait that tonic generated.