El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este tema, exploraremos dos protocolos de comunicación populares en el desarrollo de microservicios: gRPC y GraphQL. Ambos ofrecen ventajas significativas sobre los enfoques tradicionales como REST, especialmente en términos de eficiencia y flexibilidad.

gRPC

¿Qué es gRPC?

gRPC (gRPC Remote Procedure Call) es un marco de comunicación de código abierto desarrollado por Google. Utiliza HTTP/2 para el transporte, Protocol Buffers (protobuf) como lenguaje de serialización y ofrece características como autenticación, balanceo de carga y más.

Características Clave de gRPC

Alto Rendimiento: gRPC utiliza HTTP/2, lo que permite multiplexación de solicitudes y respuestas, compresión de encabezados y más.
Contract-First: Utiliza Protocol Buffers para definir la interfaz de servicio, lo que asegura que tanto el cliente como el servidor sigan el mismo contrato.
Soporte Multilenguaje: gRPC tiene soporte para múltiples lenguajes de programación, lo que facilita la interoperabilidad entre servicios escritos en diferentes lenguajes.
Streaming: Soporta streaming bidireccional, lo que permite enviar y recibir múltiples mensajes en una sola conexión.

Ejemplo de gRPC

Definición del Servicio

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Implementación del Servidor (Python)

from concurrent import futures
import grpc
import greeter_pb2
import greeter_pb2_grpc

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

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    greeter_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

Implementación del Cliente (Python)

import grpc
import greeter_pb2
import greeter_pb2_grpc

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

if __name__ == '__main__':
    run()

Ventajas y Desventajas de gRPC

Ventajas	Desventajas
Alto rendimiento y eficiencia	Curva de aprendizaje más pronunciada
Soporte para múltiples lenguajes	Menos flexible en términos de evolución de APIs
Streaming bidireccional	Requiere más configuración inicial
Contract-First con Protocol Buffers	Menos adecuado para servicios públicos o abiertos

GraphQL

¿Qué es GraphQL?

GraphQL es un lenguaje de consulta para APIs y un entorno de ejecución para realizar esas consultas con los datos existentes. Fue desarrollado por Facebook y permite a los clientes solicitar exactamente los datos que necesitan, lo que reduce el over-fetching y el under-fetching.

Características Clave de GraphQL

Consulta Flexible: Los clientes pueden especificar exactamente qué datos necesitan.
Tipado Fuerte: Utiliza un esquema fuertemente tipado para definir las capacidades de la API.
Evolución de APIs: Facilita la evolución de APIs sin romper las consultas existentes.
Single Endpoint: Todas las consultas se realizan a través de un único endpoint.

Ejemplo de GraphQL

Definición del Esquema

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

Implementación del Servidor (Node.js con 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}`);
});

Ejemplo de Consulta

query {
  hello(name: "Alice")
}

Ventajas y Desventajas de GraphQL

Ventajas	Desventajas
Flexibilidad en las consultas	Puede ser más complejo de implementar y optimizar
Reducción de over-fetching y under-fetching	Requiere un esquema bien definido y mantenido
Evolución de APIs sin romper clientes existentes	Puede ser menos eficiente para operaciones simples
Single endpoint simplifica la gestión de rutas	Problemas potenciales de seguridad y control de acceso

Ejercicio Práctico

Ejercicio 1: Implementar un Servicio gRPC

Define un servicio gRPC que permita a los clientes obtener información sobre un libro dado su ID.
Implementa el servidor en Python.
Implementa un cliente en Python que consulte el servicio para obtener información sobre un libro específico.

Ejercicio 2: Implementar un Servicio GraphQL

Define un esquema GraphQL que permita a los clientes consultar información sobre libros y autores.
Implementa el servidor en Node.js utilizando Apollo Server.
Realiza una consulta que obtenga información sobre un libro específico y su autor.

Soluciones

Solución Ejercicio 1

Definición del Servicio

syntax = "proto3";

service BookService {
  rpc GetBook (BookRequest) returns (BookResponse);
}

message BookRequest {
  string book_id = 1;
}

message BookResponse {
  string title = 1;
  string author = 2;
}

Implementación del Servidor (Python)

from concurrent import futures
import grpc
import book_pb2
import book_pb2_grpc

class BookService(book_pb2_grpc.BookServiceServicer):
    def GetBook(self, request, context):
        # Simulación de una base de datos
        books = {
            "1": {"title": "1984", "author": "George Orwell"},
            "2": {"title": "To Kill a Mockingbird", "author": "Harper Lee"}
        }
        book = books.get(request.book_id, {"title": "Unknown", "author": "Unknown"})
        return book_pb2.BookResponse(title=book["title"], author=book["author"])

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    book_pb2_grpc.add_BookServiceServicer_to_server(BookService(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

Implementación del Cliente (Python)

import grpc
import book_pb2
import book_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = book_pb2_grpc.BookServiceStub(channel)
        response = stub.GetBook(book_pb2.BookRequest(book_id='1'))
    print("Book title: " + response.title)
    print("Book author: " + response.author)

if __name__ == '__main__':
    run()

Solución Ejercicio 2

Definición del Esquema

type Book {
  id: ID!
  title: String
  author: Author
}

type Author {
  id: ID!
  name: String
}

type Query {
  book(id: ID!): Book
  author(id: ID!): Author
}

Implementación del Servidor (Node.js con Apollo Server)

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

const typeDefs = gql`
  type Book {
    id: ID!
    title: String
    author: Author
  }

  type Author {
    id: ID!
    name: String
  }

  type Query {
    book(id: ID!): Book
    author(id: ID!): Author
  }
`;

const books = [
  { id: '1', title: '1984', authorId: '1' },
  { id: '2', title: 'To Kill a Mockingbird', authorId: '2' }
];

const authors = [
  { id: '1', name: 'George Orwell' },
  { id: '2', name: 'Harper Lee' }
];

const resolvers = {
  Query: {
    book: (_, { id }) => books.find(book => book.id === id),
    author: (_, { id }) => authors.find(author => author.id === id),
  },
  Book: {
    author: (book) => authors.find(author => author.id === book.authorId),
  }
};

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

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

Ejemplo de Consulta

query {
  book(id: "1") {
    title
    author {
      name
    }
  }
}

Conclusión

En esta sección, hemos explorado dos protocolos de comunicación avanzados para microservicios: gRPC y GraphQL. Ambos ofrecen ventajas significativas en términos de eficiencia y flexibilidad, aunque también tienen sus propias desventajas y casos de uso específicos. A través de ejemplos prácticos y ejercicios, hemos aprendido cómo implementar y utilizar estos protocolos en aplicaciones reales. En el próximo módulo, profundizaremos en la implementación de microservicios, incluyendo la elección de tecnologías y herramientas adecuadas.

Protocolos de Comunicación: gRPC, GraphQL