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.
# Définissez votre infrastructure avec AWS SAM
Maintenant que vous avez créé votre projet, vous êtes prêt à définir votre infrastructure d'applications avec AWS SAM. Pour ce faire, configurez votre AWS SAM modèle pour définir les ressources et les propriétés de votre application, c'est-à-dire le `template.yaml` fichier de votre AWS SAM projet.
Les rubriques de cette section fournissent du contenu sur la définition de votre infrastructure dans votre AWS SAM modèle (votre `template.yaml` fichier). Il contient également des rubriques sur la définition de ressources pour des cas d'utilisation spécifiques, tels que l'utilisation de couches Lambda, l'utilisation d'applications imbriquées, le contrôle de l'accès à API Gateway APIs, l'orchestration des ressources avec AWS Step Functions, la signature de code de vos applications et la validation de votre modèle. AWS SAM
**Topics**
+ [Définissez les ressources de l'application dans votre AWS SAM modèle](authoring-define-resources.md)
+ [Configuration et gestion de l'accès aux ressources dans votre AWS SAM modèle](sam-permissions.md)
+ [Contrôlez l'accès aux API avec votre AWS SAM modèle](serverless-controlling-access-to-apis.md)
+ [Améliorez l'efficacité en utilisant les couches Lambda avec AWS SAM](serverless-sam-cli-layers.md)
+ [Réutilisez le code et les ressources à l'aide d'applications imbriquées dans AWS SAM](serverless-sam-template-nested-applications.md)
+ [Gérez les événements temporels avec le EventBridge planificateur dans AWS SAM](using-eventbridge-scheduler.md)
+ [Orchestrer les AWS SAM ressources avec AWS Step Functions](serverless-step-functions-in-sam.md)
+ [Configurer la signature de code pour votre AWS SAM application](authoring-codesigning.md)
+ [Valider les fichiers AWS SAM modèles](serverless-sam-cli-using-validate.md)
# Définissez les ressources de l'application dans votre AWS SAM modèle
Vous définissez les AWS ressources utilisées par votre application sans serveur dans la `Resources` section de votre AWS SAM modèle. Lorsque vous définissez une ressource, vous identifiez ce qu'elle est, comment elle interagit avec les autres ressources et comment elle est accessible (c'est-à-dire les autorisations de la ressource).
La `Resources` section de votre AWS SAM modèle peut contenir une combinaison de CloudFormation ressources et de AWS SAM ressources. En outre, vous pouvez utiliser AWS SAM la syntaxe abrégée pour les ressources suivantes :
| AWS SAM syntaxe abrégée | Ce qu'il fait avec une AWS ressource connexe |
| --- | --- |
| [AWS::Serverless::Api](sam-resource-api.md) | Crée une collection de ressources et de méthodes API Gateway qui peuvent être invoquées via des points de terminaison HTTPS. |
| [AWS::Serverless::Application](sam-resource-application.md) | Intègre une application sans serveur à partir du [AWS Serverless Application Repository](https://serverlessrepo.aws.amazon.com/applications) ou à partir d'un compartiment Amazon S3 comme application imbriquée. |
| [AWS::Serverless::Connector](sam-resource-connector.md) | Configure les autorisations entre deux ressources. Pour obtenir une présentation des connecteurs, veuillez consulter [Gestion des autorisations relatives aux ressources à l'aide de AWS SAM connecteurs](managing-permissions-connectors.md). |
| [AWS::Serverless::Function](sam-resource-function.md) | Crée une AWS Lambda fonction, un rôle d'exécution Gestion des identités et des accès AWS (IAM) et des mappages de sources d'événements qui déclenchent la fonction. |
| [AWS::Serverless::GraphQLApi](sam-resource-graphqlapi.md) | crée et configure une AWS AppSync GraphQL API pour votre application sans serveur. |
| [AWS::Serverless::HttpApi](sam-resource-httpapi.md) | Crée une API HTTP Amazon API Gateway, qui vous permet de créer RESTful APIs avec une latence et des coûts inférieurs à ceux de REST APIs. |
| [AWS::Serverless::LayerVersion](sam-resource-layerversion.md) | Crée un Lambda LayerVersion qui contient la bibliothèque ou le code d'exécution nécessaire à une fonction Lambda. |
| [AWS::Serverless::SimpleTable](sam-resource-simpletable.md) | Crée une table DynamoDB avec une clé primaire d'attribut unique. |
| [AWS::Serverless::StateMachine](sam-resource-statemachine.md) | Crée une machine à AWS Step Functions états, que vous pouvez utiliser pour orchestrer des AWS Lambda fonctions et d'autres AWS ressources afin de créer des flux de travail complexes et robustes. |
Les ressources ci-dessus sont également répertoriées dans[AWS SAM ressources et propriétés](sam-specification-resources-and-properties.md).
Pour obtenir des informations de référence sur tous les types de AWS ressources et de propriétés CloudFormation ainsi que sur le AWS SAM support, voir la [référence aux types de AWS ressources et de propriétés](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) dans le *guide de AWS CloudFormation l'utilisateur*.
# 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*.
# Contrôlez l'accès aux API avec votre AWS SAM modèle
Le contrôle de l'accès à votre API Gateway APIs permet de garantir que votre application sans serveur est sécurisée et n'est accessible que par le biais de l'autorisation que vous autorisez. Vous pouvez activer l'autorisation dans votre AWS SAM modèle pour contrôler qui peut accéder à votre API Gateway APIs.
AWS SAM prend en charge plusieurs mécanismes pour contrôler l'accès à votre API Gateway APIs. L'ensemble des mécanismes pris en charge diffère entre les types de ressources `AWS::Serverless::HttpApi` et `AWS::Serverless::Api`.
Le tableau suivant récapitule les mécanismes pris en charge par type de ressource.
| Mécanismes de contrôle de l'accès | AWS::Serverless::HttpApi | AWS::Serverless::Api |
| --- | --- | --- |
| Mécanismes d'autorisation Lambda | ✓ | ✓ |
| Autorisations IAM | | ✓ |
| Groupes d'utilisateurs Amazon Cognito | ✓ \$1 | ✓ |
| Clés d’API | | ✓ |
| Politiques basées sur une ressource | | ✓ |
| OAuth 2.0/Autorisateurs JWT | ✓ | |
\$1 Vous pouvez utiliser Amazon Cognito en tant qu'auteur de jeton web JSON (JWT) avec le type de ressource `AWS::Serverless::HttpApi`.
+ **Mécanismes d'autorisation** – Un mécanisme d'autorisation Lambda (anciennement appelé *Custom Authorizer (mécanisme d'autorisation personnalisée)*) est une fonction Lambda vous permettant de contrôler l'accès à vos API. Lorsque votre API est appelée, cette fonction Lambda est appelée avec un contexte de requête ou un jeton d'autorisation fourni par l'application cliente. La fonction Lambda répond si l'appelant est autorisé à effectuer l'opération demandée.
Les types de ressources `AWS::Serverless::HttpApi` et `AWS::Serverless::Api` prennent tous deux en charge les mécanismes d'autorisation Lambda.
Pour plus d'informations sur les autorisateurs Lambda avec`AWS::Serverless::HttpApi`, consultez la section [Working with AWS Lambda authorizers for HTTP dans le Guide du développeur APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) d'*API* Gateway. Pour plus d'informations sur les mécanismes d'autorisation Lambda avec `AWS::Serverless::Api`, consultez [Utilisation des mécanismes d'autorisation Lambda API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) dans le *Guide du développeur API Gateway*.
Pour obtenir des exemples de mécanismes d'autorisation Lambda pour l'un ou l'autre des deux type de ressource, consultez [Exemples d'autorisateurs Lambda pour AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md).
+ **Autorisations IAM** – Vous pouvez contrôler les personnes pouvant appeler votre API en utilisant [Gestion des identités et des accès AWS (IAM) autorisations](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html). Les utilisateurs appelant votre API doivent être authentifiés avec des informations d'identification IAM. Les appels vers votre API ne réussissent que s'il existe une stratégie IAM attachée à l'utilisateur IAM qui représente l'appelant API, un groupe IAM qui contient l'utilisateur ou un rôle IAM assumé par l'utilisateur.
Seul le type de ressource `AWS::Serverless::Api` prend en charge les autorisations IAM.
Pour plus d'informations, consultez le [Contrôle de l'accès à une API avec des autorisations IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) dans le *Guide du développeur API*. Pour obtenir un exemple, consultez [Exemple d'autorisation IAM pour AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ **Groupes d'utilisateurs Amazon Cognito** – Les groupes d'utilisateurs Amazon Cognito sont des répertoires d'utilisateurs dans Amazon Cognito. Un client de votre API doit d'abord se connecter à un groupe d'utilisateurs et obtenir un jeton d'identité ou d'accès pour l'utilisateur. Ensuite, le client appelle votre API avec l'un des jetons renvoyés. L'appel d'API réussit uniquement si le jeton requis est valide.
Le type de ressource `AWS::Serverless::Api` prend en charge les groupes d'utilisateurs Amazon Cognito. Le type de ressource `AWS::Serverless::HttpApi` prend en charge l'utilisation d'Amazon Cognito en tant qu'auteur de JWT.
Pour plus d'informations, consultez [Contrôle de l'accès à une API REST à l'aide de groupes d'utilisateurs Amazon Cognito en tant que mécanisme d'autorisation](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) dans le *Guide du développeur API Gateway*. Pour obtenir un exemple, consultez [Exemple de groupe d'utilisateurs Amazon Cognito pour AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ Les **clés API** sont des valeurs de chaînes alphanumériques que vous distribuez aux clients développeurs d'applications pour leur accorder l'accès à votre API.
Seul le type de ressource `AWS::Serverless::Api` prend en charge les clés API.
Pour plus d'informations concernant les clés API, consultez [Création et utilisation de plans d'utilisation avec les clés API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) dans le *Guide du développeur API Gateway*. Pour obtenir un exemple de clés API, voir[Exemple de clé d'API pour AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Stratégies de ressources** – Les stratégies de ressources sont des documents de stratégie JSON que vous pouvez attacher à une API API Gateway. Vous pouvez utiliser les stratégies de ressources pour contrôler si un mandataire spécifié (généralement, un utilisateur ou un rôle IAM) peut appeler l'API.
Seul le type de `AWS::Serverless::Api` ressource prend en charge les politiques de ressources en tant que mécanisme de contrôle de l'accès à API Gateway APIs.
Pour plus d'informations sur les stratégies de ressources, consultez [Contrôle de l'accès à une API avec des stratégies de ressources API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) dans le *Guide du développeur API*. Pour un exemple de stratégies de ressources, consultez [Exemple de politique de ressources pour AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth Autorisateurs 2.0/JWT** — Vous pouvez les utiliser dans JWTs le cadre des frameworks OpenID [Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) et [OAuth 2.0](https://oauth.net/2/) pour contrôler l'accès à votre. APIs API Gateway valide les JWTs demandes d'API soumises par les clients et autorise ou refuse les demandes en fonction de la validation du jeton et, éventuellement, des étendues du jeton.
Seul le type de `AWS::Serverless::HttpApi` ressource prend en charge les autorisateurs OAuth 2.0/JWT.
Pour plus d'informations, consultez la section [Contrôle de l'accès au protocole HTTP APIs avec les autorisateurs JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) dans le guide du *développeur d'API Gateway*. Pour obtenir un exemple, consultez [OAuth Exemple d'autorisateur 2.0/JWT pour AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).
## Choix d'un mécanisme de contrôle d'accès
Le mécanisme que vous choisissez d'utiliser pour contrôler l'accès à votre API Gateway APIs dépend de plusieurs facteurs. Par exemple, si vous avez un projet inédit sans autorisation ni contrôle d'accès configuré, les groupes d'utilisateurs Amazon Cognito peuvent constituer votre meilleure option. En effet, lorsque vous configurez des groupes d'utilisateurs, vous configurez également automatiquement l'authentification et le contrôle d'accès.
Cependant, si votre application a déjà configuré l'authentification, l'utilisation de mécanismes d'autorisation Lambda pourrait être votre meilleur choix. Cela est dû au fait que vous pouvez appeler votre service d'authentification existant et renvoyer un document de stratégie basé sur la réponse. En outre, si votre application nécessite une authentification personnalisée ou une logique de contrôle d'accès que les groupes d'utilisateurs ne prennent pas en charge, alors les autorisations Lambda pourraient constituer votre meilleure option.
Lorsque vous avez choisi le mécanisme à utiliser, consultez la section correspondante [Exemples](#serverless-controlling-access-to-apis-examples) pour savoir comment l'utiliser AWS SAM pour configurer votre application afin qu'elle utilise ce mécanisme.
## Personnalisation des réponses d'erreur
Vous pouvez l'utiliser AWS SAM pour personnaliser le contenu de certaines réponses d'erreur d'API Gateway. Seul le type de ressource `AWS::Serverless::Api` prend en charge les réponses personnalisées API Gateway.
Pour plus d'informations sur les réponses API Gateway, consultez [Réponses de passerelle dans API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) dans le *Guide du développeur API Gateway*. Pour obtenir un exemple de réponses personnalisées, consultez [Exemple de réponse personnalisée pour AWS SAM](serverless-controlling-access-to-apis-customize-response.md).
## Exemples
+ [Exemples d'autorisateurs Lambda pour AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Exemple d'autorisation IAM pour AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Exemple de groupe d'utilisateurs Amazon Cognito pour AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Exemple de clé d'API pour AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Exemple de politique de ressources pour AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth Exemple d'autorisateur 2.0/JWT pour AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Exemple de réponse personnalisée pour AWS SAM](serverless-controlling-access-to-apis-customize-response.md)
# Exemples d'autorisateurs Lambda pour AWS SAM
Le type de ressource `AWS::Serverless::Api` prend en charge deux types de mécanismes d'autorisation Lambda : les mécanismes d'autorisation de `TOKEN` et les mécanismes d'autorisation de `REQUEST`. Le type de ressource `AWS::Serverless::HttpApi` prend uniquement en charge les mécanismes d' autorisation `REQUEST`. Voici des exemples de chaque type.
## Exemples d'autorisation Lambda `TOKEN` (AWS::Serverless::Api)
Vous pouvez contrôler l'accès à votre APIs en définissant un `TOKEN` autorisateur Lambda dans votre modèle. AWS SAM Vous devez pour cela utiliser le type de données [ApiAuth](sam-property-api-apiauth.md).
Voici un exemple de section de AWS SAM modèle pour un autorisateur Lambda `TOKEN` :
**Note**
Dans l'exemple suivant, le SAM `FunctionRole` est généré implicitement.
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaTokenAuthorizer
Authorizers:
MyLambdaTokenAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Pour plus d'informations sur les mécanismes d'autorisation Lambda, consultez [Utilisation des mécanismes d'autorisation pour les API Gateway Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) dans le *Guide du développeur API Gateway*.
## Exemples d'autorisation Lambda `REQUEST` (AWS::Serverless::Api)
Vous pouvez contrôler l'accès à votre APIs en définissant un `REQUEST` autorisateur Lambda dans votre modèle. AWS SAM Vous devez pour cela utiliser le type de données [ApiAuth](sam-property-api-apiauth.md).
Voici un exemple de section de AWS SAM modèle pour un autorisateur Lambda `REQUEST` :
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionPayloadType: REQUEST
FunctionArn: !GetAtt MyAuthFunction.Arn
Identity:
QueryStrings:
- auth
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Pour plus d'informations sur les mécanismes d'autorisation Lambda, consultez [Utilisation des mécanismes d'autorisation pour les API Gateway Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) dans le *Guide du développeur API Gateway*.
## Exemples d'autorisation Lambda (AWS::Serverless::HttpApi)
Vous pouvez contrôler l'accès à votre HTTP APIs en définissant un autorisateur Lambda dans votre modèle. AWS SAM Vous devez pour cela utiliser le type de données [HttpApiAuth](sam-property-httpapi-httpapiauth.md).
Voici un exemple de section de AWS SAM modèle pour un autorisateur Lambda :
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn
Identity:
Headers:
- Authorization
AuthorizerPayloadFormatVersion: 2.0
EnableSimpleResponses: true
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: HttpApi
Properties:
ApiId: !Ref MyApi
Path: /
Method: get
PayloadFormatVersion: "2.0"
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
# Exemple d'autorisation IAM pour AWS SAM
Vous pouvez contrôler l'accès à votre APIs en définissant les autorisations IAM dans votre AWS SAM modèle. Vous devez pour cela utiliser le type de données [ApiAuth](sam-property-api-apiauth.md).
Voici un exemple de AWS SAM modèle utilisé pour les autorisations IAM :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Description: 'API with IAM authorization'
Auth:
DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API
MyFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.10
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
```
Pour plus d'informations sur les autorisations IAM, consultez le [Contrôle de l'accès à une API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) dans le *Guide du développeur API Gateway*.
# Exemple de groupe d'utilisateurs Amazon Cognito pour AWS SAM
Vous pouvez contrôler l'accès à votre compte APIs en définissant des groupes d'utilisateurs Amazon Cognito dans votre AWS SAM modèle. Vous devez pour cela utiliser le type de données [ApiAuth](sam-property-api-apiauth.md).
Voici un exemple de section de AWS SAM modèle pour un groupe d'utilisateurs :
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Cors: "'*'"
Auth:
DefaultAuthorizer: MyCognitoAuthorizer
Authorizers:
MyCognitoAuthorizer:
UserPoolArn: !GetAtt MyCognitoUserPool.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: lambda.handler
Runtime: nodejs12.x
Events:
Root:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: GET
MyCognitoUserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: !Ref CognitoUserPoolName
Policies:
PasswordPolicy:
MinimumLength: 8
UsernameAttributes:
- email
Schema:
- AttributeDataType: String
Name: email
Required: false
MyCognitoUserPoolClient:
Type: AWS::Cognito::UserPoolClient
Properties:
UserPoolId: !Ref MyCognitoUserPool
ClientName: !Ref CognitoUserPoolClientName
GenerateSecret: false
```
Pour plus informations sur les groupes d'utilisateurs Amazon Cognito, consultez [Contrôle de l'accès à une API REST à l'aide de groupes d'utilisateurs Amazon Cognito en tant que mécanisme d'autorisation](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) dans le *Guide du développeur API Gateway*.
# Exemple de clé d'API pour AWS SAM
Vous pouvez contrôler l'accès à votre APIs en exigeant des clés d'API dans votre AWS SAM modèle. Vous devez pour cela utiliser le type de données [ApiAuth](sam-property-api-apiauth.md).
Voici un exemple de section de AWS SAM modèle pour les clés d'API :
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
ApiKeyRequired: true # sets for all methods
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: index.handler
Runtime: nodejs12.x
Events:
ApiKey:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
Auth:
ApiKeyRequired: true
```
Pour plus d'informations concernant les clés API, consultez [Création et utilisation de plans d'utilisation avec les clés API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) dans le *Guide du développeur API Gateway*.
# Exemple de politique de ressources pour AWS SAM
Vous pouvez contrôler l'accès à votre APIs en joignant une politique de ressources à votre AWS SAM modèle. Vous devez pour cela utiliser le type de données [ApiAuth](sam-property-api-apiauth.md).
Voici un exemple de AWS SAM modèle pour une API privée. Une API privée doit disposer d'une politique de ressources pour être déployée.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyPrivateApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
EndpointConfiguration: PRIVATE # Creates a private API. Resource policies are required for all private APIs.
Auth:
ResourcePolicy:
CustomStatements:
- Effect: 'Allow'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
- Effect: 'Deny'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
MyFunction:
Type: 'AWS::Serverless::Function'
Properties:
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
Handler: index.handler
Runtime: python3.10
Events:
AddItem:
Type: Api
Properties:
RestApiId:
Ref: MyPrivateApi
Path: /
Method: get
```
Pour plus d'informations sur les stratégies de ressources, consultez [Contrôle de l'accès à une API avec des stratégies de ressources API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) dans le *Guide du développeur API*. Pour plus d'informations sur le mode privé APIs, consultez [la section Création d'une API privée dans Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) dans le *guide du développeur d'API Gateway*.
# OAuth Exemple d'autorisateur 2.0/JWT pour AWS SAM
[Vous pouvez contrôler l'accès à votre APIs utilisation dans JWTs le cadre des [frameworks OpenID Connect (OIDC) et OAuth 2.0](https://openid.net/specs/openid-connect-core-1_0.html).](https://oauth.net/2/) Vous devez pour cela utiliser le type de données [HttpApiAuth](sam-property-httpapi-httpapiauth.md).
Voici un exemple de section de AWS SAM modèle pour un autorisateur OAuth 2.0/JWT :
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
Auth:
Authorizers:
MyOauth2Authorizer:
AuthorizationScopes:
- scope
IdentitySource: $request.header.Authorization
JwtConfiguration:
audience:
- audience1
- audience2
issuer: "https://www.example.com/v1/connect/oidc"
DefaultAuthorizer: MyOauth2Authorizer
StageName: Prod
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Events:
GetRoot:
Properties:
ApiId: MyApi
Method: get
Path: /
PayloadFormatVersion: "2.0"
Type: HttpApi
Handler: index.handler
Runtime: nodejs12.x
```
*Pour plus d'informations sur les autorisateurs OAuth 2.0/JWT, consultez la section [Contrôle de l'accès au HTTP APIs avec les autorisateurs JWT dans le guide du développeur](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) d'API Gateway.*
# Exemple de réponse personnalisée pour AWS SAM
Vous pouvez personnaliser certaines réponses d'erreur API Gateway en définissant des en-têtes de réponse dans votre modèle AWS SAM . Vous devez pour cela utiliser le type de données [Objet de réponse de passerelle](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).
Voici un exemple de AWS SAM modèle qui crée une réponse personnalisée à l'`DEFAULT_5XX`erreur.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
GatewayResponses:
DEFAULT_5XX:
ResponseParameters:
Headers:
Access-Control-Expose-Headers: "'WWW-Authenticate'"
Access-Control-Allow-Origin: "'*'"
ErrorHeader: "'MyCustomErrorHeader'"
ResponseTemplates:
application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }"
GetFunction:
Type: AWS::Serverless::Function
Properties:
Runtime: python3.10
Handler: index.handler
InlineCode: |
def handler(event, context):
raise Exception('Check out the new response!')
Events:
GetResource:
Type: Api
Properties:
Path: /error
Method: get
RestApiId: !Ref MyApi
```
Pour plus d'informations sur les réponses API Gateway, consultez [Réponses de passerelle dans API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) dans le *Guide du développeur API Gateway*.
# Améliorez l'efficacité en utilisant les couches Lambda avec AWS SAM
En utilisant AWS SAM, vous pouvez inclure des couches dans vos applications sans serveur. AWS Lambda les couches vous permettent d'extraire le code d'une fonction Lambda dans une couche Lambda qui peut ensuite être utilisée dans plusieurs fonctions Lambda. Cela vous permet de réduire la taille de vos packages de déploiement, de séparer la logique des fonctions de base des dépendances et de partager les dépendances entre plusieurs fonctions. Pour plus d'informations sur les couches, consultez la section [Couches Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) dans le Guide du *AWS Lambda développeur*.
Cette rubrique fournit des informations sur les éléments suivants :
+ Inclusion de couches dans votre application
+ Comment les couches sont mises en cache localement
Pour plus d'informations sur la création de couches personnalisées, consultez [Création de couches Lambda dans AWS SAM](building-layers.md).
## Inclusion de couches dans votre application
Pour inclure des couches dans votre application, utilisez la propriété `Layers` du type de ressource [AWS::Serverless::Function](sam-resource-function.md).
Voici un exemple de AWS SAM modèle avec une fonction Lambda qui inclut une couche :
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
-
```
## Comment les couches sont mises en cache localement
Lorsque vous appelez votre fonction à l'aide de l'une des commandes `sam local`, le package de couches de votre fonction est téléchargé et mis en cache sur votre hôte local.
Le tableau suivant montre les emplacements de répertoire des mises en cache par défaut pour les différents systèmes d'exploitation.
****
| Système d’exploitation | Location |
| --- | --- |
| Windows 7 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 8 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 10 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| macOS | \$1/.aws-sam/layers-pkg |
| Unix | \$1/.aws-sam/layers-pkg |
Une fois que le package est mis en cache, la CLI AWS SAM superpose les couches sur une image Docker utilisée pour invoquer votre fonction. AWS SAMCLIGénère les noms des images qu'il crée, ainsi que celles LayerVersions qui sont conservées dans le cache. Vous trouverez davantage de détails sur le schéma dans les sections suivantes.
Pour inspecter les couches superposées, exécutez la commande suivante pour démarrer une séance bash dans l'image à inspecter :
```
docker run -it --entrypoint=/bin/bash samcli/lambda: -i
```
**Schéma de nom de répertoire de mise en cache des couches**
Étant donné LayerVersionArn qu'un est défini dans votre modèle, la AWS SAMCLI version LayerName et est extraite de l'ARN. Elle crée un répertoire pour y placer le contenu de la couche, qui sera nommé `LayerName-Version-`.
Exemple :
```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```
**Schéma de balises pour les images Docker**
Pour calculer le hachage des couches uniques, combinez tous les noms de couches uniques avec un délimiteur « - », prenez le SHA256 hachage, puis les 10 premiers caractères.
Exemple :
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
- arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
- arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```
Les noms uniques sont calculés de la même manière que le schéma de nom du répertoire de mise en cache des couches :
```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```
Pour calculer le hachage des couches uniques, combinez tous les noms de couches uniques avec un délimiteur de '-', prenez le hachage sha256, puis prenez les 25 premiers caractères.
```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```
Combinez ensuite cette valeur avec l'exécution et l'architecture de la fonction, avec un délimiteur de '-' :
```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```
# Réutilisez le code et les ressources à l'aide d'applications imbriquées dans AWS SAM
Une application sans serveur peut comporter une ou plusieurs **applications imbriquées**. Une application imbriquée fait partie d'une application plus vaste et peut être empaquetée et déployée en tant qu'artefact autonome ou en tant que composant d'une application plus vaste. Les applications imbriquées vous permettent de transformer le code fréquemment utilisé en une seule application qui peut ensuite être réutilisée dans une application sans serveur plus importante ou dans plusieurs applications sans serveur.
Au fur et à mesure que vos architectures sans serveur se développent, des modèles communs apparaissent généralement dans lesquels les mêmes composants sont définis dans plusieurs modèles d'applications. Les applications imbriquées vous permettent de réutiliser le code, les fonctionnalités, les ressources et les configurations courants dans des AWS SAM modèles distincts, ce qui vous permet de ne gérer que le code provenant d'une source unique. Cela permet de réduire le code et les configurations dupliqués. En outre, cette approche modulaire rationalise le développement, améliore l'organisation du code et facilite la cohérence entre les applications sans serveur. Avec les applications imbriquées, vous pouvez rester plus concentré sur la logique métier propre à votre application.
Pour définir une application imbriquée dans votre application sans serveur, utilisez le type de ressource [AWS::Serverless::Application](sam-resource-application.md).
Vous pouvez définir des applications imbriquées à partir des deux sources suivantes :
+ Une **application AWS Serverless Application Repository ** – Vous pouvez définir des applications imbriquées à l'aide d'applications disponibles pour votre compte dans le AWS Serverless Application Repository. Celles-ci peuvent être des applications *privées* dans votre compte, des applications qui sont *partagé de manière privée* avec votre compte, ou des applications qui sont *publiquement partagées * dans le AWS Serverless Application Repository. Pour plus d'informations sur les différents niveaux d'autorisation de déploiement, consultez [Autorisations de déploiement d'applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) et [Publication des applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) dans le *Guide du développeur AWS Serverless Application Repository *.
+ Une **application locale** – Vous pouvez définir des applications imbriquées à l'aide d'applications qui sont stockées sur votre système de fichiers local.
Consultez les sections suivantes pour savoir comment AWS SAM définir ces deux types d'applications imbriquées dans votre application sans serveur.
**Note**
Le nombre maximal d'applications pouvant être imbriquées dans une application sans serveur est de 200.
Le nombre maximal de paramètres qu'une application imbriquée peut avoir est de 60.
## Définition d'une application imbriquée à partir du AWS Serverless Application Repository
Vous pouvez définir des applications imbriquées à l'aide d'applications qui sont disponibles pour votre compte dans le AWS Serverless Application Repository. Vous pouvez également stocker et distribuer des applications qui contiennent des applications imbriquées à l'aide du AWS Serverless Application Repository. Pour consulter les détails d'une application imbriquée dans le AWS Serverless Application Repository, vous pouvez utiliser le AWS SDK, la console Lambda ou la AWS CLI console Lambda.
Pour définir une application hébergée AWS Serverless Application Repository dans le AWS SAM modèle de votre application sans serveur, utilisez le bouton **Copier en tant que ressource SAM** sur la page détaillée de chaque AWS Serverless Application Repository application. Pour cela, procédez comme suit :
1. Assurez-vous que vous êtes connecté à la AWS Management Console.
1. Trouvez l'application dans laquelle vous souhaitez vous intégrer AWS Serverless Application Repository en suivant les étapes décrites dans la section [Navigation, recherche et déploiement d'applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications ) du *guide du AWS Serverless Application Repository développeur*.
1. Cliquez sur le bouton **Copier comme ressource SAM**. La section de modèle SAM de l'application que vous consultez est maintenant dans votre Presse-papiers.
1. Collez la section du modèle SAM dans la section `Resources:` du fichier de modèle SAM pour l'application que vous souhaitez imbriquer dans cette application.
Voici un exemple de section de modèle SAM pour une application imbriquée hébergée dans le AWS Serverless Application Repository :
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:us-east-1:123456789012:applications/application-alias-name
SemanticVersion: 1.0.0
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Si aucun paramètre n'est requis, vous pouvez omettre la section `Parameters:` du modèle.
**Important**
Les applications qui contiennent des applications imbriquées hébergées dans le AWS Serverless Application Repository héritent des restrictions de partage des applications imbriquées.
Supposons, par exemple, qu'une application soit partagée publiquement, mais qu'elle contienne une application imbriquée qui n'est partagée en privé qu'avec le AWS compte qui a créé l'application parent. Dans ce cas, si votre AWS compte n'est pas autorisé à déployer l'application imbriquée, vous ne pouvez pas déployer l'application parent. Pour plus d'informations sur les autorisation de déploiement des applications, consultez [Autorisations de déploiement d'applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) et [Publication des applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) dans le *Guide du développeur AWS Serverless Application Repository *.
## Définition d'une application imbriquée à partir du système de fichiers local
Vous pouvez définir des applications imbriquées à l'aide d'applications qui sont stockées sur votre système de fichiers local. Pour ce faire, spécifiez le chemin d'accès au fichier AWS SAM modèle stocké sur votre système de fichiers local.
Voici un exemple de section de modèle SAM pour une application imbriquée :
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location: ../my-other-app/template.yaml
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
S'il n'y a pas de réglage de paramètres, vous pouvez omettre la section `Parameters:` du modèle.
## Déploiement d'applications imbriquées
Vous pouvez déployer votre application imbriquée en utilisant la commande `sam deploy` de la CLI AWS SAM. Pour en savoir plus, consultez [Déployez votre application et vos ressources avec AWS SAM](serverless-deploying.md).
**Note**
Lorsque vous déployez une application qui contient des applications imbriquées, vous devez reconnaître qu'elle contient des applications imbriquées. Pour ce faire, passez `CAPABILITY_AUTO_EXPAND` à l'[CreateCloudFormationChangeSet API](https://docs.aws.amazon.com/goto/WebAPI/serverlessrepo-2017-09-08/CreateCloudFormationChangeSet) ou utilisez la [https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html) AWS CLI commande.
Pour plus d'informations sur la reconnaissance des applications imbriquées, consultez [Reconnaissance des rôles, des stratégies de ressources et des applications imbriquées IAM lors du déploiement d'applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/acknowledging-application-capabilities.html) dans le *Guide du développeur AWS Serverless Application Repository *.
# Gérez les événements temporels avec le EventBridge planificateur dans AWS SAM
Le contenu de cette rubrique explique en détail ce qu'est Amazon EventBridge Scheduler, quelles sont les AWS SAM offres d'assistance, comment créer des événements Scheduler, ainsi que des exemples auxquels vous pouvez vous référer lors de la création d'événements Scheduler.
## Qu'est-ce qu'Amazon EventBridge Scheduler ?
Utilisez le EventBridge planificateur pour planifier des événements dans vos AWS SAM modèles. Amazon EventBridge Scheduler est un service de planification qui vous permet de créer, de lancer et de gérer des dizaines de millions d'événements et de tâches dans tous les AWS services. Ce service est particulièrement utile pour les événements liés au temps. Vous pouvez l'utiliser pour planifier des événements et des appels récurrents basés sur le temps. Il prend également en charge les événements ponctuels ainsi que les expressions de taux et de chronologie avec une heure de début et de fin.
Pour en savoir plus sur Amazon EventBridge Scheduler, consultez [Qu'est-ce qu'Amazon EventBridge ](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html) Scheduler ? dans le guide de l'*utilisateur EventBridge du planificateur*.
**Topics**
+ [Qu'est-ce qu'Amazon EventBridge Scheduler ?](#using-eventbridge-scheduler-intro)
+ [EventBridge Support du planificateur dans AWS SAM](#using-eventbridge-scheduler-sam-support)
+ [Création d' EventBridge événements du planificateur dans AWS SAM](#using-eventbridge-scheduler-sam-create)
+ [Exemples](#using-eventbridge-scheduler-examples)
+ [En savoir plus](#using-eventbridge-scheduler-learn)
## EventBridge Support du planificateur dans AWS SAM
La spécification du modèle AWS Serverless Application Model (AWS SAM) fournit une syntaxe simple et abrégée que vous pouvez utiliser pour planifier des événements avec EventBridge Scheduler for et. AWS Lambda AWS Step Functions
## Création d' EventBridge événements du planificateur dans AWS SAM
Définissez la `ScheduleV2` propriété comme type d'événement dans votre AWS SAM modèle pour définir votre événement EventBridge Scheduler. Cette propriété prend en charge les types de ressources `AWS::Serverless::Function` et `AWS::Serverless::StateMachine`.
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2Function
Description: Test schedule event
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2StateMachine
Description: Test schedule event
```
EventBridge La planification des événements du planificateur prend également en charge les *files d'attente de lettres mortes (DLQ*) pour les événements non traités. *Pour plus d'informations sur les files d'attente de lettres mortes, consultez la [section Configuration d'une file d'attente de lettres mortes pour le planificateur dans le guide de l'utilisateur du EventBridge planificateur](https://docs.aws.amazon.com/scheduler/latest/UserGuide/configuring-schedule-dlq.html). EventBridge *
Lorsqu'un ARN DLQ est spécifié, AWS SAM configure les autorisations pour que le planificateur planifie l'envoi de messages au DLQ. Lorsqu'aucun ARN DLQ n'est spécifié, la AWS SAM ressource DLQ est créée.
## Exemples
### Exemple de base de définition d'un événement EventBridge Scheduler avec AWS SAM
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
MySFNFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
StateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Type: STANDARD
Definition:
StartAt: MyLambdaState
States:
MyLambdaState:
Type: Task
Resource: !GetAtt MySFNFunction.Arn
End: true
Policies:
- LambdaInvokePolicy:
FunctionName: !Ref MySFNFunction
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
```
## En savoir plus
Pour en savoir plus sur la définition de la propriété `ScheduleV2` EventBridge Scheduler, voir :
+ [ScheduleV2](sam-property-function-schedulev2.md) pour `AWS::Serverless::Function`.
+ [ScheduleV2](sam-property-statemachine-statemachineschedulev2.md) pour `AWS::Serverless::StateMachine`.
# Orchestrer les AWS SAM ressources avec AWS Step Functions
Vous pouvez l'utiliser [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/)pour orchestrer des AWS Lambda fonctions et d'autres AWS ressources afin de créer des flux de travail complexes et robustes. Step Functions pour indiquer à votre application quand et dans quelles conditions vos AWS ressources, telles que AWS Lambda les fonctions, sont utilisées. Cela simplifie le processus de création de flux de travail complexes et robustes. À l'aide de[AWS::Serverless::StateMachine](sam-resource-statemachine.md), vous définissez les différentes étapes de votre flux de travail, associez des ressources à chaque étape, puis séquencez ces étapes ensemble. Vous ajoutez également des transitions et des conditions là où elles sont nécessaires. Cela simplifie le processus de création d'un flux de travail complexe et robuste.
**Note**
Pour gérer les AWS SAM modèles contenant des machines d'état Step Functions, vous devez utiliser la version 0.52.0 ou ultérieure du AWS SAMCLI. Pour vérifier la version dont vous disposez, exécutez la commande `sam --version`.
Step Functions repose sur les concepts de [tâches](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html) et de [machines d'état](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html). Vous définissez les machines d'état à l'aide du [Langage des états Amazon](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) basé sur JSON. La [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) affiche une vue graphique de la structure de votre machine d'état, ce qui vous permet de vérifier visuellement la logique de votre machine d'état et de contrôler les exécutions.
Grâce à la prise en charge de Step Functions dans AWS Serverless Application Model (AWS SAM), vous pouvez effectuer les opérations suivantes :
+ Définissez des machines à états, soit directement dans un AWS SAM modèle, soit dans un fichier séparé
+ Créez des rôles d'exécution de machines à états via des modèles de AWS SAM politiques, des politiques intégrées ou des politiques gérées
+ Déclenchez des exécutions automatiques à l'aide d' EventBridge événements API Gateway ou Amazon, selon un calendrier défini dans un AWS SAM modèle ou en appelant APIs directement
+ Utiliser des [AWS SAM Modèles de stratégie](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) disponibles pour les modèles de développement courants Step Functions.
## Exemple
L'extrait d'un fichier AWS SAM modèle suivant définit une machine d'état Step Functions dans un fichier de définition. Remarque : le fichier `my_state_machine.asl.json` doit être écrit dans la [Langue des états Amazon](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html).
```
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Sample SAM template with Step Functions State Machine
Resources:
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionUri: statemachine/my_state_machine.asl.json
...
```
Pour télécharger un exemple d' AWS SAM application qui inclut une machine d'état Step Functions, voir [Create a Step Functions State Machine Using AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html) dans le *manuel du AWS Step Functions développeur*.
## En savoir plus
Pour en savoir plus sur Step Functions et son utilisation avec Step Functions AWS SAM, consultez les rubriques suivantes :
+ [Fonctionnement de AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/how-step-functions-works.html)
+ [AWS Step Functions et AWS Serverless Application Model](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-sam-sfn.html)
+ [Tutoriel : Création d'une machine à états Step Functions à l'aide de AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html)
+ [AWS SAM Spécification : AWS::Serverless::StateMachine](sam-resource-statemachine.md)
# Configurer la signature de code pour votre AWS SAM application
Pour garantir que seul le code fiable est déployé, vous pouvez AWS SAM activer la signature de code avec vos applications sans serveur. La signature de votre code permet de garantir que le code n'a pas été modifié depuis la signature et que seuls les packages de code signés provenant d'éditeurs approuvés s'exécutent dans vos fonctions Lambda. Cela permet aux entreprises de se libérer de la charge de créer des composants de contrôle d'accès dans leurs pipelines de déploiement.
Pour plus d'informations sur la signature de code, consultez la [section Configuration de la signature de code pour les fonctions Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html) dans le Guide du *AWS Lambda développeur*.
Avant de configurer la signature de code pour votre application sans serveur, vous devez créer un profil de signature à l'aide de AWS Signer. Vous utiliserez ce profil de signature pour les tâches suivantes :
1. **Création d'une configuration de signature de code** – Déclarez une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html) pour spécifier les profils de signature des éditeurs approuvés et définir l'action de stratégie pour les vérifications de validation. Vous pouvez déclarer cet objet dans le même AWS SAM modèle que votre fonction sans serveur, dans un autre AWS SAM modèle ou dans un CloudFormation modèle. Vous activez ensuite la signature de code pour une fonction sans serveur en spécifiant la propriété [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn) avec la fonction Amazon Resource Name (ARN) d'une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html).
1. **Signature de votre code** – Utilisez la commande [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html) ou [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) avec l'option `--signing-profiles`.
**Note**
Afin de signer avec succès votre code avec les commandes `sam package` ou `sam deploy`, la gestion des versions doit être activée pour le compartiment Amazon S3 que vous utilisez avec ces commandes. Si vous utilisez le compartiment Amazon S3 AWS SAM créé pour vous, le versionnement est activé automatiquement. Pour de plus amples informations sur la gestion des versions du compartiment Amazon S3 et des instructions sur l'activation de la gestion des versions sur un compartiment Amazon S3 que vous fournissez, consultez [Utilisation de la gestion des versions dans les compartiments Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *Guide du emploi Amazon Simple Storage Service*.
Lorsque vous déployez une application sans serveur, Lambda effectue des vérifications de validation sur toutes les fonctions pour lesquelles vous avez activé la signature de code. Lambda effectue également des vérifications de validation sur toutes les couches dont ces fonctions dépendent. Pour de plus amples informations sur les vérifications de validation de Lambda, consultez [Validation de signature](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html#config-codesigning-valid) dans le *Guide du développeur AWS Lambda *.
## Exemple
### Création d'un profil de signature
Pour créer un profil de signature, exécutez la commande suivante :
```
aws signer put-signing-profile --platform-id "AWSLambda-SHA384-ECDSA" --profile-name MySigningProfile
```
Si la commande précédente réussit, vous voyez l'ARN du profil de signature renvoyé. Par exemple :
```
{
"arn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile",
"profileVersion": "SAMPLEverx",
"profileVersionArn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile/SAMPLEverx"
}
```
Le champ `profileVersionArn` contient l'ARN à utiliser lors de la création de la configuration de signature de code.
### Création d'une configuration de signature de code et activation de la signature de code pour une fonction
L'exemple de AWS SAM modèle suivant déclare une [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)ressource et active la signature de code pour une fonction Lambda. Dans cet exemple, il existe un profil approuvé et les déploiements sont rejetés si les vérifications de signature échouent.
```
Resources:
HelloWorld:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: !Ref MySignedFunctionCodeSigningConfig
MySignedFunctionCodeSigningConfig:
Type: AWS::Lambda::CodeSigningConfig
Properties:
Description: "Code Signing for MySignedLambdaFunction"
AllowedPublishers:
SigningProfileVersionArns:
- MySigningProfile-profileVersionArn
CodeSigningPolicies:
UntrustedArtifactOnDeployment: "Enforce"
```
### Signature de votre code
Vous pouvez signer votre code lors de l'empaquetage ou du déploiement de votre application. Spécifiez l'option `--signing-profiles` avec la commande `sam package` ou `sam deploy`, comme illustré dans l'exemple de commandes suivant.
Signer votre code de fonction lors de l'empaquetage de votre application :
```
sam package --signing-profiles HelloWorld=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Signer à la fois votre code de fonction et une couche dont votre fonction dépend, lors de l'empaquetage de votre application :
```
sam package --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Signer votre code de fonction et une couche, puis effectuer un déploiement :
```
sam deploy --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --template-file packaged.yaml --stack-name --region us-east-1 --capabilities CAPABILITY_IAM
```
**Note**
Afin de signer avec succès votre code avec les commandes `sam package` ou `sam deploy`, la gestion des versions doit être activée pour le compartiment Amazon S3 que vous utilisez avec ces commandes. Si vous utilisez le compartiment Amazon S3 AWS SAM créé pour vous, le versionnement est activé automatiquement. Pour de plus amples informations sur la gestion des versions du compartiment Amazon S3 et des instructions sur l'activation de la gestion des versions sur un compartiment Amazon S3 que vous fournissez, consultez [Utilisation de la gestion des versions dans les compartiments Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) dans le *Guide du emploi Amazon Simple Storage Service*.
## Fournir des profils de signature avec `sam deploy --guided`
Lorsque vous exécutez la `sam deploy --guided` commande avec une application sans serveur configurée avec la signature de code, elle vous AWS SAM invite à fournir le profil de signature à utiliser pour la signature de code. Pour plus d'informations sur les invites `sam deploy --guided`, consultez [sam deploy](sam-cli-command-reference-sam-deploy.md) dans la référence des commandes de la CLI AWS SAM.
# Valider les fichiers AWS SAM modèles
Validez vos modèles avec `sam validate`. Actuellement, cette commande valide le fait que le modèle fourni est un JSON/YAML valide. Comme avec la plupart des commandes CLI AWS SAM, elle recherche un fichier `template.[yaml|yml]` par défaut dans votre répertoire de travail actuel. Vous pouvez spécifier un autre modèle à l' file/location aide de l'`--template`option `-t` ou.
Exemple :
```
$ sam validate
/template.yaml is a valid SAM Template
```
**Note**
La `sam validate` commande nécessite la configuration des AWS informations d'identification. Pour de plus amples informations, veuillez consulter [Configuration de la CLI AWS SAM](using-sam-cli-configure.md).