`, che è l'Amazon Resource Name (ARN) per il bucket creato in precedenzaArgomento 2= Il nome del tuo Firehose (questo pilota lo sta `firehose_to_s3_stream` usando).Argomento 3= Il nome del ruolo IAM (questo programma pilota lo utilizza). `firehose_to_s3`python CreateFireHoseToS3.py firehose_to_s3_stream firehose_to_s3
Se il ruolo IAM specificato non esiste, lo script creerà un ruolo di assunzione con una politica di relazione affidabile, nonché una politica che concede autorizzazioni Amazon S3 sufficienti. Per esempi di queste politiche, consulta la sezione *Informazioni aggiuntive*. | Architetto del cloud, sviluppatore di app |
| Verifica lo stream di distribuzione di Firehose. | Descrivi il flusso di distribuzione di Firehose utilizzando la CLI di AWS per verificare che il flusso di distribuzione sia stato creato correttamente.aws firehose describe-delivery-stream --delivery-stream-name firehose_to_s3_stream
| Architetto del cloud, sviluppatore di app |
### Creare una funzione Lambda per elaborare il flusso di distribuzione di Firehose
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea una politica di fiducia per la funzione Lambda. | Crea un file di criteri di fiducia con le seguenti informazioni. {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} Ciò consente alla funzione di accedere alle risorse AWS. | Architetto del cloud, sviluppatore di app |
| Crea un ruolo di esecuzione per la funzione Lambda. | Per creare il ruolo di esecuzione, esegui il codice seguente.aws iam create-role --role-name lambda-ex --assume-role-policy-document file://TrustPolicy.json
| Architetto del cloud, sviluppatore di app |
| Aggiungi l'autorizzazione al ruolo. | Per aggiungere l'autorizzazione al ruolo, usa il `attach-policy-to-role` comando.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
| Architetto del cloud, sviluppatore di app |
| Creazione di una funzione Lambda. | Comprimi il `LambdaStreamProcessor.py` file dal repository di codice eseguendo il seguente comando.zip function.zip LambdaStreamProcessor.py
Quando crei la funzione Lambda, avrai bisogno del ruolo di esecuzione Lambda ARN. Per ottenere l'ARN, esegui il codice seguente.aws iam get-role \
--role-name lambda-ex
Per creare la funzione Lambda, esegui il codice seguente.# 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}"
| Architetto del cloud, sviluppatore di app |
| Configura il trigger della funzione Lambda. | Utilizza l'AWS CLI per configurare il trigger (DynamoDB Streams), che richiama la funzione Lambda. La dimensione del batch di 400 serve per evitare di incorrere in problemi di concorrenza Lambda.aws lambda create-event-source-mapping --function-name LambdaStreamProcessor \
--batch-size 400 --starting-position LATEST \
--event-source-arn
| Architetto del cloud, sviluppatore di app |
### Prova la funzionalità
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiungi articoli con timestamp scaduti alla tabella delle prenotazioni. | Per testare la funzionalità, aggiungi alla tabella elementi con timestamp d'epoca scaduti. `Reservation` TTL eliminerà automaticamente gli elementi in base al timestamp. La funzione Lambda viene avviata sulle attività di DynamoDB Stream e filtra l'evento per identificare l'attività o gli elementi eliminati. `REMOVE` Quindi inserisce i record nel flusso di distribuzione di Firehose in formato batch.Il flusso di distribuzione Firehose trasferisce gli articoli a un bucket S3 di destinazione con il prefisso. `firehosetos3example/year=current year/month=current month/ day=current day/hour=current hour/`Per ottimizzare il recupero dei dati, configura Amazon S3 con `Prefix` `ErrorOutputPrefix` le informazioni dettagliate *nella* sezione Informazioni aggiuntive. | Architetto del cloud |
### Pulisci le risorse
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Eliminare tutte le risorse. | Elimina tutte le risorse per assicurarti che non ti vengano addebitati costi per i servizi che non utilizzi. | Architetto del cloud, sviluppatore di app |
## Risorse correlate
+ [Gestione del ciclo di vita dello storage](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html)
+ [Classi di storage Amazon S3](https://aws.amazon.com/s3/storage-classes/)
+ [Documentazione dell'SDK AWS per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
## Informazioni aggiuntive
**Creare e configurare un flusso di distribuzione Firehose — Esempi di policy**
*Documento di esempio sulla politica delle relazioni di fiducia di Firehose*
```
firehose_assume_role = {
'Version': '2012-10-17',
'Statement': [
{
'Sid': '',
'Effect': 'Allow',
'Principal': {
'Service': 'firehose.amazonaws.com'
},
'Action': 'sts:AssumeRole'
}
]
}
```
*Esempio di politica di autorizzazione S3*
```
s3_access = {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListBucketMultipartUploads",
"s3:PutObject"
],
"Resource": [
"{your s3_bucket ARN}/*",
"{Your s3 bucket ARN}"
]
}
]
}
```
**Verifica la funzionalità: configurazione Amazon S3**
La configurazione Amazon S3 con la seguente `Prefix` e `ErrorOutputPrefix` viene scelta per ottimizzare il recupero dei dati.
*prefisso*
```
firehosetos3example/year=! {timestamp: yyyy}/month=! {timestamp:MM}/day=! {timestamp:dd}/hour=!{timestamp:HH}/
```
Firehose crea innanzitutto una cartella di base chiamata `firehosetos3example` direttamente sotto il bucket S3. Quindi valuta le espressioni e l'anno `!{timestamp:yyyy}``!{timestamp:MM}`, il mese`!{timestamp:dd}`, `!{timestamp:HH}` il giorno e l'ora utilizzando il formato Java. [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)
Ad esempio, un timestamp di arrivo approssimativo di 1604683577 in Unix epoch Time restituisce,, e. `year=2020` `month=11` `day=06` `hour=05` Pertanto, viene valutata la posizione in Amazon S3, in cui vengono distribuiti i record di dati. `firehosetos3example/year=2020/month=11/day=06/hour=05/`
*ErrorOutputPrefix*
```
firehosetos3erroroutputbase/!{firehose:random-string}/!{firehose:error-output-type}/!{timestamp:yyyy/MM/dd}/
```
I `ErrorOutputPrefix` risultati sono in una cartella di base richiamata `firehosetos3erroroutputbase` direttamente sotto il bucket S3. L'espressione `!{firehose:random-string}` restituisce una stringa casuale di 11 caratteri come. `ztWxkdg3Thg` Potrebbe essere valutata la posizione di un oggetto Amazon S3 in cui vengono consegnati i record non riusciti. `firehosetos3erroroutputbase/ztWxkdg3Thg/processing-failed/2020/11/06/`
# Crea un'architettura serverless multi-tenant in Amazon Service OpenSearch
*Tabby Ward e Nisha Gambhir, Amazon Web Services*
## Riepilogo
Amazon OpenSearch Service è un servizio gestito che semplifica l'implementazione, il funzionamento e la scalabilità di Elasticsearch, un popolare motore di ricerca e analisi open source. OpenSearch Il servizio offre la ricerca a testo libero, nonché l'inserimento e la creazione di dashboard quasi in tempo reale per lo streaming di dati come log e metriche.
I fornitori di software as a service (SaaS) utilizzano spesso OpenSearch Service per affrontare un'ampia gamma di casi d'uso, ad esempio per ottenere informazioni sui clienti in modo scalabile e sicuro, riducendo al contempo la complessità e i tempi di inattività.
L'utilizzo OpenSearch del servizio in un ambiente multi-tenant introduce una serie di considerazioni che influiscono sul partizionamento, l'isolamento, l'implementazione e la gestione della soluzione SaaS. I provider SaaS devono considerare come scalare efficacemente i propri cluster Elasticsearch con carichi di lavoro in continuo cambiamento. Devono inoltre considerare in che modo la suddivisione in più livelli e le condizioni rumorose dei vicini potrebbero influire sul loro modello di partizionamento.
Questo modello esamina i modelli utilizzati per rappresentare e isolare i dati dei tenant con costrutti Elasticsearch. Inoltre, il modello si concentra su una semplice architettura di riferimento serverless come esempio per dimostrare l'indicizzazione e la ricerca utilizzando Service in un ambiente multi-tenant. OpenSearch Implementa il modello di partizionamento dei dati del pool, che condivide lo stesso indice tra tutti i tenant mantenendo l'isolamento dei dati del tenant. Questo modello utilizza i seguenti AWS servizi: Amazon API Gateway AWS Lambda, Amazon Simple Storage Service (Amazon S3) e Service. OpenSearch
Per ulteriori informazioni sul modello di pool e su altri modelli di partizionamento dei dati, consulta la sezione Informazioni [aggiuntive](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional).
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS
+ [AWS Command Line Interface (AWS CLI) versione 2.x](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html), installata e configurata su macOS, Linux o Windows
+ [Python versione 3.9](https://www.python.org/downloads/release/python-3921/)
+ [pip3](https://pip.pypa.io/en/stable/) — Il codice sorgente di Python viene fornito come file.zip da distribuire in una funzione Lambda. Se desideri utilizzare il codice localmente o personalizzarlo, segui questi passaggi per sviluppare e ricompilare il codice sorgente:
1. Genera il `requirements.txt` file eseguendo il seguente comando nella stessa directory degli script Python: `pip3 freeze > requirements.txt`
1. Installa le dipendenze: `pip3 install -r requirements.txt`
**Limitazioni**
+ Questo codice viene eseguito in Python e attualmente non supporta altri linguaggi di programmazione.
+ L'applicazione di esempio non include il supporto AWS interregionale o di disaster recovery (DR).
+ Questo modello è destinato esclusivamente a scopo dimostrativo. Non è destinato all'uso in un ambiente di produzione.
## Architecture
Il diagramma seguente illustra l'architettura di alto livello di questo pattern. L'architettura include quanto segue:
+ Lambda per indicizzare e interrogare il contenuto
+ OpenSearch Servizio per eseguire ricerche
+ API Gateway per fornire un'interazione API con l'utente
+ Amazon S3 per archiviare dati grezzi (non indicizzati)
+ Amazon CloudWatch per monitorare i log
+ AWS Identity and Access Management (IAM) per creare ruoli e politiche degli inquilini
![\[Architettura serverless multi-tenant di alto livello.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/1a8501e7-0776-4aca-aed3-28e3ada1d15d.png)
**Automazione e scalabilità**
Per semplicità, il pattern utilizza AWS CLI il provisioning dell'infrastruttura e la distribuzione del codice di esempio. È possibile creare uno CloudFormation o più AWS Cloud Development Kit (AWS CDK) script per automatizzare il pattern.
## Tools (Strumenti)
**Servizi AWS**
+ [AWS CLI](https://aws.amazon.com/cli/)è uno strumento unificato per la gestione Servizi AWS e le risorse utilizzando i comandi nella shell della riga di comando.
+ [Lambda](https://aws.amazon.com/lambda/) è un servizio di elaborazione che consente di eseguire codice senza effettuare il provisioning o la gestione di server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo.
+ [API Gateway](https://aws.amazon.com/api-gateway/) Servizio AWS consente di creare, pubblicare, mantenere, monitorare e proteggere REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [Amazon S3](https://aws.amazon.com/s3/) è un servizio di storage di oggetti che consente di archiviare e recuperare qualsiasi quantità di informazioni in qualsiasi momento, da qualsiasi punto del Web.
+ [OpenSearch Service](https://aws.amazon.com/opensearch-service/) è un servizio completamente gestito che semplifica l'implementazione, la protezione e l'esecuzione di Elasticsearch su larga scala in modo conveniente.
**Codice**
L'allegato fornisce file di esempio per questo modello. Ciò include:
+ `index_lambda_package.zip`— La funzione Lambda per l'indicizzazione dei dati in OpenSearch Service utilizzando il modello pool.
+ `search_lambda_package.zip`— La funzione Lambda per la ricerca di dati in OpenSearch Service.
+ `Tenant-1-data`— Esempio di dati grezzi (non indicizzati) per Tenant-1.
+ `Tenant-2-data`— Esempio di dati grezzi (non indicizzati) per Tenant-2.
**Importante**
Le storie di questo modello includono esempi di AWS CLI comandi formattati per Unix, Linux e macOS. Per Windows, sostituisci il carattere di continuazione UNIX barra rovesciata (\$1) al termine di ogni riga con un accento circonflesso (^).
**Nota**
Nei AWS CLI comandi, sostituite tutti i valori all'interno delle parentesi angolari (<>) con i valori corretti.
## Epiche
### Crea e configura un bucket S3
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un bucket S3. | Crea un bucket S3 nel tuo. Regione AWS Questo bucket conterrà i dati del tenant non indicizzati per l'applicazione di esempio. Assicurati che il nome del bucket S3 sia univoco a livello globale, perché lo spazio dei nomi è condiviso da tutti. Account AWS[Per creare un bucket S3, puoi usare il comando create-bucket come segue: AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-bucket.html)aws s3api create-bucket \
--bucket \
--region
dov'è il nome del bucket `tenantrawdata` S3. (È possibile utilizzare qualsiasi nome univoco che segua le linee guida per [la denominazione dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html).) | Architetto del cloud, amministratore del cloud |
### Crea e configura un cluster Elasticsearch
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un dominio OpenSearch di servizio. | Esegui il AWS CLI [create-elasticsearch-domain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/es/create-elasticsearch-domain.html)comando per creare un dominio OpenSearch di servizio: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\/*\" } ] }"
Il conteggio delle istanze è impostato su 1 perché il dominio è a scopo di test. È necessario abilitare il controllo granulare degli accessi utilizzando il `advanced-security-options` parametro, poiché i dettagli non possono essere modificati dopo la creazione del dominio. Questo comando crea un nome utente principale (`KibanaUser`) e una password che puoi usare per accedere alla console Kibana.Poiché il dominio fa parte di un cloud privato virtuale (VPC), devi assicurarti di poter raggiungere l'istanza Elasticsearch specificando la politica di accesso da utilizzare.Per ulteriori informazioni, consulta [la sezione Avvio dei domini Amazon OpenSearch Service all'interno di un VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html) nella documentazione. AWS | Architetto del cloud, amministratore del cloud |
| Configura un bastion host. | Configura un'istanza Windows di Amazon Elastic Compute Cloud (Amazon EC2) come host bastion per accedere alla console Kibana. Il gruppo di sicurezza Elasticsearch deve consentire il traffico proveniente dal gruppo di EC2 sicurezza Amazon. Per istruzioni, consulta il post sul blog [Controllare l'accesso alla rete alle EC2 istanze utilizzando un](https://aws.amazon.com/blogs/security/controlling-network-access-to-ec2-instances-using-a-bastion-server/) server Bastion.Quando il bastion host è stato configurato e hai a disposizione il gruppo di sicurezza associato all'istanza, usa il AWS CLI [authorize-security-group-ingress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-ingress.html)comando per aggiungere l'autorizzazione al gruppo di sicurezza Elasticsearch per consentire la porta 443 dal gruppo di sicurezza Amazon EC2 (bastion host).aws ec2 authorize-security-group-ingress \
--group-id \
--protocol tcp \
--port 443 \
--source-group
| Architetto del cloud, amministratore del cloud |
### Creare e configurare la funzione di indice Lambda
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea il ruolo di esecuzione Lambda. | Esegui il comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) per concedere alla funzione di indice Lambda l'accesso a e risorse: Servizi AWS aws iam create-role \
--role-name index-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
dove `lambda_assume_role.json` è un documento JSON che concede `AssumeRole` le autorizzazioni alla funzione Lambda, come segue:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Architetto cloud, amministratore cloud |
| Associa policy gestite al ruolo Lambda. | Esegui il AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando per allegare le politiche gestite al ruolo creato nel passaggio precedente. Queste due politiche forniscono al ruolo le autorizzazioni per creare un'interfaccia di rete elastica e scrivere log su Logs. CloudWatch 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
| Architetto cloud, amministratore cloud |
| Crea una politica per concedere alla funzione di indice Lambda il permesso di leggere gli oggetti S3. | Esegui il comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) per concedere alla funzione di indice Lambda `s3:GetObject` il permesso di leggere gli oggetti nel bucket S3:aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3-policy.json
Il file `s3-policy.json` è un documento JSON mostrato di seguito che concede le `s3:GetObject` autorizzazioni per consentire l'accesso in lettura agli oggetti S3. Se hai usato un nome diverso quando hai creato il bucket S3, fornisci il nome del bucket corretto nella sezione: `Resource `{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
} | Architetto del cloud, amministratore del cloud |
| Allega la politica di autorizzazione di Amazon S3 al ruolo di esecuzione Lambda. | Esegui il AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando per allegare la politica di autorizzazione di Amazon S3 creata nel passaggio precedente al ruolo di esecuzione Lambda:aws iam attach-role-policy \
--role-name index-lambda-role \
--policy-arn
`PolicyARN`dov'è l'Amazon Resource Name (ARN) della politica di autorizzazione di Amazon S3. Puoi ottenere questo valore dall'output del comando precedente. | Architetto del cloud, amministratore del cloud |
| Crea la funzione di indice Lambda. | Esegui il comando AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) per creare la funzione di indice Lambda, che accederà a Service: OpenSearch aws lambda create-function \
--function-name index-lambda-function \
--zip-file fileb://index_lambda_package.zip \
--handler lambda_index.lambda_handler \
--runtime python3.9 \
--role "arn:aws:iam::account-id:role/index-lambda-role" \
--timeout 30 \
--vpc-config "{\"SubnetIds\": [\"", \"\"], \
\"SecurityGroupIds\": [\"\"]}"
| Architetto cloud, amministratore cloud |
| Consenti ad Amazon S3 di chiamare la funzione di indice Lambda. | Esegui il comando AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) per concedere ad Amazon S3 l'autorizzazione a chiamare la funzione di indice Lambda:aws lambda add-permission \
--function-name index-lambda-function \
--statement-id s3-permissions \
--action lambda:InvokeFunction \
--principal s3.amazonaws.com \
--source-arn "arn:aws:s3:::" \
--source-account ""
| Architetto del cloud, amministratore del cloud |
| Aggiungi un trigger Lambda per l'evento Amazon S3. | Esegui il AWS CLI [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)comando per inviare notifiche alla funzione di indice Lambda quando viene rilevato l'evento Amazon `ObjectCreated` S3. La funzione index viene eseguita ogni volta che un oggetto viene caricato nel bucket S3. aws s3api put-bucket-notification-configuration \
--bucket \
--notification-configuration file://s3-trigger.json
Il file `s3-trigger.json` è un documento JSON nella cartella corrente che aggiunge la policy delle risorse alla funzione Lambda quando si verifica l'evento Amazon `ObjectCreated` S3. | Architetto del cloud, amministratore del cloud |
### Creare e configurare la funzione di ricerca Lambda
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea il ruolo di esecuzione Lambda. | Esegui il comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) per concedere alla funzione di ricerca Lambda l'accesso a e risorse: Servizi AWS aws iam create-role \
--role-name search-lambda-role \
--assume-role-policy-document file://lambda_assume_role.json
dove `lambda_assume_role.json` è un documento JSON nella cartella corrente che concede `AssumeRole` le autorizzazioni alla funzione Lambda, come segue:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
} | Architetto cloud, amministratore cloud |
| Associa policy gestite al ruolo Lambda. | Esegui il AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando per allegare le politiche gestite al ruolo creato nel passaggio precedente. Queste due politiche forniscono al ruolo le autorizzazioni per creare un'interfaccia di rete elastica e scrivere log su Logs. CloudWatch 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
| Architetto cloud, amministratore cloud |
| Crea la funzione di ricerca Lambda. | Esegui il comando AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) per creare la funzione di ricerca Lambda, che accederà a Service: OpenSearch aws lambda create-function \
--function-name search-lambda-function \
--zip-file fileb://search_lambda_package.zip \
--handler lambda_search.lambda_handler \
--runtime python3.9 \
--role "arn:aws:iam::account-id:role/search-lambda-role" \
--timeout 30 \
--vpc-config "{\"SubnetIds\": [\"", \"\"], \
\"SecurityGroupIds\": [\"\"]}"
| Architetto cloud, amministratore cloud |
### Crea e configura i ruoli degli inquilini
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea ruoli IAM tenant. | Esegui il comando AWS CLI [create-role](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html) per creare due ruoli tenant che verranno utilizzati per testare la funzionalità di ricerca: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
Il file `assume-role-policy.json` è un documento JSON nella cartella corrente che concede le `AssumeRole` autorizzazioni per il ruolo di esecuzione Lambda:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "",
"AWS": ""
},
"Action": "sts:AssumeRole"
}
]
} | Architetto del cloud, amministratore del cloud |
| Crea una policy IAM per i tenant. | Esegui il comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) per creare una politica del tenant che garantisca l'accesso alle operazioni di Elasticsearch:aws iam create-policy \
--policy-name tenant-policy \
--policy-document file://policy.json
Il file `policy.json` è un documento JSON nella cartella corrente che concede le autorizzazioni su Elasticsearch:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpDelete",
"es:ESHttpGet",
"es:ESHttpHead",
"es:ESHttpPost",
"es:ESHttpPut",
"es:ESHttpPatch"
],
"Resource": [
""
]
}
]
} | Architetto del cloud, amministratore del cloud |
| Allega la policy IAM del tenant ai ruoli del tenant. | Esegui il AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando per allegare la politica IAM del tenant ai due ruoli tenant che hai creato nel passaggio precedente:aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/tenant-policy \
--role-name Tenant-1-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/tenant-policy \
--role-name Tenant-2-role
L'ARN della policy proviene dall'output del passaggio precedente. | Architetto del cloud, amministratore del cloud |
| Crea una policy IAM per concedere a Lambda le autorizzazioni per assumere il ruolo. | Esegui il comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) per creare una politica affinché Lambda assuma il ruolo di tenant:aws iam create-policy \
--policy-name assume-tenant-role-policy \
--policy-document file://lambda_policy.json
Il file `lambda_policy.json` è un documento JSON nella cartella corrente che concede le autorizzazioni per: `AssumeRole`{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": ""
}
]
}Infatti`Resource`, puoi usare un carattere jolly per evitare di creare una nuova politica per ogni tenant. | Architetto del cloud, amministratore del cloud |
| Crea una policy IAM per concedere al ruolo dell'indice Lambda l'autorizzazione ad accedere ad Amazon S3. | Esegui il comando AWS CLI [create-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-policy.html) per concedere al ruolo dell'indice Lambda il permesso di accedere agli oggetti nel bucket S3:aws iam create-policy \
--policy-name s3-permission-policy \
--policy-document file://s3_lambda_policy.json
Il file `s3_lambda_policy.json` è il seguente documento di policy JSON nella cartella corrente:{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::tenantrawdata/*"
}
]
} | Architetto del cloud, amministratore del cloud |
| Associa la policy al ruolo di esecuzione Lambda. | Esegui il AWS CLI [attach-role-policy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/attach-role-policy.html)comando per allegare la policy creata nel passaggio precedente all'indice Lambda e ai ruoli di esecuzione della ricerca che hai creato in precedenza:aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \
--role-name index-lambda-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \
--role-name search-lambda-role
aws iam attach-role-policy \
--policy-arn arn:aws:iam::account-id:policy/s3-permission-policy \
--role-name index-lambda-role
L'ARN della policy proviene dall'output del passaggio precedente. | Architetto del cloud, amministratore del cloud |
### Crea e configura un'API di ricerca
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un'API REST in API Gateway. | Esegui il AWS CLI [create-rest-api](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html)comando per creare una risorsa API REST:aws apigateway create-rest-api \
--name Test-Api \
--endpoint-configuration "{ \"types\": [\"REGIONAL\"] }"
Per il tipo di configurazione dell'endpoint, è possibile specificare `EDGE` anziché `REGIONAL` utilizzare posizioni periferiche anziché una particolare Regione AWS.Annotate il valore del `id` campo dall'output del comando. Questo è l'ID API che utilizzerai nei comandi successivi. | Architetto del cloud, amministratore del cloud |
| Crea una risorsa per l'API di ricerca. | La risorsa API di ricerca avvia la funzione di ricerca Lambda con il nome della risorsa. `search` (Non è necessario creare un'API per la funzione di indice Lambda, perché viene eseguita automaticamente quando gli oggetti vengono caricati nel bucket S3.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Architetto del cloud, amministratore del cloud |
| Crea un metodo GET per l'API di ricerca. | Esegui il comando AWS CLI [put-method](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html) per creare un `GET ` metodo per l'API di ricerca:aws apigateway put-method \
--rest-api-id \
--resource-id \
--http-method GET \
--authorization-type "NONE" \
--no-api-key-required
Per`resource-id`, specifica l'ID dall'output del `create-resource` comando. | Architetto cloud, amministratore cloud |
| Crea un metodo di risposta per l'API di ricerca. | Esegui il AWS CLI [put-method-response](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html)comando per aggiungere un metodo di risposta per l'API di ricerca:aws apigateway put-method-response \
--rest-api-id \
--resource-id \
--http-method GET \
--status-code 200 \
--response-models "{\"application/json\": \"Empty\"}"
Per`resource-id`, specifica l'ID dall'output del `create-resource` comando precedente. | Architetto del cloud, amministratore del cloud |
| Configura un'integrazione proxy Lambda per l'API di ricerca. | Esegui il comando AWS CLI [put-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html) per impostare un'integrazione con la funzione di ricerca Lambda:aws apigateway put-integration \
--rest-api-id \
--resource-id \
--http-method GET \
--type AWS_PROXY \
--integration-http-method GET \
--uri arn:aws:apigateway:region:lambda:path/2015-03-31/functions/arn:aws:lambda:::function:/invocations
Per`resource-id`, specifica l'ID del comando precedente. `create-resource` | Architetto del cloud, amministratore del cloud |
| Concedi l'autorizzazione API Gateway per chiamare la funzione di ricerca Lambda. | Esegui il comando AWS CLI [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) per autorizzare API Gateway a utilizzare la funzione di ricerca: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
Modifica il `source-arn` percorso se hai utilizzato un nome di risorsa API diverso anziché`search`. | Architetto del cloud, amministratore del cloud |
| Implementa l'API di ricerca. | Esegui il comando AWS CLI [create-deployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html) per creare una risorsa di fase denominata: `dev`aws apigateway create-deployment \
--rest-api-id \
--stage-name dev
Se aggiorni l'API, puoi utilizzare lo stesso AWS CLI comando per ridistribuirla nella stessa fase. | Architetto del cloud, amministratore del cloud |
### Crea e configura i ruoli di Kibana
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Accedi alla console Kibana. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Architetto del cloud, amministratore del cloud |
| Crea e configura i ruoli di Kibana. | Per garantire l'isolamento dei dati e assicurarsi che un tenant non possa recuperare i dati di un altro tenant, è necessario utilizzare la sicurezza dei documenti, che consente agli inquilini di accedere solo ai documenti che contengono il loro ID tenant.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html) | Architetto del cloud, amministratore del cloud |
| Associa gli utenti ai ruoli. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Ti consigliamo di automatizzare la creazione dei ruoli tenant e Kibana al momento dell'onboarding del tenant. | Architetto cloud, amministratore cloud |
| Crea l'indice dei dati degli inquilini. | Nel riquadro di navigazione, in **Gestione**, scegli **Dev Tools**, quindi esegui il comando seguente. Questo comando crea l'`tenant-data`indice per definire la mappatura della `TenantId` proprietà.PUT /tenant-data
{
"mappings": {
"properties": {
"TenantId": { "type": "keyword"}
}
}
}
| Architetto del cloud, amministratore del cloud |
### Crea endpoint VPC per Amazon S3 e AWS STS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un endpoint VPC per Amazon S3. | Esegui il AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)comando per creare un endpoint VPC per Amazon S3. L'endpoint abilita la funzione di indice Lambda nel VPC per accedere ad Amazon S3.aws ec2 create-vpc-endpoint \
--vpc-id \
--service-name com.amazonaws.us-east-1.s3 \
--route-table-ids
Per`vpc-id`, specifica il VPC che stai utilizzando per la funzione di indice Lambda. Per`service-name`, usa l'URL corretto per l'endpoint Amazon S3. Per`route-table-ids`, specifica la tabella di routing associata all'endpoint VPC. | Architetto del cloud, amministratore del cloud |
| Crea un endpoint VPC per. AWS STS | Esegui il AWS CLI [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)comando per creare un endpoint VPC per AWS Security Token Service ().AWS STS L'endpoint consente l'accesso all'indice Lambda e alle funzioni di ricerca nel VPC. AWS STS Le funzioni AWS STS vengono utilizzate quando assumono il ruolo IAM.aws ec2 create-vpc-endpoint \
--vpc-id \
--vpc-endpoint-type Interface \
--service-name com.amazonaws.us-east-1.sts \
--subnet-id \
--security-group-id
Per`vpc-id`, specifica il VPC che stai utilizzando per l'indice Lambda e le funzioni di ricerca. Infatti`subnet-id`, fornisci la sottorete in cui deve essere creato questo endpoint. Per`security-group-id`, specifica il gruppo di sicurezza a cui associare questo endpoint. (Potrebbe essere lo stesso del gruppo di sicurezza utilizzato da Lambda). | Architetto del cloud, amministratore del cloud |
### Testa la multi-tenancy e l'isolamento dei dati
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiorna i file Python per le funzioni di indice e ricerca. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Puoi ottenere l'endpoint Elasticsearch dalla scheda **Panoramica** della console di servizio. OpenSearch Ha il formato. `.es.amazonaws.com` | Architetto del cloud, sviluppatore di app |
| Aggiorna il codice Lambda. | Usa il AWS CLI [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per aggiornare il codice Lambda con le modifiche apportate ai file Python:aws lambda update-function-code \
--function-name index-lambda-function \
--zip-file fileb://index_lambda_package.zip
aws lambda update-function-code \
--function-name search-lambda-function \
--zip-file fileb://search_lambda_package.zip
| Architetto cloud, sviluppatore di app |
| Carica i dati grezzi nel bucket S3. | Usa il comando AWS CLI [cp](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/cp.html) per caricare i dati per gli oggetti Tenant-1 e Tenant-2 nel `tenantrawdata` bucket (specifica il nome del bucket S3 che hai creato a questo scopo):aws s3 cp tenant-1-data s3://tenantrawdata
aws s3 cp tenant-2-data s3://tenantrawdata
Il bucket S3 è configurato per eseguire la funzione di indice Lambda ogni volta che i dati vengono caricati in modo che il documento venga indicizzato in Elasticsearch. | Architetto del cloud, amministratore del cloud |
| Cerca dati dalla console Kibana. | Sulla console Kibana, esegui la seguente query:GET tenant-data/_search
Questa query mostra tutti i documenti indicizzati in Elasticsearch. In questo caso, dovresti vedere due documenti separati per Tenant-1 e Tenant-2. | Architetto del cloud, amministratore del cloud |
| Prova l'API di ricerca da API Gateway. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.html)Per le illustrazioni delle schermate, vedere la sezione Informazioni [aggiuntive](#build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional). | Architetto del cloud, sviluppatore di app |
| Eliminare le risorse. | Pulisci tutte le risorse che hai creato per evitare addebiti aggiuntivi sul tuo account. | AWS DevOps, architetto cloud, amministratore cloud |
## Risorse correlate
+ [AWS SDK per Python (Boto)](https://aws.amazon.com/sdk-for-python/)
+ [AWS Lambda documentazione](https://docs.aws.amazon.com/lambda/)
+ [Documentazione API Gateway](https://docs.aws.amazon.com/apigateway/)
+ [Documentazione Amazon S3](https://docs.aws.amazon.com/s3/)
+ [Documentazione OpenSearch del servizio Amazon](https://docs.aws.amazon.com/elasticsearch-service/)
+ [Controllo granulare degli accessi in Amazon Service OpenSearch ](https://docs.amazonaws.cn/en_us/elasticsearch-service/latest/developerguide/fgac.html)
+ [Creazione di un'applicazione di ricerca con Amazon OpenSearch Service](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/search-example.html)
+ [Avvio dei domini Amazon OpenSearch Service all'interno di un VPC](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html)
## Informazioni aggiuntive
**Modelli di partizionamento dei dati**
Esistono tre modelli di partizionamento dei dati comuni utilizzati nei sistemi multi-tenant: silo, pool e hybrid. Il modello scelto dipende dalla conformità, dalla rumorosità dei sistemi vicini, dalle operazioni e dalle esigenze di isolamento dell'ambiente.
*Modello Silo*
Nel modello a silo, i dati di ciascun inquilino vengono archiviati in un'area di archiviazione distinta in cui non vi è alcuna combinazione dei dati del tenant. È possibile utilizzare due approcci per implementare il modello a silo con OpenSearch Service: dominio per tenant e indice per tenant.
+ **Dominio per tenant**: puoi utilizzare un dominio di OpenSearch servizio separato (sinonimo di cluster Elasticsearch) per tenant. L'inserimento di ogni tenant nel proprio dominio offre tutti i vantaggi associati alla presenza di dati in un costrutto autonomo. Tuttavia, questo approccio introduce sfide di gestione e agilità. La sua natura distribuita rende più difficile l'aggregazione e la valutazione dello stato operativo e dell'attività degli inquilini. Si tratta di un'opzione costosa che richiede che ogni dominio di OpenSearch servizio disponga almeno di tre nodi master e due nodi di dati per i carichi di lavoro di produzione.
![\[Modello di silo di dominio per tenant per architetture serverless multi-tenant.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2195f82-e5ed-40bb-b76a-3b0210bf1254.png)
+ **Indice per tenant: è possibile inserire i dati dei tenant** in indici separati all'interno di un cluster di servizi. OpenSearch Con questo approccio, si utilizza un identificatore del tenant quando si crea e si assegna un nome all'indice, anteponendo l'identificatore del tenant al nome dell'indice. L'approccio dell'indice per tenant consente di raggiungere gli obiettivi dei silo senza introdurre un cluster completamente separato per ogni tenant. Tuttavia, se il numero di indici aumenta, si potrebbe verificare una pressione sulla memoria, poiché questo approccio richiede più shard e il nodo master deve gestire una maggiore allocazione e ribilanciamento.
![\[Modello di silo indicizzato per tenant per architetture serverless multi-tenant.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/354a9463-25bb-422b-84de-d4875a7c8ea2.png)
**Isolamento nel modello a silo: nel modello** a silo, si utilizzano le policy IAM per isolare i domini o gli indici che contengono i dati di ciascun tenant. Queste politiche impediscono a un tenant di accedere ai dati di un altro tenant. Per implementare il modello di isolamento dei silo, è possibile creare una politica basata sulle risorse che controlli l'accesso alla risorsa del tenant. Si tratta spesso di una politica di accesso al dominio che specifica quali azioni un principale può eseguire sulle risorse secondarie del dominio, inclusi gli indici Elasticsearch e. APIs Con le policy basate sull'identità IAM, puoi specificare azioni *consentite* o *negate* sul dominio, sugli indici o all'interno del Servizio. APIs OpenSearch L'`Action`elemento di una policy IAM descrive l'azione o le azioni specifiche consentite o negate dalla policy e specifica gli account, gli `Principal ` utenti o i ruoli interessati.
La seguente policy di esempio concede al Tenant-1 l'accesso completo (come specificato da`es:*`) solo alle risorse secondarie del dominio. `tenant-1` La fine `/*` dell'`Resource`elemento indica che questa politica si applica alle risorse secondarie del dominio, non al dominio stesso. Quando questa politica è in vigore, i tenant non sono autorizzati a creare un nuovo dominio o modificare le impostazioni su un dominio esistente.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::user/Tenant-1"
},
"Action": "es:*",
"Resource": "arn:aws:es:::domain/tenant-1/*"
}
]
}
```
Per implementare il modello di silo tenant per index, è necessario modificare questa politica di esempio per limitare ulteriormente Tenant-1 all'indice o agli indici specificati, specificando il nome dell'indice. La seguente politica di esempio limita Tenant-1 all'indice. `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/*"
}
]
}
```
*Modello di piscina*
Nel modello di pool, tutti i dati dei tenant vengono archiviati in un indice all'interno dello stesso dominio. L'identificatore del tenant è incluso nei dati (documento) e utilizzato come chiave di partizione, in modo da poter determinare quali dati appartengono a quale tenant. Questo modello riduce il sovraccarico di gestione. Il funzionamento e la gestione dell'indice raggruppato sono più semplici ed efficienti rispetto alla gestione di più indici. Tuttavia, poiché i dati dei tenant vengono combinati all'interno dello stesso indice, si perde il naturale isolamento dei tenant fornito dal modello a silo. Questo approccio potrebbe inoltre ridurre le prestazioni a causa dell'effetto Noisy Neighbor.
![\[Modello di pool per architetture serverless multi-tenant.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/c2c3bb0f-6ccd-47a7-ab67-e7f3f8c7f289.png)
**Isolamento dei tenant nel modello pool**: in generale, l'isolamento dei tenant è difficile da implementare nel modello pool. Il meccanismo IAM utilizzato con il modello a silo non consente di descrivere l'isolamento in base all'ID del tenant memorizzato nel documento.
Un approccio alternativo consiste nell'utilizzare il supporto per il [controllo degli accessi a grana fine](https://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/fgac.html) (FGAC) fornito da Open Distro for Elasticsearch. FGAC consente di controllare le autorizzazioni a livello di indice, documento o campo. Con ogni richiesta, FGAC valuta le credenziali dell'utente e autentica l'utente o nega l'accesso. Se FGAC autentica l'utente, recupera tutti i ruoli mappati a quell'utente e utilizza il set completo di autorizzazioni per determinare come gestire la richiesta.
Per ottenere l'isolamento richiesto nel modello in pool, è possibile utilizzare la [sicurezza a livello di documento, che consente di limitare un ruolo a un sottoinsieme](https://opendistro.github.io/for-elasticsearch-docs/docs/security/access-control/document-level-security/) di documenti in un indice. Il seguente ruolo di esempio limita le query a Tenant-1. Applicando questo ruolo a Tenant-1, è possibile ottenere l'isolamento necessario.
```
{
"bool": {
"must": {
"match": {
"tenantId": "Tenant-1"
}
}
}
}
```
*Modello ibrido*
Il modello ibrido utilizza una combinazione dei modelli a silo e pool nello stesso ambiente per offrire esperienze uniche a ciascun livello di tenant (ad esempio i livelli gratuito, standard e premium). Ogni livello segue lo stesso profilo di sicurezza utilizzato nel modello pool.
![\[Modello ibrido per architetture serverless multi-tenant.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/e7def98a-38ef-435a-9881-7e95ae4d4940.png)
**Isolamento dei tenant nel modello ibrido**: nel modello ibrido, si segue lo stesso profilo di sicurezza del modello pool, dove l'utilizzo del modello di sicurezza FGAC a livello di documento forniva l'isolamento dei tenant. Sebbene questa strategia semplifichi la gestione dei cluster e offra agilità, complica altri aspetti dell'architettura. Ad esempio, il codice richiede una complessità aggiuntiva per determinare quale modello è associato a ciascun tenant. È inoltre necessario assicurarsi che le query relative a un solo tenant non saturino l'intero dominio e compromettano l'esperienza degli altri tenant.
**Test in API Gateway**
*Finestra di test per la query Tenant-1*
![\[Finestra di test per la query Tenant-1.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/a6757d3f-977a-4ecc-90cb-83ab7f1c3588.png)
*Finestra di test per la query Tenant-2*
![\[Finestra di test per la query Tenant-2.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/750196bb-03f6-4b6e-92cd-eb7141602547/images/31bfd656-33ca-4750-b6e6-da4d703c2071.png)
## Allegati
[Per accedere al contenuto aggiuntivo associato a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/750196bb-03f6-4b6e-92cd-eb7141602547/attachments/attachment.zip)
# Distribuisci applicazioni multi-stack utilizzando AWS CDK con TypeScript
*Dott. Rahul Sharad Gaikwad, Amazon Web Services*
## Riepilogo
Questo modello fornisce un step-by-step approccio per la distribuzione di applicazioni su Amazon Web Services (AWS) utilizzando AWS Cloud Development Kit (AWS CDK) con TypeScript. Ad esempio, il pattern implementa un'applicazione di analisi in tempo reale senza server.
Il pattern crea e distribuisce applicazioni stack annidate. Lo stack AWS principale chiama gli CloudFormation stack secondari, o annidati. Ogni stack secondario crea e distribuisce le risorse AWS definite nello stack. CloudFormation AWS CDK Toolkit, il comando dell'interfaccia a riga di comando (CLI)`cdk`, è l'interfaccia principale per gli stack. CloudFormation
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ Cloud privato virtuale (VPC) e sottoreti esistenti
+ AWS CDK Toolkit installato e configurato
+ Un utente con autorizzazioni di amministratore e un set di chiavi di accesso.
+ Node.js
+ Interfaccia a riga di comando di AWS (CLI AWS)
**Limitazioni**
+ Poiché AWS CDK utilizza AWS CloudFormation, le applicazioni AWS CDK sono soggette a quote di CloudFormation servizio. Per ulteriori informazioni, consulta [AWS CloudFormation quotas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
**Versioni del prodotto**
Questo modello è stato creato e testato utilizzando i seguenti strumenti e versioni.
+ Kit di strumenti CDK AWS 1.83.0
+ Node.js 14.13.0
+ npm 7.0.14
Il modello dovrebbe funzionare con qualsiasi versione di AWS CDK o npm. Tieni presente che le versioni di Node.js dalla 13.0.0 alla 13.6.0 non sono compatibili con AWS CDK.
## Architecture
**Stack tecnologico Target**
+ Console AWS Amplify
+ Gateway Amazon API
+ AWS CDK
+ Amazon CloudFront
+ Amazon Cognito
+ Amazon DynamoDB
+ Amazon Data Firehose
+ Flusso di dati Amazon Kinesis
+ AWS Lambda
+ Amazon Simple Storage Service (Amazon S3)
**Architettura Target**
Il diagramma seguente mostra la distribuzione di applicazioni a stack multiplo utilizzando AWS CDK con. TypeScript
![\[Architettura dello stack nel VPC, con uno stack principale e due stack secondari che contengono risorse.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/8f92e86a-aa3d-4f8a-9b11-b92c52a7226c.png)
Il diagramma seguente mostra l'architettura dell'applicazione serverless in tempo reale di esempio.
![\[Architettura dell'applicazione nella regione.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/2df00faf-f871-4aec-9655-19ba2eb14cf8.png)
## Tools (Strumenti)
**Strumenti**
+ La console [AWS Amplify](https://docs.aws.amazon.com/amplify/latest/userguide/welcome.html) è il centro di controllo per le distribuzioni complete di applicazioni web e mobili in AWS. L'hosting di Amplify Console offre un flusso di lavoro basato su git per l'hosting di app web serverless fullstack con distribuzione continua. L'interfaccia utente di amministrazione è un'interfaccia visiva per gli sviluppatori web e mobili di frontend per creare e gestire i backend di app al di fuori della console AWS.
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) è un servizio AWS per la creazione, la pubblicazione, la manutenzione, il monitoraggio e la protezione di REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) è un framework di sviluppo software che aiuta a definire e fornire l'infrastruttura cloud AWS in codice.
+ [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/latest/guide/cli.html) è un kit di sviluppo cloud a riga di comando che ti aiuta a interagire con la tua app AWS CDK. Il comando `cdk` CLI è lo strumento principale per interagire con l'app AWS CDK. Esegue la tua app, interroga il modello di applicazione che hai definito e produce e distribuisce i CloudFormation modelli AWS generati dal CDK AWS.
+ [Amazon CloudFront](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) è un servizio Web che accelera la distribuzione di contenuti Web statici e dinamici, come .html, .css, .js e file di immagine. CloudFront distribuisce i tuoi contenuti attraverso una rete mondiale di data center denominati edge location per ridurre la latenza e migliorare le prestazioni.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) fornisce autenticazione, autorizzazione e gestione degli utenti per le tue app Web e mobili. I tuoi utenti possono accedere direttamente o tramite terze parti.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL completamente gestito che offre prestazioni veloci e prevedibili con una scalabilità perfetta.
+ [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) è un servizio completamente gestito per la distribuzione di [dati di streaming](https://aws.amazon.com/streaming-data/) in tempo reale a destinazioni come Amazon S3, Amazon Redshift, OpenSearch Amazon Service, Splunk e qualsiasi endpoint HTTP o endpoint HTTP personalizzato di proprietà di provider di servizi terzi supportati.
+ [Amazon Kinesis Data](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) Streams è un servizio per la raccolta e l'elaborazione di grandi flussi di record di dati in tempo reale.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di elaborazione che supporta l'esecuzione di codice senza effettuare il provisioning o la gestione di server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo. Verrà addebitato soltanto il tempo di calcolo consumato e non verrà addebitato alcun costo quando il codice non è in esecuzione.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
**Codice**
Il codice per questo modello è allegato.
## Epiche
### Installa AWS CDK Toolkit
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Installa AWS CDK Toolkit. | Per installare AWS CDK Toolkit a livello globale, esegui il seguente comando.`npm install -g aws-cdk` | DevOps |
| Verifica la versione. | Per verificare la versione di AWS CDK Toolkit, esegui il comando seguente. `cdk --version` | DevOps |
### Configura le credenziali AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura le credenziali. | Per configurare le credenziali, esegui il `aws configure` comando e segui le istruzioni.$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 |
### Scarica il codice del progetto
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Scarica il codice del progetto allegato. | Per ulteriori informazioni sulla directory e sulla struttura dei file, consulta la sezione *Informazioni aggiuntive*. | DevOps |
### Esegui il bootstrap dell'ambiente AWS CDK
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Avvia l'ambiente. | Per distribuire il CloudFormation modello AWS nell'account e nella regione AWS che desideri utilizzare, esegui il comando seguente.`cdk bootstrap /`Per ulteriori informazioni, consulta la [documentazione di AWS](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html). | DevOps |
### Crea e distribuisci il progetto
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Compilare il progetto. | Per creare il codice del progetto, esegui il `npm run build` comando. | DevOps |
| Distribuisci il progetto | Per distribuire il codice del progetto, esegui il `cdk deploy` comando. | |
### Verifica gli output
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Verifica la creazione dello stack. | Nella Console di gestione AWS, scegli **CloudFormation**. Negli stack del progetto, verifica che siano stati creati uno stack principale e due stack secondari. | DevOps |
### Eseguire il test dell’applicazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Invia dati a Kinesis Data Streams. | Configura il tuo account AWS per inviare dati a Kinesis Data Streams utilizzando Amazon Kinesis Data Generator (KDG). Per ulteriori informazioni, consulta [Amazon Kinesis Data](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) Generator. | DevOps |
| Crea un utente Amazon Cognito. | [Per creare un utente Amazon Cognito, scarica il modello cognito-setup.json CloudFormation dalla sezione Crea *un utente Amazon Cognito della pagina di aiuto di Kinesis Data Generator*.](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) **Avvia il modello, quindi inserisci il nome utente e la password di Amazon **Cognito**.**La scheda **Output** elenca l'URL di Kinesis Data Generator. | DevOps |
| Accedi a Kinesis Data Generator | Per accedere a KDG, utilizza le credenziali di Amazon Cognito che hai fornito e l'URL di Kinesis Data Generator. | DevOps |
| Testare l'applicazione. | **In KDG, in **Record template, Template** **1**, incolla il codice di test dalla sezione *Informazioni aggiuntive* e scegli Invia dati.** | DevOps |
| Gateway API di prova. | Dopo che i dati sono stati inseriti, prova API Gateway utilizzando il `GET` metodo per recuperare i dati. | DevOps |
## Risorse correlate
**Riferimenti**
+ [Kit di sviluppo AWS per il cloud](https://aws.amazon.com/cdk/)
+ [CDK AWS su GitHub](https://github.com/aws/aws-cdk)
+ [Lavorare con stack annidati](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
+ [Esempio di AWS: analisi in tempo reale senza server](https://github.com/aws-samples/serverless-realtime-analytics)
## Informazioni aggiuntive
**Dettagli di directory e file**
Questo modello imposta le seguenti tre pile.
+ `parent-cdk-stack.ts`— Questo stack funge da stack principale e chiama le due applicazioni secondarie come stack annidati.
+ `real-time-analytics-poc-stack.ts`— Questo stack annidato contiene l'infrastruttura e il codice dell'applicazione.
+ `real-time-analytics-web-stack.ts`— Questo stack annidato contiene solo il codice statico dell'applicazione Web.
*File importanti e relative funzionalità*
+ `bin/real-time-analytics-poc.ts`— Punto di ingresso dell'applicazione AWS CDK. Carica tutti gli stack definiti in. `lib/`
+ `lib/real-time-analytics-poc-stack.ts`— Definizione dello stack dell'applicazione AWS CDK ()`real-time-analytics-poc`.
+ `lib/real-time-analytics-web-stack.ts`— Definizione dello stack dell'applicazione AWS CDK ()`real-time-analytics-web-stack`.
+ `lib/parent-cdk-stack.ts`— Definizione dello stack dell'applicazione AWS CDK ()`parent-cdk`.
+ `package.json`— manifesto del modulo npm, che include il nome, la versione e le dipendenze dell'applicazione.
+ `package-lock.json`— Gestito da npm.
+ `cdk.json`— Toolkit per l'esecuzione dell'applicazione.
+ `tsconfig.json`— La TypeScript configurazione del progetto.
+ `.gitignore`— Elenco di file che Git dovrebbe escludere dal controllo del codice sorgente.
+ `node_modules`— Gestito da npm; include le dipendenze del progetto.
La seguente sezione di codice nello stack principale chiama le applicazioni secondarie come stack CDK AWS annidati.
```
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');
}
}
```
**Codice per i test**
```
session={{date.now('YYYYMMDD')}}|sequence={{date.now('x')}}|reception={{date.now('x')}}|instrument={{random.number(9)}}|l={{random.number(20)}}|price_0={{random.number({"min":10000, "max":30000})}}|price_1={{random.number({"min":10000, "max":30000})}}|price_2={{random.number({"min":10000, "max":30000})}}|price_3={{random.number({"min":10000, "max":30000})}}|price_4={{random.number({"min":10000, "max":30000})}}|price_5={{random.number({"min":10000, "max":30000})}}|price_6={{random.number({"min":10000, "max":30000})}}|price_7={{random.number({"min":10000, "max":30000})}}|price_8={{random.number({"min":10000, "max":30000})}}|
```
**Test dell'API Gateway**
Sulla console API Gateway, prova API Gateway utilizzando il `GET` metodo.
![\[Console API Gateway con GET selezionato in OPZIONI.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/0ac29a11-1362-4084-92ed-6b85205763ca/images/452e5b8f-6d61-401d-8484-e5a436cb6f1b.png)
## Allegati
[Per accedere al contenuto aggiuntivo associato a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/0ac29a11-1362-4084-92ed-6b85205763ca/attachments/attachment.zip)
# Automatizza la distribuzione di applicazioni annidate utilizzando AWS SAM
*Dott. Rahul Sharad Gaikwad, Ishwar Chauthaiwale, Dmitry Gulin e Tabby Ward, Amazon Web Services*
## Riepilogo
Su Amazon Web Services (AWS), AWS Serverless Application Model (AWS SAM) Serverless Application Model (AWS) Serverless Application Model (AWS) Serverless Application Model (AWS SAM) è un framework open source che fornisce una sintassi abbreviata per esprimere funzioni APIs, database e mappature delle sorgenti degli eventi. Con solo poche righe per ogni risorsa, puoi definire l'applicazione che desideri e modellarla utilizzando YAML. Durante la distribuzione, SAM trasforma ed espande la sintassi SAM in sintassi AWS CloudFormation che puoi usare per creare applicazioni serverless più velocemente.
AWS SAM semplifica lo sviluppo, la distribuzione e la gestione di applicazioni serverless sulla piattaforma AWS. Fornisce un framework standardizzato, una distribuzione più rapida, funzionalità di test locali, gestione delle risorse, perfetta integrazione con gli strumenti di sviluppo e una community di supporto. Queste caratteristiche lo rendono uno strumento prezioso per creare applicazioni serverless in modo efficiente ed efficace.
Questo modello utilizza modelli AWS SAM per automatizzare la distribuzione di applicazioni annidate. Un'applicazione annidata è un'applicazione all'interno di un'altra applicazione. Le applicazioni principali chiamano le proprie applicazioni secondarie. Si tratta di componenti liberamente accoppiati di un'architettura serverless.
Utilizzando applicazioni annidate, puoi creare rapidamente architetture serverless altamente sofisticate riutilizzando servizi o componenti creati e gestiti in modo indipendente ma composti utilizzando AWS SAM e Serverless Application Repository. Le applicazioni annidate ti aiutano a creare applicazioni più potenti, a evitare il lavoro duplicato e a garantire la coerenza e le migliori pratiche tra i tuoi team e le tue organizzazioni. Per dimostrare le applicazioni annidate, il pattern distribuisce un esempio di applicazione [AWS serverless per il carrello degli acquisti](https://github.com/aws-samples/aws-sam-nested-stack-sample).
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ Un cloud privato virtuale (VPC) e sottoreti esistenti
+ Un ambiente di sviluppo integrato come Visual Studio Code (per ulteriori informazioni, consulta [Tools to Build on AWS](https://aws.amazon.com/getting-started/tools-sdks/#IDE_and_IDE_Toolkits))
+ Libreria Python wheel installata utilizzando pip install wheel, se non è già installata
**Limitazioni**
+ Il numero massimo di applicazioni che possono essere annidate in un'applicazione serverless è 200.
+ Il numero massimo di parametri per un'applicazione annidata può essere 60.
**Versioni del prodotto**
+ Questa soluzione è basata sull'interfaccia a riga di comando AWS SAM (AWS SAM CLI) versione 1.21.1, ma questa architettura dovrebbe funzionare con le versioni successive dell'interfaccia a riga di comando AWS SAM.
## Architecture
**Stack tecnologico Target**
+ Gateway Amazon API
+ AWS SAM
+ Amazon Cognito
+ Amazon DynamoDB
+ AWS Lambda
+ Coda Amazon Simple Queue Service (Amazon SQS)
**Architettura di destinazione**
Il diagramma seguente mostra come vengono effettuate le richieste degli utenti ai servizi di acquisto tramite chiamata APIs. La richiesta dell'utente, incluse tutte le informazioni necessarie, viene inviata ad Amazon API Gateway e all'autorizzatore Amazon Cognito, che esegue i meccanismi di autenticazione e autorizzazione per. APIs
Quando un elemento viene aggiunto, eliminato o aggiornato in DynamoDB, un evento viene inserito in DynamoDB Streams, che a sua volta avvia una funzione Lambda. Per evitare l'eliminazione immediata dei vecchi elementi come parte di un flusso di lavoro sincrono, i messaggi vengono inseriti in una coda SQS, che avvia una funzione di lavoro per eliminare i messaggi.
![\[Operazioni POST e PUT da API Gateway alle funzioni Lambda a DynamoDB e Product Service.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5b454bae-5fd4-405d-a37d-6bafc3fcf889.png)
In questa configurazione della soluzione, AWS SAM CLI funge da interfaccia per gli stack CloudFormation AWS. I modelli AWS SAM distribuiscono automaticamente applicazioni annidate. Il modello SAM principale chiama i modelli secondari e lo stack principale distribuisce gli CloudFormation stack secondari. Ogni stack secondario crea le risorse AWS definite nei modelli AWS SAM CloudFormation .
![\[Processo in quattro fasi che utilizza AWS SAM CLI con uno stack principale e tre CloudFormation stack secondari.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/218adecc-b5b8-4193-9012-b5d584e2e128/images/5828026e-72ad-4a3f-a5f2-bffac0f13e42.png)
1. Crea e distribuisci gli stack.
1. Lo CloudFormation stack di autenticazione contiene Amazon Cognito.
1. Lo CloudFormation stack di prodotti contiene una funzione Lambda e Amazon API Gateway
1. Lo CloudFormation stack Shopping contiene una funzione Lambda, Amazon API Gateway, la coda SQS e il database Amazon DynamoDB.
## Tools (Strumenti)
**Strumenti**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ti aiuta a creare, pubblicare, gestire, monitorare e proteggere REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ti CloudFormation aiuta a configurare le risorse AWS, effettuarne il provisioning in modo rapido e coerente e gestirle durante tutto il loro ciclo di vita su account e regioni AWS.
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) fornisce autenticazione, autorizzazione e gestione degli utenti per app Web e mobili.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di elaborazione che ti aiuta a eseguire codice senza dover fornire o gestire server. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di calcolo che utilizzi.
+ [AWS Serverless Application Model (AWS SAM) Serverless Application Model (AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) SAM) è un framework open source che ti aiuta a creare applicazioni serverless nel cloud AWS.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fornisce una coda ospitata sicura, durevole e disponibile che ti aiuta a integrare e disaccoppiare sistemi e componenti software distribuiti.
**Codice**
Il codice per questo modello è disponibile nel repository GitHub [AWS SAM Nested Stack Sample](https://github.com/aws-samples/aws-sam-nested-stack-sample).
## Epiche
### Installa AWS SAM CLI
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Installa AWS SAM CLI. | Per installare AWS SAM CLI, consulta le istruzioni nella documentazione di [AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). | DevOps ingegnere |
| Configura le credenziali AWS. | Per impostare le credenziali AWS in modo che la CLI di AWS SAM possa effettuare chiamate ai servizi AWS per tuo conto, esegui `aws configure` il comando e segui le istruzioni.$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]: your_secret_access_key
Default region name [None]:
Default output format [None]:
[Per ulteriori informazioni sulla configurazione delle credenziali, consulta Autenticazione e credenziali di accesso.](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) | DevOps ingegnere |
### Inizializza il progetto AWS SAM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il repository di codice AWS SAM. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingegnere |
| Implementa modelli per inizializzare il progetto. | Per inizializzare il progetto, esegui il comando. `SAM init` Quando viene richiesto di scegliere una fonte per il modello, scegliete. `Custom Template Location` | DevOps ingegnere |
### Compila e crea il codice del modello SAM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esamina i modelli di applicazione AWS SAM. | Esamina i modelli per le applicazioni annidate. Questo esempio utilizza i seguenti modelli di applicazioni annidate:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingegnere |
| Rivedi il modello principale. | Esamina il modello che richiamerà i modelli di applicazione annidati. In questo esempio, il modello principale è. `template.yml` Tutte le applicazioni separate sono annidate nell'unico modello `template.yml` principale. | DevOps ingegnere |
| Compila e crea il codice modello AWS SAM. | Utilizzando l'AWS SAM CLI, esegui il comando seguente.sam build
| DevOps ingegnere |
### Implementa il modello AWS SAM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Implementa le applicazioni. | Per avviare il codice modello SAM che crea gli CloudFormation stack di applicazioni annidate e distribuisce il codice nell'ambiente AWS, esegui il comando seguente.sam deploy --guided --stack-name shopping-cart-nested-stack --capabilities CAPABILITY_IAM CAPABILITY_AUTO_EXPAND
Il comando richiederà alcune domande. Rispondi a tutte le domande con`y`. | DevOps ingegnere |
### Verifica della distribuzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Verifica le pile. | Per esaminare gli CloudFormation stack AWS e le risorse AWS definiti nei modelli AWS SAM, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/automate-deployment-of-nested-applications-using-aws-sam.html) | DevOps ingegnere |
## Risorse correlate
**Riferimenti**
+ [Modello di applicazioni serverless AWS (AWS SAM)](https://aws.amazon.com/serverless/sam/#:~:text=The%20AWS%20Serverless%20Application%20Model,and%20model%20it%20using%20YAML.)
+ [AWS SAM su GitHub](https://github.com/aws/serverless-application-model)
+ [Microservizio Serverless Shopping Cart](https://github.com/aws-samples/aws-serverless-shopping-cart) (applicazione di esempio AWS)
**Tutorial e video**
+ [Crea un'app serverless](https://youtu.be/Hv3YrP8G4ag)
+ [AWS Online Tech Talks: creazione e implementazione di applicazioni serverless con AWS SAM](https://youtu.be/1NU7vyJw9LU)
## Informazioni aggiuntive
Dopo che tutto il codice è a posto, l'esempio ha la seguente struttura di directory:
+ [sam\$1stacks](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html) — Questa cartella contiene il layer. `shared.py` Un layer è un archivio di file che contiene librerie, un runtime personalizzato o altre dipendenze. Con i livelli, puoi utilizzare le librerie nella tua funzione senza doverle includere in un pacchetto di distribuzione.
+ *product-mock-service*— Questa cartella contiene tutte le funzioni e i file Lambda relativi al prodotto.
+ *shopping-cart-service*— Questa cartella contiene tutte le funzioni e i file Lambda relativi agli acquisti.
# Implementa l'isolamento dei tenant SaaS per Amazon S3 utilizzando un distributore automatico di token AWS Lambda
*Tabby Ward, Thomas Davis e Sravan Periyathambi, Amazon Web Services*
## Riepilogo
Le applicazioni SaaS multitenant devono implementare sistemi per garantire il mantenimento dell'isolamento dei tenant. Quando memorizzi i dati dei tenant sulla stessa AWS risorsa, ad esempio quando più tenant archiviano i dati nello stesso bucket Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3), devi assicurarti che l'accesso tra tenant non possa avvenire. I distributori automatici di token () sono un modo per garantire l'isolamento dei dati dei tenant. TVMs Queste macchine forniscono un meccanismo per ottenere token e al contempo astrarre la complessità del modo in cui questi token vengono generati. Gli sviluppatori possono utilizzare una TVM senza avere una conoscenza dettagliata di come produce i token.
Questo modello implementa una TVM utilizzando. AWS Lambda Il TVM genera un token costituito da credenziali temporanee del servizio token di sicurezza (STS) che limitano l'accesso ai dati di un singolo tenant SaaS in un bucket S3.
TVMs, e il codice fornito con questo modello, vengono in genere utilizzati con attestazioni derivate da JSON Web Tokens (JWTs) per associare le richieste di AWS risorse a una policy tenant-scoped (IAM). AWS Identity and Access Management È possibile utilizzare il codice in questo modello come base per implementare un'applicazione SaaS che genera credenziali STS temporanee e con ambito basate sulle affermazioni fornite in un token JWT.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo. Account AWS
+ AWS Command Line Interface (AWS CLI) [versione 1.19.0 o successiva](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html), installata e configurata su macOS, Linux o Windows. In alternativa, è possibile utilizzare la AWS CLI [versione 2.1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html) o successiva.
**Limitazioni**
+ Questo codice viene eseguito in Java e attualmente non supporta altri linguaggi di programmazione.
+ L'applicazione di esempio non include il supporto AWS interregionale o di disaster recovery (DR).
+ Questo modello dimostra come una Lambda TVM per un'applicazione SaaS possa fornire un accesso mirato ai tenant. Questo modello non è destinato all'uso in ambienti di produzione senza ulteriori test di sicurezza come parte dell'applicazione o del caso d'uso specifici.
## Architecture
**Stack tecnologico Target**
+ AWS Lambda
+ Simple Storage Service (Amazon S3)
+ IAM
+ AWS Security Token Service (AWS STS)
**Architettura di destinazione**
![\[Generazione di un token per ottenere credenziali STS temporanee per accedere ai dati in un bucket S3.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/14d0508a-703b-4229-85e6-c5094de7fe01.png)
## Tools (Strumenti)
**Servizi AWS**
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che consente di interagire Servizi AWS tramite comandi nella shell della riga di comando.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi.
+ [AWS Security Token Service (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) consente di richiedere credenziali temporanee con privilegi limitati per gli utenti.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
**Codice**
Il codice sorgente di questo pattern è disponibile come allegato e include i seguenti file:
+ `s3UploadSample.jar`fornisce il codice sorgente per una funzione Lambda che carica un documento JSON in un bucket S3.
+ `tvm-layer.zip`fornisce una libreria Java riutilizzabile che fornisce un token (credenziali temporanee STS) per la funzione Lambda per accedere al bucket S3 e caricare il documento JSON.
+ `token-vending-machine-sample-app.zip`fornisce il codice sorgente usato per creare questi artefatti e le istruzioni di compilazione.
Per utilizzare questi file, seguite le istruzioni riportate nella sezione successiva.
## Epiche
### Determina i valori delle variabili
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Determina i valori delle variabili. | L'implementazione di questo modello include diversi nomi di variabili che devono essere usati in modo coerente. Determina i valori da utilizzare per ogni variabile e fornisci quel valore quando richiesto nei passaggi successivi.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine.html) | Amministratore cloud |
### Creare un bucket S3
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un bucket S3 per l'applicazione di esempio. | Usa il seguente AWS CLI comando per creare un bucket S3. Fornisci il ``**** valore nel frammento di codice:aws s3api create-bucket --bucket
L'applicazione di esempio Lambda carica i file JSON in questo bucket. | Amministratore cloud |
### Crea il ruolo e la policy di IAM TVM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un ruolo TVM. | Utilizza uno dei seguenti AWS CLI comandi per creare un ruolo IAM. Fornisci il ``**** valore nel comando.Per le shell macOS o Linux:aws iam create-role \
--role-name \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Principal": {
"Service": [
"lambda.amazonaws.com"
]
},
"Condition": {
"StringEquals": {
"aws:SourceAccount": ""
}
}
}
]
}'
Per la riga di comando di Windows:aws iam create-role ^
--role-name ^
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": [\"sts:AssumeRole\"], \"Principal\": {\"Service\": [\"lambda.amazonaws.com\"]}, \"Condition\": {\"StringEquals\": {\"aws:SourceAccount\": \"\"}}}]}"
L'applicazione di esempio Lambda assume questo ruolo quando viene richiamata l'applicazione. La capacità di assumere il ruolo dell'applicazione con una policy mirata offre al codice autorizzazioni più ampie per accedere al bucket S3. | Amministratore cloud |
| Crea una politica di ruolo TVM in linea. | Utilizzate uno dei seguenti AWS CLI comandi per creare una policy IAM. Fornisci i `` valori `` **``**, e nel comando.Per le shell macOS o Linux:aws iam put-role-policy \
--role-name \
--policy-name assume-app-role \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam:::role/"
}
]}'
Per la riga di comando di Windows:aws iam put-role-policy ^
--role-name ^
--policy-name assume-app-role ^
--policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": \"sts:AssumeRole\", \"Resource\": \"arn:aws:iam:::role/\"}]}"
Questa policy è associata al ruolo TVM. Fornisce al codice la capacità di assumere il ruolo dell'applicazione, che dispone di autorizzazioni più ampie per accedere al bucket S3. | Amministratore cloud |
| Allega la policy Lambda gestita. | Usa il AWS CLI comando seguente per allegare la policy `AWSLambdaBasicExecutionRole` IAM. Fornisci il `` valore nel comando:aws iam attach-role-policy \
--role-name \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Per la riga di comando di Windows:aws iam attach-role-policy ^
--role-name ^
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Questa policy gestita è allegata al ruolo TVM per consentire a Lambda di inviare log ad Amazon. CloudWatch | Amministratore cloud |
### Crea il ruolo e la policy dell'applicazione IAM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea il ruolo dell'applicazione. | Utilizza uno dei seguenti AWS CLI comandi per creare un ruolo IAM. Fornisci i `` valori ````, e nel comando.Per le shell macOS o Linux:aws iam create-role \
--role-name \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect":
"Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/"
},
"Action": "sts:AssumeRole"
}
]}'
Per la riga di comando di Windows:aws iam create-role ^
--role-name ^
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\",\"Principal\": {\"AWS\": \"arn:aws:iam:::role/\"},\"Action\": \"sts:AssumeRole\"}]}"
L'applicazione di esempio Lambda assume questo ruolo con una policy mirata per ottenere l'accesso basato su tenant a un bucket S3. | Amministratore del cloud |
| Crea una politica in linea per i ruoli delle applicazioni. | Utilizza uno dei seguenti AWS CLI comandi per creare una policy IAM. Fornisci i ``**** valori `` and nel comando.Per le shell macOS o Linux:aws iam put-role-policy \
--role-name \
--policy-name s3-bucket-access \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": "arn:aws:s3:::/*"
},
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": "arn:aws:s3:::"
}
]}'
Per la riga di comando di Windows:aws iam put-role-policy ^
--role-name ^
--policy-name s3-bucket-access ^
--policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Effect\": \"Allow\", \"Action\": [\"s3:PutObject\", \"s3:GetObject\", \"s3:DeleteObject\"], \"Resource\": \"arn:aws:s3:::/*\"}, {\"Effect\": \"Allow\", \"Action\": [\"s3:ListBucket\"], \"Resource\": \"arn:aws:s3:::\"}]}"
Questa politica è allegata al ruolo dell'applicazione. Fornisce un ampio accesso agli oggetti nel bucket S3. Quando l'applicazione di esempio assume il ruolo, queste autorizzazioni sono limitate a un tenant specifico con la policy generata dinamicamente da TVM. | Amministratore cloud |
### Crea l'applicazione di esempio Lambda con TVM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Scarica i file sorgente compilati. | Scaricate i `tvm-layer.zip`**** file `s3UploadSample.jar` and, che sono inclusi come allegati. Il codice sorgente utilizzato per creare questi artefatti e le istruzioni di compilazione sono forniti in. `token-vending-machine-sample-app.zip` | Amministratore cloud |
| Crea il livello Lambda. | Utilizzate il seguente AWS CLI comando per creare un layer Lambda, che renda la TVM accessibile a Lambda. Se non state eseguendo questo comando dalla posizione in cui lo avete scaricato` tvm-layer.zip`, fornite il percorso corretto del parametro`tvm-layer.zip`. `--zip-file` aws lambda publish-layer-version \
--layer-name sample-token-vending-machine \
--compatible-runtimes java11 \
--zip-file fileb://tvm-layer.zip
Per la riga di comando di Windows:aws lambda publish-layer-version ^
--layer-name sample-token-vending-machine ^
--compatible-runtimes java11 ^
--zip-file fileb://tvm-layer.zip
Questo comando crea un layer Lambda che contiene la libreria TVM riutilizzabile. | Amministratore cloud, sviluppatore di app |
| Creazione della funzione Lambda | Usa il AWS CLI comando seguente per creare una funzione Lambda. Fornisci i `` valori `` ````, ````,, e nel comando. Se non esegui questo comando dalla posizione in cui lo hai scaricato`s3UploadSample.jar`, fornisci il percorso corretto `s3UploadSample.jar` nel `--zip-file` parametro. 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/}"
Per la riga di comando di Windows:aws lambda create-function ^
--function-name ^
--timeout 30 ^
--memory-size 256 ^
--runtime java11 ^
--role arn:aws:iam:::role/ ^
--handler com.amazon.aws.s3UploadSample.App ^
--zip-file fileb://s3UploadSample.jar ^
--layers arn:aws:lambda:::layer:sample-token-vending-machine:1 ^
--environment "Variables={S3_BUCKET=,ROLE=arn:aws:iam:::role/}"
Questo comando crea una funzione Lambda con il codice dell'applicazione di esempio e il livello TVM collegato. Imposta inoltre due variabili di ambiente: `S3_BUCKET` e. `ROLE` L'applicazione di esempio utilizza queste variabili per determinare il ruolo da assumere e il bucket S3 in cui caricare i documenti JSON. | Amministratore cloud, sviluppatore di app |
### Prova l'applicazione di esempio e TVM
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Richiama l'applicazione di esempio Lambda. | Utilizza uno dei seguenti AWS CLI comandi per avviare l'applicazione di esempio Lambda con il payload previsto. Fornisci i `` valori `` and nel comando.Per le shell macOS e Linux:aws lambda invoke \
--function \
--invocation-type RequestResponse \
--payload '{"tenant": ""}' \
--cli-binary-format raw-in-base64-out response.json
Per la riga di comando di Windows:aws lambda invoke ^
--function ^
--invocation-type RequestResponse ^
--payload "{\"tenant\": \"\"}" ^
--cli-binary-format raw-in-base64-out response.json
Questo comando richiama la funzione Lambda e restituisce il risultato in un `response.json` documento. In molti sistemi basati su Unix, è possibile passare `response.json` a per `/dev/stdout` inviare i risultati direttamente alla shell senza creare un altro file. La modifica del `` valore nelle chiamate successive di questa funzione Lambda modifica la posizione del documento JSON e le autorizzazioni fornite dal token. | Amministratore cloud, sviluppatore di app |
| Visualizza il bucket S3 per vedere gli oggetti creati. | Vai al bucket S3 (``) che hai creato in precedenza. Questo bucket contiene un prefisso di oggetto S3 con il valore di. `` Sotto quel prefisso, troverai un documento JSON denominato con un UUID. Richiamando più volte l'applicazione di esempio vengono aggiunti altri documenti JSON. | Amministratore cloud |
| Visualizza i log dell'applicazione di esempio in CloudWatch Logs. | Visualizza i log associati alla funzione Lambda `` denominata CloudWatch in Logs. Per istruzioni, consulta [Invio dei log delle funzioni Lambda ai CloudWatch registri nella](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html) documentazione di Lambda. È possibile visualizzare la politica basata sull'ambito dei tenant generata da TVM in questi log. Questa politica con ambito tenant fornisce le autorizzazioni per l'applicazione di esempio ad Amazon S3,, e **PutObject**GetObject**DeleteObject**ListBucket******** APIs, ma solo per il prefisso dell'oggetto a cui è associato. `` Nelle chiamate successive dell'applicazione di esempio, in caso di modifiche``, TVM aggiorna la policy di ambito in modo che corrisponda al tenant fornito nel payload di chiamata. Questa policy generata dinamicamente mostra come è possibile mantenere l'accesso con ambito tenant con una TVM nelle applicazioni SaaS. La funzionalità TVM è fornita in un livello Lambda in modo che possa essere collegata ad altre funzioni Lambda utilizzate da un'applicazione senza dover replicare il codice.[Per un'illustrazione della policy generata dinamicamente, consultate la sezione Informazioni aggiuntive.](#implement-saas-tenant-isolation-for-amazon-s3-by-using-an-aws-lambda-token-vending-machine-additional) | Amministratore cloud |
## Risorse correlate
+ [Isolamento dei tenant con policy IAM generate dinamicamente](https://aws.amazon.com/blogs/apn/isolating-saas-tenants-with-dynamically-generated-iam-policies/) (post sul blog)
+ [Applicazione di politiche di isolamento generate dinamicamente in ambienti SaaS](https://aws.amazon.com/blogs/apn/applying-dynamically-generated-isolation-policies-in-saas-environments/) (post sul blog)
+ [SaaS attivo AWS](https://aws.amazon.com/saas/)
## Informazioni aggiuntive
Il registro seguente mostra la politica generata dinamicamente dal codice TVM secondo questo schema. In questa schermata, il `` è `DOC-EXAMPLE-BUCKET` e il è. `` `test-tenant-1` Le credenziali STS restituite da questa policy con ambito non sono in grado di eseguire alcuna azione sugli oggetti nel bucket S3 ad eccezione degli oggetti associati al prefisso object key. `test-tenant-1`
![\[Log che mostra una policy generata dinamicamente prodotta dal codice TVM.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/97a34c8e-d04e-40b6-acbf-1baa176d22a9/images/d4776ebe-fb8f-41ac-b8c5-b4f97a821c8c.png)
## Allegati
[Per accedere al contenuto aggiuntivo associato a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/97a34c8e-d04e-40b6-acbf-1baa176d22a9/attachments/attachment.zip)
# Implementa il modello di saga serverless utilizzando AWS Step Functions
*Tabby Ward, Joe Kern e Rohan Mehta, Amazon Web Services*
## Riepilogo
In un'architettura di microservizi, l'obiettivo principale è creare componenti disaccoppiati e indipendenti per promuovere agilità, flessibilità e tempi di commercializzazione più rapidi per le applicazioni. Come risultato del disaccoppiamento, ogni componente dei microservizi ha il proprio livello di persistenza dei dati. In un'architettura distribuita, le transazioni commerciali possono estendersi su più microservizi. Poiché questi microservizi non possono utilizzare una singola transazione ACID (atomicità, coerenza, isolamento, durabilità), è possibile che si ottengano transazioni parziali. In questo caso, è necessaria una certa logica di controllo per annullare le transazioni che sono già state elaborate. Il modello a saga distribuito viene in genere utilizzato per questo scopo.
Il modello a saga è un modello di gestione degli errori che aiuta a stabilire la coerenza nelle applicazioni distribuite e coordina le transazioni tra più microservizi per mantenere la coerenza dei dati. Quando si utilizza il modello saga, ogni servizio che esegue una transazione pubblica un evento che attiva i servizi successivi per eseguire la transazione successiva nella catena. Questo continua fino al completamento dell'ultima transazione della catena. Se una transazione commerciale fallisce, saga orchestra una serie di transazioni di compensazione che annullano le modifiche apportate dalle transazioni precedenti.
Questo modello dimostra come automatizzare la configurazione e la distribuzione di un'applicazione di esempio (che gestisce le prenotazioni di viaggi) con tecnologie serverless come AWS Step Functions, AWS Lambda e Amazon DynamoDB. L'applicazione di esempio utilizza anche Amazon API Gateway e Amazon Simple Notification Service (Amazon SNS) per implementare un coordinatore dell'esecuzione di saga. Il pattern può essere distribuito con un framework Infrastructure as code (IaC) come AWS Cloud Development Kit (AWS CDK), AWS Serverless Application Model (AWS SAM) o Terraform.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo.
+ Autorizzazioni per creare uno CloudFormation stack AWS. Per ulteriori informazioni, consulta [Controllare l'accesso](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) nella CloudFormation documentazione.
+ Framework IaC di tua scelta (AWS CDK, AWS SAM o Terraform) configurato con il tuo account AWS in modo da poter utilizzare la CLI del framework per distribuire l'applicazione.
+ NodeJS, utilizzato per creare l'applicazione ed eseguirla localmente.
+ Un editor di codice a tua scelta (come Visual Studio Code, Sublime o Atom).
**Versioni del prodotto**
+ [NodeJS versione 14](https://nodejs.org/en/download/)
+ [CDK AWS versione 2.37.1](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install)
+ [AWS SAM versione 1.71.0](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
+ [Terraform versione 1.3.7](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)
**Limitazioni**
L'event sourcing è un modo naturale per implementare il modello di orchestrazione della saga in un'architettura di microservizi in cui tutti i componenti sono liberamente accoppiati e non hanno una conoscenza diretta l'uno dell'altro. Se la transazione prevede un numero limitato di passaggi (da tre a cinque), il modello a saga potrebbe essere la soluzione ideale. Tuttavia, la complessità aumenta con il numero di microservizi e il numero di passaggi.
Il test e il debug possono diventare difficili quando si utilizza questo design, poiché è necessario che tutti i servizi siano in esecuzione per simulare il modello di transazione.
## Architecture
**Architettura di Target**
L'architettura proposta utilizza AWS Step Functions per creare uno schema a saga per prenotare voli, prenotare auto a noleggio ed elaborare i pagamenti per le vacanze.
Il seguente diagramma del flusso di lavoro illustra il flusso tipico del sistema di prenotazione viaggi. Il flusso di lavoro consiste nella prenotazione di viaggi aerei (» ReserveFlight «), nella prenotazione di un'auto (» ReserveCarRental «), nell'elaborazione dei pagamenti (» ProcessPayment «), nella conferma delle prenotazioni dei voli (» ConfirmFlight «) e nella conferma del noleggio auto (» ConfirmCarRental «) seguite da una notifica di avvenuto completamento di questi passaggi. Tuttavia, se il sistema riscontra errori nell'esecuzione di una di queste transazioni, inizia a fallire all'indietro. Ad esempio, un errore nell'elaborazione dei pagamenti (» ProcessPayment «) attiva un rimborso (» RefundPayment «), che quindi attiva la cancellazione dell'auto a noleggio e del volo (» CancelRentalReservation "e" CancelFlightReservation «), che termina l'intera transazione con un messaggio di errore.
Questo modello implementa funzioni Lambda separate per ogni attività evidenziata nel diagramma, oltre a tre tabelle DynamoDB per voli, autonoleggi e pagamenti. Ogni funzione Lambda crea, aggiorna o elimina le righe nelle rispettive tabelle DynamoDB, a seconda che una transazione sia confermata o ripristinata. Il modello utilizza Amazon SNS per inviare messaggi di testo (SMS) agli abbonati, notificandoli delle transazioni non riuscite o riuscite.
![\[Flusso di lavoro per un sistema di prenotazione viaggi basato sullo schema della saga.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/daad3e8e-6e6b-41c2-95c1-ca79d53ead64.png)
**Automazione e scalabilità**
È possibile creare la configurazione per questa architettura utilizzando uno dei framework IaC. Usa uno dei seguenti link per il tuo IAc preferito.
+ [Implementa con AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Implementa con AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Implementa con Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
## Tools (Strumenti)
**Servizi AWS**
+ [AWS Step Functions](https://aws.amazon.com/step-functions/) è un servizio di orchestrazione serverless che consente di combinare funzioni AWS Lambda e altri servizi AWS per creare applicazioni aziendali critiche. Tramite la console grafica Step Functions, puoi vedere il flusso di lavoro dell'applicazione come una serie di passaggi guidati dagli eventi.
+ [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) è un servizio di database NoSQL completamente gestito che offre prestazioni veloci e prevedibili con una scalabilità perfetta. Puoi utilizzare DynamoDB per creare una tabella di database in grado di archiviare e recuperare qualunque quantità di dati e soddisfare qualsiasi livello di traffico di richiesto.
+ [AWS Lambda](https://aws.amazon.com/lambda/) è un servizio di elaborazione che consente di eseguire codice senza effettuare il provisioning o la gestione di server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo.
+ [Amazon API Gateway](https://aws.amazon.com/api-gateway/) è un servizio AWS per la creazione, la pubblicazione, la manutenzione, il monitoraggio e la protezione di REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [Amazon Simple Notification Service (Amazon SNS](https://aws.amazon.com/sns/)) è un servizio gestito che fornisce il recapito dei messaggi dagli editori agli abbonati.
+ [AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/) è un framework di sviluppo software per definire le risorse delle applicazioni cloud utilizzando linguaggi di programmazione familiari come Python TypeScript JavaScript, Java e C\$1/.Net.
+ [AWS Serverless Application Model (AWS SAM) Serverless Application Model (AWS) Serverless Application Model (AWS](https://aws.amazon.com/serverless/sam/) SAM) è un framework open source per la creazione di applicazioni serverless. Fornisce una sintassi abbreviata per esprimere funzioni, database e mappature delle sorgenti degli APIs eventi.
**Codice**
Il codice per un'applicazione di esempio che dimostra il modello saga, incluso il modello IaC (AWS CDK, AWS SAM o Terraform), le funzioni Lambda e le tabelle DynamoDB, è disponibile nei seguenti link. Segui le istruzioni del primo capitolo epico per installarli.
+ [Implementa con AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Implementa con AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Implementa con Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
## Epiche
### Installa pacchetti, compila e crea
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Installa i pacchetti NPM. | Crea una nuova directory, accedi a quella directory in un terminale e clona il GitHub repository di tua scelta dalla sezione *Codice* precedente di questo schema.Nella cartella principale che contiene il `package.json` file, esegui il seguente comando per scaricare e installare tutti i pacchetti Node Package Manager (NPM):npm install
| Sviluppatore, architetto cloud |
| Compila script. | Nella cartella principale, esegui il seguente comando per indicare al TypeScript transpiler di creare tutti i file necessari: JavaScript npm run build
| Sviluppatore, architetto cloud |
| Controlla le modifiche e ricompila. | Nella cartella principale, esegui il seguente comando in una finestra di terminale separata per controllare le modifiche al codice e compila il codice quando rileva una modifica:npm run watch
| Sviluppatore, architetto cloud |
| Esegui test unitari (solo AWS CDK). | Se utilizzi il CDK AWS, nella cartella principale, esegui il seguente comando per eseguire gli unit test di Jest:npm run test
| Sviluppatore, architetto del cloud |
### Distribuisci risorse sull'account AWS di destinazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Distribuisci lo stack dimostrativo su AWS. | L'applicazione è indipendente dalla regione AWS. Se utilizzi un profilo, devi dichiarare la regione in modo esplicito nel [profilo AWS Command Line Interface (AWS CLI) o tramite le variabili di ambiente [AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html) CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html).Nella cartella principale, esegui il comando seguente per creare un assembly di distribuzione e distribuirlo nell'account e nella regione AWS predefiniti.CDK AWS:cdk bootstrap
cdk deploy
AWS È:sam build
sam deploy --guided
Terraforma:terraform init
terraform apply
Il completamento di questo passaggio potrebbe richiedere alcuni minuti. Questo comando utilizza le credenziali predefinite configurate per l'AWS CLI.Nota l'URL dell'API Gateway che viene visualizzato sulla console al termine della distribuzione. Avrai bisogno di queste informazioni per testare il flusso di esecuzione della saga. | Sviluppatore, architetto cloud |
| Confronta lo stack distribuito con lo stato attuale. | Nella cartella principale, esegui il comando seguente per confrontare lo stack distribuito con lo stato corrente dopo aver apportato modifiche al codice sorgente:CDK AWS:cdk diff
AWS È:sam deploy
Terraforma:terraform plan
| Sviluppatore, architetto cloud |
### Testa il flusso di esecuzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Prova il flusso di esecuzione della saga. | Passa all'URL dell'API Gateway che hai annotato nel passaggio precedente, quando hai distribuito lo stack. Questo URL attiva l'avvio della macchina a stati. Per ulteriori informazioni su come manipolare il flusso della macchina a stati passando diversi parametri URL, consulta la sezione [Informazioni aggiuntive](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional).Per visualizzare i risultati, accedi alla Console di gestione AWS e vai alla console Step Functions. Qui puoi vedere ogni fase della saga state machine. Puoi anche visualizzare la tabella DynamoDB per vedere i record inseriti, aggiornati o eliminati. Se aggiorni spesso la schermata, puoi vedere lo stato della transazione cambiare da a. `pending` `confirmed` Puoi iscriverti all'argomento SNS aggiornando il codice nel `stateMachine.ts` file con il tuo numero di cellulare per ricevere messaggi SMS in caso di prenotazioni riuscite o non riuscite. Per ulteriori informazioni, consulta *Amazon SNS* nella sezione [Informazioni aggiuntive](#implement-the-serverless-saga-pattern-by-using-aws-step-functions-additional). | Sviluppatore, architetto cloud |
### Eliminazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Eliminare le risorse. | Per ripulire le risorse distribuite per questa applicazione, è possibile utilizzare uno dei seguenti comandi.CDK AWS:cdk destroy
AWS È:sam delete
Terraforma:terraform destroy
| Sviluppatore di app, architetto cloud |
## Risorse correlate
**Documenti tecnici**
+ [Implementazione di microservizi su AWS](https://docs.aws.amazon.com/pdfs/whitepapers/latest/microservices-on-aws/microservices-on-aws.pdf)
+ [Lente applicativa serverless](https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html)
**Documentazione del servizio AWS**
+ [Guida introduttiva alla CDK AWS](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html)
+ [Guida introduttiva ad 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/)
+ [Gateway Amazon API](https://docs.aws.amazon.com/apigateway/)
+ [Amazon SNS](https://docs.aws.amazon.com/sns/)
**Tutorial**
+ [Workshop pratici per l'informatica serverless](https://aws.amazon.com/serverless-workshops/)
## Informazioni aggiuntive
**Codice**
A scopo di test, questo modello implementa API Gateway e una funzione Lambda di test che attiva la macchina a stati Step Functions. Con Step Functions, puoi controllare la funzionalità del sistema di prenotazione viaggi passando un `run_type` parametro per simulare gli errori in "ReserveFlightReserveCarRental,» "ProcessPayment,»,» e "ConfirmFlightConfirmCarRental.»
La funzione `saga` Lambda (`sagaLambda.ts`) riceve l'input dai parametri di query nell'URL API Gateway, crea il seguente oggetto JSON e lo passa a Step Functions per l'esecuzione:
```
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"
};
```
È possibile sperimentare diversi flussi della macchina a stati Step Functions passando i seguenti parametri URL:
+ **Esecuzione riuscita** ─ https://\$1api gateway url\$1
+ **Reserve Flight Fail** ─ https://\$1api gateway url\$1? **RunType= failFlightsReservation**
+ **Conferma il fallimento del volo** ─ https://\$1api gateway url\$1? **RunType= failFlightsConfirmation**
+ **Reserve Car Rental Failure** ─ https://\$1api gateway url\$1? **RunType= Prenotazione failCarRental**
+ **Conferma il fallimento del noleggio auto** ─ https://\$1api gateway url\$1? **RunType= failCarRental Conferma**
+ **Processo di pagamento non riuscito** ─ https://\$1api gateway url\$1? **RunType=FailPayment**
+ **Passa un Trip ID** ─ https://\$1api gateway url\$1? **tripId=** \$1per impostazione predefinita, l'ID del viaggio sarà l'ID della richiesta AWS\$1
**modelli IaC**
Gli archivi collegati includono modelli IaC che è possibile utilizzare per creare l'intera applicazione di prenotazione viaggi di esempio.
+ [Implementa con AWS CDK](https://serverlessland.com/workflows/saga-pattern-cdk)
+ [Implementa con AWS SAM](https://serverlessland.com/workflows/saga-pattern-sam)
+ [Implementa con Terraform](https://serverlessland.com/workflows/saga-pattern-tf)
**Tabelle DynamoDB**
Ecco i modelli di dati per le tabelle dei voli, degli autonoleggi e dei pagamenti.
```
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"}
}
};
```
**Funzioni Lambda**
Verranno create le seguenti funzioni per supportare il flusso e l'esecuzione della macchina a stati in Step Functions:
+ **Reserve Flights**: inserisce un record nella tabella DynamoDB Flights con `transaction_status` un `pending` di, per prenotare un volo.
+ **Confirm Flight**: aggiorna il record nella tabella DynamoDB Flights, da `transaction_status` impostare su, per confermare `confirmed` il volo.
+ **Annulla prenotazione voli**: elimina il record dalla tabella DynamoDB Flights, per annullare il volo in sospeso.
+ **Reserve Car Rentals**: inserisce un record nella tabella CarRentals DynamoDB con `transaction_status` un `pending` di, per prenotare un noleggio auto.
+ **Conferma noleggio auto**: aggiorna il record nella tabella CarRentals DynamoDB, `transaction_status` impostandolo su, per confermare `confirmed` il noleggio auto.
+ **Annulla prenotazione noleggio auto:** elimina il record dalla tabella CarRentals DynamoDB, per annullare il noleggio auto in sospeso.
+ **Elabora pagamento**: inserisce un record nella tabella Pagamenti di DynamoDB per il pagamento.
+ **Annulla pagamento**: elimina il record del pagamento dalla tabella DynamoDB Payments.
**Amazon SNS**
L'applicazione di esempio crea il seguente argomento e sottoscrizione per l'invio di messaggi SMS e la notifica al cliente in caso di prenotazioni riuscite o non riuscite. Se desideri ricevere messaggi di testo durante il test dell'applicazione di esempio, aggiorna l'abbonamento SMS con il tuo numero di telefono valido nel file di definizione della macchina a stati.
Frammento di CDK AWS (aggiungi il numero di telefono nella seconda riga del codice seguente):
```
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'),
});
```
Snippet AWS SAM (sostituisci le `+1111111111` stringhe con il tuo numero di telefono valido):
```
StateMachineTopic11111111111:
Type: 'AWS::SNS::Subscription'
Properties:
Protocol: sms
TopicArn:
Ref: StateMachineTopic
Endpoint: '+11111111111'
Metadata:
'aws:sam:path': SamServerlessSagaStack/StateMachine/Topic/+11111111111/Resource
```
Snippet Terraform (sostituisci la `+111111111` stringa con il tuo numero di telefono valido):
```
resource "aws_sns_topic_subscription" "sms-target" {
topic_arn = aws_sns_topic.topic.arn
protocol = "sms"
endpoint = "+11111111111"
}
```
**Prenotazioni riuscite**
Il seguente flusso illustra una prenotazione andata a buon fine con "ReserveFlight,»ReserveCarRental,» e "ProcessPayment" seguiti da "ConfirmFlight" e "»ConfirmCarRental. Il cliente viene informato dell'avvenuta prenotazione tramite messaggi SMS che vengono inviati all'abbonato dell'argomento SNS.
![\[Esempio di prenotazione riuscita implementata da Step Functions utilizzando il modello saga.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/f58c894e-7721-4bc7-8f7d-29f23faa5dc1.png)
**Prenotazioni non riuscite**
Questo flusso è un esempio di fallimento dello schema della saga. Se, dopo aver prenotato voli e auto a noleggio, "ProcessPayment" fallisce, i passaggi vengono annullati in ordine inverso. Le prenotazioni vengono rilasciate e il cliente viene informato dell'errore tramite messaggi SMS inviati all'abbonato dell'argomento SNS.
![\[Esempio di prenotazione fallita implementata da Step Functions utilizzando il modello saga.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/fec0789c-d9b1-4d80-b179-dd9a7ecbec07/images/7c64d326-be27-42c3-b03f-d677efedb9a7.png)
# Gestisci le applicazioni container locali configurando Amazon ECS Anywhere con AWS CDK
*Dott. Rahul Sharad Gaikwad, Amazon Web Services*
## Riepilogo
[Amazon ECS](https://aws.amazon.com/ecs/anywhere/) Anywhere è un'estensione di Amazon Elastic Container Service (Amazon ECS). Puoi usare ECS Anywhere per distribuire attività native di Amazon ECS in un ambiente locale o gestito dal cliente. Questa funzionalità aiuta a ridurre i costi e mitigare l'orchestrazione e le operazioni complesse dei container locali. Puoi utilizzare ECS Anywhere per distribuire ed eseguire applicazioni container in ambienti sia locali che cloud. Elimina la necessità per il team di apprendere più domini e set di competenze o di gestire software complessi da solo.
Questo modello illustra i passaggi per configurare ECS Anywhere utilizzando gli stack [AWS Cloud Development Kit (AWS CDK)](https://aws.amazon.com/cdk/).
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo.
+ AWS Command Line Interface (AWS CLI), installata e configurata. (Vedi [Installazione, aggiornamento e disinstallazione dell'interfaccia a riga di comando di AWS nella documentazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dell'interfaccia a riga di comando di AWS.)
+ AWS CDK Toolkit, installato e configurato. (Consulta [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) nella documentazione di AWS CDK e segui le istruzioni per installare la versione 2 a livello globale).
+ Node package manager (npm), installato e configurato per AWS CDK in. TypeScript (Vedi [Download e installazione di Node.js e npm nella documentazione di npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).)
**Limitazioni**
+ Per limitazioni e considerazioni, consulta [Istanze esterne (Amazon ECS Anywhere) nella documentazione di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-anywhere.html#ecs-anywhere-considerations).
**Versioni del prodotto**
+ AWS CDK Toolkit versione 2
+ npm versione 7.20.3 o successiva
+ Node.js versione 16.6.1 o successiva
## Architecture
**Stack tecnologico Target**
+ AWS CloudFormation
+ AWS CDK
+ Amazon ECS Anywhere
+ AWS Identity and Access Management (IAM)
**Architettura Target**
Il diagramma seguente illustra un'architettura di sistema di alto livello di configurazione di ECS Anywhere che utilizza AWS CDK con TypeScript, come implementato da questo modello.
1. Quando distribuisci lo stack CDK AWS, viene creato uno CloudFormation stack su AWS.
1. Lo CloudFormation stack fornisce un cluster Amazon ECS e le relative risorse AWS.
1. Per registrare un'istanza esterna con un cluster Amazon ECS, devi installare AWS Systems Manager Agent (SSM Agent) sulla tua macchina virtuale (VM) e registrare la macchina virtuale come istanza gestita da AWS Systems Manager.
1. È inoltre necessario installare l'agente contenitore Amazon ECS e Docker sulla macchina virtuale per registrarla come istanza esterna nel cluster Amazon ECS.
1. Quando l'istanza esterna è registrata e configurata con il cluster Amazon ECS, può eseguire più contenitori sulla macchina virtuale, che è registrata come istanza esterna.
![\[Configurazione di ECS Anywhere utilizzando il CDK AWS con. TypeScript\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/3ed63c00-40e7-4831-bb9d-63049c3490aa/images/ff7dc774-830d-4b9f-8262-7314afe7a033.png)
**Automazione e scalabilità**
Il [GitHub repository](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples/) fornito con questo modello utilizza AWS CDK come strumento Infrastructure as Code (IaC) per creare la configurazione per questa architettura. AWS CDK ti aiuta a orchestrare le risorse e configurare ECS Anywhere.
## Tools (Strumenti)
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) è un framework di sviluppo software che aiuta a definire e fornire l'infrastruttura cloud AWS in codice.
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che ti aiuta a interagire con i servizi AWS tramite comandi nella tua shell a riga di comando.
**Codice**
Il codice sorgente per questo pattern è disponibile nel GitHub repository [Amazon ECS Anywhere CDK](https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples) Samples. Per clonare e utilizzare il repository, segui le istruzioni nella sezione successiva.
## Epiche
### Verifica la configurazione di AWS CDK
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Verifica la versione di AWS CDK. | Verifica la versione di AWS CDK Toolkit eseguendo il seguente comando:cdk --version
Questo modello richiede la versione 2 di AWS CDK. Se disponi di una versione precedente di AWS CDK, segui le istruzioni nella [documentazione di AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) per aggiornarla. | DevOps ingegnere |
| Configura le credenziali AWS. | Per configurare le credenziali, esegui il `aws configure` comando e segui le istruzioni:$aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
| DevOps ingegnere |
### Esegui il bootstrap dell'ambiente AWS CDK
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il repository di codice AWS CDK. | Clona il repository di GitHub codice per questo pattern usando il comando:git clone https://github.com/aws-samples/amazon-ecs-anywhere-cdk-samples.git
| DevOps ingegnere |
| Avvia l'ambiente. | Per distribuire il CloudFormation modello AWS nell'account e nella regione AWS che desideri utilizzare, esegui il seguente comando:cdk bootstrap /
Per ulteriori informazioni, consulta [Bootstrapping nella documentazione](https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html) di AWS CDK. | DevOps ingegnere |
### Crea e distribuisci il progetto
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Installa le dipendenze dei pacchetti e compila i file TypeScript . | Installa le dipendenze del pacchetto e compila TypeScript i file eseguendo i seguenti comandi:$cd amazon-ecs-anywhere-cdk-samples
$npm install
$npm fund
Questi comandi installano tutti i pacchetti dal repository di esempio. Se ricevi errori sui pacchetti mancanti, usa uno dei seguenti comandi:$npm ci
oppure$npm install -g @aws-cdk/
Per ulteriori informazioni, consulta [npm ci](https://docs.npmjs.com/cli/v7/commands/npm-ci) e [npm install nella documentazione](https://docs.npmjs.com/cli/v7/commands/npm-install) di npm. | DevOps ingegnere |
| Compilare il progetto. | Per creare il codice del progetto, esegui il comando:npm run build
Per ulteriori informazioni sulla creazione e la distribuzione del progetto, consulta La [tua prima app AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/hello_world.html#:~:text=the%20third%20parameter.-,Synthesize%20an%20AWS%20CloudFormation%20template,-Synthesize%20an%20AWS) nella documentazione di AWS CDK. | DevOps ingegnere |
| Distribuisci il progetto | Per distribuire il codice del progetto, esegui il comando:cdk deploy
| DevOps ingegnere |
| Verifica la creazione e l'output dello stack. | Apri la CloudFormation console AWS all'indirizzo [https://console.aws.amazon.com/cloudformation****](https://console.aws.amazon.com/cloudformation/) e scegli lo stack. `EcsAnywhereStack` La scheda **Outputs** mostra i comandi da eseguire sulla macchina virtuale esterna. | DevOps ingegnere |
### Configura una macchina locale
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura la tua VM usando Vagrant. | A scopo dimostrativo, puoi usare [HashiCorp Vagrant](https://www.vagrantup.com/) per creare una macchina virtuale. Vagrant è un'utilità open source per la creazione e la manutenzione di ambienti di sviluppo software virtuali portatili. Crea una VM Vagrant eseguendo il `vagrant up` comando dalla directory principale in cui è posizionato Vagrantfile. [Per ulteriori informazioni, consulta la documentazione di Vagrant.](https://www.vagrantup.com/docs/cli/up) | DevOps ingegnere |
| Registra la tua macchina virtuale come istanza esterna. | 1. Accedi alla VM Vagrant utilizzando il comando. `vagrant ssh` [Per ulteriori informazioni, consulta la documentazione di Vagrant.](https://www.vagrantup.com/docs/cli/ssh)2. Crea un codice di attivazione e un ID che puoi utilizzare per registrare la tua macchina virtuale con AWS Systems Manager e attivare l'istanza esterna. L'output di questo comando include `ActivationId` e `ActivationCode` valori: aws ssm create-activation --iam-role EcsAnywhereInstanceRole | tee ssm-activation.json
3. Esporta l'ID di attivazione e i valori del codice:export ACTIVATION_ID=
export ACTIVATION_CODE=
4. Scarica lo script di installazione sul server o sulla macchina virtuale locale: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. Esegui lo script di installazione sul server o sulla macchina virtuale locale:sudo ./ecs-anywhere-install.sh \
--cluster test-ecs-anywhere \
--activation-id $ACTIVATION_ID \
--activation-code $ACTIVATION_CODE \
--region
Per ulteriori informazioni sulla configurazione e la registrazione di una macchina virtuale, consulta [Registrazione di un'istanza esterna in un cluster](https://docs.amazonaws.cn/en_us/AmazonECS/latest/developerguide/ecs-anywhere-registration.html) nella documentazione di Amazon ECS. | DevOps ingegnere |
| Verifica lo stato di ECS Anywhere e della macchina virtuale esterna. | Per verificare se la tua casella virtuale è connessa al piano di controllo di Amazon ECS e se è in funzione, usa i seguenti comandi:aws ssm describe-instance-information
aws ecs list-container-instances --cluster $CLUSTER_NAME
| DevOps ingegnere |
### Eliminazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Pulisci ed elimina le risorse. | Dopo aver seguito questo schema, dovresti rimuovere le risorse che hai creato per evitare di incorrere in ulteriori addebiti. Per pulire, esegui il comando:cdk destroy
| DevOps ingegnere |
## Risorse correlate
+ [Documentazione di Amazon ECS Anywhere](https://aws.amazon.com/ecs/anywhere/)
+ [Demo di Amazon ECS Anywhere](https://www.youtube.com/watch?v=-eud6yUXsJM)
+ [Esempi di workshop su Amazon ECS Anywhere](https://github.com/aws-samples/aws-ecs-anywhere-workshop-samples)
# Modernizza le applicazioni ASP.NET Web Forms su AWS
*Vijai Anand Ramalingam e Sreelaxmi Pai, Amazon Web Services*
## Riepilogo
Questo modello descrive i passaggi per modernizzare un'applicazione ASP.NET Web Forms legacy e monolitica portandola su ASP.NET Core su AWS.
Il trasferimento delle applicazioni ASP.NET Web Forms su ASP.NET Core consente di sfruttare le prestazioni, i risparmi sui costi e il robusto ecosistema di Linux. Tuttavia, può essere un notevole sforzo manuale. In questo modello, l'applicazione legacy viene modernizzata in modo incrementale utilizzando un approccio graduale e quindi containerizzata nel cloud AWS.
Prendi in considerazione un'applicazione monolitica legacy per un carrello della spesa. Supponiamo che sia stata creata come applicazione ASP.NET Web Forms e sia costituita da pagine.aspx con un file code-behind (). `aspx.cs` Il processo di modernizzazione consiste nei seguenti passaggi:
1. Suddividi il monolite in microservizi utilizzando i modelli di scomposizione appropriati. Per ulteriori informazioni, consulta la guida [Decomposizione dei monoliti in microservizi sul](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-decomposing-monoliths/) sito Web AWS Prescriptive Guidance.
1. Trasferisci la tua applicazione ASP.NET Web Forms (.NET Framework) legacy su ASP.NET Core in .NET 5 o versione successiva. In questo modello, si utilizza Porting Assistant for .NET per analizzare l'applicazione ASP.NET Web Forms e identificare le incompatibilità con ASP.NET Core. Ciò riduce lo sforzo di portabilità manuale.
1. Risviluppa il livello dell'interfaccia utente di Web Forms utilizzando React. Questo modello non copre la riqualificazione dell'interfaccia utente. Per istruzioni, consulta [Creare una nuova app React](https://reactjs.org/docs/create-a-new-react-app.html) nella documentazione di React.
1. Risviluppa il file code-behind di Web Forms (interfaccia aziendale) come API web ASP.NET Core. Questo modello utilizza i NDepend report per aiutare a identificare i file e le dipendenze necessari.
1. Aggiorna shared/common progetti, come Business Logic e Data Access, nell'applicazione precedente a .NET 5 o versione successiva utilizzando Porting Assistant for .NET.
1. Aggiungi i servizi AWS per completare la tua applicazione. Ad esempio, puoi utilizzare [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) per monitorare, archiviare e accedere ai log delle tue applicazioni e [AWS Systems Manager](https://aws.amazon.com/systems-manager/) per archiviare le impostazioni delle applicazioni.
1. Containerizza l'applicazione ASP.NET Core modernizzata. Questo modello crea un file Docker destinato a Linux in Visual Studio e utilizza Docker Desktop per testarlo localmente. Questo passaggio presuppone che l'applicazione legacy sia già in esecuzione su un'istanza Windows locale o Amazon Elastic Compute Cloud (Amazon EC2). Per ulteriori informazioni, consulta lo schema [Esegui un contenitore Docker dell'API Web ASP.NET Core su un'istanza Amazon EC2 Linux](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html).
1. Distribuisci l'applicazione core ASP.NET modernizzata su Amazon Elastic Container Service (Amazon ECS). Questo modello non copre la fase di implementazione. Per istruzioni, consulta [Amazon ECS Workshop.](https://ecsworkshop.com/)
**Nota**
Questo modello non copre lo sviluppo dell'interfaccia utente, la modernizzazione del database o le fasi di implementazione dei container.
## Prerequisiti e limitazioni
**Prerequisiti**
+ [Visual Studio](https://visualstudio.microsoft.com/downloads/) o [Visual Studio Code](https://code.visualstudio.com/download), scaricato e installato.
+ Accesso a un account AWS utilizzando la Console di gestione AWS e l'AWS Command Line Interface (AWS CLI) versione 2. (Consulta le [istruzioni per configurare l'interfaccia a riga di comando di AWS](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)).
+ AWS Toolkit for Visual Studio ([vedi le istruzioni di configurazione](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html)).
+ Docker Desktop, [scaricato e installato](https://www.docker.com/products/docker-desktop).
+ .NET SDK, [scaricato e installato](https://download.visualstudio.microsoft.com/download/pr/4263dc3b-dc67-4f11-8d46-cc0ae86a232e/66782bbd04c53651f730b2e30a873f18/dotnet-sdk-5.0.203-win-x64.exe).
+ NDepend strumento, [scaricato](https://www.ndepend.com/download) e installato. Per installare l' NDepend estensione per Visual Studio, esegui `NDepend.VisualStudioExtension.Installer` ([vedi istruzioni](https://www.ndepend.com/docs/getting-started-with-ndepend#Part1)). Puoi selezionare Visual Studio 2019 o 2022, a seconda delle tue esigenze.
+ Porting Assistant per .NET, [scaricato](https://aws.amazon.com/porting-assistant-dotnet/) e installato.
## Architecture
**Modernizzazione dell'applicazione del carrello degli acquisti**
Il diagramma seguente illustra il processo di modernizzazione di un'applicazione esistente per il carrello degli acquisti ASP.NET.
![\[Modernizzazione di un'applicazione legacy per il carrello degli acquisti\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/4367e259-9bb3-4eb6-a54d-1c1e2dece7d4.png)
**Architettura Target**
Il diagramma seguente illustra l'architettura dell'applicazione modernizzata per il carrello degli acquisti su AWS. APIs I Web ASP.NET Core vengono distribuiti in un cluster Amazon ECS. I servizi di registrazione e configurazione sono forniti da Amazon CloudWatch Logs e AWS Systems Manager.
![\[Architettura di destinazione per l'applicazione ASP.NET Web Forms su AWS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/36cda8e6-f2cb-4f1a-b37f-fa3045cc5ba1/images/ed6d65ec-0dc9-43ab-ac07-1f172e089399.png)
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) — Amazon Elastic Container Service (Amazon ECS) è un servizio di gestione dei container veloce e altamente scalabile per l'esecuzione, l'arresto e la gestione dei container su un cluster. Puoi eseguire attività e servizi su un'infrastruttura serverless gestita da AWS Fargate. In alternativa, per un maggiore controllo sulla tua infrastruttura, puoi eseguire attività e servizi su un cluster di EC2 istanze da te gestito.
+ [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html): Amazon CloudWatch Logs centralizza i log di tutti i sistemi, le applicazioni e i servizi AWS che utilizzi. Puoi visualizzare e monitorare i log, cercarli per codici o modelli di errore specifici, filtrarli in base a campi specifici o archiviarli in modo sicuro per analisi future.
+ [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ─ AWS Systems Manager è un servizio AWS che puoi usare per visualizzare e controllare la tua infrastruttura su AWS. Utilizzando la console Systems Manager, puoi visualizzare i dati operativi da più servizi AWS e automatizzare le attività operative tra le tue risorse AWS. Systems Manager ti aiuta a mantenere la sicurezza e la conformità scansionando le istanze gestite e segnalando (o adottando azioni correttive) su eventuali violazioni delle policy rilevate.
**Strumenti**
+ [Visual Studio](https://visualstudio.microsoft.com/) o [Visual Studio Code](https://code.visualstudio.com/): strumenti per la creazione di applicazioni.NET APIs, Web e altri programmi.
+ [AWS Toolkit for Visual](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) Studio: un'estensione per Visual Studio che aiuta a sviluppare, eseguire il debug e distribuire applicazioni.NET che utilizzano i servizi AWS.
+ [Docker Desktop](https://www.docker.com/products/docker-desktop): uno strumento che semplifica la creazione e la distribuzione di applicazioni containerizzate.
+ [NDepend](https://www.ndepend.com/features/)— Un analizzatore che monitora il codice.NET per individuare dipendenze, problemi di qualità e modifiche al codice.
+ [Porting Assistant for .NET](https://aws.amazon.com/porting-assistant-dotnet/): strumento di analisi che analizza il codice.NET per identificare le incompatibilità con .NET Core e stimare lo sforzo di migrazione.
## Epiche
### Trasferisci la tua applicazione precedente su.NET 5 o versione successiva
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiorna la tua applicazione.NET Framework legacy a.NET 5. | È possibile utilizzare Porting Assistant for .NET per convertire l'applicazione ASP.NET Web Forms legacy in .NET 5 o versione successiva. Segui le istruzioni contenute nella documentazione di [Porting Assistant for .NET](https://docs.aws.amazon.com/portingassistant/latest/userguide/porting-assistant-getting-started.html). | Sviluppatore di app |
| Genera NDepend report. | Quando modernizzi l'applicazione ASP.NET Web Forms scomponendola in microservizi, potresti non aver bisogno di tutti i file.cs dell'applicazione precedente. È possibile utilizzarlo NDepend per generare un report per qualsiasi file code-behind (.cs), per ottenere tutti i chiamanti e i chiamanti. Questo rapporto consente di identificare e utilizzare solo i file richiesti nei microservizi.Dopo l'installazione NDepend (vedi la sezione [Prerequisiti](#modernize-asp-net-web-forms-applications-on-aws-prereqs)), apri la soluzione (file.sln) per l'applicazione precedente in Visual Studio e segui questi passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Questo processo genera un report per il file code-behind che elenca tutti i chiamanti e i chiamanti. [Per ulteriori informazioni sul grafico delle dipendenze, consulta la documentazione. NDepend ](https://www.ndepend.com/docs/visual-studio-dependency-graph) | Sviluppatore di app |
| Crea una nuova soluzione.NET 5. | Per creare una nuova struttura.NET 5 (o versione successiva) per il tuo sito Web ASP.NET Core modernizzato: APIs[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Per ulteriori informazioni sulla creazione di progetti e soluzioni, consulta la [documentazione di Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/creating-solutions-and-projects).Man mano che si crea la soluzione e si verifica la funzionalità, è possibile identificare diversi file aggiuntivi da aggiungere alla soluzione, oltre ai file NDepend identificati. | Sviluppatore di app |
### Aggiorna il codice dell'applicazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Implementa APIs il web con ASP.NET Core. | *Supponiamo che uno dei microservizi che hai identificato nella tua precedente applicazione per il carrello degli acquisti Monolith sia Products.* Hai creato un nuovo progetto API web ASP.NET Core per *Products* nell'epopea precedente. *In questo passaggio, identifichi e modernizzi tutti i moduli Web (pagine.aspx) correlati ai prodotti.* [Supponiamo che *Products* sia composto da quattro moduli Web, come illustrato in precedenza nella sezione Architettura:](#modernize-asp-net-web-forms-applications-on-aws-architecture)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)È necessario analizzare ogni modulo Web, identificare tutte le richieste inviate al database per eseguire una logica e ottenere risposte. È possibile implementare ogni richiesta come endpoint dell'API Web. Dati i suoi moduli web, *Products* può avere i seguenti endpoint possibili:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Come accennato in precedenza, puoi anche riutilizzare tutti gli altri progetti che hai aggiornato a.NET 5, inclusi Business Logic, Data Access e i progetti. shared/common | Sviluppatore di app |
| Configura Amazon CloudWatch Logs. | Puoi usare [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) per monitorare, archiviare e accedere ai log della tua applicazione. Puoi accedere ai dati in Amazon CloudWatch Logs utilizzando un SDK AWS. [Puoi anche integrare applicazioni.NET con CloudWatch Logs utilizzando i più diffusi framework di logging.NET come [NLog](https://www.nuget.org/packages/AWS.Logger.NLog/)[Log4Net](https://www.nuget.org/packages/AWS.Logger.Log4net/) e il framework di registrazione ASP.NET Core.](https://www.nuget.org/packages/AWS.Logger.AspNetCore/)Per ulteriori informazioni su questo passaggio, consulta il post di blog [Amazon CloudWatch Logs e.NET Logging](https://aws.amazon.com/blogs/developer/amazon-cloudwatch-logs-and-net-logging-frameworks/) Frameworks. | Sviluppatore di app |
| Configura AWS Systems Manager Parameter Store. | Puoi utilizzare [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html) per archiviare le impostazioni dell'applicazione, come le stringhe di connessione, separatamente dal codice dell'applicazione. Il NuGet pacchetto [Amazon.Extensions.Configuration. SystemsManager](https://www.nuget.org/packages/Amazon.Extensions.Configuration.SystemsManager/)semplifica il modo in cui l'applicazione carica queste impostazioni da AWS Systems Manager Parameter Store nel sistema di configurazione .NET Core. Per ulteriori informazioni su questo passaggio, consulta il post del blog [.NET Core configuration provider for AWS Systems Manager](https://aws.amazon.com/blogs/developer/net-core-configuration-provider-for-aws-systems-manager/). | Sviluppatore di app |
### Aggiungi autenticazione e autorizzazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Utilizza un cookie condiviso per l'autenticazione. | La modernizzazione di un'applicazione monolitica legacy è un processo iterativo e richiede la coesistenza del monolito e della sua versione modernizzata. È possibile utilizzare un cookie condiviso per ottenere un'autenticazione senza interruzioni tra le due versioni. L'applicazione ASP.NET legacy continua a convalidare le credenziali dell'utente ed emette il cookie, mentre l'applicazione ASP.NET Core modernizzata convalida il cookie. [Per istruzioni e codice di esempio, consulta il progetto di esempio. GitHub ](https://github.com/aws-samples/dotnet-share-auth-cookie-between-monolith-and-modernized-apps) | Sviluppatore di app |
### Crea ed esegui il contenitore localmente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un'immagine Docker usando Visual Studio. | In questo passaggio, crei un file Docker utilizzando l'API web di Visual Studio for .NET Core.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html)Visual Studio crea un file Docker per il tuo progetto. Per un file Docker di esempio, vedi [Visual Studio Container Tools for Docker sul sito](https://docs.microsoft.com/en-us/visualstudio/containers/overview) Web di Microsoft. | Sviluppatore di app |
| Crea ed esegui il contenitore utilizzando Docker Desktop. | Ora puoi creare, creare ed eseguire il contenitore in Docker Desktop.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/modernize-asp-net-web-forms-applications-on-aws.html) | Sviluppatore di app |
## Risorse correlate
+ [Esegui un contenitore Docker dell'API Web ASP.NET Core su un'istanza Amazon EC2 Linux](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/run-an-asp-net-core-web-api-docker-container-on-an-amazon-ec2-linux-instance.html) (AWS Prescriptive Guidance)
+ [Workshop Amazon ECS](https://ecsworkshop.com/)
+ [Esegui blue/green implementazioni ECS utilizzando CodeDeploy AWS (documentazione CloudFormation AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html)) CloudFormation
+ [Guida introduttiva a (documentazione NDepend](https://www.ndepend.com/docs/getting-started-with-ndepend)) NDepend
+ [Porting Assistant per.NET](https://aws.amazon.com/porting-assistant-dotnet/)
## Informazioni aggiuntive
Le tabelle seguenti forniscono esempi di progetti di esempio per un'applicazione legacy per il carrello degli acquisti e i progetti equivalenti nell'applicazione ASP.NET Core modernizzata.
**Soluzione legacy:**
|
|
| Project name (Nome progetto) | Modello di progetto | Framework Target |
| --- |--- |--- |
| Interfaccia aziendale | Libreria di classi | .NET Framework |
| BusinessLogic | Libreria di classi | .NET Framework |
| WebApplication | Applicazione Web ASP.NET Framework | .NET Framework |
| UnitTests | NUnit Progetto di test | .NET Framework |
| Condiviso -> Comune | Libreria di classi | .NET Framework |
| Condiviso -> Framework | Libreria di classi | .NET Framework |
**Nuova soluzione:**
|
|
| Project name (Nome progetto) | Modello di progetto | Framework Target |
| --- |--- |--- |
| BusinessLogic | Libreria di classi | .NET 5.0 |
| | API Web ASP.NET Core | .NET 5.0 |
| . UnitTests | NUnit Progetto 3 Test | .NET 5.0 |
| Condiviso -> Comune | Libreria di classi | .NET 5.0 |
| Condiviso -> Framework | Libreria di classi | .NET 5.0 |
# Onboarding dei tenant nell'architettura SaaS per il modello a silo utilizzando C\$1 e AWS CDK
*Tabby Ward, Susmitha Reddy Gankidi e Vijai Anand Ramalingam, Amazon Web Services*
## Riepilogo
Le applicazioni Software as a Service (SaaS) possono essere create con una varietà di modelli architettonici diversi. Il *modello a silo* si riferisce a un'architettura in cui ai tenant vengono fornite risorse dedicate.
Le applicazioni SaaS si basano su un modello semplice per introdurre nuovi inquilini nel loro ambiente. Ciò richiede spesso l'orchestrazione di una serie di componenti per fornire e configurare correttamente tutti gli elementi necessari per creare un nuovo tenant. Questo processo, nell'architettura SaaS, viene chiamato onboarding dei tenant. L'onboarding dovrebbe essere completamente automatizzato per ogni ambiente SaaS utilizzando l'infrastruttura come codice nel processo di onboarding.
Questo modello ti guida attraverso un esempio di creazione di un tenant e di provisioning di un'infrastruttura di base per il tenant su Amazon Web Services (AWS). Il modello utilizza C\$1 e AWS Cloud Development Kit (AWS CDK).
Poiché questo modello crea un allarme di fatturazione, consigliamo di implementare lo stack negli Stati Uniti orientali (Virginia settentrionale) o us-east-1, nella regione AWS. Per ulteriori informazioni, consulta la [documentazione di AWS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html).
## Prerequisiti e limitazioni
**Prerequisiti******
+ Un [account AWS](https://aws.amazon.com/account/) attivo.
+ Un principal AWS Identity and Access Management (IAM) con accesso IAM sufficiente per creare risorse AWS per questo modello. Per maggiori informazioni, consulta [Ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
+ [Installa Amazon Command Line Interface (AWS CLI) e configura AWS](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) [CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) per eseguire la distribuzione di AWS CDK.
+ [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) scaricato e installato o [Visual Studio Code](https://code.visualstudio.com/download) scaricato e installato.
+ Configurazione di [AWS Toolkit for Visual](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/setup.html) Studio.
+ [.NET Core 3.1 o versione successiva](https://dotnet.microsoft.com/download/dotnet-core/3.1) (richiesto per le applicazioni C\$1 AWS CDK)
+ [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools) installato.
**Limitazioni******
+ AWS CDK utilizza [AWS CloudFormation](https://aws.amazon.com/cloudformation/), quindi le applicazioni AWS CDK sono soggette a quote di CloudFormation servizio. Per ulteriori informazioni, consulta [AWS CloudFormation quotas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
+ Lo CloudFormation stack tenant viene creato con un ruolo di CloudFormation servizio `infra-cloudformation-role` con caratteri jolly sulle azioni (`sns`\$1 e`sqs*`) ma con risorse limitate al prefisso. `tenant-cluster` Per un caso d'uso di produzione, valuta questa impostazione e fornisci solo l'accesso richiesto a questo ruolo di servizio. La funzione `InfrastructureProvision` Lambda utilizza anche un carattere jolly (`cloudformation*`) per effettuare il provisioning dello CloudFormation stack, ma con risorse limitate al prefisso. `tenant-cluster`
+ La build docker di questo codice di esempio utilizza `--platform=linux/amd64` per forzare le immagini `linux/amd64` basate. Questo per garantire che gli artefatti dell'immagine finale siano adatti a Lambda, che per impostazione predefinita utilizza l'architettura x86-64. Se devi modificare l'architettura Lambda di destinazione, assicurati di modificare sia i codici Dockerfiles che quelli AWS CDK. Per ulteriori informazioni, consulta il post sul blog [Migrazione delle funzioni AWS Lambda su processori AWS Graviton2 basati su ARM](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-to-arm-based-aws-graviton2-processors/).
+ Il processo di eliminazione dello stack non eliminerà i log (gruppi di CloudWatch log e log) generati dallo stack. È necessario pulire manualmente i log tramite la CloudWatch console Amazon della Console di gestione AWS o tramite l'API.
Questo modello è impostato come esempio. Per l'uso in produzione, valuta le seguenti configurazioni e apporta le modifiche in base ai requisiti aziendali:
+ Il bucket [AWS Simple Storage Service (Amazon S3](https://aws.amazon.com/s3/)) in questo esempio non ha il controllo delle versioni abilitato per motivi di semplicità. Valuta e aggiorna la configurazione secondo necessità.
+ Questo esempio configura gli endpoint [dell'API REST di Amazon API Gateway](https://aws.amazon.com/api-gateway/) senza autenticazione, autorizzazione o limitazione per motivi di semplicità. Per l'uso in produzione, consigliamo di integrare il sistema con l'infrastruttura di sicurezza aziendale. Valuta questa impostazione e aggiungi le impostazioni di sicurezza richieste, se necessario.
+ Per questo esempio di infrastruttura tenant, [Amazon Simple Notification Service (Amazon SNS) e Amazon Simple](https://aws.amazon.com/sns/) [Queue Service (Amazon SQS) hanno solo configurazioni](https://aws.amazon.com/sqs/) minime. [L'[AWS Key Management Service (AWS KMS)](https://aws.amazon.com/kms/) per ogni tenant consente di utilizzare i servizi [Amazon](https://aws.amazon.com/cloudwatch/) e Amazon CloudWatch SNS dell'account in base alla policy delle chiavi AWS KMS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-key-management.html#compatibility-with-aws-services) La configurazione è solo un esempio di segnaposto. Modifica le configurazioni secondo necessità in base al tuo caso d'uso aziendale.
+ L'intera configurazione, che include, a titolo esemplificativo ma non esaustivo, gli endpoint delle API e il provisioning e l'eliminazione dei tenant di backend tramite AWS CloudFormation, copre solo il caso base di happy path. Valuta e aggiorna la configurazione con la logica di riprova necessaria, la logica di gestione degli errori aggiuntiva e la logica di sicurezza in base alle tue esigenze aziendali.
+ Il codice di esempio viene testato con up-to-date [cdk-nag](https://github.com/cdklabs/cdk-nag) per verificare le politiche al momento della stesura di questo documento. In futuro potrebbero essere applicate nuove politiche. Queste nuove politiche potrebbero richiedere la modifica manuale dello stack in base ai consigli prima di poter implementare lo stack. Esamina il codice esistente per assicurarti che sia in linea con i requisiti aziendali.
+ Il codice si basa sul CDK AWS per generare un suffisso casuale anziché affidarsi a nomi fisici assegnati statici per la maggior parte delle risorse create. Questa configurazione serve a garantire che queste risorse siano uniche e non entrino in conflitto con altri stack. Per ulteriori informazioni, consulta la [documentazione di AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/resources.html#resources_physical_names). Adattalo in base alle tue esigenze aziendali.
+ [Questo codice di esempio impacchetta gli artefatt.NET Lambda in immagini basate su Docker e viene eseguito con il runtime dell'immagine Container fornito da Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/csharp-image.html) Il runtime dell'immagine del contenitore presenta vantaggi per i meccanismi standard di trasferimento e archiviazione (registri dei contenitori) e per ambienti di test locali più accurati (tramite l'immagine del contenitore). Puoi cambiare il progetto in modo che utilizzi i [runtime.NET forniti da Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-csharp.html) per ridurre il tempo di compilazione delle immagini Docker, ma dovrai quindi configurare meccanismi di trasferimento e archiviazione e assicurarti che la configurazione locale corrisponda alla configurazione Lambda. Modifica il codice per allinearlo ai requisiti aziendali degli utenti.
**Versioni del prodotto**
+ AWS CDK versione 2.45.0 o successiva
+ Visual Studio 2022
## Architecture
**Stack tecnologico**
+ Gateway Amazon API
+ AWS CloudFormation
+ Amazon CloudWatch
+ Amazon DynamoDB
+ AWS Identity and Access Management (IAM)
+ AWS KMS
+ AWS Lambda
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
+ Amazon SQS
**Architettura**
Il diagramma seguente mostra il flusso di creazione dello stack dei tenant. *Per ulteriori informazioni sugli stack tecnologici control-plane e tenant, consultate la sezione Informazioni aggiuntive.*
![\[Flusso di lavoro per creare un tenant e fornire un'infrastruttura di base per il tenant su AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/5baef800-fe39-4eb8-b11d-2c23eb3175fc/images/0b579484-b87c-4acb-8c60-8c33c18370e3.png)
**Flusso di creazione dello stack dei tenant**
1. L'utente invia una richiesta API POST con un nuovo payload del tenant (nome del tenant, descrizione del tenant) in JSON a un'API REST ospitata da Amazon API Gateway. L'API Gateway elabora la richiesta e la inoltra alla funzione backend Lambda Tenant Onboarding. In questo esempio, non esiste alcuna autorizzazione o autenticazione. In una configurazione di produzione, questa API deve essere integrata con il sistema di sicurezza dell'infrastruttura SaaS.
1. La funzione Tenant Onboarding verifica la richiesta. Quindi tenta di archiviare il record del tenant, che include il nome del tenant, l'identificatore univoco universale (UUID) generato dal tenant e la descrizione del tenant, nella tabella di onboarding dei tenant di Amazon DynamoDB.
1. Dopo che DynamoDB ha archiviato il record, un flusso DynamoDB avvia la funzione downstream Lambda Tenant Infrastructure.
1. La funzione Tenant Infrastructure Lambda agisce in base al flusso DynamoDB ricevuto. Se lo stream è destinato all'evento INSERT, la funzione utilizza la NewImage sezione dello stream (ultimo record di aggiornamento, campo Tenant Name) per richiamare CloudFormation la creazione di una nuova infrastruttura tenant utilizzando il modello archiviato nel bucket S3. Il CloudFormation modello richiede il parametro Tenant Name.
1. AWS CloudFormation crea l'infrastruttura tenant in base al CloudFormation modello e ai parametri di input.
1. Ogni configurazione dell'infrastruttura tenant presenta un CloudWatch allarme, un allarme di fatturazione e un evento di allarme.
1. L'evento di allarme diventa un messaggio a un argomento SNS, che viene crittografato dalla chiave AWS KMS del tenant.
1. L'argomento SNS inoltra il messaggio di allarme ricevuto alla coda SQS, che viene crittografata dalla chiave di crittografia AWS KMS for encryption del tenant.
Altri sistemi possono essere integrati con Amazon SQS per eseguire azioni basate sui messaggi in coda. In questo esempio, per mantenere il codice generico, i messaggi in arrivo rimangono in coda e richiedono l'eliminazione manuale.
**Flusso di eliminazione dello stack dei tenant**
1. L'utente invia una richiesta API DELETE con un nuovo payload del tenant (nome del tenant, descrizione del tenant) in JSON all'API REST ospitata da Amazon API Gateway, che elaborerà la richiesta e la inoltrerà alla funzione Tenant Onboarding. In questo esempio, non esiste alcuna autorizzazione o autenticazione. In una configurazione di produzione, questa API sarà integrata con il sistema di sicurezza dell'infrastruttura SaaS.
1. La funzione Tenant Onboarding verificherà la richiesta e quindi tenterà di eliminare il record del tenant (nome del tenant) dalla tabella Tenant Onboarding.
1. Dopo che DynamoDB ha eliminato correttamente il record (il record esiste nella tabella e viene eliminato), un flusso DynamoDB avvia la funzione downstream Lambda Tenant Infrastructure.
1. La funzione Tenant Infrastructure Lambda agisce in base al record di flusso DynamoDB ricevuto. Se lo stream è destinato all'evento REMOVE, la funzione utilizza la OldImage sezione del record (informazioni sul record e campo Tenant Name, prima dell'ultima modifica, ovvero delete) per avviare l'eliminazione di uno stack esistente in base alle informazioni di quel record.
1. AWS CloudFormation elimina lo stack di tenant di destinazione in base all'input.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ti aiuta a creare, pubblicare, gestire, monitorare e proteggere REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) è un framework di sviluppo software che aiuta a definire e fornire l'infrastruttura cloud AWS in codice.
+ [AWS CDK Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) è un kit di sviluppo cloud a riga di comando che ti aiuta a interagire con l'app AWS Cloud Development Kit (AWS CDK).
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che ti aiuta a interagire con i servizi AWS tramite comandi nella tua shell a riga di comando.
+ [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ti CloudFormation aiuta a configurare le risorse AWS, effettuarne il provisioning in modo rapido e coerente e gestirle durante tutto il loro ciclo di vita su account e regioni AWS.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue risorse AWS controllando chi è autenticato e autorizzato a utilizzarle.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ti aiuta a creare e controllare chiavi crittografiche per proteggere i tuoi dati.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di elaborazione che ti aiuta a eseguire codice senza dover fornire o gestire server. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di calcolo che utilizzi.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
+ [Amazon Simple Notification Service (Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)) ti aiuta a coordinare e gestire lo scambio di messaggi tra editori e clienti, inclusi server Web e indirizzi e-mail.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fornisce una coda ospitata sicura, durevole e disponibile che ti aiuta a integrare e disaccoppiare sistemi e componenti software distribuiti.
+ [AWS Toolkit for Visual](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) Studio è un plug-in per l'ambiente di sviluppo integrato (IDE) di Visual Studio. Il Toolkit for Visual Studio supporta lo sviluppo, il debug e la distribuzione di applicazioni.NET che utilizzano i servizi AWS.
**Altri strumenti**
+ [Visual Studio](https://docs.microsoft.com/en-us/visualstudio/ide/whats-new-visual-studio-2022?view=vs-2022) è un IDE che include compilatori, strumenti di completamento del codice, progettisti grafici e altre funzionalità che supportano lo sviluppo del software.
**Codice**
Il codice per questo pattern si trova nel repository [Tenant onboarding in SaaS Architecture for Silo Model APG](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example) Example.
## Epiche
### Configura AWS CDK
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Verifica l'installazione di Node.js. | Per verificare che Node.js sia installato sul computer locale, esegui il comando seguente.node --version
| Amministratore AWS, AWS DevOps |
| Installa AWS CDK Toolkit. | Per installare AWS CDK Toolkit sul tuo computer locale, esegui il comando seguente.npm install -g aws-cdk
[Se npm non è installato, puoi installarlo dal sito Node.js.](https://nodejs.org/en/download/package-manager/) | Amministratore AWS, AWS DevOps |
| Verifica la versione di AWS CDK Toolkit. | Per verificare che la versione di AWS CDK Toolkit sia installata correttamente sul computer, esegui il comando seguente. cdk --version
| Amministratore AWS, AWS DevOps |
### Rivedi il codice per il piano di controllo dell'onboarding dei tenant
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Clona il [repository](https://github.com/aws-samples/tenant-onboarding-in-saas-architecture-for-silo-model-apg-example) e accedi alla `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example` cartella.In Visual Studio 2022, apri la `\src\TenantOnboardingInfra.sln` soluzione. Apri il `TenantOnboardingInfraStack.cs` file e rivedi il codice.Le seguenti risorse vengono create come parte di questo stack:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Amministratore AWS, AWS DevOps |
| Esamina il CloudFormation modello. | Nella `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\template` cartella`infra.yaml`, apri e rivedi il CloudFormation modello. Questo modello verrà idratato con il nome del tenant recuperato dalla tabella DynamoDB di onboarding del tenant.Il modello fornisce l'infrastruttura specifica del tenant. In questo esempio, effettua il provisioning della chiave AWS KMS, Amazon SNS, Amazon SQS e dell'allarme. CloudWatch | Sviluppatore di app, AWS DevOps |
| Esamina la funzione di onboarding dei tenant. | Apri `Function.cs` e rivedi il codice per la funzione di onboarding dei tenant, creata con il modello Visual Studio AWS Lambda Project (.NET Core- C\$1) con il blueprint .NET 6 (Container Image).Apri e rivedi il codice. `Dockerfile` `Dockerfile`È un file di testo che contiene istruzioni per creare l'immagine del contenitore Lambda.Nota che i seguenti NuGet pacchetti vengono aggiunti come dipendenze al `TenantOnboardingFunction` progetto:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Sviluppatore di app, AWS DevOps |
| Esamina la InfraProvisioning funzione Tenant. | Accedi a `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\InfraProvisioningFunction`.Apri `Function.cs` ed esamina il codice per la funzione di provisioning dell'infrastruttura tenant, creata con il modello Visual Studio AWS Lambda Project (.NET Core- C\$1) con il blueprint .NET 6 (Container Image).Apri e rivedi il `Dockerfile` codice. Nota che i seguenti NuGet pacchetti vengono aggiunti come dipendenze al `InfraProvisioningFunction` progetto:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Sviluppatore di app, AWS DevOps |
### Implementa le risorse AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea la soluzione. | Per creare la soluzione, effettuate le seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Assicurati di aggiornare il `Amazon.CDK.Lib NuGet` pacchetto alla versione più recente del `\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example\src\TenantOnboardingInfra` progetto prima di creare la soluzione. | Sviluppatore di app |
| Esegui il bootstrap dell'ambiente AWS CDK. | Apri il prompt dei comandi di Windows e accedi alla cartella principale dell'app AWS CDK in cui è disponibile il `cdk.json` file ()`\tenant-onboarding-in-saas-architecture-for-silo-model-apg-example`. Esegui il seguente comando per il bootstrap.cdk bootstrap
Se hai creato un profilo AWS per le credenziali, usa il comando con il tuo profilo.cdk bootstrap --profile
| Amministratore AWS, AWS DevOps |
| Elenca gli stack CDK AWS. | Per elencare tutti gli stack da creare nell'ambito di questo progetto, esegui il comando seguente.cdk ls
cdk ls --profile
Se hai creato un profilo AWS per le credenziali, usa il comando con il tuo profilo.cdk ls --profile
| Amministratore AWS, AWS DevOps |
| Verifica quali risorse AWS verranno create. | Per esaminare tutte le risorse AWS che verranno create nell'ambito di questo progetto, esegui il comando seguente.cdk diff
Se hai creato un profilo AWS per le credenziali, usa il comando con il tuo profilo.cdk diff --profile
| Amministratore AWS, AWS DevOps |
| Distribuisci tutte le risorse AWS utilizzando AWS CDK. | Per distribuire tutte le risorse AWS esegui il seguente comando.cdk deploy --all --require-approval never
Se hai creato un profilo AWS per le credenziali, usa il comando con il tuo profilo.cdk deploy --all --require-approval never --profile
Una volta completata la distribuzione, copia l'URL dell'API dalla sezione degli output del prompt dei comandi, come mostrato nell'esempio seguente.Outputs:
TenantOnboardingInfraStack.TenantOnboardingAPIEndpoint42E526D7 = https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/
| Amministratore AWS, AWS DevOps |
### Verifica la funzionalità
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un nuovo inquilino. | Per creare il nuovo tenant, invia la seguente richiesta curl.curl -X POST tenant -d '{"Name":"Tenant123", "Description":"Stack for Tenant123"}'
Cambia il `` segnaposto con il valore effettivo di AWS CDK, come mostrato nell'esempio seguente.curl -X POST https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant -d '{"Name":"Tenant123", "Description":"test12"}'L'esempio seguente mostra l'output.{"message": "A new tenant added - 5/4/2022 7:11:30 AM"} | Sviluppatore di app, amministratore AWS, AWS DevOps |
| Verifica i dettagli del tenant appena creato in DynamoDB. | Per verificare i dettagli del tenant appena creato in DynamoDB, procedi nel seguente modo.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Sviluppatore di app, amministratore AWS, AWS DevOps |
| Verifica la creazione dello stack per il nuovo tenant. | Verifica che il nuovo stack sia stato creato correttamente e dotato dell'infrastruttura per il tenant appena creato in base al modello. CloudFormation [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Sviluppatore di app, amministratore AWS, AWS DevOps |
| Elimina lo stack dei tenant. | Per eliminare lo stack dei tenant, invia la seguente richiesta curl.curl -X DELETE tenant/
Cambia il `` segnaposto con il valore effettivo da AWS CDK e passa `` al valore effettivo della precedente fase di creazione del tenant, come mostrato nell'esempio seguente.curl -X DELETE https://j2qmp8ds21i1i.execute-api.us-west-2.amazonaws.com/prod/tenant/Tenant123
L'esempio seguente mostra l'output.{"message": "Tenant destroyed - 5/4/2022 7:14:48 AM"} | Sviluppatore di app, AWS DevOps, amministratore AWS |
| Verifica l'eliminazione dello stack per il tenant esistente. | Per verificare che lo stack di tenant esistente sia stato eliminato, effettuate le seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) | Sviluppatore di app, amministratore AWS, AWS DevOps |
### Eliminazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Distruggi l'ambiente. | Prima di ripulire lo stack, assicurati quanto segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)Al termine del test, è possibile utilizzare AWS CDK per distruggere tutti gli stack e le risorse correlate eseguendo il comando seguente.cdk destroy --all;
Se hai creato un profilo AWS per le credenziali, usa il profilo.Conferma la richiesta di eliminazione dello stack per eliminare lo stack. | Amministratore AWS, AWS DevOps |
| Pulisci Amazon CloudWatch Logs. | Il processo di eliminazione dello stack non eliminerà CloudWatch i log (gruppi di log e log) generati dallo stack. Pulisci manualmente CloudWatch le risorse utilizzando la CloudWatch console o l'API. | Sviluppatore di app, AWS DevOps, amministratore AWS |
## Risorse correlate
+ [Workshop AWS CDK.NET](https://cdkworkshop.com/40-dotnet.html)
+ [Lavorare con AWS CDK in C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [Riferimento CDK.NET](https://docs.aws.amazon.com/cdk/api/v2/dotnet/api/index.html)
## Informazioni aggiuntive
**Stack tecnologico Control-Plane**
Il codice CDK scritto in .NET viene utilizzato per effettuare il provisioning dell'infrastruttura del piano di controllo, che comprende le seguenti risorse:
1. **API Gateway**
Funge da punto di ingresso dell'API REST per lo stack del piano di controllo.
1. **Funzione Lambda di onboarding dei tenant**
Questa funzione Lambda viene avviata da API Gateway utilizzando il metodo m.
Una richiesta API del metodo POST comporta l'inserimento di (`tenant name`,`tenant description`) nella tabella `Tenant Onboarding` DynamoDB.
In questo esempio di codice, il nome del tenant viene utilizzato anche come parte del nome dello stack del tenant e dei nomi delle risorse all'interno di tale stack. Questo serve a facilitare l'identificazione di queste risorse. Il nome del tenant deve essere univoco in tutta la configurazione per evitare conflitti o errori. La configurazione dettagliata della convalida degli input è spiegata nella documentazione dei [ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) e nella sezione *Limitazioni*.
Il processo di persistenza nella tabella DynamoDB avrà esito positivo solo se il nome del tenant non viene utilizzato in nessun altro record della tabella.
Il nome del tenant in questo caso è la chiave di partizione per questa tabella, poiché solo la chiave di partizione può essere utilizzata come espressione di condizione. `PutItem`
Se il nome del tenant non è mai stato registrato prima, il record verrà salvato correttamente nella tabella.
Tuttavia, se il nome del tenant è già utilizzato da un record esistente nella tabella, l'operazione avrà esito negativo e avvierà un'eccezione DynamoDB. `ConditionalCheckFailedException` L'eccezione verrà utilizzata per restituire un messaggio di errore (`HTTP BadRequest`) che indica che il nome del tenant esiste già.
Una richiesta API di `DELETE` metodo rimuoverà il record per un nome di tenant specifico dalla tabella `Tenant Onboardin` g.
L'eliminazione del record DynamoDB in questo esempio avrà esito positivo anche se il record non esiste.
Se il record di destinazione esiste e viene eliminato, creerà un record di flusso DynamoDB. In caso contrario, non verrà creato alcun record downstream.
1. **Onboarding di DynamoDB da parte dei tenant, con Amazon DynamoDB Streams abilitato**
Questo registra le informazioni sui metadati del tenant e qualsiasi salvataggio o eliminazione di record invierà un flusso a valle alla funzione `Tenant Infrastructure` Lambda.
1. **Funzione Lambda dell'infrastruttura tenant**
Questa funzione Lambda viene avviata dal record di flusso DynamoDB del passaggio precedente. Se il record riguarda un `INSERT` evento, richiama AWS per CloudFormation creare una nuova infrastruttura tenant con il CloudFormation modello archiviato in un bucket S3. Se il record è for`REMOVE`, avvia l'eliminazione di uno stack esistente in base al campo del record dello stream. `Tenant Name`
1. **Bucket S3**
Serve per memorizzare il modello. CloudFormation
1. **Ruoli IAM per ogni funzione Lambda e un ruolo di servizio per CloudFormation**
Ogni funzione Lambda ha il suo ruolo IAM unico con autorizzazioni con [privilegi minimi](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) per svolgere il proprio compito. Ad esempio, la funzione `Tenant On-boarding` Lambda ha read/write accesso a DynamoDB e la funzione `Tenant Infrastructure` Lambda può leggere solo il flusso DynamoDB.
Viene creato un ruolo di CloudFormation servizio personalizzato per il provisioning dello stack dei tenant. Questo ruolo di servizio contiene autorizzazioni aggiuntive per il provisioning CloudFormation dello stack (ad esempio, la chiave AWS KMS). Questo divide i ruoli tra Lambda CloudFormation ed evita tutte le autorizzazioni su un singolo ruolo (ruolo Infrastructure Lambda).
Le autorizzazioni che consentono azioni potenti (come la creazione e l'eliminazione di CloudFormation pile) sono bloccate e consentite solo per le risorse che iniziano con. `tenantcluster-` L'eccezione è AWS KMS, a causa della sua convenzione di denominazione delle risorse. Il nome del tenant importato dall'API verrà aggiunto `tenantcluster-` insieme ad altri controlli di convalida (alfanumerico con solo trattino e limitato a meno di 30 caratteri per adattarsi alla maggior parte dei nomi delle risorse AWS). Ciò garantisce che il nome del tenant non comporti accidentalmente l'interruzione degli stack o delle risorse dell'infrastruttura di base.
**Stack tecnologico Tenant**
Un CloudFormation modello è archiviato nel bucket S3. [Il modello fornisce la chiave AWS KMS specifica del tenant, un CloudWatch allarme, un argomento SNS, una coda SQS e una policy SQS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-using-identity-based-policies.html)
La chiave AWS KMS viene utilizzata per la crittografia dei dati da Amazon SNS e Amazon SQS per i loro messaggi. Le pratiche di sicurezza per [AwsSolutionsSNS2 e AwsSolutions SQS2](https://github.com/cdklabs/cdk-nag/blob/main/RULES.md) consigliano di configurare Amazon SNS e Amazon SQS con crittografia. Tuttavia, gli CloudWatch allarmi non funzionano con Amazon SNS quando si utilizza una chiave gestita da AWS, quindi in questo caso è necessario utilizzare una chiave gestita dal cliente. Per ulteriori informazioni, consulta l'[AWS Knowledge Center](https://aws.amazon.com/premiumsupport/knowledge-center/cloudwatch-receive-sns-for-alarm-trigger/).
La policy SQS viene utilizzata nella coda Amazon SQS per consentire all'argomento SNS creato di recapitare il messaggio alla coda. Senza la policy SQS, l'accesso verrà negato. Per ulteriori informazioni, consulta la documentazione di [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/subscribe-sqs-queue-to-sns-topic.html#SendMessageToSQS.sqs.permissions).
# Scomponi i monoliti in microservizi utilizzando CQRS e l'event sourcing
*Rodolfo Junior Cerrada, Dmitry Gulin e Tabby Ward, Amazon Web Services*
## Riepilogo
Questo modello combina due modelli, utilizzando sia il pattern CQRS (Command Query Responsibility Separation) che il pattern di approvvigionamento degli eventi. Il pattern CQRS separa le responsabilità dei modelli di comando e di interrogazione. Il pattern di approvvigionamento degli eventi sfrutta la comunicazione asincrona basata sugli eventi per migliorare l'esperienza utente complessiva.
Puoi utilizzare i servizi CQRS e Amazon Web Services (AWS) per mantenere e scalare ogni modello di dati in modo indipendente, rifattorizzando al contempo la tua applicazione monolitica in un'architettura di microservizi. È quindi possibile utilizzare il pattern di approvvigionamento degli eventi per sincronizzare i dati dal database dei comandi al database delle query.
Questo modello utilizza un codice di esempio che include un file di soluzione (\$1.sln) che è possibile aprire utilizzando l'ultima versione di Visual Studio. L'esempio contiene il codice API Reward per mostrare come funzionano CQRS e l'event sourcing nelle applicazioni serverless e tradizionali o locali di AWS.
[Per ulteriori informazioni su CQRS e l'approvvigionamento di eventi, consulta la sezione Informazioni aggiuntive.](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional)
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ Amazon CloudWatch
+ Tabelle Amazon DynamoDB
+ Amazon DynamoDB Streams
+ Chiave di accesso e chiave segreta di AWS Identity and Access Management (IAM); per ulteriori informazioni, guarda il video nella sezione *Risorse correlate*
+ AWS Lambda
+ Familiarità con Visual Studio
+ *Familiarità con AWS Toolkit for Visual Studio; per ulteriori informazioni, guarda *il video dimostrativo di AWS Toolkit for Visual Studio* nella sezione Risorse correlate*
**Versioni del prodotto**
+ [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/).
+ [AWS Toolkit per Visual Studio 2019](https://aws.amazon.com/visualstudio/).
+ .NET Core 3.1. Questo componente è un'opzione nell'installazione di Visual Studio. Per includere.NET Core durante l'installazione, seleziona **lo sviluppo multipiattaforma NET Core**.
**Limitazioni**
+ Il codice di esempio per un'applicazione locale tradizionale (API Web ASP.NET Core e oggetti di accesso ai dati) non viene fornito con un database. Tuttavia, viene fornito con l'oggetto `CustomerData` in memoria, che funge da database fittizio. Il codice fornito è sufficiente per testare il modello.
## Architecture
**Stack di tecnologia di origine**
+ Progetto API Web ASP.NET Core
+ Server Web IIS
+ Oggetto di accesso ai dati
+ Modello CRUD
**Architettura di origine**
Nell'architettura di origine, il modello CRUD contiene interfacce di comando e di interrogazione in un'unica applicazione. Per un esempio di codice, vedere `CustomerDAO.cs` (allegato).
![\[Connessioni tra applicazione, interfaccia di servizio, modello CRUD del cliente e database.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1cd3a84c-12c7-4306-99aa-23f2c53d3cd3.png)
**Stack tecnologico Target**
+ Amazon DynamoDB
+ Amazon DynamoDB Streams
+ AWS Lambda
+ (Opzionale) Amazon API Gateway
+ (Opzionale) Amazon Simple Notification Service (Amazon SNS)
**Architettura Target**
Nell'architettura di destinazione, le interfacce di comando e di interrogazione sono separate. L'architettura mostrata nel diagramma seguente può essere estesa con API Gateway e Amazon SNS. Per ulteriori informazioni, consulta la sezione [Informazioni aggiuntive](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional).
![\[Connessione delle applicazioni con microservizi Customer Command e Customer Query senza server.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/1c665697-e3ac-4ef4-98d0-86c2cbf164c1.png)
1. Le funzioni Command Lambda eseguono operazioni di scrittura, come creare, aggiornare o eliminare, sul database.
1. Le funzioni Query Lambda eseguono operazioni di lettura, come get o select, sul database.
1. Questa funzione Lambda elabora i flussi DynamoDB dal database Command e aggiorna il database Query per le modifiche.
## Tools (Strumenti)
**Strumenti**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) — Amazon DynamoDB è un servizio di database NoSQL completamente gestito che offre prestazioni veloci e prevedibili con una scalabilità perfetta.
+ [Amazon DynamoDB Streams — DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) acquisisce una sequenza ordinata nel tempo di modifiche a livello di elemento in qualsiasi tabella DynamoDB. Quindi memorizza queste informazioni in un registro per un massimo di 24 ore. La crittografia a riposo crittografa i dati in DynamoDB Streams.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): AWS Lambda è un servizio di elaborazione che supporta l'esecuzione di codice senza effettuare il provisioning o la gestione di server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo. Verrà addebitato soltanto il tempo di calcolo consumato e non verrà addebitato alcun costo quando il codice non è in esecuzione.
+ [Console di gestione AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/learn-whats-new.html): la Console di gestione AWS è un'applicazione Web che comprende un'ampia raccolta di console di servizio per la gestione dei servizi AWS.
+ [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/) — Visual Studio 2019 è un ambiente di sviluppo integrato (IDE). La Community Edition è gratuita per i contributori open source. In questo modello, utilizzerai Visual Studio 2019 Community Edition per aprire, compilare ed eseguire codice di esempio. Solo per la visualizzazione, puoi utilizzare qualsiasi editor di testo o [Visual Studio Code.](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html)
+ [AWS Toolkit for Visual](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html) Studio — AWS Toolkit for Visual Studio è un plug-in per l'IDE di Visual Studio. AWS Toolkit for Visual Studio semplifica lo sviluppo, il debug e la distribuzione di applicazioni.NET che utilizzano i servizi AWS.
**Codice**
Il codice di esempio è allegato. Per istruzioni sulla distribuzione del codice di esempio, consulta la sezione *Epics*.
## Epiche
### Apri e crea la soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aprire la soluzione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app |
| Crea la soluzione. | Apri il menu contestuale (fai clic con il pulsante destro del mouse) per la soluzione, quindi scegli **Crea soluzione**. Questo creerà e compilerà tutti i progetti della soluzione. Dovrebbe essere compilato correttamente.Visual Studio Solution Explorer dovrebbe mostrare la struttura delle cartelle.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app |
### Crea le tabelle DynamoDB
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Fornire le credenziali. | Se non disponi ancora di una chiave di accesso, guarda il video nella sezione *Risorse correlate*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app, ingegnere dei dati, DBA |
| Compilare il progetto. | **Per creare il progetto, apri il menu contestuale (fai clic con il pulsante destro del mouse) per il progetto **aws.apg.cqrses.BUILD**, quindi scegli Build.** | Sviluppatore di app, ingegnere dei dati, DBA |
| Crea e popola le tabelle. | ****Per creare le tabelle e popolarle con i dati iniziali, apri il menu contestuale (fai clic con il pulsante destro del mouse) per il progetto **aws.apg.cqrses.Build**, quindi scegli Debug, Avvia nuova istanza.**** | Sviluppatore di app, ingegnere dei dati, DBA |
| Verifica la struttura della tabella e i dati. | Per verificare, accedi ad **AWS Explorer** ed espandi **Amazon DynamoDB**. Dovrebbe visualizzare le tabelle. Apri ogni tabella per visualizzare i dati di esempio. | Sviluppatore di app, ingegnere dei dati, DBA |
### Esegui test locali
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Costruisci il progetto CQRS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app, tecnico di test |
| Crea il progetto di event-sourcing. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app, tecnico di test |
| Esegui i test. | Per eseguire tutti i test, scegli **Visualizza**, **Test Explorer**, quindi scegli **Esegui tutti i test in visualizzazione**. Tutti i test devono essere superati, come indicato da un'icona verde con un segno di spunta. | Sviluppatore di app, tecnico di test |
### Pubblica le funzioni CQRS Lambda in AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Pubblica la prima funzione Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app, DevOps ingegnere |
| Verifica il caricamento della funzione. | (Facoltativo) Puoi verificare che la funzione sia stata caricata correttamente accedendo ad AWS Explorer ed espandendo **AWS** Lambda. Per aprire la finestra di test, scegliete la funzione Lambda (doppio clic). | Sviluppatore di app, ingegnere DevOps |
| Prova la funzione Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Tutti i progetti CQRS Lambda si trovano nelle cartelle ` CQRS AWS Serverless\CQRS\Command Microservice` e `CQRS AWS Serverless\CQRS\Command Microservice` solution. Per la directory e i progetti della soluzione, vedete **Directory del codice sorgente** nella sezione [Informazioni aggiuntive](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Sviluppatore di app, DevOps ingegnere |
| Pubblica le funzioni rimanenti. | Ripetete i passaggi precedenti per i seguenti progetti:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app, DevOps ingegnere |
### Configura la funzione Lambda come ascoltatore di eventi
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Pubblica i gestori di eventi Customer and Reward Lambda. | Per pubblicare ogni gestore di eventi, segui i passaggi dell'epopea precedente.I progetti si trovano nelle cartelle `CQRS AWS Serverless\Event Source\Customer Event` e `CQRS AWS Serverless\Event Source\Reward Event` solution. Per ulteriori informazioni, consulta la *directory del codice sorgente* nella sezione [Informazioni aggiuntive](#decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing-additional). | Sviluppatore di app |
| Collega il listener di eventi Lambda event-sourcing. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html)Dopo che il listener è stato collegato correttamente alla tabella DynamoDB, verrà visualizzato nella pagina di progettazione Lambda. | Sviluppatore di app |
| Pubblica e allega la funzione EventSourceReward Lambda. | Per pubblicare e allegare la funzione `EventSourceReward` Lambda, ripeti i passaggi delle due storie precedenti, selezionando **cqrses-reward-cmd**dall'elenco a discesa della tabella **DynamoDB**. | Sviluppatore di app |
### Testa e convalida i flussi DynamoDB e il trigger Lambda
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Prova lo stream e il trigger Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app |
| Convalida utilizzando la tabella delle query di ricompensa di DynamodDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app |
| Convalida, utilizzando i registri. CloudWatch | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.html) | Sviluppatore di app |
| Convalida il trigger. EventSourceCustomer | Per convalidare il `EventSourceCustomer` trigger, ripeti i passaggi di questa epopea, utilizzando la tabella dei clienti e i registri relativi al `EventSourceCustomer` trigger. CloudWatch | Sviluppatore di app |
## Risorse correlate
**Riferimenti**
+ [Download di Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/downloads/)
+ [Scarica AWS Toolkit per Visual Studio](https://aws.amazon.com/visualstudio/)
+ [Guida per l'utente di AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html)
+ [Serverless su AWS](https://aws.amazon.com/serverless/)
+ [Casi d'uso e modelli di progettazione di DynamoDB](https://aws.amazon.com/blogs/database/dynamodb-streams-use-cases-and-design-patterns/)
+ [Martin Fowler CQRS](https://martinfowler.com/bliki/CQRS.html)
+ [Fornitura di eventi Martin Fowler](https://martinfowler.com/eaaDev/EventSourcing.html)
**Video**
+ [Demo di AWS Toolkit per Visual Studio](https://www.youtube.com/watch?v=B190tcu1ERk)
+ [Come posso creare un ID di chiave di accesso per un nuovo utente IAM?](https://www.youtube.com/watch?v=665RYobRJDY)
## Informazioni aggiuntive
**CQRS e sourcing di eventi**
*CQRS*
Il pattern CQRS separa un singolo modello di operazioni concettuali, ad esempio un modello CRUD (create, read, update, delete) a oggetti di accesso ai dati, in modelli di operazioni di comando e interrogazione. Il modello di comando si riferisce a qualsiasi operazione, come la creazione, l'aggiornamento o l'eliminazione, che modifica lo stato. Il modello di interrogazione si riferisce a qualsiasi operazione che restituisce un valore.
![\[Architettura con interfaccia di servizio, modello CRUD e database.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/3f64756d-681e-4f0e-8034-746263d857b2.png)
1. Il modello Customer CRUD include le seguenti interfacce:
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
Man mano che le tue esigenze diventano più complesse, puoi passare da questo approccio a modello singolo. CQRS utilizza un modello di comandi e un modello di interrogazione per separare la responsabilità della scrittura e della lettura dei dati. In questo modo, i dati possono essere mantenuti e gestiti in modo indipendente. Con una chiara separazione delle responsabilità, i miglioramenti apportati a ciascun modello non influiscono sull'altro. Questa separazione migliora la manutenzione e le prestazioni e riduce la complessità dell'applicazione man mano che cresce.
![\[L'applicazione si è divisa in modelli di comando e query, condividendo un unico database.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/12db023c-eb81-4c27-bbb9-b085b13176ae.png)
1. Interfacce nel modello Customer Command:
+ `Create Customer()`
+ `UpdateCustomer()`
+ `DeleteCustomer()`
+ `AddPoints()`
+ `RedeemPoints()`
1. Interfacce nel modello Customer Query:
+ `GetVIPCustomers()`
+ `GetCustomerList()`
+ `GetCustomerPoints()`
+ `GetMonthlyStatement()`
Per un esempio di codice, vedi *Directory del codice sorgente*.
Il pattern CQRS quindi disaccoppia il database. Questo disaccoppiamento porta alla totale indipendenza di ogni servizio, che è l'ingrediente principale dell'architettura dei microservizi.
![\[Database separati per modelli di comando e interrogazione.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/016dbfa8-3bd8-42ee-afa1-38a98986c7d5.png)
Utilizzando CQRS nel cloud AWS, puoi ottimizzare ulteriormente ogni servizio. Ad esempio, puoi impostare diverse impostazioni di elaborazione o scegliere tra un microservizio serverless o basato su container. Puoi sostituire la memorizzazione nella cache locale con Amazon. ElastiCache Se disponi di una publish/subscribe messaggistica locale, puoi sostituirla con Amazon Simple Notification Service (Amazon SNS). Inoltre, puoi sfruttare pay-as-you-go i prezzi e l'ampia gamma di servizi AWS che paghi solo per ciò che usi.
CQRS include i seguenti vantaggi:
+ Scalabilità indipendente: ogni modello può avere la propria strategia di scalabilità adattata per soddisfare i requisiti e la domanda del servizio. Analogamente alle applicazioni ad alte prestazioni, la separazione di lettura e scrittura consente al modello di scalare in modo indipendente per soddisfare ogni esigenza. È inoltre possibile aggiungere o ridurre le risorse di elaborazione per soddisfare la richiesta di scalabilità di un modello senza influire sull'altro.
+ Manutenzione indipendente: la separazione dei modelli di query e comando migliora la manutenibilità dei modelli. È possibile apportare modifiche e miglioramenti al codice di un modello senza influire sull'altro.
+ Sicurezza: è più semplice applicare le autorizzazioni e le politiche a modelli separati per la lettura e la scrittura.
+ Letture ottimizzate: è possibile definire uno schema ottimizzato per le query. Ad esempio, è possibile definire uno schema per i dati aggregati e uno schema separato per le tabelle dei fatti.
+ Integrazione: CQRS si adatta bene ai modelli di programmazione basati su eventi.
+ Complessità gestita: la separazione in modelli di query e comandi è adatta a domini complessi.
Quando utilizzate CQRS, tenete presente le seguenti avvertenze:
+ Il pattern CQRS si applica solo a una parte specifica di un'applicazione e non all'intera applicazione. Se implementato in un dominio che non corrisponde al modello, può ridurre la produttività, aumentare i rischi e introdurre complessità.
+ Il pattern funziona meglio per i modelli utilizzati di frequente che presentano uno squilibrio nelle operazioni di lettura e scrittura.
+ Per le applicazioni che richiedono molta lettura, come i report di grandi dimensioni che richiedono tempo per l'elaborazione, CQRS offre la possibilità di selezionare il database giusto e creare uno schema per archiviare i dati aggregati. Ciò migliora il tempo di risposta di lettura e visualizzazione del report elaborando i dati del report una sola volta e scaricandoli nella tabella aggregata.
+ Per le applicazioni che richiedono molta scrittura, è possibile configurare il database per le operazioni di scrittura e consentire al comando microservice di scalare in modo indipendente quando la richiesta di scrittura aumenta. Per esempi, consulta and microservices. `AWS.APG.CQRSES.CommandRedeemRewardLambda` `AWS.APG.CQRSES.CommandAddRewardLambda`
*Approvvigionamento di eventi*
Il passaggio successivo consiste nell'utilizzare l'origine degli eventi per sincronizzare il database delle query quando viene eseguito un comando. Ad esempio, considerate i seguenti eventi:
+ Viene aggiunto un punto premio cliente che richiede l'aggiornamento dei punti premio totali o aggregati del cliente nel database delle query.
+ Il cognome di un cliente viene aggiornato nel database dei comandi, il che richiede l'aggiornamento delle informazioni sostitutive sul cliente contenute nel database delle query.
Nel modello CRUD tradizionale, si garantisce la coerenza dei dati bloccandoli fino al termine di una transazione. Nell'event sourcing, i dati vengono sincronizzati mediante la pubblicazione di una serie di eventi che verranno utilizzati da un abbonato per aggiornare i rispettivi dati.
Il modello di sourcing degli eventi garantisce e registra una serie completa di azioni intraprese sui dati e le pubblica attraverso una sequenza di eventi. Questi eventi rappresentano un insieme di modifiche ai dati che i sottoscrittori di quell'evento devono elaborare per mantenere aggiornato il proprio record. Questi eventi vengono utilizzati dal sottoscrittore, sincronizzando i dati nel database del sottoscrittore. In questo caso, si tratta del database delle interrogazioni.
Il diagramma seguente mostra l'event sourcing utilizzato con CQRS su AWS.
![\[Architettura di microservizi per il CQRS e modelli di approvvigionamento degli eventi che utilizzano i servizi serverless AWS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/cc9bc84a-60b4-4459-9a5c-2334c69dbb4e.png)
1. Le funzioni Command Lambda eseguono operazioni di scrittura, come creare, aggiornare o eliminare, sul database.
1. Le funzioni Query Lambda eseguono operazioni di lettura, come get o select, sul database.
1. Questa funzione Lambda elabora i flussi DynamoDB dal database Command e aggiorna il database Query per le modifiche. Puoi utilizzare questa funzione anche per pubblicare un messaggio su Amazon SNS in modo che i suoi abbonati possano elaborare i dati.
1. (Facoltativo) L'abbonato all'evento Lambda elabora il messaggio pubblicato da Amazon SNS e aggiorna il database Query.
1. (Facoltativo) Amazon SNS invia una notifica e-mail dell'operazione di scrittura.
Su AWS, il database delle query può essere sincronizzato tramite DynamoDB Streams. DynamoDB acquisisce una sequenza ordinata nel tempo di modifiche a livello di elemento in una tabella DynamoDB quasi in tempo reale e archivia le informazioni in modo duraturo entro 24 ore.
L'attivazione di DynamoDB Streams consente al database di pubblicare una sequenza di eventi che rende possibile lo schema di sourcing degli eventi. Il pattern di origine degli eventi aggiunge il sottoscrittore dell'evento. L'applicazione Event Subscriber utilizza l'evento e lo elabora in base alla responsabilità del sottoscrittore. Nel diagramma precedente, il sottoscrittore dell'evento invia le modifiche al database Query DynamoDB per mantenere i dati sincronizzati. L'uso di Amazon SNS, del broker di messaggi e dell'applicazione Event Subscriber mantiene l'architettura disaccoppiata.
L'event sourcing include i seguenti vantaggi:
+ Coerenza per i dati transazionali
+ Una pista di controllo e una cronologia delle azioni affidabili, che possono essere utilizzate per monitorare le azioni intraprese nei dati
+ Consente alle applicazioni distribuite come i microservizi di sincronizzare i dati in tutto l'ambiente
+ Pubblicazione affidabile degli eventi ogni volta che lo stato cambia
+ Ricostruzione o riproduzione degli stati passati
+ Entità liberamente accoppiate che scambiano eventi per la migrazione da un'applicazione monolitica ai microservizi
+ Riduzione dei conflitti causati dagli aggiornamenti simultanei; l'event sourcing evita la necessità di aggiornare gli oggetti direttamente nell'archivio dati
+ Flessibilità ed estensibilità grazie al disaccoppiamento tra attività ed evento
+ Aggiornamenti di sistema esterni
+ Gestione di più attività in un unico evento
Quando utilizzi il sourcing degli eventi, tieni presente le seguenti avvertenze:
+ Poiché si verifica un certo ritardo nell'aggiornamento dei dati tra i database degli abbonati di origine, l'unico modo per annullare una modifica consiste nell'aggiungere un evento di compensazione all'archivio eventi.
+ L'implementazione dell'event sourcing presenta una curva di apprendimento a causa del suo diverso stile di programmazione.
**Dati di test**
Utilizza i seguenti dati di test per testare la funzione Lambda dopo una corretta implementazione.
**CommandCreate Cliente**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Done", "CompanyName":"AnyCompany", "Address": "USA", "VIP":true }
```
**CommandUpdate Cliente**
```
{ "Id":1501, "Firstname":"John", "Lastname":"Doe", "CompanyName":"Example Corp.", "Address": "Seattle, USA", "VIP":true }
```
**CommandDelete Cliente**
Immettete l'ID cliente come dati della richiesta. Ad esempio, se l'ID cliente è 151, inserisci 151 come dati della richiesta.
```
151
```
**QueryCustomerList**
Questo campo è vuoto. Quando viene richiamato, restituirà tutti i clienti.
**CommandAddReward**
Ciò aggiungerà 40 punti al cliente con ID 1 (Richard).
```
{
"Id":10101,
"CustomerId":1,
"Points":40
}
```
**CommandRedeemReward**
In questo modo verranno detratti 15 punti dal cliente con ID 1 (Richard).
```
{
"Id":10110,
"CustomerId":1,
"Points":15
}
```
**QueryReward**
Inserisci l'ID del cliente. Ad esempio, inserisci 1 per Richard, 2 per Arnav e 3 per Shirley.
```
2
```
**Directory del codice sorgente**
Usa la tabella seguente come guida alla struttura di directory della soluzione Visual Studio.
*Directory della soluzione CQRS On-Premises Code Sample*
![\[Directory di soluzioni con servizi di comando e interrogazione ampliata.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/4811c2c0-643b-410f-bb87-0b86ec5e194c.png)
**Modello CRUD del cliente**
Esempio di codice locale CQRS\$1 Modello CRUD\$1 Progetto AWS.APG.CQRSES.DAL
**Versione CQRS del modello Customer CRUD**
+ Comando cliente: progetto `CQRS On-Premises Code Sample\CQRS Model\Command Microservice\AWS.APG.CQRSES.Command`
+ Richiesta del cliente: `CQRS On-Premises Code Sample\CQRS Model\Query Microservice\AWS.APG.CQRSES.Query` progetto
**Microservizi Command and Query**
Il microservizio Command si trova nella cartella della soluzione: `CQRS On-Premises Code Sample\CQRS Model\Command Microservice`
+ `AWS.APG.CQRSES.CommandMicroservice`Il progetto ASP.NET Core API funge da punto di ingresso in cui i consumatori interagiscono con il servizio.
+ `AWS.APG.CQRSES.Command`Il progetto.NET Core è un oggetto che ospita oggetti e interfacce relativi ai comandi.
Il microservizio di interrogazione si trova nella cartella della soluzione: `CQRS On-Premises Code Sample\CQRS Model\Query Microservice`
+ `AWS.APG.CQRSES.QueryMicroservice`Il progetto ASP.NET Core API funge da punto di ingresso in cui i consumatori interagiscono con il servizio.
+ `AWS.APG.CQRSES.Query`Il progetto.NET Core è un oggetto che ospita oggetti e interfacce relativi alle query.
*Directory di soluzioni di codice serverless CQRS AWS*
![\[Directory di soluzioni che mostra sia i microservizi che la fonte degli eventi espansa.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/9f1bc700-def4-4201-bb2d-f1fa27404f15/images/23f8655c-95ad-422c-b20a-e29dc145e995.png)
Questo codice è la versione AWS del codice locale che utilizza i servizi serverless AWS.
In C\$1 .NET Core, ogni funzione Lambda è rappresentata da un progetto.NET Core. Nel codice di esempio di questo pattern, esiste un progetto separato per ogni interfaccia nei modelli di comando e query.
**CQRS che utilizza i servizi AWS**
Puoi trovare la directory della soluzione principale per CQRS che utilizza i servizi serverless AWS nella `CQRS AWS Serverless\CQRS` cartella. L'esempio include due modelli: Customer e Reward.
Le funzioni di comando Lambda per Customer e Reward si trovano nelle cartelle `CQRS\Command Microservice\Customer` e`CQRS\Command Microservice\Reward`. Contengono i seguenti progetti Lambda:
+ Comando cliente: `CommandCreateLambda``CommandDeleteLambda`, e `CommandUpdateLambda`
+ Comando di ricompensa: `CommandAddRewardLambda` e `CommandRedeemRewardLambda`
Le funzioni di interrogazione Lambda per Customer e Reward si trovano nelle cartelle `CQRS\Query Microservice\Customer` and`CQRS\QueryMicroservice\Reward`. Contengono i progetti `QueryCustomerListLambda` e `QueryRewardLambda` Lambda.
**Progetto di test CQRS**
Il progetto di test si trova nella `CQRS\Tests` cartella. Questo progetto contiene uno script di test per automatizzare il test delle funzioni CQRS Lambda.
**Approvvigionamento di eventi tramite i servizi AWS**
I seguenti gestori di eventi Lambda vengono avviati dai flussi DynamoDB Customer e Reward per elaborare e sincronizzare i dati nelle tabelle di query.
+ La funzione `EventSourceCustomer` Lambda è mappata sul flusso `cqrses-customer-cmd` DynamoDB della tabella Customer ().
+ La funzione `EventSourceReward` Lambda è mappata sul flusso `cqrses-reward-cmd` DynamoDB della tabella Reward ().
## Allegati
[Per accedere a contenuti aggiuntivi associati a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/9f1bc700-def4-4201-bb2d-f1fa27404f15/attachments/attachment.zip)
# Altri modelli
**Topics**
+ [Accedi alle applicazioni container in modo privato su Amazon EKS utilizzando AWS PrivateLink e un Network Load Balancer](access-container-applications-privately-on-amazon-eks-using-aws-privatelink-and-a-network-load-balancer.md)
+ [Automatizza l'aggiunta o l'aggiornamento delle voci di registro di Windows utilizzando AWS Systems Manager](automate-adding-or-updating-windows-registry-entries-using-aws-systems-manager.md)
+ [Automatizza il failover e il failback tra regioni utilizzando DR Orchestrator Framework](automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.md)
+ [Crea e distribuisci automaticamente un'applicazione Java su Amazon EKS utilizzando una pipeline CI/CD](automatically-build-and-deploy-a-java-application-to-amazon-eks-using-a-ci-cd-pipeline.md)
+ [Crea automaticamente CI/CD pipeline e cluster Amazon ECS per microservizi utilizzando AWS CDK](automatically-build-ci-cd-pipelines-and-amazon-ecs-clusters-for-microservices-using-aws-cdk.md)
+ [Esegui il backup e l'archiviazione dei dati del mainframe su Amazon S3 utilizzando BMC AMI Cloud Data](back-up-and-archive-mainframe-data-to-amazon-s3-using-bmc-ami-cloud-data.md)
+ [Create un Micro Focus Enterprise Server PAC con Amazon EC2 Auto Scaling e Systems Manager](build-a-micro-focus-enterprise-server-pac-with-amazon-ec2-auto-scaling-and-systems-manager.md)
+ [Crea una rete dati aziendale con Amazon DataZone e AWS CDK AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md)
+ [Containerizza i carichi di lavoro mainframe che sono stati modernizzati da Blu Age](containerize-mainframe-workloads-that-have-been-modernized-by-blu-age.md)
+ [Converti e decomprimi i dati EBCDIC in ASCII su AWS usando Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md)
+ [Convertite file di dati mainframe con layout di registrazione complessi utilizzando Micro Focus](convert-mainframe-data-files-with-complex-record-layouts-using-micro-focus.md)
+ [Crea un portale per micro-frontend utilizzando Angular e AWS Amplify Module Federation](create-amplify-micro-frontend-portal.md)
+ [Distribuisci contenitori utilizzando Elastic Beanstalk](deploy-containers-by-using-elastic-beanstalk.md)
+ [Emula Oracle DR utilizzando un database globale Aurora compatibile con PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md)
+ [Genera approfondimenti sui dati utilizzando Modernizzazione del mainframe AWS Amazon Q in Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md)
+ [Genera approfondimenti sui z/OS dati Db2 utilizzando Modernizzazione del mainframe AWS Amazon Q in Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md)
+ [Identifica automaticamente le immagini duplicate dei container durante la migrazione a un repository Amazon ECR](identify-duplicate-container-images-automatically-when-migrating-to-ecr-repository.md)
+ [Implementa la diagnostica e la risoluzione dei problemi di Kubernetes basate sull'intelligenza artificiale con K8SGPT e l'integrazione con Amazon Bedrock](implement-ai-powered-kubernetes-diagnostics-and-troubleshooting-with-k8sgpt-and-amazon-bedrock-integration.md)
+ [Implementa l'autenticazione basata su Microsoft Entra ID in un'applicazione mainframe modernizzata AWS Blu Age](implement-entra-id-authentication-in-aws-blu-age-modernized-mainframe-application.md)
+ [Implementa il controllo delle versioni delle API basato sul percorso utilizzando domini personalizzati in Amazon API Gateway](implement-path-based-api-versioning-by-using-custom-domains.md)
+ [Migrazione incrementale da Amazon RDS for Oracle ad Amazon RDS for PostgreSQL utilizzando Oracle SQL Developer e AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md)
+ [Integra il controller universale Stonebranch con la modernizzazione del mainframe AWS](integrate-stonebranch-universal-controller-with-aws-mainframe-modernization.md)
+ [Gestisci i prodotti AWS Service Catalog in più account AWS e regioni AWS](manage-aws-service-catalog-products-in-multiple-aws-accounts-and-aws-regions.md)
+ [Esegui la migrazione di un account AWS membro da a AWS Organizations AWS Control Tower](migrate-an-aws-member-account-from-aws-organizations-to-aws-control-tower.md)
+ [Esegui la migrazione e la replica di file VSAM su Amazon RDS o Amazon MSK utilizzando Connect from Precisly](migrate-and-replicate-vsam-files-to-amazon-rds-or-amazon-msk-using-connect-from-precisely.md)
+ [Esegui la migrazione da SAP ASE ad Amazon RDS per SQL Server utilizzando AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md)
+ [Esegui la migrazione di tabelle esterne Oracle verso Amazon Aurora, compatibile con PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md)
+ [Modernizza l'applicazione CardDemo mainframe utilizzando AWS Transform](modernize-carddemo-mainframe-app.md)
+ [Modernizza e implementa le applicazioni mainframe utilizzando e Terraform AWS Transform](modernize-mainframe-app-transform-terraform.md)
+ [Modernizza i carichi di lavoro di stampa in batch su mainframe AWS utilizzando Rocket Enterprise Server e LRS VPSX/MFI](modernize-mainframe-batch-printing-workloads-on-aws-by-using-rocket-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernizza i carichi di lavoro di stampa online mainframe su AWS utilizzando Micro Focus Enterprise Server e LRS VPSX/MFI](modernize-mainframe-online-printing-workloads-on-aws-by-using-micro-focus-enterprise-server-and-lrs-vpsx-mfi.md)
+ [Modernizza la gestione dell'output del mainframe AWS utilizzando Rocket Enterprise Server e LRS X PageCenter](modernize-mainframe-output-management-on-aws-by-using-rocket-enterprise-server-and-lrs-pagecenterx.md)
+ [Sposta i file mainframe direttamente su Amazon S3 utilizzando Transfer Family](move-mainframe-files-directly-to-amazon-s3-using-transfer-family.md)
+ [Ottimizza le implementazioni serverless multi-account utilizzando i flussi di lavoro e Actions AWS CDK GitHub](optimize-multi-account-serverless-deployments.md)
+ [Ottimizza le prestazioni della tua applicazione modernizzata AWS Blu Age](optimize-performance-aws-blu-age-modernized-application.md)
+ [Automatizza le blue/green implementazioni dei database globali di Amazon Aurora utilizzando i principi IaC](p-automate-blue-green-deployments-aurora-global-databases-iac.md)
+ [Replica i database mainframe su AWS utilizzando Precisly Connect](replicate-mainframe-databases-to-aws-by-using-precisely-connect.md)
+ [Esegui attività Amazon ECS su Amazon WorkSpaces con Amazon ECS Anywhere](run-amazon-ecs-tasks-on-amazon-workspaces-with-amazon-ecs-anywhere.md)
+ [Invia dati di telemetria da AWS Lambda a OpenSearch per analisi e visualizzazione in tempo reale](send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.md)
+ [Imposta il rilevamento della CloudFormation deriva in un'organizzazione multiregionale e con più account](set-up-aws-cloudformation-drift-detection-in-a-multi-region-multi-account-organization.md)
+ [Struttura un progetto Python in architettura esagonale utilizzando AWS Lambda](structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.md)
+ [AWS Infrastruttura di test utilizzando LocalStack e Terraform Tests](test-aws-infra-localstack-terraform.md)
+ [Trasforma Easytrieve in linguaggi moderni utilizzando soluzioni personalizzate AWS Transform](transform-easytrieve-modern-languages.md)
+ [Aggiornamento dei cluster SAP Pacemaker da a ENSA1 ENSA2](upgrade-sap-pacemaker-clusters-from-ensa1-to-ensa2.md)
+ [Usa Amazon Q Developer come assistente di programmazione per aumentare la tua produttività](use-q-developer-as-coding-assistant-to-increase-productivity.md)
+ [Convalida il codice Account Factory for Terraform (AFT) localmente](validate-account-factory-for-terraform-aft-code-locally.md)