

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à.

# Tutorial: Guida introduttiva alla sicurezza in Amazon OpenSearch Serverless (CLI)
<a name="gsg-serverless-cli"></a>

Questo tutorial illustra i passaggi descritti nel [tutorial introduttivo alla console](gsg-serverless.md) per la sicurezza, ma utilizza la console AWS CLI anziché la console di servizio. OpenSearch 

In questo tutorial completerai i seguenti passaggi:

1. Crea una politica di autorizzazioni IAM

1. Collega la policy IAM a un ruolo IAM

1. Creare una policy di crittografia

1. Creazione di una policy di rete

1. Creare una raccolta

1. Configurazione di una policy di accesso ai dati

1. Recupera l'endpoint di raccolta

1. Carica i dati nella tua raccolta

1. Cerca i dati nella tua raccolta

L'obiettivo di questo tutorial è configurare un'unica raccolta OpenSearch Serverless con impostazioni di crittografia, rete e accesso ai dati abbastanza semplici. Ad esempio, si configura l'accesso alla rete pubblica, una Chiave gestita da AWS per la crittografia e una politica di accesso ai dati semplificata che concede autorizzazioni minime a un singolo utente. 

In uno scenario di produzione, ti consigliamo di implementare una configurazione più affidabile, che includa l'autenticazione SAML, una chiave di crittografia personalizzata e l'accesso al VPC.

**Per iniziare con le politiche di sicurezza in Serverless OpenSearch**

1. 
**Nota**  
Puoi saltare questa fase se stai già utilizzando una policy più ampia basata sull'identità, ad esempio `Action":"aoss:*"` o `Action":"*"`. Negli ambienti di produzione, tuttavia, segui il principio del privilegio minimo e assegna solo le autorizzazioni minime necessarie per completare un'attività.

   Per iniziare, crea una AWS Identity and Access Management politica con le autorizzazioni minime richieste per eseguire i passaggi di questo tutorial. Assegna un nome alla politica`TutorialPolicy`:

   ```
   aws iam create-policy \
     --policy-name TutorialPolicy \
     --policy-document "{\"Version\": \"2012-10-17\",\"Statement\": [{\"Action\": [\"aoss:ListCollections\",\"aoss:BatchGetCollection\",\"aoss:CreateCollection\",\"aoss:CreateSecurityPolicy\",\"aoss:GetSecurityPolicy\",\"aoss:ListSecurityPolicies\",\"aoss:CreateAccessPolicy\",\"aoss:GetAccessPolicy\",\"aoss:ListAccessPolicies\"],\"Effect\": \"Allow\",\"Resource\": \"*\"}]}"
   ```

   **Risposta di esempio**

   ```
   {
       "Policy": {
           "PolicyName": "TutorialPolicy",
           "PolicyId": "ANPAW6WRAECKG6QJWUV7U",
           "Arn": "arn:aws:iam::{{123456789012}}:policy/TutorialPolicy",
           "Path": "/",
           "DefaultVersionId": "v1",
           "AttachmentCount": 0,
           "PermissionsBoundaryUsageCount": 0,
           "IsAttachable": true,
           "CreateDate": "2022-10-16T20:57:18+00:00",
           "UpdateDate": "2022-10-16T20:57:18+00:00"
       }
   }
   ```

1. Allega la `TutorialPolicy` al ruolo IAM che indicizzerà e cercherà i dati nella raccolta. In questo esempio, il ruolo è denominato`TutorialRole`:

   ```
   aws iam attach-role-policy \
     --role-name {{TutorialRole}} \
     --policy-arn arn:aws:iam::{{123456789012}}:policy/TutorialPolicy
   ```

1. Prima di creare una raccolta, è necessario creare una [politica di crittografia](serverless-encryption.md) che assegni un Chiave di proprietà di AWS valore alla raccolta di *libri* creata in un passaggio successivo.

   Invia la seguente richiesta per creare una policy di crittografia per la raccolta *books*:

   ```
   aws opensearchserverless create-security-policy \
     --name books-policy \
     --type encryption --policy "{\"Rules\":[{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/books\"]}],\"AWSOwnedKey\":true}"
   ```

   **Risposta di esempio**

   ```
   {
       "securityPolicyDetail": {
           "type": "encryption",
           "name": "books-policy",
           "policyVersion": "MTY2OTI0MDAwNTk5MF8x",
           "policy": {
               "Rules": [
                   {
                       "Resource": [
                           "collection/books"
                       ],
                       "ResourceType": "collection"
                   }
               ],
               "AWSOwnedKey": true
           },
           "createdDate": 1669240005990,
           "lastModifiedDate": 1669240005990
       }
   }
   ```

1. Crea una [policy di rete](serverless-network.md) che fornisca l'accesso pubblico alla raccolta *books*:

   ```
   aws opensearchserverless create-security-policy --name books-policy --type network \
     --policy "[{\"Description\":\"Public access for books collection\",\"Rules\":[{\"ResourceType\":\"dashboard\",\"Resource\":[\"collection\/books\"]},{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/books\"]}],\"AllowFromPublic\":true}]"
   ```

   **Risposta di esempio**

   ```
   {
       "securityPolicyDetail": {
           "type": "network",
           "name": "books-policy",
           "policyVersion": "MTY2OTI0MDI1Njk1NV8x",
           "policy": [
               {
                   "Rules": [
                       {
                           "Resource": [
                               "collection/books"
                           ],
                           "ResourceType": "dashboard"
                       },
                       {
                           "Resource": [
                               "collection/books"
                           ],
                           "ResourceType": "collection"
                       }
                   ],
                   "AllowFromPublic": true,
                   "Description": "Public access for books collection"
               }
           ],
           "createdDate": 1669240256955,
           "lastModifiedDate": 1669240256955
       }
   }
   ```

