Лекція 299: Оптимізація запитів у GraphQL

GraphQL — це потужний інструмент, який дозволяє клієнтам запитувати тільки потрібні дані. Однак із збільшенням складності запитів і розростанням схеми, GraphQL може почати сильно навантажувати сервер і бази даних. Розберемо, як проблеми продуктивності можуть проявлятися в GraphQL:

• Проблема N+1: один із найпоширеніших сценаріїв, коли запит до поля призводить до множинних схожих запитів у базу даних. Наприклад, якщо ви запитуєте користувачів і їхні пости, можна виконати запит для отримання всіх користувачів, а потім для кожного користувача виконати окремий запит для отримання постів — це і є проблема N+1.
• Глибокі запити: клієнти можуть вимагати дані з надмірною глибиною і вкладеністю, що може призвести до перевантаження сервера.
• Відсутність кешування: якщо не оптимізувати запити й не використовувати кешування, це негативно вплине на ресурси як сервера, так і бази даних.
• Дублювання даних: один і той самий запит може виконуватися кілька разів, якщо не обробляти дані батчами.

Всі ці проблеми важливо вирішувати, щоб створити відзивчивий і масштабований GraphQL API.

Інструменти для аналізу й оптимізації запитів

Щоб зрозуміти, як запити впливають на продуктивність, можна використовувати такі інструменти та методи аналізу:

1. Профілювання запитів:

• Увімкніть логування запитів у базу даних, щоб бачити, скільки часу займає кожен SQL-запит.
• Використовуйте бібліотеки, такі як Spring Actuator, щоб відстежувати метрики вашого застосунку.

2. Інструменти GraphQL для аналізу запитів:

• GraphQL Engine (наприклад, Apollo Engine) — допомагає профілювати і аналізувати виконання ваших GraphQL-запитів.
• Інструменти трасування, такі як Sentry або OpenTelemetry, для розподіленого моніторингу.

3. DataLoader:

• DataLoader — це бібліотека, яка використовується для батчування і дедуплікації запитів.
• Вона рятує від проблеми N+1 у GraphQL. Детальніше про це ми обговорювали в попередній лекції.

4. Ліміти та обмеження:

• Обмежуйте глибину запитів і їхню складність, щоб уникнути зловживання вашим API.
• Використовуйте бібліотеки, такі як graphql-depth-limit, для обмеження глибини запитів.

Методи оптимізації запитів

Переходимо до практичних рекомендацій з оптимізації запитів у GraphQL.

Використання DataLoader для батчування

DataLoader допомагає об’єднати кілька запитів до бази даних в один. Розглянемо приклад, де ви запитуєте користувачів і їхні пости:

query {
  users {
    id
    name
    posts {
      id
      title
    }
  }
}

Без DataLoader це призведе до наступного:

1. Один запит для отримання всіх користувачів.
2. N запитів для отримання постів кожного користувача.

З DataLoader ви можете батчувати запити до постів, об’єднавши їх в один запит.

Приклад реалізації DataLoader:

@Bean
public DataLoaderRegistry dataLoaderRegistry(PostService postService) {
    DataLoaderRegistry registry = new DataLoaderRegistry();

    DataLoader<Long, List<Post>> postDataLoader = DataLoader.newMappedDataLoader(userIds ->
        CompletableFuture.supplyAsync(() -> postService.getPostsByUserIds(userIds))
    );

    registry.register("postLoader", postDataLoader);
    return registry;
}

@DataFetcher
public DataFetcher<List<Post>> postsFetcher(DataLoaderRegistry dataLoaderRegistry) {
    return environment -> {
        DataLoader<Long, List<Post>> dataLoader = dataLoaderRegistry.getDataLoader("postLoader");
        Long userId = environment.getSource();
        return dataLoader.load(userId); // Асинхронно завантажуємо дані
    };
}

Коли ви запитуєте користувачів і їхні пости, запити до бази даних будуть об’єднані.

2. Обмеження глибини та складності запитів

Щоб уникнути надмірного навантаження на сервер, обмежте глибину запитів і їхню складність. Наприклад:

query {
  user {
    posts {
      comments {
        author {
          friends {
            posts { ... }
          }
        }
      }
    }
  }
}

Такий запит може бути вкрай дорогим в виконанні.

Приклад обмеження глибини в Spring GraphQL:

Використовуємо бібліотеку, наприклад graphql-depth-limit:

GraphQL graphQL = GraphQL.newGraphQL(schema)
        .instrumentation(new MaxQueryDepthInstrumentation(10)) // Максимальна глибина 10
        .build();

3. Кешування запитів

Кешування — ваш друг у високонавантажених застосунках. Кешувати можна на кількох рівнях:

• Кешування GraphQL-запитів: зберігайте результати виконання запитів на рівні сервера.
• Кешування в базі даних: використовуйте другий рівень кешу (наприклад, у Hibernate) для зменшення навантаження на базу.
• Клієнтське кешування: використовуйте інструменти, такі як Apollo Client, для кешування на стороні клієнта.

Приклад використання Redis для кешування GraphQL даних:

@Service
public class UserService {

    @Autowired
    private RedisTemplate<String, User> redisTemplate;

    public User getUserById(Long id) {
        User cachedUser = redisTemplate.opsForValue().get("user:" + id);
        if (cachedUser != null) {
            return cachedUser;
        }
        User user = userRepository.findById(id).orElseThrow(); // Отримуємо з бази
        redisTemplate.opsForValue().set("user:" + id, user, 10, TimeUnit.MINUTES); // Кешуємо
        return user;
    }
}

4. Оптимізація схеми

Переконайтеся, що ваша GraphQL-схема продумана й мінімалістична. Видаляйте зайві поля, групуйте пов’язані дані й уточнюйте параметри запитів.

Приклад оновленої схеми:

Замість:

type User {
  id: ID!
  name: String!
  posts: [Post]!
  comments: [Comment]!
}

Розгляньте варіант:

type User {
  id: ID!
  name: String!
  recentActivity: RecentActivity!
}

type RecentActivity {
  posts: [Post]!
  comments: [Comment]!
}

Це допоможе клієнтам запитувати тільки потрібні дані і покращить читабельність схеми.

Практика: Оптимізація запитів у GraphQL API

Ви отримали запит від клієнта, який часто використовують у вашому застосунку:

query {
  users {
    id
    name
    posts {
      id
      title
    }
  }
}

Цей запит викликає 1 запит для користувачів і N запитів для кожного користувача для отримання постів. Ваше завдання:

1. Використати DataLoader для усунення проблеми N+1.
2. Додати обмеження на глибину запитів.
3. Закешувати відповіді для підвищення продуктивності.

Реалізація

1. Налаштуйте DataLoader, як описано раніше.
2. Додайте обмеження глибини запитів.
3. Закешуйте запити, використовуючи Redis:

@Bean
public CachingDataFetcher postCachingDataFetcher(PostService postService) {
    return new CachingDataFetcher(environment -> {
        Long userId = environment.getSource();
        return cacheManager.get("user_posts", userId.toString(), 
            () -> postService.getPostsByUserId(userId)
        );
    });
}

Висновок

Тепер ви знаєте, які проблеми можуть виникати з продуктивністю в GraphQL і як їх вирішувати. Ви вивчили DataLoader для батчування запитів, обмеження глибини, кешування даних і оптимізацію схеми. Ці підходи допоможуть вам побудувати більш ефективний, стабільний і масштабований GraphQL API, який тішитиме як клієнтів, так і вас (і вашу базу даних).