Como configurar o cache do lado do servidor e a compactação da carga útil da API no AWS AppSync

AWS AppSyncOs recursos de cache de dados do lado do servidor disponibilizam os dados em um cache na memória de alta velocidade, melhorando a performance e diminuindo a latência. Isso reduz a necessidade de acessar fontes de dados diretamente. O armazenamento em cache está disponível para resolvedores unitários e de pipeline.

O AWS AppSync também permite compactar as respostas da API para que o conteúdo da carga seja carregado e baixado mais rapidamente. Isso reduz potencialmente a pressão sobre suas aplicações e, ao mesmo tempo, reduz potencialmente suas cobranças de transferência de dados. O comportamento de compactação pode ser configurado e definido a seu próprio critério.

Consulte esta seção se precisar de ajuda para definir o comportamento desejado do armazenamento em cache e da compactação do lado do servidor em sua API do AWS AppSync.

Tipos de instância

O AWS AppSync hospeda instâncias do Amazon ElastiCache (Redis OSS) na mesma conta da AWS e região da AWS que a sua API do AWS AppSync.

O tipos de instâncias do ElastiCache (Redis OSS) a seguir estão disponíveis:

Comportamento de armazenamento em cache

Veja a seguir os comportamentos relacionados ao armazenamento em cache:

Criptografia de cache

Quando você usa o atributo de armazenamento em cache dos dados no lado do servidor do AWS AppSync, a criptografia em repouso e em trânsito permanece sempre habilitada para novos caches e não pode ser desabilitada.

Para habilitar a criptografia em um cache de API existente, exclua o cache e, em seguida, recrie-o.

Para invalidar as entradas de cache, você pode fazer uma chamada de API para limpar o cache usando o console do AWS AppSync ou a AWS Command Line Interface (AWS CLI).

Para obter mais informações, consulte o tipo de dados ApiCache na Referência de API do AWS AppSync.

Remoção de cache

Ao configurar o cache do lado do servidor do AWS AppSync, você pode configurar um TTL máximo. Ele define por quanto tempo as entradas em cache serão armazenadas na memória. Quando precisar remover entradas específicas do seu cache, você poderá usar o utilitário de evictFromApiCache extensões do AWS AppSync na solicitação ou resposta do seu resolvedor. (Por exemplo, os dados em suas fontes de dados mudaram, e agora sua entrada de cache ficou obsoleta.) Para remover um item do cache, você deve saber qual é sua chave. Por esse motivo, se você precisar despejar itens dinamicamente, recomendamos usar o cache por resolvedor e definir explicitamente uma chave para adicionar entradas ao seu cache.

Remover uma entrada de cache

Para remover um item do cache, use o utilitário de extensões evictFromApiCache. Especifique o nome do tipo e o nome do campo e, em seguida, forneça um objeto de itens de valor-chave para criar a chave da entrada que você deseja remover. No objeto, cada chave representa uma entrada válida do objeto context que é usada na lista de cachingKey em cache do resolvedor. Para criar o valor da chave são usados os valores reais. Você deve colocar os itens no objeto seguindo a ordem das chaves de cache na lista em cache de cachingKey do resolvedor.

Por exemplo, confira o seguinte esquema:

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

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

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

Neste exemplo, você pode habilitar o armazenamento em cache por resolvedor e, em seguida, habilitá-lo para a consulta de getNote. Em seguida, é possível configurar a chave de cache de modo que ela seja [context.arguments.id].

Quando você tenta obter uma Note para criar a chave de cache, o AWS AppSync executa uma busca em seu cache do lado do servidor usando o argumento do id da consulta de getNote.

Ao atualizar uma Note, é preciso remover a entrada da nota específica para garantir que a próxima solicitação realize a busca na fonte de dados do back-end. Para isso, crie um manipulador de solicitações.

O exemplo a seguir mostra um modo de lidar com a remoção usando este método:

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;

Outra opção é tratar da remoção no manipulador de respostas.

Quando a mutação de updateNote é processada, o AWS AppSync tenta remover a entrada. Se uma entrada for apagada com sucesso, a resposta vai conter um valor de apiCacheEntriesDeleted no objeto extensions que mostra quantas entradas foram excluídas:

"extensions": {  "apiCacheEntriesDeleted": 1}

Remover uma entrada de cache com base na identidade

Você pode criar chaves de cache com base em diversos valores do objeto context.

Por exemplo, veja o esquema a seguir, que usa grupos de usuários do Amazon Cognito como modo de autenticação padrão e é apoiado por uma fonte de dados do 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
}

Os tipos de objeto Note são salvos em uma tabela do DynamoDB. A tabela tem uma chave composta que usa o nome de usuário do Amazon Cognito como chave primária e o id (um slug) da Note como chave de partição. Esse é um sistema multilocatário que pode hospedar vários usuários e atualizar seus objetos privados Note, que nunca são compartilhados.

Como esse é um sistema que exige muita leitura, a getNote consulta é armazenada usando o cache por resolvedor, com a chave de cache composta por [context.identity.username, context.arguments.id]. Quando a Note é atualizada, você pode despejar a entrada específica da Note. Você deve adicionar os componentes no objeto seguindo a ordem em que estão especificados na lista de cachingKeys do seu resolvedor.

O exemplo a seguir mostra isso.

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;

Um sistema de back-end também pode atualizar a Note e remover a entrada. Por exemplo, considere esta mutação:

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

Você pode despejar a entrada, mas adicionar os componentes da chave de cache ao objeto cachingKeys.

No exemplo a seguir, a remoção ocorre na resposta do resolvedor:

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;
}

Nos casos em que seus dados de back-end tiverem sido atualizados fora do AWS AppSync, você pode remover um item do cache chamando uma mutação que usa uma fonte de dados NONE.

Compactar respostas da API

O AWS AppSync permite que os clientes solicitem cargas compactadas. Se solicitadas, as respostas da API são compactadas e retornadas em resposta às solicitações que indicam que o conteúdo compactado tem preferência. As respostas compactadas da API carregam mais rápido, assim como o download do conteúdo, e suas taxas de transferência de dados também podem ser reduzidas.

O AWS AppSync pode compactar tamanhos de payload da consulta do GraphQL entre 1.000 a 10.000.000 bytes. Para ativar a compactação, o cliente deve enviar o cabeçalho de Accept-Encoding com o valor gzip. A compactação pode ser confirmada ao verificar o valor do cabeçalho Content-Encoding na resposta (gzip).

O explorador de consultas no console do AWS AppSync define automaticamente o valor do cabeçalho na solicitação por padrão. Se você executar uma consulta com uma resposta grande o suficiente, a compactação poderá ser confirmada usando as ferramentas de desenvolvedor do seu navegador.