Comment informer les abonnés AWS AppSync des mises à jour de base de données externes qui ne sont pas effectuées par les mutations côté client ?

Date de la dernière mise à jour : 06/10/2021

J'ai besoin que les clients de mon application se mettent à jour en temps réel lorsque des modifications de bases de données externes sont apportées et qui ne sont pas effectuées via des mutations côté client. Comment utiliser AWS AppSync pour informer les abonnés de ces modifications ?

Brève description

Utilisez les résolveurs locaux pour avertir les abonnés des modifications des bases de données externes en temps réel sans avoir besoin d'effectuer un appel de source de données.

Suivez ces instructions pour créer un exemple d'API GraphQL qui tient les abonnés à jour en temps réel lorsque des données sont écrites dans une source de données de tables Amazon DynamoDB.

Remarque : l'utilisation de résolveurs locaux peut être utile lorsque les abonnés ont besoin de données en temps réel. Par exemple, les résolveurs locaux sont pratiques dans une application de compagnie aérienne qui doit être régulièrement mise à jour avec les derniers horaires de vol et tarifications.

Résolution

Créer une API GraphQL à l'aide de l'assistant

Utilisez l'assistant de schéma guidé AWS AppSync pour créer une nouvelle API GraphQL. Pour plus d'informations, consultez Conception d'une API GraphQL.

1.    Ouvrez la console AWS AppSync.

2.    Sélectionnez Create API (Créer une API).

