El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

GraphQL en microserveis

Següent ►
►

En aquest tema, explorarem com integrar GraphQL en una arquitectura de microserveis. Els microserveis són una manera de dissenyar aplicacions com una col·lecció de serveis petits i independents que es comuniquen entre ells. GraphQL pot ser una eina poderosa per unificar aquestes comunicacions i proporcionar una interfície coherent per als clients.

Objectius d'aprenentatge

  • Comprendre els avantatges d'utilitzar GraphQL en una arquitectura de microserveis.
  • Aprendre a dissenyar esquemes de GraphQL per a microserveis.
  • Implementar un servidor GraphQL que agregui dades de diversos microserveis.
  • Gestionar la comunicació i la seguretat entre microserveis amb GraphQL.

Avantatges de GraphQL en microserveis

  • Unificació de dades: GraphQL permet als clients obtenir dades de múltiples microserveis amb una sola consulta.
  • Flexibilitat: Els clients poden sol·licitar exactament les dades que necessiten, reduint la sobrecàrrega de dades.
  • Evolució de l'API: Les APIs de GraphQL poden evolucionar sense trencar les aplicacions clients, ja que les noves funcionalitats es poden afegir sense afectar les existents.

Disseny d'esquemes de GraphQL per a microserveis

Quan dissenyem esquemes de GraphQL per a microserveis, és important tenir en compte com es distribuiran les dades i com es gestionaran les dependències entre serveis.

Exemples de disseny d'esquemes

Suposem que tenim una aplicació de comerç electrònic amb els següents microserveis:

  • Servei d'Usuaris: Gestiona la informació dels usuaris.
  • Servei de Productes: Gestiona la informació dels productes.
  • Servei de Comandes: Gestiona les comandes dels usuaris.

Podem dissenyar un esquema de GraphQL que agregui dades d'aquests serveis:

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

type Product {
  id: ID!
  name: String!
  price: Float!
}

type Order {
  id: ID!
  user: User!
  products: [Product]!
  total: Float!
}

type Query {
  user(id: ID!): User
  product(id: ID!): Product
  order(id: ID!): Order
}

Implementació de resolvers

Els resolvers són responsables de recuperar les dades dels microserveis corresponents. A continuació, es mostra un exemple de resolvers per a l'esquema anterior:

const resolvers = {
  Query: {
    user: async (_, { id }) => {
      // Crida al Servei d'Usuaris
      return fetchUserById(id);
    },
    product: async (_, { id }) => {
      // Crida al Servei de Productes
      return fetchProductById(id);
    },
    order: async (_, { id }) => {
      // Crida al Servei de Comandes
      return fetchOrderById(id);
    },
  },
  User: {
    orders: async (user) => {
      // Crida al Servei de Comandes per obtenir les comandes de l'usuari
      return fetchOrdersByUserId(user.id);
    },
  },
  Order: {
    user: async (order) => {
      // Crida al Servei d'Usuaris per obtenir la informació de l'usuari
      return fetchUserById(order.userId);
    },
    products: async (order) => {
      // Crida al Servei de Productes per obtenir la informació dels productes
      return fetchProductsByIds(order.productIds);
    },
  },
};

Comunicació entre microserveis

La comunicació entre microserveis pot ser gestionada mitjançant crides HTTP, RPC (Remote Procedure Call) o altres protocols de comunicació. És important assegurar-se que aquestes comunicacions siguin segures i eficients.

Exemple de crida HTTP

const fetchUserById = async (id) => {
  const response = await fetch(`http://user-service/users/${id}`);
  return response.json();
};

const fetchProductById = async (id) => {
  const response = await fetch(`http://product-service/products/${id}`);
  return response.json();
};

const fetchOrderById = async (id) => {
  const response = await fetch(`http://order-service/orders/${id}`);
  return response.json();
};

Seguretat en GraphQL per a microserveis

La seguretat és un aspecte crític en qualsevol arquitectura de microserveis. Algunes pràctiques recomanades inclouen:

  • Autenticació i autorització: Assegurar-se que només els usuaris autoritzats puguin accedir a les dades.
  • Limitació de velocitat: Prevenir abusos limitant el nombre de consultes que un client pot fer en un període de temps determinat.
  • Validació de dades: Assegurar-se que les dades enviades i rebudes compleixin amb els requisits esperats.

Exemple d'autenticació

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

const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => {
    // Obtenir el token d'autenticació de les capçaleres de la sol·licitud
    const token = req.headers.authorization || '';

    // Validar el token i obtenir la informació de l'usuari
    const user = validateToken(token);

    // Afegir l'usuari al context
    return { user };
  },
});

Exercici pràctic

Exercici

Implementa un servidor GraphQL que agregui dades de dos microserveis: un servei d'usuaris i un servei de productes. El servidor ha de permetre obtenir la informació d'un usuari i els productes que ha comprat.

Solució

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

const typeDefs = gql`
  type User {
    id: ID!
    name: String!
    email: String!
    products: [Product]
  }

  type Product {
    id: ID!
    name: String!
    price: Float!
  }

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

const resolvers = {
  Query: {
    user: async (_, { id }) => {
      const response = await fetch(`http://user-service/users/${id}`);
      return response.json();
    },
  },
  User: {
    products: async (user) => {
      const response = await fetch(`http://product-service/products?userId=${user.id}`);
      return response.json();
    },
  },
};

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

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

Conclusió

Integrar GraphQL en una arquitectura de microserveis pot proporcionar una interfície unificada i flexible per als clients, permetent una millor gestió de les dades i una evolució més fàcil de l'API. En aquest tema, hem après a dissenyar esquemes de GraphQL per a microserveis, implementar resolvers per agregar dades de diversos serveis i gestionar la comunicació i la seguretat entre microserveis. Amb aquests coneixements, estàs preparat per aplicar GraphQL en una arquitectura de microserveis en projectes del món real.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats