Dans ce guide technique, nous allons déployer une API GraphQL avec Apollo Server sur Node.js et y intégrer un système d’authentification par JWT. L’objectif ? Offrir à vos applications web ou mobiles une interface flexible, performante et sécurisée. Cette approche s’adresse aux CTO et lead dev souhaitant structurer rapidement une API moderne, tout en maîtrisant les enjeux de sécurité et de montée en charge.

installer apollo server graphql sur node.js et sécuriser l’api avec jwt

Prérequis

Node.js ≥ 14 et npm ou yarn
Postman ou GraphQL Playground pour les tests
Un projet existant ou un dossier dédié

Étape 1 : initialiser le projet et installer les dépendances

# Créez un dossier de travail
mkdir graphql-jwt-api && cd graphql-jwt-api

# Initialisez npm
npm init -y

# Installez Apollo Server, GraphQL et JWT
npm install apollo-server graphql jsonwebtoken bcryptjs

Étape 2 : définir le schéma et les resolvers

Dans src/schema.js, on déclare types et mutations :

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

const typeDefs = gql`
  type User {
    id: ID!
    username: String!
  }

  type AuthPayload {
    token: String!
    user: User!
  }

  type Query {
    me: User
  }

  type Mutation {
    signup(username: String!, password: String!): AuthPayload
    login(username: String!, password: String!): AuthPayload
  }
`;

module.exports = typeDefs;

Puis, dans src/resolvers.js, on implémente la logique :

const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const SECRET = process.env.JWT_SECRET || 'votre_cle_secrete';

// Stockage en mémoire pour l'exemple
const users = [];

const resolvers = {
  Query: {
    me: (_, __, { user }) => user || null,
  },
  Mutation: {
    signup: async (_, { username, password }) => {
      const hashed = await bcrypt.hash(password, 10);
      const user = { id: users.length+1, username, password: hashed };
      users.push(user);
      const token = jwt.sign({ userId: user.id }, SECRET, { expiresIn: '2h' });
      return { token, user: { id: user.id, username } };
    },
    login: async (_, { username, password }) => {
      const user = users.find(u => u.username === username);
      if (!user || !await bcrypt.compare(password, user.password)) {
        throw new Error('Invalid credentials');
      }
      const token = jwt.sign({ userId: user.id }, SECRET, { expiresIn: '2h' });
      return { token, user: { id: user.id, username } };
    }
  }
};

module.exports = resolvers;

Étape 3 : configurer Apollo Server avec le contexte JWT

const { ApolloServer } = require('apollo-server');
const typeDefs = require('./schema');
const resolvers = require('./resolvers');
const jwt = require('jsonwebtoken');
const SECRET = process.env.JWT_SECRET || 'votre_cle_secrete';

const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => {
    const auth = req.headers.authorization || '';
    if (auth.startsWith('Bearer ')) {
      try {
        const payload = jwt.verify(auth.slice(7), SECRET);
        return { user: { id: payload.userId } };
      } catch (e) {
        console.warn('Token invalide', e);
      }
    }
    return {};
  }
});

server.listen({ port: 4000 }).then(({ url }) => {
  console.log(`🚀 Server démarré sur ${url}`);
});

Étape 4 : tester votre API

Lancez node src/index.js.
Dans GraphQL Playground (http://localhost:4000), exécutez la mutation signup puis login.
Copiez le token et ajoutez-le en header : Authorization: Bearer <token>.
Testez la query { me { id username } }.

bonnes pratiques et optimisation

1. Gestion des erreurs et sécurité

Limitez le taux de requêtes (rate limiting) avec apollo-server-plugin-rate-limit.
Renouvelez périodiquement JWT_SECRET et stockez-le dans un vault (Vault HashiCorp, AWS Secrets Manager).
Mettez en place des tests d’intégration avec Jest ou Mocha et Supertest.

2. Performance et monitoring

Activez la tracing Apollo pour mesurer la latence des résolvers.
Exploitez Prometheus et Grafana pour collecter métriques et alertes.
Privilégiez le caching côté client (Apollo Client) et serveur (dataloader, Redis) sur les requêtes coûteuses.

conclusion

Vous disposez désormais d’une API GraphQL sécurisée par JWT, prête pour une montée en charge maîtrisée et un cycle de développement agile. Pour aller plus loin, découvrez nos services de développement d’applications web ou contactez nos experts pour un audit personnalisé.