

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Tutoriel : prise en main de la sécurité dans Amazon OpenSearch Serverless (CLI)
<a name="gsg-serverless-cli"></a>

Ce didacticiel explique les étapes décrites dans le [didacticiel de démarrage de la console](gsg-serverless.md) pour la sécurité, mais utilise la console AWS CLI plutôt que la console OpenSearch de service. 

Dans le cadre de ce didacticiel, vous suivrez les étapes suivantes :

1. Création d'une politique d'autorisations IAM

1. Associer la politique IAM à un rôle IAM

1. Créer une politique de chiffrement

1. Création d'une stratégie réseau

1. Créer une collection

1. Configuration d'une stratégie d'accès aux données

1. Récupérer le point de terminaison de collecte

1. Téléchargez des données sur votre connexion

1. Rechercher des données dans votre collection

L'objectif de ce didacticiel est de configurer une collection unique OpenSearch sans serveur avec des paramètres de chiffrement, de réseau et d'accès aux données assez simples. Par exemple, nous allons configurer l'accès au réseau public, un Clé gérée par AWS système de chiffrement et une politique d'accès aux données simplifiée qui accorde des autorisations minimales à un seul utilisateur. 

Dans un scénario de production, envisagez de mettre en œuvre une configuration plus robuste, notamment une authentification SAML, une clé de chiffrement personnalisée et un accès VPC.

**Pour commencer à utiliser les politiques de sécurité dans OpenSearch Serverless**

1. 
**Note**  
Vous pouvez ignorer cette étape si vous utilisez déjà une politique basée sur l'identité plus large, telle que `Action":"aoss:*"` ou `Action":"*"`. Toutefois, dans les environnements de production, nous vous recommandons de suivre le principe du moindre privilège et de n'attribuer que les autorisations minimales nécessaires pour effectuer une tâche.

   Pour commencer, créez une Gestion des identités et des accès AWS politique avec les autorisations minimales requises pour effectuer les étapes de ce didacticiel. Nous nommerons la politique `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\": \"*\"}]}"
   ```

   **Exemple de réponse**

   ```
   {
       "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. Attachez `TutorialPolicy` au rôle IAM qui indexera et recherchera les données dans la collection. Nous nommerons l'utilisateur `TutorialRole` :

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

1. Avant de créer une collection, vous devez créer une [stratégie de chiffrement](serverless-encryption.md) qui attribue une Clé détenue par AWS à la collection *books* que vous créerez ultérieurement.

   Envoyez la requête suivante afin de créer une stratégie de chiffrement pour la collection *books* :

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

   **Exemple de réponse**

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

1. Créez une [stratégie réseau](serverless-network.md) qui fournit un accès public à la collection *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}]"
   ```

   **Exemple de réponse**

   ```
   {
       "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. Créez la collection *books* :

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

   **Exemple de réponse**

   ```
   {
       "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. Créez une [stratégie d'accès aux données](serverless-data-access.md) qui fournit les autorisations minimales nécessaires pour indexer et rechercher des données dans la collection *books*. Remplacez l'ARN du principal par l'ARN du `TutorialRole` de l'étape 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\"]}]"
   ```

   **Exemple de réponse**

   ```
   {
       "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
       }
   }
   ```

   `TutorialRole` devrait désormais pouvoir indexer et rechercher des documents dans la collection *books*. 

1. Pour appeler l' OpenSearch API, vous avez besoin du point de terminaison de collecte. Envoyez la requête suivante pour récupérer le paramètre `collectionEndpoint` :

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

   **Exemple de réponse**

   ```
   {
       "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": []
   }
   ```
**Note**  
Vous ne pourrez pas voir le point de terminaison de la collection tant que le statut de la collection ne sera pas passé à `ACTIVE`. Vous devrez peut-être effectuer plusieurs appels pour vérifier le statut jusqu'à ce que la collection soit correctement créée.

1. Utilisez un outil HTTP tel que [Postman](https://www.getpostman.com/) ou curl pour indexer les données dans la collection *books*. Nous allons créer un index appelé *books-index* et ajouter un seul document.

   Envoyez la requête suivante au point de terminaison de collection que vous avez récupéré à l'étape précédente, à l'aide des informations d'identification de `TutorialRole`.

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

   **Exemple de réponse**

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

1. Pour commencer à rechercher des données dans votre collection, utilisez l'[API de recherche](https://opensearch.org/docs/latest/opensearch/rest-api/search/). La requête suivante permet d'effectuer une recherche de base :

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

   **Exemple de réponse**

   ```
   {
       "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
                   }
               }
           ]
       }
   }
   ```