Nombreuses petites demandes par rapport à quelques grandes demandes (conception d'API)

Je travaille actuellement sur un projet avec une organisation comme suit:

• Client - Obtient des données du serveur principal via l'API REST.
• Serveur - Demande des données à différents serveurs via des API tierces
• API tierces - Services hors de mon contrôle qui fournissent des données au serveur (Reddit, Hackernews, Quora, etc.)

Par souci d'argumentation, supposons que le client ait d'abord besoin d'une liste d'éléments de chacune des API tierces. À partir de cette liste, un élément sera choisi, à quel moment le client doit voir le contenu complet de l'élément ainsi que les réponses (commentaires) à l'élément. J'essaie de choisir entre trois options:

À la carte

Dans cette approche, j'aurais trois terminaux différents sur mon serveur: un pour obtenir la liste des éléments, un pour obtenir le contenu principal d'un élément et un pour obtenir les réponses de l'élément.

• Avantages: je ne fais jamais plus de demandes que nécessaire, les demandes doivent être petites, donc généralement plus rapides.
• Inconvénients: je dois faire beaucoup de demandes. Après avoir choisi un élément de la liste, l'utilisateur peut devoir attendre avant de voir le contenu principal, puis attendre encore plus longtemps pour voir les réponses.

Cache côté serveur

Dans cette demande, je ferais un seul appel à mon serveur pour "récupérer" toutes les données de toutes les sources. Les données seraient alors mises en cache sur le serveur. Le client aurait alors les mêmes points de terminaison REST qu'auparavant, sauf qu'il n'y aurait pas beaucoup d'attente entre les appels puisque mon serveur dispose déjà des données et doit simplement les transmettre au client.

• Avantages: toujours facile à mettre en œuvre côté client, mais sans les problèmes de latence
• Inconvénients: Un côté serveur un peu plus impliqué et le premier appel risque de prendre beaucoup de temps.

Cache côté client

Ce scénario est similaire au précédent, sauf que le client ne fait qu'une demande au serveur: donnez-moi toutes les données. À partir de là, il incombe au client de sauvegarder les données et de les utiliser de manière appropriée.

• Avantages: mise en œuvre facile du serveur, très rapide après le premier appel
• Inconvénients: le premier appel sera très lent, une implémentation plus compliquée côté client

Je ne sais pas quelle est la meilleure approche, ou si peut-être je manque la solution évidente. Tout avis serait grandement apprécié!

Il convient de garder à l’esprit la latence réseau attendue (c’est-à-dire le temps de ping) entre vos clients et votre serveur. Dans une situation de latence élevée avec une bonne bande passante sinon, de nombreuses petites demandes exécuteront considérablement pire qu'un grand.

J'ai récemment collaboré à un projet d'application Web multi-équipes reposant sur une base de données et dont l'une des équipes est en Inde (les autres aux États-Unis). Nous avons une seule base de données hébergée dans notre bureau américain, à laquelle les développeurs connectent nos instances de serveur Web locales. Mon bureau est peut-être à une cinquantaine de mètres et deux réseaux LAN se détachent de l'instance de base de données, et les performances sont satisfaisantes.

Lorsque nous avons commencé à travailler avec les développeurs en Inde, ils attendaient énormément de temps d’attente pour démarrer l’application et naviguer de page en page. Nous parlons ici de dix minutes d'attente. Il s’avère que c’est parce que le temps de réponse de 200 ms environ entre leur bureau et notre serveur de base de données dev était multiplié par de nombreuses requêtes brèves adressées à la base de données. Mon ping local à 0,5 ms était si trivial que la causalité entre le serveur Web et le serveur de base de données n’a jamais eu d’importance. C'était la première fois que nous avions une séparation géographique entre serveur Web et serveur de base de données.

Dans notre cas, la solution consistait à cloner le serveur de base de données et à conserver la copie en Inde, mais vous devez garder à l’esprit que, si votre client et votre serveur sont très distants, la latence du réseau sera multipliée par le nombre de communications à travers le réseau. câble. La bande passante une fois que la connexion est établie est généralement beaucoup moins préoccupante.

Ces trois options ne sont pas mutuellement exclusives. Vous pouvez utiliser une combinaison des caches côté client et côté serveur. Toutefois, certaines données, telles que les commentaires, peuvent devenir obsolètes si elles sont conservées trop longtemps dans le cache. Étant donné que vous ne pouvez pas vérifier si tel est le cas, vous devriez probablement vous abstenir de le stocker du tout. D'un autre côté, le contenu ne change généralement pas radicalement. Par conséquent, il ne serait pas nuisible de le mettre en cache côté serveur, puis d'en pré-extraire une partie du côté client afin de réduire la latence.

Basé uniquement sur les informations que vous avez données, option 1, car

• avec une seule demande client, vous mélangez des pommes et des oranges et le panier de fruits peut être très volumineux.

• la mise en cache est un compromis où vous gagnez en performance mais perdez potentiellement de la cohérence (données obsolètes). Si vous ne rencontrez aucun problème de performances, les problèmes de synchronisation ne valent généralement pas la peine d'être risqués.

J'ai toujours trouvé quelques grandes requêtes plus performantes et plus évolutives. Mais il existe des compromis dans toutes les approches, cela dépend donc des besoins du serveur et du client. Vous souhaiterez peut-être utiliser une autre option, à savoir que le client spécifie une plage entière ou un ensemble de données à extraire - pas nécessairement toutes les données, mais une plage qui est ajustée dans le temps pour correspondre à la bande passante disponible.

Je voudrais (presque) escompte l'option 3. Choisir entre 1 et 2 dépend de deux choses:

• (A) quelle est la taille du résultat d'une seule extraction totale
• (B) quelle quantité de détail du résultat le client / utilisateur utilisera généralement dans cette session.

Il est facile de prendre une décision si A et B sont des extrêmes:

• Si A est grand et B est petit, optez pour l'option 1 (à la carte).
• Si A est petit et B est grand, choisissez 2 (cache côté serveur) ou même 3 (cache côté client).

Pour toute autre variante A / B (grande / petite), vous devrez faire preuve de discrétion. Je donne souvent les deux points de terminaison grossiers et fins pour répondre à différents cas d'utilisation de différents clients.

Comme toujours dans la programmation, cela dépend.

La vraie question est donc la suivante: que devriez-vous prendre en compte lorsque vous décidez de choisir A / B / C ou une combinaison des trois?

Je dirais que les véritables facteurs discriminants sont les détails de mise en œuvre des API tierces que vous consommez. A titre d'exemple, vous devriez considérer: sont-ils rapides ou lents? Les données changent-elles fréquemment et de manière inattendue? Sont-ils "bavards" ou de repos?

Dans le cas de services rapides et faciles à appeler, avec des données qui changent si souvent que votre cache côté serveur créera des problèmes de cache obsolète, optez pour l'option 1: davantage de demandes, pas de cache, uniquement en cas de besoin.

Si vos données externes vont changer de manière prévisible, ou si leur utilisation est limitée, ou si vous pouvez simplement obtenir une meilleure expérience utilisateur pour mettre les données en cache sur votre serveur, optez pour 2. Cependant, gardez à l'esprit que le cache n'est pas gratuit: cela a des coûts en termes de débogage et parfois les utilisateurs se plaignent de ne pas voir les mises à jour.

L'option 3, je ne considérerais que si les données ne représentent pas beaucoup, mais dans ce cas, même les options 1 ou 2 peuvent fonctionner, et vous gardez plus de logique sur le serveur, donc je m'en tiens à 1 ou 2.

Juste mon 2c.