Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Crea un'architettura serverless multi-tenant in Amazon Service OpenSearch
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service"></a>

*Tabby Ward e Nisha Gambhir, Amazon Web Services*

## Riepilogo
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-summary"></a>

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
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-prereqs"></a>

**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
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-architecture"></a>

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)
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-tools"></a>

**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
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-epics"></a>

### Crea e configura un bucket S3
<a name="create-and-configure-an-s3-bucket"></a>


| 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)<pre>aws s3api create-bucket \<br />  --bucket <tenantrawdata> \<br />  --region <your-AWS-Region></pre>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
<a name="create-and-configure-an-elasticsearch-cluster"></a>


| 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:<pre>aws es create-elasticsearch-domain \<br />  --domain-name vpc-cli-example \<br />  --elasticsearch-version 7.10 \<br />  --elasticsearch-cluster-config InstanceType=t3.medium.elasticsearch,InstanceCount=1 \<br />  --ebs-options EBSEnabled=true,VolumeType=gp2,VolumeSize=10 \<br />  --domain-endpoint-options "{\"EnforceHTTPS\": true}" \<br />  --encryption-at-rest-options "{\"Enabled\": true}" \<br />  --node-to-node-encryption-options "{\"Enabled\": true}" \<br />  --advanced-security-options "{\"Enabled\": true, \"InternalUserDatabaseEnabled\": true, \<br />    \"MasterUserOptions\": {\"MasterUserName\": \"KibanaUser\", \<br />    \"MasterUserPassword\": \"NewKibanaPassword@123\"}}" \<br />  --vpc-options "{\"SubnetIds\": [\"<subnet-id>\"], \"SecurityGroupIds\": [\"<sg-id>\"]}" \<br />  --access-policies "{\"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \ <br />    \"Principal\": {\"AWS\": \"*\" }, \"Action\":\"es:*\", \<br />    \"Resource\": \"arn:aws:es:<region>:<account-id>:domain\/vpc-cli-example\/*\" } ] }"</pre>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).<pre>aws ec2 authorize-security-group-ingress \<br />  --group-id <SecurityGroupIdfElasticSearch> \ <br />  --protocol tcp \<br />  --port 443 \<br />  --source-group <SecurityGroupIdfBashionHostEC2></pre> | Architetto del cloud, amministratore del cloud | 

### Creare e configurare la funzione di indice Lambda
<a name="create-and-configure-the-lam-index-function"></a>


| 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 <pre>aws iam create-role \<br />  --role-name index-lambda-role \<br />  --assume-role-policy-document file://lambda_assume_role.json</pre>dove `lambda_assume_role.json` è un documento JSON che concede `AssumeRole` le autorizzazioni alla funzione Lambda, come segue:<pre>{<br />     "Version": "2012-10-17",		 	 	 <br />     "Statement": [<br />         {<br />             "Effect": "Allow",<br />             "Principal": {<br />                 "Service": "lambda.amazonaws.com"<br />               },<br />             "Action": "sts:AssumeRole"<br />         }<br />     ]<br /> }</pre> | 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 <pre>aws iam attach-role-policy \<br />  --role-name index-lambda-role \<br />  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole<br /><br />aws iam attach-role-policy \<br />  --role-name index-lambda-role \<br />  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole </pre> | 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:<pre>aws iam create-policy \<br />  --policy-name s3-permission-policy \<br />  --policy-document file://s3-policy.json</pre>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 `<pre>{<br />    "Version": "2012-10-17",		 	 	 <br />    "Statement": [<br />        {<br />           "Effect": "Allow",<br />           "Action": "s3:GetObject",<br />           "Resource": "arn:aws:s3:::<tenantrawdata>/*"<br />        }<br />    ]<br />}</pre> | 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:<pre>aws iam attach-role-policy \<br />  --role-name index-lambda-role \<br />  --policy-arn <PolicyARN></pre>`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 <pre>aws lambda create-function \<br />  --function-name index-lambda-function \<br />  --zip-file fileb://index_lambda_package.zip \<br />  --handler lambda_index.lambda_handler \<br />  --runtime python3.9 \<br />  --role "arn:aws:iam::account-id:role/index-lambda-role" \<br />  --timeout 30 \<br />  --vpc-config "{\"SubnetIds\": [\"<subnet-id1\>", \"<subnet-id2>\"], \<br />    \"SecurityGroupIds\": [\"<sg-1>\"]}"</pre> | 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:<pre>aws lambda add-permission \<br />  --function-name index-lambda-function \<br />  --statement-id s3-permissions \<br />  --action lambda:InvokeFunction \<br />  --principal s3.amazonaws.com \<br />  --source-arn "arn:aws:s3:::<tenantrawdata>" \<br />  --source-account "<account-id>" </pre> | 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. <pre>aws s3api put-bucket-notification-configuration \<br />  --bucket <tenantrawdata> \<br />  --notification-configuration file://s3-trigger.json</pre>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
<a name="create-and-configure-the-lam-search-function"></a>


