`, qui est le nom de ressource Amazon (ARN) du bucket que vous avez créé précédemmentArgument 2= Le nom de votre Firehose (ce pilote utilise.) `firehose_to_s3_stream`Argument 3= Le nom de votre rôle IAM (ce pilote utilise`firehose_to_s3`.)python CreateFireHoseToS3.py firehose_to_s3_stream firehose_to_s3
Si le rôle IAM spécifié n'existe pas, le script créera un rôle d'assume avec une politique de relation de confiance, ainsi qu'une politique accordant une autorisation Amazon S3 suffisante. Pour des exemples de ces politiques, consultez la section *Informations supplémentaires*. | Architecte cloud, développeur d'applications |
| Vérifiez le flux de diffusion de Firehose. | Décrivez le flux de diffusion Firehose à l'aide de la CLI AWS pour vérifier que le flux de diffusion a bien été créé.aws firehose describe-delivery-stream --delivery-stream-name firehose_to_s3_stream
| Architecte cloud, développeur d'applications |
### Créez une fonction Lambda pour traiter le flux de diffusion Firehose
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez une politique de confiance pour la fonction Lambda. | Créez un fichier de politique de confiance contenant les informations suivantes. {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} Cela donne à votre fonction l'autorisation d'accéder aux ressources AWS. | Architecte cloud, développeur d'applications |
| Créez un rôle d'exécution pour la fonction Lambda. | Pour créer le rôle d'exécution, exécutez le code suivant.aws iam create-role --role-name lambda-ex --assume-role-policy-document file://TrustPolicy.json
| Architecte cloud, développeur d'applications |
| Ajoutez une autorisation au rôle. | Pour ajouter une autorisation au rôle, utilisez la `attach-policy-to-role` commande.aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaDynamoDBExecutionRole
aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/AmazonKinesisFirehoseFullAccess
aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/IAMFullAccess
| Architecte cloud, développeur d'applications |
| créer une fonction Lambda ; | Compressez le `LambdaStreamProcessor.py` fichier depuis le référentiel de code en exécutant la commande suivante.zip function.zip LambdaStreamProcessor.py
Lorsque vous créez la fonction Lambda, vous aurez besoin de l'ARN du rôle d'exécution Lambda. Pour obtenir l'ARN, exécutez le code suivant.aws iam get-role \
--role-name lambda-ex
Pour créer la fonction Lambda, exécutez le code suivant.# Review the environment variables and replace them with your values.
aws lambda create-function --function-name LambdaStreamProcessor \
--zip-file fileb://function.zip --handler LambdaStreamProcessor.handler --runtime python3.8 \
--role {Your Lamda Execution Role ARN}\
--environment Variables="{firehose_name=firehose_to_s3_stream,bucket_arn = ,iam_role_name = firehose_to_s3, batch_size=400}"
| Architecte cloud, développeur d'applications |
| Configurez le déclencheur de la fonction Lambda. | Utilisez l'AWS CLI pour configurer le déclencheur (DynamoDB Streams), qui appelle la fonction Lambda. La taille du lot de 400 permet d'éviter de rencontrer des problèmes de simultanéité Lambda.aws lambda create-event-source-mapping --function-name LambdaStreamProcessor \
--batch-size 400 --starting-position LATEST \
--event-source-arn
| Architecte cloud, développeur d'applications |
### Testez les fonctionnalités
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Ajoutez les articles dont l'horodatage a expiré au tableau des réservations. | Pour tester la fonctionnalité, ajoutez au tableau des éléments dont l'horodatage d'époque a expiré. `Reservation` TTL supprimera automatiquement les éléments en fonction de l'horodatage. La fonction Lambda est lancée lors des activités de DynamoDB Stream, et elle filtre l'événement pour identifier l'activité ou les éléments supprimés. `REMOVE` Il place ensuite les enregistrements dans le flux de diffusion Firehose au format batch.Le flux de livraison Firehose transfère les articles vers un compartiment S3 de destination avec le `firehosetos3example/year=current year/month=current month/ day=current day/hour=current hour/` préfixe.Pour optimiser la récupération des données, configurez Amazon S3 avec le `Prefix` et `ErrorOutputPrefix` qui est détaillé dans la section *Informations supplémentaires*. | Architecte du cloud |
### Nettoyez les ressources
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Supprimez toutes les ressources. | Supprimez toutes les ressources pour vous assurer que les services que vous n'utilisez pas ne vous seront pas facturés. | Architecte cloud, développeur d'applications |
## Ressources connexes
+ [Gestion du cycle de vie de votre stockage](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html)
+ [Classes de stockage Amazon S3](https://aws.amazon.com/s3/storage-classes/)
+ [Documentation du kit SDK AWS pour Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
## Informations supplémentaires
**Création et configuration d'un flux de diffusion Firehose — Exemples de politiques**
*Exemple de document de politique sur les relations de confiance Firehose*
```
firehose_assume_role = {
'Version': '2012-10-17',
'Statement': [
{
'Sid': '',
'Effect': 'Allow',
'Principal': {
'Service': 'firehose.amazonaws.com'
},
'Action': 'sts:AssumeRole'
}
]
}
```
*Exemple de politique d'autorisations S3*
```
s3_access = {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListBucketMultipartUploads",
"s3:PutObject"
],
"Resource": [
"{your s3_bucket ARN}/*",
"{Your s3 bucket ARN}"
]
}
]
}
```
**Tester la fonctionnalité — Configuration Amazon S3**
La configuration Amazon S3 avec les éléments suivants `Prefix` `ErrorOutputPrefix` est choisie pour optimiser la récupération des données.
*prefix*
```
firehosetos3example/year=! {timestamp: yyyy}/month=! {timestamp:MM}/day=! {timestamp:dd}/hour=!{timestamp:HH}/
```
Firehose crée d'abord un dossier de base appelé `firehosetos3example` directement sous le compartiment S3. Il évalue ensuite les expressions`!{timestamp:yyyy}`,`!{timestamp:MM}`, `!{timestamp:dd}` et `!{timestamp:HH}` en fonction de l'année, du mois, du jour et de l'heure en utilisant le [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)format Java.
Par exemple, un horodatage d'arrivée approximatif de 1604683577 dans Unix Epoch Time équivaut à,, et. `year=2020` `month=11` `day=06` `hour=05` Par conséquent, l'emplacement dans Amazon S3, où les enregistrements de données sont livrés, est évalué à`firehosetos3example/year=2020/month=11/day=06/hour=05/`.
*ErrorOutputPrefix*
```
firehosetos3erroroutputbase/!{firehose:random-string}/!{firehose:error-output-type}/!{timestamp:yyyy/MM/dd}/
```
Le `ErrorOutputPrefix` résultat est un dossier de base appelé `firehosetos3erroroutputbase` directement sous le compartiment S3. L'expression `!{firehose:random-string}` correspond à une chaîne aléatoire de 11 caractères telle que. `ztWxkdg3Thg` L'emplacement d'un objet Amazon S3 où les enregistrements défaillants sont livrés peut être évalué à`firehosetos3erroroutputbase/ztWxkdg3Thg/processing-failed/2020/11/06/`.
# Créez une architecture sans serveur multi-locataires dans Amazon Service OpenSearch
*Tabby Ward et Nisha Gambhir, Amazon Web Services*
## Résumé
Amazon OpenSearch Service est un service géré qui facilite le déploiement, l'exploitation et le dimensionnement d'Elasticsearch, un moteur de recherche et d'analyse open source populaire. OpenSearch Le service fournit une recherche en texte libre ainsi qu'une ingestion et un tableau de bord en temps quasi réel pour les données de streaming telles que les journaux et les métriques.
Les fournisseurs de logiciels en tant que service (SaaS) utilisent fréquemment le OpenSearch service pour répondre à un large éventail de cas d'utilisation, tels que l'obtention d'informations sur les clients de manière évolutive et sécurisée tout en réduisant la complexité et les temps d'arrêt.
L'utilisation OpenSearch du service dans un environnement mutualisé introduit une série de considérations qui affectent le partitionnement, l'isolation, le déploiement et la gestion de votre solution SaaS. Les fournisseurs de SaaS doivent réfléchir à la manière de faire évoluer efficacement leurs clusters Elasticsearch face à des charges de travail en constante évolution. Ils doivent également tenir compte de l'impact de la hiérarchisation et des conditions de voisinage bruyantes sur leur modèle de partitionnement.
Ce modèle passe en revue les modèles utilisés pour représenter et isoler les données des locataires à l'aide des constructions Elasticsearch. En outre, le modèle se concentre sur une architecture de référence sans serveur simple à titre d'exemple pour illustrer l'indexation et la recherche à l'aide de OpenSearch Service dans un environnement mutualisé. Il met en œuvre le modèle de partitionnement des données du pool, qui partage le même indice entre tous les locataires tout en préservant l'isolation des données d'un locataire. Ce modèle utilise les AWS services suivants : Amazon API Gateway AWS Lambda, Amazon Simple Storage Service (Amazon S3) et Service. OpenSearch
Pour plus d'informations sur le modèle de pool et les autres modèles de partitionnement des données, consultez la section [Informations supplémentaires](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional).
## Conditions préalables et limitations
**Conditions préalables**
+ Un actif Compte AWS
+ [AWS Command Line Interface (AWS CLI) version 2.x](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html), installée et configurée sur macOS, Linux ou Windows
+ [Version 3.9 de Python](https://www.python.org/downloads/release/python-3921/)
+ [pip3](https://pip.pypa.io/en/stable/) — Le code source Python est fourni sous forme de fichier .zip à déployer dans une fonction Lambda. Si vous souhaitez utiliser le code localement ou le personnaliser, procédez comme suit pour développer et recompiler le code source :
1. Générez le `requirements.txt` fichier en exécutant la commande suivante dans le même répertoire que les scripts Python : `pip3 freeze > requirements.txt`
1. Installez les dépendances : `pip3 install -r requirements.txt`
**Limites**
+ Ce code fonctionne en Python et ne prend actuellement pas en charge les autres langages de programmation.
+ L'exemple d'application n'inclut pas de support AWS interrégional ou de reprise après sinistre (DR).
+ Ce modèle est destiné à des fins de démonstration uniquement. Il n'est pas destiné à être utilisé dans un environnement de production.
## Architecture
Le schéma suivant illustre l'architecture de haut niveau de ce modèle. L'architecture inclut les éléments suivants :
+ Lambda pour indexer et interroger le contenu
+ OpenSearch Service pour effectuer une recherche
+ API Gateway pour fournir une interaction API avec l'utilisateur
+ Amazon S3 pour stocker des données brutes (non indexées)
+ Amazon CloudWatch va surveiller les journaux
+ Gestion des identités et des accès AWS (IAM) pour créer des rôles et des politiques de locataire
![\[Architecture sans serveur multi-locataires de haut niveau.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/1a8501e7-0776-4aca-aed3-28e3ada1d15d.png)
**Automatisation et mise à l'échelle**
Pour des raisons de simplicité, le modèle AWS CLI est utilisé pour provisionner l'infrastructure et déployer l'exemple de code. Vous pouvez créer un CloudFormation modèle ou AWS Cloud Development Kit (AWS CDK) des scripts pour automatiser le modèle.
## Outils
**Services AWS**
+ [AWS CLI](https://aws.amazon.com/cli/)est un outil unifié de gestion Services AWS et de gestion des ressources à l'aide de commandes dans votre interface de ligne de commande.
+ [Lambda](https://aws.amazon.com/lambda/) est un service de calcul qui vous permet d'exécuter du 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.
+ [API Gateway permet](https://aws.amazon.com/api-gateway/) de créer, Service AWS de publier, de maintenir, de surveiller et de sécuriser REST, HTTP, et ce, WebSocket APIs à n'importe quelle échelle.
+ [Amazon S3](https://aws.amazon.com/s3/) est un service de stockage d'objets qui vous permet de stocker et de récupérer n'importe quel volume d'informations à tout moment, où que vous soyez sur le Web.
+ OpenSearch Le [service](https://aws.amazon.com/opensearch-service/) est un service entièrement géré qui vous permet de déployer, de sécuriser et d'exécuter Elasticsearch facilement et de manière rentable à grande échelle.
**Code**
La pièce jointe fournit des fichiers d'exemple pour ce modèle. Il s’agit des licences suivantes :
+ `index_lambda_package.zip`— La fonction Lambda pour indexer les données dans OpenSearch Service à l'aide du modèle de pool.
+ `search_lambda_package.zip`— La fonction Lambda pour rechercher des données dans OpenSearch Service.
+ `Tenant-1-data`— Échantillon de données brutes (non indexées) pour Tenant-1.
+ `Tenant-2-data`— Échantillon de données brutes (non indexées) pour Tenant-2.
**Important**
Les articles de ce modèle incluent des exemples de AWS CLI commandes formatés pour Unix, Linux et macOS. Pour Windows, remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\$1), à la fin de chaque ligne par un accent circonflexe (^).
**Note**
Dans AWS CLI les commandes, remplacez toutes les valeurs entre crochets (<>) par les valeurs correctes.
## Épopées
### Création et configuration d'un compartiment S3
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez un compartiment S3. | Créez un compartiment S3 dans votre Région AWS. Ce compartiment contiendra les données du locataire non indexées pour l'exemple d'application. Assurez-vous que le nom du compartiment S3 est unique au monde, car l'espace de noms est partagé par tous Comptes AWS.Pour créer un compartiment S3, vous pouvez utiliser la commande AWS CLI [create-bucket](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-bucket.html) comme suit :aws s3api create-bucket \
--bucket \
--region
où `tenantrawdata` est le nom du compartiment S3. (Vous pouvez utiliser n'importe quel nom unique conforme [aux directives de dénomination des compartiments](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html).) | Architecte cloud, administrateur cloud |
### Création et configuration d'un cluster Elasticsearch
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez un domaine OpenSearch de service. | Exécutez la AWS CLI [create-elasticsearch-domain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/es/create-elasticsearch-domain.html)commande pour créer un domaine OpenSearch de service :aws es create-elasticsearch-domain \
--domain-name vpc-cli-example \
--elasticsearch-version 7.10 \
--elasticsearch-cluster-config InstanceType=t3.medium.elasticsearch,InstanceCount=1 \
--ebs-options EBSEnabled=true,VolumeType=gp2,VolumeSize=10 \
--domain-endpoint-options "{\"EnforceHTTPS\": true}" \
--encryption-at-rest-options "{\"Enabled\": true}" \
--node-to-node-encryption-options "{\"Enabled\": true}" \
--advanced-security-options "{\"Enabled\": true, \"InternalUserDatabaseEnabled\": true, \
\"MasterUserOptions\": {\"MasterUserName\": \"KibanaUser\", \
\"MasterUserPassword\": \"NewKibanaPassword@123\"}}" \
--vpc-options "{\"SubnetIds\": [\"\"], \"SecurityGroupIds\": [\"\"]}" \
--access-policies "{\"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \
\"Principal\": {\"AWS\": \"*\" }, \"Action\":\"es:*\", \
\"Resource\": \"arn:aws:es:::domain\/vpc-cli-example\/*\" } ] }"
Le nombre d'instances est défini sur 1 car le domaine est destiné à des fins de test. Vous devez activer le contrôle d'accès détaillé à l'aide du `advanced-security-options` paramètre, car les détails ne peuvent pas être modifiés une fois le domaine créé. Cette commande crée un nom d'utilisateur principal (`KibanaUser`) et un mot de passe que vous pouvez utiliser pour vous connecter à la console Kibana.Le domaine faisant partie d'un cloud privé virtuel (VPC), vous devez vous assurer que vous pouvez accéder à l'instance Elasticsearch en spécifiant la politique d'accès à utiliser.Pour plus d'informations, consultez la section [Lancement de vos domaines Amazon OpenSearch Service au sein d'un VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html) dans la AWS documentation. | Architecte cloud, administrateur cloud |
| Configurez un hôte bastion. | Configurez une instance Windows Amazon Elastic Compute Cloud (Amazon EC2) en tant qu'hôte bastion pour accéder à la console Kibana. Le groupe de sécurité Elasticsearch doit autoriser le trafic provenant du groupe de EC2 sécurité Amazon. Pour obtenir des instructions, consultez le billet de blog [Contrôler l'accès réseau aux EC2 instances à l'aide d'un serveur Bastion.](https://aws.amazon.com/blogs/security/controlling-network-access-to-ec2-instances-using-a-bastion-server/)Lorsque l'hôte bastion a été configuré et que le groupe de sécurité associé à l'instance est disponible, utilisez la AWS CLI [authorize-security-group-ingress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-ingress.html)commande pour ajouter l'autorisation au groupe de sécurité Elasticsearch afin d'autoriser le port 443 du groupe de sécurité Amazon EC2 (hôte bastion).aws ec2 authorize-security-group-ingress \
--group-id \
--protocol tcp \
--port 443 \
--source-group
| Architecte cloud, administrateur cloud |
### Création et configuration de la fonction d'index Lambda
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez le rôle d'exécution Lambda. | Exécutez la commande AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) pour accorder à la fonction d'index Lambda l'accès aux ressources et aux ressources : Services AWS aws iam create-role \
--role-name index-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
où se `lambda_assume_role.json` trouve un document JSON qui accorde des `AssumeRole` autorisations à la fonction Lambda, comme suit :{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Architecte cloud, administrateur cloud |
| Associez des politiques gérées au rôle Lambda. | Exécutez la AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)commande pour associer des politiques gérées au rôle créé à l'étape précédente. Ces deux politiques autorisent le rôle à créer une interface réseau élastique et à écrire des journaux dans CloudWatch Logs.aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole
| Architecte cloud, administrateur cloud |
| Créez une politique pour autoriser la fonction d'index Lambda à lire les objets S3. | Exécutez la commande AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) pour `s3:GetObject` autoriser la fonction d'index Lambda à lire les objets du compartiment S3 :aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3-policy.json
Le fichier `s3-policy.json` est un document JSON illustré ci-dessous qui accorde des `s3:GetObject` autorisations pour autoriser l'accès en lecture aux objets S3. Si vous avez utilisé un nom différent lors de la création du compartiment S3, indiquez le nom de compartiment correct dans la `Resource ` section :{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
} | Architecte cloud, administrateur cloud |
| Associez la politique d'autorisation Amazon S3 au rôle d'exécution Lambda. | Exécutez la AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)commande pour associer la politique d'autorisation Amazon S3 que vous avez créée à l'étape précédente au rôle d'exécution Lambda :aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn
où `PolicyARN` est le nom de ressource Amazon (ARN) de la politique d'autorisation Amazon S3. Vous pouvez obtenir cette valeur à partir de la sortie de la commande précédente. | Architecte cloud, administrateur cloud |
| Créez la fonction d'index Lambda. | Exécutez la commande AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) pour créer la fonction d'index Lambda, qui accèdera à Service : OpenSearch aws lambda create-function \
--function-name index-lambda-function \
--zip-file fileb://index_lambda_package.zip \
--handler lambda_index.lambda_handler \
--runtime python3.9 \
--role "arn:aws:iam::account-id:role/index-lambda-role" \
--timeout 30 \
--vpc-config "{\"SubnetIds\": [\"", \"\"], \
\"SecurityGroupIds\": [\"\"]}"
| Architecte cloud, administrateur cloud |
| Autorisez Amazon S3 à appeler la fonction d'index Lambda. | Exécutez la AWS CLI [commande add permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) pour autoriser Amazon S3 à appeler la fonction d'index Lambda :aws lambda add-permission \
--function-name index-lambda-function \
--statement-id s3-permissions \
--action lambda:InvokeFunction \
--principal s3.amazonaws.com \
--source-arn "arn:aws:s3:::" \
--source-account ""
| Architecte cloud, administrateur cloud |
| Ajoutez un déclencheur Lambda pour l'événement Amazon S3. | Exécutez la AWS CLI [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)commande pour envoyer des notifications à la fonction d'index Lambda lorsque l'`ObjectCreated`événement Amazon S3 est détecté. La fonction d'index s'exécute chaque fois qu'un objet est chargé dans le compartiment S3. aws s3api put-bucket-notification-configuration \
--bucket \
--notification-configuration file://s3-trigger.json
Le fichier `s3-trigger.json` est un document JSON dans le dossier actuel qui ajoute la politique de ressources à la fonction Lambda lorsque l'`ObjectCreated`événement Amazon S3 se produit. | Architecte cloud, administrateur cloud |
### Création et configuration de la fonction de recherche Lambda
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez le rôle d'exécution Lambda. | Exécutez la commande AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) pour autoriser la fonction de recherche Lambda à accéder aux ressources et aux ressources : Services AWS aws iam create-role \
--role-name search-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
où se `lambda_assume_role.json` trouve un document JSON dans le dossier actuel qui accorde des `AssumeRole` autorisations à la fonction Lambda, comme suit :{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Architecte cloud, administrateur cloud |
| Associez des politiques gérées au rôle Lambda. | Exécutez la AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)commande pour associer des politiques gérées au rôle créé à l'étape précédente. Ces deux politiques autorisent le rôle à créer une interface réseau élastique et à écrire des journaux dans CloudWatch Logs.aws iam attach-role-policy \
--role-name search-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam attach-role-policy \
--role-name search-lambda-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole
| Architecte cloud, administrateur cloud |
| Créez la fonction de recherche Lambda. | Exécutez la commande AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) pour créer la fonction de recherche Lambda, qui accèdera à Service : OpenSearch aws lambda create-function \
--function-name search-lambda-function \
--zip-file fileb://search_lambda_package.zip \
--handler lambda_search.lambda_handler \
--runtime python3.9 \
--role "arn:aws:iam::account-id:role/search-lambda-role" \
--timeout 30 \
--vpc-config "{\"SubnetIds\": [\"", \"\"], \
\"SecurityGroupIds\": [\"\"]}"
| Architecte cloud, administrateur cloud |
### Création et configuration des rôles de locataire
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez des rôles IAM pour les locataires. | Exécutez la commande AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) pour créer deux rôles de locataire qui seront utilisés pour tester la fonctionnalité de recherche :aws iam create-role \
--role-name Tenant-1-role \
--assume-role-policy-document file://assume-role-policy.json
aws iam create-role \
--role-name Tenant-2-role \
--assume-role-policy-document file://assume-role-policy.json
Le fichier `assume-role-policy.json` est un document JSON dans le dossier actuel qui accorde des `AssumeRole` autorisations au rôle d'exécution Lambda :{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "",
"AWS": ""
},
"Action": "sts:AssumeRole"
}
]
} | Architecte cloud, administrateur cloud |
| Créez une politique IAM pour les locataires. | Exécutez la commande AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) pour créer une politique de locataire qui accorde l'accès aux opérations d'Elasticsearch :aws iam create-policy \
--policy-name tenant-policy \
--policy-document file://policy.json
Le fichier `policy.json` est un document JSON situé dans le dossier actuel qui accorde des autorisations sur Elasticsearch :{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpDelete",
"es:ESHttpGet",
"es:ESHttpHead",
"es:ESHttpPost",
"es:ESHttpPut",
"es:ESHttpPatch"
],
"Resource": [
""
]
}
]
} | Architecte cloud, administrateur cloud |
| Associez la politique IAM du locataire aux rôles du locataire. | Exécutez la AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)commande pour associer la politique IAM du locataire aux deux rôles de locataire que vous avez créés à l'étape précédente :aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/tenant-policy \
--role-name Tenant-1-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/tenant-policy \
--role-name Tenant-2-role
L'ARN de la politique provient du résultat de l'étape précédente. | Architecte cloud, administrateur cloud |
| Créez une politique IAM pour autoriser Lambda à assumer ce rôle. | Exécutez la commande AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) pour créer une politique permettant à Lambda d'assumer le rôle de locataire :aws iam create-policy \
--policy-name assume-tenant-role-policy \
--policy-document file://lambda_policy.json
Le fichier `lambda_policy.json` est un document JSON dans le dossier actuel qui accorde des autorisations pour `AssumeRole` :{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": ""
}
]
}En `Resource` effet, vous pouvez utiliser un caractère générique pour éviter de créer une nouvelle politique pour chaque locataire. | Architecte cloud, administrateur cloud |
| Créez une politique IAM pour autoriser le rôle d'index Lambda à accéder à Amazon S3. | Exécutez la commande AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) pour autoriser le rôle d'index Lambda à accéder aux objets du compartiment S3 :aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3_lambda_policy.json
Le fichier `s3_lambda_policy.json` est le document de politique JSON suivant dans le dossier actuel :{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::tenantrawdata/*"
}
]
} | Architecte cloud, administrateur cloud |
| Attachez la politique au rôle d'exécution Lambda. | Exécutez la AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)commande pour associer la politique créée à l'étape précédente à l'index Lambda et aux rôles d'exécution de recherche que vous avez créés précédemment :aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \
--role-name index-lambda-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \
--role-name search-lambda-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/s3-permission-policy \
--role-name index-lambda-role
L'ARN de la politique provient du résultat de l'étape précédente. | Architecte cloud, administrateur cloud |
### Création et configuration d'une API de recherche
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez une API REST dans API Gateway. | Exécutez la AWS CLI [create-rest-api](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html)commande pour créer une ressource d'API REST :aws apigateway create-rest-api \
--name Test-Api \
--endpoint-configuration "{ \"types\": [\"REGIONAL\"] }"
Pour le type de configuration du point de terminaison, vous pouvez spécifier `EDGE` au lieu d'`REGIONAL`utiliser des emplacements périphériques au lieu d'un emplacement particulier Région AWS.Notez la valeur du `id` champ à partir de la sortie de commande. Il s'agit de l'ID d'API que vous utiliserez dans les commandes suivantes. | Architecte cloud, administrateur cloud |
| Créez une ressource pour l'API de recherche. | La ressource API de recherche lance la fonction de recherche Lambda avec le nom de la ressource. `search` (Il n'est pas nécessaire de créer une API pour la fonction d'index Lambda, car elle s'exécute automatiquement lorsque des objets sont chargés dans le compartiment S3.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Architecte cloud, administrateur cloud |
| Créez une méthode GET pour l'API de recherche. | Exécutez la commande AWS CLI [put-method](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html) pour créer une `GET ` méthode pour l'API de recherche :aws apigateway put-method \
--rest-api-id \
--resource-id \
--http-method GET \
--authorization-type "NONE" \
--no-api-key-required
Pour`resource-id`, spécifiez l'ID à partir de la sortie de la `create-resource` commande. | Architecte cloud, administrateur cloud |
| Créez une réponse de méthode pour l'API de recherche. | Exécutez la AWS CLI [put-method-response](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html)commande pour ajouter une réponse de méthode pour l'API de recherche :aws apigateway put-method-response \
--rest-api-id \
--resource-id \
--http-method GET \
--status-code 200 \
--response-models "{\"application/json\": \"Empty\"}"
Pour`resource-id`, spécifiez l'ID issu de la sortie de la `create-resource` commande précédente. | Architecte cloud, administrateur cloud |
| Configurez une intégration Lambda par proxy pour l'API de recherche. | Exécutez la commande AWS CLI [put-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html) pour configurer une intégration avec la fonction de recherche Lambda :aws apigateway put-integration \
--rest-api-id \
--resource-id \
--http-method GET \
--type AWS_PROXY \
--integration-http-method GET \
--uri arn:aws:apigateway:region:lambda:path/2015-03-31/functions/arn:aws:lambda:::function:/invocations
Pour`resource-id`, spécifiez l'ID de la `create-resource` commande précédente. | Architecte cloud, administrateur cloud |
| Accordez à API Gateway l'autorisation d'appeler la fonction de recherche Lambda. | Exécutez AWS CLI [la commande add permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) pour autoriser API Gateway à utiliser la fonction de recherche :aws lambda add-permission \
--function-name \
--statement-id apigateway-get \
--action lambda:InvokeFunction \
--principal apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:::api-id/*/GET/search
Modifiez le `source-arn` chemin si vous avez utilisé un autre nom de ressource d'API au lieu de`search`. | Architecte cloud, administrateur cloud |
| Déployez l'API de recherche. | Exécutez la commande AWS CLI [create-deployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html) pour créer une ressource de stage nommée : `dev`aws apigateway create-deployment \
--rest-api-id \
--stage-name dev
Si vous mettez à jour l'API, vous pouvez utiliser la même AWS CLI commande pour la redéployer au même stade. | Architecte cloud, administrateur cloud |
### Création et configuration des rôles Kibana
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Connectez-vous à la console Kibana. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Architecte cloud, administrateur cloud |
| Créez et configurez des rôles Kibana. | Pour isoler les données et empêcher un locataire de récupérer les données d'un autre locataire, vous devez utiliser la sécurité des documents, qui permet aux locataires d'accéder uniquement aux documents contenant leur identifiant de locataire.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Architecte cloud, administrateur cloud |
| Associez les utilisateurs aux rôles. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Nous vous recommandons d'automatiser la création des rôles de locataire et de Kibana au moment de l'intégration des locataires. | Architecte cloud, administrateur cloud |
| Créez l'index des données des locataires. | Dans le volet de navigation, sous **Gestion**, choisissez **Dev Tools**, puis exécutez la commande suivante. Cette commande crée l'`tenant-data`index pour définir le mappage de la `TenantId` propriété.PUT /tenant-data
{
"mappings": {
"properties": {
"TenantId": { "type": "keyword"}
}
}
}
| Architecte cloud, administrateur cloud |
### Créez des points de terminaison VPC pour Amazon S3 et AWS STS
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez un point de terminaison VPC pour Amazon S3. | Exécutez la AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)commande pour créer un point de terminaison VPC pour Amazon S3. Le point de terminaison permet à la fonction d'index Lambda du VPC d'accéder à Amazon S3.aws ec2 create-vpc-endpoint \
--vpc-id \
--service-name com.amazonaws.us-east-1.s3 \
--route-table-ids
Pour`vpc-id`, spécifiez le VPC que vous utilisez pour la fonction d'index Lambda. Pour`service-name`, utilisez l'URL correcte pour le point de terminaison Amazon S3. Pour`route-table-ids`, spécifiez la table de routage associée au point de terminaison du VPC. | Architecte cloud, administrateur cloud |
| Créez un point de terminaison VPC pour. AWS STS | Exécutez la AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)commande pour créer un point de terminaison VPC pour AWS Security Token Service ()AWS STS. Le point de terminaison permet d'accéder à l'index Lambda et aux fonctions de recherche du VPC. AWS STS Les fonctions sont utilisées AWS STS lorsqu'elles assument le rôle IAM.aws ec2 create-vpc-endpoint \
--vpc-id \
--vpc-endpoint-type Interface \
--service-name com.amazonaws.us-east-1.sts \
--subnet-id \
--security-group-id
Pour`vpc-id`, spécifiez le VPC que vous utilisez pour l'index Lambda et les fonctions de recherche. Pour`subnet-id`, indiquez le sous-réseau dans lequel ce point de terminaison doit être créé. Pour`security-group-id`, spécifiez le groupe de sécurité auquel associer ce point de terminaison. (Il peut s'agir du même groupe de sécurité que celui utilisé par Lambda.) | Architecte cloud, administrateur cloud |
### Testez la mutualisation et l'isolation des données
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Mettez à jour les fichiers Python pour les fonctions d'index et de recherche. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Vous pouvez obtenir le point de terminaison Elasticsearch depuis l'onglet **Vue d'ensemble** de la console de OpenSearch service. Il a le format`.es.amazonaws.com`. | Architecte cloud, développeur d'applications |
| Mettez à jour le code Lambda. | Utilisez la AWS CLI [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)commande pour mettre à jour le code Lambda avec les modifications que vous avez apportées aux fichiers Python :aws lambda update-function-code \
--function-name index-lambda-function \
--zip-file fileb://index_lambda_package.zip
aws lambda update-function-code \
--function-name search-lambda-function \
--zip-file fileb://search_lambda_package.zip
| Architecte cloud, développeur d'applications |
| Téléchargez les données brutes dans le compartiment S3. | Utilisez la commande AWS CLI [cp](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/cp.html) pour télécharger les données des objets Tenant-1 et Tenant-2 dans le `tenantrawdata` compartiment (spécifiez le nom du compartiment S3 que vous avez créé à cette fin) :aws s3 cp tenant-1-data s3://tenantrawdata
aws s3 cp tenant-2-data s3://tenantrawdata
Le compartiment S3 est configuré pour exécuter la fonction d'index Lambda chaque fois que des données sont téléchargées afin que le document soit indexé dans Elasticsearch. | Architecte cloud, administrateur cloud |
| Recherchez des données depuis la console Kibana. | Sur la console Kibana, exécutez la requête suivante :GET tenant-data/_search
Cette requête affiche tous les documents indexés dans Elasticsearch. Dans ce cas, vous devriez voir deux documents distincts pour le locataire 1 et le locataire 2. | Architecte cloud, administrateur cloud |
| Testez l'API de recherche depuis API Gateway. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Pour les illustrations d'écran, consultez la section [Informations supplémentaires](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional). | Architecte cloud, développeur d'applications |
| nettoyer les ressources. | Nettoyez toutes les ressources que vous avez créées pour éviter des frais supplémentaires sur votre compte. | AWS DevOps, architecte cloud, administrateur cloud |
## Ressources connexes
+ [AWS SDK pour Python (Boto)](https://aws.amazon.com/sdk-for-python/)
+ [AWS Lambda documentation](https://docs.aws.amazon.com/lambda/)
+ [Documentation d'API Gateway](https://docs.aws.amazon.com/apigateway/)
+ [Documentation Amazon S3](https://docs.aws.amazon.com/s3/)
+ [Documentation Amazon OpenSearch Service](https://docs.aws.amazon.com/elasticsearch-service/)
+ [Contrôle d'accès précis dans Amazon Service OpenSearch ](https://docs.amazonaws.cn/en_us/elasticsearch-service/latest/developerguide/fgac.html)
+ [Création d'une application de recherche avec Amazon OpenSearch Service](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/search-example.html)
+ [Lancement de vos domaines Amazon OpenSearch Service au sein d'un VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html)
## Informations supplémentaires
**Modèles de partitionnement des données**
Il existe trois modèles courants de partitionnement des données utilisés dans les systèmes à locataires multiples : silo, pool et hybride. Le modèle que vous choisissez dépend de la conformité, du voisinage bruyant, des opérations et des besoins d'isolation de votre environnement.
*Modèle de silo*
Dans le modèle de silo, les données de chaque locataire sont stockées dans une zone de stockage distincte où il n'y a aucun mélange des données des locataires. Vous pouvez utiliser deux approches pour implémenter le modèle de silo avec OpenSearch Service : domaine par locataire et index par locataire.
+ **Domaine par locataire** : vous pouvez utiliser un domaine de OpenSearch service distinct (synonyme d'un cluster Elasticsearch) par locataire. Le fait de placer chaque locataire dans son propre domaine offre tous les avantages associés au fait de disposer de données dans une structure autonome. Cependant, cette approche pose des défis en termes de gestion et d'agilité. En raison de sa nature distribuée, il est plus difficile d'agréger et d'évaluer la santé opérationnelle et l'activité des locataires. Il s'agit d'une option coûteuse qui nécessite que chaque domaine de OpenSearch service dispose au minimum de trois nœuds principaux et de deux nœuds de données pour les charges de travail de production.
![\[Modèle de silo domaine par locataire pour les architectures sans serveur multi-locataires.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2195f82-e5ed-40bb-b76a-3b0210bf1254.png)
+ **Index par locataire** : vous pouvez placer les données des locataires dans des index distincts au sein d'un cluster OpenSearch de services. Avec cette approche, vous utilisez un identifiant de locataire lorsque vous créez et nommez l'index, en ajoutant l'identifiant de locataire au nom de l'index. L'approche de l'indice par locataire vous aide à atteindre vos objectifs de silo sans introduire de cluster complètement distinct pour chaque locataire. Cependant, vous risquez de rencontrer une pression sur la mémoire si le nombre d'index augmente, car cette approche nécessite davantage de partitions et le nœud maître doit gérer davantage d'allocations et de rééquilibrage.
![\[Modèle de silo d'index par locataire pour les architectures sans serveur à locataires multiples.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/354a9463-25bb-422b-84de-d4875a7c8ea2.png)
**Isolation dans le modèle de silo** : dans le modèle de silo, vous utilisez des politiques IAM pour isoler les domaines ou les index contenant les données de chaque locataire. Ces politiques empêchent un locataire d'accéder aux données d'un autre locataire. Pour implémenter votre modèle d'isolation en silo, vous pouvez créer une politique basée sur les ressources qui contrôle l'accès à vos ressources locataires. Il s'agit souvent d'une politique d'accès au domaine qui spécifie les actions qu'un principal peut effectuer sur les sous-ressources du domaine, notamment les index Elasticsearch et. APIs Avec les politiques basées sur l'identité IAM, vous pouvez spécifier des actions *autorisées* ou *refusées* sur le domaine, les index ou au sein du Service. APIs OpenSearch L'`Action`élément d'une politique IAM décrit l'action ou les actions spécifiques autorisées ou refusées par la politique, et l'`Principal `élément spécifie les comptes, utilisateurs ou rôles concernés.
L'exemple de politique suivant accorde au Tenant-1 un accès complet (tel que spécifié par`es:*`) aux sous-ressources du domaine uniquement. `tenant-1` La fin de `/*` l'`Resource`élément indique que cette politique s'applique aux sous-ressources du domaine, et non au domaine lui-même. Lorsque cette politique est en vigueur, les locataires ne sont pas autorisés à créer un nouveau domaine ou à modifier les paramètres d'un domaine existant.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::user/Tenant-1"
},
"Action": "es:*",
"Resource": "arn:aws:es:::domain/tenant-1/*"
}
]
}
```
Pour implémenter le modèle de silo tenant par index, vous devez modifier cet exemple de politique afin de restreindre davantage le Tenant-1 à l'index ou aux index spécifiés, en spécifiant le nom de l'index. L'exemple de politique suivant limite Tenant-1 à l'index. `tenant-index-1`
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/Tenant-1"
},
"Action": "es:*",
"Resource": "arn:aws:es:::domain/test-domain/tenant-index-1/*"
}
]
}
```
*Modèle de piscine*
Dans le modèle de pool, toutes les données des locataires sont stockées dans un index au sein du même domaine. L'identifiant du locataire est inclus dans les données (document) et utilisé comme clé de partition. Vous pouvez ainsi déterminer quelles données appartiennent à quel locataire. Ce modèle réduit les frais de gestion. L'exploitation et la gestion de l'index groupé sont plus faciles et plus efficaces que la gestion de plusieurs index. Cependant, étant donné que les données des locataires sont mélangées au sein du même index, vous perdez l'isolation naturelle des locataires que fournit le modèle de silo. Cette approche peut également dégrader les performances en raison de l'effet de voisinage bruyant.
![\[Modèle de pool pour les architectures sans serveur à locataires multiples.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2c3bb0f-6ccd-47a7-ab67-e7f3f8c7f289.png)
**Isolation des locataires dans le modèle de piscine** — En général, l'isolation des locataires est difficile à mettre en œuvre dans le modèle de piscine. Le mécanisme IAM utilisé avec le modèle de silo ne vous permet pas de décrire l'isolation en fonction de l'ID de locataire enregistré dans votre document.
Une autre approche consiste à utiliser le support de [contrôle d'accès détaillé](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/fgac.html) (FGAC) fourni par Open Distro pour Elasticsearch. Le FGAC vous permet de contrôler les autorisations au niveau d'un index, d'un document ou d'un champ. À chaque demande, le FGAC évalue les informations d'identification de l'utilisateur et authentifie l'utilisateur ou refuse l'accès. Si le FGAC authentifie l'utilisateur, il récupère tous les rôles mappés à cet utilisateur et utilise l'ensemble complet des autorisations pour déterminer comment traiter la demande.
Pour obtenir l'isolation requise dans le modèle groupé, vous pouvez utiliser la [sécurité au niveau du document](https://opendistro.github.io/for-elasticsearch-docs/docs/security/access-control/document-level-security/), qui vous permet de restreindre un rôle à un sous-ensemble de documents d'un index. L'exemple de rôle suivant limite les requêtes au Tenant-1. En appliquant ce rôle au locataire 1, vous pouvez obtenir l'isolation nécessaire.
```
{
"bool": {
"must": {
"match": {
"tenantId": "Tenant-1"
}
}
}
}
```
*Modèle hybride*
Le modèle hybride utilise une combinaison des modèles de silo et de pool dans le même environnement pour offrir des expériences uniques à chaque niveau de locataire (tels que les niveaux gratuit, standard et premium). Chaque niveau suit le même profil de sécurité que celui utilisé dans le modèle de pool.
![\[Modèle hybride pour les architectures sans serveur à locataires multiples.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/e7def98a-38ef-435a-9881-7e95ae4d4940.png)
**Isolation des locataires dans le modèle hybride** — Dans le modèle hybride, vous suivez le même profil de sécurité que dans le modèle de pool, où l'utilisation du modèle de sécurité FGAC au niveau du document assurait l'isolation des locataires. Bien que cette stratégie simplifie la gestion des clusters et offre de l'agilité, elle complique d'autres aspects de l'architecture. Par exemple, votre code nécessite une complexité supplémentaire pour déterminer quel modèle est associé à chaque locataire. Vous devez également vous assurer que les requêtes à locataire unique ne saturent pas l'ensemble du domaine et ne dégradent pas l'expérience des autres locataires.
**Tests dans API Gateway**
*Fenêtre de test pour la requête Tenant-1*
![\[Fenêtre de test pour la requête Tenant-1.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/a6757d3f-977a-4ecc-90cb-83ab7f1c3588.png)
*Fenêtre de test pour la requête Tenant-2*
![\[Fenêtre de test pour la requête Tenant-2.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/31bfd656-33ca-4750-b6e6-da4d703c2071.png)
## Pièces jointes
[Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/750196bb-03f6-4b6e-92cd-eb7141602547/attachments/attachment.zip)
# Déployez des applications à piles multiples à l'aide d'AWS CDK avec TypeScript
*M. Rahul Sharad Gaikwad, Amazon Web Services*
## Résumé
Ce modèle fournit une step-by-step approche pour le déploiement d'applications sur Amazon Web Services (AWS) à l'aide d'AWS Cloud Development Kit (AWS CDK) avec TypeScript. À titre d'exemple, le modèle déploie une application d'analyse en temps réel sans serveur.
Le modèle crée et déploie des applications imbriquées. La CloudFormation pile AWS parent appelle les piles enfants, ou piles imbriquées. Chaque pile enfant crée et déploie les ressources AWS définies dans la CloudFormation pile. AWS CDK Toolkit, la commande d'interface de ligne de commande (CLI)`cdk`, est l'interface principale pour les CloudFormation piles.
## Conditions préalables et limitations
**Conditions préalables**
+ Un compte AWS actif
+ Cloud privé virtuel (VPC) et sous-réseaux existants
+ AWS CDK Toolkit installé et configuré
+ Utilisateur doté d'autorisations d'administrateur et d'un ensemble de clés d'accès.
+ Node.js
+ Interface de ligne de commande AWS (AWS CLI)
**Limites**
+ Comme AWS CDK utilise AWS CloudFormation, les applications AWS CDK sont soumises à des quotas de CloudFormation service. Pour plus d'informations, consultez la section [ CloudFormation Quotas AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
**Versions du produit**
Ce modèle a été créé et testé à l'aide des outils et versions suivants.
+ Boîte à outils AWS CDK 1.83.0
+ Node.js 14,13.0
+ npm 7,0,14
Le modèle doit fonctionner avec n'importe quelle version d'AWS CDK ou de npm. Notez que les versions 13.0.0 à 13.6.0 de Node.js ne sont pas compatibles avec le CDK AWS.
## Architecture
**Pile technologique cible**
+ Console AWS Amplify
+ Amazon API Gateway
+ AWS CDK
+ Amazon CloudFront
+ Amazon Cognito
+ Amazon DynamoDB
+ Amazon Data Firehose
+ Amazon Kinesis Data Streams
+ AWS Lambda
+ Amazon Simple Storage Service (Amazon S3)
**Architecture cible**
Le schéma suivant montre le déploiement d'applications à piles multiples à l'aide d'AWS CDK avec. TypeScript
![\[Architecture de pile dans le VPC, avec une pile parent et deux piles enfants contenant des ressources.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/8f92e86a-aa3d-4f8a-9b11-b92c52a7226c.png)
Le schéma suivant montre l'architecture de l'exemple d'application temps réel sans serveur.
![\[Architecture des applications dans la région.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/2df00faf-f871-4aec-9655-19ba2eb14cf8.png)
## Outils
**Outils**
+ La [console AWS Amplify](https://docs.aws.amazon.com/amplify/latest/userguide/welcome.html) est le centre de contrôle pour les déploiements complets d'applications Web et mobiles dans AWS. L'hébergement Amplify Console fournit un flux de travail basé sur Git pour héberger des applications Web sans serveur Fullstack avec un déploiement continu. L'interface utilisateur d'administration est une interface visuelle permettant aux développeurs Web et mobiles de créer et de gérer des backends d'applications en dehors de la console AWS.
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) est un service AWS permettant de créer, de publier, de gérer, de surveiller et de sécuriser REST, HTTP, et ce, WebSocket APIs à n'importe quelle échelle.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) est un framework de développement logiciel qui vous aide à définir et à provisionner l'infrastructure du cloud AWS sous forme de code.
+ [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/latest/guide/cli.html) est un kit de développement cloud en ligne de commande qui vous permet d'interagir avec votre application AWS CDK. La commande `cdk` CLI est le principal outil d'interaction avec votre application AWS CDK. Il exécute votre application, interroge le modèle d'application que vous avez défini et produit et déploie les CloudFormation modèles AWS générés par le CDK AWS.
+ [Amazon CloudFront](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) est un service Web qui accélère la distribution de contenus Web statiques et dynamiques, tels que les fichiers .html, .css, .js et les fichiers image. CloudFront diffuse votre contenu via un réseau mondial de centres de données appelés emplacements périphériques pour réduire la latence et améliorer les performances.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) fournit des fonctionnalités d'authentification, d'autorisation et de gestion des utilisateurs pour vos applications Web et mobiles. Vos utilisateurs peuvent se connecter directement ou par l'intermédiaire d'un tiers.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) 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 Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) est un service entièrement géré permettant de diffuser des [données de streaming](https://aws.amazon.com/streaming-data/) en temps réel vers des destinations telles qu'Amazon S3, Amazon Redshift, OpenSearch Amazon Service, Splunk et tout point de terminaison HTTP personnalisé ou appartenant à des fournisseurs de services tiers pris en charge.
+ [Amazon Kinesis Data](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) Streams est un service permettant de collecter et de traiter de grands flux d'enregistrements de données en temps réel.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) 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é.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données.
**Code**
Le code de ce modèle est joint.
## Épopées
### Installer le kit d'outils AWS CDK
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Installez le kit d'outils AWS CDK. | Pour installer AWS CDK Toolkit dans le monde entier, exécutez la commande suivante.`npm install -g aws-cdk` | DevOps |
| Vérifiez la version. | Pour vérifier la version d'AWS CDK Toolkit, exécutez la commande suivante. `cdk --version` | DevOps |
### Configurer les informations d'identification AWS
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Configurez les informations d'identification. | Pour configurer les informations d'identification, exécutez la `aws configure` commande et suivez les instructions.$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]: your_secret_access_key
Default region name [None]:
Default output format [None]:
| DevOps |
### Téléchargez le code du projet
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Téléchargez le code de projet ci-joint. | Pour plus d'informations sur le répertoire et la structure des fichiers, consultez la section *Informations supplémentaires*. | DevOps |
### Démarrez l'environnement AWS CDK
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Démarrez l'environnement. | Pour déployer le CloudFormation modèle AWS sur le compte et la région AWS que vous souhaitez utiliser, exécutez la commande suivante.`cdk bootstrap /`Pour plus d'informations, consultez la [documentation AWS](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html). | DevOps |
### Créez et déployez le projet
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Générez le projet. | Pour créer le code du projet, exécutez la `npm run build` commande. | DevOps |
| Déployez le projet. | Pour déployer le code du projet, exécutez la `cdk deploy` commande. | |
### Vérifier les sorties
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Vérifiez la création de la pile. | Sur la console de gestion AWS, choisissez **CloudFormation**. Dans les piles du projet, vérifiez qu'une pile parent et deux piles enfants ont été créées. | DevOps |
### Tester l'application
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Envoyez des données vers Kinesis Data Streams. | Configurez votre compte AWS pour envoyer des données à Kinesis Data Streams à l'aide d'Amazon Kinesis Data Generator (KDG). Pour plus d'informations, consultez [Amazon Kinesis Data](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) Generator. | DevOps |
| Créez un utilisateur Amazon Cognito. | [Pour créer un utilisateur Amazon Cognito, téléchargez le modèle cognito-setup.json depuis la section Créer un *utilisateur Amazon Cognito sur CloudFormation la page d'aide de Kinesis Data Generator*.](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) **Lancez le modèle, puis entrez votre nom d'**utilisateur** et votre mot de passe Amazon Cognito.**L'onglet **Sorties** répertorie l'URL du Kinesis Data Generator. | DevOps |
| Connectez-vous à Kinesis Data Generator | Pour vous connecter à KDG, utilisez les informations d'identification Amazon Cognito que vous avez fournies et l'URL du générateur de données Kinesis. | DevOps |
| Testez l'application. | Dans KDG, dans Modèle d'**enregistrement, Modèle** **1**, collez le code de test dans la section *Informations supplémentaires*, puis choisissez **Envoyer des données**. | DevOps |
| Testez API Gateway. | Une fois les données ingérées, testez API Gateway en utilisant la `GET` méthode de récupération des données. | DevOps |
## Ressources connexes
**Références**
+ [Kit de développement AWS Cloud](https://aws.amazon.com/cdk/)
+ [AWS CDK activé GitHub](https://github.com/aws/aws-cdk)
+ [Utilisation de piles imbriquées](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
+ [Exemple d'exemple AWS : analyse en temps réel sans serveur](https://github.com/aws-samples/serverless-realtime-analytics)
## Informations supplémentaires
**Détails du répertoire et du fichier**
Ce modèle définit les trois piles suivantes.
+ `parent-cdk-stack.ts`— Cette pile agit en tant que pile parent et appelle les deux applications enfants en tant que piles imbriquées.
+ `real-time-analytics-poc-stack.ts`— Cette pile imbriquée contient l'infrastructure et le code de l'application.
+ `real-time-analytics-web-stack.ts`— Cette pile imbriquée contient uniquement le code statique de l'application Web.
*Les fichiers importants et leurs fonctionnalités*
+ `bin/real-time-analytics-poc.ts`— Point d'entrée de l'application AWS CDK. Il charge toutes les piles définies `lib/` ci-dessous.
+ `lib/real-time-analytics-poc-stack.ts`— Définition de la pile de l'application AWS CDK (`real-time-analytics-poc`).
+ `lib/real-time-analytics-web-stack.ts`— Définition de la pile de l'application AWS CDK (`real-time-analytics-web-stack`).
+ `lib/parent-cdk-stack.ts`— Définition de la pile de l'application AWS CDK (`parent-cdk`).
+ `package.json`— le manifeste du module npm, qui inclut le nom, la version et les dépendances de l'application.
+ `package-lock.json`— Maintenu par npm.
+ `cdk.json`— Boîte à outils pour exécuter l'application.
+ `tsconfig.json`— La TypeScript configuration du projet.
+ `.gitignore`— Liste des fichiers que Git doit exclure du contrôle de source.
+ `node_modules`— Maintenu par npm ; inclut les dépendances du projet.
La section de code suivante de la pile parent appelle les applications enfants sous la forme de piles AWS CDK imbriquées.
```
import * as cdk from '@aws-cdk/core';
import { Construct, Stack, StackProps } from '@aws-cdk/core';
import { RealTimeAnalyticsPocStack } from './real-time-analytics-poc-stack';
import { RealTimeAnalyticsWebStack } from './real-time-analytics-web-stack';
export class CdkParentStack extends Stack {
constructor(scope: Construct, id: string, props?: StackProps) {
super(scope, id, props);
new RealTimeAnalyticsPocStack(this, 'RealTimeAnalyticsPocStack');
new RealTimeAnalyticsWebStack(this, 'RealTimeAnalyticsWebStack');
}
}
```
**Code pour les tests**
```
session={{date.now('YYYYMMDD')}}|sequence={{date.now('x')}}|reception={{date.now('x')}}|instrument={{random.number(9)}}|l={{random.number(20)}}|price_0={{random.number({"min":10000, "max":30000})}}|price_1={{random.number({"min":10000, "max":30000})}}|price_2={{random.number({"min":10000, "max":30000})}}|price_3={{random.number({"min":10000, "max":30000})}}|price_4={{random.number({"min":10000, "max":30000})}}|price_5={{random.number({"min":10000, "max":30000})}}|price_6={{random.number({"min":10000, "max":30000})}}|price_7={{random.number({"min":10000, "max":30000})}}|price_8={{random.number({"min":10000, "max":30000})}}|
```
**Test de l'API Gateway**
Sur la console API Gateway, testez API Gateway à l'aide de la `GET` méthode.
![\[Console API Gateway avec GET sélectionné sous OPTIONS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/452e5b8f-6d61-401d-8484-e5a436cb6f1b.png)
## Pièces jointes
[Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/0ac29a11-1362-4084-92ed-6b85205763ca/attachments/attachment.zip)
# Automatisez le déploiement d'applications imbriquées à l'aide d'AWS SAM
*Dr. Rahul Sharad Gaikwad, Ishwar Chauthaiwale, Dmitry Gulin et Tabby Ward, Amazon Web Services*
## Résumé
Sur Amazon Web Services (AWS), AWS Serverless Application Model (AWS SAM) est un framework open source qui fournit une syntaxe abrégée pour exprimer les fonctions APIs, les bases de données et les mappages de sources d'événements. Avec seulement quelques lignes pour chaque ressource, vous pouvez définir l'application que vous souhaitez et la modéliser à l'aide de YAML. Au cours du déploiement, SAM transforme et étend la syntaxe SAM en CloudFormation syntaxe AWS, que vous pouvez utiliser pour créer des applications sans serveur plus rapidement.
AWS SAM simplifie le développement, le déploiement et la gestion des applications sans serveur sur la plateforme AWS. Il fournit un cadre standardisé, un déploiement plus rapide, des capacités de test locales, une gestion des ressources, une intégration fluide avec les outils de développement et une communauté de soutien. Ces fonctionnalités en font un outil précieux pour créer des applications sans serveur de manière efficace.
Ce modèle utilise des modèles AWS SAM pour automatiser le déploiement d'applications imbriquées. Une application imbriquée est une application intégrée à une autre application. Les applications pour parents sont appelées applications pour enfants. Il s'agit de composants faiblement couplés d'une architecture sans serveur.
À l'aide d'applications imbriquées, vous pouvez créer rapidement des architectures sans serveur très sophistiquées en réutilisant des services ou des composants créés et gérés de manière indépendante, mais composés à l'aide d'AWS SAM et du Serverless Application Repository. Les applications imbriquées vous aident à créer des applications plus puissantes, à éviter les doublons et à garantir la cohérence et les meilleures pratiques au sein de vos équipes et organisations. Pour illustrer les applications imbriquées, le modèle déploie un exemple d'application de [panier d'achat sans serveur AWS](https://github.com/aws-samples/aws-sam-nested-stack-sample).
## Conditions préalables et limitations
**Conditions préalables**
+ Un compte AWS actif
+ Un cloud privé virtuel (VPC) et des sous-réseaux existants
+ Un environnement de développement intégré tel que Visual Studio Code (pour plus d'informations, voir [Outils pour créer sur AWS](https://aws.amazon.com/getting-started/tools-sdks/#IDE_and_IDE_Toolkits))
+ bibliothèque Python Wheel installée à l'aide de pip install wheel, si elle n'est pas déjà installée
**Limites**
+ Le nombre maximal d'applications pouvant être imbriquées dans une application sans serveur est de 200.
+ Le nombre maximum de paramètres pour une application imbriquée peut être de 60.
**Versions du produit**
+ Cette solution repose sur l'interface de ligne de commande AWS SAM (AWS SAM CLI) version 1.21.1, mais cette architecture devrait fonctionner avec les versions ultérieures de l'interface de ligne de commande AWS SAM.
## Architecture
**Pile technologique cible**
+ Amazon API Gateway
+ AWS SAM
+ Amazon Cognito
+ Amazon DynamoDB
+ AWS Lambda
+ File d'attente Amazon Simple Queue Service (Amazon SQS)
**Architecture cible**
Le schéma suivant montre comment les demandes des utilisateurs sont adressées aux services d'achat en appelant APIs. La demande de l'utilisateur, y compris toutes les informations nécessaires, est envoyée à Amazon API Gateway et à l'autorisateur Amazon Cognito, qui met en œuvre les mécanismes d'authentification et d'autorisation pour le. APIs
Lorsqu'un élément est ajouté, supprimé ou mis à jour dans DynamoDB, un événement est placé dans DynamoDB Streams, qui à son tour lance une fonction Lambda. Pour éviter la suppression immédiate d'anciens éléments dans le cadre d'un flux de travail synchrone, les messages sont placés dans une file d'attente SQS, qui lance une fonction de travail pour supprimer les messages.
![\[Opérations POST et PUT, depuis API Gateway jusqu'aux fonctions Lambda, en passant par DynamoDB et Product Service.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5b454bae-5fd4-405d-a37d-6bafc3fcf889.png)
Dans cette configuration de solution, l'interface de ligne de commande AWS SAM sert d'interface pour les CloudFormation piles AWS. Les modèles AWS SAM déploient automatiquement des applications imbriquées. Le modèle SAM parent appelle les modèles enfants, et la CloudFormation pile parent déploie les piles enfants. Chaque pile enfant crée les ressources AWS définies dans les CloudFormation modèles AWS SAM.
![\[Processus en quatre étapes utilisant la CLI AWS SAM avec une pile parent et trois CloudFormation piles enfants.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5828026e-72ad-4a3f-a5f2-bffac0f13e42.png)
1. Construisez et déployez les piles.
1. La CloudFormation pile Auth contient Amazon Cognito.
1. La CloudFormation pile de produits contient une fonction Lambda et Amazon API Gateway
1. La CloudFormation pile Shopping contient une fonction Lambda, Amazon API Gateway, la file d'attente SQS et la base de données Amazon DynamoDB.
## Outils
**Outils**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) vous aide à créer, publier, gérer, surveiller et sécuriser REST, HTTP, et ce, WebSocket APIs à n'importe quelle échelle.
+ [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) vous CloudFormation aide à configurer les ressources AWS, à les approvisionner rapidement et de manière cohérente, et à les gérer tout au long de leur cycle de vie sur l'ensemble des comptes et des régions AWS.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) fournit des fonctionnalités d'authentification, d'autorisation et de gestion des utilisateurs pour les applications Web et mobiles.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service de calcul qui vous permet d'exécuter du code sans avoir à provisionner ou à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez.
+ [AWS Serverless Application Model (AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)) est un framework open source qui vous aide à créer des applications sans serveur dans le cloud AWS.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fournit une file d'attente hébergée sécurisée, durable et disponible qui vous permet d'intégrer et de dissocier les systèmes et composants logiciels distribués.
**Code**
Le code de ce modèle est disponible dans le référentiel d'[échantillons GitHub AWS SAM Nested Stack](https://github.com/aws-samples/aws-sam-nested-stack-sample).
## Épopées
### Installation de l'interface de ligne de commande AWS SAM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Installez l'interface de ligne de commande AWS SAM. | Pour installer l'interface de ligne de commande AWS SAM, consultez les instructions de la [documentation AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). | DevOps ingénieur |
| Configurez les informations d'identification AWS. | Pour définir les informations d'identification AWS afin que l'interface de ligne de commande AWS SAM puisse appeler les services AWS en votre nom, exécutez la `aws configure` commande et suivez les instructions.$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]: your_secret_access_key
Default region name [None]:
Default output format [None]:
Pour plus d'informations sur la configuration de vos informations d'identification, consultez [Authentification et informations d'accès](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html). | DevOps ingénieur |
### Initialisation du projet AWS SAM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Clonez le référentiel de code AWS SAM. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingénieur |
| Déployez des modèles pour initialiser le projet. | Pour initialiser le projet, exécutez la `SAM init` commande. Lorsque vous êtes invité à choisir une source de modèle, choisissez`Custom Template Location`. | DevOps ingénieur |
### Compiler et créer le code du modèle SAM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Consultez les modèles d'applications AWS SAM. | Passez en revue les modèles pour les applications imbriquées. Cet exemple utilise les modèles d'application imbriqués suivants :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingénieur |
| Passez en revue le modèle parent. | Passez en revue le modèle qui invoquera les modèles d'applications imbriqués. Dans cet exemple, le modèle parent est`template.yml`. Toutes les applications distinctes sont imbriquées dans le modèle `template.yml` parent unique. | DevOps ingénieur |
| Compilez et générez le code du modèle AWS SAM. | À l'aide de l'interface de ligne de commande AWS SAM, exécutez la commande suivante.sam build
| DevOps ingénieur |
### Déployer le modèle AWS SAM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Déployez les applications. | Pour lancer le modèle de code SAM qui crée les CloudFormation piles d'applications imbriquées et déploie le code dans l'environnement AWS, exécutez la commande suivante.sam deploy --guided --stack-name shopping-cart-nested-stack --capabilities CAPABILITY_IAM CAPABILITY_AUTO_EXPAND
La commande posera quelques questions. Répondez à toutes les questions avec`y`. | DevOps ingénieur |
### Vérification du déploiement
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Vérifiez les piles. | Pour consulter les CloudFormation piles AWS et les ressources AWS définies dans les modèles AWS SAM, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingénieur |
## Ressources connexes
**Références**
+ [Modèle d'application sans serveur AWS (AWS SAM)](https://aws.amazon.com/serverless/sam/#:~:text=The%20AWS%20Serverless%20Application%20Model,and%20model%20it%20using%20YAML.)
+ [AWS SAM activé GitHub](https://github.com/aws/serverless-application-model)
+ [Microservice de panier d'achat sans serveur](https://github.com/aws-samples/aws-serverless-shopping-cart) (exemple d'application AWS)
**Tutoriels et vidéos**
+ [Créez une application sans serveur](https://youtu.be/Hv3YrP8G4ag)
+ [Discussions techniques en ligne sur AWS : création et déploiement d'applications sans serveur avec AWS SAM](https://youtu.be/1NU7vyJw9LU)
## Informations supplémentaires
Une fois que tout le code est en place, l'exemple présente la structure de répertoire suivante :
+ [sam\$1stacks](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html) — Ce dossier contient la couche. `shared.py` Une couche est une archive de fichiers contenant des bibliothèques, un environnement d'exécution personnalisé ou d'autres dépendances. Avec les couches, vous pouvez utiliser des bibliothèques dans votre fonction sans avoir à les inclure dans un package de déploiement.
+ *product-mock-service*— Ce dossier contient toutes les fonctions et tous les fichiers Lambda relatifs au produit.
+ *shopping-cart-service*— Ce dossier contient toutes les fonctions et tous les fichiers Lambda liés au shopping.
# Mettez en œuvre l'isolation des locataires SaaS pour Amazon S3 à l'aide d'un distributeur automatique de AWS Lambda jetons
*Tabby Ward, Thomas Davis et Sravan Periyathambi, Amazon Web Services*
## Résumé
Les applications SaaS mutualisées doivent mettre en œuvre des systèmes garantissant le maintien de l'isolement des locataires. Lorsque vous stockez des données de locataires sur la même AWS ressource, par exemple lorsque plusieurs locataires stockent des données dans le même compartiment Amazon Simple Storage Service (Amazon S3), vous devez vous assurer qu'aucun accès entre locataires ne peut avoir lieu. Les distributeurs automatiques de jetons (TVMs) constituent un moyen d'isoler les données des locataires. Ces machines fournissent un mécanisme permettant d'obtenir des jetons tout en faisant abstraction de la complexité de la façon dont ces jetons sont générés. Les développeurs peuvent utiliser un TVM sans avoir une connaissance détaillée de la façon dont il produit des jetons.
Ce modèle implémente un TVM en utilisant AWS Lambda. Le TVM génère un jeton composé d'informations d'identification temporaires du service de jetons de sécurité (STS) qui limitent l'accès aux données d'un seul locataire SaaS dans un compartiment S3.
TVMs, et le code fourni avec ce modèle, sont généralement utilisés avec des revendications dérivées de JSON Web Tokens (JWTs) pour associer les demandes de AWS ressources à une politique IAM Gestion des identités et des accès AWS (tenant-scoped). Vous pouvez utiliser le code de ce modèle comme base pour implémenter une application SaaS qui génère des informations d'identification STS temporaires et étendues sur la base des revendications fournies dans un jeton JWT.
## Conditions préalables et limitations
**Conditions préalables**
+ Un actif Compte AWS.
+ AWS Command Line Interface (AWS CLI) [version 1.19.0 ou ultérieure](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html), installée et configurée sur macOS, Linux ou Windows. Vous pouvez également utiliser AWS CLI [la version 2.1 ou ultérieure](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
**Limites**
+ Ce code fonctionne en Java et ne prend actuellement pas en charge les autres langages de programmation.
+ L'exemple d'application n'inclut pas de support AWS interrégional ou de reprise après sinistre (DR).
+ Ce modèle montre comment un Lambda TVM pour une application SaaS peut fournir un accès étendu aux locataires. Ce modèle n'est pas destiné à être utilisé dans des environnements de production sans tests de sécurité supplémentaires dans le cadre de votre application ou de votre cas d'utilisation spécifique.
## Architecture
**Pile technologique cible**
+ AWS Lambda
+ Amazon S3
+ IAM
+ AWS Security Token Service (AWS STS)
**Architecture cible**
![\[Génération d'un jeton pour obtenir des informations d'identification STS temporaires afin d'accéder aux données d'un compartiment S3.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/14d0508a-703b-4229-85e6-c5094de7fe01.png)
## Outils
**Services AWS**
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) est un outil open source qui vous permet d'interagir Services AWS par le biais de commandes dans votre interface de ligne de commande.
+ [Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos AWS ressources en contrôlant qui est authentifié et autorisé à les utiliser.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service de calcul qui vous aide à exécuter du code sans avoir à allouer ni à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez.
+ [AWS Security Token Service (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) vous permet de demander des informations d'identification temporaires à privilèges limités pour les utilisateurs.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données.
**Code**
Le code source de ce modèle est disponible sous forme de pièce jointe et inclut les fichiers suivants :
+ `s3UploadSample.jar`fournit le code source d'une fonction Lambda qui télécharge un document JSON dans un compartiment S3.
+ `tvm-layer.zip`fournit une bibliothèque Java réutilisable qui fournit un jeton (informations d'identification temporaires STS) permettant à la fonction Lambda d'accéder au compartiment S3 et de télécharger le document JSON.
+ `token-vending-machine-sample-app.zip`fournit le code source utilisé pour créer ces artefacts et les instructions de compilation.
Pour utiliser ces fichiers, suivez les instructions de la section suivante.
## Épopées
### Déterminer les valeurs des variables
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Déterminez les valeurs des variables. | L'implémentation de ce modèle inclut plusieurs noms de variables qui doivent être utilisés de manière cohérente. Déterminez les valeurs qui doivent être utilisées pour chaque variable et fournissez cette valeur lorsque cela est demandé lors des étapes suivantes.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine.html) | Administrateur du cloud |
### Création d’un compartiment S3
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez un compartiment S3 pour l'exemple d'application. | Utilisez la AWS CLI commande suivante pour créer un compartiment S3. Indiquez la ``**** valeur dans l'extrait de code :aws s3api create-bucket --bucket
L'exemple d'application Lambda télécharge des fichiers JSON dans ce compartiment. | Administrateur du cloud |
### Création du rôle et de la politique IAM TVM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez un rôle TVM. | Utilisez l'une des AWS CLI commandes suivantes pour créer un rôle IAM. Entrez la ``**** valeur dans la commande.Pour les shells macOS ou Linux :aws iam create-role \
--role-name \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Principal": {
"Service": [
"lambda.amazonaws.com"
]
},
"Condition": {
"StringEquals": {
"aws:SourceAccount": ""
}
}
}
]
}'
Pour la ligne de commande Windows :aws iam create-role ^
--role-name ^
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": [\"sts:AssumeRole\"], \"Principal\": {\"Service\": [\"lambda.amazonaws.com\"]}, \"Condition\": {\"StringEquals\": {\"aws:SourceAccount\": \"\"}}}]}"
L'exemple d'application Lambda assume ce rôle lorsqu'elle est invoquée. La possibilité d'assumer le rôle d'application avec une politique étendue donne au code des autorisations plus étendues pour accéder au compartiment S3. | Administrateur du cloud |
| Créez une politique de rôle TVM intégrée. | Utilisez l'une des AWS CLI commandes suivantes pour créer une politique IAM. Indiquez les `` valeurs `` **``**, et dans la commande.Pour les shells macOS ou Linux :aws iam put-role-policy \
--role-name \
--policy-name assume-app-role \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam:::role/"
}
]}'
Pour la ligne de commande Windows :aws iam put-role-policy ^
--role-name ^
--policy-name assume-app-role ^
--policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": \"sts:AssumeRole\", \"Resource\": \"arn:aws:iam:::role/\"}]}"
Cette politique est liée au rôle TVM. Cela donne au code la capacité d'assumer le rôle d'application, qui dispose d'autorisations plus larges pour accéder au compartiment S3. | Administrateur du cloud |
| Joignez la politique Lambda gérée. | Utilisez la AWS CLI commande suivante pour joindre la politique `AWSLambdaBasicExecutionRole` IAM. Entrez la `` valeur dans la commande :aws iam attach-role-policy \
--role-name \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Pour la ligne de commande Windows :aws iam attach-role-policy ^
--role-name ^
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Cette politique gérée est associée au rôle TVM pour permettre à Lambda d'envoyer des journaux à Amazon. CloudWatch | Administrateur du cloud |
### Création du rôle et de la politique de l'application IAM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez le rôle d'application. | Utilisez l'une des AWS CLI commandes suivantes pour créer un rôle IAM. Indiquez les `` valeurs ````, et dans la commande.Pour les shells macOS ou Linux :aws iam create-role \
--role-name \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect":
"Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/"
},
"Action": "sts:AssumeRole"
}
]}'
Pour la ligne de commande Windows :aws iam create-role ^
--role-name ^
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\",\"Principal\": {\"AWS\": \"arn:aws:iam:::role/\"},\"Action\": \"sts:AssumeRole\"}]}"
L'exemple d'application Lambda assume ce rôle avec une politique définie pour obtenir un accès basé sur le locataire à un compartiment S3. | Administrateur du cloud |
| Créez une politique de rôle d'application en ligne. | Utilisez l'une des commandes suivantes AWS CLI pour créer une politique IAM. Indiquez les ``**** valeurs `` et dans la commande.Pour les shells macOS ou Linux :aws iam put-role-policy \
--role-name \
--policy-name s3-bucket-access \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": "arn:aws:s3:::/*"
},
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": "arn:aws:s3:::"
}
]}'
Pour la ligne de commande Windows :aws iam put-role-policy ^
--role-name ^
--policy-name s3-bucket-access ^
--policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": [\"s3:PutObject\", \"s3:GetObject\", \"s3:DeleteObject\"], \"Resource\": \"arn:aws:s3:::/*\"}, {\"Effect\": \"Allow\", \"Action\": [\"s3:ListBucket\"], \"Resource\": \"arn:aws:s3:::\"}]}"
Cette politique est associée au rôle d'application. Il fournit un accès étendu aux objets du compartiment S3. Lorsque l'exemple d'application assume le rôle, ces autorisations sont étendues à un locataire spécifique avec la politique générée dynamiquement par le TVM. | Administrateur du cloud |
### Création de l'exemple d'application Lambda avec TVM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Téléchargez les fichiers source compilés. | Téléchargez les `tvm-layer.zip`**** fichiers `s3UploadSample.jar` et, qui sont inclus sous forme de pièces jointes. Le code source utilisé pour créer ces artefacts et les instructions de compilation sont fournis dans. `token-vending-machine-sample-app.zip` | Administrateur du cloud |
| Créez la couche Lambda. | Utilisez la AWS CLI commande suivante pour créer une couche Lambda, qui rend le TVM accessible à Lambda. Si vous n'exécutez pas cette commande depuis l'emplacement où vous l'avez téléchargée` tvm-layer.zip`, indiquez le chemin d'accès correct `tvm-layer.zip` dans le `--zip-file` paramètre. aws lambda publish-layer-version \
--layer-name sample-token-vending-machine \
--compatible-runtimes java11 \
--zip-file fileb://tvm-layer.zip
Pour la ligne de commande Windows :aws lambda publish-layer-version ^
--layer-name sample-token-vending-machine ^
--compatible-runtimes java11 ^
--zip-file fileb://tvm-layer.zip
Cette commande crée une couche Lambda qui contient la bibliothèque TVM réutilisable. | Administrateur cloud, développeur d'applications |
| Créez la fonction Lambda. | Utilisez la AWS CLI commande suivante pour créer une fonction Lambda. Indiquez les `` valeurs ````,``, ````,, et dans la commande. Si vous n'exécutez pas cette commande depuis l'emplacement où vous l'avez téléchargée`s3UploadSample.jar`, indiquez le chemin d'accès correct `s3UploadSample.jar` dans le `--zip-file` paramètre. aws lambda create-function \
--function-name \
--timeout 30 \
--memory-size 256 \
--runtime java11 \
--role arn:aws:iam:::role/ \
--handler com.amazon.aws.s3UploadSample.App \
--zip-file fileb://s3UploadSample.jar \
--layers arn:aws:lambda:::layer:sample-token-vending-machine:1 \
--environment "Variables={S3_BUCKET=,
ROLE=arn:aws:iam:::role/}"
Pour la ligne de commande Windows :aws lambda create-function ^
--function-name ^
--timeout 30 ^
--memory-size 256 ^
--runtime java11 ^
--role arn:aws:iam:::role/ ^
--handler com.amazon.aws.s3UploadSample.App ^
--zip-file fileb://s3UploadSample.jar ^
--layers arn:aws:lambda:::layer:sample-token-vending-machine:1 ^
--environment "Variables={S3_BUCKET=,ROLE=arn:aws:iam:::role/}"
Cette commande crée une fonction Lambda avec l'exemple de code d'application et la couche TVM attachés. Il définit également deux variables d'environnement : `S3_BUCKET` et`ROLE`. L'exemple d'application utilise ces variables pour déterminer le rôle à assumer et le compartiment S3 dans lequel télécharger les documents JSON. | Administrateur cloud, développeur d'applications |
### Testez l'exemple d'application et le TVM
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Appelez l'exemple d'application Lambda. | Utilisez l'une des AWS CLI commandes suivantes pour démarrer l'exemple d'application Lambda avec la charge utile attendue. Indiquez les `` valeurs `` et dans la commande.Pour les shells macOS et Linux :aws lambda invoke \
--function \
--invocation-type RequestResponse \
--payload '{"tenant": ""}' \
--cli-binary-format raw-in-base64-out response.json
Pour la ligne de commande Windows :aws lambda invoke ^
--function ^
--invocation-type RequestResponse ^
--payload "{\"tenant\": \"\"}" ^
--cli-binary-format raw-in-base64-out response.json
Cette commande appelle la fonction Lambda et renvoie le résultat dans un `response.json` document. Sur de nombreux systèmes basés sur Unix, vous pouvez passer `response.json` `/dev/stdout` à pour afficher les résultats directement dans votre shell sans créer un autre fichier. La modification de la `` valeur lors des appels ultérieurs de cette fonction Lambda modifie l'emplacement du document JSON et les autorisations fournies par le jeton. | Administrateur cloud, développeur d'applications |
| Consultez le compartiment S3 pour voir les objets créés. | Accédez au compartiment S3 (``) que vous avez créé précédemment. Ce compartiment contient un préfixe d'objet S3 dont la valeur est. `` Sous ce préfixe, vous trouverez un document JSON nommé avec un UUID. Le fait d'invoquer plusieurs fois l'exemple d'application permet d'ajouter d'autres documents JSON. | Administrateur du cloud |
| Consultez les journaux de l'exemple d'application dans CloudWatch Logs. | Affichez les journaux associés à la fonction Lambda nommée `` dans CloudWatch Logs. Pour obtenir des instructions, consultez la section [Envoi des journaux de fonctions Lambda vers CloudWatch Logs](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html) dans la documentation Lambda. Vous pouvez consulter la politique définie par le locataire générée par le TVM dans ces journaux. Cette politique limitée au locataire donne des autorisations pour l'exemple d'application à Amazon S3 **PutObject**,, **GetObject**, et **DeleteObject**ListBucket**** APIs, mais uniquement pour le préfixe d'objet associé à. `` Lors des appels ultérieurs de l'exemple d'application, si vous modifiez``, le TVM met à jour la politique étendue pour qu'elle corresponde au locataire indiqué dans la charge utile d'invocation. Cette politique générée dynamiquement montre comment l'accès limité au locataire peut être maintenu avec un TVM dans les applications SaaS. La fonctionnalité TVM est fournie dans une couche Lambda afin qu'elle puisse être associée à d'autres fonctions Lambda utilisées par une application sans avoir à répliquer le code.Pour une illustration de la politique générée dynamiquement, consultez la section [Informations supplémentaires](#implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine-additional). | Administrateur du cloud |
## Ressources connexes
+ [Isolation des locataires grâce à des politiques IAM générées dynamiquement](https://aws.amazon.com/blogs/apn/isolating-saas-tenants-with-dynamically-generated-iam-policies/) (article de blog)
+ [Appliquer des politiques d'isolation générées dynamiquement dans les environnements SaaS](https://aws.amazon.com/blogs/apn/applying-dynamically-generated-isolation-policies-in-saas-environments/) (article de blog)
+ [SaaS activé AWS](https://aws.amazon.com/saas/)
## Informations supplémentaires
Le journal suivant montre la politique générée dynamiquement produite par le code TVM selon ce modèle. Dans cette capture d'écran, le `` est `DOC-EXAMPLE-BUCKET` et le `` est`test-tenant-1`. Les informations d'identification STS renvoyées par cette politique étendue ne peuvent effectuer aucune action sur les objets du compartiment S3, à l'exception des objets associés au préfixe de clé `test-tenant-1` d'objet.
![\[Journal montrant une politique générée dynamiquement par le code TVM.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/d4776ebe-fb8f-41ac-b8c5-b4f97a821c8c.png)
## Pièces jointes
[Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/97a34c8e-d04e-40b6-acbf-1baa176d22a9/attachments/attachment.zip)
# Implémentez le modèle de saga sans serveur à l'aide d'AWS Step Functions
*Tabby Ward, Joe Kern et Rohan Mehta, Amazon Web Services*
## Résumé
Dans une architecture de microservices, l'objectif principal est de créer des composants découplés et indépendants afin de promouvoir l'agilité, la flexibilité et d'accélérer la mise sur le marché de vos applications. Grâce au découplage, chaque composant de microservice possède sa propre couche de persistance des données. Dans une architecture distribuée, les transactions commerciales peuvent couvrir plusieurs microservices. Comme ces microservices ne peuvent pas utiliser une seule transaction ACID (atomicité, cohérence, isolation, durabilité), vous risquez de vous retrouver avec des transactions partielles. Dans ce cas, une certaine logique de contrôle est nécessaire pour annuler les transactions déjà traitées. Le modèle de saga distribué est généralement utilisé à cette fin.
Le modèle saga est un modèle de gestion des défaillances qui permet d'établir la cohérence dans les applications distribuées et de coordonner les transactions entre plusieurs microservices afin de maintenir la cohérence des données. Lorsque vous utilisez le modèle saga, chaque service qui effectue une transaction publie un événement qui déclenche les services suivants pour effectuer la transaction suivante de la chaîne. Cela continue jusqu'à ce que la dernière transaction de la chaîne soit terminée. Si une transaction commerciale échoue, Saga orchestre une série de transactions compensatoires qui annulent les modifications apportées par les transactions précédentes.
Ce modèle montre comment automatiser la configuration et le déploiement d'un exemple d'application (qui gère les réservations de voyages) à l'aide de technologies sans serveur telles qu'AWS Step Functions, AWS Lambda et Amazon DynamoDB. L'exemple d'application utilise également Amazon API Gateway et Amazon Simple Notification Service (Amazon SNS) pour implémenter un coordinateur d'exécution de saga. Le modèle peut être déployé avec un framework d'infrastructure en tant que code (IaC) tel que l'AWS Cloud Development Kit (AWS CDK), l'AWS Serverless Application Model (AWS Serverless Application Model) (AWS SAM) ou Terraform.
## Conditions préalables et limitations
**Conditions préalables**
+ Un compte AWS actif.
+ Autorisations pour créer une CloudFormation pile AWS. Pour plus d'informations, consultez la section [Contrôle de l'accès](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) dans la CloudFormation documentation.
+ Framework IaC de votre choix (AWS CDK, AWS SAM ou Terraform) configuré avec votre compte AWS afin que vous puissiez utiliser la CLI du framework pour déployer l'application.
+ NodeJS, utilisé pour créer l'application et l'exécuter localement.
+ Un éditeur de code de votre choix (tel que Visual Studio Code, Sublime ou Atom).
**Versions du produit**
+ [NodeJS version 14](https://nodejs.org/en/download/)
+ [Version 2.37.1 du kit de développement logiciel AWS](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install)
+ [Version 1.71.0 d'AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
+ [Terraform version 1.3.7](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)
**Limites**
Le sourcing d'événements est un moyen naturel d'implémenter le modèle d'orchestration de la saga dans une architecture de microservices où tous les composants sont faiblement couplés et ne se connaissent pas directement les uns les autres. Si votre transaction comporte un petit nombre d'étapes (trois à cinq), le modèle de la saga pourrait convenir parfaitement. Cependant, la complexité augmente avec le nombre de microservices et le nombre d'étapes.
Les tests et le débogage peuvent devenir difficiles lorsque vous utilisez cette conception, car tous les services doivent être exécutés pour simuler le modèle de transaction.
## Architecture
**Architecture cible**
L'architecture proposée utilise AWS Step Functions pour créer un modèle de saga permettant de réserver des vols, de réserver des locations de voitures et de traiter les paiements pour les vacances.
Le schéma de flux de travail suivant illustre le flux typique du système de réservation de voyages. Le flux de travail consiste à réserver un voyage en avion (» ReserveFlight «), à réserver une voiture (» ReserveCarRental «), à traiter les paiements (» ProcessPayment «), à confirmer les réservations de vol (» ConfirmFlight «) et à confirmer la location de voiture (» ConfirmCarRental «), suivis d'une notification de réussite lorsque ces étapes sont terminées. Cependant, si le système rencontre des erreurs lors de l'exécution de l'une de ces transactions, il commence à échouer en arrière. Par exemple, une erreur dans le traitement du paiement (» ProcessPayment «) déclenche un remboursement (» RefundPayment «), qui déclenche ensuite l'annulation de la voiture de location et du vol (» » et CancelRentalReservation « CancelFlightReservation «), mettant fin à l'ensemble de la transaction avec un message d'échec.
Ce modèle déploie des fonctions Lambda distinctes pour chaque tâche mise en évidence dans le diagramme, ainsi que trois tables DynamoDB pour les vols, les locations de voitures et les paiements. Chaque fonction Lambda crée, met à jour ou supprime les lignes des tables DynamoDB respectives, selon qu'une transaction est confirmée ou annulée. Le modèle utilise Amazon SNS pour envoyer des messages texte (SMS) aux abonnés, les informant de l'échec ou de la réussite des transactions.
![\[Flux de travail pour un système de réservation de voyages basé sur le modèle de la saga.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/daad3e8e-6e6b-41c2-95c1-ca79d53ead64.png)
**Automatisation et évolutivité**
Vous pouvez créer la configuration de cette architecture en utilisant l'un des frameworks IaC. Utilisez l'un des liens suivants pour accéder à votre iAc préféré.
+ [Déployez avec AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Déploiement avec AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Déployez avec Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
## Outils
**Services AWS**
+ [AWS Step Functions](https://aws.amazon.com/step-functions/) est un service d'orchestration sans serveur qui vous permet de combiner les fonctions AWS Lambda et d'autres services AWS pour créer des applications critiques pour l'entreprise. La console graphique Step Functions vous permet de voir le flux de travail de votre application comme une série d'étapes pilotées par des événements.
+ [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) est un service de base de données NoSQL entièrement géré qui fournit des performances rapides et prévisibles avec une évolutivité sans faille. Vous pouvez utiliser DynamoDB pour créer une table de base de données capable de stocker et de récupérer n'importe quelle quantité de données, ainsi que de traiter n'importe quel niveau de trafic des demandes.
+ [AWS Lambda](https://aws.amazon.com/lambda/) est un service de calcul qui vous permet d'exécuter du 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.
+ [Amazon API Gateway](https://aws.amazon.com/api-gateway/) est un service AWS permettant de créer, de publier, de gérer, de surveiller et de sécuriser REST, HTTP, et ce, WebSocket APIs à n'importe quelle échelle.
+ [Amazon Simple Notification Service (Amazon SNS](https://aws.amazon.com/sns/)) est un service géré qui fournit des messages aux abonnés par les éditeurs.
+ [AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/) est un framework de développement logiciel permettant de définir les ressources de vos applications cloud à l'aide de langages de programmation courants tels que Python TypeScript JavaScript, Java et C\$1/Net.
+ [AWS Serverless Application Model (AWS SAM](https://aws.amazon.com/serverless/sam/)) est un framework open source permettant de créer des applications sans serveur. Il fournit une syntaxe abrégée pour exprimer les fonctions APIs, les bases de données et les mappages de sources d'événements.
**Code**
Le code d'un exemple d'application illustrant le modèle saga, y compris le modèle IaC (AWS CDK, AWS SAM ou Terraform), les fonctions Lambda et les tables DynamoDB se trouve dans les liens suivants. Suivez les instructions du premier épisode pour les installer.
+ [Déployez avec AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Déploiement avec AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Déployez avec Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
## Épopées
### Installer des packages, compiler et compiler
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Installez les packages NPM. | Créez un nouveau répertoire, naviguez jusqu'à ce répertoire dans un terminal et clonez le GitHub référentiel de votre choix à partir de la section *Code* plus haut dans ce modèle.Dans le dossier racine contenant le `package.json` fichier, exécutez la commande suivante pour télécharger et installer tous les packages Node Package Manager (NPM) :npm install
| Développeur, architecte cloud |
| Compilez des scripts. | Dans le dossier racine, exécutez la commande suivante pour demander au TypeScript transpileur de créer tous les fichiers nécessaires JavaScript :npm run build
| Développeur, architecte cloud |
| Surveillez les modifications et recompilez. | Dans le dossier racine, exécutez la commande suivante dans une fenêtre de terminal séparée pour surveiller les modifications de code et compilez le code lorsqu'il détecte une modification :npm run watch
| Développeur, architecte cloud |
| Exécutez des tests unitaires (AWS CDK uniquement). | Si vous utilisez le AWS CDK, dans le dossier racine, exécutez la commande suivante pour effectuer les tests unitaires Jest :npm run test
| Développeur, architecte cloud |
### Déployer des ressources sur le compte AWS cible
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Déployez la pile de démonstration sur AWS. | L'application est indépendante de la région AWS. Si vous utilisez un profil, vous devez déclarer la région de manière explicite dans le profil [AWS Command Line Interface (AWS CLI) ou via des variables](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) d'[environnement de l'AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html).Dans le dossier racine, exécutez la commande suivante pour créer un assembly de déploiement et le déployer sur le compte et la région AWS par défaut.KIT AWS :cdk bootstrap
cdk deploy
IDENTIFIANT AWS :sam build
sam deploy --guided
Terraforme :terraform init
terraform apply
Cette étape peut prendre plusieurs minutes. Cette commande utilise les informations d'identification par défaut configurées pour l'AWS CLI.Notez l'URL de l'API Gateway qui s'affiche sur la console une fois le déploiement terminé. Vous aurez besoin de ces informations pour tester le flux d'exécution de la saga. | Développeur, architecte cloud |
| Comparez la pile déployée avec l'état actuel. | Dans le dossier racine, exécutez la commande suivante pour comparer la pile déployée à l'état actuel après avoir modifié le code source :KIT AWS :cdk diff
IDENTIFIANT AWS :sam deploy
Terraforme :terraform plan
| Développeur, architecte cloud |
### Tester le flux d'exécution
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Testez le flux d'exécution de la saga. | Accédez à l'URL API Gateway que vous avez notée à l'étape précédente, lorsque vous avez déployé la pile. Cette URL déclenche le démarrage de la machine à états. Pour plus d'informations sur la manière de manipuler le flux de la machine à états en transmettant différents paramètres d'URL, consultez la section [Informations supplémentaires](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional).Pour consulter les résultats, connectez-vous à l'AWS Management Console et accédez à la console Step Functions. Ici, vous pouvez voir chaque étape de la machine à états de la saga. Vous pouvez également consulter la table DynamoDB pour voir les enregistrements insérés, mis à jour ou supprimés. Si vous actualisez fréquemment l'écran, vous pouvez voir le statut de la transaction passer de `pending` à`confirmed`. Vous pouvez vous abonner à la rubrique SNS en mettant à jour le code contenu dans le `stateMachine.ts` fichier avec votre numéro de téléphone portable pour recevoir des SMS en cas de réservation réussie ou échouée. Pour plus d'informations, consultez *Amazon SNS* dans la section [Informations supplémentaires](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional). | Développeur, architecte cloud |
### Nettoyage
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| nettoyer les ressources. | Pour nettoyer les ressources déployées pour cette application, vous pouvez utiliser l'une des commandes suivantes.KIT AWS :cdk destroy
IDENTIFIANT AWS :sam delete
Terraforme :terraform destroy
| Développeur d'applications, architecte cloud |
## Ressources connexes
**Papiers techniques**
+ [Implémentation de microservices sur AWS](https://docs.aws.amazon.com/pdfs/whitepapers/latest/microservices-on-aws/microservices-on-aws.pdf)
+ [Objectif d'application sans serveur](https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html)
**Documentation des services AWS**
+ [Commencer à utiliser le kit AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html)
+ [Commencer à utiliser AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html)
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/)
+ [Amazon DynamoDB](https://docs.aws.amazon.com/dynamodb/)
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/)
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/)
+ [Amazon SNS](https://docs.aws.amazon.com/sns/)
**Didacticiels**
+ [Ateliers pratiques sur l'informatique sans serveur](https://aws.amazon.com/serverless-workshops/)
## Informations supplémentaires
**Code**
À des fins de test, ce modèle déploie API Gateway et une fonction Lambda de test qui déclenche la machine d'état Step Functions. Avec Step Functions, vous pouvez contrôler les fonctionnalités du système de réservation de voyages en transmettant un `run_type` paramètre pour imiter les défaillances dans « ReserveFlightReserveCarRental, » », » » ProcessPaymentConfirmFlight, » » et « »ConfirmCarRental.
La fonction `saga` Lambda (`sagaLambda.ts`) prend en compte les paramètres de requête dans l'URL de l'API Gateway, crée l'objet JSON suivant et le transmet à Step Functions pour exécution :
```
let input = {
"trip_id": tripID, // value taken from query parameter, default is AWS request ID
"depart_city": "Detroit",
"depart_time": "2021-07-07T06:00:00.000Z",
"arrive_city": "Frankfurt",
"arrive_time": "2021-07-09T08:00:00.000Z",
"rental": "BMW",
"rental_from": "2021-07-09T00:00:00.000Z",
"rental_to": "2021-07-17T00:00:00.000Z",
"run_type": runType // value taken from query parameter, default is "success"
};
```
Vous pouvez tester différents flux de la machine d'état Step Functions en transmettant les paramètres d'URL suivants :
+ **Exécution réussie** ─ https://\$1api gateway url\$1
+ Le **vol de réservation échoue** ─ https://\$1api gateway url\$1 ? **Type d'exécution = failFlightsReservation**
+ **Confirmer l'échec du vol** ─ https://\$1api gateway url\$1 ? **Type d'exécution = failFlightsConfirmation**
+ **La réservation de location de voiture échoue** ─ https://\$1api gateway url\$1 ? **RunType= Réservation failCarRental**
+ **Confirmer l'échec de la location de voiture** ─ https://\$1api gateway url\$1 ? **RunType= Confirmation failCarRental**
+ **Échec du processus de paiement** ─ https://\$1api gateway url\$1 ? **RunType=FailPayment**
+ **Transmettre un code de voyage** ─ https://\$1api gateway url\$1 ? **tripID=** \$1par défaut, l'ID de trajet sera l'ID de demande AWS\$1
**Modèles iAc**
Les référentiels liés incluent des modèles IaC que vous pouvez utiliser pour créer l'intégralité de l'exemple d'application de réservation de voyages.
+ [Déployez avec AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Déploiement avec AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Déployez avec Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
**Tables DynamoDB**
Voici les modèles de données pour les vols, les locations de voitures et les tableaux de paiements.
```
Flight Data Model:
var params = {
TableName: process.env.TABLE_NAME,
Item: {
'pk' : {S: event.trip_id},
'sk' : {S: flightReservationID},
'trip_id' : {S: event.trip_id},
'id': {S: flightReservationID},
'depart_city' : {S: event.depart_city},
'depart_time': {S: event.depart_time},
'arrive_city': {S: event.arrive_city},
'arrive_time': {S: event.arrive_time},
'transaction_status': {S: 'pending'}
}
};
Car Rental Data Model:
var params = {
TableName: process.env.TABLE_NAME,
Item: {
'pk' : {S: event.trip_id},
'sk' : {S: carRentalReservationID},
'trip_id' : {S: event.trip_id},
'id': {S: carRentalReservationID},
'rental': {S: event.rental},
'rental_from': {S: event.rental_from},
'rental_to': {S: event.rental_to},
'transaction_status': {S: 'pending'}
}
};
Payment Data Model:
var params = {
TableName: process.env.TABLE_NAME,
Item: {
'pk' : {S: event.trip_id},
'sk' : {S: paymentID},
'trip_id' : {S: event.trip_id},
'id': {S: paymentID},
'amount': {S: "750.00"}, // hard coded for simplicity as implementing any monetary transaction functionality is beyond the scope of this pattern
'currency': {S: "USD"},
'transaction_status': {S: "confirmed"}
}
};
```
**Fonctions Lambda**
Les fonctions suivantes seront créées pour prendre en charge le flux et l'exécution de la machine à états dans Step Functions :
+ **Réserver des vols** : insère un enregistrement dans le tableau des vols DynamoDB avec `transaction_status` un « `pending` de » pour réserver un vol.
+ **Confirmer le vol** : met à jour l'enregistrement dans le tableau DynamoDB Flights, en le réglant sur`transaction_status`, `confirmed` afin de confirmer le vol.
+ **Annuler la réservation de vols** : Supprime l'enregistrement du tableau des vols DynamoDB pour annuler le vol en attente.
+ **Réserver une location de voiture** : insère un enregistrement dans la table CarRentals DynamoDB avec `transaction_status` un « de » pour réserver une location `pending` de voiture.
+ **Confirmer les locations de voitures** : met à jour l'enregistrement dans la table CarRentals DynamoDB, pour le `transaction_status` définir sur, afin de confirmer `confirmed` la location de voiture.
+ **Annuler la réservation de location de voiture :** Supprime l'enregistrement de la table CarRentals DynamoDB pour annuler la location de voiture en attente.
+ **Traitement du paiement** : insère un enregistrement dans la table des paiements DynamoDB pour le paiement.
+ **Annuler le paiement** : Supprime l'enregistrement du paiement de la table DynamoDB Payments.
**Amazon SNS**
L'exemple d'application crée le sujet et l'abonnement suivants pour envoyer des SMS et informer le client de la réussite ou de l'échec des réservations. Si vous souhaitez recevoir des SMS pendant que vous testez l'exemple d'application, mettez à jour l'abonnement SMS avec votre numéro de téléphone valide dans le fichier de définition de la machine d'état.
Extrait de code AWS CDK (ajoutez le numéro de téléphone dans la deuxième ligne du code suivant) :
```
const topic = new sns.Topic(this, 'Topic');
topic.addSubscription(new subscriptions.SmsSubscription('+11111111111'));
const snsNotificationFailure = new tasks.SnsPublish(this ,'SendingSMSFailure', {
topic:topic,
integrationPattern: sfn.IntegrationPattern.REQUEST_RESPONSE,
message: sfn.TaskInput.fromText('Your Travel Reservation Failed'),
});
const snsNotificationSuccess = new tasks.SnsPublish(this ,'SendingSMSSuccess', {
topic:topic,
integrationPattern: sfn.IntegrationPattern.REQUEST_RESPONSE,
message: sfn.TaskInput.fromText('Your Travel Reservation is Successful'),
});
```
Extrait de code AWS SAM (remplacez les `+1111111111` chaînes par votre numéro de téléphone valide) :
```
StateMachineTopic11111111111:
Type: 'AWS::SNS::Subscription'
Properties:
Protocol: sms
TopicArn:
Ref: StateMachineTopic
Endpoint: '+11111111111'
Metadata:
'aws:sam:path': SamServerlessSagaStack/StateMachine/Topic/+11111111111/Resource
```
Extrait de code Terraform (remplacez la `+111111111` chaîne par votre numéro de téléphone valide) :
```
resource "aws_sns_topic_subscription" "sms-target" {
topic_arn = aws_sns_topic.topic.arn
protocol = "sms"
endpoint = "+11111111111"
}
```
**Réservations réussies**
Le flux suivant illustre une réservation réussie avec « ReserveFlightReserveCarRental, » » et « ProcessPayment » suivis de « ConfirmFlight » et « »ConfirmCarRental. Le client est informé de la réussite de la réservation par le biais de messages SMS envoyés à l'abonné du sujet SNS.
![\[Exemple de réservation réussie implémentée par Step Functions en utilisant le modèle saga.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/f58c894e-7721-4bc7-8f7d-29f23faa5dc1.png)
**Réservations échouées**
Ce flux est un exemple d'échec dans le schéma de la saga. Si, après la réservation des vols et des locations de voiture, « ProcessPayment » échoue, les étapes sont annulées dans l'ordre inverse. Les réservations sont annulées et le client est informé de l'échec par le biais de messages SMS envoyés à l'abonné de la rubrique SNS.
![\[Exemple d'échec de réservation implémenté par Step Functions en utilisant le modèle saga.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/7c64d326-be27-42c3-b03f-d677efedb9a7.png)
# Gérez les applications de conteneur sur site en configurant Amazon ECS Anywhere avec le kit AWS CDK
*M. Rahul Sharad Gaikwad, Amazon Web Services*
## Résumé
[Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/) est une extension d'Amazon Elastic Container Service (Amazon ECS). Vous pouvez utiliser ECS Anywhere pour déployer des tâches Amazon ECS natives dans un environnement sur site ou géré par le client. Cette fonctionnalité permet de réduire les coûts et d'atténuer l'orchestration et les opérations complexes des conteneurs locaux. Vous pouvez utiliser ECS Anywhere pour déployer et exécuter des applications de conteneur dans des environnements sur site et dans le cloud. Ainsi, votre équipe n'a plus besoin d'apprendre plusieurs domaines et compétences, ou de gérer elle-même des logiciels complexes.
Ce modèle décrit les étapes de configuration d'ECS Anywhere à l'aide des [piles AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/).
## Conditions préalables et limitations
**Conditions préalables**
+ Un compte AWS actif.
+ Interface de ligne de commande AWS (AWS CLI), installée et configurée. (Voir [Installation, mise à jour et désinstallation de l'interface de ligne de commande AWS dans la](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) documentation de l'interface de ligne de commande AWS.)
+ AWS CDK Toolkit, installé et configuré. (Consultez le [kit d'outils AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) dans la documentation AWS CDK et suivez les instructions pour installer la version 2 dans le monde entier.)
+ Gestionnaire de packages de nœuds (npm), installé et configuré pour le AWS CDK dans. TypeScript (Voir [Téléchargement et installation de Node.js et de npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) dans la documentation de npm.)
**Limites**
+ Pour connaître les limites et les considérations, consultez la section [Instances externes (Amazon ECS Anywhere)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-anywhere.html#ecs-anywhere-considerations) dans la documentation Amazon ECS.
**Versions du produit**
+ Kit d'outils AWS CDK version 2
+ npm version 7.20.3 ou ultérieure
+ Node.js version 16.6.1 ou ultérieure
## Architecture
**Pile technologique cible**
+ AWS CloudFormation
+ AWS CDK
+ Amazon ECS Anywhere
+ AWS Identity and Access Management (IAM)
**Architecture cible**
Le schéma suivant illustre une architecture système de haut niveau d'ECS Anywhere configurée à l'aide d'AWS CDK avec TypeScript, telle qu'implémentée par ce modèle.
1. Lorsque vous déployez la pile AWS CDK, elle crée une CloudFormation pile sur AWS.
1. La CloudFormation pile fournit un cluster Amazon ECS et les ressources AWS associées.
1. Pour enregistrer une instance externe auprès d'un cluster Amazon ECS, vous devez installer l'agent AWS Systems Manager (agent SSM) sur votre machine virtuelle (VM) et enregistrer la machine virtuelle en tant qu'instance gérée par AWS Systems Manager.
1. Vous devez également installer l'agent de conteneur Amazon ECS et Docker sur votre machine virtuelle pour l'enregistrer en tant qu'instance externe auprès du cluster Amazon ECS.
1. Lorsque l'instance externe est enregistrée et configurée avec le cluster Amazon ECS, elle peut exécuter plusieurs conteneurs sur votre machine virtuelle, qui est enregistrée en tant qu'instance externe.
![\[Configuration d'ECS Anywhere à l'aide du kit AWS CDK avec TypeScript.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/3ed63c00-40e7-4831-bb9d-63049c3490aa/images/ff7dc774-830d-4b9f-8262-7314afe7a033.png)
**Automatisation et mise à l'échelle**
Le [GitHub référentiel](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples/) fourni avec ce modèle utilise le CDK AWS comme outil d'infrastructure en tant que code (IaC) pour créer la configuration de cette architecture. AWS CDK vous aide à orchestrer les ressources et à configurer ECS Anywhere.
## Outils
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) est un framework de développement logiciel qui vous aide à définir et à provisionner l'infrastructure du cloud AWS sous forme de code.
+ [L'interface de ligne de commande AWS (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) est un outil open source qui vous permet d'interagir avec les services AWS par le biais de commandes dans votre shell de ligne de commande.
**Code**
Le code source de ce modèle est disponible sur GitHub, dans le référentiel [Amazon ECS Anywhere CDK Samples](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples). Pour cloner et utiliser le référentiel, suivez les instructions de la section suivante.
## Épopées
### Vérifier la configuration d'AWS CDK
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Vérifiez la version du kit AWS CDK. | Vérifiez la version du kit d'outils AWS CDK en exécutant la commande suivante :cdk --version
Ce modèle nécessite la version 2 d'AWS CDK. Si vous disposez d'une version antérieure du CDK AWS, suivez les instructions de la [documentation du CDK AWS](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) pour la mettre à jour. | DevOps ingénieur |
| Configurez les informations d'identification AWS. | Pour configurer les informations d'identification, exécutez la `aws configure` commande et suivez les instructions :$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
| DevOps ingénieur |
### Démarrez l'environnement AWS CDK
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Clonez le référentiel de code AWS CDK. | Clonez le référentiel de GitHub code pour ce modèle à l'aide de la commande :git clone https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples.git
| DevOps ingénieur |
| Démarrez l'environnement. | Pour déployer le CloudFormation modèle AWS sur le compte et la région AWS que vous souhaitez utiliser, exécutez la commande suivante :cdk bootstrap /
Pour plus d'informations, consultez la section [Bootstrapping](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html) dans la documentation AWS CDK. | DevOps ingénieur |
### Créez et déployez le projet
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Installez les dépendances des packages et compilez TypeScript les fichiers. | Installez les dépendances du package et compilez les TypeScript fichiers en exécutant les commandes suivantes :$cd amazon-ecs-anywhere-cdk-samples
$npm install
$npm fund
Ces commandes installent tous les packages du référentiel d'échantillons. Si vous recevez des erreurs concernant des packages manquants, utilisez l'une des commandes suivantes :$npm ci
—ou—$npm install -g @aws-cdk/
Pour plus d'informations, consultez [npm ci](https://docs.npmjs.com/cli/v7/commands/npm-ci) et [npm install](https://docs.npmjs.com/cli/v7/commands/npm-install) dans la documentation de npm. | DevOps ingénieur |
| Générez le projet. | Pour créer le code du projet, exécutez la commande suivante :npm run build
Pour plus d'informations sur la création et le déploiement du projet, consultez [Votre première application AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/hello_world.html#:~:text=the%20third%20parameter.-,Synthesize%20an%20AWS%20CloudFormation%20template,-Synthesize%20an%20AWS) dans la documentation du CDK AWS. | DevOps ingénieur |
| Déployez le projet. | Pour déployer le code du projet, exécutez la commande suivante :cdk deploy
| DevOps ingénieur |
| Vérifiez la création et la sortie de la pile. | Ouvrez la CloudFormation console AWS à l'[https://console---aws.amazon.com.rproxy.goskope.comadresse /cloudformation****](https://console.aws.amazon.com/cloudformation/) et choisissez la `EcsAnywhereStack` pile. L'onglet **Sorties** affiche les commandes à exécuter sur votre machine virtuelle externe. | DevOps ingénieur |
### Configuration d'une machine sur site
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Configurez votre machine virtuelle à l'aide de Vagrant. | À des fins de démonstration, vous pouvez utiliser [HashiCorp Vagrant](https://www.vagrantup.com/) pour créer une machine virtuelle. Vagrant est un utilitaire open source permettant de créer et de maintenir des environnements de développement de logiciels virtuels portables. Créez une machine virtuelle Vagrant en exécutant la `vagrant up` commande depuis le répertoire racine dans lequel Vagrantfile est placé. Pour plus d'informations, consultez la [documentation de Vagrant](https://www.vagrantup.com/docs/cli/up). | DevOps ingénieur |
| Enregistrez votre machine virtuelle en tant qu'instance externe. | 1. Connectez-vous à la machine virtuelle Vagrant à l'aide de la `vagrant ssh` commande. Pour plus d'informations, consultez la [documentation de Vagrant](https://www.vagrantup.com/docs/cli/ssh).2. Créez un code d'activation et un identifiant que vous pouvez utiliser pour enregistrer votre machine virtuelle auprès d'AWS Systems Manager et pour activer votre instance externe. Le résultat de cette commande inclut les `ActivationCode` valeurs `ActivationId` et suivantes : aws ssm create-activation --iam-role EcsAnywhereInstanceRole | tee ssm-activation.json
3. Exportez l'ID d'activation et les valeurs du code :export ACTIVATION_ID=
export ACTIVATION_CODE=
4. Téléchargez le script d'installation sur votre serveur ou machine virtuelle sur site :curl -o "ecs-anywhere-install.sh" "https://amazon-ecs-agent.s3.amazonaws.com/ecs-anywhere-install-latest.sh" && sudo chmod +x ecs-anywhere-install.sh
5. Exécutez le script d'installation sur votre serveur ou machine virtuelle sur site :sudo ./ecs-anywhere-install.sh \
--cluster test-ecs-anywhere \
--activation-id $ACTIVATION_ID \
--activation-code $ACTIVATION_CODE \
--region
Pour plus d'informations sur la configuration et l'enregistrement de votre machine virtuelle, consultez la section [Enregistrement d'une instance externe dans un cluster](https://docs.amazonaws.cn/en_us/AmazonECS/latest/developerguide/ecs-anywhere-registration.html) dans la documentation Amazon ECS. | DevOps ingénieur |
| Vérifiez l'état d'ECS Anywhere et de la machine virtuelle externe. | Pour vérifier si votre boîte virtuelle est connectée au plan de contrôle Amazon ECS et en cours d'exécution, utilisez les commandes suivantes :aws ssm describe-instance-information
aws ecs list-container-instances --cluster $CLUSTER_NAME
| DevOps ingénieur |
### Nettoyage
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Nettoyez et supprimez les ressources. | Après avoir suivi ce schéma, vous devez supprimer les ressources que vous avez créées pour éviter d'encourir des frais supplémentaires. Pour nettoyer, exécutez la commande suivante :cdk destroy
| DevOps ingénieur |
## Ressources connexes
+ [Documentation Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/)
+ [Démo d'Amazon ECS Anywhere](https://www.youtube.com/watch?v=-eud6yUXsJM)
+ [Exemples d'ateliers Amazon ECS Anywhere](https://github.com/aws-samples/aws-ecs-anywhere-workshop-samples)
# Modernisez les applications ASP.NET Web Forms sur AWS
*Vijai Anand Ramalingam et Sreelaxmi Pai, Amazon Web Services*
## Résumé
Ce modèle décrit les étapes de modernisation d'une ancienne application ASP.NET Web Forms monolithe en la portant vers ASP.NET Core sur AWS.
Le portage des applications ASP.NET Web Forms vers ASP.NET Core vous permet de tirer parti des performances, des économies et de l'écosystème robuste de Linux. Cependant, il peut s'agir d'un effort manuel important. Dans ce modèle, l'ancienne application est modernisée progressivement en utilisant une approche progressive, puis conteneurisée dans le cloud AWS.
Envisagez une ancienne application monolithe pour un panier d'achats. Supposons qu'il a été créé en tant qu'application ASP.NET Web Forms et qu'il se compose de pages .aspx avec un fichier code-behind (). `aspx.cs` Le processus de modernisation comprend les étapes suivantes :
1. Divisez le monolithe en microservices en utilisant les modèles de décomposition appropriés. Pour plus d'informations, consultez le guide [Décomposer les monolithes en microservices](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-decomposing-monoliths/) sur le site Web AWS Prescriptive Guidance.
1. Portez votre ancienne application ASP.NET Web Forms (.NET Framework) vers ASP.NET Core dans .NET 5 ou version ultérieure. Dans ce modèle, vous utilisez l'assistant de portage pour .NET pour analyser votre application ASP.NET Web Forms et identifier les incompatibilités avec ASP.NET Core. Cela réduit l'effort de portage manuel.
1. Redéveloppez la couche d'interface utilisateur Web Forms à l'aide de React. Ce modèle ne couvre pas le réaménagement de l'interface utilisateur. Pour obtenir des instructions, voir [Créer une nouvelle application React](https://reactjs.org/docs/create-a-new-react-app.html) dans la documentation React.
1. Redéveloppez le fichier de code Web Forms (interface professionnelle) en tant qu'API Web ASP.NET Core. Ce modèle utilise des NDepend rapports pour aider à identifier les fichiers et les dépendances requis.
1. Mettez à niveau shared/common des projets, tels que Business Logic et Data Access, de votre ancienne application vers .NET 5 ou une version ultérieure à l'aide de l'assistant de portage pour .NET.
1. Ajoutez des services AWS pour compléter votre application. Par exemple, vous pouvez utiliser [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) pour surveiller, stocker et accéder aux journaux de votre application, et [AWS Systems Manager](https://aws.amazon.com/systems-manager/) pour stocker les paramètres de votre application.
1. Conteneurisez l'application ASP.NET Core modernisée. Ce modèle crée un fichier Docker qui cible Linux dans Visual Studio et utilise Docker Desktop pour le tester localement. Cette étape suppose que votre ancienne application est déjà exécutée sur une instance Windows sur site ou Amazon Elastic Compute Cloud (Amazon EC2). Pour plus d'informations, consultez le modèle [Exécuter un conteneur Docker d'API Web ASP.NET Core sur une instance Amazon EC2 Linux.](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html)
1. Déployez l'application principale ASP.NET modernisée sur Amazon Elastic Container Service (Amazon ECS). Ce modèle ne couvre pas l'étape de déploiement. Pour obtenir des instructions, consultez l'[atelier Amazon ECS](https://ecsworkshop.com/).
**Note**
Ce modèle ne couvre pas le développement de l'interface utilisateur, la modernisation de la base de données ou les étapes de déploiement de conteneurs.
## Conditions préalables et limitations
**Conditions préalables**
+ [Visual Studio](https://visualstudio.microsoft.com/downloads/) ou [Visual Studio Code](https://code.visualstudio.com/download), téléchargé et installé.
+ Accès à un compte AWS à l'aide de la console de gestion AWS et de l'interface de ligne de commande AWS (AWS CLI) version 2. (Consultez les [instructions de configuration de l'interface de ligne de commande AWS](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).)
+ Le kit d'outils AWS pour Visual Studio (voir les [instructions de configuration](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html)).
+ Docker Desktop, [téléchargé](https://www.docker.com/products/docker-desktop) et installé.
+ SDK .NET, [téléchargé](https://download.visualstudio.microsoft.com/download/pr/4263dc3b-dc67-4f11-8d46-cc0ae86a232e/66782bbd04c53651f730b2e30a873f18/dotnet-sdk-5.0.203-win-x64.exe) et installé.
+ NDepend outil, [téléchargé](https://www.ndepend.com/download) et installé. Pour installer l' NDepend extension pour Visual Studio, exécutez `NDepend.VisualStudioExtension.Installer` ([voir les instructions](https://www.ndepend.com/docs/getting-started-with-ndepend#Part1)). Vous pouvez sélectionner Visual Studio 2019 ou 2022, selon vos besoins.
+ Assistant de portage pour .NET, [téléchargé](https://aws.amazon.com/porting-assistant-dotnet/) et installé.
## Architecture
**Modernisation de l'application de panier**
Le schéma suivant illustre le processus de modernisation d'une ancienne application de panier d'achat ASP.NET.
![\[Modernisation d'une ancienne application de panier\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/4367e259-9bb3-4eb6-a54d-1c1e2dece7d4.png)
**Architecture cible**
Le schéma suivant illustre l'architecture de l'application de panier d'achat modernisée sur AWS. APIs Les sites Web ASP.NET Core sont déployés sur un cluster Amazon ECS. Les services de journalisation et de configuration sont fournis par Amazon CloudWatch Logs et AWS Systems Manager.
![\[Architecture cible pour l'application ASP.NET Web Forms sur AWS\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/ed6d65ec-0dc9-43ab-ac07-1f172e089399.png)
## Outils
**Services AWS**
+ [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) — Amazon Elastic Container Service (Amazon ECS) est un service de gestion de conteneurs rapide et hautement évolutif permettant d'exécuter, d'arrêter et de gérer des conteneurs sur un cluster. Vous pouvez exécuter vos tâches et services sur une infrastructure sans serveur gérée par AWS Fargate. Pour mieux contrôler votre infrastructure, vous pouvez également exécuter vos tâches et services sur un cluster d' EC2 instances que vous gérez.
+ [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) — Amazon CloudWatch Logs centralise les journaux de tous les systèmes, applications et services AWS que vous utilisez. Vous pouvez consulter et surveiller les journaux, y rechercher des codes ou modèles d'erreur spécifiques, les filtrer en fonction de champs spécifiques ou les archiver en toute sécurité pour une analyse future.
+ [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ─ AWS Systems Manager est un service AWS que vous pouvez utiliser pour visualiser et contrôler votre infrastructure sur AWS. À l'aide de la console Systems Manager, vous pouvez consulter les données opérationnelles de plusieurs services AWS et automatiser les tâches opérationnelles sur l'ensemble de vos ressources AWS. Systems Manager vous aide à maintenir la sécurité et la conformité en scannant vos instances gérées et en signalant (ou en prenant des mesures correctives) les violations des politiques détectées.
**Outils**
+ [Visual Studio](https://visualstudio.microsoft.com/) ou [Visual Studio Code](https://code.visualstudio.com/) : outils permettant de créer des applications .NET, des applications Web APIs et d'autres programmes.
+ [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) : extension pour Visual Studio qui permet de développer, de déboguer et de déployer des applications .NET utilisant les services AWS.
+ [Docker Desktop](https://www.docker.com/products/docker-desktop) : outil qui simplifie la création et le déploiement d'applications conteneurisées.
+ [NDepend](https://www.ndepend.com/features/)— Un analyseur qui surveille le code .NET pour détecter les dépendances, les problèmes de qualité et les modifications de code.
+ [Assistant de portage pour .NET](https://aws.amazon.com/porting-assistant-dotnet/) : outil d'analyse qui analyse le code .NET afin d'identifier les incompatibilités avec .NET Core et d'estimer l'effort de migration.
## Épopées
### Portez votre ancienne application vers .NET 5 ou version ultérieure
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Mettez à niveau votre ancienne application .NET Framework vers .NET 5. | Vous pouvez utiliser l'assistant de portage pour .NET pour convertir votre ancienne application ASP.NET Web Forms en .NET 5 ou version ultérieure. Suivez les instructions de la [documentation de l'assistant de portage pour .NET](https://docs.aws.amazon.com/portingassistant/latest/userguide/porting-assistant-getting-started.html). | Développeur d’applications |
| Générez NDepend des rapports. | Lorsque vous modernisez votre application ASP.NET Web Forms en la décomposant en microservices, il se peut que vous n'ayez pas besoin de tous les fichiers .cs de l'ancienne application. Vous pouvez l'utiliser NDepend pour générer un rapport pour n'importe quel fichier code-behind (.cs), afin d'obtenir tous les appelants et appelés. Ce rapport vous aide à identifier et à utiliser uniquement les fichiers requis dans vos microservices.Après l'installation NDepend (voir la section [Conditions préalables](#modernize-asp-net-web-forms-applications-on-aws-prereqs)), ouvrez la solution (fichier .sln) pour votre ancienne application dans Visual Studio et procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Ce processus génère un rapport pour le fichier code-behind qui répertorie tous les appelants et appelés. Pour plus d'informations sur le graphe de dépendance, consultez la [NDepend documentation](https://www.ndepend.com/docs/visual-studio-dependency-graph). | Développeur d’applications |
| Créez une nouvelle solution .NET 5. | Pour créer une nouvelle structure .NET 5 (ou version ultérieure) pour votre site Web ASP.NET Core modernisé : APIs[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Pour plus d'informations sur la création de projets et de solutions, consultez la [documentation de Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/creating-solutions-and-projects).Au fur et à mesure que vous créez la solution et que vous vérifiez ses fonctionnalités, vous pouvez identifier plusieurs fichiers supplémentaires à ajouter à la solution, en plus des fichiers NDepend identifiés. | Développeur d’applications |
### Mettez à jour le code de votre application
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Implémentez le Web APIs avec ASP.NET Core. | *Supposons que l'un des microservices que vous avez identifiés dans votre ancienne application de panier d'achat monolithe soit Products.* Vous avez créé un nouveau projet d'API Web ASP.NET Core pour les *produits* dans l'épopée précédente. *Au cours de cette étape, vous identifiez et modernisez tous les formulaires Web (pages .aspx) liés aux produits.* Supposons que les *produits* se composent de quatre formulaires Web, comme illustré précédemment dans la section [Architecture](#modernize-asp-net-web-forms-applications-on-aws-architecture) :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Vous devez analyser chaque formulaire Web, identifier toutes les demandes envoyées à la base de données pour appliquer une certaine logique et obtenir des réponses. Vous pouvez implémenter chaque demande en tant que point de terminaison d'API Web. Compte tenu de ses formulaires Web, *les produits* peuvent avoir les points de terminaison suivants :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Comme indiqué précédemment, vous pouvez également réutiliser tous les autres projets que vous avez mis à niveau vers .NET 5, notamment Business Logic, Data Access et les shared/common projets. | Développeur d’applications |
| Configurez Amazon CloudWatch Logs. | Vous pouvez utiliser [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) pour surveiller, stocker et accéder aux journaux de votre application. Vous pouvez enregistrer des données dans Amazon CloudWatch Logs à l'aide d'un SDK AWS. Vous pouvez également intégrer des applications .NET à CloudWatch Logs en utilisant des frameworks de journalisation .NET courants tels que [NLog](https://www.nuget.org/packages/AWS.Logger.NLog/)[Log4Net](https://www.nuget.org/packages/AWS.Logger.Log4net/) et [ASP.NET Core](https://www.nuget.org/packages/AWS.Logger.AspNetCore/).Pour plus d'informations sur cette étape, consultez le billet de blog [Amazon CloudWatch Logs and .NET Logging Frameworks](https://aws.amazon.com/blogs/developer/amazon-cloudwatch-logs-and-net-logging-frameworks/). | Développeur d’applications |
| Configurez le magasin de paramètres AWS Systems Manager. | Vous pouvez utiliser [AWS Systems Manager Parameter Store pour stocker](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html) les paramètres de l'application, tels que les chaînes de connexion, séparément du code de votre application. Le NuGet package [Amazon.Extensions.Configuration. SystemsManager](https://www.nuget.org/packages/Amazon.Extensions.Configuration.SystemsManager/)simplifie la façon dont votre application charge ces paramètres depuis l'AWS Systems Manager Parameter Store dans le système de configuration .NET Core. Pour plus d'informations sur cette étape, consultez le billet de blog sur le [fournisseur de configuration .NET Core pour AWS Systems Manager](https://aws.amazon.com/blogs/developer/net-core-configuration-provider-for-aws-systems-manager/). | Développeur d’applications |
### Ajouter l'authentification et l'autorisation
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Utilisez un cookie partagé pour l'authentification. | La modernisation d'une ancienne application monolithe est un processus itératif qui nécessite la coexistence du monolithe et de sa version modernisée. Vous pouvez utiliser un cookie partagé pour garantir une authentification fluide entre les deux versions. L'ancienne application ASP.NET continue de valider les informations d'identification de l'utilisateur et émet le cookie tandis que l'application ASP.NET Core modernisée valide le cookie. Pour obtenir des instructions et un exemple de code, consultez l'[exemple de GitHub projet](https://github.com/aws-samples/dotnet-share-auth-cookie-between-monolith-and-modernized-apps). | Développeur d’applications |
### Créez et exécutez le conteneur localement
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez une image Docker à l'aide de Visual Studio. | Au cours de cette étape, vous allez créer un fichier Docker à l'aide de l'API Web Visual Studio pour .NET Core.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Visual Studio crée un fichier Docker pour votre projet. Pour un exemple de fichier Docker, voir [Visual Studio Container Tools pour Docker sur le site](https://docs.microsoft.com/en-us/visualstudio/containers/overview) Web de Microsoft. | Développeur d’applications |
| Créez et exécutez le conteneur à l'aide de Docker Desktop. | Vous pouvez désormais créer, créer et exécuter le conteneur dans Docker Desktop.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html) | Développeur d’applications |
## Ressources connexes
+ [Exécuter un conteneur Docker d'API Web ASP.NET Core sur une instance Amazon EC2 Linux](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) (AWS Prescriptive Guidance)
+ [Atelier Amazon ECS](https://ecsworkshop.com/)
+ [Réaliser des blue/green déploiements ECS à CodeDeploy l'aide d'AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) ( CloudFormation documentation AWS)
+ [Mise en route avec NDepend](https://www.ndepend.com/docs/getting-started-with-ndepend) (NDepend documentation)
+ [Assistant de portage pour .NET](https://aws.amazon.com/porting-assistant-dotnet/)
## Informations supplémentaires
Les tableaux suivants fournissent des exemples de projets pour une ancienne application de panier d'achat et les projets équivalents dans votre application ASP.NET Core modernisée.
**Solution héritée :**
|
|
| Nom du projet | Modèle de projet | Infrastructure cible |
| --- |--- |--- |
| Interface commerciale | Bibliothèque de classes | .NET Framework |
| BusinessLogic | Bibliothèque de classes | .NET Framework |
| WebApplication | Application Web ASP.NET Framework | .NET Framework |
| UnitTests | NUnit Projet de test | .NET Framework |
| Partagé -> Commun | Bibliothèque de classes | .NET Framework |
| Framework partagé | Bibliothèque de classes | .NET Framework |
**Nouvelle solution :**
|
|
| Nom du projet | Modèle de projet | Infrastructure cible |
| --- |--- |--- |
| BusinessLogic | Bibliothèque de classes | .NET 5.0 |
| | API Web ASP.NET Core | .NET 5.0 |
| . UnitTests | NUnit 3 Projet de test | .NET 5.0 |
| Partagé -> Commun | Bibliothèque de classes | .NET 5.0 |
| Framework partagé | Bibliothèque de classes | .NET 5.0 |
# Intégration des locataires dans l'architecture SaaS pour le modèle de silo à l'aide de C\$1 et d'AWS CDK
*Tabby Ward, Susmitha Reddy Gankidi et Vijai Anand Ramalingam, Amazon Web Services*
## Résumé
Les applications SaaS (Software as a Service) peuvent être créées à l'aide de différents modèles architecturaux. Le *modèle de silo* fait référence à une architecture dans laquelle les locataires disposent de ressources dédiées.
Les applications SaaS s'appuient sur un modèle fluide pour introduire de nouveaux locataires dans leur environnement. Cela nécessite souvent l'orchestration d'un certain nombre de composants pour approvisionner et configurer correctement tous les éléments nécessaires à la création d'un nouveau locataire. Ce processus, dans l'architecture SaaS, est appelé intégration des locataires. L'intégration doit être entièrement automatisée pour chaque environnement SaaS en utilisant l'infrastructure sous forme de code dans votre processus d'intégration.
Ce modèle vous guide à travers un exemple de création d'un locataire et de mise en service d'une infrastructure de base pour le locataire sur Amazon Web Services (AWS). Le modèle utilise le C\$1 et l'AWS Cloud Development Kit (AWS CDK).
Étant donné que ce modèle crée une alarme de facturation, nous vous recommandons de déployer la pile dans la région AWS de l'est des États-Unis (Virginie du Nord), ou us-east-1. Pour plus d'informations, consultez la [documentation AWS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html).
## Conditions préalables et limitations
**Prérequis******
+ Un [compte AWS](https://aws.amazon.com/account/) actif.
+ Un responsable AWS Identity and Access Management (IAM) disposant d'un accès IAM suffisant pour créer des ressources AWS correspondant à ce modèle. Pour en savoir plus, consultez [Rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
+ [Installez l'interface de ligne de commande Amazon (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) [et configurez l'interface de ligne de commande AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) pour effectuer le déploiement d'AWS CDK.
+ [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) téléchargé et installé ou [Visual Studio Code](https://code.visualstudio.com/download) téléchargé et installé.
+ Configuration d'[AWS Toolkit pour Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html).
+ [.NET Core 3.1 ou version ultérieure](https://dotnet.microsoft.com/download/dotnet-core/3.1) (requis pour les applications C\$1 AWS CDK)
+ [Amazon.Lambda.Tools installé.](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools)
**Limites******
+ AWS CDK utilise [AWS CloudFormation](https://aws.amazon.com/cloudformation/). Les applications AWS CDK sont donc soumises à des quotas de CloudFormation service. Pour plus d'informations, consultez la section [ CloudFormation Quotas AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
+ La CloudFormation pile de locataires est créée avec un rôle de CloudFormation service `infra-cloudformation-role` avec des caractères génériques sur les actions (`sns`\$1 et`sqs*`) mais avec des ressources limitées au `tenant-cluster` préfixe. Pour un cas d'utilisation en production, évaluez ce paramètre et fournissez uniquement l'accès requis à ce rôle de service. La fonction `InfrastructureProvision` Lambda utilise également un caractère générique (`cloudformation*`) pour approvisionner la CloudFormation pile, mais les ressources sont limitées au préfixe. `tenant-cluster`
+ La version docker de cet exemple de code est utilisée `--platform=linux/amd64` pour forcer les images`linux/amd64`. Cela permet de garantir que les artefacts d'image finaux seront adaptés à Lambda, qui utilise par défaut l'architecture x86-64. Si vous devez modifier l'architecture Lambda cible, veillez à modifier à la fois les codes Dockerfiles et AWS CDK. Pour plus d'informations, consultez le billet de blog [Migration des fonctions AWS Lambda vers les processeurs AWS Graviton2 basés sur ARM](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-to-arm-based-aws-graviton2-processors/).
+ Le processus de suppression de la pile ne nettoie pas CloudWatch les journaux (groupes de journaux et journaux) générés par la pile. Vous devez nettoyer manuellement les journaux via la console Amazon AWS Management CloudWatch Console ou via l'API.
Ce modèle est configuré à titre d'exemple. Pour une utilisation en production, évaluez les configurations suivantes et apportez des modifications en fonction des besoins de votre entreprise :
+ Dans cet exemple, la gestion des versions du bucket [AWS Simple Storage Service (Amazon S3)](https://aws.amazon.com/s3/) n'est pas activée pour des raisons de simplicité. Évaluez et mettez à jour la configuration selon les besoins.
+ Cet exemple configure les points de terminaison de [l'API REST Amazon API Gateway](https://aws.amazon.com/api-gateway/) sans authentification, autorisation ou limitation pour des raisons de simplicité. Pour une utilisation en production, nous recommandons d'intégrer le système à l'infrastructure de sécurité de l'entreprise. Évaluez ce paramètre et ajoutez les paramètres de sécurité requis selon les besoins.
+ Pour cet exemple d'infrastructure client, [Amazon Simple Notification Service (Amazon SNS) et Amazon](https://aws.amazon.com/sns/) [Simple Queue Service (Amazon SQS) ne proposent que des configurations](https://aws.amazon.com/sqs/) minimales. L'[AWS Key Management Service (AWS KMS)](https://aws.amazon.com/kms/) de chaque locataire ouvre la voie aux services [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) et Amazon SNS du compte à utiliser conformément à la politique [clé d'AWS KMS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-key-management.html#compatibility-with-aws-services). La configuration n'est qu'un exemple d'espace réservé. Ajustez les configurations selon vos besoins en fonction de votre cas d'utilisation professionnel.
+ L'ensemble de la configuration, qui inclut, sans s'y limiter, les points de terminaison d'API et le provisionnement et la suppression des locataires du backend à l'aide d'AWS CloudFormation, ne couvre que le cas de base du happy path. Évaluez et mettez à jour la configuration avec la logique de nouvelle tentative nécessaire, la logique de gestion des erreurs supplémentaire et la logique de sécurité en fonction des besoins de votre entreprise.
+ L'exemple de code est testé avec up-to-date [cdk-nag](https://github.com/cdklabs/cdk-nag) pour vérifier les politiques au moment de la rédaction de cet article. De nouvelles politiques pourraient être appliquées à l'avenir. Ces nouvelles politiques peuvent vous obliger à modifier manuellement la pile en fonction des recommandations avant que la pile ne puisse être déployée. Passez en revue le code existant pour vous assurer qu'il correspond aux exigences de votre entreprise.
+ Le code s'appuie sur le CDK AWS pour générer un suffixe aléatoire au lieu de s'appuyer sur des noms physiques assignés de manière statique pour la plupart des ressources créées. Cette configuration permet de garantir que ces ressources sont uniques et n'entrent pas en conflit avec d'autres piles. Pour plus d'informations, consultez la [documentation AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/resources.html#resources_physical_names). Ajustez cela en fonction des besoins de votre entreprise.
+ [Cet exemple de code regroupe les artefacts .NET Lambda dans des images basées sur Docker et s'exécute avec le moteur d'exécution d'images Container fourni par Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/csharp-image.html) L'environnement d'exécution de l'image du conteneur présente des avantages pour les mécanismes de transfert et de stockage standard (registres de conteneurs) et pour les environnements de test locaux plus précis (via l'image du conteneur). Vous pouvez modifier le projet pour utiliser les environnements d'[exécution .NET fournis par Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-csharp.html) afin de réduire le temps de génération des images Docker, mais vous devrez ensuite configurer les mécanismes de transfert et de stockage et vous assurer que la configuration locale correspond à la configuration Lambda. Ajustez le code pour l'aligner sur les exigences commerciales des utilisateurs.
**Versions du produit**
+ AWS CDK version 2.45.0 ou ultérieure
+ Visual Studio 2022
## Architecture
**Pile technologique**
+ Amazon API Gateway
+ AWS CloudFormation
+ Amazon CloudWatch
+ Amazon DynamoDB
+ AWS Identity and Access Management (IAM)
+ AWS KMS
+ AWS Lambda
+ Amazon S3
+ Amazon SNS
+ Amazon SQS
**Architecture**
Le schéma suivant montre le flux de création de la pile de locataires. Pour plus d'informations sur les piles technologiques du plan de contrôle et des locataires, consultez la section *Informations supplémentaires*.
![\[Flux de travail pour créer un locataire et fournir une infrastructure de base pour le locataire sur AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/5baef800-fe39-4eb8-b11d-2c23eb3175fc/images/0b579484-b87c-4acb-8c60-8c33c18370e3.png)
**Flux de création d'une pile de locataires**
1. L'utilisateur envoie une demande d'API POST avec la nouvelle charge utile du locataire (nom du locataire, description du locataire) au format JSON à une API REST hébergée par Amazon API Gateway. L'API Gateway traite la demande et la transmet à la fonction principale Lambda Tenant Onboarding. Dans cet exemple, il n'y a aucune autorisation ni authentification. Dans une configuration de production, cette API doit être intégrée au système de sécurité de l'infrastructure SaaS.
1. La fonction d'intégration des locataires vérifie la demande. Il tente ensuite de stocker l'enregistrement du locataire, qui inclut le nom du locataire, l'identifiant unique universel (UUID) généré et la description du locataire, dans la table d'intégration des locataires Amazon DynamoDB.
1. Une fois que DynamoDB a enregistré l'enregistrement, un flux DynamoDB lance la fonction Lambda Tenant Infrastructure en aval.
1. La fonction Lambda de l'infrastructure Tenant agit en fonction du flux DynamoDB reçu. Si le flux est destiné à l'événement INSERT, la fonction utilise la NewImage section du flux (dernier enregistrement de mise à jour, champ Nom du tenant) CloudFormation pour créer une nouvelle infrastructure locataire à l'aide du modèle stocké dans le compartiment S3. Le CloudFormation modèle nécessite le paramètre Tenant Name.
1. AWS CloudFormation crée l'infrastructure du locataire en fonction du CloudFormation modèle et des paramètres d'entrée.
1. Chaque configuration de l'infrastructure du locataire comporte une CloudWatch alarme, une alarme de facturation et un événement d'alarme.
1. L'événement d'alarme devient un message envoyé à une rubrique SNS, qui est chiffré par la clé AWS KMS du locataire.
1. La rubrique SNS transmet le message d'alarme reçu à la file d'attente SQS, qui est chiffrée par la clé de chiffrement AWS KMS du locataire.
D'autres systèmes peuvent être intégrés à Amazon SQS pour effectuer des actions en fonction des messages en file d'attente. Dans cet exemple, pour que le code reste générique, les messages entrants restent en file d'attente et doivent être supprimés manuellement.
**Flux de suppression de la pile de locataires**
1. L'utilisateur envoie une demande d'API DELETE avec la nouvelle charge utile du locataire (nom du locataire, description du locataire) au format JSON à l'API REST hébergée par Amazon API Gateway, qui traitera la demande et la transmettra à la fonction d'intégration des locataires. Dans cet exemple, il n'y a aucune autorisation ni authentification. Dans une configuration de production, cette API sera intégrée au système de sécurité de l'infrastructure SaaS.
1. La fonction d'intégration des locataires vérifiera la demande, puis tentera de supprimer le dossier du locataire (nom du locataire) de la table d'accueil des locataires.
1. Une fois que DynamoDB a correctement supprimé l'enregistrement (l'enregistrement existe dans la table et est supprimé), un flux DynamoDB lance la fonction Lambda Tenant Infrastructure en aval.
1. La fonction Lambda de l'infrastructure Tenant agit en fonction de l'enregistrement de flux DynamoDB reçu. Si le flux est destiné à l'événement REMOVE, la fonction utilise la OldImage section de l'enregistrement (informations sur l'enregistrement et champ Nom du locataire, avant la dernière modification, qui est la suppression) pour lancer la suppression d'une pile existante sur la base de ces informations d'enregistrement.
1. AWS CloudFormation supprime la pile de locataires cible en fonction de l'entrée.
## Outils
**Services AWS**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) vous aide à créer, publier, gérer, surveiller et sécuriser REST, HTTP, et ce, WebSocket APIs à n'importe quelle échelle.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) est un framework de développement logiciel qui vous aide à définir et à provisionner l'infrastructure du cloud AWS sous forme de code.
+ [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) est un kit de développement cloud en ligne de commande qui vous permet d'interagir avec votre application AWS Cloud Development Kit (AWS CDK).
+ [L'interface de ligne de commande AWS (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) est un outil open source qui vous permet d'interagir avec les services AWS par le biais de commandes dans votre shell de ligne de commande.
+ [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) vous CloudFormation aide à configurer les ressources AWS, à les approvisionner rapidement et de manière cohérente, et à les gérer tout au long de leur cycle de vie sur l'ensemble des comptes et des régions AWS.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos ressources AWS en contrôlant qui est authentifié et autorisé à les utiliser.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) vous aide à créer et à contrôler des clés cryptographiques afin de protéger vos données.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service de calcul qui vous permet d'exécuter du code sans avoir à approvisionner ou à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données.
+ [Amazon Simple Notification Service (Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)) vous aide à coordonner et à gérer l'échange de messages entre les éditeurs et les clients, y compris les serveurs Web et les adresses e-mail.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fournit une file d'attente hébergée sécurisée, durable et disponible qui vous permet d'intégrer et de dissocier les systèmes et composants logiciels distribués.
+ [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) est un plugin pour l'environnement de développement intégré (IDE) Visual Studio. Le Toolkit for Visual Studio prend en charge le développement, le débogage et le déploiement d'applications .NET utilisant les services AWS.
**Autres outils**
+ [Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/whats-new-visual-studio-2022?view=vs-2022) est un IDE qui inclut des compilateurs, des outils de complétion de code, des concepteurs graphiques et d'autres fonctionnalités qui prennent en charge le développement de logiciels.
**Code**
Le code de ce modèle se trouve dans le référentiel d'exemples [APG d'intégration des locataires dans l'architecture SaaS pour Silo Model](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example).
## Épopées
### Configuration d'AWS CDK
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Vérifiez l'installation de Node.js. | Pour vérifier que Node.js est installé sur votre ordinateur local, exécutez la commande suivante.node --version
| Administrateur AWS, AWS DevOps |
| Installez le kit d'outils AWS CDK. | Pour installer AWS CDK Toolkit sur votre machine locale, exécutez la commande suivante.npm install -g aws-cdk
Si npm n'est pas installé, vous pouvez l'installer depuis le [site Node.js](https://nodejs.org/en/download/package-manager/). | Administrateur AWS, AWS DevOps |
| Vérifiez la version d'AWS CDK Toolkit. | Pour vérifier que la version d'AWS CDK Toolkit est correctement installée sur votre machine, exécutez la commande suivante. cdk --version
| Administrateur AWS, AWS DevOps |
### Vérifiez le code du plan de contrôle d'embarquement du locataire
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Pour cloner le référentiel. | Clonez le [référentiel](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example) et naviguez jusqu'au `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example` dossier.Dans Visual Studio 2022, ouvrez la `\src\TenantOnboardingInfra.sln` solution. Ouvrez le `TenantOnboardingInfraStack.cs` fichier et examinez le code.Les ressources suivantes sont créées dans le cadre de cette pile :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Administrateur AWS, AWS DevOps |
| Passez en revue le CloudFormation modèle. | Dans le `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\template` dossier`infra.yaml`, ouvrez et examinez le CloudFormation modèle. Ce modèle sera hydraté avec le nom du locataire extrait de la table DynamoDB d'accueil du locataire.Le modèle fournit l'infrastructure spécifique au locataire. Dans cet exemple, il fournit la clé AWS KMS, Amazon SNS, Amazon SQS et l'alarme. CloudWatch | Développeur d'applications, AWS DevOps |
| Passez en revue la fonction d'intégration des locataires. | Ouvrez `Function.cs` et examinez le code de la fonction d'intégration des locataires, qui est créée avec le modèle Visual Studio AWS Lambda Project (.NET Core- C\$1) avec le plan .NET 6 (Container Image).Ouvrez le `Dockerfile` et passez en revue le code. `Dockerfile`Il s'agit d'un fichier texte contenant des instructions pour créer l'image du conteneur Lambda.Notez que les NuGet packages suivants sont ajoutés en tant que dépendances au `TenantOnboardingFunction` projet :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Développeur d'applications, AWS DevOps |
| Passez en revue la InfraProvisioning fonction Tenant. | Accédez à `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\InfraProvisioningFunction`.Ouvrez `Function.cs` et examinez le code de la fonction de provisionnement de l'infrastructure locataire, qui est créé avec le modèle Visual Studio AWS Lambda Project (.NET Core- C\$1) avec le plan .NET 6 (Container Image).Ouvrez le `Dockerfile` et passez en revue le code. Notez que les NuGet packages suivants sont ajoutés en tant que dépendances au `InfraProvisioningFunction` projet :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Développeur d'applications, AWS DevOps |
### Déployer les ressources AWS
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez la solution. | Pour créer la solution, effectuez les opérations suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Assurez-vous de mettre à jour le `Amazon.CDK.Lib NuGet` package avec la dernière version du `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\TenantOnboardingInfra` projet avant de créer la solution. | Développeur d’applications |
| Démarrez l'environnement AWS CDK. | Ouvrez l'invite de commande Windows et accédez au dossier racine de l'application AWS CDK dans lequel le `cdk.json` fichier est disponible (`\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example`). Exécutez la commande suivante pour le démarrage.cdk bootstrap
Si vous avez créé un profil AWS pour les informations d'identification, utilisez la commande avec votre profil.cdk bootstrap --profile
| Administrateur AWS, AWS DevOps |
| Répertoriez les piles de CDK AWS. | Pour répertorier toutes les piles à créer dans le cadre de ce projet, exécutez la commande suivante.cdk ls
cdk ls --profile
Si vous avez créé un profil AWS pour les informations d'identification, utilisez la commande avec votre profil.cdk ls --profile
| Administrateur AWS, AWS DevOps |
| Vérifiez quelles ressources AWS seront créées. | Pour consulter toutes les ressources AWS qui seront créées dans le cadre de ce projet, exécutez la commande suivante.cdk diff
Si vous avez créé un profil AWS pour les informations d'identification, utilisez la commande avec votre profil.cdk diff --profile
| Administrateur AWS, AWS DevOps |
| Déployez toutes les ressources AWS à l'aide d'AWS CDK. | Pour déployer toutes les ressources AWS, exécutez la commande suivante.cdk deploy --all --require-approval never
Si vous avez créé un profil AWS pour les informations d'identification, utilisez la commande avec votre profil.cdk deploy --all --require-approval never --profile
Une fois le déploiement terminé, copiez l'URL de l'API depuis la section des sorties de l'invite de commande, comme illustré dans l'exemple suivant.Outputs:
TenantOnboardingInfraStack.TenantOnboardingAPIEndpoint42E526D7 = https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/
| Administrateur AWS, AWS DevOps |
### Vérifiez la fonctionnalité
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez un nouveau locataire. | Pour créer le nouveau locataire, envoyez la demande curl suivante.curl -X POST tenant -d '{"Name":"Tenant123", "Description":"Stack for Tenant123"}'
Remplacez l'espace `` réservé par la valeur réelle d'AWS CDK, comme indiqué dans l'exemple suivant.curl -X POST https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant -d '{"Name":"Tenant123", "Description":"test12"}'L'exemple suivant montre le résultat.{"message": "A new tenant added - 5/4/2022 7:11:30 AM"} | Développeur d'applications, administrateur AWS, AWS DevOps |
| Vérifiez les informations du locataire nouvellement créé dans DynamoDB. | Pour vérifier les informations du locataire nouvellement créé dans DynamoDB, effectuez les étapes suivantes.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Développeur d'applications, administrateur AWS, AWS DevOps |
| Vérifiez la création de la pile pour le nouveau locataire. | Vérifiez que la nouvelle pile a été créée avec succès et dotée d'une infrastructure pour le locataire nouvellement créé conformément au CloudFormation modèle.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Développeur d'applications, administrateur AWS, AWS DevOps |
| Supprimez la pile de locataires. | Pour supprimer la pile de locataires, envoyez la demande curl suivante.curl -X DELETE tenant/
Remplacez l'espace `` réservé par la valeur réelle d'AWS CDK, puis par la valeur réelle de l'étape précédente de création du locataire, comme indiqué dans l'exemple suivant. ``curl -X DELETE https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant/Tenant123
L'exemple suivant montre le résultat.{"message": "Tenant destroyed - 5/4/2022 7:14:48 AM"} | Développeur d'applications, AWS DevOps, administrateur AWS |
| Vérifiez la suppression de la pile pour le locataire existant. | Pour vérifier que la pile de locataires existante a été supprimée, effectuez les étapes suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Développeur d'applications, administrateur AWS, AWS DevOps |
### Nettoyage
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Détruisez l'environnement. | Avant le nettoyage de la pile, assurez-vous de ce qui suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Une fois les tests effectués, AWS CDK peut être utilisé pour détruire toutes les piles et les ressources associées en exécutant la commande suivante.cdk destroy --all;
Si vous avez créé un profil AWS pour les informations d'identification, utilisez-le.Confirmez l'invite de suppression de la pile pour supprimer la pile. | Administrateur AWS, AWS DevOps |
| Nettoyez Amazon CloudWatch Logs. | Le processus de suppression de la pile ne nettoie pas CloudWatch les journaux (groupes de journaux et journaux) générés par la pile. Nettoyez manuellement les CloudWatch ressources à l'aide de la CloudWatch console ou de l'API. | Développeur d'applications, AWS DevOps, administrateur AWS |
## Ressources connexes
+ [Atelier AWS CDK .NET](https://cdkworkshop.com/40-dotnet.html)
+ [Utilisation du kit AWS CDK en C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [Référence CDK .NET](https://docs.aws.amazon.com/cdk/api/v2/dotnet/api/index.html)
## Informations supplémentaires
**Pile technologique de plan de contrôle**
Le code CDK écrit en .NET est utilisé pour approvisionner l'infrastructure du plan de contrôle, qui comprend les ressources suivantes :
1. **API Gateway**
Sert de point d'entrée de l'API REST pour la pile du plan de contrôle.
1. **Intégration des locataires à la fonction Lambda**
Cette fonction Lambda est initiée par API Gateway à l'aide de la méthode m.
Une demande d'API de méthode POST entraîne l'insertion de (`tenant name`,`tenant description`) dans la table `Tenant Onboarding` DynamoDB.
Dans cet exemple de code, le nom du tenant est également utilisé dans le cadre du nom de la pile de locataires et des noms des ressources de cette pile. Cela permet de faciliter l'identification de ces ressources. Ce nom de locataire doit être unique dans l'ensemble de la configuration pour éviter les conflits ou les erreurs. La configuration détaillée de la validation des entrées est expliquée dans la documentation [des rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) et dans la section *Limitations*.
Le processus de persistance de la table DynamoDB n'aboutira que si le nom du locataire n'est utilisé dans aucun autre enregistrement de la table.
Dans ce cas, le nom du locataire est la clé de partition de cette table, car seule la clé de partition peut être utilisée comme expression de `PutItem` condition.
Si le nom du locataire n'a jamais été enregistré auparavant, l'enregistrement sera correctement enregistré dans la table.
Toutefois, si le nom du locataire est déjà utilisé par un enregistrement existant dans la table, l'opération échouera et déclenchera une exception `ConditionalCheckFailedException` DynamoDB. L'exception sera utilisée pour renvoyer un message d'échec (`HTTP BadRequest`) indiquant que le nom du locataire existe déjà.
Une demande d'API de `DELETE` méthode supprimera l'enregistrement d'un nom de locataire spécifique de la table `Tenant Onboardin` g.
Dans cet exemple, la suppression de l'enregistrement DynamoDB réussira même si l'enregistrement n'existe pas.
Si l'enregistrement cible existe et est supprimé, il créera un enregistrement de flux DynamoDB. Dans le cas contraire, aucun enregistrement en aval ne sera créé.
1. **Intégration du locataire à DynamoDB, avec Amazon DynamoDB Streams activé**
Cela enregistre les informations de métadonnées du locataire, et toute sauvegarde ou suppression d'enregistrement enverra un flux en aval à la fonction `Tenant Infrastructure` Lambda.
1. **Fonction Lambda de l'infrastructure locataire**
Cette fonction Lambda est initiée par l'enregistrement de flux DynamoDB de l'étape précédente. Si l'enregistrement concerne un `INSERT` événement, il invoque AWS CloudFormation pour créer une nouvelle infrastructure locataire avec le CloudFormation modèle stocké dans un compartiment S3. Si l'enregistrement est pour`REMOVE`, il initie la suppression d'une pile existante en fonction du `Tenant Name` champ de l'enregistrement du flux.
1. **Compartiment S3**
C'est pour stocker le CloudFormation modèle.
1. **Des rôles IAM pour chaque fonction Lambda et un rôle de service pour CloudFormation**
Chaque fonction Lambda possède un rôle IAM unique avec des [autorisations de moindre privilège pour accomplir](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) sa tâche. Par exemple, la fonction `Tenant On-boarding` Lambda a read/write accès à DynamoDB, et la fonction `Tenant Infrastructure` Lambda ne peut lire que le flux DynamoDB.
Un rôle CloudFormation de service personnalisé est créé pour le provisionnement de la pile des locataires. Ce rôle de service contient des autorisations supplémentaires pour le provisionnement des CloudFormation piles (par exemple, la clé AWS KMS). Cela permet de répartir les rôles entre Lambda et d' CloudFormation éviter toutes les autorisations sur un seul rôle (rôle Lambda d'infrastructure).
Les autorisations qui autorisent des actions puissantes (telles que la création et la suppression de CloudFormation piles) sont verrouillées et autorisées uniquement sur les ressources commençant `tenantcluster-` par. L'exception est AWS KMS, en raison de sa convention de dénomination des ressources. Le nom du locataire ingéré provenant de l'API sera ajouté au début, `tenantcluster-` ainsi que d'autres contrôles de validation (alphanumérique avec tiret uniquement, et limité à moins de 30 caractères pour s'adapter à la plupart des noms de ressources AWS). Cela garantit que le nom du locataire n'entraînera pas accidentellement une perturbation des infrastructures ou des ressources de base.
**Pile technologique pour locataires**
Un CloudFormation modèle est stocké dans le compartiment S3. [Le modèle fournit la clé AWS KMS spécifique au locataire, une CloudWatch alarme, une rubrique SNS, une file d'attente SQS et une politique SQS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-using-identity-based-policies.html)
La clé AWS KMS est utilisée pour le chiffrement des données par Amazon SNS et Amazon SQS pour leurs messages. Les pratiques de sécurité pour [AwsSolutions- SNS2 et AwsSolutions -](https://github.com/cdklabs/cdk-nag/blob/main/RULES.md) vous SQS2 recommandent de configurer Amazon SNS et Amazon SQS avec le chiffrement. Toutefois, les CloudWatch alarmes ne fonctionnent pas avec Amazon SNS lorsque vous utilisez une clé gérée par AWS. Vous devez donc utiliser une clé gérée par le client dans ce cas. Pour plus d'informations, consultez le [centre de connaissances AWS](https://aws.amazon.com/premiumsupport/knowledge-center/cloudwatch-receive-sns-for-alarm-trigger/).
La politique SQS est utilisée dans la file d'attente Amazon SQS pour permettre à la rubrique SNS créée de transmettre le message à la file d'attente. Sans la politique SQS, l'accès sera refusé. Pour plus d'informations, consultez la [documentation Amazon SNS.](https://docs.aws.amazon.com/sns/latest/dg/subscribe-sqs-queue-to-sns-topic.html#SendMessageToSQS.sqs.permissions)
# 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)
# Plus de modèles
**Topics**
+ [Accédez à des applications de conteneur en privé sur Amazon EKS à l'aide d'AWS PrivateLink et d'un Network Load Balancer](access-container-applications-privately-on-amazon-eks-using-aws-privatelink-and-a-network-load-balancer.md)
+ [Automatisez l'ajout ou la mise à jour d'entrées de registre Windows à l'aide d'AWS Systems Manager](automate-adding-or-updating-windows-registry-entries-using-aws-systems-manager.md)
+ [Automatisez le basculement et le retour en arrière entre régions à l'aide de DR Orchestrator Framework](automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.md)
+ [Créez et déployez automatiquement une application Java sur Amazon EKS à l'aide d'un CI/CD pipeline](automatically-build-and-deploy-a-java-application-to-amazon-eks-using-a-ci-cd-pipeline.md)
+ [Créez automatiquement des CI/CD pipelines et des clusters Amazon ECS pour les microservices à l'aide d'AWS CDK](automatically-build-ci-cd-pipelines-and-amazon-ecs-clusters-for-microservices-using-aws-cdk.md)
+ [Sauvegardez et archivez les données du mainframe sur Amazon S3 à l'aide de BMC AMI Cloud Data](back-up-and-archive-mainframe-data-to-amazon-s3-using-bmc-ami-cloud-data.md)
+ [Créez un PAC de serveur Micro Focus Enterprise avec Amazon EC2 Auto Scaling et Systems Manager](build-a-micro-focus-enterprise-server-pac-with-amazon-ec2-auto-scaling-and-systems-manager.md)
+ [Créez un maillage de données d'entreprise avec Amazon DataZone AWS CDK, et AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md)
+ [Conteneurisez les charges de travail du mainframe qui ont été modernisées par Blu Age](containerize-mainframe-workloads-that-have-been-modernized-by-blu-age.md)
+ [Convertissez et décompressez les données EBCDIC en ASCII sur AWS à l'aide de Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md)
+ [Convertissez des fichiers de données du mainframe avec des mises en page d'enregistrement complexes à l'aide de Micro Focus](convert-mainframe-data-files-with-complex-record-layouts-using-micro-focus.md)
+ [Créez un portail pour les micro-frontends en utilisant AWS Amplify Angular et Module Federation](create-amplify-micro-frontend-portal.md)
+ [Déployez des conteneurs à l'aide d'Elastic Beanstalk](deploy-containers-by-using-elastic-beanstalk.md)
+ [Émulez Oracle DR à l'aide d'une base de données globale Aurora compatible avec PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md)
+ [Générez des informations sur les données AWS Mainframe Modernization en utilisant Amazon Q dans Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md)
+ [Générez des informations sur z/OS les données DB2 en utilisant AWS Mainframe Modernization Amazon Q dans Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md)
+ [Identifiez automatiquement les images de conteneur dupliquées lors de la migration vers un référentiel Amazon ECR](identify-duplicate-container-images-automatically-when-migrating-to-ecr-repository.md)
+ [Implémentez les diagnostics et le dépannage de Kubernetes basés sur l'IA grâce à l'intégration de K8sGPT et Amazon Bedrock](implement-ai-powered-kubernetes-diagnostics-and-troubleshooting-with-k8sgpt-and-amazon-bedrock-integration.md)
+ [Mettre en œuvre l'authentification basée sur l'identifiant Microsoft Entra dans une application centrale modernisée de AWS Blu Age](implement-entra-id-authentication-in-aws-blu-age-modernized-mainframe-application.md)
+ [Implémentez la gestion des versions d'API basée sur les chemins en utilisant des domaines personnalisés dans Amazon API Gateway](implement-path-based-api-versioning-by-using-custom-domains.md)
+ [Migrez progressivement d'Amazon RDS for Oracle vers Amazon RDS for PostgreSQL à l'aide d'Oracle SQL Developer et d'AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md)
+ [Intégrez le contrôleur universel Stonebranch à la modernisation du mainframe AWS](integrate-stonebranch-universal-controller-with-aws-mainframe-modernization.md)
+ [Gérez les produits AWS Service Catalog dans plusieurs comptes AWS et régions AWS](manage-aws-service-catalog-products-in-multiple-aws-accounts-and-aws-regions.md)
+ [Migrer un compte AWS membre de AWS Organizations vers AWS Control Tower](migrate-an-aws-member-account-from-aws-organizations-to-aws-control-tower.md)
+ [Migrez et répliquez des fichiers VSAM vers Amazon RDS ou Amazon MSK à l'aide de Connect from Precisely](migrate-and-replicate-vsam-files-to-amazon-rds-or-amazon-msk-using-connect-from-precisely.md)
+ [Migrez de SAP ASE vers Amazon RDS for SQL Server à l'aide d'AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md)
+ [Migrer des tables externes Oracle vers des tables compatibles avec Amazon Aurora PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md)
+ [Modernisez l'application CardDemo mainframe en utilisant AWS Transform](modernize-carddemo-mainframe-app.md)
+ [Modernisez et déployez des applications mainframe à l'aide de AWS Transform Terraform](modernize-mainframe-app-transform-terraform.md)
+ [Modernisez les charges de travail d'impression par lots du mainframe à l'aide de AWS Rocket Enterprise Server et de LRS VPSX/MFI](modernize-mainframe-batch-printing-workloads-on-aws-by-using-rocket-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernisez les charges de travail d'impression en ligne du mainframe sur AWS à l'aide de Micro Focus Enterprise Server et de LRS VPSX/MFI](modernize-mainframe-online-printing-workloads-on-aws-by-using-micro-focus-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernisez la gestion des sorties du mainframe AWS en utilisant Rocket Enterprise Server et PageCenter LRS X](modernize-mainframe-output-management-on-aws-by-using-rocket-enterprise-server-and-lrs-pagecenterx.md)
+ [Déplacez les fichiers du mainframe directement vers Amazon S3 à l'aide de Transfer Family](move-mainframe-files-directly-to-amazon-s3-using-transfer-family.md)
+ [Optimisez les déploiements multicomptes sans serveur en utilisant les flux de travail et AWS CDK Actions GitHub](optimize-multi-account-serverless-deployments.md)
+ [Optimisez les performances de votre application AWS Blu Age modernisée](optimize-performance-aws-blu-age-modernized-application.md)
+ [Automatisez blue/green les déploiements de bases de données mondiales Amazon Aurora en utilisant les principes IaC](p-automate-blue-green-deployments-aurora-global-databases-iac.md)
+ [Répliquez des bases de données mainframe sur AWS à l'aide de Precisely Connect](replicate-mainframe-databases-to-aws-by-using-precisely-connect.md)
+ [Exécutez des tâches Amazon ECS sur Amazon WorkSpaces avec Amazon ECS Anywhere](run-amazon-ecs-tasks-on-amazon-workspaces-with-amazon-ecs-anywhere.md)
+ [Envoyez des données de télémétrie de AWS Lambda vers OpenSearch pour des analyses et des visualisations en temps réel](send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.md)
+ [Configurer la détection des CloudFormation dérives dans une organisation multirégionale et multi-comptes](set-up-aws-cloudformation-drift-detection-in-a-multi-region-multi-account-organization.md)
+ [Structurer un projet Python dans une architecture hexagonale à l'aide d'AWS Lambda](structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.md)
+ [AWS Infrastructure de test à l'aide LocalStack de tests Terraform](test-aws-infra-localstack-terraform.md)
+ [Transformez Easytrieve en langues modernes en utilisant des outils personnalisés AWS Transform](transform-easytrieve-modern-languages.md)
+ [Mettez à niveau les clusters SAP Pacemaker de ENSA1 ENSA2](upgrade-sap-pacemaker-clusters-from-ensa1-to-ensa2.md)
+ [Utilisez Amazon Q Developer comme assistant de codage pour augmenter votre productivité](use-q-developer-as-coding-assistant-to-increase-productivity.md)
+ [Validez le code Account Factory pour Terraform (AFT) localement](validate-account-factory-for-terraform-aft-code-locally.md)