3.    Sur la page Getting Started (Mise en route) sous Customize your API or import from Amazon DynamoDB (Personnaliser votre API ou importer depuis Amazon DynamoDB), sélectionnez Create with wizard (Créer avec l'assistant), puis Start (Démarrer).

4.    Sur la page Create a model (Créer un modèle), procédez comme suit :
Sous Name the model,(Nommer le modèle), vous pouvez entrer un nom pour votre modèle. Pour cet exemple de configuration, ne modifiez pas le nom du modèle (MyModelType).
Sous Configure model fields (Configurer les champs de modèle), vous pouvez définir les types de données de votre application. Pour cet exemple de configuration, conservez les noms de champs par défaut (id et title) et les types.
(Facultatif) Développez Configure model table (facultatif) (Configurer les champs de modèle [facultatif]) pour ajouter un index.
Choisissez Create (Créer).

5.    Sur la page Create resources (Créer des ressources), entrez un nom pour votre API, puis sélectionnez Create (Créer). AWS AppSync crée votre API comme indiqué et ouvre la page Queries (Requêtes) de votre API.

Créer un abonnement test

1.    Dans la console AWS AppSync, sur la page Queries (Requêtes) de votre API, ouvrez une fenêtre ou un onglet de navigateur en double.

2.    Dans l'onglet ou la fenêtre du navigateur dupliqué, dans l'éditeur de requête, entrez ce qui suit :

subscription sub1 {
  onCreateMyModelType{
    id
    title
  }
}

Cette opération crée un abonnement pour les mutations createMyModelType.

3.    Sélectionnez le bouton de lecture (Execute Query [Exécuter la requête]), puis sub1. L'onglet ou la fenêtre du navigateur en double est abonné à la mutation.

4.    Dans l'onglet ou la fenêtre du navigateur d'origine, choisissez le bouton de lecture (Execute Query [Exécuter la requête]), puis createMyModelType. Cette opération exécute la mutation. Vous pouvez voir les résultats dans les onglets ou fenêtres du navigateur d'origine et en double (abonnement).

5.    Fermez l'onglet ou la fenêtre du navigateur en double une fois que le comportement d'abonnement a été démontré.

Créer une source de données de type None

Le type de source de données None transmet le modèle de mappage des requêtes directement au modèle de mappage des réponses.

1.    Dans l'onglet ou la fenêtre du navigateur d'origine, dans le volet de navigation de gauche de la console AWS AppSync, sélectionnez Data Sources (Sources de données).

2.    Sélectionnez Create Data Source (Créer une source de données).

3.    Sur la page New Data Source (Nouvelle source de données), sous Create new Data Source (Créer une nouvelle source de données), procédez comme suit :
Pour Data source name (Nom de la source de données), entrez un nom. Par exemple, real_time_data.
Pour Data source type (Type de source de données), sélectionnez None (Aucun).

4.    Choisissez Create (Créer).

Pour plus d'informations, consultez Attachement d'une source de données.

Ajouter une mutation au schéma

Mettez à jour le schéma avec une mutation qui transmet les mises à jour des bases de données à la source de données de type None.

1.    Dans le volet de navigation de gauche de la console AWS AppSync, sélectionnez Schema (Schéma).

2.    Dans l'éditeur de schéma, sous type Mutation {, remplacez ceci :

createMyModelType(input: CreateMyModelTypeInput!): MyModelType

Par ceci :

addMyModelType(id : ID! , title : String!): MyModelType

3.    Dans l'éditeur de schéma, sous type Subscription {, remplacez ceci :

@aws_subscribe(mutations: ["createMyModelType"])

Par ceci :

@aws_subscribe(mutations: ["addMyModelType"])

Remarque : vous pouvez également créer un nouveau type de mutation et l'abonnement correspondant au lieu de les remplacer.

4.    Choisissez Save Schema (enregistrer le schéma).

Pour plus d'informations, consultez Conception de votre schéma.

Attacher un résolveur à l'abonnement

1.    Dans la console AWS AppSync, sur la page Schema (Schéma) votre API, sous Resolvers (Résolveurs), faites défiler l'écran jusqu'à Mutation. Ou, pour Filter types (Types de filtres), entrez Mutation.

2.    En regard de addMyModelType (...): MyModelType, sous Resolver (Résolveurs), sélectionnez Attach (Joindre).

3.    Sur la page Create new Resolver (Créer un nouveau résolveur) pour Data source name (Nom de la source de données), sélectionnez le nom de la source de données type None que vous avez créée précédemment. (Par exemple, real_time_data.)

4.    Sous Configure the request mapping template (Configurer le modèle de mappage des requêtes), remplacez ceci :

"payload": {
    "hello": "local",
}

Par ceci :

"payload": $util.toJson($context.args)

4.    Choisissez Save Resolver (Enregistrer le résolveur).

Pour plus d'informations, consultez Configuration des résolveurs.

Créer un nouvel abonnement test

1.    Dans la console AWS AppSync, dans le volet de navigation de gauche, sélectionnez Queries (Requêtes).

2.    Sur la page Queries (Requêtes) de votre API, ouvrez une fenêtre ou un onglet de navigateur en double.

3.    Dans l'onglet ou la fenêtre du navigateur dupliqué, dans l'éditeur de requête, remplacez ceci :

mutation createMyModelType($createmymodeltypeinput: CreateMyModelTypeInput!) {
  createMyModelType(input: $createmymodeltypeinput) {
    id
    title
  }
}

Par ceci :

subscription sub1 {
  onCreateMyModelType{
    id
    title
  }
}

4.    Sélectionnez le bouton de lecture (Execute Query [Exécuter la requête]), puis sub2. L'onglet ou la fenêtre du navigateur en double est abonné à la mutation.

Créer une nouvelle mutation de test

1.    Dans l'onglet ou la fenêtre du navigateur d'origine, sur la page Queries (Requêtes) de votre API, dans l'éditeur de requête, remplacez ceci :

mutation createMyModelType($createmymodeltypeinput: CreateMyModelTypeInput!) {
  createMyModelType(input: $createmymodeltypeinput) {
    id
    title
  }
}

Par ceci :

mutation mutation1 {
  addMyModelType(id:"5",title:"new update"){
    id
    title
  }
}

Cette opération crée une mutation addMyModelType.

2.    Sélectionnez le bouton de lecture (Execute Query [Exécuter la requête]), puis mutation1.

3.    Dans l'onglet ou la fenêtre du navigateur dupliqué (abonnement), vérifiez que l'abonné reçoit la mise à jour en temps réel.

(Facultatif) Consultez les exemples de cas d'utilisation

Lorsque vous créez votre application client et appliquez ces concepts, pensez à l'exemple de cas d'utilisation d'une compagnie aérienne qui fournit la tarification et les heures de vol. Dans ce cas, pour informer les clients abonnés lorsque les détails du vol changent dans une table DynamoDB, procédez comme suit :

1.    Créez une fonction AWS Lambda qui utilise un flux DynamoDB comme déclencheur. La fonction Lambda est appelée chaque fois qu'une mise à jour est apportée à la table DynamoDB. Pour plus d'informations, consultez Utilisation d'AWS Lambda avec Amazon DynamoDB.

2.    Dans le code de la fonction Lambda, incluez la logique pour filtrer les mises à jour appropriées et effectuer un appel de mutation à AWS AppSync. Ainsi, AWS AppSync informe les abonnés par le biais de l'abonnement. Pour plus d'informations, consultez Didacticiel : résolveurs AWS Lambda.

3.    Dans AWS AppSync, ajoutez un nouveau champ de mutation (par exemple, nommé publishPrice) avec un résolveur local.

4.    Abonnez-vous à cette mutation dans un champ d'abonnement (par exemple, nommé onPriceUpdate).

Exemple de schéma

type flightDetails {
  id: ID!
  src: String!
  destn: String!
  price : Int
}

type Mutation {
   # A local resolver targeting a None data source that publishes the message to subscribed clients.
  publishPrice(price: Int): flightDetails
}

type Subscription {
  # Notified whenever *publishPrice* is called.
  onPriceUpdate: Message
    @aws_subscribe(mutations: ["publishPrice"])
}

type Query { ... }

Pour plus d'informations, consultez Conception de votre schéma.

5.    Créez une autre fonction AWS Lambda qui utilise un flux DynamoDB comme déclencheur. Dans cette fonction, appelez la mutation publishPrice. Étant donné que la mutation publishPrice possède un résolveur local, les données ne sont pas de nouveau écrites dans DynamoDB. De cette façon, vous pouvez utiliser AWS AppSync comme agent PubSub.

Pour plus d'informations et un autre exemple de cas d'utilisation, consultez Didacticiel : résolveurs locaux.


Cet article vous a-t-il été utile ?


Besoin d'aide pour une question technique ou de facturation ?