| 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 <pre>aws iam create-role \<br />  --role-name search-lambda-role \<br />  --assume-role-policy-document file://lambda_assume_role.json</pre>dove `lambda_assume_role.json` è un documento JSON nella cartella corrente che concede `AssumeRole` le autorizzazioni alla funzione Lambda, come segue:<pre>{<br />     "Version": "2012-10-17",		 	 	 <br />     "Statement": [<br />         {<br />             "Effect": "Allow",<br />             "Principal": {<br />                 "Service": "lambda.amazonaws.com"<br />               },<br />             "Action": "sts:AssumeRole"<br />         }<br />     ]<br /> }</pre> | 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 <pre>aws iam attach-role-policy \<br />  --role-name search-lambda-role \<br />  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole<br /><br />aws iam attach-role-policy \<br />  --role-name search-lambda-role \<br />  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole </pre> | 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 <pre>aws lambda create-function \<br />  --function-name search-lambda-function \<br />  --zip-file fileb://search_lambda_package.zip \<br />  --handler lambda_search.lambda_handler \<br />  --runtime python3.9 \<br />  --role "arn:aws:iam::account-id:role/search-lambda-role" \<br />  --timeout 30 \<br />  --vpc-config "{\"SubnetIds\": [\"<subnet-id1\>", \"<subnet-id2>\"], \<br />    \"SecurityGroupIds\": [\"<sg-1>\"]}"</pre> | Architetto cloud, amministratore cloud | 

### Crea e configura i ruoli degli inquilini
<a name="create-and-configure-tenant-roles"></a>


| 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:<pre>aws iam create-role \<br />  --role-name Tenant-1-role \<br />  --assume-role-policy-document file://assume-role-policy.json</pre><pre>aws iam create-role \<br />  --role-name Tenant-2-role \<br />  --assume-role-policy-document file://assume-role-policy.json</pre>Il file `assume-role-policy.json` è un documento JSON nella cartella corrente che concede le `AssumeRole` autorizzazioni per il ruolo di esecuzione Lambda:<pre>{<br />    "Version": "2012-10-17",		 	 	 <br />    "Statement": [<br />        {<br />            "Effect": "Allow",<br />            "Principal": {<br />                 "AWS": "<Lambda execution role for index function>",<br />                 "AWS": "<Lambda execution role for search function>"<br />             },<br />            "Action": "sts:AssumeRole"<br />        }<br />    ]<br />}</pre> | 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:<pre>aws iam create-policy \<br />  --policy-name tenant-policy \<br />  --policy-document file://policy.json</pre>Il file `policy.json` è un documento JSON nella cartella corrente che concede le autorizzazioni su Elasticsearch:<pre>{<br />    "Version": "2012-10-17",		 	 	 <br />    "Statement": [<br />        {<br />            "Effect": "Allow",<br />            "Action": [<br />                "es:ESHttpDelete",<br />                "es:ESHttpGet",<br />                "es:ESHttpHead",<br />                "es:ESHttpPost",<br />                "es:ESHttpPut",<br />                "es:ESHttpPatch"<br />            ],<br />            "Resource": [<br />                "<ARN of Elasticsearch domain created earlier>"<br />            ]<br />        }<br />    ]<br />}</pre> | 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:<pre>aws iam attach-role-policy \<br />  --policy-arn arn:aws:iam::account-id:policy/tenant-policy \<br />  --role-name Tenant-1-role<br /><br />aws iam attach-role-policy \<br />  --policy-arn arn:aws:iam::account-id:policy/tenant-policy \<br />  --role-name Tenant-2-role</pre>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:<pre>aws iam create-policy \<br />  --policy-name assume-tenant-role-policy \<br />  --policy-document file://lambda_policy.json</pre>Il file `lambda_policy.json` è un documento JSON nella cartella corrente che concede le autorizzazioni per: `AssumeRole`<pre>{<br />    "Version": "2012-10-17",		 	 	 <br />    "Statement": [<br />       {<br />            "Effect": "Allow",<br />            "Action":  "sts:AssumeRole",<br />            "Resource": "<ARN of tenant role created earlier>"<br />       }<br />    ]<br />}</pre>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:<pre>aws iam create-policy \<br />  --policy-name s3-permission-policy \<br />  --policy-document file://s3_lambda_policy.json</pre>Il file `s3_lambda_policy.json` è il seguente documento di policy JSON nella cartella corrente:<pre>{<br />    "Version": "2012-10-17",		 	 	 <br />    "Statement": [<br />        {<br />            "Effect": "Allow",<br />            "Action": "s3:GetObject",<br />            "Resource": "arn:aws:s3:::tenantrawdata/*"<br />        }<br />    ]<br />}</pre> | 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:<pre>aws iam attach-role-policy \<br />  --policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \<br />  --role-name index-lambda-role<br /><br />aws iam attach-role-policy \<br />  --policy-arn arn:aws:iam::account-id:policy/assume-tenant-role-policy \<br />  --role-name search-lambda-role<br /><br />aws iam attach-role-policy \<br />  --policy-arn arn:aws:iam::account-id:policy/s3-permission-policy \<br />  --role-name index-lambda-role</pre>L'ARN della policy proviene dall'output del passaggio precedente. | Architetto del cloud, amministratore del cloud | 

