Привет, Хабр!
Protobuf, или Protocol Buffers, это бинарный формат сериализации, разработанный в Google для эффективного обмена данными между сервисами. Это как JSON, только компактнее, быстрее и типизированнее. Если JSON был вашим первым крашем в мире сериализации, то Protobuf – это тот, с кем вы хотите серьёзных отношений.
Если вы хотите, чтобы ваши приложения общались между сервисами с молниеносной скоростью и минимальными задержками, тогда Protobuf — твой хороший выбор.
Установка
Шаг 1: установка Protobuf Compiler
Первым делом, вам нужно скачать Protobuf Compiler. Загляните на GitHub страницу Protobuf и выберите версию, подходящую для вашей ОС.
После скачивания распакуйте содержимое и добавьте путь к исполняемому файлу protoc в вашу системную переменную PATH. В Unix это что-то вроде export PATH=$PATH:/path/to/protoc.
Шаг 2: установка Protobuf Plugin
Запустите go get -u google.golang.org/protobuf/cmd/protoc-gen-go для установки плагина protoc для Go. Этот плагин нужен, чтобы превращать ваши .proto файлы в go-файлы.
Введите protoc --version в консоли. Если вы видите версию, вы успешно установили компилятор!
Cтруктура .proto файлов
Прежде всего, .proto файл - это схема данных для Protobuf. Это место, где вы описываете структуру данных, которую хотите сериализовать/десериализовать.
Все начинается с указания версии синтаксиса. Например, syntax = "proto3";. Это говорит компилятору, какие правила использовать при анализе содержимого. Затем идет объявление пакета package mypackage;. Это помогает избежать конфликтов имен и организовать код.
Сердце .proto файла - это объявления сообщений. Каждое сообщение - это структура данных, которую вы хотите сериализовать.
Сообщения определяются с использованием синтаксиса message MyMessage {}. Внутри фигурных скобок вы описываете поля данных. Поля могут быть стандартными типами данных, такими как int32, float, double, string или bool. Также могут быть пользовательские типы или другие сообщения.
В Protobuf есть три типа правил для полей: singular для одиночных значений, repeated для массивов значений и map для ассоциативных массивов. Каждому полю присваивается уникальный номер. Эти номера используются в бинарном представлении и очень важны для совместимости данных
Начинайте номера полей с 1, и будьте осторожны, не перепрыгивая через десятки и сотни - это может быть полезно для будущих версий вашего протокола. Если поле больше не нужно, пометьте его как reserved.
Предположим, вы хотите сериализовать информацию о техническом обзоре, который включает в себя разделы, заголовки и содержание:
syntax = "proto"
package techreview;
// Объявляем перечисление для различных типов контента
enum ContentType {
UNKNOWN = 0;
INTRODUCTION = 1;
TECHNICAL_OVERVIEW = 2;
BEST_PRACTICES = 3;
CONCLUSION = 4;
}
// Определяем структуру для раздела обзора
message Section {
string title = 1; // Заголовок раздела
string content = 2; // Содержание раздела
ContentType type = 3; // Тип содержимого (введение, обзор и т.д.)
}
// Определяем основную структуру для всего технического обзора
message TechnicalReview {
repeated Section sections = 1; // Массив разделов обзора
}Enums, Maps
Создаем Enum в .proto:
enum Status {
UNKNOWN = 0;
RUNNING = 1;
STOPPED = 2;
}После компиляции .proto файла, мы получаем четко определенный тип Status, который можно использовать прямо в коде.
var currentStatus Status = Status_RUNNINGMaps позволяет создавать структурированные коллекции пар ключ-значение.
Объявление Map в .proto:
message Environment {
map<string, string> variables = 1;
}После компиляции .proto файла, мы получаем map, который можно легко использовать.
env := Environment{
Variables: map[string]string{"HOME": "/home/user", "PATH": "/usr/bin"},
}Прощай, массивы пар или сложные структуры для простых задач.
Oneof: когда одного поля мало
oneof - это инструмент в Protobuf для работы с различными структурами в одном поле.
В .proto файле:
message Command {
oneof command_type {
string text = 1;
int32 number = 2;
}
}После компиляции .proto, можно управлять этими полями как обычными структурами в Go.
cmd := Command{
CommandType: &Command_Text{Text: "Hello, Protobuf!"},
}Как автоматически генерировать код из .proto файлов
Допустим, у нас есть следующий .proto файл, который описывает структуру данных для пользователя:
syntax = "proto ";
package user;
message User {
string name = 1;
int32 age = 2;
string email = 3;
} Для генерации кода можно юзать команду protoc:
protoc --go_out=. user.protoПосле выполнения этой команды в той же директории появится файл user.pb.go, содержащий код на Go для ваших структур данных.
Как можно использовать сгенерированный код на Go:
package main
import (
"fmt"
"log"
"github.com/golang/protobuf/proto"
"path/to/generated/user" // Импорт сгенерированного кода
)
func main() {
newUser := &user.User{
Name: "Alice",
Age: 30,
Email: "alice@example.com",
}
// сериализация данных
data, err := proto.Marshal(newUser)
if err != nil {
log.Fatal("Marshaling error: ", err)
}
// десериализация данных
newUser2 := &user.User{}
err = proto.Unmarshal(data, newUser2)
if err != nil {
log.Fatal("Unmarshaling error: ", err)
}
fmt.Println(newUser2.GetName(), newUser2.GetAge(), newUser2.GetEmail())
}Для добавления дополнительного функционала можно использовать плагины. Например, protoc-gen-go-grpc для создания gRPC сервера и клиента.
gRPC в protobuf
Установим нужные пакеты:
go get -u google.golang.org/grpc
go get -u github.com/golang/protobuf/protoc-gen-goДля начала определим наш gRPC сервис и сообщения в .proto файле:
syntax = "proto3";
package example;
// Определение сервиса
service Greeter {
// Определение метода сервиса
rpc SayHello (HelloRequest) returns (HelloReply) {}
}
// Определение сообщения, используемого для запроса
message HelloRequest {
string name = 1;
}
// Определение сообщения, используемого для ответа
message HelloReply {
string message = 1;
}Следующий шаг - сгенерировать Golang код из нашего .proto файла:
protoc --go_out=plugins=grpc:. *.protoРеализуем сервер:
package main
import (
"context"
"log"
"net"
"google.golang.org/grpc"
pb "path/to/your/protos/example"
)
// server is used to implement example.GreeterServer.
type server struct {
pb.UnimplementedGreeterServer
}
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
log.Printf("Received: %v", in.GetName())
return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}
func main() {
lis, err := net.Listen("tcp", ":50051")
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterGreeterServer(s, &server{})
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}И наконец, реализуем клиент для общения с нашим сервером:
package main
import (
"context"
"log"
"os"
"time"
"google.golang.org/grpc"
pb "path/to/your/protos/example"
)
const (
address = "localhost:50051"
defaultName = "world"
)
func main() {
// Установка соединения с сервером
conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewGreeterClient(conn)
// Имя пользователя для приветствия
name := defaultName
if len(os.Args) > 1 {
name = os.Args[1]
}
// Контекст для отмены запроса по истечении таймаута
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
// Вызов метода SayHello на сервере
r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", r.GetMessage())
}Микросервисы
Предположим, у нас есть микросервис для управления пользователями:
syntax = "proto3";
package user;
// Сервис для работы с пользователями
service UserService {
// Запрос на получение информации о пользователе
rpc GetUser (UserRequest) returns (UserResponse) {}
}
// Запрос на получение информации о пользователе
message UserRequest {
int64 id = 1;
}
// Ответ с информацией о пользователе
message UserResponse {
int64 id = 1;
string name = 2;
string email = 3;
}Допустим, мы сгенерировали Golang код из нашего файла. Напишем сервер:
package main
import (
"context"
"log"
"net"
"google.golang.org/grpc"
pb "path/to/your/protos/user"
)
type server struct {
pb.UnimplementedUserServiceServer
}
func (s *server) GetUser(ctx context.Context, in *pb.UserRequest) (*pb.UserResponse, error) {
log.Printf("Received: %v", in.GetId())
// здест к примеру логика получения пользователя из базы данных или другого сервиса
return &pb.UserResponse{Id: in.GetId(), Name: "John", Email: "john@example.com"}, nil
}
func main() {
lis, err := net.Listen("tcp", ":50051")
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterUserServiceServer(s, &server{})
log.Printf("Server listening at %v", lis.Addr())
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}Создадим клиент, который будет общаться с нашим сервером:
package main
import (
"context"
"log"
"os"
"time"
"google.golang.org/grpc"
pb "path/to/your/protos/user"
)
const (
address = "localhost:50051"
)
func main() {
// установка соединения с сервером
conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewUserServiceClient(conn)
// ус тановим контекст с таймаутом
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
// запрс на получение пользователя
r, err := c.GetUser(ctx, &pb.UserRequest{Id: 123})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("User: %s", r.GetName())
}Protobuf это компактный, бинарный формат, который уменьшает размер передаваемых данных и ускоряет их обработку, также он совместим со многими ЯПами.
В завершение хочу порекомендовать бесплатный вебинар, где вы узнаете, какие конкретные компетенции необходимы Golang-инженерам на разных этапах развития карьеры. Регистрация доступна по ссылке.
