Configuration de la mise en cache côté serveur et de la compression de la charge utile des API dans AWS AppSync

AWS AppSync les fonctionnalités de mise en cache des données côté serveur rendent les données disponibles dans un cache en mémoire à haut débit, améliorant ainsi les performances et réduisant la latence. Cela réduit le besoin d'accéder directement aux sources de données. La mise en cache est disponible pour les résolveurs d'unités et de pipelines.

AWS AppSync vous permet également de compresser les réponses des API afin que le contenu de la charge utile se charge et se télécharge plus rapidement. Cela réduit potentiellement la charge qui pèse sur vos applications tout en réduisant potentiellement vos frais de transfert de données. Le comportement de compression est configurable et peut être défini à votre guise.

Reportez-vous à cette section pour obtenir de l'aide pour définir le comportement souhaité de la mise en cache et de la compression côté serveur dans votre API. AWS AppSync

Types d’instances

AWS AppSync héberge des instances Amazon ElastiCache (Redis OSS) dans le même AWS compte et dans la même AWS région que votre AWS AppSync API.

Les types d'instances ElastiCache (Redis OSS) suivants sont disponibles :

Comportement de mise en cache

Les comportements liés à la mise en cache sont les suivants :

Chiffrement du cache

Le chiffrement du cache est disponible sous les deux formes suivantes. Ils sont similaires aux paramètres autorisés par ElastiCache (Redis OSS). Vous ne pouvez activer les paramètres de chiffrement que lors de la première activation de la mise en cache pour votre AWS AppSync API.

Pour invalider les entrées du cache, vous pouvez effectuer un appel d'API Flush Cache à l'aide de la AWS AppSync console ou du AWS Command Line Interface ()AWS CLI.

Pour plus d'informations, consultez le type de ApiCachedonnées dans la référence de l' AWS AppSync API.

Expulsion du cache

Lorsque vous configurez AWS AppSync la mise en cache côté serveur, vous pouvez configurer un TTL maximal. Cette valeur définit la durée pendant laquelle les entrées mises en cache sont stockées en mémoire. Dans les situations où vous devez supprimer des entrées spécifiques de votre cache, vous pouvez utiliser l'utilitaire AWS AppSync d'evictFromApiCacheextensions dans la demande ou la réponse de votre résolveur. (Par exemple, lorsque les données de vos sources de données ont changé et que votre entrée de cache est désormais obsolète.) Pour expulser un élément du cache, vous devez connaître sa clé. C'est pourquoi, si vous devez expulser des éléments de manière dynamique, nous vous recommandons d'utiliser la mise en cache par résolveur et de définir explicitement une clé à utiliser pour ajouter des entrées à votre cache.

Expulsion d'une entrée de cache

Pour expulser un élément du cache, utilisez l'utilitaire d'evictFromApiCacheextensions. Spécifiez le nom du type et le nom du champ, puis fournissez un objet contenant des éléments clé-valeur pour créer la clé de l'entrée que vous souhaitez expulser. Dans l'objet, chaque clé représente une entrée valide provenant de l'contextobjet utilisé dans la liste du résolveur mis en cache. cachingKey Chaque valeur est la valeur réelle utilisée pour construire la valeur de la clé. Vous devez placer les éléments de l'objet dans le même ordre que les clés de mise en cache dans la liste du résolveur mis en cache. cachingKey

Par exemple, consultez le schéma suivant :

type Note {
  id: ID!
  title: String
  content: String!
}

type Query {
  getNote(id: ID!): Note
}

type Mutation {
  updateNote(id: ID!, content: String!): Note
}

Dans cet exemple, vous pouvez activer la mise en cache par résolveur, puis l'activer pour la requête. getNote Ensuite, vous pouvez configurer la clé de mise en cache pour qu'elle soit composée de[context.arguments.id].

Lorsque vous essayez d'obtenir uneNote, pour créer la clé de cache, AWS AppSync effectue une recherche dans son cache côté serveur à l'aide de l'idargument de la getNote requête.

Lorsque vous mettez à jour unNote, vous devez supprimer l'entrée correspondant à la note spécifique afin de vous assurer que la demande suivante la récupère depuis la source de données principale. Pour cela, vous devez créer un gestionnaire de demandes.

L'exemple suivant montre une façon de gérer l'expulsion à l'aide de cette méthode :