### Crea e configura un'API di ricerca
<a name="create-and-configure-a-search-api"></a>


| 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:<pre>aws apigateway create-rest-api \<br />  --name Test-Api \<br />  --endpoint-configuration "{ \"types\": [\"REGIONAL\"] }"</pre>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:<pre>aws apigateway put-method \<br />  --rest-api-id <API-ID> \<br />  --resource-id <ID from the previous command output> \<br />  --http-method GET \<br />  --authorization-type "NONE" \<br />  --no-api-key-required</pre>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:<pre>aws apigateway put-method-response \<br />  --rest-api-id <API-ID> \<br />  --resource-id  <ID from the create-resource command output> \<br />  --http-method GET \<br />  --status-code 200 \<br />  --response-models "{\"application/json\": \"Empty\"}"</pre>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:<pre>aws apigateway put-integration \<br />  --rest-api-id <API-ID> \<br />  --resource-id  <ID from the create-resource command output> \<br />  --http-method GET \<br />  --type AWS_PROXY \<br />  --integration-http-method GET \<br />  --uri arn:aws:apigateway:region:lambda:path/2015-03-31/functions/arn:aws:lambda:<region>:<account-id>:function:<function-name>/invocations</pre>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:<pre>aws lambda add-permission \<br />  --function-name <function-name> \<br />  --statement-id apigateway-get \<br />  --action lambda:InvokeFunction \<br />  --principal apigateway.amazonaws.com \<br />  --source-arn "arn:aws:execute-api:<region>:<account-id>:api-id/*/GET/search</pre>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`<pre>aws apigateway create-deployment \<br />  --rest-api-id <API-ID> \<br />  --stage-name dev</pre>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
<a name="create-and-configure-kibana-roles"></a>


| 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à.<pre>PUT /tenant-data<br />{<br />  "mappings": {<br />    "properties": {<br />      "TenantId": { "type": "keyword"}<br />    }<br />  }<br />}</pre> | Architetto del cloud, amministratore del cloud | 

### Crea endpoint VPC per Amazon S3 e AWS STS
<a name="create-vpc-endpoints-for-s3-and-sts"></a>


| 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.<pre>aws ec2 create-vpc-endpoint \<br />  --vpc-id <VPC-ID> \<br />  --service-name com.amazonaws.us-east-1.s3 \<br />  --route-table-ids <route-table-ID></pre>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.<pre>aws ec2 create-vpc-endpoint \<br />  --vpc-id <VPC-ID> \<br />  --vpc-endpoint-type Interface \<br />  --service-name com.amazonaws.us-east-1.sts \<br />  --subnet-id <subnet-ID> \<br />  --security-group-id <security-group-ID></pre>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
<a name="test-multi-tenancy-and-data-isolation"></a>


| 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. `<AWS-Region>.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:<pre>aws lambda update-function-code \<br />  --function-name index-lambda-function \<br />  --zip-file fileb://index_lambda_package.zip<br /><br />aws lambda update-function-code \<br />  --function-name search-lambda-function \<br />  --zip-file fileb://search_lambda_package.zip</pre> | 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):<pre>aws s3 cp tenant-1-data s3://tenantrawdata<br />aws s3 cp tenant-2-data s3://tenantrawdata</pre>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:<pre>GET tenant-data/_search</pre>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
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-resources"></a>
+ [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
<a name="build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service-additional"></a>

**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::<aws-account-id>:user/Tenant-1"
         },
         "Action": "es:*",
         "Resource": "arn:aws:es:<Region>:<account-id>: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:<Region>:<account-id>: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
<a name="attachments-750196bb-03f6-4b6e-92cd-eb7141602547"></a>

[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)