0Pricing
Learn Rust Coding · Aula

Chamando a partir de um cliente gRPC

Consuma o serviço.

Chamando a partir de um cliente gRPC é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

O Cliente Gerado

Para cada serviço, tonic gera uma estrutura de cliente, como GreeterClient, no módulo greeter_client. Ela expõe um método assíncrono para cada rpc.

Você a cria a partir de um canal de transporte ou conectando-se diretamente a um endpoint.

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

Conectando-se a um Servidor

O caminho mais simples é GreeterClient::connect, que recebe uma cadeia de endereço e retorna um cliente conectado.

Ele é executado dentro de um contexto assíncrono; portanto, chame-o sob #[tokio::main] com .await.

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

Fazendo uma Chamada Unária

Envolva sua mensagem em uma tonic::Request (ou use Request::new) e chame o método gerado.

A resposta é uma tonic::Response; chame .into_inner() para ler a mensagem.

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

Tratando Erros de Status

Se o servidor retornar um erro, a chamada será resolvida como Err(Status). Inspecione status.code() e status.message() para reagir.

Isso espelha o lado do servidor: códigos como NotFound ou Unauthenticated retornam ao cliente.

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

Construindo um Canal

Para reutilização e configuração, construa um Channel explicitamente com Endpoint. Você pode definir tempos limite, manutenção de conexão TCP e opções de conexão.

Em seguida, crie o cliente com 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);

Enviando Metadados

Anexe cabeçalhos, como tokens de autenticação, inserindo-os nos metadados da solicitação antes do envio.

Use MetadataValue para o valor; ele deve ser um valor de cabeçalho 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);

Prazos por Chamada

Defina um prazo para que um servidor lento não mantenha o cliente bloqueado. set_timeout na solicitação a interrompe com um status DeadlineExceeded se o prazo for ultrapassado.

Os prazos são propagados para o servidor, que pode interromper o trabalho antecipadamente.

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?;

Consumindo um Fluxo do Servidor

Uma chamada com fluxo do servidor retorna um fluxo. Obtenha-o com into_inner() e extraia mensagens com message().await em um loop até que ele produza None.

Cada iteração fornece uma resposta decodificada.

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

Fluxo do Cliente

Para uma chamada com fluxo do cliente, passe um fluxo assíncrono de solicitações. Envolva um iterador ou canal com tokio_stream e passe-o ao método.

A única resposta chega depois que você termina 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());

Conexões TLS

Para um transporte criptografado, configure um ClientTlsConfig com um certificado CA e o domínio do servidor; em seguida, conecte-se por https.

Isso exige o recurso tls na dependência 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?;

Reutilizando o Cliente

O Channel subjacente é barato de clonar e multiplexa solicitações em uma única conexão HTTP/2. Clone o cliente entre tarefas em vez de se reconectar.

Isso mantém baixos os custos de configuração da conexão durante a concorrência.

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

Verificação Rápida

Como você lê o resultado de uma chamada de cliente unária em tonic?

Recapitulação

Você conectou um cliente gerado, fez chamadas unárias, tratou erros Status, construiu canais configurados, enviou metadados, definiu prazos, consumiu fluxos do servidor e do cliente, habilitou TLS e reutilizou clientes baratos de clonar.

Agora você pode criar serviços gRPC completos baseados em tonic, de ponta a ponta.

Perguntas Frequentes

A aula “Chamando a partir de um cliente gRPC” é grátis?

Sim — o texto completo de “Chamando a partir de um cliente gRPC” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Chamando a partir de um cliente gRPC”?

Consuma o serviço. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Chamando a partir de um cliente gRPC”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definições de Protobuf e serviços
  2. Gerando código com tonic-build
  3. Implementando um servidor gRPC
  4. Chamando a partir de um cliente gRPC
← Voltar para Learn Rust Coding