0Pricing
Learn Rust Coding · Lección

Realizar llamadas desde un cliente gRPC

Consuma el servicio

Realizar llamadas desde un cliente gRPC es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

El cliente generado

Para cada servicio, tonic genera una estructura de cliente, por ejemplo GreeterClient, en el módulo greeter_client. Expone un método asíncrono por cada rpc.

Puede construirlo a partir de un canal de transporte o conectarlo directamente a un endpoint.

use greeter::v1::greeter_client::GreeterClient;
use greeter::v1::HelloRequest;

Conectarse a un servidor

La forma más sencilla es GreeterClient::connect, que recibe una cadena de dirección y devuelve un cliente conectado.

Se ejecuta dentro de un contexto asíncrono, así que debe llamarlo bajo #[tokio::main] con .await.

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GreeterClient::connect("http://[::1]:50051").await?;
    Ok(())
}

Realizar una llamada unaria

Envuelva su mensaje en un tonic::Request (o utilice Request::new) y llame al método generado.

La respuesta es un tonic::Response; llame a .into_inner() para leer el mensaje.

let request = tonic::Request::new(HelloRequest { name: "Ada".into() });
let response = client.say_hello(request).await?;
println!("{}", response.into_inner().message);

Gestionar errores de Status

Si el servidor devuelve un error, la llamada se resuelve como Err(Status). Inspeccione status.code() y status.message() para reaccionar.

Esto refleja el lado del servidor: códigos como NotFound o Unauthenticated regresan al cliente.

match client.say_hello(req).await {
    Ok(resp) => println!("{}", resp.into_inner().message),
    Err(status) => eprintln!("{}: {}", status.code(), status.message()),
}

Construir un canal

Para reutilizarlo y configurarlo, construya explícitamente un Channel con Endpoint. Puede establecer tiempos de espera, keepalive de TCP y opciones de conexión.

Después, construya el cliente con GreeterClient::new(channel).

use tonic::transport::{Channel, Endpoint};
let channel = Endpoint::from_static("http://[::1]:50051")
    .timeout(std::time::Duration::from_secs(5))
    .connect()
    .await?;
let mut client = GreeterClient::new(channel);

Enviar metadatos

Adjunte encabezados, como tokens de autenticación, insertándolos en los metadatos de la solicitud antes de enviarla.

Utilice MetadataValue para el valor; debe ser un valor de encabezado ASCII válido.

use tonic::metadata::MetadataValue;
let mut req = tonic::Request::new(HelloRequest { name: "Ada".into() });
let token: MetadataValue<_> = "Bearer abc123".parse()?;
req.metadata_mut().insert("authorization", token);

Plazos por llamada

Establezca un plazo para que un servidor lento no bloquee el cliente. set_timeout en la solicitud la cancela con un estado DeadlineExceeded si se supera el plazo.

Los plazos se propagan al servidor, que puede detener el trabajo antes de tiempo.

let mut req = tonic::Request::new(HelloRequest { name: "Ada".into() });
req.set_timeout(std::time::Duration::from_secs(2));
let resp = client.say_hello(req).await?;

Consumir un flujo del servidor

Una llamada con streaming del servidor devuelve un flujo. Obténgalo con into_inner() y extraiga mensajes con message().await en un bucle hasta que devuelva None.

Cada iteración proporciona una respuesta decodificada.

let mut stream = client.server_stream(req).await?.into_inner();
while let Some(item) = stream.message().await? {
    println!("{:?}", item);
}

Streaming del cliente

Para una llamada con streaming del cliente, pase un flujo asíncrono de solicitudes. Envuelva un iterador o un canal con tokio_stream y páselo al método.

La única respuesta llega después de que termine de enviar.

use tokio_stream::iter;
let outbound = iter(vec![msg1, msg2, msg3]);
let response = client.client_stream(Request::new(outbound)).await?;
println!("{:?}", response.into_inner());

Conexiones TLS

Para un transporte cifrado, configure un ClientTlsConfig con un certificado de CA y el dominio del servidor; después, conéctese mediante https.

Esto requiere la característica tls en la dependencia tonic.

use tonic::transport::{ClientTlsConfig, Endpoint};
let tls = ClientTlsConfig::new().domain_name("example.com");
let channel = Endpoint::from_static("https://example.com:50051")
    .tls_config(tls)?
    .connect()
    .await?;

Reutilizar el cliente

El Channel subyacente se puede clonar fácilmente y multiplexa las solicitudes en una sola conexión HTTP/2. Clone el cliente entre tareas en lugar de volver a conectarse.

Así se mantienen bajos los costes de establecer conexiones cuando hay concurrencia.

let client = GreeterClient::new(channel);
let mut c1 = client.clone();
let mut c2 = client.clone();
// use c1 and c2 in separate tokio tasks

Comprobación rápida

¿Cómo se lee el resultado de una llamada unaria de cliente en tonic?

Resumen

Conectó un cliente generado, realizó llamadas unarias, gestionó errores Status, construyó canales configurados, envió metadatos, estableció plazos, consumió flujos del servidor y del cliente, habilitó TLS y reutilizó clientes clonados de forma económica.

Ahora puede crear servicios gRPC completos basados en tonic de extremo a extremo.

Preguntas frecuentes

¿La lección «Realizar llamadas desde un cliente gRPC» es gratis?

Sí — el texto completo de «Realizar llamadas desde un cliente gRPC» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Realizar llamadas desde un cliente gRPC»?

Consuma el servicio Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Realizar llamadas desde un cliente gRPC»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Protobuf y definiciones de servicios
  2. Generar código con tonic-build
  3. Implementar un servidor gRPC
  4. Realizar llamadas desde un cliente gRPC
← Volver a Learn Rust Coding