Criando o primeiro servidor gRPC em Go

Curso de Go Avanzado: Protobuffers y gRPC

Contenido del curso

Introducción

gRPC

Conclusión

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:50

Criando o primeiro servidor gRPC em Go

Curso de Go Avanzado: Protobuffers y gRPC

Clase 10 de 22

Clase 10 / 22

Recursos

Construir um servidor gRPC em Go envolve mais do que escrever funções: requer ligar o repositório, respeitar interfaces geradas pelo proto buffer e configurar o listener TCP correto. Aqui vais aprender a montar o teu primeiro StudentServiceServer passo a passo, ideal para quem já trabalha com bases de dados em Go e quer dar o salto para microsserviços.

Como estruturar a pasta server e o construtor do StudentServer?

O ponto de partida é organizar o código numa pasta dedicada. Cria uma pasta server e, dentro dela, um ficheiro server.go com o pacote server. A struct principal recebe o repositório como dependência, o que permite isolar a lógica de acesso a dados da lógica de transporte gRPC.

O construtor NewStudentServer aceita um repo do tipo repositório e devolve uma instância do servidor. Esta separação facilita testes e respeita o princípio de injeção de dependências.

¿Para que serve o construtor NewStudentServer? Recebe o repositório como parâmetro e devolve uma instância pronta para registar no gRPC, ligando a camada de dados à camada de serviço.

Um detalhe técnico importante [02:10]: renomeia a pasta gerada pelo proto buffer para studentPB, igual ao nome do pacote definido no ficheiro .proto. Assim, o Go importa-a sem conflitos.

Como implementar GetStudent e SetStudent no servidor gRPC?

Ambos os métodos seguem a assinatura definida no ficheiro .proto gerado. O servidor traduz pedidos gRPC em chamadas ao repositório e devolve respostas tipadas.

GetStudent: ler um aluno pelo id

O método recebe um context.Context e um *studentPB.GetStudentRequest. Para aceder ao identificador podes usar request.Id ou o getter request.GetId(), ambos válidos.

go func (s *Server) GetStudent(ctx context.Context, request *studentPB.GetStudentRequest) (*studentPB.Student, error) { student, err := s.repo.GetStudent(ctx, request.GetId()) if err != nil { return nil, err } return &studentPB.Student{ Id: student.Id, Name: student.Name, Age: student.Age, }, nil }

Repara num ponto crítico: a struct studentPB.Student e a struct do modelo de dados não são iguais. Uma vem do código gerado pelo proto, a outra do teu modelo interno. Tens de mapear os campos manualmente [04:20].

SetStudent: inserir um aluno

Aqui o pedido é um studentPB.Student completo, e a resposta é um SetStudentResponse que devolve apenas o id. Constrói a struct do modelo a partir do request, envia para o repositório e devolve a confirmação.

Qual é a diferença entre GetStudentRequest e Student como input? GetStudentRequest carrega só o id para leitura; Student carrega todos os campos para inserção ou atualização.

Como ligar o servidor gRPC com listener TCP e Reflection?

Na pasta server/student cria um main.go com package main. A função main precisa de quatro peças: o listener TCP, o repositório, a struct do servidor e o registo no gRPC.

O listener abre a porta com net.Listen("tcp", ":5060"). Se houver erro, log.Fatal encerra a aplicação. A porta 5060 é configurável, tal como a URL do PostgreSQL que injetas no NewPostgresRepository.

go lis, err := net.Listen("tcp", ":5060") if err != nil { log.Fatal(err) } repo, err := database.NewPostgresRepository(url) srv := server.NewStudentServer(repo) s := grpc.NewServer() studentPB.RegisterStudentServiceServer(s, srv) reflection.Register(s) s.Serve(lis)

Por que aparece o erro de interface não implementada?

Ao chamar RegisterStudentServiceServer, o Go espera uma interface StudentServiceServer completa. Se faltar algum método, o compilador reclama. A solução elegante é incorporar studentPB.UnimplementedStudentServiceServer dentro da tua struct Server.

Isto funciona porque o Go usa composição em vez de herança. Ao embeber a struct unimplemented, o teu servidor herda automaticamente todos os métodos exigidos pela interface, mesmo os que ainda não escreveste.

Para que serve Reflection no gRPC?

O reflection.Register(s) expõe metadados sobre os serviços disponíveis. Sem isto, ferramentas como o Postman não conseguem descobrir os métodos do teu servidor para testá-los.

¿O que é Reflection em gRPC? É um mecanismo que entrega metadados dos serviços ao cliente, permitindo que ferramentas como Postman explorem e invoquem métodos sem ter o ficheiro .proto localmente.

Chama reflection.Register antes de s.Serve(lis), caso contrário o servidor arranca sem expor essa informação.

Conceitos e habilidades que ficam contigo

Composição em Go com Unimplemented...Server para cumprir interfaces geradas [07:15].
Mapeamento entre structs do proto buffer e modelos internos da aplicação.
Configuração de listeners TCP na porta 5060 com net.Listen.
Uso de getters gerados (GetId, GetName, GetAge) versus acesso direto a campos.
Registo de serviços gRPC com RegisterStudentServiceServer e ativação de Reflection.

