Code mit tonic-build generieren
Kompilieren Sie proto zu Rust.
Code mit tonic-build generieren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Was tonic-build macht
tonic-build wird zur Kompilierzeit ausgeführt und wandelt Ihre .proto-Dateien in Rust-Quellcode um. Es kapselt prost-build für Nachrichten und ergänzt darauf aufbauend die gRPC-Service-Traits und -Clients.
Es wird über ein Cargo-Build-Skript (build.rs) ausgeführt, sodass die Generierung automatisch vor der Kompilierung Ihrer Crate erfolgt.
Cargo-Abhängigkeiten
Sie benötigen Crates zur Laufzeit und eine Crate zur Build-Zeit. tonic und prost sind normale Abhängigkeiten; tonic-build gehört unter [build-dependencies].
tonic verwendet tokio als asynchrone Laufzeitumgebung, daher müssen Sie auch diese einbinden.
[dependencies]
tonic = "0.12"
prost = "0.13"
tokio = { version = "1", features = ["full"] }
[build-dependencies]
tonic-build = "0.12"Ein minimales build.rs
Erstellen Sie build.rs im Stammverzeichnis der Crate. Rufen Sie tonic_build::compile_protos mit dem Pfad zu Ihrer Proto-Datei auf.
Standardmäßig werden dabei sowohl Client- als auch Server-Code kompiliert und in das Cargo-OUT_DIR geschrieben.
fn main() -> Result<(), Box<dyn std::error::Error>> {
tonic_build::compile_protos("proto/greeter.proto")?;
Ok(())
}Den Builder konfigurieren
Für mehr Kontrolle verwenden Sie tonic_build::configure(). Sie können die Generierung des Clients oder Servers deaktivieren, Ausgabepfade festlegen oder Typattribute hinzufügen.
Hier generieren wir den Server, überspringen aber den Client – nützlich für eine reine Backend-Crate.
tonic_build::configure()
.build_client(false)
.build_server(true)
.compile_protos(&["proto/greeter.proto"], &["proto"])?;Include-Pfade
Das zweite Argument von compile_protos ist die Liste der Include-Verzeichnisse. Imports innerhalb Ihrer Proto-Datei, etwa google/protobuf/empty.proto, werden anhand dieser Stammverzeichnisse aufgelöst.
Binden Sie immer das Verzeichnis ein, das Ihre Proto-Dateien enthält, damit dateiübergreifende Imports aufgelöst werden können.
tonic_build::configure()
.compile_protos(
&["proto/greeter.proto", "proto/health.proto"],
&["proto"],
)?;Wo der Code landet
Generierte Dateien werden in das Verzeichnis geschrieben, das in der Umgebungsvariable OUT_DIR angegeben ist. Ihr Name basiert auf dem Proto-Paket, zum Beispiel greeter.v1.rs.
Sie binden sie mit dem Makro include_proto! innerhalb eines Moduls in Ihre Crate ein.
pub mod greeter {
pub mod v1 {
tonic::include_proto!("greeter.v1");
}
}Was generiert wird
Für jeden Service erzeugt tonic ein Servermodul mit einem Trait (zum Beispiel greeter_server::Greeter) und einem Wrapper GreeterServer sowie eine Client-Struktur GreeterClient.
Jede Nachricht wird zu einer Rust-Struktur, die Clone, PartialEq und prosts Message ableitet.
// generated (sketch):
// pub mod greeter_server { pub trait Greeter { /* methods */ } }
// pub mod greeter_client { pub struct GreeterClient<T> { /* ... */ } }Derives mit type_attribute hinzufügen
Oft benötigen Sie zusätzliche Derives für generierte Strukturen, etwa serde::Serialize. Verwenden Sie type_attribute, um Attribute auf bestimmte Typen oder mit . auf alle Typen anzuwenden.
So können generierte Nachrichten in JSON-APIs oder Test-Fixtures verwendet werden.
tonic_build::configure()
.type_attribute(".", "#[derive(serde::Serialize)]")
.compile_protos(&["proto/greeter.proto"], &["proto"])?;Neubuilds auslösen
Cargo führt build.rs nur dann erneut aus, wenn es annimmt, dass sich Eingaben geändert haben. Geben Sie Zeilen mit cargo:rerun-if-changed aus, damit Änderungen an Proto-Dateien eine erneute Generierung erzwingen.
Andernfalls wird eine geänderte Proto-Datei möglicherweise erst dann neu generiert, wenn Sie eine Rust-Datei ändern.
fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("cargo:rerun-if-changed=proto/greeter.proto");
tonic_build::compile_protos("proto/greeter.proto")?;
Ok(())
}Voraussetzung protoc
Historisch hat tonic-build den Compiler protoc als externen Prozess aufgerufen, der installiert sein musste. Moderne Versionen können den in reinem Rust geschriebenen Parser protox verwenden und diese Abhängigkeit dadurch vermeiden.
Wenn Sie einen Fehler wegen eines fehlenden protoc sehen, installieren Sie protoc oder aktivieren Sie ein Feature für einen mitgelieferten Compiler.
// In CI you may install protoc, e.g.:
// apt-get install -y protobuf-compilerDateideskriptorsammlungen
Für Reflection oder fortgeschrittene Werkzeuge können Sie tonic-build anweisen, mit file_descriptor_set_path eine Dateideskriptorsammlung auszugeben.
Die resultierenden Bytes können an tonic-reflection übergeben werden, sodass Werkzeuge wie grpcurl Ihre Services zur Laufzeit erkennen können.
tonic_build::configure()
.file_descriptor_set_path(
std::env::var("OUT_DIR").unwrap() + "/greeter.bin")
.compile_protos(&["proto/greeter.proto"], &["proto"])?;Kurze Überprüfung
Wohin gelangt der generierte tonic-Code, und wie wird er geladen?
Zusammenfassung
Sie haben Abhängigkeiten eingerichtet, ein build.rs geschrieben, die Generierung von Client und Server sowie Include-Pfade konfiguriert, Code über include_proto! geladen, Derives hinzugefügt, Auslöser für Neubuilds behandelt und protoc sowie Deskriptorsammlungen kennengelernt.
Als Nächstes implementieren Sie den von tonic generierten Server-Trait.
Häufig gestellte Fragen
Ist die Lektion „Code mit tonic-build generieren“ kostenlos?
Ja — der vollständige Text von „Code mit tonic-build generieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Code mit tonic-build generieren“?
Kompilieren Sie proto zu Rust. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn Rust Coding zu starten?
Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Code mit tonic-build generieren“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?
Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Protobuf- und Servicedefinitionen
- Code mit tonic-build generieren
- Einen gRPC-Server implementieren
- Von einem gRPC-Client aufrufen