El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

En aquest tema, explorarem dos protocols de comunicació populars en l'arquitectura de microserveis: gRPC i GraphQL. Aquests protocols ofereixen diferents avantatges i característiques que poden ser útils segons les necessitats específiques de la teva aplicació.

Introducció a gRPC

1.1. Què és gRPC?

gRPC (Google Remote Procedure Call) és un framework de comunicació de codi obert desenvolupat per Google. Utilitza HTTP/2 per al transport, Protocol Buffers (protobuf) per a la serialització de dades i proporciona suport per a múltiples llenguatges de programació.

1.2. Característiques de gRPC

Alt Rendiment: Utilitza HTTP/2, que permet la multiplexació de múltiples trucades en una sola connexió TCP.
Contracte Fort: Utilitza Protocol Buffers per definir l'API, assegurant que tant el client com el servidor tinguin un contracte clar.
Suport Multillenguatge: Compatible amb diversos llenguatges de programació com Java, C++, Python, Go, entre d'altres.
Streaming: Suporta streaming bidireccional, permetent la transmissió contínua de dades entre client i servidor.

1.3. Exemple de gRPC

Definició del servei amb Protocol Buffers

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Implementació del servidor en Python

import grpc
from concurrent import futures
import time
import hello_pb2
import hello_pb2_grpc

class Greeter(hello_pb2_grpc.GreeterServicer):
    def SayHello(self, request, context):
        return hello_pb2.HelloReply(message='Hello, %s!' % request.name)

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    hello_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    try:
        while True:
            time.sleep(86400)
    except KeyboardInterrupt:
        server.stop(0)

if __name__ == '__main__':
    serve()

Implementació del client en Python

import grpc
import hello_pb2
import hello_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = hello_pb2_grpc.GreeterStub(channel)
        response = stub.SayHello(hello_pb2.HelloRequest(name='World'))
    print("Greeter client received: " + response.message)

if __name__ == '__main__':
    run()

Introducció a GraphQL

2.1. Què és GraphQL?

GraphQL és un llenguatge de consulta per a APIs i un entorn d'execució per a les teves consultes, desenvolupat per Facebook. Permet als clients sol·licitar exactament les dades que necessiten, i res més.

2.2. Característiques de GraphQL

Flexibilitat en les Consultes: Els clients poden especificar exactament quines dades necessiten.
Tipat Fort: Utilitza un esquema fortament tipat per definir les dades disponibles.
Una Sola Endpoint: Totes les operacions es realitzen a través d'una sola endpoint.
Evolució de l'API: Permet afegir nous camps i tipus a l'API sense afectar les consultes existents.

2.3. Exemple de GraphQL

Definició de l'esquema

type Query {
  hello(name: String): String
}

Implementació del servidor en Node.js amb Apollo Server

const { ApolloServer, gql } = require('apollo-server');

const typeDefs = gql`
  type Query {
    hello(name: String): String
  }
`;

const resolvers = {
  Query: {
    hello: (_, { name }) => `Hello, ${name || 'World'}!`,
  },
};

const server = new ApolloServer({ typeDefs, resolvers });

server.listen().then(({ url }) => {
  console.log(`🚀 Server ready at ${url}`);
});

Consulta des del client

query {
  hello(name: "Alice")
}

Comparació entre gRPC i GraphQL

Característica	gRPC	GraphQL
Transport	HTTP/2	HTTP
Serialització	Protocol Buffers	JSON
Tipat	Fort (Protocol Buffers)	Fort (Esquema GraphQL)
Flexibilitat	Contracte rígid	Consultes flexibles
Streaming	Sí (bidireccional)	No
Suport Multillenguatge	Sí	Sí
Evolució de l'API	Difícil (requereix actualització del contracte)	Fàcil (afegir nous camps sense trencar)

Exercici Pràctic

4.1. Exercici amb gRPC

Defineix un nou servei gRPC que permeti obtenir informació d'un usuari per ID.
Implementa el servidor i el client en el llenguatge de la teva elecció.
Prova la comunicació entre el client i el servidor.

4.2. Exercici amb GraphQL

Defineix un esquema GraphQL que permeti obtenir informació d'un usuari per ID.
Implementa el servidor amb Apollo Server.
Realitza una consulta des del client per obtenir la informació de l'usuari.

Solucions

Solució gRPC

Definició del servei:

syntax = "proto3";

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse) {}
}

message UserRequest {
  int32 id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

Implementació del servidor i client (similar a l'exemple anterior).

Solució GraphQL

Definició de l'esquema:

type Query {
  user(id: Int!): User
}

type User {
  id: Int
  name: String
  email: String
}

Implementació del servidor:

const { ApolloServer, gql } = require('apollo-server');

const typeDefs = gql`
  type Query {
    user(id: Int!): User
  }

  type User {
    id: Int
    name: String
    email: String
  }
`;

const resolvers = {
  Query: {
    user: (_, { id }) => ({ id, name: `User ${id}`, email: `user${id}@example.com` }),
  },
};

const server = new ApolloServer({ typeDefs, resolvers });

server.listen().then(({ url }) => {
  console.log(`🚀 Server ready at ${url}`);
});

Consulta des del client:

query {
  user(id: 1) {
    id
    name
    email
  }
}

Conclusió

En aquesta secció, hem explorat dos protocols de comunicació populars en l'arquitectura de microserveis: gRPC i GraphQL. Hem vist les seves característiques, avantatges i desavantatges, i hem proporcionat exemples pràctics per a cada un. Amb aquesta informació, hauràs de ser capaç de decidir quin protocol s'adapta millor a les necessitats de la teva aplicació i implementar-lo de manera efectiva.

Protocols de Comunicació: gRPC, GraphQL