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.
# Configuration et gestion de l'accès aux ressources dans votre AWS SAM modèle
Pour que vos AWS ressources puissent interagir les unes avec les autres, l'accès et les autorisations appropriés doivent être configurés entre vos ressources. Pour ce faire, vous devez configurer les utilisateurs, les rôles et les politiques Gestion des identités et des accès AWS (IAM) pour effectuer votre interaction de manière sécurisée.
Les rubriques de cette section concernent toutes la configuration de l'accès aux ressources définies dans votre modèle. Cette section commence par les meilleures pratiques générales. Les deux rubriques suivantes passent en revue deux options dont vous disposez pour configurer l'accès et les autorisations entre les ressources référencées dans votre application sans serveur : les AWS SAM connecteurs et les modèles de AWS SAM politique. La dernière rubrique fournit des détails sur la gestion de l'accès des utilisateurs à l'aide des mêmes mécanismes que CloudFormation ceux utilisés pour gérer les utilisateurs.
Pour en savoir plus, veuillez consulter la rubrique [Contrôle de l'accès avec Gestion des identités et des accès AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) dans le *Guide de l'utilisateur AWS CloudFormation *.
Le AWS Serverless Application Model (AWS SAM) propose deux options qui simplifient la gestion des accès et des autorisations pour vos applications sans serveur.
1. AWS SAM connecteurs
1. Modèles de politique AWS SAM
## AWS SAM connecteurs
Les connecteurs permettent de fournir des autorisations entre deux ressources. Pour ce faire, décrivez comment ils doivent interagir les uns avec les autres dans votre AWS SAM modèle. Ils peuvent être définis à l'aide de l'attribut de ressource `Connectors` ou du type de ressource `AWS::Serverless::Connector`. Les connecteurs prennent en charge le provisionnement `Read` et l'`Write`accès aux données et aux événements entre une combinaison de AWS ressources. Pour en savoir plus sur les AWS SAM connecteurs, voir[Gestion des autorisations relatives aux ressources à l'aide de AWS SAM connecteurs](managing-permissions-connectors.md).
## Modèles de politique AWS SAM
AWS SAM les modèles de politique sont des ensembles prédéfinis d'autorisations que vous pouvez ajouter à vos AWS SAM modèles pour gérer l'accès et les autorisations entre vos AWS Lambda fonctions, vos machines AWS Step Functions d'état et les ressources avec lesquelles elles interagissent. Pour en savoir plus sur les modèles de AWS SAM politiques, consultez[Modèles de politique AWS SAM](serverless-policy-templates.md).
## AWS CloudFormation mécanismes
CloudFormation les mécanismes incluent la configuration des utilisateurs, des rôles et des politiques IAM pour gérer les autorisations entre vos AWS ressources. Pour en savoir plus, veuillez consulter la section [Gestion des AWS SAM autorisations à l'aide de CloudFormation mécanismes](sam-permissions-cloudformation.md).
## Bonnes pratiques
Dans l'ensemble de vos applications sans serveur, vous pouvez utiliser plusieurs méthodes pour configurer les autorisations entre vos ressources. Vous pouvez donc sélectionner la meilleure option pour chaque scénario et utiliser plusieurs options ensemble dans vos applications. Voici quelques éléments à prendre en compte lors du choix de l'option la mieux adaptée à votre cas :
+ AWS SAM les connecteurs et les modèles de politique réduisent tous deux l'expertise IAM requise pour faciliter les interactions sécurisées entre vos AWS ressources. Utilisez des connecteurs et des modèles de politique lorsque cela est possible.
+ AWS SAM les connecteurs fournissent une syntaxe abrégée simple et intuitive pour définir les autorisations dans vos AWS SAM modèles et nécessitent le moins d'expertise en matière d'IAM. Lorsque les AWS SAM connecteurs et les modèles de politique sont pris en charge, utilisez des AWS SAM connecteurs.
+ AWS SAM les connecteurs peuvent fournir des données `Read` et des événements et `Write` y accéder entre les ressources AWS SAM source et de destination prises en charge. Pour afficher la liste des ressources prises en charge, consultez [AWS SAM référence du connecteur](reference-sam-connector.md). Lorsque cela est pris en charge, utilisez AWS SAM des connecteurs.
+ Bien que les modèles de AWS SAM politique soient limités aux autorisations entre vos fonctions Lambda, les machines d'état Step Functions et les AWS ressources avec lesquelles elles interagissent, les modèles de politique prennent en charge toutes les opérations CRUD. Lorsque cela est pris en charge et qu'un modèle de AWS SAM stratégie adapté à votre scénario est disponible, utilisez des modèles AWS SAM de stratégie. Pour afficher la liste des modèles de politique disponibles, consultez [Modèles de politique AWS SAM](serverless-policy-templates.md).
+ Pour tous les autres scénarios, ou lorsque la granularité est requise, utilisez CloudFormation des mécanismes.
# Gestion des autorisations relatives aux ressources à l'aide de AWS SAM connecteurs
Les connecteurs sont un AWS Serverless Application Model (AWS SAM) type de ressource abstrait, identifié comme tel`AWS::Serverless::Connector`, qui fournit des autorisations simples et bien définies entre les ressources de vos applications sans serveur.
## Avantages des AWS SAM connecteurs
En composant automatiquement les politiques d'accès appropriées entre les ressources, les connecteurs vous permettent de créer vos applications sans serveur et de vous concentrer sur l'architecture de votre application sans avoir besoin d'expertise en matière de fonctionnalités d' AWS autorisation, de langage de politique et de paramètres de sécurité spécifiques aux services. Par conséquent, les connecteurs constituent un avantage considérable pour les développeurs novices en matière de développement sans serveur, mais également pour les développeurs chevronnés qui souhaitent augmenter leur vitesse de développement.
## Utilisation de AWS SAM connecteurs
Utilisez l'attribut de ressource `Connectors` en l'incorporant dans une ressource **source**. Définissez ensuite votre ressource de **destination** et décrivez comment les données ou les événements doivent circuler entre ces ressources. AWS SAM compose ensuite les politiques d'accès nécessaires pour faciliter les interactions requises.
Voici un aperçu de la façon dont cet attribut de ressource est écrit :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
Destination:
Permissions:
...
```
## Fonctionnement des connecteurs
**Note**
Cette section explique comment les connecteurs fournissent les ressources nécessaires en arrière-plan. Cela se produit automatiquement lorsque vous utilisez des connecteurs.
Tout d'abord, l'attribut de ressource `Connectors` intégré est transformé en un type de ressource `AWS::Serverless::Connector`. Son identifiant logique est automatiquement créé en tant que**.
Par exemple, voici un connecteur intégré :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Cela générera la ressource `AWS::Serverless::Connector` suivante :
```
Transform: AWS::Serverless-2016-10-31
Resources:
...
MyFunctionMyConn:
Type: AWS::Serverless::Connector
Properties:
Source:
Id: MyFunction
Destination:
Id: MyTable
Permissions:
- Read
- Write
```
**Note**
Vous pouvez également définir des connecteurs dans votre AWS SAM modèle à l'aide de cette syntaxe. Cela est recommandé lorsque votre ressource source est définie sur un modèle distinct de votre connecteur.
Ensuite, les politiques d'accès nécessaires à cette connexion sont automatiquement élaborées. Pour plus d'informations sur les ressources générées par les connecteurs, consultez [CloudFormation ressources générées lorsque vous spécifiez AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).
## Exemple de connecteurs
L'exemple suivant montre comment utiliser des connecteurs pour écrire des données d'une AWS Lambda fonction dans une table Amazon DynamoDB.
![\[Fonction Lambda écrivant des données dans une table DynamoDB à l'aide de connecteurs. AWS SAM\]](http://docs.aws.amazon.com/fr_fr/serverless-application-model/latest/developerguide/images/managing-connectors-example.png)
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyTable:
Type: AWS::Serverless::SimpleTable
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Write
Properties:
Runtime: nodejs16.x
Handler: index.handler
InlineCode: |
const AWS = require("aws-sdk");
const docClient = new AWS.DynamoDB.DocumentClient();
exports.handler = async (event, context) => {
await docClient.put({
TableName: process.env.TABLE_NAME,
Item: {
id: context.awsRequestId,
event: JSON.stringify(event)
}
}).promise();
}
Environment:
Variables:
TABLE_NAME: !Ref MyTable
```
L'attribut de ressource `Connectors` est intégré à la ressource source de la fonction Lambda. La table DynamoDB est définie comme la ressource de destination à l'aide de la propriété `Id`. Les connecteurs fourniront des autorisations `Write` entre ces deux ressources.
Lorsque vous déployez votre AWS SAM modèle sur CloudFormation, il compose AWS SAM automatiquement les politiques d'accès nécessaires au bon fonctionnement de cette connexion.
## Connexions prises en charge entre les ressources source et de destination
Les connecteurs prennent en charge les types d'autorisations `Read` et `Write` pour les données et les événements entre une combinaison choisie de connexions de ressources source et destination. Par exemple, ils prennent en charge une connexion `Write` entre une ressource source `AWS::ApiGateway::RestApi` et une ressource destination `AWS::Lambda::Function`.
Les ressources source et de destination peuvent être définies à l'aide d'une combinaison de propriétés prises en charge. Les exigences en matière de propriété dépendent de la connexion que vous établissez et de l'endroit où les ressources sont définies.
**Note**
Les connecteurs peuvent attribuer des autorisations entre les types de ressources sans serveur et non sans serveur pris en charge.
Pour obtenir la liste des connexions aux ressources prises en charge et de leurs exigences en matière de propriétés, consultez [Types de ressources source et de destination pris en charge pour les connecteurs](reference-sam-connector.md#supported-connector-resource-types).
# Définissez les autorisations de lecture et d'écriture dans AWS SAM
Dans AWS SAM, `Read` et `Write` les autorisations peuvent être allouées au sein d'un seul connecteur :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyTableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Pour plus d'informations sur l'utilisation des connecteurs, reportez-vous à[AWS SAM référence du connecteur](reference-sam-connector.md).
# Définissez les ressources à l'aide d'autres propriétés prises en charge dans AWS SAM
Pour les ressources source et de destination, lorsqu'elles sont définies dans le même modèle, utilisez la propriété `Id`. Sinon, un élément `Qualifier` peut être ajouté pour réduire la portée de la ressource que vous avez définie. Quand les ressources ne se trouvent pas dans le même modèle, utilisez une combinaison d'autres propriétés prises en charge.
+ Pour obtenir la liste des combinaisons de propriétés prises en charge pour les ressources source et de destination, consultez [Types de ressources source et de destination pris en charge pour les connecteurs](reference-sam-connector.md#supported-connector-resource-types).
+ Pour obtenir une description des propriétés que vous pouvez utiliser avec les connecteurs, reportez-vous à la section [AWS::Serverless::Connector](sam-resource-connector.md).
Lorsque vous définissez une ressource source avec une propriété autre que la propriété `Id`, utilisez la propriété `SourceReference`.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
SourceReference:
Qualifier:
Destination:
Permissions:
```
Voici un exemple d'utilisation d'un élément `Qualifier` pour réduire la portée d'une ressource Amazon API Gateway :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyApi:
Type: AWS::Serverless::Api
Connectors:
ApiToLambdaConn:
Properties:
SourceReference:
Qualifier: Prod/GET/foobar
Destination:
Id: MyFunction
Permissions:
- Write
...
```
Voici un exemple utilisant une combinaison prise en charge d'éléments `Arn` et `Type` pour définir une ressource de destination à partir d'un autre modèle :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
TableConn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
...
```
Pour plus d'informations sur l'utilisation des connecteurs, reportez-vous à[AWS SAM référence du connecteur](reference-sam-connector.md).
# Créez plusieurs connecteurs à partir d'une seule source dans AWS SAM
Au sein d'une ressource source, vous pouvez définir plusieurs connecteurs, chacun ayant une ressource de destination différente.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
BucketConn:
Properties:
Destination:
Id: amzn-s3-demo-bucket
Permissions:
- Read
- Write
SQSConn:
Properties:
Destination:
Id: MyQueue
Permissions:
- Read
- Write
TableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
TableConnWithTableArn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
Permissions:
- Read
- Write
...
```
Pour plus d'informations sur l'utilisation des connecteurs, reportez-vous à[AWS SAM référence du connecteur](reference-sam-connector.md).
# Créez des connecteurs à destinations multiples dans AWS SAM
Au sein d'une ressource source, vous pouvez définir un connecteur unique avec plusieurs ressources de destination. Voici un exemple de ressource source d'une fonction Lambda connectée à un compartiment Amazon Simple Storage Service (Amazon S3) et à une table DynamoDB :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
WriteAccessConn:
Properties:
Destination:
- Id: OutputBucket
- Id: CredentialTable
Permissions:
- Write
...
OutputBucket:
Type: AWS::S3::Bucket
CredentialTable:
Type: AWS::DynamoDB::Table
```
Pour plus d'informations sur l'utilisation des connecteurs, reportez-vous à[AWS SAM référence du connecteur](reference-sam-connector.md).
# Définissez les attributs des ressources à l'aide de connecteurs dans AWS SAM
Les attributs de ressource peuvent être définis pour les ressources afin de spécifier des comportements et des relations supplémentaires. Pour plus d'informations sur les attributs des ressources, consultez [Référence d'attribut de ressource](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html) dans le *Guide de l'utilisateur AWS CloudFormation *.
Vous pouvez ajouter des attributs de ressource à votre connecteur intégré en les définissant au même niveau que les propriétés de votre connecteur. Lorsque votre AWS SAM modèle est transformé lors du déploiement, les attributs sont transmis aux ressources générées.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
DeletionPolicy: Retain
DependsOn: AnotherFunction
Properties:
...
```
Pour plus d'informations sur l'utilisation des connecteurs, reportez-vous à[AWS SAM référence du connecteur](reference-sam-connector.md).
## En savoir plus
Pour plus d'informations sur l'utilisation des AWS SAM connecteurs, consultez les rubriques suivantes :
+ [AWS::Serverless::Connector](sam-resource-connector.md)
+ [Définissez les autorisations de lecture et d'écriture dans AWS SAM](connector-usage-define.md)
+ [Définissez les ressources à l'aide d'autres propriétés prises en charge dans AWS SAM](connector-usage-other-properties.md)
+ [Créez plusieurs connecteurs à partir d'une seule source dans AWS SAM](connector-usage-single-source.md)
+ [Créez des connecteurs à destinations multiples dans AWS SAM](connector-usage-multi-destination.md)
+ [Définissez les autorisations de lecture et d'écriture dans AWS SAM](connector-usage-define.md)
+ [Définissez les attributs des ressources à l'aide de connecteurs dans AWS SAM](connector-usage-resource-attributes.md)
## Faire un commentaire
Pour fournir des commentaires sur les connecteurs, [soumettez un nouveau problème](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) dans le *serverless-application-model AWS GitHubréférentiel*.
# Modèles de politique AWS SAM
Le AWS Serverless Application Model (AWS SAM) vous permet de choisir parmi une liste de modèles de politiques pour étendre les autorisations de vos fonctions Lambda et de vos machines d' AWS Step Functions état aux ressources utilisées par votre application.
AWS SAM les applications du AWS Serverless Application Repository qui utilisent des modèles de politique ne nécessitent aucun accusé de réception spécial du client pour déployer l'application depuis le. AWS Serverless Application Repository
Si vous souhaitez demander un nouveau modèle de stratégie à ajouter, procédez comme suit :
1. Soumettez une pull request sur le fichier source policy\$1templates.json dans la branche du `develop` projet. AWS SAM GitHub Vous pouvez trouver le fichier source dans [policy\$1templates.json](https://github.com/aws/serverless-application-model/blob/develop/samtranslator/policy_templates_data/policy_templates.json) sur le site Web. GitHub
1. Soumettez un problème dans le AWS SAM GitHub projet qui inclut les raisons de votre pull request et un lien vers la demande. Utilisez ce lien pour soumettre un nouveau problème : [AWS Serverless Application Model : Problèmes](https://github.com/aws/serverless-application-model/issues/new).
## Syntaxe
Pour chaque modèle de stratégie que vous spécifiez dans votre fichier de AWS SAM modèle, vous devez toujours spécifier un objet contenant les valeurs d'espace réservé du modèle de stratégie. Si un modèle de stratégie ne nécessite aucune valeur d'espace réservé, vous devez spécifier un objet vide.
### YAML
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Policies:
- PolicyTemplateName1: # Policy template with placeholder value
Key1: Value1
- PolicyTemplateName2: {} # Policy template with no placeholder value
```
**Note**
Si vous avez configuré une politique IAM normale ou si vous avez géré des politiques via Lambda, le modèle de stratégie peut être défini sans utiliser d'objet vide.
## Exemples
### Exemple 1 : Modèle de stratégie avec des valeurs d'espace réservé
L'exemple suivant montre que le modèle de stratégie [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) attend un `QueueName` comme ressource. Le AWS SAM modèle récupère le nom de la file « `MyQueue` » Amazon SQS, que vous pouvez créer dans la même application ou demander en tant que paramètre de l'application.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - SQSPollerPolicy:
9. QueueName:
10. !GetAtt MyQueue.QueueName
```
### Exemple 2 : modèle de stratégie sans valeurs d'espace réservé
L'exemple suivant contient le modèle de stratégie[CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy), qui n'a pas de valeurs d'espace réservé.
**Note**
Même s'il n'y a pas de valeurs d'espace réservé, vous devez spécifier un objet vide, sinon une erreur se produira.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - CloudWatchPutMetricPolicy: {}
```
### Exemple 3 : modèle de politique avec des valeurs d'espace réservé et une politique IAM normale
L'exemple suivant contient la politique et [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) le modèle de politique Amazon SQSFull Access. La politique Amazon SQSFull Access est une politique IAM et non une AWS SAM politique. Il n'est donc pas nécessaire de spécifier un objet vide car la politique serait directement transmise au CloudFormation.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - AmazonSQSFullAccess // IAM policy could be set without passing an empty object
9. - DynamoDBCrudPolicy: // SAM specific policy, has a defined structure
10. TableName:
11. !Ref SampleTable
```
## Tableau de modèle de stratégie
Voici un tableau des modèles de stratégie disponibles.
****
| Modèle de stratégie | Description |
| --- | --- |
| [AcmGetCertificatePolicy](serverless-policy-template-list.md#acm-get-certificate-policy) | Donne l'autorisation de lire un certificat à partir de AWS Certificate Manager. |
| [AMIDescribePolicy](serverless-policy-template-list.md#ami-describe-policy) | Donne l'autorisation de décrire Amazon Machine Images (AMIs). |
| [AthenaQueryPolicy](serverless-policy-template-list.md#athena-query-policy) | Donne des autorisations pour exécuter des requêtes Athena. |
| [AWSSecretsManagerGetSecretValuePolicy](serverless-policy-template-list.md#secrets-manager-get-secret-value-policy) | Donne l'autorisation d'obtenir la valeur secrète pour le secret AWS Secrets Manager spécifié. |
| [AWSSecretsManagerRotationPolicy](serverless-policy-template-list.md#secrets-manager-rotation-policy) | Donne l'autorisation de faire pivoter un secret dans AWS Secrets Manager. |
| [CloudFormationDescribeStacksPolicy](serverless-policy-template-list.md#cloud-formation-describe-stacks-policy) | Donne l'autorisation de décrire les CloudFormation piles. |
| [CloudWatchDashboardPolicy](serverless-policy-template-list.md#cloudwatch-dashboard-policy) | Permet de placer des métriques à appliquer sur les CloudWatch tableaux de bord. |
| [CloudWatchDescribeAlarmHistoryPolicy](serverless-policy-template-list.md#cloudwatch-describe-alarm-history-policy) | Permet de décrire l'historique des CloudWatch alarmes. |
| [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) | Donne l'autorisation d'envoyer des métriques à CloudWatch. |
| [CodeCommitCrudPolicy](serverless-policy-template-list.md#codecommit-crud-policy) | Donne des autorisations aux create/read/update/delete objets d'un CodeCommit référentiel spécifique. |
| [CodeCommitReadPolicy](serverless-policy-template-list.md#codecommit-read-policy) | Permet de lire des objets au sein d'un CodeCommit référentiel spécifique. |
| [CodePipelineLambdaExecutionPolicy](serverless-policy-template-list.md#code-pipeline-lambda-execution-policy) | Permet à une fonction Lambda invoquée par CodePipeline de signaler l'état de la tâche. |
| [CodePipelineReadOnlyPolicy](serverless-policy-template-list.md#code-pipeline-readonly-policy) | Donne l'autorisation de lecture pour obtenir des informations sur un CodePipeline pipeline. |
| [ComprehendBasicAccessPolicy](serverless-policy-template-list.md#comprehend-basic-access-policy) | Donne l'autorisation de détecter des entités, des expressions clés, des langues et des sentiments. |
| [CostExplorerReadOnlyPolicy](serverless-policy-template-list.md#cost-explorer-readonly-policy) | Donne une autorisation en lecture seule à Cost APIs Explorer en lecture seule pour l'historique de facturation. |
| [DynamoDBBackupFullAccessPolicy](serverless-policy-template-list.md#ddb-back-full-policy) | Donne l'autorisation de lecture/écriture aux sauvegardes DynamoDB à la demande pour une table. |
| [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) | Donne les autorisations de créer, lire, mettre à jour, supprimer à une table Amazon DynamoDB. |
| [DynamoDBReadPolicy](serverless-policy-template-list.md#dynamo-db-read-policy) | Donne l'autorisation de lecture seule à une table DynamoDB. |
| [DynamoDBReconfigurePolicy](serverless-policy-template-list.md#dynamo-db-reconfigure-policy) | Donne l'autorisation de reconfigurer une table DynamoDB. |
| [DynamoDBRestoreFromBackupPolicy](serverless-policy-template-list.md#ddb-restore-from-backup-policy) | Donne l'autorisation de restaurer une table DynamoDB à partir d'une sauvegarde. |
| [DynamoDBStreamReadPolicy](serverless-policy-template-list.md#dynamo-db-stream-read-policy) | Donne l'autorisation de décrire et de lire les flux DynamoDB Streams ainsi que les enregistrements. |
| [DynamoDBWritePolicy](serverless-policy-template-list.md#dynamo-db-write-policy) | Donne l'autorisation d'écriture seule à une table DynamoDB. |
| [EC2CopyImagePolicy](serverless-policy-template-list.md#ec2-copy-image-policy) | Donne l'autorisation de copier les images Amazon EC2. |
| [EC2DescribePolicy](serverless-policy-template-list.md#ec2-describe-policy) | Donne l'autorisation de décrire des instances Amazon Elastic Compute Cloud (Amazon EC2). |
| [EcsRunTaskPolicy](serverless-policy-template-list.md#ecs-run-task-policy) | Donne l'autorisation de démarrer une nouvelle tâche pour une définition de tâche. |
| [EFSWriteAccessPolicy](serverless-policy-template-list.md#efs-write-access-policy) | Donne l'autorisation de monter un système de fichiers Amazon EFS avec accès en écriture. |
| [EKSDescribePolicy](serverless-policy-template-list.md#eks-describe-policy) | Donne l'autorisation de décrire ou de répertorier les clusters Amazon EKS. |
| [ElasticMapReduceAddJobFlowStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-add-job-flows-policy) | Donne l'autorisation d'ajouter de nouvelles étapes à un cluster en cours d'exécution. |
| [ElasticMapReduceCancelStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-cancel-steps-policy) | Donne l'autorisation d'annuler une étape ou des étapes en attente dans un cluster en cours d'exécution. |
| [ElasticMapReduceModifyInstanceFleetPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-fleet-policy) | Donne l'autorisation de répertorier les détails et de modifier les capacités des flottes d'instances au sein d'un cluster. |
| [ElasticMapReduceModifyInstanceGroupsPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-groups-policy) | Donne l'autorisation de répertorier les détails et de modifier les réglages des groupes d'instances au sein d'un cluster. |
| [ElasticMapReduceSetTerminationProtectionPolicy](serverless-policy-template-list.md#elastic-map-reduce-set-termination-protection-policy) | Donne l'autorisation de définir une protection contre l'arrêt pour un cluster. |
| [ElasticMapReduceTerminateJobFlowsPolicy](serverless-policy-template-list.md#elastic-map-reduce-terminate-job-flows-policy) | Donne l'autorisation d'arrêter un cluster. |
| [ElasticsearchHttpPostPolicy](serverless-policy-template-list.md#elastic-search-http-post-policy) | Donne l'autorisation POST à Amazon OpenSearch Service. |
| [EventBridgePutEventsPolicy](serverless-policy-template-list.md#eventbridge-put-events-policy) | Donne l'autorisation d'envoyer des événements à EventBridge. |
| [FilterLogEventsPolicy](serverless-policy-template-list.md#filter-log-events-policy) | Donne l'autorisation de filtrer CloudWatch les événements des journaux à partir d'un groupe de journaux spécifié. |
| [FirehoseCrudPolicy](serverless-policy-template-list.md#firehose-crud-policy) | Donne l'autorisation de créer, d'écrire, de mettre à jour et de supprimer un flux de diffusion Firehose. |
| [FirehoseWritePolicy](serverless-policy-template-list.md#firehose-write-policy) | Donne l'autorisation d'écrire dans un flux de diffusion Firehose. |
| [KinesisCrudPolicy](serverless-policy-template-list.md#kinesis-crud-policy) | Donne l'autorisation de créer, publier et supprimer un flux Amazon Kinesis. |
| [KinesisStreamReadPolicy](serverless-policy-template-list.md#kinesis-stream-read-policy) | Donne l'autorisation d'afficher et de lire un flux Amazon Kinesis. |
| [KMSDecryptPolicy](serverless-policy-template-list.md#kms-decrypt-policy) | Donne l'autorisation de déchiffrer avec une clé AWS Key Management Service (AWS KMS). |
| [KMSEncryptPolicy](serverless-policy-template-list.md#kms-encrypt-policy) | Donne l'autorisation de chiffrer avec une clé AWS Key Management Service (AWS KMS). |
| [LambdaInvokePolicy](serverless-policy-template-list.md#lambda-invoke-policy) | Donne l'autorisation d'invoquer une AWS Lambda fonction, un alias ou une version. |
| [MobileAnalyticsWriteOnlyAccessPolicy](serverless-policy-template-list.md#mobile-analytics-write-only-access-policy) | Donne uniquement l'autorisation d'écriture pour placer les données d'événements pour toutes les ressources d'application. |
| [OrganizationsListAccountsPolicy](serverless-policy-template-list.md#organizations-list-accounts-policy) | Donne l'autorisation en lecture seule de répertorier les noms de comptes enfants et. IDs |
| [PinpointEndpointAccessPolicy](serverless-policy-template-list.md#pinpoint-endpoint-access-policy) | Donne l'autorisation d'obtenir et de mettre à jour les points de terminaison pour une application Amazon Pinpoint. |
| [PollyFullAccessPolicy](serverless-policy-template-list.md#polly-full-access-policy) | Donne l'autorisation d'accès complet aux ressources de lexique Amazon Polly. |
| [RekognitionDetectOnlyPolicy](serverless-policy-template-list.md#rekognition-detect-only-policy) | Donne l'autorisation de comparer et de détecter les visages et les étiquettes. |
| [RekognitionFacesManagementPolicy](serverless-policy-template-list.md#rekognition-face-management-policy) | Donne l'autorisation d'ajouter, de supprimer et de rechercher des visages dans une collection Amazon Rekognition. |
| [RekognitionFacesPolicy](serverless-policy-template-list.md#rekognition-faces-policy) | Donne l'autorisation de comparer et de détecter les visages et les étiquettes. |
| [RekognitionLabelsPolicy](serverless-policy-template-list.md#rekognition-labels-policy) | Donne l'autorisation de détecter les étiquettes d'objet et de modération. |
| [RekognitionNoDataAccessPolicy](serverless-policy-template-list.md#rekognition-no-data-access-policy) | Donne l'autorisation de comparer et de détecter les visages et les étiquettes. |
| [RekognitionReadPolicy](serverless-policy-template-list.md#rekognition-read-policy) | Donne l'autorisation de lister et de rechercher des visages. |
| [RekognitionWriteOnlyAccessPolicy](serverless-policy-template-list.md#rekognition-write-only-access-policy) | Donne l'autorisation de créer des collections et d'indexer des visages. |
| [Route53ChangeResourceRecordSetsPolicy](serverless-policy-template-list.md#route53-change-resource-record-sets-policy) | Donne l'autorisation de modifier des jeux d'enregistrements de ressources dans Route 53. |
| [S3CrudPolicy](serverless-policy-template-list.md#s3-crud-policy) | Donne l'autorisation de créer, lire, mettre à jour et supprimer pour agir sur les objets d'un compartiment Amazon S3. |
| [S3FullAccessPolicy](serverless-policy-template-list.md#s3-full-access-policy) | Donne l'autorisation d'accès complet pour agir sur les objets d'un compartiment Amazon S3. |
| [S3ReadPolicy](serverless-policy-template-list.md#s3-read-policy) | Donne l'autorisation de lire des objets en lecture seule dans un compartiment Amazon Simple Storage Service (Amazon S3). |
| [S3WritePolicy](serverless-policy-template-list.md#s3-write-policy) | Donne l'autorisation d'écrire des objets dans un compartiment Amazon S3. |
| [SageMakerCreateEndpointConfigPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-config-policy) | Donne l'autorisation de créer une configuration de point de terminaison dans SageMaker AI. |
| [SageMakerCreateEndpointPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-policy) | Donne l'autorisation de créer un point de terminaison dans SageMaker AI. |
| [ServerlessRepoReadWriteAccessPolicy](serverless-policy-template-list.md#serverlessrepo-read-write-access-policy) | Donne l'autorisation de créer et de répertorier des applications dans le AWS Serverless Application Repository service. |
| [SESBulkTemplatedCrudPolicy](serverless-policy-template-list.md#ses-bulk-templated-crud-policy) | Donne l'autorisation d'envoyer des e-mails, des e-mails modélisés, des e-mails groupés et de vérifier l'identité. |
| [SESBulkTemplatedCrudPolicy\$1v2](serverless-policy-template-list.md#ses-bulk-templated-crud-policy-v2) | Donne l'autorisation d'envoyer des e-mails Amazon SES, des e-mails modélisés, des e-mails groupés et de vérifier l'identité. |
| [SESCrudPolicy](serverless-policy-template-list.md#ses-crud-policy) | Donne l'autorisation d'envoyer un e-mail et de vérifier l'identité. |
| [SESEmailTemplateCrudPolicy](serverless-policy-template-list.md#ses-email-template-crud-policy) | Donne l'autorisation de créer, obtenir, répertorier, mettre à jour et supprimer les modèles d'e-mail Amazon SES. |
| [SESSendBouncePolicy](serverless-policy-template-list.md#ses-send-bounce-policy) | Donne SendBounce l'autorisation d'utiliser une identité Amazon Simple Email Service (Amazon SES). |
| [SNSCrudPolicy](serverless-policy-template-list.md#sns-crud-policy) | Donne l'autorisation de créer et de publier des rubriques Amazon SNS, et de s'y abonner. |
| [SNSPublishMessagePolicy](serverless-policy-template-list.md#sqs-publish-message-policy) | Donne l'autorisation de publier un message dans une rubrique Amazon Simple Notification Service (Amazon SNS). |
| [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) | Donne l'autorisation d'interroger une file d'attente Amazon Simple Queue Service (Amazon SQS). |
| [SQSSendMessagePolicy](serverless-policy-template-list.md#sqs-send-message-policy) | Donne l'autorisation d'envoyer un message à une file d'attente Amazon SQS. |
| [SSMParameterReadPolicy](serverless-policy-template-list.md#ssm-parameter-read-policy) | Donne l'autorisation d'accéder à un paramètre à partir d'un magasin de paramètres Amazon EC2 Systems Manager (SSM) pour charger des secrets dans ce compte. À utiliser lorsque le nom du paramètre n'est pas précédé d'une barre oblique. |
| [SSMParameterWithSlashPrefixReadPolicy](serverless-policy-template-list.md#ssm-parameter-slash-read-policy) | Donne l'autorisation d'accéder à un paramètre à partir d'un magasin de paramètres Amazon EC2 Systems Manager (SSM) pour charger des secrets dans ce compte. À utiliser lorsque le nom du paramètre est précédé d'une barre oblique. |
| [StepFunctionsExecutionPolicy](serverless-policy-template-list.md#stepfunctions-execution-policy) | Donne l'autorisation de lancer l'exécution d'une machine d'état Step Functions. |
| [TextractDetectAnalyzePolicy](serverless-policy-template-list.md#textract-detect-analyze-policy) | Donne l'accès permettant de détecter et d'analyser des documents avec Amazon Textract. |
| [TextractGetResultPolicy](serverless-policy-template-list.md#textract-get-result-policy) | Donne l'accès permettant d'obtenir des documents détectés et analysés avec Amazon Textract. |
| [TextractPolicy](serverless-policy-template-list.md#textract-policy) | Donne l'accès complet à Amazon Textract. |
| [VPCAccessPolicy](serverless-policy-template-list.md#vpc-access-policy) | Donne l'accès pour créer, supprimer, décrire et détacher des interfaces réseau élastiques. |
## Résolution des problèmes
### Erreur SAM CLI : « Vous devez spécifier des valeurs de paramètres valides pour le modèle de politique '< policy-template-name >' »
Lors de l'exécution de `sam build`, l'erreur suivante s'affiche :
```
"Must specify valid parameter values for policy template ''"
```
Cela signifie que vous n'avez pas transmis d'objet vide lors de la déclaration d'un modèle de stratégie qui ne contient aucune valeur d'espace réservé.
Pour résoudre ce problème, déclarez la stratégie comme l'exemple suivant pour [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy).
```
1. MyFunction:
2. Policies:
3. - CloudWatchPutMetricPolicy: {}
```
# AWS SAM liste de modèles de politiques
Vous trouverez ci-dessous les modèles de politiques disponibles, ainsi que les autorisations appliquées à chacun d'entre eux. AWS Serverless Application Model (AWS SAM) renseigne automatiquement les éléments réservés (tels que AWS la région et le numéro de compte) avec les informations appropriées.
**Topics**
+ [AcmGetCertificatePolicy](#acm-get-certificate-policy)
+ [AMIDescribePolicy](#ami-describe-policy)
+ [AthenaQueryPolicy](#athena-query-policy)
+ [AWSSecretsManagerGetSecretValuePolicy](#secrets-manager-get-secret-value-policy)
+ [AWSSecretsManagerRotationPolicy](#secrets-manager-rotation-policy)
+ [CloudFormationDescribeStacksPolicy](#cloud-formation-describe-stacks-policy)
+ [CloudWatchDashboardPolicy](#cloudwatch-dashboard-policy)
+ [CloudWatchDescribeAlarmHistoryPolicy](#cloudwatch-describe-alarm-history-policy)
+ [CloudWatchPutMetricPolicy](#cloudwatch-put-metric-policy)
+ [CodePipelineLambdaExecutionPolicy](#code-pipeline-lambda-execution-policy)
+ [CodePipelineReadOnlyPolicy](#code-pipeline-readonly-policy)
+ [CodeCommitCrudPolicy](#codecommit-crud-policy)
+ [CodeCommitReadPolicy](#codecommit-read-policy)
+ [ComprehendBasicAccessPolicy](#comprehend-basic-access-policy)
+ [CostExplorerReadOnlyPolicy](#cost-explorer-readonly-policy)
+ [DynamoDBBackupFullAccessPolicy](#ddb-back-full-policy)
+ [DynamoDBCrudPolicy](#dynamo-db-crud-policy)
+ [DynamoDBReadPolicy](#dynamo-db-read-policy)
+ [DynamoDBReconfigurePolicy](#dynamo-db-reconfigure-policy)
+ [DynamoDBRestoreFromBackupPolicy](#ddb-restore-from-backup-policy)
+ [DynamoDBStreamReadPolicy](#dynamo-db-stream-read-policy)
+ [DynamoDBWritePolicy](#dynamo-db-write-policy)
+ [EC2CopyImagePolicy](#ec2-copy-image-policy)
+ [EC2DescribePolicy](#ec2-describe-policy)
+ [EcsRunTaskPolicy](#ecs-run-task-policy)
+ [EFSWriteAccessPolicy](#efs-write-access-policy)
+ [EKSDescribePolicy](#eks-describe-policy)
+ [ElasticMapReduceAddJobFlowStepsPolicy](#elastic-map-reduce-add-job-flows-policy)
+ [ElasticMapReduceCancelStepsPolicy](#elastic-map-reduce-cancel-steps-policy)
+ [ElasticMapReduceModifyInstanceFleetPolicy](#elastic-map-reduce-modify-instance-fleet-policy)
+ [ElasticMapReduceModifyInstanceGroupsPolicy](#elastic-map-reduce-modify-instance-groups-policy)
+ [ElasticMapReduceSetTerminationProtectionPolicy](#elastic-map-reduce-set-termination-protection-policy)
+ [ElasticMapReduceTerminateJobFlowsPolicy](#elastic-map-reduce-terminate-job-flows-policy)
+ [ElasticsearchHttpPostPolicy](#elastic-search-http-post-policy)
+ [EventBridgePutEventsPolicy](#eventbridge-put-events-policy)
+ [FilterLogEventsPolicy](#filter-log-events-policy)
+ [FirehoseCrudPolicy](#firehose-crud-policy)
+ [FirehoseWritePolicy](#firehose-write-policy)
+ [KinesisCrudPolicy](#kinesis-crud-policy)
+ [KinesisStreamReadPolicy](#kinesis-stream-read-policy)
+ [KMSDecryptPolicy](#kms-decrypt-policy)
+ [KMSEncryptPolicy](#kms-encrypt-policy)
+ [LambdaInvokePolicy](#lambda-invoke-policy)
+ [MobileAnalyticsWriteOnlyAccessPolicy](#mobile-analytics-write-only-access-policy)
+ [OrganizationsListAccountsPolicy](#organizations-list-accounts-policy)
+ [PinpointEndpointAccessPolicy](#pinpoint-endpoint-access-policy)
+ [PollyFullAccessPolicy](#polly-full-access-policy)
+ [RekognitionDetectOnlyPolicy](#rekognition-detect-only-policy)
+ [RekognitionFacesManagementPolicy](#rekognition-face-management-policy)
+ [RekognitionFacesPolicy](#rekognition-faces-policy)
+ [RekognitionLabelsPolicy](#rekognition-labels-policy)
+ [RekognitionNoDataAccessPolicy](#rekognition-no-data-access-policy)
+ [RekognitionReadPolicy](#rekognition-read-policy)
+ [RekognitionWriteOnlyAccessPolicy](#rekognition-write-only-access-policy)
+ [Route53ChangeResourceRecordSetsPolicy](#route53-change-resource-record-sets-policy)
+ [S3CrudPolicy](#s3-crud-policy)
+ [S3FullAccessPolicy](#s3-full-access-policy)
+ [S3ReadPolicy](#s3-read-policy)
+ [S3WritePolicy](#s3-write-policy)
+ [SageMakerCreateEndpointConfigPolicy](#sagemaker-create-endpoint-config-policy)
+ [SageMakerCreateEndpointPolicy](#sagemaker-create-endpoint-policy)
+ [ServerlessRepoReadWriteAccessPolicy](#serverlessrepo-read-write-access-policy)
+ [SESBulkTemplatedCrudPolicy](#ses-bulk-templated-crud-policy)
+ [SESBulkTemplatedCrudPolicy\$1v2](#ses-bulk-templated-crud-policy-v2)
+ [SESCrudPolicy](#ses-crud-policy)
+ [SESEmailTemplateCrudPolicy](#ses-email-template-crud-policy)
+ [SESSendBouncePolicy](#ses-send-bounce-policy)
+ [SNSCrudPolicy](#sns-crud-policy)
+ [SNSPublishMessagePolicy](#sqs-publish-message-policy)
+ [SQSPollerPolicy](#sqs-poller-policy)
+ [SQSSendMessagePolicy](#sqs-send-message-policy)
+ [SSMParameterReadPolicy](#ssm-parameter-read-policy)
+ [SSMParameterWithSlashPrefixReadPolicy](#ssm-parameter-slash-read-policy)
+ [StepFunctionsExecutionPolicy](#stepfunctions-execution-policy)
+ [TextractDetectAnalyzePolicy](#textract-detect-analyze-policy)
+ [TextractGetResultPolicy](#textract-get-result-policy)
+ [TextractPolicy](#textract-policy)
+ [VPCAccessPolicy](#vpc-access-policy)
## AcmGetCertificatePolicy
Donne l'autorisation de lire un certificat à partir de AWS Certificate Manager.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"acm:GetCertificate"
],
"Resource": {
"Fn::Sub": [
"${certificateArn}",
{
"certificateArn": {
"Ref": "CertificateArn"
}
}
]
}
}
]
```
## AMIDescribePolicy
Donne l'autorisation de décrire Amazon Machine Images (AMIs).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeImages"
],
"Resource": "*"
}
]
```
## AthenaQueryPolicy
Donne des autorisations pour exécuter des requêtes Athena.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListWorkGroups",
"athena:GetExecutionEngine",
"athena:GetExecutionEngines",
"athena:GetNamespace",
"athena:GetCatalogs",
"athena:GetNamespaces",
"athena:GetTables",
"athena:GetTable"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"athena:GetQueryResults",
"athena:DeleteNamedQuery",
"athena:GetNamedQuery",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResultsStream",
"athena:ListNamedQueries",
"athena:CreateNamedQuery",
"athena:GetQueryExecution",
"athena:BatchGetNamedQuery",
"athena:BatchGetQueryExecution",
"athena:GetWorkGroup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:athena:${AWS::Region}:${AWS::AccountId}:workgroup/${workgroupName}",
{
"workgroupName": {
"Ref": "WorkGroupName"
}
}
]
}
}
]
```
## AWSSecretsManagerGetSecretValuePolicy
Donne l'autorisation d'obtenir la valeur secrète pour le AWS Secrets Manager secret spécifié.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": {
"Fn::Sub": [
"${secretArn}",
{
"secretArn": {
"Ref": "SecretArn"
}
}
]
}
}
]
```
## AWSSecretsManagerRotationPolicy
Donne l'autorisation de faire pivoter un secret dans AWS Secrets Manager.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:DescribeSecret",
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:*"
},
"Condition": {
"StringEquals": {
"secretsmanager:resource/AllowRotationLambdaArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
}
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword"
],
"Resource": "*"
}
]
```
## CloudFormationDescribeStacksPolicy
Donne l'autorisation de décrire les CloudFormation piles.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
}
}
]
```
## CloudWatchDashboardPolicy
Permet de placer des métriques à appliquer sur les CloudWatch tableaux de bord.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetDashboard",
"cloudwatch:ListDashboards",
"cloudwatch:PutDashboard",
"cloudwatch:ListMetrics"
],
"Resource": "*"
}
]
```
## CloudWatchDescribeAlarmHistoryPolicy
Permet de décrire l'historique des CloudWatch alarmes Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarmHistory"
],
"Resource": "*"
}
]
```
## CloudWatchPutMetricPolicy
Donne l'autorisation d'envoyer des métriques à CloudWatch.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
```
## CodePipelineLambdaExecutionPolicy
Permet à une fonction Lambda invoquée par AWS CodePipeline de signaler l'état de la tâche.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": "*"
}
]
```
## CodePipelineReadOnlyPolicy
Donne l'autorisation de lecture pour obtenir des informations sur un CodePipeline pipeline.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:ListPipelineExecutions"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
{
"pipelinename": {
"Ref": "PipelineName"
}
}
]
}
}
]
```
## CodeCommitCrudPolicy
Permet de créer, de lire, de mettre à jour et de supprimer des objets dans un CodeCommit référentiel spécifique.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GitPush",
"codecommit:CreateBranch",
"codecommit:DeleteBranch",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:MergeBranchesByFastForward",
"codecommit:MergeBranchesBySquash",
"codecommit:MergeBranchesByThreeWay",
"codecommit:UpdateDefaultBranch",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:CreateUnreferencedMergeCommit",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:CreatePullRequest",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:MergePullRequestByFastForward",
"codecommit:MergePullRequestBySquash",
"codecommit:MergePullRequestByThreeWay",
"codecommit:PostCommentForPullRequest",
"codecommit:UpdatePullRequestDescription",
"codecommit:UpdatePullRequestStatus",
"codecommit:UpdatePullRequestTitle",
"codecommit:DeleteFile",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:PutFile",
"codecommit:DeleteCommentContent",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:PostCommentForComparedCommit",
"codecommit:PostCommentReply",
"codecommit:UpdateComment",
"codecommit:BatchGetCommits",
"codecommit:CreateCommit",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:UpdateRepositoryDescription",
"codecommit:ListTagsForResource",
"codecommit:TagResource",
"codecommit:UntagResource",
"codecommit:GetRepositoryTriggers",
"codecommit:PutRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:UploadArchive",
"codecommit:GetUploadArchiveStatus",
"codecommit:CancelUploadArchive"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## CodeCommitReadPolicy
Permet de lire des objets dans un CodeCommit référentiel spécifique.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:BatchGetCommits",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:ListTagsForResource",
"codecommit:GetRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetUploadArchiveStatus"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## ComprehendBasicAccessPolicy
Donne l'autorisation de détecter des entités, des expressions clés, des langues et des sentiments.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"comprehend:BatchDetectKeyPhrases",
"comprehend:DetectDominantLanguage",
"comprehend:DetectEntities",
"comprehend:BatchDetectEntities",
"comprehend:DetectKeyPhrases",
"comprehend:DetectSentiment",
"comprehend:BatchDetectDominantLanguage",
"comprehend:BatchDetectSentiment"
],
"Resource": "*"
}
]
```
## CostExplorerReadOnlyPolicy
Donne une autorisation en lecture seule à l'utilisateur en lecture seule (Cost AWS Cost Explorer Explorer) APIs pour l'historique de facturation.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ce:GetCostAndUsage",
"ce:GetDimensionValues",
"ce:GetReservationCoverage",
"ce:GetReservationPurchaseRecommendation",
"ce:GetReservationUtilization",
"ce:GetTags"
],
"Resource": "*"
}
]
```
## DynamoDBBackupFullAccessPolicy
Donne l'autorisation de lecture/écriture aux sauvegardes DynamoDB à la demande pour une table.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:DescribeContinuousBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteBackup",
"dynamodb:DescribeBackup",
"dynamodb:ListBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBCrudPolicy
Donne les autorisations de créer, lire, mettre à jour, supprimer à une table Amazon DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:DeleteItem",
"dynamodb:PutItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReadPolicy
Donne l'autorisation de lecture seule à une table DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReconfigurePolicy
Donne l'autorisation de reconfigurer une table DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateTable"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBRestoreFromBackupPolicy
Donne l'autorisation de restaurer une table DynamoDB à partir d'une sauvegarde.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:RestoreTableFromBackup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBStreamReadPolicy
Donne l'autorisation de décrire et de lire les flux DynamoDB Streams ainsi que les enregistrements.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/${streamName}",
{
"tableName": {
"Ref": "TableName"
},
"streamName": {
"Ref": "StreamName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:ListStreams"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBWritePolicy
Donne l'autorisation d'écriture seule à une table DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## EC2CopyImagePolicy
Donne l'autorisation de copier EC2 des images Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CopyImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ec2:${AWS::Region}:${AWS::AccountId}:image/${imageId}",
{
"imageId": {
"Ref": "ImageId"
}
}
]
}
}
]
```
## EC2DescribePolicy
Donne l'autorisation de décrire les instances Amazon Elastic Compute Cloud (Amazon EC2).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeRegions",
"ec2:DescribeInstances"
],
"Resource": "*"
}
]
```
## EcsRunTaskPolicy
Donne l'autorisation de démarrer une nouvelle tâche pour une définition de tâche.
```
"Statement": [
{
"Action": [
"ecs:RunTask"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:task-definition/${taskDefinition}",
{
"taskDefinition": {
"Ref": "TaskDefinition"
}
}
]
},
"Effect": "Allow"
}
]
```
## EFSWriteAccessPolicy
Donne l'autorisation de monter un système de fichiers Amazon EFS avec accès en écriture.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticfilesystem:ClientMount",
"elasticfilesystem:ClientWrite"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:file-system/${FileSystem}",
{
"FileSystem": {
"Ref": "FileSystem"
}
}
]
},
"Condition": {
"StringEquals": {
"elasticfilesystem:AccessPointArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:access-point/${AccessPoint}",
{
"AccessPoint": {
"Ref": "AccessPoint"
}
}
]
}
}
}
}
]
```
## EKSDescribePolicy
Donne l'autorisation de décrire ou de répertorier des clusters Amazon Elastic Kubernetes Service (Amazon EKS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters"
],
"Resource": "*"
}
]
```
## ElasticMapReduceAddJobFlowStepsPolicy
Donne l'autorisation d'ajouter de nouvelles étapes à un cluster en cours d'exécution.
```
"Statement": [
{
"Action": "elasticmapreduce:AddJobFlowSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceCancelStepsPolicy
Donne l'autorisation d'annuler une étape ou des étapes en attente dans un cluster en cours d'exécution.
```
"Statement": [
{
"Action": "elasticmapreduce:CancelSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceFleetPolicy
Donne l'autorisation de répertorier les détails et de modifier les capacités des flottes d'instances au sein d'un cluster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceFleet",
"elasticmapreduce:ListInstanceFleets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceGroupsPolicy
Donne l'autorisation de répertorier les détails et de modifier les réglages des groupes d'instances au sein d'un cluster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceGroups",
"elasticmapreduce:ListInstanceGroups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceSetTerminationProtectionPolicy
Donne l'autorisation de définir une protection contre l'arrêt pour un cluster.
```
"Statement": [
{
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceTerminateJobFlowsPolicy
Donne l'autorisation d'arrêter un cluster.
```
"Statement": [
{
"Action": "elasticmapreduce:TerminateJobFlows",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticsearchHttpPostPolicy
Donne les autorisations POST et PUT à Amazon OpenSearch Service.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpPost",
"es:ESHttpPut"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:es:${AWS::Region}:${AWS::AccountId}:domain/${domainName}/*",
{
"domainName": {
"Ref": "DomainName"
}
}
]
}
}
]
```
## EventBridgePutEventsPolicy
Donne l'autorisation d'envoyer des événements à Amazon EventBridge.
```
"Statement": [
{
"Effect": "Allow",
"Action": "events:PutEvents",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:event-bus/${eventBusName}",
{
"eventBusName": {
"Ref": "EventBusName"
}
}
]
}
}
]
```
## FilterLogEventsPolicy
Donne l'autorisation de filtrer CloudWatch les événements des journaux à partir d'un groupe de journaux spécifié.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:FilterLogEvents"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:${logGroupName}:log-stream:*",
{
"logGroupName": {
"Ref": "LogGroupName"
}
}
]
}
}
]
```
## FirehoseCrudPolicy
Donne l'autorisation de créer, d'écrire, de mettre à jour et de supprimer un flux de diffusion Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:CreateDeliveryStream",
"firehose:DeleteDeliveryStream",
"firehose:DescribeDeliveryStream",
"firehose:PutRecord",
"firehose:PutRecordBatch",
"firehose:UpdateDestination"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## FirehoseWritePolicy
Donne l'autorisation d'écrire dans un flux de diffusion Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## KinesisCrudPolicy
Donne l'autorisation de créer, publier et supprimer un flux Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:AddTagsToStream",
"kinesis:CreateStream",
"kinesis:DecreaseStreamRetentionPeriod",
"kinesis:DeleteStream",
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetShardIterator",
"kinesis:IncreaseStreamRetentionPeriod",
"kinesis:ListTagsForStream",
"kinesis:MergeShards",
"kinesis:PutRecord",
"kinesis:PutRecords",
"kinesis:SplitShard",
"kinesis:RemoveTagsFromStream"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KinesisStreamReadPolicy
Donne l'autorisation d'afficher et de lire un flux Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:ListStreams",
"kinesis:DescribeLimits"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/*"
}
},
{
"Effect": "Allow",
"Action": [
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetRecords",
"kinesis:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KMSDecryptPolicy
Donne l'autorisation de déchiffrer avec une clé AWS Key Management Service (AWS KMS). Notez qu'`keyId`il doit s'agir d'un identifiant de AWS KMS clé et non d'un alias de clé.
```
"Statement": [
{
"Action": "kms:Decrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## KMSEncryptPolicy
Donne l'autorisation de chiffrer avec une AWS KMS clé. Notez que KeyID doit être un identifiant de AWS KMS clé et non un alias de clé.
```
"Statement": [
{
"Action": "kms:Encrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## LambdaInvokePolicy
Donne l'autorisation d'invoquer une AWS Lambda fonction, un alias ou une version.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}*",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
]
```
## MobileAnalyticsWriteOnlyAccessPolicy
Donne uniquement l'autorisation d'écriture pour placer les données d'événements pour toutes les ressources d'application.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobileanalytics:PutEvents"
],
"Resource": "*"
}
]
```
## OrganizationsListAccountsPolicy
Donne l'autorisation en lecture seule de répertorier les noms de comptes enfants et. IDs
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"organizations:ListAccounts"
],
"Resource": "*"
}
]
```
## PinpointEndpointAccessPolicy
Donne l'autorisation d'obtenir et de mettre à jour les points de terminaison pour une application Amazon Pinpoint.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobiletargeting:GetEndpoint",
"mobiletargeting:UpdateEndpoint",
"mobiletargeting:UpdateEndpointsBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:mobiletargeting:${AWS::Region}:${AWS::AccountId}:apps/${pinpointApplicationId}/endpoints/*",
{
"pinpointApplicationId": {
"Ref": "PinpointApplicationId"
}
}
]
}
}
]
```
## PollyFullAccessPolicy
Donne l'autorisation d'accès complet aux ressources de lexique Amazon Polly.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"polly:GetLexicon",
"polly:DeleteLexicon"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/${lexiconName}",
{
"lexiconName": {
"Ref": "LexiconName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:ListLexicons",
"polly:PutLexicon",
"polly:SynthesizeSpeech"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/*"
}
]
}
]
```
## RekognitionDetectOnlyPolicy
Donne l'autorisation de comparer et de détecter les visages et les étiquettes.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels",
"rekognition:DetectText"
],
"Resource": "*"
}
]
```
## RekognitionFacesManagementPolicy
Donne l'autorisation d'ajouter, de supprimer et de rechercher des visages dans une collection Amazon Rekognition.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:IndexFaces",
"rekognition:DeleteFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage",
"rekognition:ListFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionFacesPolicy
Donne l'autorisation de comparer et de détecter les visages et les étiquettes.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces"
],
"Resource": "*"
}
]
```
## RekognitionLabelsPolicy
Donne l'autorisation de détecter les étiquettes d'objet et de modération.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": "*"
}
]
```
## RekognitionNoDataAccessPolicy
Donne l'autorisation de comparer et de détecter les visages et les étiquettes.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionReadPolicy
Donne l'autorisation de lister et de rechercher des visages.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:ListCollections",
"rekognition:ListFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionWriteOnlyAccessPolicy
Donne l'autorisation de créer des collections et d'indexer des visages.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CreateCollection",
"rekognition:IndexFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## Route53ChangeResourceRecordSetsPolicy
Donne l'autorisation de modifier des jeux d'enregistrements de ressources dans Route 53.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
{
"HostedZoneId": {
"Ref": "HostedZoneId"
}
}
]
}
}
]
```
## S3CrudPolicy
Donne l'autorisation de créer, lire, mettre à jour et supprimer pour agir sur les objets d'un compartiment Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration",
"s3:DeleteObject"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3FullAccessPolicy
Donne l'autorisation d'accès complet pour agir sur les objets d'un compartiment Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:DeleteObject",
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3ReadPolicy
Donne l'autorisation de lire des objets en lecture seule dans un compartiment Amazon Simple Storage Service (Amazon S3).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:GetLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3WritePolicy
Donne l'autorisation d'écrire des objets dans un compartiment Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## SageMakerCreateEndpointConfigPolicy
Donne l'autorisation de créer une configuration de point de terminaison dans SageMaker AI.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpointConfig"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint-config/${endpointConfigName}",
{
"endpointConfigName": {
"Ref": "EndpointConfigName"
}
}
]
},
"Effect": "Allow"
}
]
```
## SageMakerCreateEndpointPolicy
Donne l'autorisation de créer un point de terminaison dans SageMaker AI.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpoint"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint/${endpointName}",
{
"endpointName": {
"Ref": "EndpointName"
}
}
]
},
"Effect": "Allow"
}
]
```
## ServerlessRepoReadWriteAccessPolicy
Donne l'autorisation de créer et de répertorier des applications dans le service AWS Serverless Application Repository (AWS SAM).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"serverlessrepo:CreateApplication",
"serverlessrepo:CreateApplicationVersion",
"serverlessrepo:GetApplication",
"serverlessrepo:ListApplications",
"serverlessrepo:ListApplicationVersions"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:serverlessrepo:${AWS::Region}:${AWS::AccountId}:applications/*"
}
]
}
]
```
## SESBulkTemplatedCrudPolicy
Donne l'autorisation d'envoyer des e-mails Amazon SES, des e-mails modélisés, des e-mails groupés et de vérifier l'identité.
**Note**
L'action `ses:SendTemplatedEmail` nécessite un modèle d'ARN. Utilisez `SESBulkTemplatedCrudPolicy_v2` à la place.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESBulkTemplatedCrudPolicy\$1v2
Donne l'autorisation d'envoyer des e-mails Amazon SES, des e-mails modélisés, des e-mails groupés et de vérifier l'identité.
```
"Statement": [
{
"Action": [
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail"
],
"Effect": "Allow",
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:template/${templateName}",
{
"templateName": {
"Ref": "TemplateName"
}
}
]
}
]
},
{
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:VerifyEmailIdentity"
],
"Effect": "Allow",
"Resource": "*"
}
]
```
## SESCrudPolicy
Donne l'autorisation d'envoyer un e-mail et de vérifier l'identité.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESEmailTemplateCrudPolicy
Donne l'autorisation de créer, obtenir, répertorier, mettre à jour et supprimer les modèles d'e-mail Amazon SES.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:CreateTemplate",
"ses:GetTemplate",
"ses:ListTemplates",
"ses:UpdateTemplate",
"ses:DeleteTemplate",
"ses:TestRenderTemplate"
],
"Resource": "*"
}
]
```
## SESSendBouncePolicy
Donne SendBounce l'autorisation d'utiliser une identité Amazon Simple Email Service (Amazon SES).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:SendBounce"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SNSCrudPolicy
Donne l'autorisation de créer et de publier des rubriques Amazon SNS, et de s'y abonner.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:ListSubscriptionsByTopic",
"sns:CreateTopic",
"sns:SetTopicAttributes",
"sns:Subscribe",
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}*",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SNSPublishMessagePolicy
Donne l'autorisation de publier un message dans une rubrique Amazon Simple Notification Service (Amazon SNS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SQSPollerPolicy
Donne l'autorisation d'interroger une file d'attente Amazon Simple Queue Service (Amazon SQS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:ChangeMessageVisibility",
"sqs:ChangeMessageVisibilityBatch",
"sqs:DeleteMessage",
"sqs:DeleteMessageBatch",
"sqs:GetQueueAttributes",
"sqs:ReceiveMessage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SQSSendMessagePolicy
Donne l'autorisation d'envoyer un message à une file d'attente Amazon SQS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage*"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SSMParameterReadPolicy
Permet d'accéder à un paramètre depuis un magasin de paramètres Amazon EC2 Systems Manager (SSM) pour charger des secrets dans ce compte. À utiliser lorsque le nom du paramètre n'est pas précédé d'une barre oblique.
**Note**
Si vous n'utilisez pas la clé par défaut, vous aurez également besoin de la stratégie `KMSDecryptPolicy`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter/${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## SSMParameterWithSlashPrefixReadPolicy
Permet d'accéder à un paramètre depuis un magasin de paramètres Amazon EC2 Systems Manager (SSM) pour charger des secrets dans ce compte. À utiliser lorsque le nom du paramètre est précédé d'une barre oblique.
**Note**
Si vous n'utilisez pas la clé par défaut, vous aurez également besoin de la stratégie `KMSDecryptPolicy`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## StepFunctionsExecutionPolicy
Donne l'autorisation de lancer l'exécution d'une machine d'état Step Functions.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${stateMachineName}",
{
"stateMachineName": {
"Ref": "StateMachineName"
}
}
]
}
}
]
```
## TextractDetectAnalyzePolicy
Donne l'accès permettant de détecter et d'analyser des documents avec Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:DetectDocumentText",
"textract:StartDocumentTextDetection",
"textract:StartDocumentAnalysis",
"textract:AnalyzeDocument"
],
"Resource": "*"
}
]
```
## TextractGetResultPolicy
Donne l'accès permettant d'obtenir des documents détectés et analysés avec Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:GetDocumentTextDetection",
"textract:GetDocumentAnalysis"
],
"Resource": "*"
}
]
```
## TextractPolicy
Donne l'accès complet à Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:*"
],
"Resource": "*"
}
]
```
## VPCAccessPolicy
Donne l'accès pour créer, supprimer, décrire et détacher des interfaces réseau élastiques.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*"
}
]
```
# Gestion des AWS SAM autorisations à l'aide de CloudFormation mécanismes
Pour contrôler l'accès aux AWS ressources, le AWS Serverless Application Model (AWS SAM) peut utiliser les mêmes mécanismes que CloudFormation. Pour plus d’informations, consultez [Contrôle de l’accès à l’aide de Gestion des identités et des accès AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) dans le *Guide de l’utilisateur AWS CloudFormation *.
Il existe trois options principales pour accorder à un utilisateur l’autorisation de gérer des applications sans serveur. Chaque option offre aux utilisateurs différents niveaux de contrôle d’accès.
+ Accorder des autorisations d’administrateur
+ Joignez les politiques AWS gérées nécessaires.
+ Accordez des autorisations spécifiques Gestion des identités et des accès AWS (IAM).
Selon l'option choisie, les utilisateurs ne peuvent gérer que les applications sans serveur contenant des AWS ressources auxquelles ils sont autorisés à accéder.
Les sections suivantes décrivent chaque option plus en détail.
## Accorder des autorisations d’administrateur
Si vous accordez des autorisations d'administrateur à un utilisateur, celui-ci peut gérer des applications sans serveur contenant n'importe quelle combinaison de AWS ressources. C’est l’option la plus simple, mais elle accorde également aux utilisateurs l’ensemble d’autorisations le plus étendu, ce qui leur permet de réaliser des actions d’un impact le plus élevé.
Pour plus d’informations sur l’attribution d’autorisations d’administrateur à un utilisateur, consultez [Création de votre premier utilisateur administrateur et groupe IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) dans le *Guide de l’utilisateur IAM*
## Joindre les politiques AWS gérées nécessaires
Vous pouvez accorder aux utilisateurs un sous-ensemble d’autorisations en utilisant des [stratégies gérées par AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies), plutôt que d’accorder des autorisations d’administrateur complètes. Si vous utilisez cette option, assurez-vous que l'ensemble de politiques AWS gérées couvre toutes les actions et ressources requises pour les applications sans serveur gérées par les utilisateurs.
Par exemple, les politiques AWS gérées suivantes sont suffisantes pour [déployer l'exemple d'application Hello World](serverless-getting-started-hello-world.md) :
+ AWSCloudFormationFullAccess
+ IAMFullAccès
+ AWSLambda\$1FullAccess
+ APIGatewayAdministrateur Amazon
+ Amazon S3 FullAccess
+ Amazon EC2 ContainerRegistryFullAccess
Pour plus d’informations sur l’attachement de stratégies à un utilisateur IAM, consultez [Modification des autorisations d’un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) dans le *Guide de l’utilisateur IAM*.
## Accorder des autorisations (IAM) spécifiques.
Pour un niveau de contrôle d’accès plus détaillé, vous pouvez accorder des autorisations IAM spécifiques aux utilisateurs à l’aide des [déclarations de stratégie](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_statement.html). Si vous utilisez cette option, assurez-vous que la déclaration de stratégie comprenne toutes les actions et ressources requises pour les applications sans serveur gérées par les utilisateurs.
La bonne pratique avec cette option consiste à refuser aux utilisateurs l’autorisation de créer des rôles, y compris des rôles d’exécution Lambda, afin qu’ils ne puissent pas s’accorder eux-mêmes des autorisations progressives. Ainsi, en tant qu’administrateur, vous devez d’abord créer un [Rôle d’exécution Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) qui sera spécifié dans les applications sans serveur que les utilisateurs vont gérer. Pour plus d’informations sur la création de rôles d’exécution Lambda, consultez [Création d’un rôle d’exécution dans la console IAM](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html#permissions-executionrole-console).
Pour l'[exemple d'application Hello World](serverless-getting-started-hello-world.md), **AWSLambdaBasicExecutionRole**c'est suffisant pour exécuter l'application. Après avoir créé un rôle d'exécution Lambda, modifiez le fichier AWS SAM modèle de l'exemple d'application Hello World pour ajouter la propriété suivante à la `AWS::Serverless::Function` ressource :
```
Role: lambda-execution-role-arn
```
Lorsque l’application Hello World modifiée est en place, la déclaration de stratégie suivante accorde des autorisations suffisantes aux utilisateurs pour le déploiement, la mise à jour et l’élimination de l’application :
**Note**
L’exemple de déclaration de stratégie de cette section vous permet de déployer, de mettre à jour et d’éliminer l’[exemple d’application Hello World](serverless-getting-started-hello-world.md). Si vous ajoutez des types de ressources supplémentaires à l’application, vous devez mettre à jour la déclaration de stratégie pour inclure les éléments suivants :
Autorisation permettant à l’application d’appeler les actions du service.
Le principal du service, si nécessaire pour les actions du service.
Par exemple, si vous ajoutez un flux de travail Step Functions, vous devrez peut-être ajouter des autorisations pour les actions répertoriées [ici](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsstepfunctions.html#awsstepfunctions-actions-as-permissions) et le `states.amazonaws.com`principal du service.
Pour plus d’informations sur la gestion des stratégies IAM, consultez [Gestion des stratégies IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) dans le *Guide de l’utilisateur IAM*.