`, das ist der Amazon-Ressourcenname (ARN) für den Bucket, den Sie zuvor erstellt habenArgument 2= Ihr Firehose-Name (Dieser Pilot verwendet`firehose_to_s3_stream`.)Argument 3= Ihr IAM-Rollenname (dieser Pilot verwendet.) `firehose_to_s3`python CreateFireHoseToS3.py firehose_to_s3_stream firehose_to_s3
Wenn die angegebene IAM-Rolle nicht existiert, erstellt das Skript eine Rolle annehmen mit einer Richtlinie für vertrauenswürdige Beziehungen sowie eine Richtlinie, die ausreichende Amazon S3 S3-Berechtigungen gewährt. Beispiele für diese Richtlinien finden Sie im Abschnitt *Zusätzliche Informationen*. | Cloud-Architekt, App-Entwickler |
| Überprüfen Sie den Firehose-Lieferstream. | Beschreiben Sie den Firehose-Lieferstream mithilfe der AWS-CLI, um zu überprüfen, ob der Lieferstream erfolgreich erstellt wurde.aws firehose describe-delivery-stream --delivery-stream-name firehose_to_s3_stream
| Cloud-Architekt, App-Entwickler |
### Erstellen Sie eine Lambda-Funktion zur Verarbeitung des Firehose-Lieferdatenstroms
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie eine Vertrauensrichtlinie für die Lambda-Funktion. | Erstellen Sie eine Vertrauensrichtliniendatei mit den folgenden Informationen. {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} Dadurch erhält Ihre Funktion die Erlaubnis, auf AWS-Ressourcen zuzugreifen. | Cloud-Architekt, App-Entwickler |
| Erstellen Sie eine Ausführungsrolle für die Lambda-Funktion. | Führen Sie den folgenden Code aus, um die Ausführungsrolle zu erstellen.aws iam create-role --role-name lambda-ex --assume-role-policy-document file://TrustPolicy.json
| Cloud-Architekt, App-Entwickler |
| Fügen Sie der Rolle eine Berechtigung hinzu. | Verwenden Sie den `attach-policy-to-role` Befehl, um der Rolle eine Berechtigung hinzuzufügen.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
| Cloud-Architekt, App-Entwickler |
| Erstellen Sie eine Lambda-Funktion. | Komprimieren Sie die `LambdaStreamProcessor.py` Datei aus dem Code-Repository, indem Sie den folgenden Befehl ausführen.zip function.zip LambdaStreamProcessor.py
Wenn Sie die Lambda-Funktion erstellen, benötigen Sie den ARN für die Lambda-Ausführungsrolle. Führen Sie den folgenden Code aus, um den ARN abzurufen.aws iam get-role \
--role-name lambda-ex
Führen Sie den folgenden Code aus, um die Lambda-Funktion zu erstellen.# 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}"
| Cloud-Architekt, App-Entwickler |
| Konfigurieren Sie den Lambda-Funktionstrigger. | Verwenden Sie die AWS-CLI, um den Trigger (DynamoDB Streams) zu konfigurieren, der die Lambda-Funktion aufruft. Die Batchgröße von 400 soll verhindern, dass Lambda-Parallelitätsprobleme auftreten.aws lambda create-event-source-mapping --function-name LambdaStreamProcessor \
--batch-size 400 --starting-position LATEST \
--event-source-arn
| Cloud-Architekt, App-Entwickler |
### Testen Sie die Funktionalität
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Fügen Sie Artikel mit abgelaufenen Zeitstempeln zur Reservierungstabelle hinzu. | Um die Funktionalität zu testen, fügen Sie der Tabelle Artikel mit abgelaufenen Epochenzeitstempeln hinzu. `Reservation` TTL löscht automatisch Elemente auf der Grundlage des Zeitstempels. Die Lambda-Funktion wird bei DynamoDB-Stream-Aktivitäten ausgelöst und filtert das Ereignis, um `REMOVE` Aktivitäten oder gelöschte Elemente zu identifizieren. Anschließend werden Datensätze im Batch-Format in Firehose Firehose-Lieferstream eingefügt.Der Firehose-Lieferstream überträgt Artikel mit dem `firehosetos3example/year=current year/month=current month/ day=current day/hour=current hour/` Präfix an einen S3-Ziel-Bucket.Um den Datenabruf zu optimieren, konfigurieren Sie Amazon S3 mit den `Prefix` und`ErrorOutputPrefix`, die im Abschnitt *Zusätzliche Informationen* detailliert beschrieben werden. | Cloud-Architekt |
### Säubere die Ressourcen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Löschen Sie alle Ressourcen. | Löschen Sie alle Ressourcen, um sicherzustellen, dass Ihnen keine Dienste in Rechnung gestellt werden, die Sie nicht nutzen. | Cloud-Architekt, App-Entwickler |
## Zugehörige Ressourcen
+ [Verwalten Ihres Speicher-Lebenszyklus](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html)
+ [Amazon S3 S3-Speicherklassen](https://aws.amazon.com/s3/storage-classes/)
+ [Dokumentation zum AWS-SDK SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
## Zusätzliche Informationen
**Einen Firehose-Lieferstream erstellen und konfigurieren — Richtlinienbeispiele**
*Beispieldokument Firehose Firehose-Richtlinie für vertrauenswürdige Beziehungen*
```
firehose_assume_role = {
'Version': '2012-10-17',
'Statement': [
{
'Sid': '',
'Effect': 'Allow',
'Principal': {
'Service': 'firehose.amazonaws.com'
},
'Action': 'sts:AssumeRole'
}
]
}
```
*Beispiel für eine S3-Berechtigungsrichtlinie*
```
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}"
]
}
]
}
```
**Testen Sie die Funktionalität — Amazon S3 S3-Konfiguration**
Die Amazon S3 S3-Konfiguration mit den folgenden Optionen `Prefix` wurde ausgewählt, um den Datenabruf zu optimieren. `ErrorOutputPrefix`
*prefix*
```
firehosetos3example/year=! {timestamp: yyyy}/month=! {timestamp:MM}/day=! {timestamp:dd}/hour=!{timestamp:HH}/
```
Firehose erstellt zunächst einen Basisordner, der `firehosetos3example` direkt unter dem S3-Bucket aufgerufen wird. Anschließend werden die Ausdrücke`!{timestamp:yyyy}`,`!{timestamp:MM}`, und `!{timestamp:HH}` nach Jahr`!{timestamp:dd}`, Monat, Tag und Stunde im [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)Java-Format ausgewertet.
Ein ungefährer Ankunftszeitstempel von 1604683577 in der Unix-Epochenzeit ergibt beispielsweise,, und. `year=2020` `month=11` `day=06` `hour=05` Daher wird der Standort in Amazon S3, an den die Datensätze geliefert werden, ausgewertet. `firehosetos3example/year=2020/month=11/day=06/hour=05/`
*ErrorOutputPrefix*
```
firehosetos3erroroutputbase/!{firehose:random-string}/!{firehose:error-output-type}/!{timestamp:yyyy/MM/dd}/
```
Die `ErrorOutputPrefix` Ergebnisse werden in einem Basisordner angezeigt, der `firehosetos3erroroutputbase` direkt unter dem S3-Bucket aufgerufen wird. Der Ausdruck `!{firehose:random-string}` ergibt eine zufällige 11-stellige Zeichenfolge wie. `ztWxkdg3Thg` Der Standort für ein Amazon S3 S3-Objekt, an das fehlerhafte Datensätze übermittelt werden, könnte ausgewertet werden`firehosetos3erroroutputbase/ztWxkdg3Thg/processing-failed/2020/11/06/`.
# Erstellen Sie eine serverlose Architektur mit mehreren Mandanten in Amazon Service OpenSearch
*Tabby Ward und Nisha Gambhir, Amazon Web Services*
## Zusammenfassung
Amazon OpenSearch Service ist ein verwalteter Service, der die Bereitstellung, den Betrieb und die Skalierung von Elasticsearch, einer beliebten Open-Source-Such- und Analyse-Engine, vereinfacht. OpenSearch Der Service bietet eine Freitextsuche sowie die Erfassung und das Dashboarding von Streaming-Daten wie Logs und Metriken nahezu in Echtzeit.
Anbieter von Software as a Service (SaaS) nutzen OpenSearch Service häufig, um eine Vielzahl von Anwendungsfällen abzudecken, z. B. um Kundeninformationen auf skalierbare und sichere Weise zu gewinnen und gleichzeitig Komplexität und Ausfallzeiten zu reduzieren.
Die Verwendung von OpenSearch Service in einer Umgebung mit mehreren Mandanten bringt eine Reihe von Überlegungen mit sich, die sich auf die Partitionierung, Isolierung, Bereitstellung und Verwaltung Ihrer SaaS-Lösung auswirken. SaaS-Anbieter müssen überlegen, wie sie ihre Elasticsearch-Cluster bei sich ständig ändernden Workloads effektiv skalieren können. Sie müssen auch berücksichtigen, wie sich Stufenbildung und laute Nachbarschaftsbedingungen auf ihr Partitionierungsmodell auswirken könnten.
In diesem Muster werden die Modelle untersucht, die zur Darstellung und Isolierung von Mandantendaten mit Elasticsearch-Konstrukten verwendet werden. Darüber hinaus konzentriert sich das Muster auf eine einfache serverlose Referenzarchitektur als Beispiel, um die Indizierung und Suche mithilfe von OpenSearch Service in einer Umgebung mit mehreren Mandanten zu demonstrieren. Es implementiert das Pool-Datenpartitionierungsmodell, das denselben Index für alle Mandanten verwendet und gleichzeitig die Datenisolierung eines Mandanten gewährleistet. Dieses Muster verwendet die folgenden AWS Dienste: Amazon API Gateway AWS Lambda, Amazon Simple Storage Service (Amazon S3) und OpenSearch Service.
Weitere Informationen zum Poolmodell und anderen Datenpartitionierungsmodellen finden Sie im Abschnitt [Zusätzliche Informationen](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional).
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktiver AWS-Konto
+ [AWS Command Line Interface (AWS CLI) Version 2.x](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html), installiert und konfiguriert auf macOS, Linux oder Windows
+ [Python-Version 3.9](https://www.python.org/downloads/release/python-3921/)
+ [pip3](https://pip.pypa.io/en/stable/) — Der Python-Quellcode wird als ZIP-Datei bereitgestellt, die in einer Lambda-Funktion bereitgestellt wird. Wenn Sie den Code lokal verwenden oder anpassen möchten, gehen Sie wie folgt vor, um den Quellcode zu entwickeln und neu zu kompilieren:
1. Generieren Sie die `requirements.txt` Datei, indem Sie den folgenden Befehl im selben Verzeichnis wie die Python-Skripte ausführen: `pip3 freeze > requirements.txt`
1. Installieren Sie die Abhängigkeiten: `pip3 install -r requirements.txt`
**Einschränkungen**
+ Dieser Code läuft in Python und unterstützt derzeit keine anderen Programmiersprachen.
+ Die Beispielanwendung bietet keine AWS regionsübergreifende Unterstützung oder Unterstützung für Disaster Recovery (DR).
+ Dieses Muster dient nur zu Demonstrationszwecken. Es ist nicht für die Verwendung in einer Produktionsumgebung vorgesehen.
## Architektur
Das folgende Diagramm veranschaulicht die allgemeine Architektur dieses Musters. Die Architektur umfasst Folgendes:
+ Lambda zum Indizieren und Abfragen des Inhalts
+ OpenSearch Dienst zur Durchführung der Suche
+ API Gateway zur Bereitstellung einer API-Interaktion mit dem Benutzer
+ Amazon S3 zum Speichern von Rohdaten (nicht indexiert)
+ Amazon CloudWatch zur Überwachung von Protokollen
+ AWS Identity and Access Management (IAM), um Mandantenrollen und Richtlinien zu erstellen
![\[Serverlose Mehrmandanten-Architektur auf hohem Niveau.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/1a8501e7-0776-4aca-aed3-28e3ada1d15d.png)
**Automatisierung und Skalierung**
Der Einfachheit halber wird das Muster für AWS CLI die Bereitstellung der Infrastruktur und für die Bereitstellung des Beispielcodes verwendet. Sie können eine CloudFormation Vorlage oder AWS Cloud Development Kit (AWS CDK) Skripts erstellen, um das Muster zu automatisieren.
## Tools
**AWS-Services**
+ [AWS CLI](https://aws.amazon.com/cli/)ist ein einheitliches Tool zur Verwaltung AWS-Services von Ressourcen mithilfe von Befehlen in Ihrer Befehlszeilen-Shell.
+ [Lambda](https://aws.amazon.com/lambda/) ist ein Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitzustellen oder zu verwalten. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde.
+ [API Gateway](https://aws.amazon.com/api-gateway/) dient AWS-Service zum Erstellen, Veröffentlichen, Verwalten, Überwachen und Sichern von REST, HTTP und WebSocket APIs in jeder Größenordnung.
+ [Amazon S3](https://aws.amazon.com/s3/) ist ein Objektspeicherservice, mit dem Sie jederzeit und von überall im Internet eine beliebige Menge an Informationen speichern und abrufen können.
+ [OpenSearch Service](https://aws.amazon.com/opensearch-service/) ist ein vollständig verwalteter Service, der es Ihnen leicht macht, Elasticsearch kostengünstig und skalierbar bereitzustellen, zu sichern und auszuführen.
**Code**
Der Anhang enthält Beispieldateien für dieses Muster. Dazu zählen:
+ `index_lambda_package.zip`— Die Lambda-Funktion für die Indizierung von Daten im OpenSearch Service mithilfe des Poolmodells.
+ `search_lambda_package.zip`— Die Lambda-Funktion für die Suche nach Daten im OpenSearch Service.
+ `Tenant-1-data`— Beispiel für Rohdaten (nicht indexiert) für Tenant-1.
+ `Tenant-2-data`— Stichprobe von Rohdaten (nicht indexiert) für Tenant-2.
**Wichtig**
Die Geschichten in diesem Muster enthalten AWS CLI Befehlsbeispiele, die für Unix, Linux und macOS formatiert sind. Ersetzen Sie unter Windows den umgekehrten Schrägstrich (\$1), das Unix-Fortsetzungszeichen, am Ende jeder Zeile durch ein Caret-Zeichen oder Zirkumflex (^).
**Anmerkung**
Ersetzen Sie in AWS CLI Befehlen alle Werte in den spitzen Klammern (<>) durch korrekte Werte.
## Epen
### Erstellen und konfigurieren Sie einen S3-Bucket
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie einen S3-Bucket. | Erstellen Sie einen S3-Bucket in Ihrem AWS-Region. Dieser Bucket enthält die nicht indizierten Mandantendaten für die Beispielanwendung. Stellen Sie sicher, dass der Name des S3-Buckets global eindeutig ist, da der Namespace von allen gemeinsam genutzt wird. AWS-KontenUm einen S3-Bucket zu erstellen, können Sie den Befehl AWS CLI [create-bucket](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-bucket.html) wie folgt verwenden:aws s3api create-bucket \
--bucket \
--region
wo `tenantrawdata` ist der Name des S3-Buckets. (Sie können jeden eindeutigen Namen verwenden, [der den Richtlinien zur Benennung von Buckets entspricht](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html).) | Cloud-Architekt, Cloud-Administrator |
### Erstellen und konfigurieren Sie einen Elasticsearch-Cluster
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie eine OpenSearch Dienstdomäne. | Führen Sie den AWS CLI [create-elasticsearch-domain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/es/create-elasticsearch-domain.html)Befehl aus, um eine OpenSearch Dienstdomäne zu erstellen: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\/*\" } ] }"
Die Anzahl der Instanzen ist auf 1 gesetzt, da die Domäne zu Testzwecken dient. Sie müssen mithilfe des `advanced-security-options` Parameters eine differenzierte Zugriffskontrolle aktivieren, da die Details nach der Erstellung der Domäne nicht mehr geändert werden können. Dieser Befehl erstellt einen Master-Benutzernamen (`KibanaUser`) und ein Passwort, mit denen Sie sich bei der Kibana-Konsole anmelden können.Da die Domain Teil einer Virtual Private Cloud (VPC) ist, müssen Sie sicherstellen, dass Sie die Elasticsearch-Instanz erreichen können, indem Sie die zu verwendende Zugriffsrichtlinie angeben.Weitere Informationen finden Sie in der AWS Dokumentation unter [Starten Ihrer Amazon OpenSearch Service-Domains innerhalb einer VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html). | Cloud-Architekt, Cloud-Administrator |
| Richten Sie einen Bastion-Host ein. | Richten Sie eine Amazon Elastic Compute Cloud (Amazon EC2) Windows-Instance als Bastion-Host für den Zugriff auf die Kibana-Konsole ein. Die Elasticsearch-Sicherheitsgruppe muss Datenverkehr von der EC2 Amazon-Sicherheitsgruppe zulassen. Eine Anleitung finden Sie im Blogbeitrag [Controlling Network Access to EC2 Instances Using a Bastion Server.](https://aws.amazon.com/blogs/security/controlling-network-access-to-ec2-instances-using-a-bastion-server/)Wenn der Bastion-Host eingerichtet wurde und Sie die Sicherheitsgruppe, die der Instance zugeordnet ist, verfügbar haben, verwenden Sie den AWS CLI [authorize-security-group-ingress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-ingress.html)Befehl, um der Elasticsearch-Sicherheitsgruppe die Erlaubnis hinzuzufügen, Port 443 von der Amazon-Sicherheitsgruppe EC2 (Bastion Host) zuzulassen.aws ec2 authorize-security-group-ingress \
--group-id \
--protocol tcp \
--port 443 \
--source-group
| Cloud-Architekt, Cloud-Administrator |
### Erstellen und konfigurieren Sie die Lambda-Index-Funktion
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie die Lambda-Ausführungsrolle. | Führen Sie den Befehl AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) aus, um der Lambda-Indexfunktion Zugriff auf und Ressourcen zu AWS-Services gewähren:aws iam create-role \
--role-name index-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
wo `lambda_assume_role.json` ist ein JSON-Dokument, das der Lambda-Funktion wie folgt `AssumeRole` Berechtigungen gewährt:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Cloud-Architekt, Cloud-Administrator |
| Hängen Sie verwaltete Richtlinien an die Lambda-Rolle an. | Führen Sie den AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)Befehl aus, um verwaltete Richtlinien an die im vorherigen Schritt erstellte Rolle anzuhängen. Diese beiden Richtlinien gewähren der Rolle Berechtigungen zum Erstellen einer elastic network interface und zum Schreiben von Protokollen in 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
| Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie eine Richtlinie, um der Lambda-Indexfunktion die Berechtigung zum Lesen der S3-Objekte zu erteilen. | Führen Sie den Befehl AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) aus, um der Lambda-Indexfunktion die `s3:GetObject` Erlaubnis zu erteilen, die Objekte im S3-Bucket zu lesen:aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3-policy.json
Bei der Datei `s3-policy.json` handelt es sich um ein unten gezeigtes JSON-Dokument, das `s3:GetObject` Berechtigungen für den Lesezugriff auf S3-Objekte gewährt. Wenn Sie bei der Erstellung des S3-Buckets einen anderen Namen verwendet haben, geben Sie im `Resource ` Abschnitt den richtigen Bucket-Namen an:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
} | Cloud-Architekt, Cloud-Administrator |
| Hängen Sie die Amazon S3 S3-Berechtigungsrichtlinie an die Lambda-Ausführungsrolle an. | Führen Sie den AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)Befehl aus, um die Amazon S3 S3-Berechtigungsrichtlinie, die Sie im vorherigen Schritt erstellt haben, an die Lambda-Ausführungsrolle anzuhängen:aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn
wo `PolicyARN` ist der Amazon-Ressourcenname (ARN) der Amazon S3-Genehmigungsrichtlinie. Sie können diesen Wert aus der Ausgabe des vorherigen Befehls abrufen. | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie die Lambda-Index-Funktion. | Führen Sie den Befehl AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) aus, um die Lambda-Indexfunktion zu erstellen, die auf Service zugreift: 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\": [\"\"]}"
| Cloud-Architekt, Cloud-Administrator |
| Erlauben Sie Amazon S3, die Lambda-Index-Funktion aufzurufen. | Führen Sie den Befehl AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) aus, um Amazon S3 die Erlaubnis zu erteilen, die Lambda-Index-Funktion aufzurufen: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 ""
| Cloud-Architekt, Cloud-Administrator |
| Fügen Sie einen Lambda-Trigger für das Amazon S3 S3-Ereignis hinzu. | Führen Sie den AWS CLI [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)Befehl aus, um Benachrichtigungen an die Lambda-Indexfunktion zu senden, wenn das Amazon S3 `ObjectCreated` S3-Ereignis erkannt wird. Die Indexfunktion wird immer dann ausgeführt, wenn ein Objekt in den S3-Bucket hochgeladen wird. aws s3api put-bucket-notification-configuration \
--bucket \
--notification-configuration file://s3-trigger.json
Die Datei `s3-trigger.json` ist ein JSON-Dokument im aktuellen Ordner, das die Ressourcenrichtlinie zur Lambda-Funktion hinzufügt, wenn das Amazon S3 `ObjectCreated` S3-Ereignis eintritt. | Cloud-Architekt, Cloud-Administrator |
### Lambda-Suchfunktion erstellen und konfigurieren
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie die Lambda-Ausführungsrolle. | Führen Sie den Befehl AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) aus, um der Lambda-Suchfunktion Zugriff auf und Ressourcen zu AWS-Services gewähren:aws iam create-role \
--role-name search-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
wo `lambda_assume_role.json` befindet sich ein JSON-Dokument im aktuellen Ordner, das der Lambda-Funktion wie folgt `AssumeRole` Berechtigungen gewährt:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Cloud-Architekt, Cloud-Administrator |
| Hängen Sie verwaltete Richtlinien an die Lambda-Rolle an. | Führen Sie den AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)Befehl aus, um verwaltete Richtlinien an die im vorherigen Schritt erstellte Rolle anzuhängen. Diese beiden Richtlinien gewähren der Rolle Berechtigungen zum Erstellen einer elastic network interface und zum Schreiben von Protokollen in 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
| Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie die Lambda-Suchfunktion. | Führen Sie den Befehl AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) aus, um die Lambda-Suchfunktion zu erstellen, die auf Service zugreift: 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\": [\"\"]}"
| Cloud-Architekt, Cloud-Administrator |
### Mandantenrollen erstellen und konfigurieren
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie Mandanten-IAM-Rollen. | Führen Sie den Befehl AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) aus, um zwei Mandantenrollen zu erstellen, die zum Testen der Suchfunktion verwendet werden: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
Die Datei `assume-role-policy.json` ist ein JSON-Dokument im aktuellen Ordner, das der Lambda-Ausführungsrolle `AssumeRole` Berechtigungen gewährt:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "",
"AWS": ""
},
"Action": "sts:AssumeRole"
}
]
} | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie eine IAM-Richtlinie für Mandanten. | Führen Sie den Befehl AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) aus, um eine Mandantenrichtlinie zu erstellen, die Zugriff auf Elasticsearch-Operationen gewährt:aws iam create-policy \
--policy-name tenant-policy \
--policy-document file://policy.json
Die Datei `policy.json` ist ein JSON-Dokument im aktuellen Ordner, das Berechtigungen für Elasticsearch gewährt:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpDelete",
"es:ESHttpGet",
"es:ESHttpHead",
"es:ESHttpPost",
"es:ESHttpPut",
"es:ESHttpPatch"
],
"Resource": [
""
]
}
]
} | Cloud-Architekt, Cloud-Administrator |
| Hängen Sie die Mandanten-IAM-Richtlinie an die Mandantenrollen an. | Führen Sie den AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)Befehl aus, um die Mandanten-IAM-Richtlinie an die beiden Mandantenrollen anzuhängen, die Sie im vorherigen Schritt erstellt haben: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
Der Richtlinien-ARN stammt aus der Ausgabe des vorherigen Schritts. | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie eine IAM-Richtlinie, um Lambda Berechtigungen zur Übernahme einer Rolle zu erteilen. | Führen Sie den Befehl AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) aus, um eine Richtlinie zu erstellen, damit Lambda die Mandantenrolle übernimmt:aws iam create-policy \
--policy-name assume-tenant-role-policy \
--policy-document file://lambda_policy.json
Die Datei `lambda_policy.json` ist ein JSON-Dokument im aktuellen Ordner, das Berechtigungen gewährt für: `AssumeRole`{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": ""
}
]
}Denn Sie können ein Platzhalterzeichen verwenden`Resource`, um zu vermeiden, dass für jeden Mandanten eine neue Richtlinie erstellt wird. | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie eine IAM-Richtlinie, um der Lambda-Indexrolle Zugriff auf Amazon S3 zu gewähren. | Führen Sie den Befehl AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) aus, um der Lambda-Indexrolle die Erlaubnis zu erteilen, auf die Objekte im S3-Bucket zuzugreifen:aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3_lambda_policy.json
Bei der Datei `s3_lambda_policy.json` handelt es sich um das folgende JSON-Richtliniendokument im aktuellen Ordner:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::tenantrawdata/*"
}
]
} | Cloud-Architekt, Cloud-Administrator |
| Hängen Sie die Richtlinie an die Lambda-Ausführungsrolle an. | Führen Sie den AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)Befehl aus, um die im vorherigen Schritt erstellte Richtlinie an die zuvor erstellten Lambda-Index- und Suchausführungsrollen anzuhängen: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
Der Richtlinien-ARN stammt aus der Ausgabe des vorherigen Schritts. | Cloud-Architekt, Cloud-Administrator |
### Erstellen und konfigurieren Sie eine Such-API
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie eine REST-API in API Gateway. | Führen Sie den AWS CLI [create-rest-api](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html)Befehl aus, um eine REST-API-Ressource zu erstellen:aws apigateway create-rest-api \
--name Test-Api \
--endpoint-configuration "{ \"types\": [\"REGIONAL\"] }"
Für den Endpunkt-Konfigurationstyp können Sie angeben, `REGIONAL` dass `EDGE` anstelle eines bestimmten Kantenstandorts verwendet werden soll AWS-Region.Notieren Sie sich den Wert des `id` Felds aus der Befehlsausgabe. Dies ist die API-ID, die Sie in nachfolgenden Befehlen verwenden werden. | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie eine Ressource für die Such-API. | Die Such-API-Ressource startet die Lambda-Suchfunktion mit dem Ressourcennamen`search`. (Sie müssen keine API für die Lambda-Indexfunktion erstellen, da sie automatisch ausgeführt wird, wenn Objekte in den S3-Bucket hochgeladen werden.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie eine GET-Methode für die Such-API. | Führen Sie den Befehl AWS CLI [put-method](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html) aus, um eine `GET ` Methode für die Such-API zu erstellen:aws apigateway put-method \
--rest-api-id \
--resource-id \
--http-method GET \
--authorization-type "NONE" \
--no-api-key-required
Geben Sie für `resource-id` die ID aus der Ausgabe des `create-resource` Befehls an. | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie eine Methodenantwort für die Such-API. | Führen Sie den AWS CLI [put-method-response](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html)Befehl aus, um eine Methodenantwort für die Such-API hinzuzufügen:aws apigateway put-method-response \
--rest-api-id \
--resource-id \
--http-method GET \
--status-code 200 \
--response-models "{\"application/json\": \"Empty\"}"
Geben Sie für `resource-id` die ID aus der Ausgabe des vorherigen `create-resource` Befehls an. | Cloud-Architekt, Cloud-Administrator |
| Richten Sie eine Proxy-Lambda-Integration für die Such-API ein. | Führen Sie den Befehl AWS CLI [put-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html) aus, um eine Integration mit der Lambda-Suchfunktion einzurichten: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
Geben Sie für `resource-id` die ID aus dem vorherigen Befehl an. `create-resource` | Cloud-Architekt, Cloud-Administrator |
| Erteilen Sie API Gateway die Erlaubnis, die Lambda-Suchfunktion aufzurufen. | Führen Sie den Befehl AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) aus, um API Gateway die Erlaubnis zu erteilen, die Suchfunktion zu verwenden: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
Ändern Sie den `source-arn` Pfad, wenn Sie anstelle von `search` einen anderen API-Ressourcennamen verwendet haben. | Cloud-Architekt, Cloud-Administrator |
| Stellen Sie die Such-API bereit. | Führen Sie den Befehl AWS CLI [create-deployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html) aus, um eine Staging-Ressource mit dem Namen zu erstellen: `dev`aws apigateway create-deployment \
--rest-api-id \
--stage-name dev
Wenn Sie die API aktualisieren, können Sie sie mit demselben AWS CLI Befehl erneut in derselben Phase bereitstellen. | Cloud-Architekt, Cloud-Administrator |
### Kibana-Rollen erstellen und konfigurieren
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Loggen Sie sich in die Kibana-Konsole ein. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Cloud-Architekt, Cloud-Administrator |
| Erstellen und konfigurieren Sie Kibana-Rollen. | Um Daten zu isolieren und sicherzustellen, dass ein Mandant die Daten eines anderen Mandanten nicht abrufen kann, müssen Sie Document Security verwenden, sodass Mandanten nur auf Dokumente zugreifen können, die ihre Mandanten-ID enthalten.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Cloud-Architekt, Cloud-Administrator |
| Ordnen Sie Benutzer Rollen zu. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Wir empfehlen Ihnen, die Erstellung der Mandanten- und Kibana-Rollen beim Onboarding des Mandanten zu automatisieren. | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie den Mieterdatenindex. | Wählen Sie im Navigationsbereich unter **Verwaltung** die Option **Dev Tools** aus, und führen Sie dann den folgenden Befehl aus. Mit diesem Befehl wird der `tenant-data` Index erstellt, um die Zuordnung für die `TenantId` Eigenschaft zu definieren.PUT /tenant-data
{
"mappings": {
"properties": {
"TenantId": { "type": "keyword"}
}
}
}
| Cloud-Architekt, Cloud-Administrator |
### VPC-Endpunkte für Amazon S3 erstellen und AWS STS
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie einen VPC-Endpunkt für Amazon S3. | Führen Sie den AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)Befehl aus, um einen VPC-Endpunkt für Amazon S3 zu erstellen. Der Endpunkt ermöglicht der Lambda-Index-Funktion in der VPC den Zugriff auf Amazon S3.aws ec2 create-vpc-endpoint \
--vpc-id \
--service-name com.amazonaws.us-east-1.s3 \
--route-table-ids
Geben Sie für `vpc-id` die VPC an, die Sie für die Lambda-Indexfunktion verwenden. Verwenden Sie für `service-name` die richtige URL für den Amazon S3 S3-Endpunkt. Geben Sie für `route-table-ids` die Routentabelle an, die dem VPC-Endpunkt zugeordnet ist. | Cloud-Architekt, Cloud-Administrator |
| Erstellen Sie einen VPC-Endpunkt für AWS STS. | Führen Sie den AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)Befehl aus, um einen VPC-Endpunkt für AWS -Security-Token-Service (AWS STS) zu erstellen. Der Endpunkt ermöglicht den Zugriff auf den Lambda-Index und die Suchfunktionen in der VPC. AWS STS Die Funktionen verwenden AWS STS , wenn sie die IAM-Rolle übernehmen.aws ec2 create-vpc-endpoint \
--vpc-id \
--vpc-endpoint-type Interface \
--service-name com.amazonaws.us-east-1.sts \
--subnet-id \
--security-group-id
Geben Sie für `vpc-id` die VPC an, die Sie für den Lambda-Index und die Suchfunktionen verwenden. Geben Sie für das Subnetz an`subnet-id`, in dem dieser Endpunkt erstellt werden soll. Geben Sie für die Sicherheitsgruppe an`security-group-id`, der dieser Endpunkt zugeordnet werden soll. (Es könnte dasselbe sein wie die Sicherheitsgruppe, die Lambda verwendet.) | Cloud-Architekt, Cloud-Administrator |
### Testen Sie Mehrmandantenfähigkeit und Datenisolierung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Aktualisieren Sie die Python-Dateien für die Index- und Suchfunktionen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Sie können den Elasticsearch-Endpunkt auf der Registerkarte „**Übersicht**“ der OpenSearch Service-Konsole abrufen. Er hat das Format`.es.amazonaws.com`. | Cloud-Architekt, App-Entwickler |
| Aktualisieren Sie den Lambda-Code. | Verwenden Sie den AWS CLI [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl, um den Lambda-Code mit den Änderungen zu aktualisieren, die Sie an den Python-Dateien vorgenommen haben: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
| Cloud-Architekt, App-Entwickler |
| Laden Sie Rohdaten in den S3-Bucket hoch. | Verwenden Sie den Befehl AWS CLI [cp](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/cp.html), um Daten für die Objekte Tenant-1 und Tenant-2 in den `tenantrawdata` Bucket hochzuladen (geben Sie den Namen des S3-Buckets an, den Sie zu diesem Zweck erstellt haben):aws s3 cp tenant-1-data s3://tenantrawdata
aws s3 cp tenant-2-data s3://tenantrawdata
Der S3-Bucket ist so eingerichtet, dass er die Lambda-Indexfunktion jedes Mal ausführt, wenn Daten hochgeladen werden, sodass das Dokument in Elasticsearch indexiert wird. | Cloud-Architekt, Cloud-Administrator |
| Suchen Sie Daten von der Kibana-Konsole aus. | Führen Sie auf der Kibana-Konsole die folgende Abfrage aus:GET tenant-data/_search
Diese Abfrage zeigt alle in Elasticsearch indexierten Dokumente an. In diesem Fall sollten Sie zwei separate Dokumente für Tenant-1 und Tenant-2 sehen. | Cloud-Architekt, Cloud-Administrator |
| Testen Sie die Such-API von API Gateway aus. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Bildschirmdarstellungen finden Sie im Abschnitt [Zusätzliche Informationen](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional). | Cloud-Architekt, App-Entwickler |
| Bereinigen Sie die Ressourcen. | Bereinigen Sie alle Ressourcen, die Sie erstellt haben, um zusätzliche Gebühren für Ihr Konto zu vermeiden. | AWS DevOps, Cloud-Architekt, Cloud-Administrator |
## Zugehörige Ressourcen
+ [AWS SDK für Python (Boto)](https://aws.amazon.com/sdk-for-python/)
+ [AWS Lambda Dokumentation](https://docs.aws.amazon.com/lambda/)
+ [API Gateway Gateway-Dokumentation](https://docs.aws.amazon.com/apigateway/)
+ [Amazon S3 S3-Dokumentation](https://docs.aws.amazon.com/s3/)
+ [Amazon OpenSearch Service-Dokumentation](https://docs.aws.amazon.com/elasticsearch-service/)
+ [Feinkörnige Zugriffskontrolle in Amazon Service OpenSearch ](https://docs.amazonaws.cn/en_us/elasticsearch-service/latest/developerguide/fgac.html)
+ [Eine Suchanwendung mit Amazon OpenSearch Service erstellen](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/search-example.html)
+ [Starten Ihrer Amazon OpenSearch Service-Domains innerhalb einer VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html)
## Zusätzliche Informationen
**Modelle zur Datenpartitionierung**
Es gibt drei gängige Datenpartitionierungsmodelle, die in Systemen mit mehreren Mandanten verwendet werden: Silo, Pool und Hybrid. Welches Modell Sie wählen, hängt von den Anforderungen Ihrer Umgebung in Bezug auf Compliance, Noisy Neighbor, Betrieb und Isolierung ab.
*Silo-Modell*
Im Silomodell werden die Daten jedes Mandanten in einem eigenen Speicherbereich gespeichert, in dem es nicht zu einer Vermischung von Mandantendaten kommt. Sie können zwei Ansätze verwenden, um das Silomodell mit OpenSearch Service zu implementieren: Domäne pro Mandant und Index pro Mandant.
+ **Domain pro Mandant** — Sie können pro Mandant eine separate OpenSearch Service-Domain (gleichbedeutend mit einem Elasticsearch-Cluster) verwenden. Die Platzierung jedes Mandanten in einer eigenen Domain bietet alle Vorteile, die mit der Speicherung von Daten in einem eigenständigen Konstrukt verbunden sind. Dieser Ansatz bringt jedoch Herausforderungen in Bezug auf Management und Agilität mit sich. Aufgrund seines dezentralen Charakters ist es schwieriger, den betrieblichen Zustand und die Aktivität der Mieter zu aggregieren und zu bewerten. Dies ist eine kostspielige Option, bei der jede OpenSearch Dienstdomäne mindestens über drei Masterknoten und zwei Datenknoten für Produktionsworkloads verfügen muss.
![\[Silomodell „Domäne pro Mandant“ für serverlose Architekturen mit mehreren Mandanten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2195f82-e5ed-40bb-b76a-3b0210bf1254.png)
+ **Index pro Mandant** — Sie können Mandantendaten in separaten Indizes innerhalb eines Serviceclusters platzieren. OpenSearch Bei diesem Ansatz verwenden Sie bei der Erstellung und Benennung des Indexes eine Mandanten-ID, indem Sie die Mandanten-ID dem Indexnamen voranstellen. Der Ansatz „Index pro Mandant“ hilft Ihnen dabei, Ihre Siloziele zu erreichen, ohne für jeden Mandanten einen komplett separaten Cluster einzuführen. Es kann jedoch zu Speicherauslastung kommen, wenn die Anzahl der Indizes zunimmt, da für diesen Ansatz mehr Shards erforderlich sind und der Master-Knoten für mehr Zuweisung und Neuverteilung zuständig sein muss.
![\[Silo-Modell mit Index pro Mandant für serverlose Architekturen mit mehreren Mandanten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/354a9463-25bb-422b-84de-d4875a7c8ea2.png)
**Isolierung im Silomodell — Im Silomodell** verwenden Sie IAM-Richtlinien, um die Domänen oder Indizes zu isolieren, die die Daten der einzelnen Mandanten enthalten. Diese Richtlinien verhindern, dass ein Mandant auf die Daten eines anderen Mandanten zugreift. Um Ihr Silo-Isolationsmodell zu implementieren, können Sie eine ressourcenbasierte Richtlinie erstellen, die den Zugriff auf Ihre Mandantenressource steuert. Dabei handelt es sich häufig um eine Domain-Zugriffsrichtlinie, die festlegt, welche Aktionen ein Principal an den Unterressourcen der Domain durchführen kann, einschließlich Elasticsearch-Indizes und. APIs Mit identitätsbasierten IAM-Richtlinien können Sie *zulässige* oder *verweigerte Aktionen für die Domain, Indizes* oder innerhalb von Service angeben. APIs OpenSearch Das `Action` Element einer IAM-Richtlinie beschreibt die spezifischen Aktionen, die durch die Richtlinie zugelassen oder verweigert werden, und das `Principal ` Element gibt die betroffenen Konten, Benutzer oder Rollen an.
Die folgende Beispielrichtlinie gewährt Tenant-1 vollen Zugriff (wie von angegeben`es:*`) nur auf die Unterressourcen in der Domäne. `tenant-1` Das nachstehende `/*` `Resource` Element weist darauf hin, dass diese Richtlinie für die Unterressourcen der Domain gilt, nicht für die Domain selbst. Wenn diese Richtlinie in Kraft ist, dürfen Mandanten keine neue Domäne erstellen oder Einstellungen für eine bestehende Domäne ändern.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::user/Tenant-1"
},
"Action": "es:*",
"Resource": "arn:aws:es:::domain/tenant-1/*"
}
]
}
```
Um das Silo-Modell „Mandant pro Index“ zu implementieren, müssten Sie diese Beispielrichtlinie ändern, um Tenant-1 weiter auf den angegebenen Index oder die angegebenen Indizes zu beschränken, indem Sie den Indexnamen angeben. Die folgende Beispielrichtlinie beschränkt Tenant-1 auf den 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/*"
}
]
}
```
*Pool-Modell*
Im Poolmodell werden alle Mandantendaten in einem Index innerhalb derselben Domäne gespeichert. Die Mandanten-ID ist in den Daten (Dokument) enthalten und wird als Partitionsschlüssel verwendet, sodass Sie bestimmen können, welche Daten zu welchem Mandanten gehören. Dieses Modell reduziert den Verwaltungsaufwand. Der Betrieb und die Verwaltung des gepoolten Indexes sind einfacher und effizienter als die Verwaltung mehrerer Indizes. Da Mandantendaten jedoch innerhalb desselben Index zusammengefasst sind, verlieren Sie die natürliche Mandantenisolierung, die das Silomodell bietet. Dieser Ansatz kann aufgrund des Noisy-Neighbor-Effekts auch zu Leistungseinbußen führen.
![\[Pool-Modell für serverlose Architekturen mit mehreren Mandanten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2c3bb0f-6ccd-47a7-ab67-e7f3f8c7f289.png)
**Mandantenisolierung im Poolmodell** — Im Allgemeinen ist es schwierig, die Mandantenisolierung im Poolmodell zu implementieren. Der im Silomodell verwendete IAM-Mechanismus ermöglicht es Ihnen nicht, die Isolierung anhand der in Ihrem Dokument gespeicherten Mandanten-ID zu beschreiben.
Ein alternativer Ansatz besteht darin, die FGAC-Unterstützung ([Fine-Grained Access Control](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/fgac.html)) zu verwenden, die von der Open Distro for Elasticsearch bereitgestellt wird. Mit FGAC können Sie Berechtigungen auf Index-, Dokument- oder Feldebene steuern. Bei jeder Anfrage wertet FGAC die Benutzeranmeldedaten aus und authentifiziert den Benutzer entweder oder verweigert den Zugriff. Wenn FGAC den Benutzer authentifiziert, ruft es alle Rollen ab, die diesem Benutzer zugeordnet sind, und verwendet den vollständigen Satz von Berechtigungen, um zu bestimmen, wie die Anfrage behandelt werden soll.
Um die erforderliche Isolierung im Poolmodell zu erreichen, können Sie die [Sicherheit auf Dokumentebene](https://opendistro.github.io/for-elasticsearch-docs/docs/security/access-control/document-level-security/) verwenden, sodass Sie eine Rolle auf eine Teilmenge von Dokumenten in einem Index beschränken können. Die folgende Beispielrolle beschränkt Abfragen auf Tenant-1. Indem Sie diese Rolle auf Tenant-1 anwenden, können Sie die erforderliche Isolierung erreichen.
```
{
"bool": {
"must": {
"match": {
"tenantId": "Tenant-1"
}
}
}
}
```
*Hybrides Modell*
Das Hybridmodell verwendet eine Kombination der Silo- und Poolmodelle in derselben Umgebung, um jedem Mieter (z. B. kostenlose Tarife, Standard- und Premium-Tarife) einzigartige Erlebnisse zu bieten. Jede Stufe folgt demselben Sicherheitsprofil, das im Poolmodell verwendet wurde.
![\[Hybridmodell für serverlose Architekturen mit mehreren Mandanten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/e7def98a-38ef-435a-9881-7e95ae4d4940.png)
**Mandantenisolierung im Hybridmodell** — Im Hybridmodell verwenden Sie dasselbe Sicherheitsprofil wie im Poolmodell, wo die Verwendung des FGAC-Sicherheitsmodells auf Dokumentenebene die Mandantenisolierung ermöglichte. Diese Strategie vereinfacht zwar die Clusterverwaltung und bietet Flexibilität, verkompliziert aber andere Aspekte der Architektur. Ihr Code erfordert beispielsweise zusätzliche Komplexität, um zu bestimmen, welches Modell jedem Mandanten zugeordnet ist. Sie müssen außerdem sicherstellen, dass Abfragen für einzelne Mandanten nicht die gesamte Domäne überlasten und die Benutzererfahrung für andere Mandanten beeinträchtigen.
**Testen im API Gateway**
*Testfenster für Tenant-1-Abfrage*
![\[Testfenster für Tenant-1-Abfrage.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/a6757d3f-977a-4ecc-90cb-83ab7f1c3588.png)
*Testfenster für Tenant-2-Abfrage*
![\[Testfenster für Tenant-2-Abfrage.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/31bfd656-33ca-4750-b6e6-da4d703c2071.png)
## Anlagen
[Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/750196bb-03f6-4b6e-92cd-eb7141602547/attachments/attachment.zip)
# Stellen Sie Multi-Stack-Anwendungen mithilfe von AWS CDK bereit mit TypeScript
*Dr. Rahul Sharad Gaikwad, Amazon Web Services*
## Zusammenfassung
Dieses Muster bietet einen step-by-step Ansatz für die Anwendungsbereitstellung auf Amazon Web Services (AWS) mithilfe des AWS Cloud Development Kit (AWS CDK) mit TypeScript. Das Muster stellt beispielsweise eine serverlose Echtzeit-Analyseanwendung bereit.
Das Muster erstellt und implementiert verschachtelte Stack-Anwendungen. Der übergeordnete CloudFormation AWS-Stack ruft die untergeordneten oder verschachtelten Stacks auf. Jeder untergeordnete Stack erstellt und stellt die AWS-Ressourcen bereit, die im CloudFormation Stack definiert sind. AWS CDK Toolkit, der Befehl Command Line Interface (CLI)`cdk`, ist die primäre Schnittstelle für die CloudFormation Stacks.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto
+ Bestehende virtuelle private Cloud (VPC) und Subnetze
+ AWS CDK Toolkit installiert und konfiguriert
+ Ein Benutzer mit Administratorrechten und einer Reihe von Zugriffsschlüsseln.
+ Node.js
+ AWS-Befehlszeilenschnittstelle (AWS Command Line Interface, AWS CLI)
**Einschränkungen**
+ Da AWS CDK AWS verwendet CloudFormation, unterliegen AWS CDK-Anwendungen CloudFormation Service-Kontingenten. Weitere Informationen finden Sie unter [ CloudFormation AWS-Kontingente](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
**Produktversionen**
Dieses Muster wurde mit den folgenden Tools und Versionen erstellt und getestet.
+ AWS-CDK-Toolkit 1.83.0
+ Node.js 14,13.0
+ npm 7.0.14
Das Muster sollte mit jeder Version von AWS CDK oder npm funktionieren. Beachten Sie, dass die Versionen 13.0.0 bis 13.6.0 von Node.js nicht mit dem AWS CDK kompatibel sind.
## Architektur
**Zieltechnologie-Stack**
+ AWS Amplify Amplify-Konsole
+ 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)
**Zielarchitektur**
Das folgende Diagramm zeigt die Bereitstellung mehrerer Stack-Anwendungen mithilfe von AWS CDK mit. TypeScript
![\[Stack-Architektur in der VPC mit einem übergeordneten Stack und zwei untergeordneten Stacks, die Ressourcen enthalten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/8f92e86a-aa3d-4f8a-9b11-b92c52a7226c.png)
Das folgende Diagramm zeigt die Architektur der beispielhaften serverlosen Echtzeitanwendung.
![\[Anwendungsarchitektur in der Region.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/2df00faf-f871-4aec-9655-19ba2eb14cf8.png)
## Tools
**Tools**
+ Die [AWS Amplify Console](https://docs.aws.amazon.com/amplify/latest/userguide/welcome.html) ist das Kontrollzentrum für Full-Stack-Bereitstellungen von Web- und Mobilanwendungen in AWS. Amplify Console Hosting bietet einen Git-basierten Workflow für das Hosten serverloser Full-Stack-Web-Apps mit kontinuierlicher Bereitstellung. Die Admin-Benutzeroberfläche ist eine visuelle Oberfläche für Frontend-Web- und Mobilentwickler, um App-Backends außerhalb der AWS-Konsole zu erstellen und zu verwalten.
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ist ein AWS-Service für die Erstellung, Veröffentlichung, Wartung, Überwachung und Sicherung von REST, HTTP und WebSocket APIs in jeder Größenordnung.
+ Das [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) ist ein Softwareentwicklungs-Framework, das Sie bei der Definition und Bereitstellung der AWS-Cloud-Infrastruktur im Code unterstützt.
+ [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/latest/guide/cli.html) ist ein Befehlszeilen-Cloud-Entwicklungskit, das Sie bei der Interaktion mit Ihrer AWS-CDK-App unterstützt. Der `cdk` CLI-Befehl ist das wichtigste Tool für die Interaktion mit Ihrer AWS-CDK-App. Es führt Ihre App aus, fragt das von Ihnen definierte Anwendungsmodell ab und erstellt und stellt die vom AWS-CDK generierten CloudFormation AWS-Vorlagen bereit.
+ [Amazon CloudFront](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) ist ein Webservice, der die Verteilung statischer und dynamischer Webinhalte wie .html-, .css-, .js- und Bilddateien beschleunigt. CloudFront stellt Ihre Inhalte über ein weltweites Netzwerk von Rechenzentren bereit, die als Edge-Standorte bezeichnet werden, um die Latenz zu verringern und die Leistung zu verbessern.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) bietet Authentifizierung, Autorisierung und Benutzerverwaltung für Ihre Web- und mobilen Apps. Ihre Benutzer können sich direkt oder über einen Drittanbieter anmelden.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbankservice, der schnelle und vorhersehbare Leistung mit nahtloser Skalierbarkeit bietet.
+ [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) ist ein vollständig verwalteter Service für die Bereitstellung von [Echtzeit-Streaming-Daten](https://aws.amazon.com/streaming-data/) an Ziele wie Amazon S3, Amazon Redshift, Amazon OpenSearch Service, Splunk und alle benutzerdefinierten HTTP-Endpunkte oder HTTP-Endpunkte, die unterstützten Drittanbietern gehören.
+ [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) ist ein Service zum Sammeln und Verarbeiten großer Datenströme in Echtzeit.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Rechenservice, der die Ausführung von Code unterstützt, ohne Server bereitzustellen oder zu verwalten. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde. Sie bezahlen nur für die Datenverarbeitungszeit, die Sie wirklich nutzen und es werden keine Gebühren in Rechnung gestellt, wenn Ihr Code nicht ausgeführt wird.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
**Code**
Der Code für dieses Muster ist angehängt.
## Epen
### Installieren Sie das AWS CDK Toolkit
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Installieren Sie das AWS CDK Toolkit. | Führen Sie den folgenden Befehl aus, um AWS CDK Toolkit global zu installieren.`npm install -g aws-cdk` | DevOps |
| Überprüfen Sie die Version. | Führen Sie den folgenden Befehl aus, um die Version des AWS CDK Toolkit zu überprüfen. `cdk --version` | DevOps |
### AWS-Anmeldeinformationen einrichten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Richten Sie Anmeldeinformationen ein. | Um Anmeldeinformationen einzurichten, führen Sie den `aws configure` Befehl aus und folgen Sie den Anweisungen.$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 |
### Laden Sie den Projektcode herunter
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Laden Sie den beigefügten Projektcode herunter. | Weitere Informationen zur Verzeichnis- und Dateistruktur finden Sie im Abschnitt *Zusätzliche Informationen*. | DevOps |
### Bootstrap für die AWS-CDK-Umgebung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Bootstrap für die Umgebung. | Führen Sie den folgenden Befehl aus, um die CloudFormation AWS-Vorlage für das Konto und die AWS-Region bereitzustellen, die Sie verwenden möchten.`cdk bootstrap /`Weitere Informationen finden Sie in der [AWS-Dokumentation](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html). | DevOps |
### Erstellen und implementieren Sie das Projekt
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie das Projekt. | Führen Sie den `npm run build` Befehl aus, um den Projektcode zu erstellen. | DevOps |
| Stellen Sie das Projekt bereit. | Führen Sie den `cdk deploy` Befehl aus, um den Projektcode bereitzustellen. | |
### Überprüfen Sie die Ausgaben
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Überprüfen Sie die Stack-Erstellung. | Wählen Sie in der AWS-Managementkonsole **CloudFormation**. Vergewissern Sie sich, dass in den Stacks für das Projekt ein übergeordneter Stack und zwei untergeordnete Stapel erstellt wurden. | DevOps |
### Testen der Anwendung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Senden Sie Daten an Kinesis Data Streams. | Konfigurieren Sie Ihr AWS-Konto so, dass Daten mithilfe von Amazon Kinesis Data Generator (KDG) an Kinesis Data Streams gesendet werden. Weitere Informationen finden Sie unter [Amazon Kinesis Data Generator](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html). | DevOps |
| Erstellen Sie einen Amazon Cognito Cognito-Benutzer. | [Um einen Amazon Cognito Cognito-Benutzer zu erstellen, laden Sie die CloudFormation Vorlage cognito-setup.json aus dem Abschnitt *Amazon Cognito Cognito-Benutzer erstellen auf der Kinesis* Data Generator-Hilfeseite herunter.](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) Initiieren Sie die Vorlage und geben Sie dann Ihren Amazon Cognito **Cognito-Benutzernamen** und Ihr **Passwort ein**.Auf der Registerkarte **Ausgaben** ist die Kinesis Data Generator-URL aufgeführt. | DevOps |
| Melden Sie sich bei Kinesis Data Generator an | Um sich bei KDG anzumelden, verwenden Sie die von Ihnen angegebenen Amazon Cognito Cognito-Anmeldeinformationen und die Kinesis Data Generator-URL. | DevOps |
| Testen Sie die Anwendung. | **Fügen Sie in KDG in **Record template**, **Template 1**, den Testcode aus dem Abschnitt *Zusätzliche Informationen* ein und wählen Sie Daten senden aus.** | DevOps |
| Testen Sie das API Gateway. | Nachdem die Daten aufgenommen wurden, testen Sie API Gateway, indem Sie die `GET` Methode zum Abrufen von Daten verwenden. | DevOps |
## Zugehörige Ressourcen
**Referenzen**
+ [AWS-Cloud-Entwicklungskit](https://aws.amazon.com/cdk/)
+ [AWS CDK auf GitHub](https://github.com/aws/aws-cdk)
+ [Arbeiten mit verschachtelten Stacks](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
+ [AWS-Beispielbeispiel — Serverlose Echtzeitanalysen](https://github.com/aws-samples/serverless-realtime-analytics)
## Zusätzliche Informationen
**Verzeichnis- und Dateidetails**
Dieses Muster setzt die folgenden drei Stapel zusammen.
+ `parent-cdk-stack.ts`— Dieser Stapel fungiert als übergeordneter Stapel und ruft die beiden untergeordneten Anwendungen als verschachtelte Stapel auf.
+ `real-time-analytics-poc-stack.ts`— Dieser verschachtelte Stapel enthält die Infrastruktur und den Anwendungscode.
+ `real-time-analytics-web-stack.ts`— Dieser verschachtelte Stapel enthält nur den statischen Webanwendungscode.
*Wichtige Dateien und ihre Funktionalität*
+ `bin/real-time-analytics-poc.ts`— Einstiegspunkt der AWS-CDK-Anwendung. Es lädt alle Stacks, die unter definiert sind. `lib/`
+ `lib/real-time-analytics-poc-stack.ts`— Definition des Stacks der AWS-CDK-Anwendung (`real-time-analytics-poc`).
+ `lib/real-time-analytics-web-stack.ts`— Definition des Stacks der AWS-CDK-Anwendung (`real-time-analytics-web-stack`).
+ `lib/parent-cdk-stack.ts`— Definition des Stacks der AWS-CDK-Anwendung (`parent-cdk`).
+ `package.json`— Das NPM-Modulmanifest, das den Namen, die Version und die Abhängigkeiten der Anwendung enthält.
+ `package-lock.json`— Wird von npm verwaltet.
+ `cdk.json`— Toolkit zum Ausführen der Anwendung.
+ `tsconfig.json`— Die TypeScript Konfiguration des Projekts.
+ `.gitignore`— Liste der Dateien, die Git von der Quellcodeverwaltung ausschließen soll.
+ `node_modules`— Wird von npm verwaltet; beinhaltet die Abhängigkeiten des Projekts.
Der folgende Codeabschnitt im übergeordneten Stack ruft untergeordnete Anwendungen als verschachtelte AWS-CDK-Stacks auf.
```
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 zum Testen**
```
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})}}|
```
**Testen des API Gateway**
Testen Sie API Gateway auf der API Gateway Gateway-Konsole mithilfe der `GET` Methode.
![\[API-Gateway-Konsole, bei der GET unter OPTIONS ausgewählt wurde.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/452e5b8f-6d61-401d-8484-e5a436cb6f1b.png)
## Anlagen
[Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/0ac29a11-1362-4084-92ed-6b85205763ca/attachments/attachment.zip)
# Automatisieren Sie die Bereitstellung verschachtelter Anwendungen mit AWS SAM
*Dr. Rahul Sharad Gaikwad, Ishwar Chauthaiwale, Dmitry Gulin und Tabby Ward, Amazon Web Services*
## Zusammenfassung
Auf Amazon Web Services (AWS) ist das AWS Serverless Application Model (AWS SAM) ein Open-Source-Framework, das Kurzsyntax zum Ausdrücken von Funktionen APIs, Datenbanken und Zuordnungen von Ereignisquellen bereitstellt. Mit nur wenigen Zeilen für jede Ressource können Sie die gewünschte Anwendung definieren und sie mithilfe von YAML modellieren. Während der Bereitstellung transformiert und erweitert SAM die SAM-Syntax in CloudFormation AWS-Syntax, mit der Sie serverlose Anwendungen schneller erstellen können.
AWS SAM vereinfacht die Entwicklung, Bereitstellung und Verwaltung serverloser Anwendungen auf der AWS-Plattform. Es bietet ein standardisiertes Framework, eine schnellere Bereitstellung, lokale Testfunktionen, Ressourcenmanagement, eine nahtlose Integration mit Entwicklungstools und eine unterstützende Community. Diese Funktionen machen es zu einem wertvollen Tool für die effiziente und effektive Erstellung serverloser Anwendungen.
Dieses Muster verwendet AWS-SAM-Vorlagen, um die Bereitstellung verschachtelter Anwendungen zu automatisieren. Eine verschachtelte Anwendung ist eine Anwendung innerhalb einer anderen Anwendung. Übergeordnete Anwendungen rufen ihre untergeordneten Anwendungen auf. Dies sind lose miteinander verbundene Komponenten einer serverlosen Architektur.
Mithilfe verschachtelter Anwendungen können Sie schnell hochentwickelte serverlose Architekturen erstellen, indem Sie Services oder Komponenten wiederverwenden, die unabhängig erstellt und verwaltet wurden, aber mithilfe von AWS SAM und dem Serverless Application Repository zusammengestellt wurden. Verschachtelte Anwendungen helfen Ihnen dabei, leistungsstärkere Anwendungen zu erstellen, Doppelarbeit zu vermeiden und Konsistenz und bewährte Verfahren in Ihren Teams und Organisationen sicherzustellen. Um verschachtelte Anwendungen zu demonstrieren, stellt das Muster eine [serverlose AWS-Einkaufswagen-Beispielanwendung](https://github.com/aws-samples/aws-sam-nested-stack-sample) bereit.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto
+ Eine bestehende virtuelle private Cloud (VPC) und Subnetze
+ Eine integrierte Entwicklungsumgebung wie Visual Studio Code (weitere Informationen finden Sie unter [Tools to Build on AWS](https://aws.amazon.com/getting-started/tools-sdks/#IDE_and_IDE_Toolkits))
+ Die Python-Wheel-Bibliothek wurde mit Pip Install Wheel installiert, falls sie noch nicht installiert ist
**Einschränkungen**
+ Die maximale Anzahl von Anwendungen, die in einer serverlosen Anwendung verschachtelt werden können, beträgt 200.
+ Die maximale Anzahl von Parametern für eine verschachtelte Anwendung kann 60 betragen.
**Produktversionen**
+ Diese Lösung basiert auf der AWS SAM-Befehlszeilenschnittstelle (AWS SAM CLI) Version 1.21.1, aber diese Architektur sollte mit späteren AWS SAM CLI-Versionen funktionieren.
## Architektur
**Zieltechnologie-Stack**
+ Amazon API Gateway
+ AWS SAM
+ Amazon Cognito
+ Amazon DynamoDB
+ AWS Lambda
+ Amazon Simple Queue Service-Warteschlange (Amazon SQS)
**Zielarchitektur**
Das folgende Diagramm zeigt, wie Benutzeranfragen per Anruf an die Einkaufsdienste gestellt werden APIs. Die Anfrage des Benutzers, einschließlich aller erforderlichen Informationen, wird an Amazon API Gateway und den Amazon Cognito Authorizer gesendet, der Authentifizierungs- und Autorisierungsmechanismen für die durchführt. APIs
Wenn ein Element in DynamoDB hinzugefügt, gelöscht oder aktualisiert wird, wird ein Ereignis in DynamoDB Streams abgelegt, wodurch wiederum eine Lambda-Funktion ausgelöst wird. Um zu verhindern, dass alte Elemente im Rahmen eines synchronen Workflows sofort gelöscht werden, werden Nachrichten in eine SQS-Warteschlange gestellt, wodurch eine Worker-Funktion zum Löschen der Nachrichten ausgelöst wird.
![\[POST- und PUT-Operationen vom API Gateway über Lambda-Funktionen bis hin zu DynamoDB und Product Service.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5b454bae-5fd4-405d-a37d-6bafc3fcf889.png)
In diesem Lösungs-Setup dient AWS SAM CLI als Schnittstelle für CloudFormation AWS-Stacks. AWS-SAM-Vorlagen stellen automatisch verschachtelte Anwendungen bereit. Die übergeordnete SAM-Vorlage ruft die untergeordneten Vorlagen auf, und der übergeordnete CloudFormation Stack stellt die untergeordneten Stacks bereit. Jeder untergeordnete Stack erstellt die AWS-Ressourcen, die in den CloudFormation AWS-SAM-Vorlagen definiert sind.
![\[Vierstufiger Prozess mit AWS SAM CLI mit einem übergeordneten und drei untergeordneten CloudFormation Stacks.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5828026e-72ad-4a3f-a5f2-bffac0f13e42.png)
1. Erstellen und implementieren Sie die Stacks.
1. Der CloudFormation Auth-Stack enthält Amazon Cognito.
1. Der CloudFormation Produkt-Stack enthält eine Lambda-Funktion und Amazon API Gateway
1. Der CloudFormation Shopping-Stack enthält eine Lambda-Funktion, Amazon API Gateway, die SQS-Warteschlange und die Amazon DynamoDB DynamoDB-Datenbank.
## Tools
**Tools**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) unterstützt Sie bei der Erstellung, Veröffentlichung, Wartung, Überwachung und Sicherung von REST, HTTP und WebSocket APIs in jeder Größenordnung.
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) hilft Ihnen dabei, AWS-Ressourcen einzurichten, sie schnell und konsistent bereitzustellen und sie während ihres gesamten Lebenszyklus über AWS-Konten und Regionen hinweg zu verwalten.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) bietet Authentifizierung, Autorisierung und Benutzerverwaltung für Web- und mobile Apps.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Er führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen.
+ Das [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) ist ein Open-Source-Framework, mit dem Sie serverlose Anwendungen in der AWS-Cloud erstellen können.
+ [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) bietet eine sichere, dauerhafte und verfügbare gehostete Warteschlange, mit der Sie verteilte Softwaresysteme und -komponenten integrieren und entkoppeln können.
**Code**
Der Code für dieses Muster ist im GitHub [AWS SAM Nested Stack Sample](https://github.com/aws-samples/aws-sam-nested-stack-sample) Repository verfügbar.
## Epen
### Installieren Sie AWS SAM CLI
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Installieren Sie AWS SAM CLI. | Informationen zur Installation von AWS SAM CLI finden Sie in der [AWS SAM-Dokumentation](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). | DevOps Ingenieur |
| Richten Sie AWS-Anmeldeinformationen ein. | Um AWS-Anmeldeinformationen so einzurichten, dass die AWS SAM CLI in Ihrem Namen AWS-Services aufrufen kann, führen Sie den `aws configure` Befehl aus und folgen Sie den Anweisungen.$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]: your_secret_access_key
Default region name [None]:
Default output format [None]:
Weitere Informationen zur Einrichtung Ihrer Anmeldeinformationen finden Sie unter [Authentifizierungs- und Zugangsdaten](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html). | DevOps Ingenieur |
### Initialisieren Sie das AWS-SAM-Projekt
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das AWS-SAM-Code-Repository. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps Ingenieur |
| Stellen Sie Vorlagen bereit, um das Projekt zu initialisieren. | Führen Sie den Befehl aus, um das Projekt zu initialisieren. `SAM init` Wenn Sie aufgefordert werden, eine Vorlagenquelle auszuwählen, wählen Sie`Custom Template Location`. | DevOps Ingenieur |
### Kompilieren und erstellen Sie den SAM-Vorlagencode
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Sehen Sie sich die AWS-SAM-Anwendungsvorlagen an. | Überprüfen Sie die Vorlagen für die verschachtelten Anwendungen. In diesem Beispiel werden die folgenden verschachtelten Anwendungsvorlagen verwendet:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps Ingenieur |
| Überprüfen Sie die übergeordnete Vorlage. | Prüfen Sie die Vorlage, mit der die verschachtelten Anwendungsvorlagen aufgerufen werden. In diesem Beispiel ist die übergeordnete Vorlage. `template.yml` Alle separaten Anwendungen sind in der einzigen übergeordneten Vorlage `template.yml` verschachtelt. | DevOps Ingenieur |
| Kompilieren und erstellen Sie den AWS-SAM-Vorlagencode. | Führen Sie mit der AWS SAM CLI den folgenden Befehl aus.sam build
| DevOps Ingenieur |
### Stellen Sie die AWS-SAM-Vorlage bereit
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Stellen Sie die Anwendungen bereit. | Führen Sie den folgenden Befehl aus, um den SAM-Vorlagencode zu starten, der die verschachtelten CloudFormation Anwendungsstapel erstellt und Code in der AWS-Umgebung bereitstellt.sam deploy --guided --stack-name shopping-cart-nested-stack --capabilities CAPABILITY_IAM CAPABILITY_AUTO_EXPAND
Der Befehl wird Sie mit einigen Fragen auffordern. Beantworten Sie alle Fragen mit`y`. | DevOps Ingenieur |
### Überprüfen der Bereitstellung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Überprüfe die Stapel. | Gehen Sie wie folgt vor, um die CloudFormation AWS-Stacks und AWS-Ressourcen zu überprüfen, die in den AWS-SAM-Vorlagen definiert wurden:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps Ingenieur |
## Zugehörige Ressourcen
**Referenzen**
+ [Serverloses AWS-Anwendungsmodell (AWS SAM)](https://aws.amazon.com/serverless/sam/#:~:text=The%20AWS%20Serverless%20Application%20Model,and%20model%20it%20using%20YAML.)
+ [AWS SAM auf GitHub](https://github.com/aws/serverless-application-model)
+ [Serverloser Einkaufswagen-Microservice](https://github.com/aws-samples/aws-serverless-shopping-cart) (AWS-Beispielanwendung)
**Tutorials und Videos**
+ [Erstellen Sie eine serverlose App](https://youtu.be/Hv3YrP8G4ag)
+ [AWS Online Tech Talks: Serverlose Anwendungsentwicklung und -bereitstellung mit AWS SAM](https://youtu.be/1NU7vyJw9LU)
## Zusätzliche Informationen
Nachdem der gesamte Code vorhanden ist, hat das Beispiel die folgende Verzeichnisstruktur:
+ [sam\$1stacks](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html) — Dieser Ordner enthält die Ebene. `shared.py` Eine Ebene ist ein Dateiarchiv, das Bibliotheken, eine benutzerdefinierte Runtime oder andere Abhängigkeiten enthält. Mit Ebenen können Sie Bibliotheken in Ihrer Funktion verwenden, ohne sie in ein Bereitstellungspaket aufnehmen zu müssen.
+ *product-mock-service*— Dieser Ordner enthält alle produktbezogenen Lambda-Funktionen und -Dateien.
+ *shopping-cart-service*— Dieser Ordner enthält alle Lambda-Funktionen und -Dateien zum Einkaufen.
# Implementieren Sie die SaaS-Mandantenisolierung für Amazon S3 mithilfe eines AWS Lambda Token-Verkaufsautomaten
*Tabby Ward, Thomas Davis und Sravan Periyathambi, Amazon Web Services*
## Zusammenfassung
Mehrmandantenfähige SaaS-Anwendungen müssen Systeme implementieren, um sicherzustellen, dass die Mandantenisolierung aufrechterhalten wird. Wenn Sie Mandantendaten auf derselben AWS Ressource speichern, z. B. wenn mehrere Mandanten Daten in demselben Amazon Simple Storage Service (Amazon S3) -Bucket speichern, müssen Sie sicherstellen, dass kein mandantenübergreifender Zugriff möglich ist. Token-Verkaufsautomaten (TVMs) sind eine Möglichkeit, die Daten von Mietern zu isolieren. Diese Maschinen bieten einen Mechanismus zum Abrufen von Token und abstrahieren gleichzeitig die Komplexität der Token-Generierung. Entwickler können ein TVM verwenden, ohne detaillierte Kenntnisse darüber zu haben, wie es Token produziert.
Dieses Muster implementiert ein TVM mithilfe von. AWS Lambda Das TVM generiert ein Token, das aus temporären STS-Anmeldeinformationen (Security Token Service) besteht, die den Zugriff auf die Daten eines einzelnen SaaS-Mandanten in einem S3-Bucket einschränken.
TVMs, und der Code, der mit diesem Muster bereitgestellt wird, werden in der Regel mit Ansprüchen verwendet, die von JSON-Web-Tokens (JWTs) abgeleitet sind, um Anfragen nach AWS Ressourcen mit einer AWS Identity and Access Management mandantenbezogenen Richtlinie (IAM) zu verknüpfen. Sie können den Code in diesem Muster als Grundlage für die Implementierung einer SaaS-Anwendung verwenden, die temporäre STS-Anmeldeinformationen mit Gültigkeitsbereich auf der Grundlage der in einem JWT-Token bereitgestellten Ansprüche generiert.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktiver. AWS-Konto
+ AWS Command Line Interface (AWS CLI) [Version 1.19.0 oder höher](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html), installiert und konfiguriert auf macOS, Linux oder Windows. Alternativ können Sie AWS CLI [Version 2.1 oder höher](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html) verwenden.
**Einschränkungen**
+ Dieser Code läuft in Java und unterstützt derzeit keine anderen Programmiersprachen.
+ Die Beispielanwendung bietet keine AWS regionsübergreifende Unterstützung oder Unterstützung für Disaster Recovery (DR).
+ Dieses Muster zeigt, wie ein Lambda-TVM für eine SaaS-Anwendung begrenzten Mandantenzugriff bereitstellen kann. Dieses Muster ist nicht für die Verwendung in Produktionsumgebungen ohne zusätzliche Sicherheitstests als Teil Ihrer spezifischen Anwendung oder Ihres Anwendungsfalls vorgesehen.
## Architektur
**Zieltechnologie-Stack**
+ AWS Lambda
+ Amazon S3
+ IAM
+ AWS -Security-Token-Service (AWS STS)
**Zielarchitektur**
![\[Generieren eines Tokens, um temporäre STS-Anmeldeinformationen für den Zugriff auf Daten in einem S3-Bucket zu erhalten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/14d0508a-703b-4229-85e6-c5094de7fe01.png)
## Tools
**AWS-Services**
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie AWS-Services über Befehle in Ihrer Befehlszeilen-Shell interagieren können.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS Ressourcen sicher zu verwalten, indem es kontrolliert, wer authentifiziert und autorisiert ist, diese zu verwenden.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen.
+ [AWS -Security-Token-Service (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) hilft Ihnen dabei, temporäre Anmeldeinformationen mit eingeschränkten Rechten für Benutzer anzufordern.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
**Code**
Der Quellcode für dieses Muster ist als Anlage verfügbar und umfasst die folgenden Dateien:
+ `s3UploadSample.jar`stellt den Quellcode für eine Lambda-Funktion bereit, die ein JSON-Dokument in einen S3-Bucket hochlädt.
+ `tvm-layer.zip`stellt eine wiederverwendbare Java-Bibliothek bereit, die ein Token (temporäre STS-Anmeldeinformationen) für die Lambda-Funktion bereitstellt, um auf den S3-Bucket zuzugreifen und das JSON-Dokument hochzuladen.
+ `token-vending-machine-sample-app.zip`stellt den Quellcode bereit, der zur Erstellung dieser Artefakte und Kompilierungsanweisungen verwendet wurde.
Folgen Sie den Anweisungen im nächsten Abschnitt, um diese Dateien zu verwenden.
## Epen
### Ermitteln Sie Variablenwerte
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Ermitteln Sie Variablenwerte. | Die Implementierung dieses Musters umfasst mehrere Variablennamen, die konsistent verwendet werden müssen. Ermitteln Sie die Werte, die für jede Variable verwendet werden sollen, und geben Sie diesen Wert an, wenn Sie in den nachfolgenden Schritten dazu aufgefordert werden.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine.html) | Cloud-Administrator |
### Erstellen eines S3-Buckets
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie einen S3-Bucket für die Beispielanwendung. | Verwenden Sie den folgenden AWS CLI Befehl, um einen S3-Bucket zu erstellen. Geben Sie den ``**** Wert im Codeausschnitt an:aws s3api create-bucket --bucket
Die Lambda-Beispielanwendung lädt JSON-Dateien in diesen Bucket hoch. | Cloud-Administrator |
### Erstellen Sie die IAM-TVM-Rolle und -Richtlinie
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie eine TVM-Rolle. | Verwenden Sie einen der folgenden AWS CLI Befehle, um eine IAM-Rolle zu erstellen. Geben Sie den ``**** Wert im Befehl ein.Für macOS- oder Linux-Shells: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": ""
}
}
}
]
}'
Für die Windows-Befehlszeile: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\": \"\"}}}]}"
Die Lambda-Beispielanwendung übernimmt diese Rolle, wenn die Anwendung aufgerufen wird. Durch die Möglichkeit, die Anwendungsrolle mit einer bereichsbezogenen Richtlinie zu übernehmen, erhält der Code umfassendere Zugriffsberechtigungen auf den S3-Bucket. | Cloud-Administrator |
| Erstellen Sie eine Inline-TVM-Rollenrichtlinie. | Verwenden Sie einen der folgenden AWS CLI Befehle, um eine IAM-Richtlinie zu erstellen. Geben Sie die `` Werte `` **``**, und im Befehl ein.Für macOS- oder Linux-Shells: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/"
}
]}'
Für die Windows-Befehlszeile: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/\"}]}"
Diese Richtlinie ist der TVM-Rolle zugeordnet. Sie gibt dem Code die Möglichkeit, die Anwendungsrolle zu übernehmen, die über umfassendere Berechtigungen für den Zugriff auf den S3-Bucket verfügt. | Cloud-Administrator |
| Hängen Sie die verwaltete Lambda-Richtlinie an. | Verwenden Sie den folgenden AWS CLI Befehl, um die `AWSLambdaBasicExecutionRole` IAM-Richtlinie anzuhängen. Geben Sie den `` Wert im Befehl ein:aws iam attach-role-policy \
--role-name \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Für die Windows-Befehlszeile:aws iam attach-role-policy ^
--role-name ^
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Diese verwaltete Richtlinie ist der TVM-Rolle zugeordnet, damit Lambda Protokolle an Amazon senden kann. CloudWatch | Cloud-Administrator |
### Erstellen Sie die IAM-Anwendungsrolle und -Richtlinie
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie die Anwendungsrolle. | Verwenden Sie einen der folgenden AWS CLI Befehle, um eine IAM-Rolle zu erstellen. Geben Sie die `` Werte ````, und im Befehl ein.Für macOS- oder Linux-Shells: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"
}
]}'
Für die Windows-Befehlszeile: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\"}]}"
Die Lambda-Beispielanwendung übernimmt diese Rolle mit einer bereichsbezogenen Richtlinie, um mandantenbasierten Zugriff auf einen S3-Bucket zu erhalten. | Cloud-Administrator |
| Erstellen Sie eine Inline-Rollenrichtlinie für Anwendungen. | Verwenden Sie einen der folgenden AWS CLI Befehle, um eine IAM-Richtlinie zu erstellen. Geben Sie die ``**** Werte `` und im Befehl ein.Für macOS- oder Linux-Shells: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:::"
}
]}'
Für die Windows-Befehlszeile: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:::\"}]}"
Diese Richtlinie ist der Anwendungsrolle zugeordnet. Sie bietet umfassenden Zugriff auf Objekte im S3-Bucket. Wenn die Beispielanwendung die Rolle übernimmt, werden diese Berechtigungen anhand der dynamisch generierten Richtlinie des TVM auf einen bestimmten Mandanten beschränkt. | Cloud-Administrator |
### Erstellen Sie die Lambda-Beispielanwendung mit TVM
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Laden Sie die kompilierten Quelldateien herunter. | Laden Sie die `tvm-layer.zip`**** Dateien `s3UploadSample.jar` und herunter, die als Anlagen enthalten sind. Den Quellcode, der zur Erstellung dieser Artefakte verwendet wurde, sowie Anweisungen zur Kompilierung finden Sie unter. `token-vending-machine-sample-app.zip` | Cloud-Administrator |
| Erstellen Sie die Lambda-Schicht. | Verwenden Sie den folgenden AWS CLI Befehl, um eine Lambda-Schicht zu erstellen, die das TVM für Lambda zugänglich macht. Wenn Sie diesen Befehl nicht von dem Speicherort aus ausführen, den Sie heruntergeladen haben` tvm-layer.zip`, geben Sie `tvm-layer.zip` im Parameter den richtigen Pfad zu an. `--zip-file` aws lambda publish-layer-version \
--layer-name sample-token-vending-machine \
--compatible-runtimes java11 \
--zip-file fileb://tvm-layer.zip
Für die Windows-Befehlszeile:aws lambda publish-layer-version ^
--layer-name sample-token-vending-machine ^
--compatible-runtimes java11 ^
--zip-file fileb://tvm-layer.zip
Dieser Befehl erstellt eine Lambda-Schicht, die die wiederverwendbare TVM-Bibliothek enthält. | Cloud-Administrator, App-Entwickler |
| So erstellen Sie die Lambda-Funktion: | Verwenden Sie den folgenden AWS CLI Befehl, um eine Lambda-Funktion zu erstellen. Geben Sie die `` Werte `` ````,``,``, und im Befehl ein. Wenn Sie diesen Befehl nicht von dem Speicherort aus ausführen, den Sie heruntergeladen haben`s3UploadSample.jar`, geben Sie `s3UploadSample.jar` im `--zip-file` Parameter den richtigen Pfad zu an. 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/}"
Für die Windows-Befehlszeile: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/}"
Dieser Befehl erstellt eine Lambda-Funktion mit dem Beispielanwendungscode und der angehängten TVM-Schicht. Außerdem werden zwei Umgebungsvariablen festgelegt: `S3_BUCKET` und. `ROLE` Die Beispielanwendung verwendet diese Variablen, um die zu übernehmende Rolle und den S3-Bucket zu bestimmen, in den JSON-Dokumente hochgeladen werden sollen. | Cloud-Administrator, App-Entwickler |
### Testen Sie die Beispielanwendung und TVM
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Rufen Sie die Lambda-Beispielanwendung auf. | Verwenden Sie einen der folgenden AWS CLI Befehle, um die Lambda-Beispielanwendung mit der erwarteten Nutzlast zu starten. Geben Sie die `` Werte `` und im Befehl ein.Für macOS- und Linux-Shells:aws lambda invoke \
--function \
--invocation-type RequestResponse \
--payload '{"tenant": ""}' \
--cli-binary-format raw-in-base64-out response.json
Für die Windows-Befehlszeile:aws lambda invoke ^
--function ^
--invocation-type RequestResponse ^
--payload "{\"tenant\": \"\"}" ^
--cli-binary-format raw-in-base64-out response.json
Dieser Befehl ruft die Lambda-Funktion auf und gibt das Ergebnis in einem `response.json` Dokument zurück. Auf vielen UNIX-basierten Systemen können Sie `response.json` zu ändern, `/dev/stdout` um die Ergebnisse direkt in Ihrer Shell auszugeben, ohne eine weitere Datei zu erstellen. Wenn Sie den `` Wert in nachfolgenden Aufrufen dieser Lambda-Funktion ändern, werden der Speicherort des JSON-Dokuments und die vom Token bereitgestellten Berechtigungen geändert. | Cloud-Administrator, App-Entwickler |
| Sehen Sie sich den S3-Bucket an, um die erstellten Objekte zu sehen. | Navigieren Sie zu dem S3-Bucket (``), den Sie zuvor erstellt haben. Dieser Bucket enthält ein S3-Objektpräfix mit dem Wert von``. Unter diesem Präfix finden Sie ein JSON-Dokument, das mit einer UUID benannt ist. Wenn Sie die Beispielanwendung mehrmals aufrufen, werden weitere JSON-Dokumente hinzugefügt. | Cloud-Administrator |
| Sehen Sie sich die Protokolle für die Beispielanwendung unter CloudWatch Logs an. | Zeigen Sie die Protokolle an, die der `` in CloudWatch Logs genannten Lambda-Funktion zugeordnet sind. Anweisungen finden Sie in der [Lambda-Dokumentation unter CloudWatch Lambda-Funktionsprotokolle an Logs senden](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html). In diesen Protokollen können Sie die vom TVM generierte Richtlinie für Mandanten einsehen. Diese mandantenbezogene Richtlinie erteilt Amazon S3,, und, und, Berechtigungen für die Beispielanwendung **PutObject**GetObject**DeleteObject******, jedoch nur für das Objektpräfix **ListBucket** APIs, das mit verknüpft ist. `` Wenn Sie bei nachfolgenden Aufrufen der Beispielanwendung eine Änderung vornehmen, aktualisiert der TVM die bereichsbezogene Richtlinie so``, dass sie dem Mandanten entspricht, der in der Aufruf-Payload angegeben ist. Diese dynamisch generierte Richtlinie zeigt, wie der mandantenbezogene Zugriff mit einem TVM in SaaS-Anwendungen aufrechterhalten werden kann. Die TVM-Funktionalität wird in einer Lambda-Schicht bereitgestellt, sodass sie an andere Lambda-Funktionen angehängt werden kann, die von einer Anwendung verwendet werden, ohne dass der Code repliziert werden muss.[Eine Veranschaulichung der dynamisch generierten Richtlinie finden Sie im Abschnitt Zusätzliche Informationen.](#implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine-additional) | Cloud-Administrator |
## Zugehörige Ressourcen
+ [Isolieren von Mandanten mit dynamisch generierten IAM-Richtlinien](https://aws.amazon.com/blogs/apn/isolating-saas-tenants-with-dynamically-generated-iam-policies/) (Blogbeitrag)
+ [Anwendung dynamisch generierter Isolationsrichtlinien in SaaS-Umgebungen](https://aws.amazon.com/blogs/apn/applying-dynamically-generated-isolation-policies-in-saas-environments/) (Blogbeitrag)
+ [SaaS auf AWS](https://aws.amazon.com/saas/)
## Zusätzliche Informationen
Das folgende Protokoll zeigt die dynamisch generierte Richtlinie, die durch den TVM-Code in diesem Muster erstellt wurde. In diesem Screenshot sind das „ist“ `DOC-EXAMPLE-BUCKET` und das `` „``ist“ zu sehen. `test-tenant-1` Die von dieser bereichsbezogenen Richtlinie zurückgegebenen STS-Anmeldeinformationen können keine Aktionen für Objekte im S3-Bucket ausführen, mit Ausnahme von Objekten, die dem Objektschlüsselpräfix zugeordnet sind. `test-tenant-1`
![\[Protokoll mit einer dynamisch generierten Richtlinie, die durch den TVM-Code erstellt wurde.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/d4776ebe-fb8f-41ac-b8c5-b4f97a821c8c.png)
## Anlagen
[Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/97a34c8e-d04e-40b6-acbf-1baa176d22a9/attachments/attachment.zip)
# Implementieren Sie das serverlose Saga-Muster mithilfe von AWS Step Functions
*Tabby Ward, Joe Kern und Rohan Mehta, Amazon Web Services*
## Zusammenfassung
In einer Microservices-Architektur besteht das Hauptziel darin, entkoppelte und unabhängige Komponenten zu erstellen, um Agilität, Flexibilität und eine schnellere Markteinführung Ihrer Anwendungen zu fördern. Durch die Entkopplung verfügt jede Microservice-Komponente über eine eigene Datenpersistenzschicht. In einer verteilten Architektur können sich Geschäftstransaktionen über mehrere Microservices erstrecken. Da diese Microservices keine einzige ACID-Transaktion (Atomicity, Consistency, Isolation, Durability) verwenden können, kann es am Ende zu Teiltransaktionen kommen. In diesem Fall ist eine gewisse Kontrolllogik erforderlich, um die bereits verarbeiteten Transaktionen rückgängig zu machen. Zu diesem Zweck wird in der Regel das verteilte Saga-Muster verwendet.
Das Saga-Muster ist ein Fehlermanagementmuster, das dazu beiträgt, Konsistenz in verteilten Anwendungen herzustellen und Transaktionen zwischen mehreren Microservices zu koordinieren, um die Datenkonsistenz aufrechtzuerhalten. Wenn Sie das Saga-Muster verwenden, veröffentlicht jeder Dienst, der eine Transaktion ausführt, ein Ereignis, das nachfolgende Dienste veranlasst, die nächste Transaktion in der Kette auszuführen. Dies wird fortgesetzt, bis die letzte Transaktion in der Kette abgeschlossen ist. Wenn eine Geschäftstransaktion fehlschlägt, orchestriert Saga eine Reihe von Ausgleichstransaktionen, die die Änderungen rückgängig machen, die durch die vorherigen Transaktionen vorgenommen wurden.
Dieses Muster zeigt, wie die Einrichtung und Bereitstellung einer Beispielanwendung (die Reisereservierungen bearbeitet) mit serverlosen Technologien wie AWS Step Functions, AWS Lambda und Amazon DynamoDB automatisiert werden kann. Die Beispielanwendung verwendet auch Amazon API Gateway und Amazon Simple Notification Service (Amazon SNS), um einen Saga-Ausführungskoordinator zu implementieren. Das Muster kann mit einem Infrastructure as Code (IaC) -Framework wie dem AWS Cloud Development Kit (AWS CDK), dem AWS Serverless Application Model (AWS SAM) oder Terraform bereitgestellt werden.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto.
+ Berechtigungen zum Erstellen eines CloudFormation AWS-Stacks. Weitere Informationen finden Sie in der CloudFormation Dokumentation unter [Zugriffskontrolle](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html).
+ IaC-Framework Ihrer Wahl (AWS CDK, AWS SAM oder Terraform), das mit Ihrem AWS-Konto konfiguriert ist, sodass Sie die Framework-CLI zur Bereitstellung der Anwendung verwenden können.
+ NodeJS, wird verwendet, um die Anwendung zu erstellen und lokal auszuführen.
+ Ein Code-Editor Ihrer Wahl (wie Visual Studio Code, Sublime oder Atom).
**Produktversionen**
+ [NodeJS versie 1.4](https://nodejs.org/en/download/)
+ [AWS CDK versie 2.37.1](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install)
+ [AWS-SAM versie 1.71.0](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
+ [Terraform versie 1.3.7](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)
**Einschränkungen**
Event Sourcing ist eine natürliche Methode, um das Saga-Orchestrierungsmuster in einer Microservices-Architektur zu implementieren, in der alle Komponenten lose miteinander verknüpft sind und keine direkte Kenntnis voneinander haben. Wenn Ihre Transaktion eine kleine Anzahl von Schritten (drei bis fünf) umfasst, ist das Saga-Muster möglicherweise hervorragend geeignet. Die Komplexität nimmt jedoch mit der Anzahl der Microservices und der Anzahl der Schritte zu.
Das Testen und Debuggen kann schwierig werden, wenn Sie dieses Design verwenden, da alle Dienste ausgeführt werden müssen, um das Transaktionsmuster zu simulieren.
## Architektur
**Zielarchitektur**
Die vorgeschlagene Architektur verwendet AWS Step Functions, um ein Saga-Muster zu erstellen, um Flüge zu buchen, Mietwagen zu buchen und Zahlungen für einen Urlaub zu verarbeiten.
Das folgende Workflow-Diagramm veranschaulicht den typischen Ablauf des Reisereservierungssystems. Der Workflow besteht aus der Reservierung von Flugreisen (“ ReserveFlight „), der Reservierung eines Autos (“ ReserveCarRental „), der Bearbeitung von Zahlungen (“ ProcessPayment „), der Bestätigung von Flugreservierungen (“ ConfirmFlight „) und der Bestätigung von Mietwagen (“ ConfirmCarRental „), gefolgt von einer Erfolgsmeldung, wenn diese Schritte abgeschlossen sind. Wenn das System jedoch bei der Ausführung einer dieser Transaktionen auf Fehler stößt, schlägt es rückwärts fehl. Beispielsweise löst ein Fehler bei der Zahlungsabwicklung (“ ProcessPayment „) eine Rückerstattung (“ RefundPayment „) aus, was dann zu einer Stornierung des Mietwagens und des Fluges (“ CancelRentalReservation "und" CancelFlightReservation „) führt, wodurch die gesamte Transaktion mit einer Fehlermeldung beendet wird.
Dieses Muster stellt separate Lambda-Funktionen für jede im Diagramm hervorgehobene Aufgabe sowie drei DynamoDB-Tabellen für Flüge, Mietwagen und Zahlungen bereit. Jede Lambda-Funktion erstellt, aktualisiert oder löscht die Zeilen in den jeweiligen DynamoDB-Tabellen, je nachdem, ob eine Transaktion bestätigt oder zurückgesetzt wurde. Das Muster verwendet Amazon SNS, um Textnachrichten (SMS) an Abonnenten zu senden und sie über fehlgeschlagene oder erfolgreiche Transaktionen zu informieren.
![\[Workflow für ein Reisereservierungssystem, das auf dem Saga-Muster basiert.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/daad3e8e-6e6b-41c2-95c1-ca79d53ead64.png)
**Automatisierung und Skalierung**
Sie können die Konfiguration für diese Architektur mithilfe eines der IaC-Frameworks erstellen. Verwenden Sie einen der folgenden Links für Ihre bevorzugte IaC.
+ [Mit AWS CDK bereitstellen](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Mit AWS SAM bereitstellen](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Mit Terraform bereitstellen](https://serverlessland.com/workflows/saga-pattern-tf)
## Tools
**AWS-Services**
+ [AWS Step Functions](https://aws.amazon.com/step-functions/) ist ein serverloser Orchestrierungsservice, mit dem Sie AWS Lambda Lambda-Funktionen und andere AWS-Services kombinieren können, um geschäftskritische Anwendungen zu erstellen. In der grafischen Konsole von Step Functions sehen Sie den Arbeitsablauf Ihrer Anwendung als eine Reihe von ereignisgesteuerten Schritten.
+ [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) ist ein vollständig verwalteter NoSQL-Datenbankservice, der schnelle und vorhersehbare Leistung mit nahtloser Skalierbarkeit bietet. Sie können mit DynamoDB eine Datenbanktabelle erstellen, mit der eine beliebige Datenmenge gespeichert und abgerufen werden kann und der Anforderungsdatenverkehr verarbeitet werden kann.
+ [AWS Lambda](https://aws.amazon.com/lambda/) ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitzustellen oder zu verwalten. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde.
+ [Amazon API Gateway](https://aws.amazon.com/api-gateway/) ist ein AWS-Service für die Erstellung, Veröffentlichung, Wartung, Überwachung und Sicherung von REST, HTTP und WebSocket APIs in jeder Größenordnung.
+ [Amazon Simple Notification Service (Amazon SNS)](https://aws.amazon.com/sns/) ist ein verwalteter Service, der die Nachrichtenzustellung von Verlagen an Abonnenten ermöglicht.
+ Das [AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/) ist ein Softwareentwicklungsframework zur Definition Ihrer Cloud-Anwendungsressourcen mithilfe vertrauter Programmiersprachen wie TypeScript,, Python JavaScript, Java und C\$1/.Net.
+ Das [AWS Serverless Application Model (AWS SAM)](https://aws.amazon.com/serverless/sam/) ist ein Open-Source-Framework für die Erstellung serverloser Anwendungen. Es bietet Kurzsyntax zum Ausdrücken von Funktionen APIs, Datenbanken und Zuordnungen von Ereignisquellen.
**Code**
Den Code für eine Beispielanwendung, die das Saga-Muster demonstriert, einschließlich der IaC-Vorlage (AWS CDK, AWS SAM oder Terraform), der Lambda-Funktionen und der DynamoDB-Tabellen, finden Sie unter den folgenden Links. Folgen Sie den Anweisungen im ersten Epos, um diese zu installieren.
+ [Mit AWS CDK bereitstellen](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Mit AWS SAM bereitstellen](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Mit Terraform bereitstellen](https://serverlessland.com/workflows/saga-pattern-tf)
## Epen
### Pakete installieren, kompilieren und bauen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Installieren Sie die NPM-Pakete. | Erstellen Sie ein neues Verzeichnis, navigieren Sie in einem Terminal zu diesem Verzeichnis und klonen Sie das GitHub Repository Ihrer Wahl aus dem *Codeabschnitt* weiter oben in diesem Muster.Führen Sie im Stammordner, der die `package.json` Datei enthält, den folgenden Befehl aus, um alle Node Package Manager (NPM) -Pakete herunterzuladen und zu installieren:npm install
| Entwickler, Cloud-Architekt |
| Kompilieren Sie Skripte. | Führen Sie im Stammordner den folgenden Befehl aus, um den TypeScript Transpiler anzuweisen, alle erforderlichen JavaScript Dateien zu erstellen:npm run build
| Entwickler, Cloud-Architekt |
| Achten Sie auf Änderungen und kompilieren Sie sie neu. | Führen Sie im Stammordner den folgenden Befehl in einem separaten Terminalfenster aus, um nach Codeänderungen zu suchen, und kompilieren Sie den Code, wenn eine Änderung erkannt wird:npm run watch
| Entwickler, Cloud-Architekt |
| Führen Sie Komponententests durch (nur AWS CDK). | Wenn Sie das AWS-CDK verwenden, führen Sie im Stammordner den folgenden Befehl aus, um die Jest-Komponententests durchzuführen:npm run test
| Entwickler, Cloud-Architekt |
### Ressourcen für das AWS-Zielkonto bereitstellen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Stellen Sie den Demo-Stack auf AWS bereit. | Die Anwendung ist von der AWS-Region unabhängig. Wenn Sie ein Profil verwenden, müssen Sie die Region explizit entweder im [AWS-Befehlszeilenschnittstellen-Profil (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) oder über [AWS-CLI-Umgebungsvariablen deklarieren.](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html)Führen Sie im Stammordner den folgenden Befehl aus, um eine Bereitstellungsassembly zu erstellen und sie für das AWS-Standardkonto und die AWS-Region bereitzustellen.AWS-CDK:cdk bootstrap
cdk deploy
AWS-BETRUG:sam build
sam deploy --guided
Terraform:terraform init
terraform apply
Dieser Schritt kann mehrere Minuten dauern. Dieser Befehl verwendet die Standardanmeldedaten, die für die AWS-CLI konfiguriert wurden.Notieren Sie sich die API Gateway Gateway-URL, die nach Abschluss der Bereitstellung auf der Konsole angezeigt wird. Sie benötigen diese Informationen, um den Saga-Ausführungsablauf zu testen. | Entwickler, Cloud-Architekt |
| Vergleichen Sie den bereitgestellten Stack mit dem aktuellen Status. | Führen Sie im Stammordner den folgenden Befehl aus, um den bereitgestellten Stack mit dem aktuellen Status zu vergleichen, nachdem Sie Änderungen am Quellcode vorgenommen haben:AWS-CDK:cdk diff
AWS-BETRUG:sam deploy
Terraform:terraform plan
| Entwickler, Cloud-Architekt |
### Testen Sie den Ausführungsablauf
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Testen Sie den Ausführungsablauf der Saga. | Navigieren Sie zu der API-Gateway-URL, die Sie im vorherigen Schritt bei der Bereitstellung des Stacks notiert haben. Diese URL löst den Start der Zustandsmaschine aus. Weitere Informationen darüber, wie Sie den Fluss der Zustandsmaschine manipulieren können, indem Sie verschiedene URL-Parameter übergeben, finden Sie im Abschnitt [Zusätzliche Informationen](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional).Um die Ergebnisse anzusehen, melden Sie sich bei der AWS-Managementkonsole an und navigieren Sie zur Step Functions Functions-Konsole. Hier können Sie jeden Schritt der Saga State Machine sehen. Sie können auch die DynamoDB-Tabelle anzeigen, um die eingefügten, aktualisierten oder gelöschten Datensätze zu sehen. Wenn Sie den Bildschirm häufig aktualisieren, können Sie beobachten, wie sich der Transaktionsstatus von `pending` zu ändert. `confirmed` Sie können das SNS-Thema abonnieren, indem Sie den Code in der `stateMachine.ts` Datei mit Ihrer Handynummer aktualisieren, um SMS-Nachrichten bei erfolgreichen oder fehlgeschlagenen Reservierungen zu erhalten. Weitere Informationen finden Sie unter *Amazon SNS* im Abschnitt [Zusätzliche Informationen](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional). | Entwickler, Cloud-Architekt |
### Bereinigen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Bereinigen Sie die Ressourcen. | Um die für diese Anwendung bereitgestellten Ressourcen zu bereinigen, können Sie einen der folgenden Befehle verwenden.AWS-CDK:cdk destroy
AWS-BETRUG:sam delete
Terraform:terraform destroy
| App-Entwickler, Cloud-Architekt |
## Zugehörige Ressourcen
**Technische Dokumente**
+ [Implementierung von Microservices auf AWS](https://docs.aws.amazon.com/pdfs/whitepapers/latest/microservices-on-aws/microservices-on-aws.pdf)
+ [Linse für serverlose Anwendungen](https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html)
**AWS-Servicedokumentation**
+ [Erste Schritte mit dem AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html)
+ [Erste Schritte mit 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/)
**Tutorials**
+ [Praktische Workshops zum Thema Serverless Computing](https://aws.amazon.com/serverless-workshops/)
## Zusätzliche Informationen
**Code**
Zu Testzwecken stellt dieses Muster API Gateway und eine Test-Lambda-Funktion bereit, die die Step Functions Functions-Zustandsmaschine auslöst. Mit Step Functions können Sie die Funktionalität des Reisereservierungssystems steuern, indem Sie einen `run_type` Parameter übergeben, um Fehler in "ReserveFlight,“ "ReserveCarRental,“ ",“ "ProcessPayment,“ und "ConfirmFlight“ nachzuahmenConfirmCarRental.
Die `saga` Lambda-Funktion (`sagaLambda.ts`) nimmt Eingaben aus den Abfrageparametern in der API-Gateway-URL entgegen, erstellt das folgende JSON-Objekt und übergibt es zur Ausführung an Step Functions:
```
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"
};
```
Sie können mit verschiedenen Abläufen der Step Functions Functions-Zustandsmaschine experimentieren, indem Sie die folgenden URL-Parameter übergeben:
+ **Erfolgreiche Ausführung** ─ https://\$1api gateway url\$1
+ **Flug reservieren gescheitert** ─ https://\$1api Gateway-URL\$1? **Ausführungstyp = failFlightsReservation**
+ **Flugfehler bestätigen ─ https://\$1api** Gateway-URL\$1? **Ausführungstyp = failFlightsConfirmation**
+ **Mietwagen-Reservierung ist fehlgeschlagen** ─ https://\$1api Gateway-URL\$1? **runType= Reservierung failCarRental**
+ **Bestätigen Sie, dass die Autovermietung fehlgeschlagen** ist ─ https://\$1api Gateway-URL\$1? **runType= Bestätigung failCarRental**
+ **Zahlungsvorgang fehlgeschlagen** ─ https://\$1api Gateway-URL\$1? **runType=Zahlung fehlschlagen**
+ **Eine Reise-ID weitergeben** ─ https://\$1api Gateway-URL\$1? **TripId=** \$1Standardmäßig ist die Reise-ID die AWS-Anfrage-ID\$1
**IaC-Vorlagen**
Die verknüpften Repositorien enthalten IaC-Vorlagen, mit denen Sie den gesamten Musterantrag für Reisereservierungen erstellen können.
+ [Mit AWS CDK bereitstellen](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Mit AWS SAM bereitstellen](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Mit Terraform bereitstellen](https://serverlessland.com/workflows/saga-pattern-tf)
**DynamoDB-Tabellen**
Hier sind die Datenmodelle für die Tabellen mit Flügen, Mietwagen und Zahlungen.
```
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"}
}
};
```
**Lambda-Funktionen**
Die folgenden Funktionen werden erstellt, um den Zustandsmaschinenfluss und die Ausführung in Step Functions zu unterstützen:
+ **Flüge reservieren**: Fügt einen Datensatz mit einem `transaction_status` of in die DynamoDB-Flugtabelle ein`pending`, um einen Flug zu buchen.
+ **Flug bestätigen**: Aktualisiert den Datensatz in der DynamoDB-Flugtabelle, um ihn auf einzustellen`confirmed`, `transaction_status` um den Flug zu bestätigen.
+ **Flugreservierung stornieren**: Löscht den Datensatz aus der DynamoDB-Flugtabelle, um den ausstehenden Flug zu stornieren.
+ **Mietwagen reservieren**: Fügt einen Datensatz mit einem `transaction_status` of in die CarRentals DynamoDB-Tabelle ein`pending`, um eine Autovermietung zu buchen.
+ **Autovermietungen bestätigen**: Aktualisiert den Datensatz in der CarRentals DynamoDB-Tabelle, um ihn auf zu setzen`confirmed`, `transaction_status` um die Autovermietung zu bestätigen.
+ **Mietwagenreservierung stornieren:** Löscht den Datensatz aus der CarRentals DynamoDB-Tabelle, um die ausstehende Autovermietung zu stornieren.
+ **Zahlung verarbeiten**: Fügt einen Datensatz für die Zahlung in die DynamoDB-Zahlungstabelle ein.
+ **Zahlung stornieren**: Löscht den Datensatz für die Zahlung aus der DynamoDB-Zahlungstabelle.
**Amazon SNS**
Die Beispielanwendung erstellt das folgende Thema und Abonnement für den Versand von SMS-Nachrichten und die Benachrichtigung des Kunden über erfolgreiche oder fehlgeschlagene Reservierungen. Wenn Sie beim Testen der Beispielanwendung Textnachrichten empfangen möchten, aktualisieren Sie das SMS-Abonnement mit Ihrer gültigen Telefonnummer in der State-Machine-Definitionsdatei.
AWS-CDK-Snippet (fügen Sie die Telefonnummer in der zweiten Zeile des folgenden Codes hinzu):
```
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'),
});
```
AWS SAM-Snippet (ersetzen Sie die `+1111111111` Zeichenketten durch Ihre gültige Telefonnummer):
```
StateMachineTopic11111111111:
Type: 'AWS::SNS::Subscription'
Properties:
Protocol: sms
TopicArn:
Ref: StateMachineTopic
Endpoint: '+11111111111'
Metadata:
'aws:sam:path': SamServerlessSagaStack/StateMachine/Topic/+11111111111/Resource
```
Terraform-Snippet (ersetzen Sie die `+111111111` Zeichenfolge durch Ihre gültige Telefonnummer):
```
resource "aws_sns_topic_subscription" "sms-target" {
topic_arn = aws_sns_topic.topic.arn
protocol = "sms"
endpoint = "+11111111111"
}
```
**Erfolgreiche Reservierungen**
Der folgende Ablauf veranschaulicht eine erfolgreiche Reservierung mit "ReserveFlight,“ "ReserveCarRental,“ und "ProcessPayment" gefolgt von "ConfirmFlight" und "“ConfirmCarRental. Der Kunde wird durch SMS-Nachrichten, die an den Abonnenten des SNS-Themas gesendet werden, über die erfolgreiche Buchung informiert.
![\[Beispiel für eine erfolgreiche Reservierung, die von Step Functions mithilfe des Saga-Musters implementiert wurde.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/f58c894e-7721-4bc7-8f7d-29f23faa5dc1.png)
**Fehlgeschlagene Reservierungen**
Dieser Ablauf ist ein Beispiel für einen Fehler im Saga-Muster. Wenn "ProcessPayment" nach der Buchung von Flügen und Mietwagen fehlschlägt, werden die Schritte in umgekehrter Reihenfolge storniert. Die Reservierungen werden freigegeben und der Kunde wird über SMS-Nachrichten, die an den Abonnenten des SNS-Themas gesendet werden, über den Ausfall informiert.
![\[Beispiel für eine fehlgeschlagene Reservierung, die von Step Functions mithilfe des Saga-Musters implementiert wurde.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/7c64d326-be27-42c3-b03f-d677efedb9a7.png)
# Verwalten Sie lokale Containeranwendungen, indem Sie Amazon ECS Anywhere mit dem AWS CDK einrichten
*Dr. Rahul Sharad Gaikwad, Amazon Web Services*
## Zusammenfassung
[Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/) ist eine Erweiterung des Amazon Elastic Container Service (Amazon ECS). Sie können ECS Anywhere verwenden, um native Amazon ECS-Aufgaben in einer lokalen oder vom Kunden verwalteten Umgebung bereitzustellen. Diese Funktion trägt dazu bei, Kosten zu senken und komplexe lokale Container-Orchestrierung und Betriebsabläufe zu vereinfachen. Sie können ECS Anywhere verwenden, um Containeranwendungen sowohl in lokalen als auch in Cloud-Umgebungen bereitzustellen und auszuführen. Dadurch entfällt für Ihr Team die Notwendigkeit, mehrere Bereiche und Fähigkeiten zu erlernen oder komplexe Software eigenständig zu verwalten.
Dieses Muster veranschaulicht die Schritte zur Einrichtung von ECS Anywhere mithilfe von [AWS Cloud Development Kit (AWS CDK) -Stacks](https://aws.amazon.com/cdk/).
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto.
+ AWS-Befehlszeilenschnittstelle (AWS CLI), installiert und konfiguriert. (Weitere Informationen finden Sie unter [Installation, Aktualisierung und Deinstallation der AWS-CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) in der AWS-CLI-Dokumentation.)
+ AWS CDK Toolkit, installiert und konfiguriert. (Sehen Sie sich das [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) in der AWS CDK-Dokumentation an und folgen Sie den Anweisungen, um Version 2 global zu installieren.)
+ Node Package Manager (npm), installiert und konfiguriert für das AWS-CDK in. TypeScript (Weitere Informationen finden Sie unter [Node.js und npm herunterladen und installieren in der npm-Dokumentation](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).)
**Einschränkungen**
+ Einschränkungen und Überlegungen finden Sie unter [Externe Instances (Amazon ECS Anywhere)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-anywhere.html#ecs-anywhere-considerations) in der Amazon ECS-Dokumentation.
**Produktversionen**
+ AWS CDK Toolkit, Version 2
+ npm Version 7.20.3 oder höher
+ Node.js Version 16.6.1 oder höher
## Architektur
**Zieltechnologie-Stack**
+ AWS CloudFormation
+ AWS-CDK
+ Amazon ECS Anywhere
+ AWS Identity and Access Management (IAM)
**Zielarchitektur**
Das folgende Diagramm zeigt eine allgemeine Systemarchitektur des ECS Anywhere-Setups unter Verwendung des AWS CDK mit TypeScript, wie in diesem Muster implementiert.
1. Wenn Sie den AWS-CDK-Stack bereitstellen, erstellt er einen CloudFormation Stack auf AWS.
1. Der CloudFormation Stack stellt einen Amazon ECS-Cluster und zugehörige AWS-Ressourcen bereit.
1. Um eine externe Instance bei einem Amazon ECS-Cluster zu registrieren, müssen Sie den AWS Systems Manager Agent (SSM Agent) auf Ihrer virtuellen Maschine (VM) installieren und die VM als von AWS Systems Manager verwaltete Instanz registrieren.
1. Sie müssen auch den Amazon ECS-Container-Agenten und Docker auf Ihrer VM installieren, um sie als externe Instance beim Amazon ECS-Cluster zu registrieren.
1. Wenn die externe Instance registriert und mit dem Amazon ECS-Cluster konfiguriert ist, kann sie mehrere Container auf Ihrer VM ausführen, die als externe Instance registriert ist.
![\[ECS Anywhere-Einrichtung mit dem AWS-CDK mit TypeScript.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/3ed63c00-40e7-4831-bb9d-63049c3490aa/images/ff7dc774-830d-4b9f-8262-7314afe7a033.png)
**Automatisierung und Skalierung**
Das mit diesem Muster bereitgestellte [GitHub Repository](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples/) verwendet das AWS-CDK als IaC-Tool (Infrastructure as Code), um die Konfiguration für diese Architektur zu erstellen. AWS CDK hilft Ihnen bei der Orchestrierung von Ressourcen und der Einrichtung von ECS Anywhere.
## Tools
+ Das [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) ist ein Softwareentwicklungs-Framework, das Sie bei der Definition und Bereitstellung der AWS-Cloud-Infrastruktur im Code unterstützt.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie über Befehle in Ihrer Befehlszeilen-Shell mit AWS-Services interagieren können.
**Code**
Der Quellcode für dieses Muster ist im [Amazon ECS Anywhere CDK Samples-Repository](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples) verfügbar. GitHub Folgen Sie den Anweisungen im nächsten Abschnitt, um das Repository zu klonen und zu verwenden.
## Epen
### Überprüfen Sie die AWS-CDK-Konfiguration
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Überprüfen Sie die AWS-CDK-Version. | Überprüfen Sie die Version des AWS CDK Toolkit, indem Sie den folgenden Befehl ausführen:cdk --version
Für dieses Muster ist AWS CDK Version 2 erforderlich. Wenn Sie eine frühere Version von AWS CDK haben, folgen Sie den Anweisungen in der [AWS CDK-Dokumentation](https://docs.aws.amazon.com/cdk/v2/guide/cli.html), um sie zu aktualisieren. | DevOps Ingenieur |
| Richten Sie AWS-Anmeldeinformationen ein. | Um Anmeldeinformationen einzurichten, führen Sie den `aws configure` Befehl aus und folgen Sie den Anweisungen:$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
| DevOps Ingenieur |
### Bootstrap für die AWS-CDK-Umgebung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das AWS-CDK-Code-Repository. | Klonen Sie das GitHub Code-Repository für dieses Muster mit dem folgenden Befehl:git clone https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples.git
| DevOps Ingenieur |
| Bootstrapping für die Umwelt. | Führen Sie den folgenden Befehl aus, um die CloudFormation AWS-Vorlage für das Konto und die AWS-Region bereitzustellen, die Sie verwenden möchten:cdk bootstrap /
Weitere Informationen finden Sie unter [Bootstrapping](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html) in der AWS CDK-Dokumentation. | DevOps Ingenieur |
### Erstellen und implementieren Sie das Projekt
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Installieren Sie Paketabhängigkeiten und kompilieren Sie TypeScript Dateien. | Installieren Sie die Paketabhängigkeiten und kompilieren Sie die TypeScript Dateien, indem Sie die folgenden Befehle ausführen:$cd amazon-ecs-anywhere-cdk-samples
$npm install
$npm fund
Mit diesen Befehlen werden alle Pakete aus dem Beispiel-Repository installiert. Wenn Sie eine Fehlermeldung über fehlende Pakete erhalten, verwenden Sie einen der folgenden Befehle:$npm ci
–oder –$npm install -g @aws-cdk/
Weitere Informationen finden Sie unter [npm ci](https://docs.npmjs.com/cli/v7/commands/npm-ci) und [npm install](https://docs.npmjs.com/cli/v7/commands/npm-install) in der npm-Dokumentation. | DevOps Ingenieur |
| Erstellen Sie das Projekt. | Führen Sie den folgenden Befehl aus, um den Projektcode zu erstellen:npm run build
Weitere Informationen zum Erstellen und Bereitstellen des Projekts finden Sie unter [Ihre erste AWS-CDK-App](https://docs.aws.amazon.com/cdk/latest/guide/hello_world.html#:~:text=the%20third%20parameter.-,Synthesize%20an%20AWS%20CloudFormation%20template,-Synthesize%20an%20AWS) in der AWS-CDK-Dokumentation. | DevOps Ingenieur |
| Stellen Sie das Projekt bereit. | Führen Sie den folgenden Befehl aus, um den Projektcode bereitzustellen:cdk deploy
| DevOps Ingenieur |
| Überprüfen Sie die Erstellung und Ausgabe des Stacks. | Öffnen Sie die CloudFormation AWS-Konsole unter [https://console.aws.amazon.com/cloudformation****](https://console.aws.amazon.com/cloudformation/) und wählen Sie den `EcsAnywhereStack` Stack aus. Auf der Registerkarte **Ausgaben** werden die Befehle angezeigt, die auf Ihrer externen VM ausgeführt werden sollen. | DevOps Ingenieur |
### Richten Sie einen lokalen Computer ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Richten Sie Ihre VM mithilfe von Vagrant ein. | Zu Demonstrationszwecken können Sie [HashiCorp Vagrant](https://www.vagrantup.com/) verwenden, um eine VM zu erstellen. Vagrant ist ein Open-Source-Hilfsprogramm für den Aufbau und die Wartung portabler virtueller Softwareentwicklungsumgebungen. Erstellen Sie eine Vagrant-VM, indem Sie den `vagrant up` Befehl im Stammverzeichnis ausführen, in dem Vagrantfile gespeichert ist. [Weitere Informationen finden Sie in der Vagrant-Dokumentation.](https://www.vagrantup.com/docs/cli/up) | DevOps Ingenieur |
| Registrieren Sie Ihre VM als externe Instanz. | 1. Melden Sie sich mit dem `vagrant ssh` Befehl bei der Vagrant-VM an. Weitere Informationen finden Sie in der [Vagrant-Dokumentation](https://www.vagrantup.com/docs/cli/ssh).2. Erstellen Sie einen Aktivierungscode und eine ID, mit denen Sie Ihre VM bei AWS Systems Manager registrieren und Ihre externe Instanz aktivieren können. Die Ausgabe dieses Befehls umfasst `ActivationId` und `ActivationCode` Werte: aws ssm create-activation --iam-role EcsAnywhereInstanceRole | tee ssm-activation.json
3. Exportieren Sie die Aktivierungs-ID und die Codewerte:export ACTIVATION_ID=
export ACTIVATION_CODE=
4. Laden Sie das Installationsskript auf Ihren lokalen Server oder Ihre VM herunter: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. Führen Sie das Installationsskript auf Ihrem lokalen Server oder Ihrer VM aus:sudo ./ecs-anywhere-install.sh \
--cluster test-ecs-anywhere \
--activation-id $ACTIVATION_ID \
--activation-code $ACTIVATION_CODE \
--region
Weitere Informationen zum Einrichten und Registrieren Ihrer VM finden Sie unter [Registrierung einer externen Instance in einem Cluster](https://docs.amazonaws.cn/en_us/AmazonECS/latest/developerguide/ecs-anywhere-registration.html) in der Amazon ECS-Dokumentation. | DevOps Ingenieur |
| Überprüfen Sie den Status von ECS Anywhere und der externen VM. | Verwenden Sie die folgenden Befehle, um zu überprüfen, ob Ihre virtuelle Box mit der Amazon ECS-Steuerebene verbunden ist und läuft:aws ssm describe-instance-information
aws ecs list-container-instances --cluster $CLUSTER_NAME
| DevOps Ingenieur |
### Bereinigen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Ressourcen bereinigen und löschen. | Nachdem Sie dieses Muster durchgegangen sind, sollten Sie die Ressourcen, die Sie erstellt haben, entfernen, um weitere Kosten zu vermeiden. Führen Sie zum Aufräumen den folgenden Befehl aus:cdk destroy
| DevOps Ingenieur |
## Zugehörige Ressourcen
+ [Dokumentation zu Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/)
+ [Amazon ECS Anywhere Anywhere-Demo](https://www.youtube.com/watch?v=-eud6yUXsJM)
+ [Beispiele Amazon ECS Anywhere Anywhere-Workshops](https://github.com/aws-samples/aws-ecs-anywhere-workshop-samples)
# Modernisieren Sie ASP.NET Web Forms-Anwendungen auf AWS
*Vijai Anand Ramalingam und Sreelaxmi Pai, Amazon Web Services*
## Zusammenfassung
Dieses Muster beschreibt die Schritte zur Modernisierung einer älteren, monolithischen ASP.NET Web Forms-Anwendung durch Portierung auf ASP.NET Core auf AWS.
Durch die Portierung von ASP.NET Web Forms-Anwendungen auf ASP.NET Core können Sie die Leistung, die Kosteneinsparungen und das robuste Ökosystem von Linux nutzen. Dies kann jedoch ein erheblicher manueller Aufwand sein. In diesem Muster wird die Legacy-Anwendung schrittweise mithilfe eines schrittweisen Ansatzes modernisiert und anschließend in der AWS-Cloud containerisiert.
Stellen Sie sich eine ältere, monolithische Anwendung für einen Einkaufswagen vor. Nehmen wir an, dass sie als ASP.NET-Webforms-Anwendung erstellt wurde und aus ASPX-Seiten mit einer Code-Behind () -Datei besteht. `aspx.cs` Der Modernisierungsprozess besteht aus den folgenden Schritten:
1. Teilen Sie den Monolith in Microservices auf, indem Sie die entsprechenden Zerlegungsmuster verwenden. Weitere Informationen finden Sie im Leitfaden [Decomposing monoliths into microservices](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-decomposing-monoliths/) auf der AWS Prescriptive Guidance Guidance-Website.
1. Portieren Sie Ihre ältere ASP.NET Web Forms (.NET Framework) -Anwendung auf ASP.NET Core in .NET 5 oder höher. In diesem Muster verwenden Sie den Portierungsassistenten für .NET, um Ihre ASP.NET Web Forms-Anwendung zu scannen und Inkompatibilitäten mit ASP.NET Core zu identifizieren. Dadurch wird der manuelle Portierungsaufwand reduziert.
1. Entwickeln Sie die Web Forms-Benutzeroberflächenebene mithilfe von React neu. Dieses Muster deckt die Neuentwicklung der Benutzeroberfläche nicht ab. Anweisungen finden Sie unter [Neue React-App erstellen](https://reactjs.org/docs/create-a-new-react-app.html) in der React-Dokumentation.
1. Entwickeln Sie die Web Forms-Codebehind-Datei (Geschäftsschnittstelle) als ASP.NET Core-Web-API neu. Dieses Muster verwendet NDepend Berichte, um benötigte Dateien und Abhängigkeiten zu identifizieren.
1. Führen Sie mithilfe des Portierungsassistenten für .NET ein Upgrade von shared/common Projekten wie Business Logic und Data Access in Ihrer Legacy-Anwendung auf .NET 5 oder höher durch.
1. Fügen Sie AWS-Services hinzu, um Ihre Anwendung zu ergänzen. Sie können beispielsweise [Amazon CloudWatch Logs verwenden, um die Protokolle](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) Ihrer Anwendung zu überwachen, zu speichern und darauf zuzugreifen, und [AWS Systems Manager](https://aws.amazon.com/systems-manager/), um Ihre Anwendungseinstellungen zu speichern.
1. Containerisieren Sie die modernisierte ASP.NET Core-Anwendung. Dieses Muster erstellt eine Docker-Datei, die auf Linux in Visual Studio abzielt und Docker Desktop verwendet, um sie lokal zu testen. In diesem Schritt wird davon ausgegangen, dass Ihre Legacy-Anwendung bereits auf einer lokalen Windows-Instance oder einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance ausgeführt wird. Weitere Informationen finden Sie im Muster [Einen ASP.NET Core-Web-API-Docker-Container auf einer Amazon EC2 Linux-Instance ausführen](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. Stellen Sie die modernisierte ASP.NET-Kernanwendung auf Amazon Elastic Container Service (Amazon ECS) bereit. Dieses Muster deckt den Bereitstellungsschritt nicht ab. Anweisungen finden Sie im [Amazon ECS-Workshop](https://ecsworkshop.com/).
**Anmerkung**
Dieses Muster deckt keine Schritte zur Entwicklung der Benutzeroberfläche, zur Datenbankmodernisierung oder zur Container-Bereitstellung ab.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ [Visual Studio](https://visualstudio.microsoft.com/downloads/) oder [Visual Studio Code](https://code.visualstudio.com/download), heruntergeladen und installiert.
+ Zugriff auf ein AWS-Konto über die AWS-Managementkonsole und die AWS-Befehlszeilenschnittstelle (AWS CLI) Version 2. (Weitere Informationen finden Sie in den [Anweisungen zur Konfiguration der AWS-CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).)
+ Das AWS Toolkit for Visual Studio (siehe [Anweisungen zur Einrichtung](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html)).
+ Docker Desktop, [heruntergeladen und installiert](https://www.docker.com/products/docker-desktop).
+ .NET SDK, [heruntergeladen](https://download.visualstudio.microsoft.com/download/pr/4263dc3b-dc67-4f11-8d46-cc0ae86a232e/66782bbd04c53651f730b2e30a873f18/dotnet-sdk-5.0.203-win-x64.exe) und installiert.
+ NDepend Tool, [heruntergeladen](https://www.ndepend.com/download) und installiert. Um die NDepend Erweiterung für Visual Studio zu installieren, führen Sie den `NDepend.VisualStudioExtension.Installer` Befehl aus ([siehe Anweisungen](https://www.ndepend.com/docs/getting-started-with-ndepend#Part1)). Sie können je nach Ihren Anforderungen Visual Studio 2019 oder 2022 auswählen.
+ Portierungsassistent für .NET, [heruntergeladen](https://aws.amazon.com/porting-assistant-dotnet/) und installiert.
## Architektur
**Modernisierung der Warenkorb-Anwendung**
Das folgende Diagramm veranschaulicht den Modernisierungsprozess für eine ältere ASP.NET-Einkaufswagenanwendung.
![\[Modernisierung einer älteren Warenkorbanwendung\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/4367e259-9bb3-4eb6-a54d-1c1e2dece7d4.png)
**Zielarchitektur**
Das folgende Diagramm veranschaulicht die Architektur der modernisierten Einkaufswagen-Anwendung auf AWS. ASP.NET Core-Web APIs werden in einem Amazon ECS-Cluster bereitgestellt. Protokollierungs- und Konfigurationsservices werden von Amazon CloudWatch Logs und AWS Systems Manager bereitgestellt.
![\[Zielarchitektur für die ASP.NET Web Forms-Anwendung auf AWS\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/ed6d65ec-0dc9-43ab-ac07-1f172e089399.png)
## Tools
**AWS-Services**
+ [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) — Amazon Elastic Container Service (Amazon ECS) ist ein hoch skalierbarer, schneller Container-Management-Service zum Ausführen, Stoppen und Verwalten von Containern in einem Cluster. Sie können Ihre Aufgaben und Services auf einer serverlosen Infrastruktur ausführen, die von AWS Fargate verwaltet wird. Um mehr Kontrolle über Ihre Infrastruktur zu erhalten, können Sie Ihre Aufgaben und Dienste alternativ auf einem Cluster von EC2 Instances ausführen, die Sie verwalten.
+ [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) — Amazon CloudWatch Logs zentralisiert die Protokolle all Ihrer Systeme, Anwendungen und AWS-Services, die Sie verwenden. Sie können die Protokolle anzeigen und überwachen, sie nach bestimmten Fehlercodes oder Mustern durchsuchen, sie nach bestimmten Feldern filtern oder sie für future Analysen sicher archivieren.
+ [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ─ AWS Systems Manager ist ein AWS-Service, mit dem Sie Ihre Infrastruktur auf AWS anzeigen und steuern können. Mithilfe der Systems Manager Manager-Konsole können Sie Betriebsdaten von mehreren AWS-Services anzeigen und betriebliche Aufgaben in Ihren AWS-Ressourcen automatisieren. Systems Manager unterstützt Sie bei der Aufrechterhaltung von Sicherheit und Compliance, indem es Ihre verwalteten Instanzen scannt und festgestellte Richtlinienverstöße meldet (oder Korrekturmaßnahmen ergreift).
**Tools**
+ [Visual Studio](https://visualstudio.microsoft.com/) oder [Visual Studio Code](https://code.visualstudio.com/) — Tools zum Erstellen von.NET-Anwendungen APIs, Web- und anderen Programmen.
+ [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) — Eine Erweiterung für Visual Studio, die beim Entwickeln, Debuggen und Bereitstellen von.NET-Anwendungen hilft, die AWS-Services verwenden.
+ [Docker Desktop](https://www.docker.com/products/docker-desktop) — Ein Tool, das die Erstellung und Bereitstellung containerisierter Anwendungen vereinfacht.
+ [NDepend](https://www.ndepend.com/features/)— Ein Analysator, der .NET-Code auf Abhängigkeiten, Qualitätsprobleme und Codeänderungen überwacht.
+ [Portierungsassistent für .NET](https://aws.amazon.com/porting-assistant-dotnet/) — Ein Analysetool, das .NET-Code scannt, um Inkompatibilitäten mit .NET Core zu identifizieren und den Migrationsaufwand abzuschätzen.
## Epen
### Portieren Sie Ihre Legacy-Anwendung auf .NET 5 oder eine neuere Version
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Aktualisieren Sie Ihre.NET Framework-Legacy-Anwendung auf .NET 5. | Sie können den Portierungsassistenten für .NET verwenden, um Ihre ältere ASP.NET Web Forms-Anwendung auf .NET 5 oder höher zu konvertieren. Folgen Sie den Anweisungen in der [Dokumentation zu Porting Assistant for .NET](https://docs.aws.amazon.com/portingassistant/latest/userguide/porting-assistant-getting-started.html). | App-Developer |
| Generieren Sie NDepend Berichte. | Wenn Sie Ihre ASP.NET Web Forms-Anwendung modernisieren, indem Sie sie in Microservices zerlegen, benötigen Sie möglicherweise nicht alle .cs-Dateien aus der Legacy-Anwendung. Sie können NDepend damit einen Bericht für jede Code-Behind (.cs) -Datei generieren, um alle Anrufer und Anrufer abzurufen. Dieser Bericht hilft Ihnen dabei, nur die erforderlichen Dateien in Ihren Microservices zu identifizieren und zu verwenden.Öffnen Sie nach der Installation NDepend (siehe Abschnitt [Voraussetzungen](#modernize-asp-net-web-forms-applications-on-aws-prereqs)) die Lösung (.sln-Datei) für Ihre Legacy-Anwendung in Visual Studio und gehen Sie wie folgt vor:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Dieser Vorgang generiert einen Bericht für die Code-Behind-Datei, in der alle Anrufer und Anrufer aufgeführt sind. [Weitere Informationen zum Abhängigkeitsdiagramm finden Sie in der Dokumentation. NDepend ](https://www.ndepend.com/docs/visual-studio-dependency-graph) | App-Developer |
| Erstellen Sie eine neue.NET 5-Lösung. | So erstellen Sie eine neue.NET 5-Struktur (oder höher) für Ihr modernisiertes ASP.NET Core-Web: APIs[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Weitere Informationen zum Erstellen von Projekten und Lösungen finden Sie in der [Visual Studio-Dokumentation](https://docs.microsoft.com/en-us/visualstudio/ide/creating-solutions-and-projects).Beim Erstellen der Lösung und beim Überprüfen der Funktionalität können Sie zusätzlich zu den NDepend identifizierten Dateien mehrere zusätzliche Dateien identifizieren, die der Lösung hinzugefügt werden sollen. | App-Developer |
### Aktualisieren Sie Ihren Anwendungscode
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Implementieren Sie das Web APIs mit ASP.NET Core. | *Nehmen wir an, dass es sich bei einem der Microservices, die Sie in Ihrer alten Monolith-Einkaufswagen-Anwendung identifiziert haben, um Produkte handelt.* Sie haben im vorherigen Epos ein neues ASP.NET Core-Web-API-Projekt für *Produkte* erstellt. *In diesem Schritt identifizieren und modernisieren Sie alle Webformulare (.aspx-Seiten), die sich auf Produkte beziehen.* [Gehen wir davon aus, dass *Produkte* aus vier Webformularen bestehen, wie weiter oben im Abschnitt Architektur dargestellt:](#modernize-asp-net-web-forms-applications-on-aws-architecture)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Sie sollten jedes Webformular analysieren, alle Anfragen identifizieren, die an die Datenbank gesendet werden, um eine gewisse Logik auszuführen, und Antworten erhalten. Sie können jede Anfrage als Web-API-Endpunkt implementieren. Aufgrund ihrer Webformulare können *Produkte* die folgenden möglichen Endpunkte haben:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Wie bereits erwähnt, können Sie auch alle anderen Projekte, die Sie auf .NET 5 aktualisiert haben, wiederverwenden, einschließlich Business Logic, Data Access und shared/common Projekte. | App-Developer |
| Konfigurieren Sie Amazon CloudWatch Logs. | Sie können [Amazon CloudWatch Logs verwenden, um die Protokolle](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) Ihrer Anwendung zu überwachen, zu speichern und darauf zuzugreifen. Sie können Daten mithilfe eines AWS-SDK in Amazon CloudWatch Logs protokollieren. Sie können auch.NET-Anwendungen in CloudWatch Logs integrieren, indem Sie gängige .NET-Logging-Frameworks wie [NLog](https://www.nuget.org/packages/AWS.Logger.NLog/)[Log4Net](https://www.nuget.org/packages/AWS.Logger.Log4net/) und das [ASP.NET Core-Logging-Framework](https://www.nuget.org/packages/AWS.Logger.AspNetCore/) verwenden.Weitere Informationen zu diesem Schritt finden Sie im Blogbeitrag [Amazon CloudWatch Logs and.NET Logging Frameworks](https://aws.amazon.com/blogs/developer/amazon-cloudwatch-logs-and-net-logging-frameworks/). | App-Developer |
| Konfigurieren Sie den AWS Systems Manager Parameter Store. | Sie können den [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html) verwenden, um Anwendungseinstellungen wie Verbindungszeichenfolgen getrennt vom Code Ihrer Anwendung zu speichern. Das NuGet Paket [Amazon.Extensions.Configuration. SystemsManager](https://www.nuget.org/packages/Amazon.Extensions.Configuration.SystemsManager/)vereinfacht, wie Ihre Anwendung diese Einstellungen aus dem AWS Systems Manager Parameter Store in das .NET Core-Konfigurationssystem lädt. Weitere Informationen zu diesem Schritt finden Sie im Blogbeitrag [.NET Core-Konfigurationsanbieter für AWS Systems Manager](https://aws.amazon.com/blogs/developer/net-core-configuration-provider-for-aws-systems-manager/). | App-Developer |
### Fügen Sie Authentifizierung und Autorisierung hinzu
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Verwenden Sie ein geteiltes Cookie zur Authentifizierung. | Die Modernisierung einer älteren Monolith-Anwendung ist ein iterativer Prozess, bei dem der Monolith und seine modernisierte Version nebeneinander existieren müssen. Sie können ein geteiltes Cookie verwenden, um eine nahtlose Authentifizierung zwischen den beiden Versionen zu erreichen. Die ältere ASP.NET-Anwendung validiert weiterhin die Benutzeranmeldeinformationen und gibt das Cookie aus, während die modernisierte ASP.NET Core-Anwendung das Cookie validiert. [Anweisungen und Beispielcode finden Sie im Beispielprojekt. GitHub ](https://github.com/aws-samples/dotnet-share-auth-cookie-between-monolith-and-modernized-apps) | App-Developer |
### Erstellen Sie den Container und führen Sie ihn lokal aus
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie ein Docker-Image mit Visual Studio. | In diesem Schritt erstellen Sie eine Docker-Datei mithilfe der Visual Studio for .NET Core-Web-API.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Visual Studio erstellt eine Docker-Datei für Ihr Projekt. Eine Docker-Beispieldatei finden Sie unter [Visual Studio Container Tools for Docker](https://docs.microsoft.com/en-us/visualstudio/containers/overview) auf der Microsoft-Website. | App-Developer |
| Erstellen Sie den Container mit Docker Desktop und führen Sie ihn aus. | Jetzt können Sie den Container in Docker Desktop erstellen, erstellen und ausführen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html) | App-Developer |
## Zugehörige Ressourcen
+ [Einen ASP.NET Core-Web-API-Docker-Container auf einer Amazon EC2 Linux-Instance ausführen](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)
+ [Amazon ECS-Workshop](https://ecsworkshop.com/)
+ [Durchführung von blue/green ECS-Bereitstellungen CodeDeploy mithilfe von AWS CloudFormation ( CloudFormation AWS-Dokumentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html))
+ [Erste Schritte mit NDepend](https://www.ndepend.com/docs/getting-started-with-ndepend) (NDepend Dokumentation)
+ [Portierungsassistent für .NET](https://aws.amazon.com/porting-assistant-dotnet/)
## Zusätzliche Informationen
Die folgenden Tabellen enthalten Beispiele für Beispielprojekte für eine ältere Warenkorbanwendung und die entsprechenden Projekte in Ihrer modernisierten ASP.NET Core-Anwendung.
**Legacy-Lösung:**
|
|
| Project name | Vorlage für ein Projekt | Target framework |
| --- |--- |--- |
| Geschäftsoberfläche | Klassenbibliothek | .NET Framework. |
| BusinessLogic | Klassenbibliothek | .NET Framework. |
| WebApplication | ASP.NET Framework-Webanwendung | .NET Framework. |
| UnitTests | NUnit Projekt testen | .NET Framework. |
| Geteilt -> Allgemein | Klassenbibliothek | .NET Framework. |
| Geteilt -> Framework | Klassenbibliothek | .NET Framework. |
**Neue Lösung:**
|
|
| Project name | Vorlage für ein Projekt | Target framework |
| --- |--- |--- |
| BusinessLogic | Klassenbibliothek | .NET 5.0 |
| | ASP.NET-Core-Web-API | .NET 5.0 |
| . UnitTests | NUnit 3 Testprojekt | .NET 5.0 |
| Geteilt -> Allgemein | Klassenbibliothek | .NET 5.0 |
| Geteilt -> Framework | Klassenbibliothek | .NET 5.0 |
# Mandanten-Onboarding in der SaaS-Architektur für das Silomodell mit C\$1 und AWS CDK
*Tabby Ward, Susmitha Reddy Gankidi und Vijai Anand Ramalingam, Amazon Web Services*
## Zusammenfassung
Software-as-a-Service (SaaS) -Anwendungen können mit einer Vielzahl unterschiedlicher Architekturmodelle erstellt werden. Das *Silomodell* bezieht sich auf eine Architektur, in der Mandanten dedizierte Ressourcen zur Verfügung gestellt werden.
SaaS-Anwendungen basieren auf einem reibungslosen Modell für die Einführung neuer Mandanten in ihre Umgebung. Dies erfordert häufig die Orchestrierung einer Reihe von Komponenten, um alle Elemente, die für die Erstellung eines neuen Mandanten erforderlich sind, erfolgreich bereitzustellen und zu konfigurieren. Dieser Prozess wird in der SaaS-Architektur als Mandanten-Onboarding bezeichnet. Das Onboarding sollte für jede SaaS-Umgebung vollständig automatisiert werden, indem Infrastruktur als Code in Ihrem Onboarding-Prozess verwendet wird.
Dieses Muster führt Sie durch ein Beispiel für die Erstellung eines Mandanten und die Bereitstellung einer Basisinfrastruktur für den Mandanten auf Amazon Web Services (AWS). Das Muster verwendet C\$1 und das AWS Cloud Development Kit (AWS CDK).
Da dieses Muster einen Fakturierungsalarm auslöst, empfehlen wir, den Stack in der AWS-Region USA Ost (Nord-Virginia) oder US-East-1 bereitzustellen. Weitere Informationen finden Sie in der [AWS-Dokumentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html).
## Voraussetzungen und Einschränkungen
**Voraussetzungen******
+ Ein aktives [AWS-Konto](https://aws.amazon.com/account/).
+ Ein AWS Identity and Access Management (IAM) -Principal mit ausreichendem IAM-Zugriff, um AWS-Ressourcen für dieses Muster zu erstellen. Weitere Informationen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
+ [Installieren Sie Amazon Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und [konfigurieren Sie AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) für die AWS-CDK-Bereitstellung.
+ [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) wurde heruntergeladen und installiert oder [Visual Studio Code](https://code.visualstudio.com/download) wurde heruntergeladen und installiert.
+ Einrichtung des [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html).
+ [.NET Core 3.1 oder höher](https://dotnet.microsoft.com/download/dotnet-core/3.1) (erforderlich für C\$1 AWS CDK-Anwendungen)
+ [Amazon.Lambda.Tools installiert](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools).
**Einschränkungen******
+ AWS CDK verwendet [AWS CloudFormation](https://aws.amazon.com/cloudformation/), sodass AWS-CDK-Anwendungen CloudFormation Service-Kontingenten unterliegen. Weitere Informationen finden Sie unter [ CloudFormation AWS-Kontingente](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
+ Der CloudFormation Mandanten-Stack wird mit einer CloudFormation Servicerolle `infra-cloudformation-role` mit Platzhalterzeichen für Aktionen (`sns`\$1 und`sqs*`) erstellt, wobei die Ressourcen jedoch auf das `tenant-cluster` Präfix beschränkt sind. Evaluieren Sie diese Einstellung für einen Produktionsanwendungsfall und gewähren Sie nur den erforderlichen Zugriff auf diese Servicerolle. Die `InfrastructureProvision` Lambda-Funktion verwendet auch ein Platzhalterzeichen (`cloudformation*`), um den CloudFormation Stack bereitzustellen, wobei die Ressourcen jedoch auf das `tenant-cluster` Präfix beschränkt sind.
+ Der Docker-Build dieses Beispielcodes verwendet`--platform=linux/amd64`, um `linux/amd64` basierte Images zu erzwingen. Dadurch soll sichergestellt werden, dass die endgültigen Bildartefakte für Lambda geeignet sind, das standardmäßig die x86-64-Architektur verwendet. Wenn Sie die Lambda-Zielarchitektur ändern müssen, stellen Sie sicher, dass Sie sowohl die Dockerfiles als auch die AWS-CDK-Codes ändern. Weitere Informationen finden Sie im Blogbeitrag [Migration von AWS Lambda Lambda-Funktionen auf ARM-basierte AWS Graviton2-Prozessoren](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-to-arm-based-aws-graviton2-processors/).
+ Beim Löschen des Stacks werden keine vom Stack generierten CloudWatch Protokolle (Protokollgruppen und Protokolle) bereinigt. Sie müssen die Protokolle manuell über die AWS-Managementkonsole, die CloudWatch Amazon-Konsole oder die API bereinigen.
Dieses Muster dient als Beispiel. Evaluieren Sie für den Einsatz in der Produktion die folgenden Konfigurationen und nehmen Sie je nach Ihren Geschäftsanforderungen Änderungen vor:
+ Für den Bucket [AWS Simple Storage Service (Amazon S3)](https://aws.amazon.com/s3/) ist in diesem Beispiel der Einfachheit halber die Versionierung nicht aktiviert. Evaluieren und aktualisieren Sie das Setup nach Bedarf.
+ In diesem Beispiel werden der [Einfachheit halber Amazon API Gateway](https://aws.amazon.com/api-gateway/) REST-API-Endpunkte ohne Authentifizierung, Autorisierung oder Drosselung eingerichtet. Für den Produktionseinsatz empfehlen wir, das System in die Sicherheitsinfrastruktur des Unternehmens zu integrieren. Bewerten Sie diese Einstellung und fügen Sie bei Bedarf die erforderlichen Sicherheitseinstellungen hinzu.
+ Für dieses Beispiel mit einer Mandanteninfrastruktur haben [Amazon Simple Notification Service (Amazon SNS)](https://aws.amazon.com/sns/) und [Amazon Simple Queue Service (Amazon SQS)](https://aws.amazon.com/sqs/) nur Mindestkonfigurationen. Der [AWS Key Management Service (AWS KMS)](https://aws.amazon.com/kms/) für jeden Mandanten wird für [Amazon CloudWatch - und Amazon](https://aws.amazon.com/cloudwatch/) SNS SNS-Services im Konto geöffnet, um sie auf der Grundlage der [AWS KMS KMS-Schlüsselrichtlinie](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-key-management.html#compatibility-with-aws-services) zu nutzen. Das Setup ist nur ein Beispiel für einen Platzhalter. Passen Sie die Setups je nach Bedarf an Ihren geschäftlichen Anwendungsfall an.
+ Das gesamte Setup, das unter anderem API-Endpunkte und die Bereitstellung und Löschung von Backend-Mandanten mithilfe von AWS umfasst CloudFormation, deckt nur den grundlegenden Happy-Path-Fall ab. Evaluieren und aktualisieren Sie das Setup mit der erforderlichen Wiederholungslogik, zusätzlicher Fehlerbehandlungslogik und Sicherheitslogik auf der Grundlage Ihrer Geschäftsanforderungen.
+ Der Beispielcode wurde mit up-to-date [cdk-nag](https://github.com/cdklabs/cdk-nag) getestet, um zu überprüfen, ob es zum Zeitpunkt der Erstellung dieses Artikels Richtlinien gibt. In future könnten neue Richtlinien durchgesetzt werden. Diese neuen Richtlinien erfordern möglicherweise, dass Sie den Stack anhand der Empfehlungen manuell ändern müssen, bevor der Stack bereitgestellt werden kann. Überprüfen Sie den vorhandenen Code, um sicherzustellen, dass er Ihren Geschäftsanforderungen entspricht.
+ Der Code verwendet das AWS-CDK, um ein zufälliges Suffix zu generieren, anstatt sich auf statisch zugewiesene physische Namen für die meisten erstellten Ressourcen zu verlassen. Dieses Setup soll sicherstellen, dass diese Ressourcen einzigartig sind und nicht mit anderen Stacks in Konflikt geraten. Weitere Informationen finden Sie in der [AWS-CDK-Dokumentation](https://docs.aws.amazon.com/cdk/v2/guide/resources.html#resources_physical_names). Passen Sie dies an Ihre Geschäftsanforderungen an.
+ Dieser Beispielcode packt .NET Lambda-Artefakte in Docker-basierte Images und wird mit der von Lambda bereitgestellten [Container-Image-Laufzeit](https://docs.aws.amazon.com/lambda/latest/dg/csharp-image.html) ausgeführt. Die Container-Image-Laufzeit bietet Vorteile für standardmäßige Übertragungs- und Speichermechanismen (Container-Registries) und genauere lokale Testumgebungen (über das Container-Image). Sie können das Projekt so umstellen, dass es die von [Lambda bereitgestellten .NET-Laufzeiten](https://docs.aws.amazon.com/lambda/latest/dg/lambda-csharp.html) verwendet, um die Erstellungszeit der Docker-Images zu reduzieren. Dann müssen Sie jedoch Übertragungs- und Speichermechanismen einrichten und sicherstellen, dass das lokale Setup mit dem Lambda-Setup übereinstimmt. Passen Sie den Code an die Geschäftsanforderungen der Benutzer an.
**Produktversionen**
+ AWS CDK Version 2.45.0 oder höher
+ Visual Studio 2022
## Architektur
**Technologie-Stack**
+ 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
**Architektur**
Das folgende Diagramm zeigt den Ablauf der Erstellung von Mandanten-Stacks. Weitere Informationen zu den Technologie-Stacks für Steuerungsebene und Mandanten finden Sie im Abschnitt *Zusätzliche* Informationen.
![\[Workflow zur Erstellung eines Mandanten und zur Bereitstellung einer Basisinfrastruktur für den Mandanten auf AWS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/5baef800-fe39-4eb8-b11d-2c23eb3175fc/images/0b579484-b87c-4acb-8c60-8c33c18370e3.png)
**Ablauf zur Erstellung eines Mandanten-Stacks**
1. Der Benutzer sendet eine POST-API-Anfrage mit neuer Mandanten-Payload (Mandantenname, Mandantenbeschreibung) in JSON an eine von Amazon API Gateway gehostete REST-API. Das API Gateway verarbeitet die Anfrage und leitet sie an die Lambda Tenant Onboarding-Funktion im Backend weiter. In diesem Beispiel gibt es keine Autorisierung oder Authentifizierung. In einer Produktionsumgebung sollte diese API in das Sicherheitssystem der SaaS-Infrastruktur integriert werden.
1. Die Tenant Onboarding-Funktion verifiziert die Anfrage. Anschließend wird versucht, den Mandantendatensatz, der den Namen des Mandanten, die generierte allgemeine eindeutige Kennung (UUID) und die Mandantenbeschreibung enthält, in der Amazon DynamoDB Tenant Onboarding-Tabelle zu speichern.
1. Nachdem DynamoDB den Datensatz gespeichert hat, initiiert ein DynamoDB-Stream die nachgeschaltete Lambda Tenant Infrastructure-Funktion.
1. Die Lambda-Funktion Tenant Infrastructure agiert auf der Grundlage des empfangenen DynamoDB-Streams. Wenn der Stream für das INSERT-Ereignis bestimmt ist, verwendet die Funktion den NewImage Abschnitt des Streams (letzter Aktualisierungsdatensatz, Feld Mandantenname), um mithilfe der Vorlage, die im S3-Bucket gespeichert ist, eine neue Mandanteninfrastruktur aufzurufen CloudFormation . Für die CloudFormation Vorlage ist der Parameter Tenant Name erforderlich.
1. AWS CloudFormation erstellt die Mandanteninfrastruktur auf der Grundlage der CloudFormation Vorlage und der Eingabeparameter.
1. Jede Einrichtung der Mandanteninfrastruktur verfügt über einen CloudWatch Alarm, einen Abrechnungsalarm und ein Alarmereignis.
1. Das Alarmereignis wird zu einer Nachricht an ein SNS-Thema, die mit dem AWS-KMS-Schlüssel des Mandanten verschlüsselt wird.
1. Das SNS-Thema leitet die empfangene Alarmmeldung an die SQS-Warteschlange weiter, die mit dem AWS-KMS-Verschlüsselungsschlüssel des Mandanten verschlüsselt wird.
Andere Systeme können in Amazon SQS integriert werden, um Aktionen auf der Grundlage von Nachrichten in der Warteschlange durchzuführen. In diesem Beispiel bleiben eingehende Nachrichten in der Warteschlange und müssen manuell gelöscht werden, um den Code generisch zu halten.
**Ablauf beim Löschen von Mandantenstapeln**
1. Der Benutzer sendet eine DELETE-API-Anfrage mit neuer Mandanten-Payload (Mandantenname, Mandantenbeschreibung) in JSON an die von Amazon API Gateway gehostete REST-API, die die Anfrage verarbeitet und an die Tenant-Onboarding-Funktion weiterleitet. In diesem Beispiel gibt es keine Autorisierung oder Authentifizierung. In einem Produktionssetup wird diese API in das Sicherheitssystem der SaaS-Infrastruktur integriert.
1. Die Tenant-Onboarding-Funktion überprüft die Anfrage und versucht dann, den Mandantendatensatz (Mandantenname) aus der Tenant-Onboarding-Tabelle zu löschen.
1. Nachdem DynamoDB den Datensatz erfolgreich gelöscht hat (der Datensatz ist in der Tabelle vorhanden und wird gelöscht), initiiert ein DynamoDB-Stream die Downstream-Funktion Lambda Tenant Infrastructure.
1. Die Lambda-Funktion Tenant Infrastructure handelt auf der Grundlage des empfangenen DynamoDB-Stream-Datensatzes. Wenn der Stream für das REMOVE-Ereignis bestimmt ist, verwendet die Funktion den OldImage Abschnitt des Datensatzes (Datensatzinformationen und Feld Mandantenname vor der letzten Änderung, d. h. Löschen), um das Löschen eines vorhandenen Stacks auf der Grundlage dieser Datensatzinformationen zu initiieren.
1. AWS CloudFormation löscht den Zielmandanten-Stack entsprechend der Eingabe.
## Tools
**AWS-Services**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) unterstützt Sie bei der Erstellung, Veröffentlichung, Wartung, Überwachung und Sicherung von REST, HTTP und WebSocket APIs in jeder Größenordnung.
+ Das [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) ist ein Softwareentwicklungs-Framework, das Sie bei der Definition und Bereitstellung der AWS-Cloud-Infrastruktur im Code unterstützt.
+ [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) ist ein Befehlszeilen-Cloud-Entwicklungskit, mit dem Sie mit Ihrer AWS Cloud Development Kit (AWS CDK) -App interagieren können.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie über Befehle in Ihrer Befehlszeilen-Shell mit AWS-Services interagieren können.
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) hilft Ihnen dabei, AWS-Ressourcen einzurichten, sie schnell und konsistent bereitzustellen und sie während ihres gesamten Lebenszyklus über AWS-Konten und Regionen hinweg zu verwalten.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS-Ressourcen sicher zu verwalten, indem kontrolliert wird, wer authentifiziert und autorisiert ist, diese zu verwenden.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) unterstützt Sie bei der Erstellung und Kontrolle kryptografischer Schlüssel, um Ihre Daten zu schützen.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Er führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
+ [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) unterstützt Sie bei der Koordination und Verwaltung des Nachrichtenaustauschs zwischen Herausgebern und Kunden, einschließlich Webservern und E-Mail-Adressen.
+ [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) bietet eine sichere, dauerhafte und verfügbare gehostete Warteschlange, mit der Sie verteilte Softwaresysteme und -komponenten integrieren und entkoppeln können.
+ [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) ist ein Plugin für die integrierte Entwicklungsumgebung (IDE) von Visual Studio. Das Toolkit for Visual Studio unterstützt die Entwicklung, das Debuggen und die Bereitstellung von.NET-Anwendungen, die AWS-Services verwenden.
**Andere Tools**
+ [Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/whats-new-visual-studio-2022?view=vs-2022) ist eine IDE, die Compiler, Tools zur Codevervollständigung, Grafikdesigner und andere Funktionen zur Unterstützung der Softwareentwicklung enthält.
**Code**
Der Code für dieses Muster befindet sich im [APG-Beispiel-Repository Tenant Onboarding in SaaS Architecture for Silo Model](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example).
## Epen
### AWS CDK einrichten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Überprüfen Sie die Installation von Node.js. | Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Node.js auf Ihrem lokalen Computer installiert ist.node --version
| AWS-Administrator, AWS DevOps |
| Installieren Sie das AWS CDK Toolkit. | Führen Sie den folgenden Befehl aus, um AWS CDK Toolkit auf Ihrem lokalen Computer zu installieren.npm install -g aws-cdk
[Wenn npm nicht installiert ist, können Sie es von der Website Node.js aus installieren.](https://nodejs.org/en/download/package-manager/) | AWS-Administrator, AWS DevOps |
| Überprüfen Sie die Version des AWS CDK Toolkit. | Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Version des AWS CDK Toolkit korrekt auf Ihrem Computer installiert ist. cdk --version
| AWS-Administrator, AWS DevOps |
### Überprüfen Sie den Code für die Onboarding-Kontrollebene des Mandanten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das Repository | Klonen Sie das [Repository](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example) und navigieren Sie zu dem `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example` Ordner.Öffnen Sie die `\src\TenantOnboardingInfra.sln` Lösung in Visual Studio 2022. Öffnen Sie die `TenantOnboardingInfraStack.cs` Datei und überprüfen Sie den Code.Die folgenden Ressourcen werden als Teil dieses Stacks erstellt:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | AWS-Administrator, AWS DevOps |
| Überprüfen Sie die CloudFormation Vorlage. | Öffnen `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\template` `infra.yaml` Sie im Ordner die CloudFormation Vorlage und überprüfen Sie sie. Diese Vorlage wird mit dem Mandantennamen, der aus der DynamoDB-Tabelle zum Onboarding des Mandanten abgerufen wurde, hydratisiert.Die Vorlage stellt die mandantenspezifische Infrastruktur bereit. In diesem Beispiel werden der AWS-KMS-Schlüssel, Amazon SNS, Amazon SQS und der CloudWatch Alarm bereitgestellt. | App-Entwickler, AWS DevOps |
| Sehen Sie sich die Onboarding-Funktion für Mandanten an. | Öffnen `Function.cs` und überprüfen Sie den Code für die Mandanten-Onboarding-Funktion, die mit der Visual Studio AWS Lambda Lambda-Projektvorlage (.NET Core-C\$1) mit dem.NET 6-Blueprint (Container Image) erstellt wurde.Öffnen Sie die `Dockerfile` und überprüfen Sie den Code. Das `Dockerfile` ist eine Textdatei, die Anweisungen zum Erstellen des Lambda-Container-Images enthält.Beachten Sie, dass die folgenden NuGet Pakete dem `TenantOnboardingFunction` Projekt als Abhängigkeiten hinzugefügt werden:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | App-Entwickler, AWS DevOps |
| Überprüfen Sie die InfraProvisioning Mandantenfunktion. | Navigieren Sie zu `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\InfraProvisioningFunction`.Öffnen `Function.cs` und überprüfen Sie den Code für die Funktion zur Bereitstellung der Mandanteninfrastruktur, die mit der Vorlage Visual Studio AWS Lambda Project (.NET Core — C\$1) mit dem.NET 6-Blueprint (Container Image) erstellt wurde.Öffnen Sie die `Dockerfile` und überprüfen Sie den Code. Beachten Sie, dass die folgenden NuGet Pakete dem `InfraProvisioningFunction` Projekt als Abhängigkeiten hinzugefügt werden:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | App-Entwickler, AWS DevOps |
### Stellen Sie die AWS-Ressourcen bereit
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie die Lösung. | Gehen Sie wie folgt vor, um die Lösung zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Stellen Sie sicher, dass Sie das `Amazon.CDK.Lib NuGet` Paket auf die neueste Version im `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\TenantOnboardingInfra` Projekt aktualisieren, bevor Sie die Lösung erstellen. | App-Developer |
| Bootstrap für die AWS-CDK-Umgebung. | Öffnen Sie die Windows-Befehlszeile und navigieren Sie zum Stammordner der AWS CDK-App, in dem die `cdk.json` Datei verfügbar ist (`\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example`). Führen Sie den folgenden Befehl für das Bootstrapping aus.cdk bootstrap
Wenn Sie ein AWS-Profil für die Anmeldeinformationen erstellt haben, verwenden Sie den Befehl mit Ihrem Profil.cdk bootstrap --profile
| AWS-Administrator, AWS DevOps |
| Listet die AWS-CDK-Stacks auf. | Führen Sie den folgenden Befehl aus, um alle Stacks aufzulisten, die im Rahmen dieses Projekts erstellt werden sollen.cdk ls
cdk ls --profile
Wenn Sie ein AWS-Profil für die Anmeldeinformationen erstellt haben, verwenden Sie den Befehl mit Ihrem Profil.cdk ls --profile
| AWS-Administrator, AWS DevOps |
| Prüfen Sie, welche AWS-Ressourcen erstellt werden. | Führen Sie den folgenden Befehl aus, um alle AWS-Ressourcen zu überprüfen, die im Rahmen dieses Projekts erstellt werden.cdk diff
Wenn Sie ein AWS-Profil für die Anmeldeinformationen erstellt haben, verwenden Sie den Befehl mit Ihrem Profil.cdk diff --profile
| AWS-Administrator, AWS DevOps |
| Stellen Sie alle AWS-Ressourcen mithilfe von AWS CDK bereit. | Führen Sie den folgenden Befehl aus, um alle AWS-Ressourcen bereitzustellen.cdk deploy --all --require-approval never
Wenn Sie ein AWS-Profil für die Anmeldeinformationen erstellt haben, verwenden Sie den Befehl mit Ihrem Profil.cdk deploy --all --require-approval never --profile
Kopieren Sie nach Abschluss der Bereitstellung die API-URL aus dem Ausgabebereich in der Befehlszeile, wie im folgenden Beispiel gezeigt.Outputs:
TenantOnboardingInfraStack.TenantOnboardingAPIEndpoint42E526D7 = https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/
| AWS-Administrator, AWS DevOps |
### Überprüfen Sie die Funktionalität
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie einen neuen Mandanten. | Um den neuen Mandanten zu erstellen, senden Sie die folgende Curl-Anfrage.curl -X POST tenant -d '{"Name":"Tenant123", "Description":"Stack for Tenant123"}'
Ändern Sie den Platzhalter `` auf den tatsächlichen Wert von AWS CDK, wie im folgenden Beispiel gezeigt.curl -X POST https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant -d '{"Name":"Tenant123", "Description":"test12"}'Das folgende Beispiel zeigt die Ausgabe.{"message": "A new tenant added - 5/4/2022 7:11:30 AM"} | App-Entwickler, AWS-Administrator, AWS DevOps |
| Überprüfen Sie die neu erstellten Mandantendetails in DynamoDB. | Gehen Sie wie folgt vor, um die neu erstellten Mandantendetails in DynamoDB zu überprüfen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | App-Entwickler, AWS-Administrator, AWS DevOps |
| Überprüfen Sie die Stack-Erstellung für den neuen Mandanten. | Stellen Sie sicher, dass der neue Stack erfolgreich erstellt und mit der Infrastruktur für den neu erstellten Mandanten gemäß der CloudFormation Vorlage ausgestattet wurde.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | App-Entwickler, AWS-Administrator, AWS DevOps |
| Löschen Sie den Mandanten-Stack. | Um den Tenant-Stack zu löschen, senden Sie die folgende Curl-Anfrage.curl -X DELETE tenant/
Ändern Sie den Platzhalter `` auf den tatsächlichen Wert aus AWS CDK und ändern Sie ihn `` auf den tatsächlichen Wert aus dem vorherigen Schritt zur Mandantenerstellung, wie im folgenden Beispiel gezeigt.curl -X DELETE https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant/Tenant123
Das folgende Beispiel zeigt die Ausgabe.{"message": "Tenant destroyed - 5/4/2022 7:14:48 AM"} | App-Entwickler, AWS DevOps, AWS-Administrator |
| Überprüfen Sie, ob der Stack für den vorhandenen Mandanten gelöscht wurde. | Gehen Sie wie folgt vor, um zu überprüfen, ob der vorhandene Mandanten-Stack gelöscht wurde:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | App-Entwickler, AWS-Administrator, AWS DevOps |
### Bereinigen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Zerstöre die Umwelt. | Stellen Sie vor dem Aufräumen des Stacks Folgendes sicher:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Nach Abschluss der Tests kann AWS CDK verwendet werden, um alle Stacks und zugehörigen Ressourcen zu löschen, indem Sie den folgenden Befehl ausführen.cdk destroy --all;
Wenn Sie ein AWS-Profil für die Anmeldeinformationen erstellt haben, verwenden Sie das Profil.Bestätigen Sie die Aufforderung zum Löschen des Stacks, um den Stack zu löschen. | AWS-Administrator, AWS DevOps |
| Bereinigen Sie Amazon CloudWatch Logs. | Beim Löschen des Stacks werden keine CloudWatch Protokolle (Protokollgruppen und Protokolle) bereinigt, die vom Stack generiert wurden. Bereinigen Sie die CloudWatch Ressourcen manuell mithilfe der CloudWatch Konsole oder der API. | App-Entwickler, AWS DevOps, AWS-Administrator |
## Zugehörige Ressourcen
+ [AWS CDK .NET-Workshop](https://cdkworkshop.com/40-dotnet.html)
+ [Arbeiten mit dem AWS-CDK in C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [CDK.NET-Referenz](https://docs.aws.amazon.com/cdk/api/v2/dotnet/api/index.html)
## Zusätzliche Informationen
**Technologie-Stack auf Steuerungsebene**
Der in .NET geschriebene CDK-Code wird verwendet, um die Infrastruktur der Steuerungsebene bereitzustellen, die aus den folgenden Ressourcen besteht:
1. **API Gateway**
Dient als REST-API-Einstiegspunkt für den Kontrollebenen-Stack.
1. **Lambda-Funktion für Mandanten-Onboarding**
Diese Lambda-Funktion wird von API Gateway mit der Methode m initiiert.
Eine API-Anfrage der POST-Methode führt dazu, dass (`tenant name`,`tenant description`) in die DynamoDB-Tabelle `Tenant Onboarding` eingefügt wird.
In diesem Codebeispiel wird der Mandantenname auch als Teil des Mandanten-Stack-Namens und der Namen der Ressourcen innerhalb dieses Stacks verwendet. Dies soll die Identifizierung dieser Ressourcen erleichtern. Dieser Mandantenname muss im gesamten Setup eindeutig sein, um Konflikte oder Fehler zu vermeiden. Eine detaillierte Einrichtung der Eingabevalidierung wird in der Dokumentation zu den [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) und im Abschnitt *Einschränkungen* erläutert.
Der Persistenzprozess für die DynamoDB-Tabelle ist nur erfolgreich, wenn der Mandantenname in keinem anderen Datensatz in der Tabelle verwendet wird.
Der Mandantenname ist in diesem Fall der Partitionsschlüssel für diese Tabelle, da nur der Partitionsschlüssel als Bedingungsausdruck verwendet werden kann. `PutItem`
Wenn der Mandantenname noch nie zuvor aufgezeichnet wurde, wird der Datensatz erfolgreich in der Tabelle gespeichert.
Wenn der Mandantenname jedoch bereits von einem vorhandenen Datensatz in der Tabelle verwendet wird, schlägt der Vorgang fehl und löst eine DynamoDB-Ausnahme `ConditionalCheckFailedException` aus. Die Ausnahme wird verwendet, um eine Fehlermeldung (`HTTP BadRequest`) zurückzugeben, die angibt, dass der Mandantenname bereits existiert.
Eine `DELETE` Methoden-API-Anfrage entfernt den Datensatz für einen bestimmten Mandantennamen aus der `Tenant Onboardin` G-Tabelle.
Das Löschen von DynamoDB-Datensätzen in diesem Beispiel ist erfolgreich, auch wenn der Datensatz nicht existiert.
Wenn der Zieldatensatz existiert und gelöscht wird, wird ein DynamoDB-Stream-Datensatz erstellt. Andernfalls wird kein Downstream-Datensatz erstellt.
1. **Einbindung von Mandanten in DynamoDB mit aktivierten Amazon DynamoDB DynamoDB-Streams**
Dadurch werden die Metadateninformationen des Mandanten aufgezeichnet, und bei jedem Speichern oder Löschen von Datensätzen wird ein Stream flussabwärts an die `Tenant Infrastructure` Lambda-Funktion gesendet.
1. **Lambda-Funktion für Mandanteninfrastruktur**
Diese Lambda-Funktion wird durch den DynamoDB-Stream-Datensatz aus dem vorherigen Schritt initiiert. Wenn sich der Datensatz auf ein `INSERT` Ereignis bezieht, ruft er AWS CloudFormation auf, um eine neue Mandanteninfrastruktur mit der CloudFormation Vorlage zu erstellen, die in einem S3-Bucket gespeichert ist. Wenn der Datensatz für ist`REMOVE`, initiiert er das Löschen eines vorhandenen Stacks auf der Grundlage des Felds `Tenant Name` des Stream-Datensatzes.
1. **S3 bucket**
Dies dient zum Speichern der CloudFormation Vorlage.
1. **IAM-Rollen für jede Lambda-Funktion und eine Servicerolle für CloudFormation**
Jede Lambda-Funktion hat ihre eigene IAM-Rolle mit den geringsten [Rechten, um ihre Aufgabe zu erfüllen](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege). Die `Tenant On-boarding` Lambda-Funktion hat beispielsweise read/write Zugriff auf DynamoDB, und die `Tenant Infrastructure` Lambda-Funktion kann nur den DynamoDB-Stream lesen.
Für die Bereitstellung von Mandanten-Stacks wird eine benutzerdefinierte CloudFormation Servicerolle erstellt. Diese Servicerolle enthält zusätzliche Berechtigungen für die CloudFormation Stack-Bereitstellung (z. B. den AWS-KMS-Schlüssel). Dadurch werden Rollen zwischen Lambda aufgeteilt und alle Berechtigungen CloudFormation für eine einzelne Rolle (Infrastructure Lambda-Rolle) vermieden.
Berechtigungen, die leistungsstarke Aktionen (wie das Erstellen und Löschen von CloudFormation Stacks) ermöglichen, sind gesperrt und nur für Ressourcen zulässig, die mit beginnen. `tenantcluster-` Die Ausnahme ist AWS KMS aufgrund seiner Benennungskonvention für Ressourcen. Dem aus der API aufgenommenen Mandantennamen werden `tenantcluster-` zusammen mit anderen Validierungsprüfungen vorangestellt (nur alphanumerisch mit Bindestrich und begrenzt auf weniger als 30 Zeichen, sodass er in die meisten AWS-Ressourcenbenennungen passt). Dadurch wird sichergestellt, dass der Mandantenname nicht versehentlich zu einer Störung der Stacks oder Ressourcen der Kerninfrastruktur führt.
**Technologie-Stack für Mandanten**
Eine CloudFormation Vorlage wird im S3-Bucket gespeichert. [Die Vorlage stellt den mandantenspezifischen AWS-KMS-Schlüssel, einen CloudWatch Alarm, ein SNS-Thema, eine SQS-Warteschlange und eine SQS-Richtlinie bereit.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-using-identity-based-policies.html)
Der AWS-KMS-Schlüssel wird von Amazon SNS und Amazon SQS für die Datenverschlüsselung ihrer Nachrichten verwendet. Die Sicherheitspraktiken für [AwsSolutions— SNS2 und AwsSolutions — SQS2](https://github.com/cdklabs/cdk-nag/blob/main/RULES.md) empfehlen, dass Sie Amazon SNS und Amazon SQS mit Verschlüsselung einrichten. CloudWatch Alarme funktionieren jedoch nicht mit Amazon SNS, wenn Sie einen von AWS verwalteten Schlüssel verwenden. Daher müssen Sie in diesem Fall einen vom Kunden verwalteten Schlüssel verwenden. Weitere Informationen finden Sie im [AWS Knowledge Center](https://aws.amazon.com/premiumsupport/knowledge-center/cloudwatch-receive-sns-for-alarm-trigger/).
Die SQS-Richtlinie wird in der Amazon SQS SQS-Warteschlange verwendet, damit das erstellte SNS-Thema die Nachricht an die Warteschlange übermitteln kann. Ohne die SQS-Richtlinie wird der Zugriff verweigert. Weitere Informationen finden Sie in der [Amazon SNS SNS-Dokumentation](https://docs.aws.amazon.com/sns/latest/dg/subscribe-sqs-queue-to-sns-topic.html#SendMessageToSQS.sqs.permissions).
# Zerlegen Sie Monolithen mithilfe von CQRS und Event Sourcing in Microservices
*Rodolfo Jr. Cerrada, Dmitry Gulin und Tabby Ward,* Amazon Web Services
## Zusammenfassung
Dieses Muster kombiniert zwei Muster und verwendet sowohl das Command Query Responsibility Separation (CQRS) -Muster als auch das Event Sourcing-Muster. Das CQRS-Muster trennt die Zuständigkeiten der Befehls- und Abfragemodelle. Das Eventsourcing-Muster nutzt die Vorteile der asynchronen ereignisgesteuerten Kommunikation, um die allgemeine Benutzererfahrung zu verbessern.
Sie können CQRS- und Amazon Web Services (AWS) -Services verwenden, um jedes Datenmodell unabhängig zu verwalten und zu skalieren und gleichzeitig Ihre Monolith-Anwendung in eine Microservices-Architektur umzustrukturieren. Anschließend können Sie das Event Sourcing Pattern verwenden, um Daten aus der Befehlsdatenbank mit der Abfragedatenbank zu synchronisieren.
Dieses Muster verwendet Beispielcode, der eine Lösungsdatei (\$1.sln) enthält, die Sie mit der neuesten Version von Visual Studio öffnen können. Das Beispiel enthält Reward-API-Code, der zeigt, wie CQRS und Event Sourcing in serverlosen und traditionellen oder lokalen AWS-Anwendungen funktionieren.
[Weitere Informationen zu CQRS und Event Sourcing finden Sie im Abschnitt Zusätzliche Informationen.](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional)
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto
+ Amazon CloudWatch
+ Amazon-DynamoDB-Tabellen
+ Amazon DynamoDB Streams
+ Zugriffsschlüssel und geheimer Schlüssel für AWS Identity and Access Management (IAM); weitere Informationen finden Sie im Video im Abschnitt *Verwandte Ressourcen*
+ AWS Lambda
+ Vertrautheit mit Visual Studio
+ *Vertrautheit mit AWS Toolkit for Visual Studio; weitere Informationen finden Sie im *Demo-Video zu AWS Toolkit for Visual Studio* im Abschnitt Verwandte Ressourcen*
**Produktversionen**
+ [Visual Studio 2019 Community-Ausgabe](https://visualstudio.microsoft.com/downloads/).
+ [AWS Toolkit for Visual Studio 2019](https://aws.amazon.com/visualstudio/).
+ .NET Core 3.1. Diese Komponente ist eine Option in der Visual Studio-Installation. Um .NET Core bei der Installation einzubeziehen, wählen Sie **plattformübergreifende Entwicklung mit NET Core** aus.
**Einschränkungen**
+ Der Beispielcode für eine herkömmliche lokale Anwendung (ASP.NET Core-Web-API und Datenzugriffsobjekte) ist nicht im Lieferumfang einer Datenbank enthalten. Er wird jedoch mit dem `CustomerData` In-Memory-Objekt geliefert, das als Scheindatenbank fungiert. Der bereitgestellte Code reicht aus, um das Muster zu testen.
## Architektur
**Quelltechnologie-Stack**
+ ASP.NET Core-Web-API-Projekt
+ IIS-Webserver
+ Datenzugriffsobjekt
+ CRUD-Modell
**Quellarchitektur**
In der Quellarchitektur enthält das CRUD-Modell sowohl Befehls- als auch Abfrageschnittstellen in einer Anwendung. Beispielcode finden Sie unter `CustomerDAO.cs` (angehängt).
![\[Verbindungen zwischen Anwendung, Serviceschnittstelle, Kunden-CRUD-Modell und Datenbank.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1cd3a84c-12c7-4306-99aa-23f2c53d3cd3.png)
**Zieltechnologie-Stack**
+ Amazon DynamoDB
+ Amazon DynamoDB Streams
+ AWS Lambda
+ (Fakultativ) Amazon API Gateway
+ (Optional) Amazon Simple Notification Service (Amazon SNS)
**Zielarchitektur**
In der Zielarchitektur sind die Befehls- und Abfrageschnittstellen getrennt. Die im folgenden Diagramm gezeigte Architektur kann mit API Gateway und Amazon SNS erweitert werden. Weitere Informationen finden Sie im Abschnitt [Zusätzliche Informationen](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional).
![\[Anwendung, die eine Verbindung mit den serverlosen Microservices Customer Command und Customer Query herstellt.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1c665697-e3ac-4ef4-98d0-86c2cbf164c1.png)
1. Befehls-Lambda-Funktionen führen Schreiboperationen wie Erstellen, Aktualisieren oder Löschen in der Datenbank durch.
1. Lambda-Abfragefunktionen führen Lesevorgänge wie Get oder Select in der Datenbank durch.
1. Diese Lambda-Funktion verarbeitet die DynamoDB-Streams aus der Befehlsdatenbank und aktualisiert die Query-Datenbank für die Änderungen.
## Tools
**Tools**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) — Amazon DynamoDB ist ein vollständig verwalteter NoSQL-Datenbankservice, der schnelle und vorhersehbare Leistung mit nahtloser Skalierbarkeit bietet.
+ [Amazon DynamoDB Streams — DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) erfasst eine zeitlich geordnete Abfolge von Änderungen auf Elementebene in jeder DynamoDB-Tabelle. Anschließend werden diese Informationen bis zu 24 Stunden lang in einem Protokoll gespeichert. Die Verschlüsselung ruhender Daten verschlüsselt die Daten in DynamoDB Streams.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) — AWS Lambda ist ein Rechenservice, der die Ausführung von Code unterstützt, ohne Server bereitzustellen oder zu verwalten. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde. Sie bezahlen nur für die Datenverarbeitungszeit, die Sie wirklich nutzen und es werden keine Gebühren in Rechnung gestellt, wenn Ihr Code nicht ausgeführt wird.
+ [AWS-Managementkonsole](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/learn-whats-new.html) — Die AWS-Managementkonsole ist eine Webanwendung, die eine breite Sammlung von Servicekonsolen für die Verwaltung von AWS-Services umfasst.
+ [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/) — Visual Studio 2019 ist eine integrierte Entwicklungsumgebung (IDE). Die Community Edition ist für Open-Source-Mitwirkende kostenlos. In diesem Muster verwenden Sie Visual Studio 2019 Community Edition, um Beispielcode zu öffnen, zu kompilieren und auszuführen. Nur zur Anzeige können Sie einen beliebigen Texteditor oder [Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html) verwenden.
+ [AWS Toolkit für Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) — Das AWS Toolkit for Visual Studio ist ein Plugin für die Visual Studio-IDE. Das AWS Toolkit for Visual Studio erleichtert Ihnen das Entwickeln, Debuggen und Bereitstellen von.NET-Anwendungen, die AWS-Services verwenden.
**Code**
Der Beispielcode ist angehängt. Anweisungen zur Bereitstellung des Beispielcodes finden Sie im Abschnitt *Epics*.
## Epen
### Öffnen und erstellen Sie die Lösung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Öffnen Sie die Lösung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Developer |
| Erstellen Sie die Lösung. | Öffnen Sie das Kontextmenü (mit der rechten Maustaste) für die Lösung und wählen Sie dann **Lösung erstellen** aus. Dadurch werden alle Projekte in der Lösung erstellt und kompiliert. Es sollte erfolgreich kompiliert werden.Visual Studio Solution Explorer sollte die Verzeichnisstruktur anzeigen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Developer |
### Erstellen Sie die DynamoDB-Tabellen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Geben Sie die Anmeldeinformationen an. | Wenn Sie noch keinen Zugriffsschlüssel haben, sehen Sie sich das Video im Abschnitt *Verwandte Ressourcen* an.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Entwickler, Dateningenieur, DBA |
| Erstellen Sie das Projekt. | **Um das Projekt zu erstellen, öffnen Sie das Kontextmenü (Rechtsklick) für das Projekt **aws.apg.cqrses.Build** und wählen Sie dann Build aus.** | App-Entwickler, Dateningenieur, DBA |
| Erstellen und füllen Sie die Tabellen. | ****Um die Tabellen zu erstellen und sie mit Ausgangsdaten zu füllen, öffnen Sie das Kontextmenü (mit der rechten Maustaste) für das Projekt **aws.apg.cqrses.Build** und wählen Sie dann Debug, Start New Instance aus.**** | App-Entwickler, Dateningenieur, DBA |
| Überprüfen Sie die Tabellenkonstruktion und die Daten. | Gehen Sie zur Überprüfung zu **AWS Explorer** und erweitern Sie **Amazon DynamoDB**. Es sollte die Tabellen anzeigen. Öffnen Sie jede Tabelle, um die Beispieldaten anzuzeigen. | App-Entwickler, Dateningenieur, DBA |
### Führen Sie lokale Tests durch
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie das CQRS-Projekt. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Entwickler, Testingenieur |
| Erstellen Sie das Eventsourcing-Projekt. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Entwickler, Testingenieur |
| Führen Sie die Tests aus. | Um alle Tests auszuführen, wählen Sie **Ansicht**, **Test Explorer** und dann **Alle Tests in Ansicht ausführen** aus. Alle Tests sollten erfolgreich sein, was durch ein grünes Häkchen gekennzeichnet ist. | App-Entwickler, Testingenieur |
### Veröffentlichen Sie die CQRS Lambda-Funktionen in AWS
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Veröffentlichen Sie die erste Lambda-Funktion. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Entwickler, DevOps Ingenieur |
| Überprüfen Sie den Funktions-Upload. | (Optional) Sie können überprüfen, ob die Funktion erfolgreich geladen wurde, indem Sie zu AWS Explorer navigieren und **AWS Lambda** erweitern. Um das Testfenster zu öffnen, wählen Sie die Lambda-Funktion (Doppelklick). | App-Entwickler, Ingenieur DevOps |
| Testen Sie die Lambda-Funktion. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Alle CQRS Lambda-Projekte befinden sich in den Ordnern `CQRS AWS Serverless\CQRS\Command Microservice` und ` CQRS AWS Serverless\CQRS\Command Microservice` Solution. Das Lösungsverzeichnis und die Projekte finden Sie unter **Quellcodeverzeichnis** im Abschnitt [Zusätzliche Informationen](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | App-Entwickler, DevOps Ingenieur |
| Veröffentlichen Sie die verbleibenden Funktionen. | Wiederholen Sie die vorherigen Schritte für die folgenden Projekte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Entwickler, DevOps Ingenieur |
### Richten Sie die Lambda-Funktion als Event-Listener ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Veröffentlichen Sie die Lambda-Event-Handler „Customer“ und „Reward“. | Um die einzelnen Event-Handler zu veröffentlichen, folgen Sie den Schritten im vorherigen Abschnitt.Die Projekte befinden sich in den Ordnern `CQRS AWS Serverless\Event Source\Customer Event` und `CQRS AWS Serverless\Event Source\Reward Event` Solution. Weitere Informationen finden Sie unter *Quellcode-Verzeichnis* im Abschnitt [Zusätzliche Informationen](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | App-Developer |
| Hängen Sie den Lambda-Event-Listener an, der das Ereignis ausgibt. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Nachdem der Listener erfolgreich an die DynamoDB-Tabelle angehängt wurde, wird er auf der Lambda-Designer-Seite angezeigt. | App-Developer |
| Veröffentlichen Sie die EventSourceReward Lambda-Funktion und hängen Sie sie an. | Um die `EventSourceReward` Lambda-Funktion zu veröffentlichen und anzuhängen, wiederholen Sie die Schritte in den beiden vorherigen Storys und wählen Sie **cqrses-reward-cmd**aus der Dropdownliste der **DynamoDB-Tabelle** aus. | App-Developer |
### Testen und validieren Sie die DynamoDB-Streams und den Lambda-Trigger
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Testen Sie den Stream und den Lambda-Trigger. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Developer |
| Überprüfen Sie, indem Sie die DynamoDDB-Belohnungsabfragetabelle verwenden. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Developer |
| Bestätigen Sie mithilfe von Protokollen. CloudWatch | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | App-Developer |
| Validieren Sie den Trigger EventSourceCustomer . | Um den `EventSourceCustomer` Trigger zu validieren, wiederholen Sie die Schritte in diesem Epic und verwenden Sie dabei die entsprechende Kundentabelle und die CloudWatch Logs des `EventSourceCustomer` Triggers. | App-Developer |
## Zugehörige Ressourcen
**Referenzen**
+ [Visual Studio 2019 Community Edition wird heruntergeladen](https://visualstudio.microsoft.com/downloads/)
+ [AWS Toolkit for Visual Studio herunterladen](https://aws.amazon.com/visualstudio/)
+ [AWS Toolkit for Visual Studio — Benutzerhandbuch](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html)
+ [Serverlos auf AWS](https://aws.amazon.com/serverless/)
+ [DynamoDB-Anwendungsfälle und Entwurfsmuster](https://aws.amazon.com/blogs/database/dynamodb-streams-use-cases-and-design-patterns/)
+ [Martin Fowler CQRS](https://martinfowler.com/bliki/CQRS.html)
+ [Martin Fowler Beschaffung von Veranstaltungen](https://martinfowler.com/eaaDev/EventSourcing.html)
**Videos**
+ [Demo zum AWS Toolkit for Visual Studio](https://www.youtube.com/watch?v=B190tcu1ERk)
+ [Wie erstelle ich eine Zugriffsschlüssel-ID für einen neuen IAM-Benutzer?](https://www.youtube.com/watch?v=665RYobRJDY)
## Zusätzliche Informationen
**CQRS und Eventsourcing**
*CQRS*
Das CQRS-Muster unterteilt ein einzelnes konzeptionelles Betriebsmodell, z. B. ein einzelnes CRUD-Modell (Create, Read, Update, Delete) für Datenzugriffsobjekte, in Befehls- und Abfrageoperationsmodelle. Das Befehlsmodell bezieht sich auf jede Operation, z. B. Erstellen, Aktualisieren oder Löschen, die den Status ändert. Das Abfragemodell bezieht sich auf jede Operation, die einen Wert zurückgibt.
![\[Architektur mit Serviceschnittstelle, CRUD-Modell und Datenbank.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/3f64756d-681e-4f0e-8034-746263d857b2.png)
1. Das Kunden-CRUD-Modell umfasst die folgenden Schnittstellen:
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
Wenn Ihre Anforderungen immer komplexer werden, können Sie von diesem Einzelmodellansatz abrücken. CQRS verwendet ein Befehlsmodell und ein Abfragemodell, um die Verantwortung für das Schreiben und Lesen von Daten zu trennen. Auf diese Weise können die Daten unabhängig voneinander verwaltet und verwaltet werden. Bei einer klaren Trennung der Zuständigkeiten wirken sich Verbesserungen an den einzelnen Modellen nicht auf das andere aus. Diese Trennung verbessert Wartung und Leistung und reduziert die Komplexität der Anwendung, wenn sie wächst.
![\[Die Anwendung wurde in Befehls- und Abfragemodelle aufgeteilt und nutzt eine einzige Datenbank.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/12db023c-eb81-4c27-bbb9-b085b13176ae.png)
1. Schnittstellen im Customer Command-Modell:
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
1. Schnittstellen im Modell Customer Query:
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
+ `GetMonthlyStatement()`
Beispielcode finden Sie unter *Quellcode-Verzeichnis*.
Das CQRS-Muster entkoppelt dann die Datenbank. Diese Entkopplung führt zur vollständigen Unabhängigkeit der einzelnen Dienste, was der Hauptbestandteil der Microservice-Architektur ist.
![\[Separate Datenbanken für Befehls- und Abfragemodelle.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/016dbfa8-3bd8-42ee-afa1-38a98986c7d5.png)
Mit CQRS in der AWS-Cloud können Sie jeden Service weiter optimieren. Sie können beispielsweise verschiedene Recheneinstellungen festlegen oder zwischen einem serverlosen oder einem containerbasierten Microservice wählen. Sie können Ihr lokales Caching durch Amazon ersetzen. ElastiCache Wenn Sie ein lokales publish/subscribe Messaging-Programm haben, können Sie es durch Amazon Simple Notification Service (Amazon SNS) ersetzen. Darüber hinaus können Sie die pay-as-you-go Preisgestaltung und das breite Spektrum an AWS-Services nutzen, bei denen Sie nur für das bezahlen, was Sie tatsächlich nutzen.
CQRS bietet die folgenden Vorteile:
+ Unabhängige Skalierung — Für jedes Modell kann die Skalierungsstrategie an die Anforderungen und die Nachfrage des Dienstes angepasst werden. Ähnlich wie bei Hochleistungsanwendungen ermöglicht die Trennung von Lese- und Schreibvorgängen, dass das Modell unabhängig skaliert werden kann, um jeder Anforderung gerecht zu werden. Sie können auch Rechenressourcen hinzufügen oder reduzieren, um den Skalierbarkeitsanforderungen eines Modells gerecht zu werden, ohne dass sich dies auf das andere Modell auswirkt.
+ Unabhängige Wartung — Die Trennung von Abfrage- und Befehlsmodellen verbessert die Wartbarkeit der Modelle. Sie können Codeänderungen und Erweiterungen an einem Modell vornehmen, ohne dass sich dies auf das andere auswirkt.
+ Sicherheit — Es ist einfacher, die Berechtigungen und Richtlinien auf separate Modelle zum Lesen und Schreiben anzuwenden.
+ Optimierte Lesevorgänge — Sie können ein Schema definieren, das für Abfragen optimiert ist. Sie können beispielsweise ein Schema für die aggregierten Daten und ein separates Schema für die Faktentabellen definieren.
+ Integration — CQRS passt gut zu ereignisbasierten Programmiermodellen.
+ Verwaltete Komplexität — Die Trennung in Abfrage- und Befehlsmodelle eignet sich für komplexe Domänen.
Beachten Sie bei der Verwendung von CQRS die folgenden Vorbehalte:
+ Das CQRS-Muster gilt nur für einen bestimmten Teil einer Anwendung und nicht für die gesamte Anwendung. Wenn es in einer Domäne implementiert wird, die dem Muster nicht entspricht, kann es die Produktivität verringern, das Risiko erhöhen und zu Komplexität führen.
+ Das Muster eignet sich am besten für häufig verwendete Modelle mit einem Ungleichgewicht zwischen Lese- und Schreibvorgängen.
+ Für leseintensive Anwendungen, wie z. B. große Berichte, deren Verarbeitung einige Zeit in Anspruch nimmt, bietet Ihnen CQRS die Möglichkeit, die richtige Datenbank auszuwählen und ein Schema zum Speichern Ihrer aggregierten Daten zu erstellen. Dadurch wird die Reaktionszeit beim Lesen und Anzeigen des Berichts verbessert, da die Berichtsdaten nur einmal verarbeitet und in der aggregierten Tabelle abgelegt werden.
+ Für schreibintensive Anwendungen können Sie die Datenbank für Schreibvorgänge konfigurieren und dem Befehls-Microservice ermöglichen, unabhängig zu skalieren, wenn der Schreibbedarf steigt. Beispiele finden Sie unter den `AWS.APG.CQRSES.CommandRedeemRewardLambda` Microservices und. `AWS.APG.CQRSES.CommandAddRewardLambda`
*Ereignis-Sourcing*
Der nächste Schritt besteht darin, die Abfragedatenbank mithilfe von Event Sourcing zu synchronisieren, wenn ein Befehl ausgeführt wird. Betrachten Sie beispielsweise die folgenden Ereignisse:
+ Ein Kundenprämienpunkt wird hinzugefügt, sodass die Gesamtzahl oder die aggregierten Prämienpunkte des Kunden in der Abfragedatenbank aktualisiert werden müssen.
+ Der Nachname eines Kunden wird in der Befehlsdatenbank aktualisiert, weshalb die Ersatzkundeninformationen in der Abfragedatenbank aktualisiert werden müssen.
Im herkömmlichen CRUD-Modell stellen Sie die Konsistenz der Daten sicher, indem Sie die Daten sperren, bis eine Transaktion abgeschlossen ist. Beim Event Sourcing werden die Daten synchronisiert, indem eine Reihe von Ereignissen veröffentlicht wird, die dann von einem Abonnenten genutzt werden, um seine jeweiligen Daten zu aktualisieren.
Das Muster der Ereignisbeschaffung gewährleistet und zeichnet eine vollständige Reihe von Aktionen auf, die an den Daten vorgenommen wurden, und veröffentlicht sie in einer Abfolge von Ereignissen. Diese Ereignisse stellen eine Reihe von Änderungen an den Daten dar, die Abonnenten dieses Ereignisses verarbeiten müssen, um ihre Aufzeichnungen auf dem neuesten Stand zu halten. Diese Ereignisse werden vom Abonnenten verarbeitet, wodurch die Daten in der Datenbank des Abonnenten synchronisiert werden. In diesem Fall ist das die Abfragedatenbank.
Das folgende Diagramm zeigt Event Sourcing, das mit CQRS auf AWS verwendet wird.
![\[Microservice-Architektur für die CQRS- und Eventsourcing-Muster unter Verwendung serverloser AWS-Services.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/cc9bc84a-60b4-4459-9a5c-2334c69dbb4e.png)
1. Befehls-Lambda-Funktionen führen Schreiboperationen wie Erstellen, Aktualisieren oder Löschen in der Datenbank durch.
1. Lambda-Abfragefunktionen führen Lesevorgänge wie Get oder Select in der Datenbank durch.
1. Diese Lambda-Funktion verarbeitet die DynamoDB-Streams aus der Befehlsdatenbank und aktualisiert die Query-Datenbank für die Änderungen. Sie können diese Funktion auch verwenden, um eine Nachricht an Amazon SNS zu veröffentlichen, damit die Abonnenten die Daten verarbeiten können.
1. (Optional) Der Lambda-Event-Abonnent verarbeitet die von Amazon SNS veröffentlichte Nachricht und aktualisiert die Query-Datenbank.
1. (Optional) Amazon SNS sendet eine E-Mail-Benachrichtigung über den Schreibvorgang.
Auf AWS kann die Abfragedatenbank mit DynamoDB Streams synchronisiert werden. DynamoDB erfasst eine zeitlich geordnete Abfolge von Änderungen auf Elementebene in einer DynamoBDB-Tabelle nahezu in Echtzeit und speichert die Informationen dauerhaft innerhalb von 24 Stunden.
Durch die Aktivierung von DynamoDB Streams kann die Datenbank eine Sequenz von Ereignissen veröffentlichen, die das Eventsourcing-Muster ermöglicht. Das Event-Sourcing-Muster fügt den Event-Abonnenten hinzu. Die Anwendung für Event-Abonnenten verarbeitet das Ereignis und verarbeitet es je nach Verantwortung des Abonnenten. Im vorherigen Diagramm überträgt der Ereignisabonnent die Änderungen an die Query DynamoDB-Datenbank, um die Daten synchron zu halten. Durch die Verwendung von Amazon SNS, dem Message Broker und der Event-Abonnentenanwendung bleibt die Architektur entkoppelt.
Event Sourcing bietet die folgenden Vorteile:
+ Konsistenz für Transaktionsdaten
+ Ein zuverlässiger Prüfpfad und eine Historie der Maßnahmen, anhand derer die anhand der Daten ergriffenen Maßnahmen überwacht werden können
+ Ermöglicht verteilten Anwendungen wie Microservices, ihre Daten in der gesamten Umgebung zu synchronisieren
+ Zuverlässige Veröffentlichung von Ereignissen, wann immer sich der Status ändert
+ Rekonstruktion oder Wiederholung vergangener Staaten
+ Lose gekoppelte Entitäten, die Ereignisse austauschen, um von einer monolithischen Anwendung zu Microservices zu migrieren
+ Reduzierung von Konflikten, die durch gleichzeitige Aktualisierungen verursacht werden; durch die Ereignisbeschaffung entfällt die Notwendigkeit, Objekte direkt im Datenspeicher zu aktualisieren
+ Flexibilität und Erweiterbarkeit durch die Entkopplung von Aufgabe und Ereignis
+ Updates für externe Systeme
+ Verwaltung mehrerer Aufgaben in einem einzigen Ereignis
Beachten Sie bei der Verwendung von Event Sourcing die folgenden Vorbehalte:
+ Da es bei der Aktualisierung von Daten zwischen den Quell-Abonnentendatenbanken zu Verzögerungen kommt, besteht die einzige Möglichkeit, eine Änderung rückgängig zu machen, darin, dem Ereignisspeicher ein kompensierendes Ereignis hinzuzufügen.
+ Die Implementierung von Event Sourcing ist aufgrund des unterschiedlichen Programmierstils mit einer gewissen Lernkurve verbunden.
**Daten testen**
Verwenden Sie die folgenden Testdaten, um die Lambda-Funktion nach erfolgreicher Bereitstellung zu testen.
**CommandCreate Kunde**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Done", "CompanyName":"AnyCompany", "Address": "USA", "VIP":true }
```
**CommandUpdate Kunde**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Doe", "CompanyName":"Example Corp.", "Address": "Seattle, USA", "VIP":true }
```
**CommandDelete Kunde**
Geben Sie die Kunden-ID als Anfragedaten ein. Wenn die Kunden-ID beispielsweise 151 ist, geben Sie 151 als Anforderungsdaten ein.
```
151
```
**QueryCustomerList**
Das ist leer. Wenn es aufgerufen wird, werden alle Kunden zurückgegeben.
**CommandAddReward**
Dadurch werden dem Kunden mit der ID 1 (Richard) 40 Punkte gutgeschrieben.
```
{
"Id":10101,
"CustomerId":1,
"Points":40
}
```
**CommandRedeemReward**
Dem Kunden mit der ID 1 (Richard) werden dadurch 15 Punkte abgezogen.
```
{
"Id":10110,
"CustomerId":1,
"Points":15
}
```
**QueryReward**
Geben Sie die ID des Kunden ein. Geben Sie beispielsweise 1 für Richard, 2 für Arnav und 3 für Shirley ein.
```
2
```
**Quellcode-Verzeichnis**
Verwenden Sie die folgende Tabelle als Leitfaden für die Verzeichnisstruktur der Visual Studio-Lösung.
*Lösungsverzeichnis mit lokalen CQRS-Codebeispielen*
![\[Lösungsverzeichnis mit erweiterten Befehls- und Abfragediensten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/4811c2c0-643b-410f-bb87-0b86ec5e194c.png)
**CRUD-Modell für Kunden**
Lokales CQRS-Codebeispiel\$1 CRUD-Modell\$1 AWS.APG.CQRSES.DAL-Projekt
**CQRS-Version des Kunden-CRUD-Modells**
+ Kundenbefehl: Projekt `CQRS On-Premises Code Sample\CQRS Model\Command Microservice\AWS.APG.CQRSES.Command`
+ Kundenanfrage: `CQRS On-Premises Code Sample\CQRS Model\Query Microservice\AWS.APG.CQRSES.Query` Projekt
**Microservices für Befehle und Abfragen**
Der Command-Mikroservice befindet sich im Lösungsordner: `CQRS On-Premises Code Sample\CQRS Model\Command Microservice`
+ `AWS.APG.CQRSES.CommandMicroservice`Das ASP.NET Core API-Projekt dient als Einstiegspunkt, über den Verbraucher mit dem Dienst interagieren.
+ `AWS.APG.CQRSES.Command`.NET Core-Projekt ist ein Objekt, das befehlsbezogene Objekte und Schnittstellen hostet.
Der Abfrage-Microservice befindet sich im Lösungsordner: `CQRS On-Premises Code Sample\CQRS Model\Query Microservice`
+ `AWS.APG.CQRSES.QueryMicroservice`Das ASP.NET Core API-Projekt dient als Einstiegspunkt, über den Verbraucher mit dem Dienst interagieren.
+ `AWS.APG.CQRSES.Query`.NET Core-Projekt ist ein Objekt, das abfragebezogene Objekte und Schnittstellen hostet.
*CQRS AWS-Lösungsverzeichnis für serverlosen Code*
![\[Lösungsverzeichnis, das sowohl Microservices als auch die Eventquelle enthält, erweitert.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/23f8655c-95ad-422c-b20a-e29dc145e995.png)
Dieser Code ist die AWS-Version des lokalen Codes, der serverlose AWS-Services verwendet.
In C\$1.NET Core wird jede Lambda-Funktion durch ein .NET Core-Projekt repräsentiert. Im Beispielcode dieses Musters gibt es für jede Schnittstelle im Befehls- und Abfragemodell ein eigenes Projekt.
**CQRS verwendet AWS-Services**
Sie finden das Stammlösungsverzeichnis für CQRS, das AWS-Serverless-Services verwendet, im `CQRS AWS Serverless\CQRS` Ordner. Das Beispiel umfasst zwei Modelle: Customer und Reward.
Die Befehle Lambda-Funktionen für Customer und Reward befinden sich in den `CQRS\Command Microservice\Reward` Ordnern `CQRS\Command Microservice\Customer` und. Sie enthalten die folgenden Lambda-Projekte:
+ Kundenbefehl:`CommandCreateLambda`,`CommandDeleteLambda`, und `CommandUpdateLambda`
+ Belohnungsbefehl: `CommandAddRewardLambda` und `CommandRedeemRewardLambda`
Die Lambda-Abfragefunktionen für Customer und Reward befinden sich in den `CQRS\QueryMicroservice\Reward` Ordnern `CQRS\Query Microservice\Customer` und. Sie enthalten die Projekte `QueryCustomerListLambda` und `QueryRewardLambda` Lambda.
**CQRS-Testprojekt**
Das Testprojekt befindet sich unter dem `CQRS\Tests` Ordner. Dieses Projekt enthält ein Testskript zur Automatisierung des Testens der CQRS-Lambda-Funktionen.
**Beschaffung von Veranstaltungen mithilfe von AWS-Services**
Die folgenden Lambda-Event-Handler werden von den DynamoDB-Streams Customer und Reward initiiert, um die Daten in Abfragetabellen zu verarbeiten und zu synchronisieren.
+ Die `EventSourceCustomer` Lambda-Funktion ist dem DynamoDB-Stream Customer table (`cqrses-customer-cmd`) zugeordnet.
+ Die `EventSourceReward` Lambda-Funktion ist dem DynamoDB-Stream Reward table (`cqrses-reward-cmd`) zugeordnet.
## Anlagen
[Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/9f1bc700-def4-4201-bb2d-f1fa27404f15/attachments/attachment.zip)
# Mehr Muster
**Topics**
+ [Greifen Sie mit AWS PrivateLink und einem Network Load Balancer privat auf Container-Anwendungen auf Amazon EKS zu](access-container-applications-privately-on-amazon-eks-using-aws-privatelink-and-a-network-load-balancer.md)
+ [Automatisieren Sie das Hinzufügen oder Aktualisieren von Windows-Registrierungseinträgen mit AWS Systems Manager](automate-adding-or-updating-windows-registry-entries-using-aws-systems-manager.md)
+ [Automatisieren Sie regionsübergreifendes Failover und Failback mithilfe des DR Orchestrator Framework](automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.md)
+ [Automatisches Erstellen und Bereitstellen einer Java-Anwendung auf Amazon EKS mithilfe einer CI/CD Pipeline](automatically-build-and-deploy-a-java-application-to-amazon-eks-using-a-ci-cd-pipeline.md)
+ [Automatisches Erstellen von CI/CD Pipelines und Amazon ECS-Clustern für Microservices mithilfe von AWS CDK](automatically-build-ci-cd-pipelines-and-amazon-ecs-clusters-for-microservices-using-aws-cdk.md)
+ [Mainframe-Daten mithilfe von BMC AMI Cloud Data auf Amazon S3 sichern und archivieren](back-up-and-archive-mainframe-data-to-amazon-s3-using-bmc-ami-cloud-data.md)
+ [Erstellen Sie ein Micro Focus Enterprise Server PAC mit Amazon EC2 Auto Scaling und Systems Manager](build-a-micro-focus-enterprise-server-pac-with-amazon-ec2-auto-scaling-and-systems-manager.md)
+ [Bauen Sie mit Amazon ein Datennetz für Unternehmen auf DataZone AWS CDK, und AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md)
+ [Containerisieren Sie Mainframe-Workloads, die von Blu Age modernisiert wurden](containerize-mainframe-workloads-that-have-been-modernized-by-blu-age.md)
+ [EBCDIC-Daten mithilfe von Python in ASCII auf AWS konvertieren und entpacken](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md)
+ [Konvertieren Sie Mainframe-Datendateien mit komplexen Datensatzlayouts mit Micro Focus](convert-mainframe-data-files-with-complex-record-layouts-using-micro-focus.md)
+ [Erstellen Sie ein Portal für Mikro-Frontends mithilfe AWS Amplify von Angular und Module Federation](create-amplify-micro-frontend-portal.md)
+ [Container mithilfe von Elastic Beanstalk bereitstellen](deploy-containers-by-using-elastic-beanstalk.md)
+ [Emulieren Sie Oracle DR mithilfe einer PostgreSQL-kompatiblen globalen Aurora-Datenbank](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md)
+ [Generieren Sie Dateneinblicke mithilfe AWS Mainframe Modernization von Amazon Q in Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md)
+ [Generieren Sie Einblicke in z/OS Db2-Daten mithilfe AWS Mainframe Modernization von Amazon Q in Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md)
+ [Automatische Identifizierung doppelter Container-Images bei der Migration zu einem Amazon ECR-Repository](identify-duplicate-container-images-automatically-when-migrating-to-ecr-repository.md)
+ [Implementieren Sie KI-gestützte Kubernetes-Diagnose und -Fehlerbehebung mit der Integration von K8SGPT und Amazon Bedrock](implement-ai-powered-kubernetes-diagnostics-and-troubleshooting-with-k8sgpt-and-amazon-bedrock-integration.md)
+ [Implementieren Sie die auf Microsoft Entra ID basierende Authentifizierung in einer modernisierten Mainframe-Anwendung von AWS Blu Age](implement-entra-id-authentication-in-aws-blu-age-modernized-mainframe-application.md)
+ [Implementieren Sie die pfadbasierte API-Versionierung mithilfe benutzerdefinierter Domains in Amazon API Gateway](implement-path-based-api-versioning-by-using-custom-domains.md)
+ [Schrittweise Migration von Amazon RDS for Oracle zu Amazon RDS for PostgreSQL mithilfe von Oracle SQL Developer und AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md)
+ [Integrieren Sie Stonebranch Universal Controller in AWS Mainframe Modernization](integrate-stonebranch-universal-controller-with-aws-mainframe-modernization.md)
+ [AWS Service Catalog-Produkte in mehreren AWS-Konten und AWS-Regionen verwalten](manage-aws-service-catalog-products-in-multiple-aws-accounts-and-aws-regions.md)
+ [Migrieren Sie ein AWS Mitgliedskonto von AWS Organizations zu AWS Control Tower](migrate-an-aws-member-account-from-aws-organizations-to-aws-control-tower.md)
+ [Migrieren und replizieren Sie VSAM-Dateien mit Connect von Precisely zu Amazon RDS oder Amazon MSK](migrate-and-replicate-vsam-files-to-amazon-rds-or-amazon-msk-using-connect-from-precisely.md)
+ [Migrieren Sie mithilfe von AWS DMS von SAP ASE zu Amazon RDS for SQL Server](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md)
+ [Migrieren Sie externe Oracle-Tabellen zu Amazon Aurora PostgreSQL-kompatibel](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md)
+ [Modernisieren Sie die CardDemo Mainframe-Anwendung mithilfe von AWS Transform](modernize-carddemo-mainframe-app.md)
+ [Modernisieren und implementieren Sie Mainframe-Anwendungen mithilfe von Terraform AWS Transform](modernize-mainframe-app-transform-terraform.md)
+ [Modernisieren Sie Mainframe-Batchdruck-Workloads mithilfe AWS von Rocket Enterprise Server und LRS VPSX/MFI](modernize-mainframe-batch-printing-workloads-on-aws-by-using-rocket-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernisieren Sie Mainframe-Online-Druck-Workloads auf AWS mithilfe von Micro Focus Enterprise Server und LRS VPSX/MFI](modernize-mainframe-online-printing-workloads-on-aws-by-using-micro-focus-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernisieren Sie das Mainframe-Output-Management mithilfe AWS von Rocket Enterprise Server und LRS X PageCenter](modernize-mainframe-output-management-on-aws-by-using-rocket-enterprise-server-and-lrs-pagecenterx.md)
+ [Verschieben Sie Mainframe-Dateien mit Transfer Family direkt nach Amazon S3](move-mainframe-files-directly-to-amazon-s3-using-transfer-family.md)
+ [Optimieren Sie serverlose Bereitstellungen mit mehreren Konten mithilfe der AWS CDK Workflows und Aktionen GitHub](optimize-multi-account-serverless-deployments.md)
+ [Optimieren Sie die Leistung Ihrer modernisierten AWS Blu Age-Anwendung](optimize-performance-aws-blu-age-modernized-application.md)
+ [Automatisieren Sie blue/green die Bereitstellung globaler Amazon Aurora Aurora-Datenbanken mithilfe von IaC-Prinzipien](p-automate-blue-green-deployments-aurora-global-databases-iac.md)
+ [Replizieren Sie Mainframe-Datenbanken mithilfe von Precisely Connect nach AWS](replicate-mainframe-databases-to-aws-by-using-precisely-connect.md)
+ [Führen Sie Amazon ECS-Aufgaben auf Amazon WorkSpaces mit Amazon ECS Anywhere aus](run-amazon-ecs-tasks-on-amazon-workspaces-with-amazon-ecs-anywhere.md)
+ [Senden Sie Telemetriedaten von AWS Lambda zu OpenSearch für Analysen und Visualisierungen in Echtzeit](send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.md)
+ [Richten Sie die CloudFormation Drifterkennung in einer Organisation mit mehreren Regionen und mehreren Konten ein](set-up-aws-cloudformation-drift-detection-in-a-multi-region-multi-account-organization.md)
+ [Strukturieren Sie ein Python-Projekt in hexagonaler Architektur mit AWS Lambda](structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.md)
+ [Testen Sie die AWS Infrastruktur mithilfe LocalStack von Terraform-Tests](test-aws-infra-localstack-terraform.md)
+ [Verwandeln Sie Easytrieve mithilfe von Custom in moderne Sprachen AWS Transform](transform-easytrieve-modern-languages.md)
+ [Aktualisieren Sie SAP Pacemaker-Cluster von ENSA1 auf ENSA2](upgrade-sap-pacemaker-clusters-from-ensa1-to-ensa2.md)
+ [Verwenden Sie Amazon Q Developer als Programmierassistenten, um Ihre Produktivität zu steigern](use-q-developer-as-coding-assistant-to-increase-productivity.md)
+ [Validieren Sie den Code von Account Factory for Terraform (AFT) lokal](validate-account-factory-for-terraform-aft-code-locally.md)