پروتکل بافر (Protocol Buffers)

پروتکل بافر یک روش سریالیزیشن داده‌ها است که به شما اجازه می‌دهد داده‌ها را به صورت ساختاریافته و بهینه ذخیره و منتقل کنید. این روش به‌ویژه در سیستم‌های توزیع‌شده و میکروسرویس‌ها کاربرد فراوانی دارد.

مزایای پروتکل بافر:

- فشرده‌سازی: داده‌ها به صورت باینری ذخیره می‌شوند، که باعث کاهش حجم می‌شود.
- قابلیت توسعه: می‌توانید به سادگی فیلدهای جدید به پیام‌ها اضافه کنید.
- پشتیبانی از چندین زبان: از زبان‌های مختلفی پشتیبانی می‌کند و میتوانید کد های زبان های مختلفی رو با کامپایر پروتکل بافر ایجاد کنید.

از پروتکل بافر می توانیم در هسته سیستم خودمون، تو شرایط مختلفی که نیاز به سریالیزیشن و انتقال دیتا داریم، استفاده کنیم حتی اگر grpc هم استفاده نکنیم.

مثال: استفاده از پروتکل بافر در یک سیستم Message Driven

بیایید یک سناریو فرضی بسازیم که در آن از پروتکل بافر برای سریالیزیشن پیام‌ها در یک سیستم مبتنی بر پیام استفاده می‌کنیم. ما یک سرویس داریم که داده‌های کاربر را دریافت می‌کند و آن‌ها را به یک صف پیام ارسال می‌کند.

۱. تعریف پیام‌ها

ابتدا ساختار پیام‌ها را در یک فایل .proto تعریف می‌کنیم:

syntax = "proto3";

package user;

message User {
    string name = 1;
    int32 age = 2;
}

۲. تولید کد گولنگ

برای تولید کد گولنگ، ابتدا باید ابزار protoc و پلاگین Go را نصب کنید:

go get google.golang.org/protobuf/cmd/protoc-gen-go

سپس، کد گولنگ را با دستور زیر تولید کنید:

protoc --go_out=. user.proto

۳. ارسال پیام به سیستم Message Driven

حالا بیایید یک تولیدکننده پیام ایجاد کنیم که یک کاربر را سریالیزه کرده و به یک صف پیام (مثل Kafka) ارسال کند.

package main

import (
    "log"
    "github.com/confluentinc/confluent-kafka-go/kafka"
    "google.golang.org/protobuf/proto"
    "your_project/user"
)

func main() {
    producer, err := kafka.NewProducer(&kafka.ConfigMap{"bootstrap.servers": "localhost:9092"})
    if err != nil {
        log.Fatal(err)
    }
    defer producer.Close()

    // create user
    user := &user.User{
        Name: "Alice",
        Age:  30,
    }

    // serialize data
    data, err := proto.Marshal(user)
    if err != nil {
        log.Fatal("Failed to serialize user:", err)
    }

    // publish a message
    topic := "users"
    err = producer.Produce(&kafka.Message{
        TopicPartition: kafka.TopicPartition{Topic: &topic, Partition: kafka.PartitionAny},
        Value:          data,
    }, nil)

    if err != nil {
        log.Fatal("Failed to send message:", err)
    }

    producer.Flush(15 * 1000)
    log.Println("User sent to Kafka:", user.Name)
}

۴. کانسیوم پیام از سیستم Message Driven

حالا بیایید یک consumer پیام بسازیم که پیام‌های دریافتی را دی‌سریالیزه کند:

package main

import (
    "log"
    "github.com/confluentinc/confluent-kafka-go/kafka"
    "google.golang.org/protobuf/proto"
    "your_project/user"
)

func main() {
    consumer, err := kafka.NewConsumer(&kafka.ConfigMap{
        "bootstrap.servers": "localhost:9092",
        "group.id":          "user_group",
        "auto.offset.reset": "earliest",
    })
    if err != nil {
        log.Fatal(err)
    }
    defer consumer.Close()

    consumer.SubscribeTopics([]string{"users"}, nil)

    for {
        msg, err := consumer.ReadMessage(-1)
        if err != nil {
            log.Println("Error reading message:", err)
            continue
        }

        // deserialization
        receivedUser := &user.User{}
        if err := proto.Unmarshal(msg.Value, receivedUser); err != nil {
            log.Println("Failed to unmarshal user:", err)
            continue
        }

        // use info
        log.Printf("Received User: Name: %s, Age: %d\n", receivedUser.Name, receivedUser.Age)
    }
}

#protocol_buffer

@Syntax_fa