Go Academy · Aula

Implementando um serviço gRPC unário

Crie o servidor e o cliente com grpc-go

Aula 2 de 413 etapas

Implementando um serviço gRPC unário é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 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 Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é um RPC unário?

Um RPC unário é o padrão mais simples do gRPC: o cliente envia uma solicitação e recebe uma resposta, de forma semelhante a uma chamada de função comum pela rede.

Implementação do servidor

Implemente a interface gerada. Incorpore a estrutura Unimplemented*Server para garantir compatibilidade futura:

type userServer struct {
    pb.UnimplementedUserServiceServer
    db *sql.DB
}

func (s *userServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    // query DB
    return &pb.User{Id: req.Id, Name: "Alice"}, nil
}

Iniciando o servidor

Crie um servidor gRPC, registre a implementação e escute em uma porta TCP:

lis, _ := net.Listen("tcp", ":50051")
grpcSrv := grpc.NewServer()
pb.RegisterUserServiceServer(grpcSrv, &userServer{})
log.Fatal(grpcSrv.Serve(lis))

Conexão do cliente

Conecte-se ao servidor e crie um stub de cliente:

conn, err := grpc.NewClient("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { log.Fatal(err) }
defer conn.Close()
client := pb.NewUserServiceClient(conn)

Fazendo uma chamada unária

Chame o método RPC no stub do cliente como se ele fosse uma função local:

ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
user, err := client.GetUser(ctx, &pb.GetUserRequest{Id: 42})
if err != nil { log.Fatalf("error: %v", err) }
fmt.Println(user.Name)

Tratamento de erros

O gRPC usa códigos de status. Retorne erros com status.Errorf e verifique-os com status.Code(err):

import "google.golang.org/grpc/status"
import "google.golang.org/grpc/codes"

// Server:
return nil, status.Errorf(codes.NotFound, "user %d not found", req.Id)
// Client:
if status.Code(err) == codes.NotFound { /* handle */ }

Propagação do contexto

O contexto passado à chamada RPC do cliente transporta prazos e cancelamento para o servidor. O servidor deve passá-lo para chamadas posteriores (banco de dados, outros RPCs).

TLS em produção

Substitua as credenciais inseguras por TLS em produção:

creds, _ := credentials.NewServerTLSFromFile("cert.pem", "key.pem")
grpcSrv := grpc.NewServer(grpc.Creds(creds))

UnimplementedServer

Incorporar pb.UnimplementedXxxServer fornece implementações auxiliares de todos os métodos RPC que retornam o status Unimplemented. Isso garante que o servidor seja compilado quando novos RPCs forem adicionados ao proto antes de você implementá-los.

grpc.Dial versus grpc.NewClient

grpc.Dial está obsoleto em versões mais recentes. Use grpc.NewClient, que não estabelece uma conexão imediatamente, mas de forma tardia na primeira chamada RPC.

Serviço de reflexão

Registre o serviço de reflexão do gRPC para permitir que ferramentas como grpcurl inspecionem os serviços disponíveis sem o arquivo .proto:

reflection.Register(grpcSrv)

Verificação rápida

Qual é a finalidade de incorporar pb.UnimplementedXxxServer em uma estrutura de servidor gRPC?

Responda na aula interativa

Recapitulação: gRPC unário

Pontos principais:

Implemente a interface gerada; incorpore UnimplementedServer
grpc.NewServer() + Register + Serve em um ouvinte TCP
Cliente: grpc.NewClient + NewXxxClient gerado
Use status.Errorf/status.Code para o tratamento de erros gRPC

Grátis para começar

Aprenda Go com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Implementando um serviço gRPC unário” é grátis?

Sim — o texto completo de “Implementando um serviço gRPC unário” é 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 Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Implementando um serviço gRPC unário”?

Crie o servidor e o cliente com grpc-go Você pratica Go Academy 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 Go Academy?

Nenhuma experiência prévia é necessária. Go Academy 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 2 de 4.

Quanto tempo leva a aula “Implementando um serviço gRPC unário”?

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 Go Academy?

Sim. Cada aula de Go Academy 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

← Voltar para Go Academy