import { util, Context } from '@aws-appsync/utils';
import { update } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	extensions.evictFromApiCache('Query', 'getNote', { 'ctx.args.id': ctx.args.id });
	return update({ key: { id: ctx.args.id }, update: { context: ctx.args.content } });
}

export const response = (ctx) => ctx.result;

Vous pouvez également gérer l'expulsion dans le gestionnaire de réponses.

Lorsque la updateNote mutation est traitée, AWS AppSync tente d'expulser l'entrée. Si une entrée est correctement effacée, la réponse contient une apiCacheEntriesDeleted valeur dans l'extensionsobjet qui indique le nombre d'entrées supprimées :

"extensions": {  "apiCacheEntriesDeleted": 1}

Expulsion d'une entrée de cache en fonction de son identité

Vous pouvez créer des clés de mise en cache basées sur plusieurs valeurs de l'contextobjet.

Par exemple, prenons le schéma suivant qui utilise les groupes d'utilisateurs Amazon Cognito comme mode d'authentification par défaut et est soutenu par une source de données Amazon DynamoDB :

type Note {
  id: ID! # a slug; e.g.: "my-first-note-on-graphql"
  title: String
  content: String!
}

type Query {
  getNote(id: ID!): Note
}

type Mutation {
  updateNote(id: ID!, content: String!): Note
}

Les types Note d'objets sont enregistrés dans une table DynamoDB. La table contient une clé composite qui utilise le nom d'utilisateur Amazon Cognito comme clé primaire et le id (un slug) Note comme clé de partition. Il s'agit d'un système mutualisé qui permet à plusieurs utilisateurs d'héberger et de mettre à jour leurs Note objets privés, qui ne sont jamais partagés.

Comme il s'agit d'un système à lecture intensive, la getNote requête est mise en cache à l'aide de la mise en cache par résolveur, la clé de mise en cache étant composée de. [context.identity.username, context.arguments.id] Lorsqu'un Note est mis à jour, vous pouvez supprimer l'entrée correspondante. Note Vous devez ajouter les composants dans l'objet dans l'ordre dans lequel ils sont spécifiés dans la cachingKeys liste de votre résolveur.

L'exemple suivant illustre cela :

import { util, Context } from '@aws-appsync/utils';
import { update } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	extensions.evictFromApiCache('Query', 'getNote', {
		'ctx.identity.username': ctx.identity.username,
		'ctx.args.id': ctx.args.id,
	});
	return update({ key: { id: ctx.args.id }, update: { context: ctx.args.content } });
}

export const response = (ctx) => ctx.result;

Un système principal peut également mettre à jour l'entrée Note et l'expulser. Par exemple, prenons cette mutation :

type Mutation {
  updateNoteFromBackend(id: ID!, content: String!, username: ID!): Note @aws_iam
}

Vous pouvez supprimer l'entrée, mais ajouter les composants de la clé de mise en cache à l'cachingKeysobjet.

Dans l'exemple suivant, l'expulsion se produit dans la réponse du résolveur :

import { util, Context } from '@aws-appsync/utils';
import { update } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
    return update({ key: { id: ctx.args.id }, update: { context: ctx.args.content } });
}

export function response(ctx) {
    extensions.evictFromApiCache('Query', 'getNote', {
        'ctx.identity.username': ctx.args.username,
        'ctx.args.id': ctx.args.id,
    });
    return ctx.result;
}

Dans les cas où vos données de backend ont été mises à jour en dehors de AWS AppSync, vous pouvez expulser un élément du cache en appelant une mutation utilisant une source de NONE données.

Compression des réponses de l'API

AWS AppSync permet aux clients de demander des charges utiles compressées. Sur demande, les réponses de l'API sont compressées et renvoyées en réponse aux demandes indiquant que le contenu compressé est préféré. Les réponses d'API compressées se chargent plus rapidement, le contenu est téléchargé plus rapidement et vos frais de transfert de données peuvent également être réduits.

AWS AppSync peut compresser des tailles de charge utile de requêtes GraphQL comprises entre 1 000 et 10 000 000 octets. Pour activer la compression, le client doit envoyer l'Accept-Encodingen-tête avec la valeurgzip. La compression peut être vérifiée en vérifiant la valeur de l'Content-Encodingen-tête dans la réponse (gzip).

L'explorateur de requêtes de la AWS AppSync console définit automatiquement la valeur d'en-tête de la demande par défaut. Si vous exécutez une requête dont le taux de réponse est suffisamment élevé, la compression peut être confirmée à l'aide des outils de développement de votre navigateur.