Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Décomposez les monolithes en microservices en utilisant le CQRS et le sourcing d'événements
*Rodolfo Junior Cerrada, Dmitry Gulin et Tabby Ward,* Amazon Web Services
## Résumé
Ce modèle combine deux modèles, en utilisant à la fois le modèle de séparation des responsabilités des requêtes de commande (CQRS) et le modèle de source d'événements. Le modèle CQRS sépare les responsabilités des modèles de commande et de requête. Le modèle d'approvisionnement en événements tire parti de la communication asynchrone axée sur les événements pour améliorer l'expérience utilisateur globale.
Vous pouvez utiliser les services CQRS et Amazon Web Services (AWS) pour gérer et dimensionner chaque modèle de données indépendamment tout en refactorisant votre application monolithe en architecture de microservices. Vous pouvez ensuite utiliser le modèle d'origine des événements pour synchroniser les données de la base de commandes vers la base de données de requêtes.
Ce modèle utilise un exemple de code qui inclut un fichier de solution (\$1.sln) que vous pouvez ouvrir à l'aide de la dernière version de Visual Studio. L'exemple contient le code de l'API Reward pour montrer comment le CQRS et le sourcing d'événements fonctionnent dans les applications AWS sans serveur, traditionnelles ou sur site.
Pour en savoir plus sur le CQRS et le sourcing événementiel, consultez la section [Informations supplémentaires](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional).
## Conditions préalables et limitations
**Conditions préalables**
+ Un compte AWS actif
+ Amazon CloudWatch
+ Tables Amazon DynamoDB
+ Amazon DynamoDB Streams
+ Clé d'accès et clé secrète d'AWS Identity and Access Management (IAM) ; pour plus d'informations, regardez la vidéo dans la section *Ressources connexes*
+ AWS Lambda
+ Connaissance de Visual Studio
+ Connaissance d'AWS Toolkit for Visual Studio ; pour plus d'informations, consultez la vidéo de *démonstration d'AWS Toolkit for Visual Studio* dans la section *Ressources connexes*
**Versions du produit**
+ [Édition communautaire de Visual Studio 2019](https://visualstudio.microsoft.com/downloads/).
+ [Boîte à outils AWS pour Visual Studio 2019](https://aws.amazon.com/visualstudio/).
+ .NET Core 3.1. Ce composant est une option de l'installation de Visual Studio. Pour inclure .NET Core lors de l'installation, sélectionnez **NET Core cross-platform development**.
**Limites**
+ L'exemple de code pour une application locale traditionnelle (API Web ASP.NET Core et objets d'accès aux données) n'est pas fourni avec une base de données. Cependant, il est fourni avec l'objet `CustomerData` en mémoire, qui agit comme une base de données fictive. Le code fourni est suffisant pour que vous puissiez tester le modèle.
## Architecture
**Pile technologique source**
+ Projet d'API Web ASP.NET Core
+ Serveur Web IIS
+ Objet d'accès aux données
+ Modèle CRUD
**Architecture source**
Dans l'architecture source, le modèle CRUD contient à la fois des interfaces de commande et de requête dans une seule application. Pour un exemple de code, voir `CustomerDAO.cs` (ci-joint).
![\[Connexions entre l'application, l'interface de service, le modèle CRUD du client et la base de données.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1cd3a84c-12c7-4306-99aa-23f2c53d3cd3.png)
**Pile technologique cible**
+ Amazon DynamoDB
+ Amazon DynamoDB Streams
+ AWS Lambda
+ (Facultatif) Amazon API Gateway
+ (Facultatif) Amazon Simple Notification Service (Amazon SNS)
**Architecture cible**
Dans l'architecture cible, les interfaces de commande et de requête sont séparées. L'architecture illustrée dans le schéma suivant peut être étendue avec API Gateway et Amazon SNS. Pour plus d'informations, consultez la section [Informations supplémentaires](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional).
![\[Application connectée aux microservices Customer Command et Customer Query sans serveur.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1c665697-e3ac-4ef4-98d0-86c2cbf164c1.png)
1. Les fonctions Command Lambda exécutent des opérations d'écriture, telles que la création, la mise à jour ou la suppression, sur la base de données.
1. Les fonctions Query Lambda exécutent des opérations de lecture, telles que get ou select, sur la base de données.
1. Cette fonction Lambda traite les flux DynamoDB à partir de la base de données de commandes et met à jour la base de données Query en fonction des modifications.
## Outils
**Outils**
+ [Amazon DynamoDB — Amazon](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) DynamoDB est un service de base de données NoSQL entièrement géré qui fournit des performances rapides et prévisibles ainsi qu'une évolutivité sans faille.
+ [Amazon DynamoDB Streams — DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) Streams capture une séquence chronologique de modifications au niveau des éléments dans n'importe quelle table DynamoDB. Il enregistre ensuite ces informations dans un journal pendant 24 heures au maximum. Le chiffrement au repos chiffre les données dans les flux DynamoDB Streams.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) — AWS Lambda est un service de calcul qui prend en charge l'exécution de code sans provisionner ni gérer de serveurs. Lambda exécute le code uniquement lorsque cela est nécessaire et se met à l’échelle automatiquement, qu’il s’agisse de quelques requêtes par jour ou de milliers de requêtes par seconde. Vous payez uniquement le temps de calcul que vous utilisez. Vous n'exposez aucuns frais quand votre code n'est pas exécuté.
+ [AWS Management Console](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/learn-whats-new.html) — L'AWS Management Console est une application Web qui comprend un large éventail de consoles de service pour gérer les services AWS.
+ [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/) — Visual Studio 2019 est un environnement de développement intégré (IDE). L'édition communautaire est gratuite pour les contributeurs open source. Dans ce modèle, vous utiliserez Visual Studio 2019 Community Edition pour ouvrir, compiler et exécuter un exemple de code. Pour l'affichage uniquement, vous pouvez utiliser n'importe quel éditeur de texte ou [Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html).
+ [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) — Le kit AWS Toolkit pour Visual Studio est un plugin pour l'IDE Visual Studio. L'AWS Toolkit for Visual Studio facilite le développement, le débogage et le déploiement d'applications .NET utilisant les services AWS.
**Code**
L'exemple de code est joint en pièce jointe. Pour obtenir des instructions sur le déploiement de l'exemple de code, consultez la section *Epics*.
## Épopées
### Ouvrez et créez la solution
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Ouvrez la solution. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d’applications |
| Créez la solution. | Ouvrez le menu contextuel (clic droit) de la solution, puis choisissez **Build Solution**. Cela permettra de créer et de compiler tous les projets de la solution. Il devrait être compilé avec succès.Visual Studio Solution Explorer doit afficher la structure du répertoire.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d’applications |
### Création des tables DynamoDB
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Fournissez des informations d'identification. | Si vous n'avez pas encore de clé d'accès, regardez la vidéo dans la section *Ressources connexes*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d'applications, ingénieur de données, DBA |
| Générez le projet. | **Pour créer le projet, ouvrez le menu contextuel (clic droit) du projet **aws.apg.cqrses.build, puis choisissez Build.**** | Développeur d'applications, ingénieur de données, DBA |
| Créez et remplissez les tables. | ****Pour créer les tables et les remplir avec des données de départ, ouvrez le menu contextuel (clic droit) du projet **aws.apg.cqrses.build**, puis choisissez Debug, Start New Instance.**** | Développeur d'applications, ingénieur de données, DBA |
| Vérifiez la construction de la table et les données. | Pour vérifier, accédez à **AWS Explorer** et développez **Amazon DynamoDB**. Il doit afficher les tableaux. Ouvrez chaque table pour afficher les exemples de données. | Développeur d'applications, ingénieur de données, DBA |
### Exécuter des tests locaux
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Construisez le projet CQRS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d'applications, ingénieur de test |
| Construisez le projet d'approvisionnement en événements. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d'applications, ingénieur de test |
| Exécutez les tests. | Pour exécuter tous les tests, choisissez **Afficher**, **Explorateur de tests**, puis sélectionnez **Exécuter tous les tests en mode Affichage**. Tous les tests doivent réussir, ce qui est indiqué par une icône en forme de coche verte. | Développeur d'applications, ingénieur de test |
### Publiez les fonctions Lambda du CQRS sur AWS
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Publiez la première fonction Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d'applications, DevOps ingénieur |
| Vérifiez le téléchargement de la fonction. | (Facultatif) Vous pouvez vérifier que la fonction a été correctement chargée en accédant à AWS Explorer et en développant **AWS Lambda**. Pour ouvrir la fenêtre de test, choisissez la fonction Lambda (double-clic). | Développeur d'applications, DevOps ingénieur |
| Testez la fonction Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Tous les projets Lambda du CQRS se trouvent dans `CQRS AWS Serverless\CQRS\Command Microservice` les dossiers ` CQRS AWS Serverless\CQRS\Command Microservice` et solution. Pour le répertoire des solutions et les projets, voir **Répertoire du code source** dans la section [Informations supplémentaires](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Développeur d'applications, DevOps ingénieur |
| Publiez les fonctions restantes. | Répétez les étapes précédentes pour les projets suivants :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d'applications, DevOps ingénieur |
### Configurer la fonction Lambda en tant qu'écouteur d'événements
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Publiez les gestionnaires d'événements Lambda destinés aux clients et aux récompenses. | Pour publier chaque gestionnaire d'événements, suivez les étapes décrites dans l'épopée précédente.Les projets se trouvent dans les dossiers `CQRS AWS Serverless\Event Source\Customer Event` et `CQRS AWS Serverless\Event Source\Reward Event` solutions. Pour plus d'informations, consultez le *répertoire du code source* dans la section [Informations supplémentaires](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Développeur d’applications |
| Joignez l'écouteur d'événements Lambda de source d'événements. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Une fois que l'écouteur est correctement attaché à la table DynamoDB, il s'affiche sur la page du concepteur Lambda. | Développeur d’applications |
| Publiez et attachez la fonction EventSourceReward Lambda. | Pour publier et associer la fonction `EventSourceReward` Lambda, répétez les étapes décrites dans les deux articles précédents, en sélectionnant dans la liste déroulante **cqrses-reward-cmd**du tableau **DynamoDB**. | Développeur d’applications |
### Testez et validez les flux DynamoDB et le déclencheur Lambda
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Testez le flux et le déclencheur Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d’applications |
| Validez à l'aide de la table de requêtes de récompenses DynamodDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d’applications |
| Validez à l'aide CloudWatch des journaux. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Développeur d’applications |
| Validez le EventSourceCustomer déclencheur. | Pour valider le `EventSourceCustomer` déclencheur, répétez les étapes de cette épopée en utilisant le tableau des clients et les CloudWatch journaux correspondants du `EventSourceCustomer` déclencheur. | Développeur d’applications |
## Ressources connexes
**Références**
+ [Téléchargements de Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/)
+ [Téléchargement d'AWS Toolkit pour Visual Studio](https://aws.amazon.com/visualstudio/)
+ [Guide de l'utilisateur d'AWS Toolkit pour Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html)
+ [Sans serveur sur AWS](https://aws.amazon.com/serverless/)
+ [Cas d'utilisation et modèles de conception de DynamoDB](https://aws.amazon.com/blogs/database/dynamodb-streams-use-cases-and-design-patterns/)
+ [Martin Fowler CQRS](https://martinfowler.com/bliki/CQRS.html)
+ [Martin Fowler Recherche d'événements](https://martinfowler.com/eaaDev/EventSourcing.html)
**Vidéos**
+ [Démo d'AWS Toolkit pour Visual Studio](https://www.youtube.com/watch?v=B190tcu1ERk)
+ [Comment créer un identifiant de clé d'accès pour un nouvel utilisateur IAM ?](https://www.youtube.com/watch?v=665RYobRJDY)
## Informations supplémentaires
**CQRS et approvisionnement événementiel**
*CARS*
Le modèle CQRS sépare un modèle d'opérations conceptuel unique, tel qu'un modèle CRUD (création, lecture, mise à jour, suppression) d'un objet d'accès aux données, en modèles d'opérations de commande et de requête. Le modèle de commande fait référence à toute opération, telle que la création, la mise à jour ou la suppression, qui modifie l'état. Le modèle de requête fait référence à toute opération qui renvoie une valeur.
![\[Architecture avec interface de service, modèle CRUD et base de données.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/3f64756d-681e-4f0e-8034-746263d857b2.png)
1. Le modèle Customer CRUD inclut les interfaces suivantes :
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
Au fur et à mesure que vos exigences se complexifient, vous pouvez abandonner cette approche à modèle unique. Le CQRS utilise un modèle de commande et un modèle de requête pour séparer les responsabilités d'écriture et de lecture des données. Ainsi, les données peuvent être maintenues et gérées de manière indépendante. Grâce à une séparation claire des responsabilités, les améliorations apportées à chaque modèle n'ont aucune incidence sur l'autre. Cette séparation améliore la maintenance et les performances, et réduit la complexité de l'application à mesure qu'elle grandit.
![\[L'application s'est séparée en modèles de commande et de requête, partageant une seule base de données.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/12db023c-eb81-4c27-bbb9-b085b13176ae.png)
1. Interfaces dans le modèle de commande client :
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
1. Interfaces dans le modèle de requête client :
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
+ `GetMonthlyStatement()`
Pour un exemple de code, voir *Répertoire du code source*.
Le modèle CQRS découple ensuite la base de données. Ce découplage conduit à l'indépendance totale de chaque service, qui est l'ingrédient principal de l'architecture des microservices.
![\[Bases de données distinctes pour les modèles de commande et de requête.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/016dbfa8-3bd8-42ee-afa1-38a98986c7d5.png)
En utilisant le CQRS dans le cloud AWS, vous pouvez optimiser davantage chaque service. Par exemple, vous pouvez définir différents paramètres de calcul ou choisir entre un microservice sans serveur ou un microservice basé sur des conteneurs. Vous pouvez remplacer votre mise en cache sur site par Amazon. ElastiCache Si vous disposez d'une publish/subscribe messagerie sur site, vous pouvez la remplacer par Amazon Simple Notification Service (Amazon SNS). En outre, vous pouvez profiter de la pay-as-you-go tarification et de la vaste gamme de services AWS selon lesquels vous ne payez que pour ce que vous utilisez.
Le CQRS inclut les avantages suivants :
+ Mise à l'échelle indépendante : la stratégie de mise à l'échelle de chaque modèle peut être ajustée pour répondre aux exigences et à la demande du service. Comme pour les applications hautes performances, la séparation de la lecture et de l'écriture permet au modèle d'évoluer indépendamment pour répondre à chaque demande. Vous pouvez également ajouter ou réduire des ressources de calcul pour répondre à la demande d'évolutivité d'un modèle sans affecter l'autre.
+ Maintenance indépendante : la séparation des modèles de requête et de commande améliore la maintenabilité des modèles. Vous pouvez apporter des modifications et des améliorations au code d'un modèle sans affecter l'autre.
+ Sécurité — Il est plus facile d'appliquer les autorisations et les politiques à des modèles distincts pour la lecture et l'écriture.
+ Lectures optimisées : vous pouvez définir un schéma optimisé pour les requêtes. Par exemple, vous pouvez définir un schéma pour les données agrégées et un schéma distinct pour les tables de faits.
+ Intégration — Le CQRS s'adapte parfaitement aux modèles de programmation basés sur les événements.
+ Complexité gérée — La séparation en modèles de requête et de commande convient aux domaines complexes.
Lorsque vous utilisez le CQRS, gardez à l'esprit les mises en garde suivantes :
+ Le modèle CQRS ne s'applique qu'à une partie spécifique d'une application et non à l'ensemble de l'application. Si elle est mise en œuvre dans un domaine qui ne correspond pas au modèle, elle peut réduire la productivité, augmenter les risques et introduire de la complexité.
+ Le modèle fonctionne mieux pour les modèles fréquemment utilisés dont les opérations de lecture et d'écriture sont déséquilibrées.
+ Pour les applications nécessitant beaucoup de lecture, telles que les rapports volumineux dont le traitement prend du temps, le CQRS vous permet de sélectionner la bonne base de données et de créer un schéma pour stocker vos données agrégées. Cela améliore le temps de réponse lors de la lecture et de l'affichage du rapport en traitant les données du rapport une seule fois et en les enregistrant dans le tableau agrégé.
+ Pour les applications nécessitant beaucoup d'écriture, vous pouvez configurer la base de données pour les opérations d'écriture et autoriser le microservice de commande à évoluer indépendamment lorsque la demande d'écriture augmente. Pour des exemples, consultez les `AWS.APG.CQRSES.CommandAddRewardLambda` microservices `AWS.APG.CQRSES.CommandRedeemRewardLambda` et.
*Approvisionnement d’événement*
L'étape suivante consiste à utiliser la source d'événements pour synchroniser la base de données de requêtes lorsqu'une commande est exécutée. Par exemple, considérez les événements suivants :
+ Un point de récompense client est ajouté, ce qui nécessite la mise à jour du total ou du cumul des points de récompense du client dans la base de données de requêtes.
+ Le nom de famille d'un client est mis à jour dans la base de données de commandes, ce qui nécessite la mise à jour des informations du client de substitution dans la base de données de requêtes.
Dans le modèle CRUD traditionnel, vous garantissez la cohérence des données en verrouillant les données jusqu'à la fin d'une transaction. Lors de l'approvisionnement en événements, les données sont synchronisées grâce à la publication d'une série d'événements qui seront utilisés par un abonné pour mettre à jour ses données respectives.
Le modèle d'approvisionnement en événements garantit et enregistre une série complète d'actions entreprises sur les données et les publie par le biais d'une séquence d'événements. Ces événements représentent un ensemble de modifications apportées aux données que les abonnés à cet événement doivent traiter pour maintenir leur dossier à jour. Ces événements sont consommés par l'abonné, synchronisant les données de la base de données de l'abonné. Dans ce cas, il s'agit de la base de données de requêtes.
Le schéma suivant montre le sourcing d'événements utilisé avec CQRS sur AWS.
![\[Architecture de microservices pour le CQRS et modèles d'approvisionnement d'événements à l'aide des services sans serveur AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/cc9bc84a-60b4-4459-9a5c-2334c69dbb4e.png)
1. Les fonctions Command Lambda exécutent des opérations d'écriture, telles que la création, la mise à jour ou la suppression, sur la base de données.
1. Les fonctions Query Lambda exécutent des opérations de lecture, telles que get ou select, sur la base de données.
1. Cette fonction Lambda traite les flux DynamoDB à partir de la base de données de commandes et met à jour la base de données Query en fonction des modifications. Vous pouvez également utiliser cette fonction pour publier un message sur Amazon SNS afin que ses abonnés puissent traiter les données.
1. (Facultatif) L'abonné à l'événement Lambda traite le message publié par Amazon SNS et met à jour la base de données Query.
1. (Facultatif) Amazon SNS envoie une notification par e-mail concernant l'opération d'écriture.
Sur AWS, la base de données de requêtes peut être synchronisée par DynamoDB Streams. DynamoDB capture une séquence chronologique de modifications au niveau des éléments dans une table DynamoBDB en temps quasi réel et stocke les informations de manière durable dans les 24 heures.
L'activation de DynamoDB Streams permet à la base de données de publier une séquence d'événements qui rend possible le modèle d'approvisionnement des événements. Le modèle d'approvisionnement des événements ajoute l'abonné à l'événement. L'application d'abonnement à l'événement consomme l'événement et le traite sous la responsabilité de l'abonné. Dans le schéma précédent, l'abonné à l'événement envoie les modifications à la base de données Query DynamoDB afin de maintenir les données synchronisées. L'utilisation d'Amazon SNS, du courtier de messages et de l'application d'abonnement aux événements permet de découpler l'architecture.
Le sourcing événementiel inclut les avantages suivants :
+ Cohérence des données transactionnelles
+ Une piste d'audit fiable et un historique des actions, qui peuvent être utilisés pour surveiller les actions entreprises dans les données
+ Permet aux applications distribuées telles que les microservices de synchroniser leurs données dans l'environnement
+ Publication fiable des événements chaque fois que l'État change
+ Reconstruire ou rejouer des états passés
+ Entités faiblement couplées qui échangent des événements pour la migration d'une application monolithique vers des microservices
+ Réduction des conflits provoqués par des mises à jour simultanées ; le sourcing d'événements évite de devoir mettre à jour les objets directement dans le magasin de données
+ Flexibilité et extensibilité grâce au découplage de la tâche et de l'événement
+ Mises à jour externes du système
+ Gestion de plusieurs tâches en un seul événement
Lorsque vous utilisez le sourcing d'événements, gardez à l'esprit les mises en garde suivantes :
+ En raison du retard dans la mise à jour des données entre les bases de données d'abonnés sources, le seul moyen d'annuler une modification est d'ajouter un événement compensateur au magasin d'événements.
+ La mise en œuvre du sourcing d'événements a une courbe d'apprentissage en raison de son style de programmation différent.
**Données de test**
Utilisez les données de test suivantes pour tester la fonction Lambda après un déploiement réussi.
**CommandCreate Client**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Done", "CompanyName":"AnyCompany", "Address": "USA", "VIP":true }
```
**CommandUpdate Client**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Doe", "CompanyName":"Example Corp.", "Address": "Seattle, USA", "VIP":true }
```
**CommandDelete Client**
Entrez l'identifiant du client comme donnée de demande. Par exemple, si l'ID client est 151, entrez 151 comme données de demande.
```
151
```
**QueryCustomerList**
C'est vide. Lorsqu'il est invoqué, il renvoie tous les clients.
**CommandAddReward**
Cela ajoutera 40 points au client ayant l'ID 1 (Richard).
```
{
"Id":10101,
"CustomerId":1,
"Points":40
}
```
**CommandRedeemReward**
Cela déduira 15 points au client ayant l'ID 1 (Richard).
```
{
"Id":10110,
"CustomerId":1,
"Points":15
}
```
**QueryReward**
Entrez l'identifiant du client. Par exemple, entrez 1 pour Richard, 2 pour Arnav et 3 pour Shirley.
```
2
```
**Répertoire du code source**
Utilisez le tableau suivant comme guide de la structure de répertoires de la solution Visual Studio.
*Répertoire d'exemples de solutions de code sur site du CQRS*
![\[Répertoire de solutions avec services de commande et de requête étendus.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/4811c2c0-643b-410f-bb87-0b86ec5e194c.png)
**Modèle CRUD du client**
Exemple de code sur site CQRS \$1 Modèle CRUD \$1 Projet AWS.APG.CQRSES.DAL
**Version CQRS du modèle CUSTOMER CRUD**
+ Commande client : `CQRS On-Premises Code Sample\CQRS Model\Command Microservice\AWS.APG.CQRSES.Command` projet
+ Demande du client : `CQRS On-Premises Code Sample\CQRS Model\Query Microservice\AWS.APG.CQRSES.Query` projet
**Microservices de commande et de requête**
Le microservice Command se trouve dans le dossier `CQRS On-Premises Code Sample\CQRS Model\Command Microservice` de solutions :
+ `AWS.APG.CQRSES.CommandMicroservice`Le projet d'API ASP.NET Core constitue le point d'entrée où les consommateurs interagissent avec le service.
+ `AWS.APG.CQRSES.Command`Le projet .NET Core est un objet qui héberge des objets et des interfaces liés aux commandes.
Le microservice de requête se trouve dans le dossier `CQRS On-Premises Code Sample\CQRS Model\Query Microservice` de solution :
+ `AWS.APG.CQRSES.QueryMicroservice`Le projet d'API ASP.NET Core constitue le point d'entrée où les consommateurs interagissent avec le service.
+ `AWS.APG.CQRSES.Query`Le projet .NET Core est un objet qui héberge des objets et des interfaces liés aux requêtes.
*Répertoire de solutions de code sans serveur AWS CQRS*
![\[Répertoire de solutions affichant à la fois les microservices et la source d'événements étendus.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/23f8655c-95ad-422c-b20a-e29dc145e995.png)
Ce code est la version AWS du code sur site utilisant les services sans serveur AWS.
Dans C\$1 .NET Core, chaque fonction Lambda est représentée par un projet .NET Core. Dans l'exemple de code de ce modèle, il existe un projet distinct pour chaque interface dans les modèles de commande et de requête.
**CQRS utilisant les services AWS**
Le répertoire des solutions racine pour CQRS utilisant les services sans serveur AWS se trouve dans le `CQRS AWS Serverless\CQRS` dossier. L'exemple inclut deux modèles : client et récompense.
Les fonctions de commande Lambda pour Customer et Reward se trouvent sous `CQRS\Command Microservice\Customer` et `CQRS\Command Microservice\Reward` dans des dossiers. Ils contiennent les projets Lambda suivants :
+ Commande du client : `CommandCreateLambda``CommandDeleteLambda`, et `CommandUpdateLambda`
+ Commande de récompense : `CommandAddRewardLambda` et `CommandRedeemRewardLambda`
Les fonctions de requête Lambda pour Customer et Reward se trouvent dans les dossiers `CQRS\Query Microservice\Customer` et`CQRS\QueryMicroservice\Reward`. Ils contiennent les projets Lambda `QueryCustomerListLambda` et `QueryRewardLambda` Lambda.
**Projet de test CQRS**
Le projet de test se trouve sous le `CQRS\Tests` dossier. Ce projet contient un script de test pour automatiser le test des fonctions Lambda du CQRS.
**Recherche d'événements à l'aide des services AWS**
Les gestionnaires d'événements Lambda suivants sont lancés par les flux DynamoDB Customer et Reward pour traiter et synchroniser les données dans les tables de requêtes.
+ La fonction `EventSourceCustomer` Lambda est mappée au flux `cqrses-customer-cmd` DynamoDB de la table client ().
+ La fonction `EventSourceReward` Lambda est mappée au flux `cqrses-reward-cmd` DynamoDB de la table des récompenses ().
## Pièces jointes
[Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/9f1bc700-def4-4201-bb2d-f1fa27404f15/attachments/attachment.zip)