Na próxima aula vais testar tudo isto com Postman e validar as chamadas reais ao servidor. Se já experimentaste, conta nos comentários como correu a tua primeira ligação gRPC.

Nicolás Sañudo

Hace 4 años

Objetivo de la clase: crear servidor gRPC.

El nombre del directorio que contiene el protobuffer, tiene que ser el mismo nombre de paquete que declaramos en el archivo .proto:

option go_package = "github.com/neecosanudo/platzi-grpc;studentpb";

Renombramos el directorio proto a studentpb con Git:

git mv proto/ studentpb/

++Nota++: escribí comentarios sobre los archivos de los servidores para tener como notas. Dejo el contenido de ambos archivos en los comentarios de este comentario.

Nicolás Sañudo

Hace 4 años

Dentro de server-student/:

/** filename: server.go */
package main

import (
	"log"
	"net"

	"github.com/neecosanudo/platzi-grpc/database"
	"github.com/neecosanudo/platzi-grpc/server"
	"github.com/neecosanudo/platzi-grpc/studentpb"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

func main() {
	list, err := net.Listen("tcp", ":5060")

	if err != nil {
		log.Fatal(err)
	}

	repo, err := database.NewPostgresRepository("postgres://postgres:postgres@localhost:5432/postgres?sslmode=disable")

	server := server.NewStudentServer(repo)

	if err != nil {
		log.Fatal(err)
	}

	// Utilizamos gRPC por primera vez
	s := grpc.NewServer()
	studentpb.RegisterStudentServiceServer(s, server)

	// reflection va a servir para poder proveer cierta meta-data a los clientes
	reflection.Register(s)

	// Levantamos el servidor
	err = s.Serve(list)
	if err != nil {
		log.Fatal(err)
	}
}

Nicolás Sañudo

Hace 4 años

Dentro de server/:

/** filename: server.go */
package server

import (
	"context"

	"github.com/neecosanudo/platzi-grpc/models"
	"github.com/neecosanudo/platzi-grpc/repository"
	"github.com/neecosanudo/platzi-grpc/studentpb"
)

type Server struct {
	repo repository.Repository
	// Composition Over Inheritance: importante para que el servidor grpc admita este server
	studentpb.UnimplementedStudentServiceServer
}

// Constructor del servidor
func NewStudentServer(repo repository.Repository) *Server {
	return &Server{repo: repo}
}

// Implementamos las funciones GetStudent y SetStudent
func (s *Server) GetStudent(ctx context.Context, req *studentpb.GetStudentRequest) (*studentpb.Student, error) {
	// Traemos el estudiante que se encontró a través del repository
	student, err := s.repo.GetStudent(ctx, req.GetId())
	/**
		req.GetId() puede ser pasado como req.Id
		Ambos refieren al ID que declaramos en el archivo .proto:

		message GetStudentRequest {
	  	string id = 1;
		} */
	if err != nil {
		return nil, err
	}

	// &studentpb.Student viene del protobuffer que definimos.
	return &studentpb.Student{
		// student.Id, student.Name y student.Age, vienen del struct en models/
		Id:   student.Id,
		Name: student.Name,
		Age:  student.Age,
	}, nil
}

func (s *Server) SetStudent(ctx context.Context, req *studentpb.Student) (*studentpb.SetStudentResponse, error) {
	// Creamos el estudiante que vamos a enviar por el servidor
	student := &models.Student{ // struct que definimos en models/
		// req.GetId(), req.GetName() y req.GetAge(), vienen del protobuffer
		Id:   req.GetId(),
		Name: req.GetName(),
		Age:  req.GetAge(),
	}

	err := s.repo.SetStudent(ctx, student)
	if err != nil {
		return nil, err
	}

	return &studentpb.SetStudentResponse{
		Id: student.Id,
	}, nil
}

Introducción

Microservicios de alto rendimiento con gRPC y Go

Proyecto gRPC con streaming bidireccional

Qué son los Protocol Buffers y cómo funcionan

Compilar Protobuf a paquete Go con protoc

De monolito a microservicios con gRPC

gRPC

gRPC: qué lo hace más rápido que REST

JSON vs Protobuf: cuándo usar cada uno

Definir un StudentService con proto buffers en Go

Implementación de Repositorios y gRPC en Go con PostgreSQL

Criando o primeiro servidor gRPC em Go

Prueba tu servidor gRPC con Postman

Definiendo el servicio de test en gRPC

Implementando servidor gRPC con PostgreSQL en Go

Client streaming en gRPC con Go

Implementación de Streaming del Servidor con gRPC y Protobufs

Streaming del servidor con gRPC en Go

Streaming bidireccional en gRPC con Go

Prueba de streaming bidireccional con gRPC

Implementando un cliente gRPC en Go

Streaming bidireccional en gRPC con Go

Conclusión

gRPC en el navegador con Envoy

Streaming de Datos con gRPC y Protobufers en Backends

Criando o primeiro servidor gRPC em Go

Progreso del curso

Introducción

gRPC

Conclusión

Recursos

Recursos