Implementación de un servicio gRPC unario
Servidor y cliente con grpc-go
Implementación de un servicio gRPC unario es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 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 Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.
¿Qué es un RPC unario?
Un RPC unario es el patrón más sencillo de gRPC: el cliente envía una solicitud y recibe una respuesta, de forma similar a una llamada a una función normal a través de la red.
Implementación del servidor
Implemente la interfaz generada. Inserte la estructura Unimplemented*Server para garantizar la compatibilidad 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
}Inicio del servidor
Cree un servidor gRPC, registre la implementación y escuche en un puerto TCP:
lis, _ := net.Listen("tcp", ":50051")
grpcSrv := grpc.NewServer()
pb.RegisterUserServiceServer(grpcSrv, &userServer{})
log.Fatal(grpcSrv.Serve(lis))Conexión del cliente
Conéctese al servidor y cree un 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)Realización de una llamada unaria
Llame al método RPC en el stub del cliente como si fuera una función 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)Gestión de errores
gRPC utiliza códigos de estado. Devuelva errores con status.Errorf y compruébelos con 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 */ }Propagación del contexto
El contexto que se pasa a la llamada RPC del cliente transporta los tiempos límite y la cancelación al servidor. El servidor debe pasarlo a las llamadas posteriores (a la base de datos y a otros RPC).
TLS en producción
En producción, sustituya las credenciales no seguras por TLS:
creds, _ := credentials.NewServerTLSFromFile("cert.pem", "key.pem")
grpcSrv := grpc.NewServer(grpc.Creds(creds))UnimplementedServer
Insertar pb.UnimplementedXxxServer proporciona implementaciones auxiliares de todos los métodos RPC que devuelven el estado Unimplemented. Esto garantiza que el servidor se compile cuando se añadan nuevos RPC al proto antes de implementarlos.
grpc.Dial frente a grpc.NewClient
grpc.Dial está obsoleto en las versiones más recientes. Utilice grpc.NewClient, que no establece una conexión de forma inmediata, sino de manera diferida en la primera llamada RPC.
Servicio de reflexión
Registre el servicio de reflexión de gRPC para permitir que herramientas como grpcurl inspeccionen los servicios disponibles sin el archivo .proto:
reflection.Register(grpcSrv)Comprobación rápida
¿Cuál es la finalidad de insertar pb.UnimplementedXxxServer en una estructura de servidor gRPC?
Recapitulación: gRPC unario
Puntos clave:
- Implemente la interfaz generada e inserte UnimplementedServer
- grpc.NewServer() + Register + Serve en un listener TCP
- Cliente: grpc.NewClient + NewXxxClient generado
- Utilice status.Errorf/status.Code para gestionar los errores de gRPC
Aprende Go con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Implementación de un servicio gRPC unario» es gratis?
Sí — el texto completo de «Implementación de un servicio gRPC unario» 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 Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Implementación de un servicio gRPC unario»?
Servidor y cliente con grpc-go Practicas Go Academy 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 Go Academy?
No se requiere experiencia previa. Go Academy 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 2 de 4.
¿Cuánto tiempo toma la lección «Implementación de un servicio gRPC unario»?
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 Go Academy?
Sí. Cada lección de Go Academy 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
- Protocol Buffers y archivos .proto
- Implementación de un servicio gRPC unario
- Streaming del servidor y del cliente
- Interceptores y metadatos de gRPC