Lección 287: Cómo GraphQL simplifica la interacción con microservicios

Imagina una gran oficina con decenas de departamentos. Cada departamento se encarga solo de su parte del trabajo, y los clientes tienen que correr entre departamentos para reunir toda la información necesaria. Esa oficina es tu proyecto de microservicios, y los clientes son la aplicación frontend. Correr entre departamentos son tus peticiones HTTP al REST API. Horrible, ¿no? Aquí entra GraphQL, que actúa como un único mostrador de información: pides todo por una ventanilla.

Punto de entrada único

GraphQL te permite crear una fachada única para todos los microservicios. Todo el tráfico pasa por el servidor GraphQL, que agrega datos de cada servicio. Por ejemplo:

• Servicio de usuarios (User Service) almacena la información de los usuarios.
• Servicio de pedidos (Order Service) se encarga de los pedidos de los usuarios.
• Servicio de reseñas (Review Service) gestiona las reseñas de productos.

En vez de que el cliente pida datos a tres endpoints REST separados, hace una sola petición a GraphQL. El servidor GraphQL se encarga de saber a dónde acudir.

Ejemplo de arquitectura con GraphQL

+---------------+       +---------------------+
|    CLIENT     | -->   |     GraphQL API     |
+---------------+       +---------+-----------+
                                |
       +------------------------+------------------------+
       |                        |                        |
+---------------+      +---------------------+    +-----------------+
| User Service  |      |    Order Service    |    |  Review Service |
+---------------+      +---------------------+    +-----------------+

¿Por qué es cómodo? Porque al cliente no le importa dónde ni cómo están almacenados los datos. Solo tiene que saber que el GraphQL API le proporcionará toda la información necesaria.

Agrupación de datos desde varios microservicios

Problema de REST

Supongamos que necesitas mostrar en la página de perfil del usuario:

1. El nombre del usuario.
2. La lista de sus pedidos.
3. Reseñas sobre esos pedidos.

Con REST todo se ve así:

1. Se envía una petición al User Service para obtener el nombre del usuario.
2. En base al ID del usuario se envía una segunda petición al Order Service para obtener los pedidos.
3. Para cada pedido se envían peticiones al Review Service para obtener las reseñas.

Son decenas de peticiones que toman mucho tiempo y saturan la red. Es como ir a tres tiendas para preparar una sola cena.

Cómo GraphQL resuelve este problema

GraphQL permite combinar toda esa información en una sola consulta. Creas un esquema que describe las dependencias entre los datos, y el servidor GraphQL ejecuta la lógica compleja por ti. Aquí un ejemplo:

query GetUserProfile($userId: ID!) {
  user(id: $userId) {
    name
    orders {
      id
      items
      reviews {
        rating
        comment
      }
    }
  }
}

En respuesta obtendrás un único JSON con los datos necesarios:

{
  "data": {
    "user": {
      "name": "Iván Ivanov",
      "orders": [
        {
          "id": "123",
          "items": ["item1", "item2"],
          "reviews": [
            {
              "rating": 5,
              "comment": "¡Excelente!"
            }
          ]
        }
      ]
    }
  }
}

Al cliente no le importa de dónde vienen esos datos —el servidor GraphQL ya lo hizo todo por él.

Mejora de la experiencia del cliente

Problema de Over-fetching y Under-fetching

En un REST API o bien obtienes demasiados datos (over-fetching), o bien muy pocos (under-fetching). Por ejemplo:

• Pides una lista de usuarios, pero el REST devuelve no solo nombres sino direcciones, fechas de nacimiento y otros datos innecesarios.
• Pides un usuario concreto, pero el REST API no proporciona el campo orders, y tienes que hacer una petición adicional.

GraphQL permite a los clientes pedir exactamente lo que necesitan. Si solo necesitas la lista de nombres, puedes pedir solo el campo name:

query {
  users {
    name
  }
}

La respuesta será simple y limpia:

{
  "data": {
    "users": [
      { "name": "Iván" },
      { "name": "María" },
      { "name": "Pedro" }
    ]
  }
}

Ventajas para el frontend

1. Menos peticiones, menos latencia
   Ahora el cliente hace solo una petición en vez de tres o cuatro, ahorrando recursos de red.
2. Flexibilidad en la UI
   Si el diseño de la página cambia y hay que añadir o quitar datos, se soluciona cambiando la consulta GraphQL sin modificar el código del servidor.
3. Reactividad
   Con Subscriptions GraphQL permite a los clientes recibir actualizaciones en tiempo real. Esto es especialmente útil para notificaciones, sistemas de mensajería y interfaces dinámicas.

Práctica: configurar microservicios con GraphQL

Paso 1. Creamos el esquema

Crea el archivo schema.graphqls en tu servidor GraphQL. Por ejemplo:

type User {
  id: ID
  name: String
  orders: [Order]
}

type Order {
  id: ID
  items: [String]
  reviews: [Review]
}

type Review {
  rating: Int
  comment: String
}

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

Paso 2. Configuramos los resolvers

En el servidor GraphQL (con Spring Boot) configura los resolvers. Por ejemplo:

@Component
public class UserResolver implements GraphQLQueryResolver {
    private final UserService userService;

    public UserResolver(UserService userService) {
        this.userService = userService;
    }

    public User getUser(Long id) {
        return userService.getUserById(id);
    }
}

Ahora, cada vez que pidas el campo user, se llamará al método getUser.

Paso 3. Agregación de datos

Si los datos para los campos orders y reviews están en distintos microservicios, configura Data Fetchers:

@Component
public class OrderDataFetcher implements DataFetcher<List<Order>> {
    private final OrderService orderService;

    public OrderDataFetcher(OrderService orderService) {
        this.orderService = orderService;
    }

    @Override
    public List<Order> get(DataFetchingEnvironment env) {
        User user = env.getSource();
        return orderService.getOrdersForUser(user.getId());
    }
}

Paso 4. Testing

Usa GraphQL Playground para enviar consultas y verificar respuestas. Por ejemplo:

query {
  user(id: 1) {
    name
    orders {
      id
      items
      reviews {
        rating
        comment
      }
    }
  }
}

Ahora tienes una idea de cómo GraphQL se convierte en una fachada "todo-en-uno" para un sistema de microservicios. Simplifica la interacción, hace la API accesible y cómoda, y le da a los clientes flexibilidad para sus consultas.