Ridimensionamento con GRPC e Protobuf

In questo articolo, esploreremo come GRPC e la generazione del codice possono aiutarti:

• Scrivi documentazione che le persone leggono e usano effettivamente,
• Standardizzare la comunicazione tra i microservizi,
• Evita la duplicazione del codice tra i servizi.

Al giorno d’oggi, molti sviluppatori hanno già familiarità con GRPC. Non sorprende più che i crew relativi al servizio preferiscano per la comunicazione inter-servizio e persino per scopi di documentazione.

Cominciamo con l’concept chiave: Definire interfacce e strutture di dati in un unico posto – .proto File-e generare automaticamente tutto il resto.

Come scrivere la documentazione tecnica che viene letto

È una sfida difficile, indipendentemente dal tuo processo. Alcune modifiche al codice e i documenti sono già obsoleti. Allora, cosa possiamo fare?

Problemi comuni

• La documentazione diventa obsoleta più velocemente del codice.
• È difficile trovare il contratto corretto.
• Non esiste un singolo formato: alcuni usano la confluenza, alcuni usano i file readme e altri non scrivono nulla.

Ma cosa succede se .proto I file potrebbero risolvere questo problema? E se avessimo scritto il codice che si documenta? Diciamo che creiamo un /post-context listing con quanto segue:

// widespread/message.proto
syntax = "proto3";

package deal widespread;

// Person-generated content material (publish) object
message Put up {
  string id = 1;           // Distinctive ID
  string title = 2;        // Title
  string content material = 3;      // Physique
  repeated string tags = 4;// Tags
}

Allora cosa? Eseguiamo solo la generazione di codice e generato documenti direttamente da CI/CD:

protoc 
  -I. 
  --doc_out=markdown,docs.md:./docs 
  api/widespread/*.proto api/publish/**/*.proto

E questo è tutto.

Takeaway chiave

• Utilizzo .proto come il singola fonte di verità.
• Aggiungere commenti significativi advert ogni messaggio e RPC.
• Usa strumenti come protoc-gen-doc, grpc-gatewayo Swagger/OpenApi a Genera automaticamente la documentazione.

Ciò si traduce in documentazione aggiornata, leggibile e mantenuta automatica.

Come standardizzare la comunicazione del servizio

Diciamo che ora hai molti contesti e listing. Come assicurati che tutto segue uno normal?

Problemi attuali

• Un servizio utilizza JSON, un altro XML e un altro GRPC.
• Lo stesso oggetto (advert es. Put up) è descritto in modo diverso in ciascun luogo.
• L’aggiunta di nuovi servizi è doloroso.

E se ci muoviamo tutto possibile In GRPC – anche messaggi Kafka?

Il nostro approccio

1. Definisci evento Kafka PostCreatedEvent In widespread/occasion.proto.
2. Basta importare ciò di cui hai bisogno:

import "widespread/message.proto";
import "widespread/occasion.proto";

Certo, accade la duplicazione. Soprattutto quando i crew si muovono velocemente: enum, codici di errore e altro possono essere copiati. E poi un piccolo cambiamento provoca una cascata di aggiornamenti manuali.

Seguiamo la struttura:

api
├── widespread
│   ├── message.proto       # Put up object
│   └── occasion.proto         # PostCreatedEvent for Kafka
├── publish
│   ├── post-service
│   │   ├── messages.proto  # Particular DTOs
│   │   └── service.proto   # CreatePost methodology
│   └── posts-admin
│       ├── messages.proto
│       └── service.proto   # GetPost, UpdatePost strategies
└── content material
    └── event-service
        ├── messages.proto  # Empty DTO
        └── service.proto   # Empty service

Esempio: usando un condiviso Put up oggetto.

// post-service/service.proto
syntax = "proto3";
package deal publish;
import "widespread/message.proto";

service PostService {
  rpc CreatePost (widespread.Put up) returns (CreatePostResponse);
}

message CreatePostResponse {
  string id = 1;
}

E livello di servizio:

// posts-admin/service.proto
syntax = "proto3";
package deal admin;
import "widespread/message.proto";

service PostsAdminService {
  rpc GetPost (GetPostRequest) returns (widespread.Put up);
  rpc UpdatePost (widespread.Put up) returns (UpdatePostResponse);
}

message GetPostRequest {
  string id = 1;
}
message UpdatePostResponse {
  bool success = 1;
}

Problemi risolti

• Tutta la comunicazione passa attraverso GRPC.
• Tutti i contratti sono definiti in .proto file all’interno api/.
• I tipi riutilizzabili (DTOS, eventi) sono mantenuti api/widespread/.
• Gli oggetti duplicati non esistono

Se lo colleghi a una pipeline CI/CD condivisa – Congratulazioni, hai la piena automazione!

Conclusione

Lasciami dire questo con sicurezza:

GRPC + protobuf + codegen = leggibile, scalabile e rapido.

Takeaway chiave

• I documenti vengono letti-perché sono generati automaticamente da una singola fonte aggiornata.
• La comunicazione è standardizzata, perché GRPC applica contratti rigorosi.
• La duplicazione del codice è ridotta al minimo, grazie a tipi condivisi e definizioni di eventi.

Non aver paura di standardizzare e ottimizzare le specifiche.

Spero che questo articolo ti abbia aiutato a vedere come protoc e GRPC può risolvere problemi del mondo reale con documentazione e integrazione.

Buona fortuna là fuori!