Avis de fin de support : le 7 octobre 2026, AWS le support de AWS Proton. Après le 7 octobre 2026, vous ne pourrez plus accéder à la AWS Proton console ni aux AWS Proton ressources. Votre infrastructure déployée restera intacte. Pour plus d'informations, consultez le Guide [AWS Proton de dépréciation et de migration des services](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html).
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.
# AWS Proton paramètres
Vous pouvez définir et utiliser les paramètres de votre infrastructure sous forme de fichiers de code (IaC) pour les rendre flexibles et réutilisables. Vous pouvez lire la valeur d'un paramètre dans vos fichiers IaC en vous référant au nom du paramètre dans l'espace de *noms des AWS Proton paramètres*. AWS Proton injecte des valeurs de paramètres dans les fichiers iAc rendus qu'il génère lors du provisionnement des ressources. Pour traiter les AWS CloudFormation paramètres IaC, AWS Proton utilise [Jinja](https://jinja.palletsprojects.com/en/2.11.x/). Pour traiter les paramètres Terraform IaC, AWS Proton génère un fichier de valeurs de paramètres Terraform et s'appuie sur la capacité de paramétrage intégrée à HCL.
Avec[CodeBuild approvisionnement](ag-works-prov-methods.md#ag-works-prov-methods-codebuild), AWS Proton génère un fichier d'entrée que votre code peut importer. Le fichier est un fichier JSON ou HCL, selon une propriété du manifeste de votre modèle. Pour de plus amples informations, veuillez consulter [CodeBuild détails et exemples des paramètres de provisionnement](parameters-codebuild.md).
Vous pouvez faire référence aux paramètres de votre environnement, de vos services et de vos composants, aux fichiers iAc ou au code de provisionnement en respectant les exigences suivantes :
+ La longueur de chaque nom de paramètre ne dépasse pas 100 caractères.
+ La longueur de l'espace de noms des paramètres et du nom de ressource combinés ne dépasse pas la limite de caractères du nom de la ressource.
AWS Proton le provisionnement échoue si ces quotas sont dépassés.
## Types de paramètres
Les types de paramètres suivants sont à votre disposition pour référence dans les fichiers AWS Proton IaC :
**Paramètre d'entrée**
Les environnements et les instances de service peuvent prendre des paramètres d'entrée que vous définissez dans un [fichier de schéma](ag-schema.md) que vous associez à l'environnement ou au modèle de service. Vous pouvez vous référer aux paramètres d'entrée d'une ressource dans le fichier IaC de la ressource. Les fichiers iAc du composant peuvent faire référence aux paramètres d'entrée de l'instance de service à laquelle le composant est attaché.
AWS Proton vérifie les noms des paramètres d'entrée par rapport à votre fichier de schéma et les associe aux paramètres référencés dans vos fichiers iAc pour injecter les valeurs d'entrée que vous fournissez dans un fichier de spécifications lors du provisionnement des ressources.
**Paramètre de sortie**
Vous pouvez définir des sorties dans n'importe lequel de vos fichiers iAc. Une sortie peut être, par exemple, le nom, l'ID ou l'ARN de l'une des ressources fournies par le modèle, ou elle peut être un moyen de passer par l'une des entrées du modèle. Vous pouvez faire référence à ces sorties dans les fichiers IaC d'autres ressources.
Dans les CloudFormation fichiers IaC, définissez les paramètres de sortie dans le `Outputs:` bloc. Dans un fichier Terraform iAC, définissez chaque paramètre de sortie à l'aide d'une `output` instruction.
**Paramètre de ressource**
AWS Proton crée automatiquement les paramètres AWS Proton des ressources. Ces paramètres exposent les propriétés de l'objet de AWS Proton ressource. Voici un exemple de paramètre de ressource`environment.name`.
## Utilisation de AWS Proton paramètres dans vos fichiers iAc
Pour lire la valeur d'un paramètre dans un fichier IaC, vous devez vous référer au nom du paramètre dans l'espace de noms des AWS Proton paramètres. Pour les fichiers AWS CloudFormation iAC, vous devez utiliser la syntaxe *Jinja* et entourer le paramètre de paires d'accolades et de guillemets.
Le tableau suivant indique la syntaxe de référence pour chaque langage de modèle pris en charge, avec un exemple.
| Langage du modèle | Syntaxe | Exemple : entrée d'environnement nommée « VPC » |
| --- | --- | --- |
| CloudFormation | `"{{ parameter-name }}"` | `"{{ environment.inputs.VPC }}"` |
| Terraform | `var.parameter-name` | `var.environment.inputs.VPC` [Définitions de variables Terraform générées](ag-infrastructure-tmp-files-terraform.md#compiled-tform) |
**Note**
Si vous utilisez des [paramètres CloudFormation dynamiques](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html) dans votre fichier IaC, vous devez [y échapper pour éviter les](https://jinja.palletsprojects.com/en/2.11.x/templates/#escaping) erreurs d'interprétation par Jinja. Pour de plus amples informations, consultez [Résolution des problèmes AWS Proton](ag-troubleshooting.md).
Le tableau suivant répertorie les noms d'espaces de noms pour tous les paramètres de AWS Proton ressources. Chaque type de fichier modèle peut utiliser un sous-ensemble différent de l'espace de noms des paramètres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/proton/latest/userguide/parameters.html)
Pour plus d'informations et des exemples, consultez les sous-rubriques relatives aux paramètres des fichiers modèles IaC pour différents types de ressources et différents langages de modèles.
**Topics**
+ [Types de paramètres](#param-name-types)
+ [Utilisation de AWS Proton paramètres dans vos fichiers iAc](#param-name-spaces)
+ [Détails et exemples des paramètres du fichier CloudFormation iAC d'environnement](env-parameters.md)
+ [Détails et exemples des paramètres du fichier CloudFormation IaC du service](svc-parameters.md)
+ [Détails et exemples des paramètres du fichier CloudFormation iAC du composant](comp-parameters.md)
+ [Filtres de paramètres pour les fichiers CloudFormation IaC](parameter-filters.md)
+ [CodeBuild détails et exemples des paramètres de provisionnement](parameters-codebuild.md)
+ [Détails et exemples des paramètres du fichier d'infrastructure en tant que code (IaC) Terraform](env-parameters-tform.md)
# Détails et exemples des paramètres du fichier CloudFormation iAC d'environnement
Vous pouvez définir et référencer les paramètres de votre infrastructure d'environnement sous forme de fichiers de code (IaC). Pour une description détaillée des AWS Proton paramètres, des types de paramètres, de l'espace de noms des paramètres et de la façon d'utiliser les paramètres dans vos fichiers iAc, consultez[AWS Proton paramètres](parameters.md).
## Définir les paramètres de l'environnement
Vous pouvez définir des paramètres d'entrée et de sortie pour les fichiers iAc d'environnement.
+ **Paramètres d'entrée** : définissez les paramètres d'entrée de l'environnement dans votre [fichier de schéma](ag-schema.md).
La liste suivante inclut des exemples de paramètres d'entrée d'environnement pour des cas d'utilisation typiques.
+ Valeurs CIDR VPC
+ Paramètres de l'équilibreur de charge
+ Paramètres de base de données
+ Un délai d'expiration pour le bilan de santé
En tant qu'administrateur, vous pouvez fournir des valeurs pour les paramètres d'entrée lorsque vous [créez un environnement](ag-create-env.md) :
+ Utilisez la console pour remplir un formulaire basé sur un schéma qui AWS Proton fournit.
+ Utilisez la CLI pour fournir une spécification qui inclut les valeurs.
+ **Paramètres de sortie** — Définissez les sorties d'environnement dans les fichiers iAc de votre environnement. Vous pouvez ensuite faire référence à ces sorties dans les fichiers IaC d'autres ressources.
## Lire les valeurs des paramètres dans les fichiers iAC de l'environnement
Vous pouvez lire les paramètres relatifs à l'environnement dans les fichiers iAc de l'environnement. Vous pouvez lire la valeur d'un paramètre en faisant référence au nom du paramètre dans l'espace de noms des AWS Proton paramètres.
+ **Paramètres d'entrée** — Lisez la valeur d'entrée d'un environnement en la référençant`environment.inputs.input-name`.
+ **Paramètres des ressources** : lisez les paramètres AWS Proton des ressources en faisant référence à des noms tels que`environment.name`.
**Note**
Aucun paramètre de sortie d'autres ressources n'est disponible pour les fichiers iAc de l'environnement.
## Exemples de fichiers IaC d'environnement et de service avec paramètres
L'exemple suivant illustre la définition et la référence de paramètres dans un fichier IaC d'environnement. L'exemple montre ensuite comment les paramètres de sortie d'environnement définis dans le fichier IaC d'environnement peuvent être référencés dans un fichier IaC de service.
**Example Fichier CloudFormation iAc d'environnement**
Notez ce qui suit dans cet exemple :
+ L'espace de `environment.inputs.` noms fait référence aux paramètres d'entrée de l'environnement.
+ Le paramètre Amazon EC2 Systems Manager (SSM) `StoreInputValue` concatène les entrées de l'environnement.
+ La `MyEnvParameterValue` sortie expose la même concaténation de paramètres d'entrée qu'un paramètre de sortie. Trois paramètres de sortie supplémentaires exposent également les paramètres d'entrée individuellement.
+ Six paramètres de sortie supplémentaires exposent les ressources fournies par l'environnement.
```
Resources:
StoreInputValue:
Type: AWS::SSM::Parameter
Properties:
Type: String
Value: "{{ environment.inputs.my_sample_input }} {{ environment.inputs.my_other_sample_input}} {{ environment.inputs.another_optional_input }}"
# input parameter references
# These output values are available to service infrastructure as code files as outputs, when given the
# the 'environment.outputs' namespace, for example, service_instance.environment.outputs.ClusterName.
Outputs:
MyEnvParameterValue: # output definition
Value: !GetAtt StoreInputValue.Value
MySampleInputValue: # output definition
Value: "{{ environment.inputs.my_sample_input }}" # input parameter reference
MyOtherSampleInputValue: # output definition
Value: "{{ environment.inputs.my_other_sample_input }}" # input parameter reference
AnotherOptionalInputValue: # output definition
Value: "{{ environment.inputs.another_optional_input }}" # input parameter reference
ClusterName: # output definition
Description: The name of the ECS cluster
Value: !Ref 'ECSCluster' # provisioned resource
ECSTaskExecutionRole: # output definition
Description: The ARN of the ECS role
Value: !GetAtt 'ECSTaskExecutionRole.Arn' # provisioned resource
VpcId: # output definition
Description: The ID of the VPC that this stack is deployed in
Value: !Ref 'VPC' # provisioned resource
PublicSubnetOne: # output definition
Description: Public subnet one
Value: !Ref 'PublicSubnetOne' # provisioned resource
PublicSubnetTwo: # output definition
Description: Public subnet two
Value: !Ref 'PublicSubnetTwo' # provisioned resource
ContainerSecurityGroup: # output definition
Description: A security group used to allow Fargate containers to receive traffic
Value: !Ref 'ContainerSecurityGroup' # provisioned resource
```
**Example Fichier CloudFormation IaC du service**
L'espace de `environment.outputs.` noms fait référence aux sorties d'environnement d'un fichier IaC d'environnement. Par exemple, le nom `environment.outputs.ClusterName` indique la valeur du paramètre de sortie de `ClusterName` l'environnement.
```
AWSTemplateFormatVersion: '2010-09-09'
Description: Deploy a service on AWS Fargate, hosted in a public subnet, and accessible via a public load balancer.
Mappings:
TaskSize:
x-small:
cpu: 256
memory: 512
small:
cpu: 512
memory: 1024
medium:
cpu: 1024
memory: 2048
large:
cpu: 2048
memory: 4096
x-large:
cpu: 4096
memory: 8192
Resources:
# A log group for storing the stdout logs from this service's containers
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: '{{service_instance.name}}' # resource parameter
# The task definition. This is a simple metadata description of what
# container to run, and what resource requirements it has.
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
Family: '{{service_instance.name}}' # resource parameter
Cpu: !FindInMap [TaskSize, {{service_instance.inputs.task_size}}, cpu] # input parameter
Memory: !FindInMap [TaskSize, {{service_instance.inputs.task_size}}, memory]
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
ExecutionRoleArn: '{{environment.outputs.ECSTaskExecutionRole}}' # output reference to an environment infrastructure code file
TaskRoleArn: !Ref "AWS::NoValue"
ContainerDefinitions:
- Name: '{{service_instance.name}}' # resource parameter
Cpu: !FindInMap [TaskSize, {{service_instance.inputs.task_size}}, cpu]
Memory: !FindInMap [TaskSize, {{service_instance.inputs.task_size}}, memory]
Image: '{{service_instance.inputs.image}}'
PortMappings:
- ContainerPort: '{{service_instance.inputs.port}}' # input parameter
LogConfiguration:
LogDriver: 'awslogs'
Options:
awslogs-group: '{{service_instance.name}}' # resource parameter
awslogs-region: !Ref 'AWS::Region'
awslogs-stream-prefix: '{{service_instance.name}}' # resource parameter
# The service_instance. The service is a resource which allows you to run multiple
# copies of a type of task, and gather up their logs and metrics, as well
# as monitor the number of running tasks and replace any that have crashed
Service:
Type: AWS::ECS::Service
DependsOn: LoadBalancerRule
Properties:
ServiceName: '{{service_instance.name}}' # resource parameter
Cluster: '{{environment.outputs.ClusterName}}' # output reference to an environment infrastructure as code file
LaunchType: FARGATE
DeploymentConfiguration:
MaximumPercent: 200
MinimumHealthyPercent: 75
DesiredCount: '{{service_instance.inputs.desired_count}}'# input parameter
NetworkConfiguration:
AwsvpcConfiguration:
AssignPublicIp: ENABLED
SecurityGroups:
- '{{environment.outputs.ContainerSecurityGroup}}' # output reference to an environment infrastructure as code file
Subnets:
- '{{environment.outputs.PublicSubnetOne}}' # output reference to an environment infrastructure as code file
- '{{environment.outputs.PublicSubnetTwo}}' # output reference to an environment infrastructure as code file
TaskDefinition: !Ref 'TaskDefinition'
LoadBalancers:
- ContainerName: '{{service_instance.name}}' # resource parameter
ContainerPort: '{{service_instance.inputs.port}}' # input parameter
TargetGroupArn: !Ref 'TargetGroup'
[...]
```
# Détails et exemples des paramètres du fichier CloudFormation IaC du service
Vous pouvez définir et référencer les paramètres de votre infrastructure de service et de pipeline sous forme de fichiers de code (iAc). Pour une description détaillée des AWS Proton paramètres, des types de paramètres, de l'espace de noms des paramètres et de la façon d'utiliser les paramètres dans vos fichiers iAc, consultez[AWS Proton paramètres](parameters.md).
## Définir les paramètres du service
Vous pouvez définir des paramètres d'entrée et de sortie pour les fichiers IaC du service.
+ **Paramètres d'entrée** : définissez les paramètres d'entrée de l'instance de service dans votre [fichier de schéma](ag-schema.md).
La liste suivante inclut des exemples de paramètres d'entrée de service pour des cas d'utilisation typiques.
+ Port
+ Taille de la tâche
+ Image
+ Nombre souhaité
+ fichier Docker
+ Commande de test unitaire
Vous fournissez des valeurs pour les paramètres d'entrée lorsque vous [créez un service](ag-create-svc.md) :
+ Utilisez la console pour remplir un formulaire basé sur un schéma qui AWS Proton fournit.
+ Utilisez la CLI pour fournir une spécification qui inclut les valeurs.
+ **Paramètres de sortie** — Définissez les sorties des instances de service dans vos fichiers IaC de service. Vous pouvez ensuite faire référence à ces sorties dans les fichiers IaC d'autres ressources.
## Lire les valeurs des paramètres dans les fichiers IaC du service
Vous pouvez lire les paramètres relatifs au service et aux autres ressources dans les fichiers IaC du service. Vous pouvez lire la valeur d'un paramètre en faisant référence au nom du paramètre dans l'espace de noms des AWS Proton paramètres.
+ **Paramètres d'entrée** — Lisez la valeur d'entrée d'une instance de service en la référençant`service_instance.inputs.input-name`.
+ **Paramètres des ressources** : lisez les paramètres AWS Proton des ressources en faisant référence à des noms tels que `service.name``service_instance.name`, et`environment.name`.
+ **Paramètres de sortie** — Lisez les sorties d'autres ressources en faisant référence à `environment.outputs.output-name` ou`service_instance.components.default.outputs.output-name`.
## Exemple de fichier IaC de service avec paramètres
L'exemple suivant est un extrait d'un fichier IaC de service CloudFormation . L'espace de `environment.outputs.` noms fait référence aux sorties du fichier IaC de l'environnement. L'espace de `service_instance.inputs.` noms fait référence aux paramètres d'entrée de l'instance de service. La `service_instance.name` propriété fait référence à un paramètre de AWS Proton ressource.
```
Resources:
StoreServiceInstanceInputValue:
Type: AWS::SSM::Parameter
Properties:
Type: String
Value: "{{ service.name }} {{ service_instance.name }} {{ service_instance.inputs.my_sample_service_instance_required_input }} {{ service_instance.inputs.my_sample_service_instance_optional_input }} {{ environment.outputs.MySampleInputValue }} {{ environment.outputs.MyOtherSampleInputValue }}"
# resource parameter references # input parameter references # output references to an environment infrastructure as code file
Outputs:
MyServiceInstanceParameter: # output definition
Value: !Ref StoreServiceInstanceInputValue
MyServiceInstanceRequiredInputValue: # output definition
Value: "{{ service_instance.inputs.my_sample_service_instance_required_input }}" # input parameter reference
MyServiceInstanceOptionalInputValue: # output definition
Value: "{{ service_instance.inputs.my_sample_service_instance_optional_input }}" # input parameter reference
MyServiceInstancesEnvironmentSampleOutputValue: # output definition
Value: "{{ environment.outputs.MySampleInputValue }}" # output reference to an environment IaC file
MyServiceInstancesEnvironmentOtherSampleOutputValue: # output definition
Value: "{{ environment.outputs.MyOtherSampleInputValue }}" # output reference to an environment IaC file
```
# Détails et exemples des paramètres du fichier CloudFormation iAC du composant
Vous pouvez définir et référencer les paramètres de votre infrastructure de composants sous forme de fichiers de code (IaC). Pour une description détaillée des AWS Proton paramètres, des types de paramètres, de l'espace de noms des paramètres et de la façon d'utiliser les paramètres dans vos fichiers iAc, consultez[AWS Proton paramètres](parameters.md). Pour plus d'informations sur les composants, consultez[AWS Proton composants](ag-components.md).
## Définir les paramètres de sortie des composants
Vous pouvez définir les paramètres de sortie dans les fichiers iAc de vos composants. Vous pouvez ensuite faire référence à ces sorties dans les fichiers IaC du service.
**Note**
Vous ne pouvez pas définir d'entrées pour les fichiers iAc des composants. Les composants attachés peuvent obtenir des entrées de l'instance de service à laquelle ils sont attachés. Les composants détachés n'ont pas d'entrées.
## Lire les valeurs des paramètres dans les fichiers iAc des composants
Vous pouvez lire les paramètres relatifs au composant et à d'autres ressources dans les fichiers iAc du composant. Vous pouvez lire la valeur d'un paramètre en faisant référence au nom du paramètre dans l'espace de noms des AWS Proton paramètres.
+ **Paramètres d'entrée** — Lisez la valeur d'entrée d'une instance de service attachée en la référençant`service_instance.inputs.input-name`.
+ **Paramètres des ressources** : lisez les paramètres AWS Proton des ressources en faisant référence à des noms tels que `component.name``service.name`,`service_instance.name`, et`environment.name`.
+ **Paramètres de sortie** — Lisez les sorties de l'environnement en les référençant`environment.outputs.output-name`.
## Exemples de fichiers IaC de composants et de services avec paramètres
L'exemple suivant montre un composant qui approvisionne un bucket Amazon Simple Storage Service (Amazon S3) et la politique d'accès associée, et qui expose les Amazon Resource ARNs Names () des deux ressources sous forme de sorties de composants. Un modèle de service IaC ajoute les sorties des composants en tant que variables d'environnement de conteneur d'une tâche Amazon Elastic Container Service (Amazon ECS) afin de rendre les sorties disponibles pour le code exécuté dans le conteneur, et ajoute la politique d'accès au bucket au rôle de la tâche. Le nom du compartiment est basé sur les noms de l'environnement, du service, de l'instance de service et du composant, ce qui signifie que le compartiment est couplé à une instance spécifique du modèle de composant étendant une instance de service spécifique. Les développeurs peuvent créer plusieurs composants personnalisés sur la base de ce modèle de composants, afin de fournir des compartiments Amazon S3 pour différentes instances de service et différents besoins fonctionnels.
L'exemple montre comment vous utilisez la `{{ ... }}` syntaxe Jinja pour faire référence aux paramètres des composants et autres ressources dans votre fichier IaC de service. Vous pouvez utiliser `{% if ... %}` des instructions pour ajouter des blocs d'instructions uniquement lorsqu'un composant est attaché à l'instance de service. Les `proton_cfn_*` mots clés sont des *filtres* que vous pouvez utiliser pour nettoyer et formater les valeurs des paramètres de sortie. Pour plus d'informations sur les filtres, consultez [Filtres de paramètres pour les fichiers CloudFormation IaC](parameter-filters.md).
En tant qu'administrateur, vous créez le fichier modèle du service iAC.
**Example fichier CloudFormation IaC de service utilisant un composant**
```
# service/instance_infrastructure/cloudformation.yaml
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
TaskRoleArn: !Ref TaskRole
ContainerDefinitions:
- Name: '{{service_instance.name}}'
# ...
{% if service_instance.components.default.outputs | length > 0 %}
Environment:
{{ service_instance.components.default.outputs |
proton_cfn_ecs_task_definition_formatted_env_vars }}
{% endif %}
# ...
TaskRole:
Type: AWS::IAM::Role
Properties:
# ...
ManagedPolicyArns:
- !Ref BaseTaskRoleManagedPolicy
{{ service_instance.components.default.outputs
| proton_cfn_iam_policy_arns }}
# Basic permissions for the task
BaseTaskRoleManagedPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
# ...
```
En tant que développeur, vous créez le fichier modèle du composant iAc.
**Example fichier CloudFormation iAC du composant**
```
# cloudformation.yaml
# A component that defines an S3 bucket and a policy for accessing the bucket.
Resources:
S3Bucket:
Type: AWS::S3::Bucket
Properties:
BucketName: '{{environment.name}}-{{service.name}}-{{service_instance.name}}-{{component.name}}'
S3BucketAccessPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- 's3:Get*'
- 's3:List*'
- 's3:PutObject'
Resource: !GetAtt S3Bucket.Arn
Outputs:
BucketName:
Description: "Bucket to access"
Value: !GetAtt S3Bucket.Arn
BucketAccessPolicyArn:
Value: !Ref S3BucketAccessPolicy
```
Lors du AWS Proton rendu d'un CloudFormation modèle pour votre instance de service et du remplacement de tous les paramètres par des valeurs réelles, le modèle peut ressembler au fichier suivant.
**Example fichier IaC CloudFormation rendu par une instance de service**
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
TaskRoleArn: !Ref TaskRole
ContainerDefinitions:
- Name: '{{service_instance.name}}'
# ...
Environment:
- Name: BucketName
Value: arn:aws:s3:us-east-1:123456789012:environment_name-service_name-service_instance_name-component_name
- Name: BucketAccessPolicyArn
Value: arn:aws:iam::123456789012:policy/cfn-generated-policy-name
# ...
TaskRole:
Type: AWS::IAM::Role
Properties:
# ...
ManagedPolicyArns:
- !Ref BaseTaskRoleManagedPolicy
- arn:aws:iam::123456789012:policy/cfn-generated-policy-name
# Basic permissions for the task
BaseTaskRoleManagedPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
# ...
```
# Filtres de paramètres pour les fichiers CloudFormation IaC
Lorsque vous faites référence à des [AWS Proton paramètres](parameters.md) dans vos fichiers AWS CloudFormation iAc, vous pouvez utiliser des modificateurs Jinja appelés *filtres* pour valider, filtrer et formater les valeurs des paramètres avant qu'elles ne soient insérées dans le modèle de rendu. [Les validations de filtres sont particulièrement utiles lorsqu'il s'agit de faire référence aux paramètres de sortie des composants, car la création et l'attachement des composants sont effectués par les développeurs, et un administrateur utilisant les sorties des composants dans un modèle d'instance de service peut souhaiter vérifier leur existence et leur validité.](ag-components.md) Cependant, vous pouvez utiliser des filtres dans n'importe quel fichier Jinja iAc.
Les sections suivantes décrivent et définissent les filtres de paramètres disponibles et fournissent des exemples. AWS Proton définit la plupart de ces filtres. Le `default` filtre est un filtre intégré à Jinja.
## Formater les propriétés de l'environnement pour les tâches Amazon ECS
**Déclaration**
```
dict → proton_cfn_ecs_task_definition_formatted_env_vars (raw: boolean = True) → YAML list of dicts
```
**Description**
Ce filtre met en forme une liste de sorties à utiliser dans une [propriété d'environnement](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-containerdefinitions.html#cfn-ecs-taskdefinition-containerdefinition-environment) dans la `ContainerDefinition` section d'une définition de tâche Amazon Elastic Container Service (Amazon ECS).
Définissez `raw` sur `False` pour valider également la valeur du paramètre. Dans ce cas, la valeur doit correspondre à l'expression régulière`^[a-zA-Z0-9_-]*$`. Si la valeur échoue à cette validation, le rendu du modèle échoue.
### Exemple
Avec le modèle de composant personnalisé suivant :
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
Et le modèle de service suivant :
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
{{ service_instance.components.default.outputs
| proton_cfn_ecs_task_definition_formatted_env_vars }}
```
Le modèle de service rendu est le suivant :
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
- Name: Output1
Value: hello
- Name: Output2
Value: world
```
## Propriétés de l'environnement de formatage pour les fonctions Lambda
**Déclaration**
```
dict → proton_cfn_lambda_function_formatted_env_vars (raw: boolean = True) → YAML dict
```
**Description**
Ce filtre met en forme une liste de sorties à utiliser dans une [propriété d'environnement](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-environment) dans la `Properties` section de définition d'une AWS Lambda fonction.
Définissez `raw` sur `False` pour valider également la valeur du paramètre. Dans ce cas, la valeur doit correspondre à l'expression régulière`^[a-zA-Z0-9_-]*$`. Si la valeur échoue à cette validation, le rendu du modèle échoue.
### Exemple
Avec le modèle de composant personnalisé suivant :
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
Et le modèle de service suivant :
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
{{ service_instance.components.default.outputs
| proton_cfn_lambda_function_formatted_env_vars }}
```
Le modèle de service rendu est le suivant :
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
Output1: hello
Output2: world
```
## Extraire la politique IAM ARNs à inclure dans les rôles IAM
**Déclaration**
```
dict → proton_cfn_iam_policy_arns → YAML list
```
**Description**
Ce filtre met en forme une liste de sorties à utiliser dans une [ManagedPolicyArns propriété](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-managepolicyarns) dans la `Properties` section de définition d'un rôle Gestion des identités et des accès AWS (IAM). Le filtre utilise l'expression régulière `^arn:[a-zA-Z-]+:iam::\d{12}:policy/` pour extraire la politique IAM valide ARNs de la liste des paramètres de sortie. Vous pouvez utiliser ce filtre pour ajouter des politiques dans les valeurs des paramètres de sortie à une définition de rôle IAM dans un modèle de service.
### Exemple
Avec le modèle de composant personnalisé suivant :
```
Resources:
# ...
ExamplePolicy1:
Type: AWS::IAM::ManagedPolicy
Properties:
# ...
ExamplePolicy2:
Type: AWS::IAM::ManagedPolicy
Properties:
# ...
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
PolicyArn1:
Description: "ARN of policy 1"
Value: !Ref ExamplePolicy1
PolicyArn2:
Description: "ARN of policy 2"
Value: !Ref ExamplePolicy2
```
Et le modèle de service suivant :
```
Resources:
# ...
TaskRole:
Type: AWS::IAM::Role
Properties:
# ...
ManagedPolicyArns:
- !Ref BaseTaskRoleManagedPolicy
{{ service_instance.components.default.outputs
| proton_cfn_iam_policy_arns }}
# Basic permissions for the task
BaseTaskRoleManagedPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
# ...
```
Le modèle de service rendu est le suivant :
```
Resources:
# ...
TaskRole:
Type: AWS::IAM::Role
Properties:
# ...
ManagedPolicyArns:
- !Ref BaseTaskRoleManagedPolicy
- arn:aws:iam::123456789012:policy/cfn-generated-policy-name-1
- arn:aws:iam::123456789012:policy/cfn-generated-policy-name-2
# Basic permissions for the task
BaseTaskRoleManagedPolicy:
Type: AWS::IAM::ManagedPolicy
Properties:
# ...
```
## Nettoyez les valeurs des propriétés
**Déclaration**
```
string → proton_cfn_sanitize → string
```
**Description**
Il s'agit d'un filtre à usage général. Utilisez-le pour valider la sécurité d'une valeur de paramètre. Le filtre vérifie que la valeur correspond à l'expression régulière `^[a-zA-Z0-9_-]*$` ou qu'il s'agit d'un Amazon Resource Name (ARN) valide. Si la valeur échoue à cette validation, le rendu du modèle échoue.
### Exemple
Avec le modèle de composant personnalisé suivant :
```
Resources:
# ...
Outputs:
Output1:
Description: "Example of valid output"
Value: "This-is_valid_37"
Output2:
Description: "Example incorrect output"
Value: "this::is::incorrect"
SomeArn:
Description: "Example ARN"
Value: arn:aws:some-service::123456789012:some-resource/resource-name
```
+ La référence suivante dans un modèle de service :
```
# ...
{{ service_instance.components.default.outputs.Output1
| proton_cfn_sanitize }}
```
S'affiche comme suit :
```
# ...
This-is_valid_37
```
+ La référence suivante dans un modèle de service :
```
# ...
{{ service_instance.components.default.outputs.Output2
| proton_cfn_sanitize }}
```
Résultats avec l'erreur de rendu suivante :
```
Illegal character(s) detected in "this::is::incorrect". Must match regex ^[a-zA-Z0-9_-]*$ or be a valid ARN
```
+ La référence suivante dans un modèle de service :
```
# ...
{{ service_instance.components.default.outputs.SomeArn
| proton_cfn_sanitize }}
```
S'affiche comme suit :
```
# ...
arn:aws:some-service::123456789012:some-resource/resource-name
```
## Fournir des valeurs par défaut pour les références inexistantes
**Description**
Le `default` filtre fournit une valeur par défaut lorsqu'il n'existe aucune référence à un espace de noms. Utilisez-le pour écrire des modèles robustes qui peuvent être rendus sans échec même lorsque le paramètre auquel vous faites référence est manquant.
### Exemple
La référence suivante dans un modèle de service entraîne l'échec du rendu du modèle si l'instance de service n'a pas de composant directement défini (par défaut) attaché, ou si le composant attaché n'a pas de sortie nommée`test`.
```
# ...
{{ service_instance.components.default.outputs.test }}
```
Pour éviter ce problème, ajoutez le `default` filtre.
```
# ...
{{ service_instance.components.default.outputs.test | default("[optional-value]") }}
```
# CodeBuild détails et exemples des paramètres de provisionnement
Vous pouvez définir des paramètres dans vos modèles pour les AWS Proton ressources CodeBuild basées et référencer ces paramètres dans votre code de provisionnement. Pour une description détaillée des AWS Proton paramètres, des types de paramètres, de l'espace de noms des paramètres et de la façon d'utiliser les paramètres dans vos fichiers iAc, consultez[AWS Proton paramètres](parameters.md).
**Note**
Vous pouvez utiliser le CodeBuild provisionnement avec des environnements et des services. Pour le moment, vous ne pouvez pas approvisionner les composants de cette façon.
## Paramètres d'entrée
Lorsque vous créez une AWS Proton ressource, comme un environnement ou un service, vous fournissez des valeurs pour les paramètres d'entrée qui sont définis dans le [fichier de schéma](ag-schema.md) de votre modèle. Lorsque la ressource que vous créez utilise[CodeBuild approvisionnement](ag-works-prov-methods.md#ag-works-prov-methods-codebuild), AWS Proton affiche ces valeurs d'entrée dans un fichier d'entrée. Votre code d'approvisionnement peut importer et obtenir des valeurs de paramètres à partir de ce fichier.
Pour un exemple de CodeBuild modèle, voir[CodeBuild ensemble de modèles de provisionnement](ag-infrastructure-tmp-files-codebuild.md). Pour plus d’informations sur les fichiers manifeste, consultez [Résumez les fichiers modèles pour AWS Proton](ag-wrap-up.md).
L'exemple suivant est un fichier d'entrée JSON généré lors du provisionnement CodeBuild basé sur une instance de service.
### Exemple : utilisation du AWS CDK with CodeBuild provisioning
```
{
"service_instance": {
"name": "my-service-staging",
"inputs": {
"port": "8080",
"task_size": "medium"
}
},
"service": {
"name": "my-service"
},
"environment": {
"account_id": "123456789012",
"name": "my-env-staging",
"outputs": {
"vpc-id": "hdh2323423"
}
}
}
```
## Paramètres de sortie
Pour renvoyer les résultats de mise à disposition des ressources AWS Proton, votre code de provisionnement peut générer un fichier JSON nommé `proton-outputs.json` avec les valeurs des paramètres de sortie définis dans le fichier de [schéma](ag-schema.md) de votre modèle. Par exemple, l'`--outputs-file`argument de la `cdk deploy` commande indique de générer un fichier JSON avec des sorties de provisionnement. AWS CDK Si votre ressource utilise le AWS CDK, spécifiez la commande suivante dans votre CodeBuild modèle de manifeste :
```
aws proton notify-resource-deployment-status-change
```
AWS Proton recherche ce fichier JSON. Si le fichier existe une fois que votre code d'approvisionnement a été correctement terminé, il AWS Proton lit les valeurs des paramètres de sortie à partir de celui-ci.
# Détails et exemples des paramètres du fichier d'infrastructure en tant que code (IaC) Terraform
Vous pouvez inclure des variables d'entrée Terraform dans les `variable.tf` fichiers de votre ensemble de modèles. Vous pouvez également créer un schéma pour créer des variables AWS Proton gérées. AWS Proton crée une variable `.tf files` à partir de votre fichier de schéma. Pour de plus amples informations, veuillez consulter [Fichiers Terraform iAC](ag-infrastructure-tmp-files-terraform.md).
Pour référencer les AWS Proton variables définies par votre schéma dans votre infrastructure`.tf files`, vous utilisez les AWS Proton espaces de noms indiqués dans la table *Paramètres et espaces de noms pour Terraform* iAC. Par exemple, vous pouvez utiliser `var.environment.inputs.vpc_cidr`. Entre guillemets, entourez ces variables de crochets simples et ajoutez un signe dollar devant la première accolade (par exemple,`“${var.environment.inputs.vpc_cidr}”`).
L'exemple suivant montre comment utiliser les espaces de noms pour inclure des AWS Proton paramètres dans un environnement. `.tf file`
```
terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 3.0"
}
}
// This tells terraform to store the state file in s3 at the location
// s3://terraform-state-bucket/tf-os-sample/terraform.tfstate
backend "s3" {
bucket = "terraform-state-bucket"
key = "tf-os-sample/terraform.tfstate"
region = "us-east-1"
}
}
// Configure the AWS Provider
provider "aws" {
region = "us-east-1"
default_tags {
tags = var.proton_tags
}
}
resource "aws_ssm_parameter" "my_ssm_parameter" {
name = "my_ssm_parameter"
type = "String"
// Use the Proton environment.inputs. namespace
value = var.environment.inputs.ssm_parameter_value
}
```