

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.

# Création d'octrois
<a name="create-grant-overview"></a>

Avant de créer un octroi, découvrez ses options de personnalisation. Vous pouvez utiliser des *contraintes d'octroi* pour limiter les autorisations dans l'octroi. En outre, renseignez-vous sur l'autorisation `CreateGrant` d'octroi. Les principaux qui obtiennent l'autorisation de créer des octrois à partir d'un octroi sont limités au niveau des octrois qu'ils peuvent créer.

**Topics**
+ [Création d'un octroi](#grant-create)
+ [Accorder CreateGrant une autorisation](#grant-creategrant)

## Création d'un octroi
<a name="grant-create"></a>

Pour créer une subvention, appelez l'[CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)opération. Spécifiez une clé KMS, une liste des opérations [ de ](grants.md#terms-grant-operations) subvention autorisées et un principal [ bénéficiaire ](grants.md#terms-grantee-principal) ou un principal de service [ bénéficiaire. ](grants.md#terms-grantee-service-principal)

Lorsque vous spécifiez un principal ** bénéficiaire**, vous pouvez éventuellement désigner un principal [ sortant ](grants.md#terms-retiring-principal) ou un principal de service [ sortant](grants.md#terms-retiring-service-principal), et utiliser le `Constraints` paramètre pour définir [ les contraintes d'octroi. ](https://docs.aws.amazon.com/kms/latest/APIReference/API_GrantConstraints.html) Lorsque vous spécifiez un principal de service ** bénéficiaire**, vous devez inclure une contrainte [ de ](#terms-source-arn-constraint) `SourceArn` subvention. Vous devez également spécifier a `RetiringServicePrincipal` ou `RetiringPrincipal` a.

Lorsque vous créez, retirez ou révoquez un octroi, il peut y avoir un bref délai, généralement de moins de cinq minutes, avant que la modification ne soit disponible sur AWS KMS. Pour plus d'informations, consultez la rubrique relative à la [cohérence à terme (pour les octrois)](grants.md#terms-eventual-consistency).

Par exemple, la commande `CreateGrant` suivante crée un octroi qui permet aux utilisateurs autorisés à assumer le rôle `keyUserRole` d'appeler l'opération [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) (Déchiffrer) sur la [clé KMS symétrique](symm-asymm-choose-key-spec.md#symmetric-cmks) spécifiée. L'autorisation utilise le paramètre `RetiringPrincipal` pour désigner un principal qui peut retirer l'autorisation. Elle inclut également une contrainte d'autorisation qui l'autorise uniquement lorsque le [contexte de chiffrement](encrypt_context.md) de la requête inclut `"Department": "IT"`.

```
$  aws kms create-grant \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --grantee-principal arn:aws:iam::111122223333:role/keyUserRole \
    --operations Decrypt \
    --retiring-principal arn:aws:iam::111122223333:role/adminRole \
    --constraints EncryptionContextSubset={Department=IT}
```

Si votre code relance l'opération `CreateGrant`, ou utilise un kit SDK [AWS qui relance automatiquement les demandes](https://docs.aws.amazon.com/general/latest/gr/api-retries.html), utilisez le paramètre [Name (Nom)](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html#KMS-CreateGrant-request-Name) facultatif pour empêcher la création d'octrois en double. Si AWS KMS reçoit une `CreateGrant` demande de subvention avec les mêmes propriétés qu'une autorisation existante, y compris le nom, elle reconnaît la demande comme une nouvelle tentative et ne crée pas de nouvelle autorisation. Vous pouvez utiliser la valeur `Name` pour identifier l'octroi dans n'importe quelle opération AWS KMS .

**Important**  
N'incluez pas d'informations confidentielles ou sensibles dans le nom de l’octroi. Il peut apparaître en texte brut dans CloudTrail les journaux et autres sorties.

```
$ aws kms create-grant \
    --name IT-1234abcd-keyUserRole-decrypt \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --grantee-principal arn:aws:iam::111122223333:role/keyUserRole \
    --operations Decrypt \
    --retiring-principal arn:aws:iam::111122223333:role/adminRole \
    --constraints EncryptionContextSubset={Department=IT}
```

Pour des exemples de code qui montrent comment créer des subventions dans plusieurs langages de programmation, consultez[Utilisation `CreateGrant` avec un AWS SDK ou une CLI](example_kms_CreateGrant_section.md).

### Utilisation des contraintes d'octroi
<a name="grant-constraints"></a>

Les [contraintes d'octroi](https://docs.aws.amazon.com/kms/latest/APIReference/API_GrantConstraints.html) définissent les conditions des autorisations que l'octroi donne au principal bénéficiaire. Les contraintes d'octroi prennent la place de [clés de condition](policy-conditions.md) dans une [politique de clé](key-policies.md) ou une [politique IAM](iam-policies.md).

**Important**  
N'incluez pas d'informations confidentielles ou sensibles dans ce champ. Ce champ peut être affiché en texte brut dans les CloudTrail journaux et autres sorties.

AWS KMS prend en charge deux types de contraintes d'autorisation : les contraintes liées au contexte de chiffrement et la `SourceArn` contrainte.

#### Contraintes liées au contexte de chiffrement
<a name="grant-constraints-ec"></a>

Les contraintes de contexte de chiffrement définissent les exigences relatives [ au contexte de ](encrypt_context.md) chiffrement dans une demande d'opération cryptographique. Chaque valeur de contrainte d'octroi de contexte de chiffrement peut inclure jusqu'à 8 paires de contextes de chiffrement. La valeur du contexte de chiffrement dans chaque contrainte ne peut pas dépasser 384 caractères.
+ Les contraintes de contexte de chiffrement ne sont valides que dans un octroi pour une clé KMS de chiffrement symétrique. Les opérations de chiffrement avec d'autres clés KMS ne prennent pas en charge un contexte de chiffrement. 
+ La contrainte de contexte de chiffrement est ignorée pour les opérations `DescribeKey` et `RetireGrant`. `DescribeKey` et `RetireGrant` n'ont pas de paramètre de contexte de chiffrement, mais vous pouvez inclure ces opérations dans un octroi qui a une contrainte de contexte de chiffrement.
+ Vous pouvez utiliser une contrainte de contexte de chiffrement dans un octroi pour l'opération `CreateGrant`. La contrainte de contexte de chiffrement nécessite que tous les octrois créés avec l'autorisation `CreateGrant` aient une contrainte de contexte de chiffrement tout aussi stricte ou plus stricte.

AWS KMS prend en charge deux contraintes d'octroi de contexte de chiffrement.

**EncryptionContextEquals**  
Utilisez `EncryptionContextEquals` pour spécifier le contexte de chiffrement exact pour les demandes autorisées.   
`EncryptionContextEquals` exige que les paires de contexte de chiffrement de la requête correspondent exactement, y compris au niveau des minuscules/majuscules, aux paires de contexte de chiffrement de la contrainte d'octroi. Les paires peuvent apparaître dans n'importe quel ordre, mais les clés et valeurs dans chaque paire ne peuvent pas varier.   
Par exemple, si l'a contrainte d'octroi `EncryptionContextEquals` exige la paire de contextes de chiffrement `"Department": "IT"`, l'octroi autorise les demandes du type spécifié uniquement lorsque le contexte de chiffrement de la requête est exactement `"Department": "IT"`.

**EncryptionContextSubset**  
Utilisez `EncryptionContextSubset` pour exiger que les demandes incluent des paires de contexte de chiffrement particulières.  
`EncryptionContextSubset` exige que la demande inclue toutes les paires de contexte de chiffrement de la contrainte d'octroi (une correspondance exacte sensible à la casse), mais la demande peut avoir des paires de contexte de chiffrement supplémentaires. Les paires peuvent apparaître dans n'importe quel ordre, mais les clés et valeurs dans chaque paire ne peuvent pas varier.   
Par exemple, si l'a contrainte d'octroi `EncryptionContextSubset` exige la paire de contextes de chiffrement `Department=IT`, l'octroi autorise les demandes du type spécifié uniquement lorsque le contexte de chiffrement de la requête est `"Department": "IT"` ou inclut `"Department": "IT"`, ainsi que d'autres paires de contexte de chiffrement, telles que `"Department": "IT","Purpose": "Test"`.

Pour spécifier une contrainte de contexte de chiffrement dans une autorisation pour une clé KMS de chiffrement symétrique, utilisez le `Constraints` paramètre dans l'[CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)opération. L'octroi créé par cette commande accorde aux utilisateurs qui sont autorisés à assumer le rôle `keyUserRole` l'autorisation d'appeler l'opération [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) (Déchiffrer). Toutefois, cette autorisation est effective uniquement lorsque le contexte de chiffrement de la demande `Decrypt` est une paire de contextes de chiffrement `"Department": "IT"`.

```
$ aws kms create-grant \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --grantee-principal arn:aws:iam::111122223333:role/keyUserRole \
    --operations Decrypt \
    --retiring-principal arn:aws:iam::111122223333:role/adminRole \
    --constraints EncryptionContextEquals={Department=IT}
```

L'octroi obtenu ressemble à ce qui suit. Notez que l'autorisation accordée au rôle `keyUserRole` n'est effective que lorsque la demande `Decrypt` utilise la même paire de contextes de chiffrement que celle spécifiée dans la contrainte d'octroi. Pour rechercher les autorisations sur une clé KMS, utilisez l'[ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)opération.

```
$ aws kms list-grants --key-id 1234abcd-12ab-34cd-56ef-1234567890ab
{
    "Grants": [
        {
            "Name": "",
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "GrantId": "abcde1237f76e4ba7987489ac329fbfba6ad343d6f7075dbd1ef191f0120514a",
            "Operations": [
                "Decrypt"
            ],
            "GranteePrincipal": "arn:aws:iam::111122223333:role/keyUserRole",
            "Constraints": {
                "EncryptionContextEquals": {
                    "Department": "IT"
                }
            },
            "CreationDate": 1568565290.0,
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "RetiringPrincipal": "arn:aws:iam::111122223333:role/adminRole"
        }
    ]
}
```

Pour satisfaire la contrainte d'octroi `EncryptionContextEquals`, le contexte de chiffrement dans la demande pour l'opération `Decrypt` doit être une paire `"Department": "IT"`. Une demande telle que la suivante émanant du principal bénéficiaire satisferait à la contrainte d'octroi `EncryptionContextEquals`.

```
$ aws kms decrypt \
    --key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab\
    --ciphertext-blob fileb://encrypted_msg \
    --encryption-context Department=IT
```

Lorsque la contrainte d'octroi est `EncryptionContextSubset`, les paires de contexte de chiffrement de la demande doivent inclure les paires de contexte de chiffrement dans la contrainte d'octroi, mais la demande peut également inclure d'autres paires de contexte de chiffrement. La contrainte d'octroi suivante nécessite que l'une des paires de contexte de chiffrement dans la demande soit `"Deparment": "IT"`.

```
"Constraints": {
   "EncryptionContextSubset": {
       "Department": "IT"
   }
}
```

La demande suivante émanant du principal bénéficiaire satisferait à la fois aux contraintes d'octroi `EncryptionContextEqual` et `EncryptionContextSubset` dans cet exemple.

```
$ aws kms decrypt \
    --key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab \
    --ciphertext-blob fileb://encrypted_msg \
    --encryption-context Department=IT
```

Toutefois, une demande comme celle qui suit émanant du principal bénéficiaire satisferait à la contrainte d'octroi `EncryptionContextSubset`, mais pas à la contrainte d'octroi `EncryptionContextEquals`.

```
$ aws kms decrypt \
    --key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab \
    --ciphertext-blob fileb://encrypted_msg \
    --encryption-context Department=IT,Purpose=Test
```

AWS les services utilisent souvent des contraintes de contexte de chiffrement dans les autorisations qui leur donnent l'autorisation d'utiliser des clés KMS dans votre Compte AWS. Par exemple, Amazon DynamoDB utilise un octroi comme le suivant pour obtenir l'autorisation d'utiliser la [Clé gérée par AWS](concepts.md#aws-managed-key) pour DynamoDB dans votre compte. La contrainte d'octroi `EncryptionContextSubset` de cet octroi rend les autorisations de l'octroi effectives uniquement lorsque le contexte de chiffrement de la demande inclut les paires`"subscriberID": "111122223333"` et `"tableName": "Services"`. Cette contrainte d'octroi signifie que l'octroi autorise DynamoDB à utiliser la clé KMS spécifiée uniquement pour une table particulière de votre Compte AWS.

Pour obtenir ce résultat, exécutez l'[ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)opération sur le Clé gérée par AWS pour DynamoDB de votre compte.

```
$ aws kms list-grants --key-id 0987dcba-09fe-87dc-65ba-ab0987654321

{
    "Grants": [
        {
            "Operations": [
                "Decrypt",
                "Encrypt",
                "GenerateDataKey",
                "ReEncryptFrom",
                "ReEncryptTo",
                "RetireGrant",
                "DescribeKey"
            ],
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "Constraints": {
                "EncryptionContextSubset": {
                    "aws:dynamodb:tableName": "Services",
                    "aws:dynamodb:subscriberId": "111122223333"
                }
            },
            "CreationDate": 1518567315.0,
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321",
            "GranteePrincipal": "dynamodb.us-west-2.amazonaws.com",
            "RetiringPrincipal": "dynamodb.us-west-2.amazonaws.com",
            "Name": "8276b9a6-6cf0-46f1-b2f0-7993a7f8c89a",
            "GrantId": "1667b97d27cf748cf05b487217dd4179526c949d14fb3903858e25193253fe59"
        }
    ]
}
```

#### SourceArn contrainte
<a name="grant-constraints-source-arn"></a>

**SourceArn**  <a name="terms-source-arn-constraint"></a>
La `SourceArn` contrainte limite les autorisations d'octroi aux demandes effectuées pour le compte d'une AWS ressource spécifique, identifiée par son Amazon Resource Name (ARN). La contrainte d'`SourceArn`octroi insère effectivement une clé de condition [aws:SourceArn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) globale dans la subvention et n'est évaluée que lorsque la demande est faite par un AWS service.  
La `SourceArn` contrainte est toujours requise lorsque la subvention spécifie un`GranteeServicePrincipal`. Il peut éventuellement être utilisé avec`GranteePrincipal`.   
Contrairement aux contraintes liées au contexte de chiffrement, la `SourceArn` contrainte est prise en charge lors des autorisations pour * tous les types * de clés KMS.

Pour spécifier une `SourceArn` contrainte dans une autorisation, utilisez le `Constraints` paramètre dans l'[CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)opération. L'exemple suivant crée une autorisation qui permet à un AWS responsable de service d'appeler les `Decrypt` opérations `Encrypt` and, mais uniquement lorsque la demande est faite pour le compte de la table DynamoDB spécifiée. La `SourceArn` contrainte est requise lorsque la subvention spécifie un`GranteeServicePrincipal`.

```
$ aws kms create-grant \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --grantee-service-principal {{service-name}}.amazonaws.com \
    --operations Encrypt Decrypt \
    --retiring-service-principal {{service-name}}.amazonaws.com \
    --constraints '{"SourceArn":"arn:aws:dynamodb:us-east-1:111122223333:table/ExampleTable"}'
```

La subvention qui en résulte ressemble à ce qui suit. Les autorisations de l'autorisation ne sont effectives que lorsque la demande inclut un ARN source qui correspond à la `SourceArn` valeur de la contrainte d'autorisation.

```
$ aws kms list-grants --key-id 1234abcd-12ab-34cd-56ef-1234567890ab
{
    "Grants": [
        {
            "Name": "",
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "GrantId": "abcde1237f76e4ba7987489ac329fbfba6ad343d6f7075dbd1ef191f0120514a",
            "Operations": [
                "Encrypt",
                "Decrypt"
            ],
            "GranteeServicePrincipal": "{{service-name}}.amazonaws.com",
            "Constraints": {
                "SourceArn": "arn:aws:dynamodb:us-east-1:111122223333:table/ExampleTable"
            },
            "CreationDate": 1718567315.0,
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "RetiringServicePrincipal": "{{service-name}}.amazonaws.com"
        }
    ]
}
```

Vous pouvez également combiner plusieurs contraintes dans une seule subvention. Vous pouvez toutefois spécifier l'un `EncryptionContextEquals` ou l'autre`EncryptionContextSubset`, mais pas les deux. 

Lorsqu'elle `GranteeServicePrincipal` est spécifiée, la `SourceArn` contrainte est obligatoire. Les combinaisons valides pour créer une subvention avec plusieurs contraintes sont donc les suivantes :
+ `EncryptionContextEquals` avec `SourceArn`
+ `EncryptionContextSubset` avec `SourceArn`

L'exemple suivant crée une autorisation avec `GranteeServicePrincipal` et et `RetiringServicePrincipal` inclut à la fois une `EncryptionContextSubset` contrainte et une `SourceArn` contrainte.

```
$ aws kms create-grant \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --grantee-service-principal {{service-name}}.amazonaws.com \
    --retiring-service-principal {{service-name}}.amazonaws.com \
    --operations Encrypt Decrypt GenerateDataKey DescribeKey \
    --constraints '{"EncryptionContextSubset":{"Department":"IT"},"SourceArn":"arn:aws:dynamodb:us-east-1:111122223333:table/ExampleTable"}'
```

La subvention qui en résulte ressemble à ce qui suit. Notez que la réponse inclut des `RetiringServicePrincipal` champs `GranteeServicePrincipal` et que le `Constraints` champ contient à la fois `EncryptionContextSubset` et`SourceArn`.

```
$ aws kms list-grants --key-id 1234abcd-12ab-34cd-56ef-1234567890ab
{
    "Grants": [
        {
            "Name": "",
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "GrantId": "abcde1237f76e4ba7987489ac329fbfba6ad343d6f7075dbd1ef191f0120514a",
            "Operations": [
                "Encrypt",
                "Decrypt",
                "GenerateDataKey",
                "DescribeKey"
            ],
            "GranteeServicePrincipal": "{{service-name}}.amazonaws.com",
            "Constraints": {
                "EncryptionContextSubset": {
                    "Department": "IT"
                },
                "SourceArn": "arn:aws:dynamodb:us-east-1:111122223333:table/ExampleTable"
            },
            "CreationDate": 1718567315.0,
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "RetiringServicePrincipal": "{{service-name}}.amazonaws.com"
        }
    ]
}
```

## Accorder CreateGrant une autorisation
<a name="grant-creategrant"></a>

Un octroi peut inclure l'autorisation d'appeler l'opération `CreateGrant`. Toutefois, quand un [principal bénéficiaire](grants.md#terms-grantee-principal) obtient l'autorisation d'appeler `CreateGrant` à partir d'un octroi, plutôt que d'une politique, cette autorisation est limitée. 
+ Le principal bénéficiaire peut uniquement créer des octrois qui permettent une partie ou la totalité des opérations de l'octroi parent.
+ Les [contraintes d'octroi](#grant-constraints) dans les octrois qu'elles créent doivent être au moins aussi strictes que celles de l'octroi parent.

Ces limites ne s'appliquent pas aux principaux qui obtiennent l'autorisation `CreateGrant` à partir d'une politique, bien que leurs autorisations puissent être limitées par des [conditions de politique](grant-authorization.md).

Par exemple, imaginons un octroi qui autorise le principal bénéficiaire à appeler les opérations `GenerateDataKey`, `Decrypt` et `CreateGrant`. Nous appelons un octroi qui autorise l'autorisation `CreateGrant` d'un *octroi parent*.

```
# The original grant in a ListGrants response.
{
    "Grants": [
        {
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "CreationDate": 1572216195.0,
            "GrantId": "abcde1237f76e4ba7987489ac329fbfba6ad343d6f7075dbd1ef191f0120514a",
            "Operations": [
                "GenerateDataKey",
                "Decrypt",
                "CreateGrant
            ]
            "RetiringPrincipal": "arn:aws:iam::111122223333:role/adminRole",
            "Name": "",
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "GranteePrincipal": "arn:aws:iam::111122223333:role/keyUserRole",
            "Constraints": {
                "EncryptionContextSubset": {
                    "Department": "IT"
                }
            },
        }
    ]
}
```

Le principal bénéficiaire, exampleUser, peut utiliser cette autorisation pour créer un octroi qui inclut n'importe quel sous-ensemble des opérations spécifiées dans l'octroi parent, par exemple `CreateGrant` et `Decrypt`. L'*octroi enfant* ne peut pas inclure d'autres opérations, comme `ScheduleKeyDeletion` ou `ReEncrypt`.

De plus, les [contraintes d'octroi](https://docs.aws.amazon.com/kms/latest/APIReference/API_GrantConstraints.html) des octrois enfants doivent être aussi restrictives, voire plus, que celles de l'octroi parent. Par exemple, l'octroi enfant peut ajouter des paires dans une contrainte `EncryptionContextSubset` de l'octroi parent, mais ne peut pas les supprimer. L'octroi enfant peut modifier une contrainte `EncryptionContextSubset` en contrainte `EncryptionContextEquals`, mais pas l'inverse.

Les bonnes pratiques IAM déconseillent d'avoir recours à des utilisateurs IAM dotés d'informations d'identification à long terme. Dans la mesure du possible, utilisez des rôles IAM, qui fournissent des informations d'identification temporaires. Pour plus d'informations, consultez [Security best practices in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) (Bonnes pratiques de sécurité dans IAM) dans le *Guide de l'utilisateur IAM*.

Par exemple, le principal bénéficiaire peut utiliser l'autorisation `CreateGrant` qu'il a obtenue de l'octroi parent pour créer l'octroi enfant suivant. Les opérations de l'octroi enfant sont un sous-ensemble des opérations de l'octroi parent et les contraintes d'octroi sont plus restrictives.

```
# The child grant in a ListGrants response.
{
    "Grants": [
        {
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "CreationDate": 1572249600.0,
            "GrantId": "fedcba9999c1e2e9876abcde6e9d6c9b6a1987650000abcee009abcdef40183f",
            "Operations": [
                "CreateGrant"
                "Decrypt"
            ]
            "RetiringPrincipal": "arn:aws:iam::111122223333:user/exampleUser",
            "Name": "",
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "GranteePrincipal": "arn:aws:iam::111122223333:user/anotherUser",
            "Constraints": {
                "EncryptionContextEquals": {
                    "Department": "IT"
                }
            },
        }
    ]
}
```

Le principal bénéficiaire de l'octroi enfant ,`anotherUser`, peut utiliser son autorisation `CreateGrant` pour créer des octrois. Cependant, les octrois que `anotherUser` crée doit inclure les opérations dans leur octroi parent ou un sous-ensemble, et les contraintes d'octroi doivent être les mêmes ou plus strictes. 