1. Crea la raccolta *books*:

   ```
   aws opensearchserverless create-collection --name books --type SEARCH
   ```

   **Risposta di esempio**

   ```
   {
       "createCollectionDetail": {
           "id": "8kw362bpwg4gx9b2f6e0",
           "name": "books",
           "status": "CREATING",
           "type": "SEARCH",
           "arn": "arn:aws:aoss:us-east-1:123456789012:collection/8kw362bpwg4gx9b2f6e0",
           "kmsKeyArn": "auto",
           "createdDate": 1669240325037,
           "lastModifiedDate": 1669240325037
       }
   }
   ```

1. Crea una [policy di accesso ai dati](serverless-data-access.md) che fornisca le autorizzazioni minime per indicizzare e cercare i dati nella raccolta *books*. Sostituisci l'ARN principale con l'ARN del `TutorialRole` dalla fase 1:

   ```
   aws opensearchserverless create-access-policy \
     --name books-policy \
     --type data \
     --policy "[{\"Rules\":[{\"ResourceType\":\"index\",\"Resource\":[\"index\/books\/books-index\"],\"Permission\":[\"aoss:CreateIndex\",\"aoss:DescribeIndex\",\"aoss:ReadDocument\",\"aoss:WriteDocument\",\"aoss:UpdateIndex\",\"aoss:DeleteIndex\"]}],\"Principal\":[\"arn:aws:iam::{{123456789012}}:{{role}}\/{{TutorialRole}}\"]}]"
   ```

   **Risposta di esempio**

   ```
   {
       "accessPolicyDetail": {
           "type": "data",
           "name": "books-policy",
           "policyVersion": "MTY2OTI0MDM5NDY1M18x",
           "policy": [
               {
                   "Rules": [
                       {
                           "Resource": [
                               "index/books/books-index"
                           ],
                           "Permission": [
                               "aoss:CreateIndex",
                               "aoss:DescribeIndex",
                               "aoss:ReadDocument",
                               "aoss:WriteDocument",
                               "aoss:UpdateDocument",
                               "aoss:DeleteDocument"
                           ],
                           "ResourceType": "index"
                       }
                   ],
                   "Principal": [
                       "arn:aws:iam::123456789012:role/TutorialRole"
                   ]
               }
           ],
           "createdDate": 1669240394653,
           "lastModifiedDate": 1669240394653
       }
   }
   ```

   Ora `TutorialRole` dovrebbe essere in grado di indicizzare e cercare documenti nella raccolta *books*. 

1. Per effettuare chiamate all' OpenSearch API, è necessario l'endpoint di raccolta. Invia la seguente richiesta per recuperare il parametro `collectionEndpoint`:

   ```
   aws opensearchserverless batch-get-collection --names books {{ }}
   ```

   **Risposta di esempio**

   ```
   {
       "collectionDetails": [
           {
               "id": "8kw362bpwg4gx9b2f6e0",
               "name": "books",
               "status": "ACTIVE",
               "type": "SEARCH",
               "description": "",
               "arn": "arn:aws:aoss:us-east-1:123456789012:collection/8kw362bpwg4gx9b2f6e0",
               "createdDate": 1665765327107,
               "collectionEndpoint": "https://8kw362bpwg4gx9b2f6e0.us-east-1.aoss.amazonaws.com",
               "dashboardEndpoint": "https://8kw362bpwg4gx9b2f6e0.us-east-1.aoss.amazonaws.com/_dashboards"
           }
       ],
       "collectionErrorDetails": []
   }
   ```
**Nota**  
L'endpoint di raccolta non è disponibile finché lo stato della raccolta non cambia in. `ACTIVE` Potrebbe essere necessario effettuare più chiamate per verificare lo stato finché la raccolta non viene creata correttamente.

1. Usa uno strumento HTTP come [Postman](https://www.getpostman.com/) o curl per indicizzare i dati nella raccolta *books*. L'esempio seguente crea un indice chiamato *books-index* e aggiunge un singolo documento.

   Invia la richiesta seguente all'endpoint di raccolta recuperato nella fase precedente, utilizzando le credenziali del `TutorialRole`.

   ```
   PUT https://{{8kw362bpwg4gx9b2f6e0}}.{{us-east-1}}.aoss.amazonaws.com/books-index/_doc/1
   { 
     "title": "The Shining",
     "author": "Stephen King",
     "year": 1977
   }
   ```

   **Risposta di esempio**

   ```
   {
     "_index" : "books-index",
     "_id" : "1",
     "_version" : 1,
     "result" : "created",
     "_shards" : {
       "total" : 0,
       "successful" : 0,
       "failed" : 0
     },
     "_seq_no" : 0,
     "_primary_term" : 0
   }
   ```

1. Per iniziare a cercare i dati nella raccolta, usa l'[API di ricerca](https://opensearch.org/docs/latest/opensearch/rest-api/search/). La seguente query esegue una ricerca di base:

   ```
   GET https://{{8kw362bpwg4gx9b2f6e0}}.us-east-1.aoss.amazonaws.com/books-index/_search
   ```

   **Risposta di esempio**

   ```
   {
       "took": 405,
       "timed_out": false,
       "_shards": {
           "total": 6,
           "successful": 6,
           "skipped": 0,
           "failed": 0
       },
       "hits": {
           "total": {
               "value": 2,
               "relation": "eq"
           },
           "max_score": 1.0,
           "hits": [
               {
                   "_index": "books-index:0::3xJq14MBUaOS0wL26UU9:0",
                   "_id": "F_bt4oMBLle5pYmm5q4T",
                   "_score": 1.0,
                   "_source": {
                       "title": "The Shining",
                       "author": "Stephen King",
                       "year": 1977
                   }
               }
           ]
       }
   }
   ```