Comment informer les abonnés d'AWS AppSync des mises à jour des bases de données externes qui ne sont pas effectuées par le biais de mutations ?

Date de la dernière mise à jour : 27/02/2020

J'ai besoin que les clients de mon application mettent à jour en temps réel les modifications des bases de données externes. Comment utiliser AWS AppSync pour informer les abonnés de ces modifications ?

Brève description

Utilisez les résolveurs locaux pour avertir instantanément les abonnés des modifications des bases de données externes sans avoir besoin de déclencher un appel de source de données. Cela est utile lorsque les abonnés ont besoin de données en temps réel, par exemple, dans une application de compagnie aérienne, pour obtenir les derniers tarifs et heures de vol.

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 table Amazon DynamoDB.

Solution

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

Utilisez l'assistant de schéma guidé AWS AppSync pour créer une 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.
Sélectionnez 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, sélectionnez le bouton de lecture (Execute Query [Exécuter la requête]), puis createMyModelType. Cette opération exécute la mutation et 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 de demande directement au modèle de mappage de réponse.

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.    Sélectionnez Create (Créer).

Pour plus d'informations, consultez Association 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 { (Mutation type {), remplacez ceci :

    createMyModelType(input: CreateMyModelTypeInput!): MyModelType

Avec ceci :

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

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

        @aws_subscribe(mutations: ["createMyModelType"])

Avec 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.    Sélectionnez 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 de demande), remplacez ceci :

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

Avec ceci :

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

4.    Sélectionnez Save Resolver (Enregistrer le résolveur).

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

Créer un nouvel abonnement de 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
  }
}

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

Avec 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 d'application d'une compagnie aérienne qui fournit la tarification et les durées 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 déclenchée chaque fois qu'une mise à jour de la table DynamoDB est effectuée. 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). Le schéma peut ressembler à ce qui suit :

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 ?

Cette page peut-elle être améliorée ?


Vous avez besoin d’aide ?