Avviso di fine del supporto: il 7 ottobre 2026, AWS terminerà il supporto per AWS Proton. Dopo il 7 ottobre 2026, non potrai più accedere alla AWS Proton console o AWS Proton alle risorse. L'infrastruttura implementata rimarrà intatta. Per ulteriori informazioni, consulta [AWS Proton Service Deprecation](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html) and Migration Guide.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AWS Proton parametri
È possibile definire e utilizzare i parametri nella propria infrastruttura come file di codice (IaC) per renderli flessibili e riutilizzabili. *Leggete il valore di un parametro nei vostri file IAc facendo riferimento al nome del parametro nello spazio dei nomi dei AWS Proton parametri.* AWS Proton inserisce i valori dei parametri nei file IAc renderizzati che genera durante l'approvvigionamento delle risorse. [Per elaborare i parametri AWS CloudFormation IAc, utilizza Jinja. AWS Proton](https://jinja.palletsprojects.com/en/2.11.x/) Per elaborare i parametri Terraform IAc, AWS Proton genera un file di valori dei parametri Terraform e si basa sulla capacità di parametrizzazione integrata in HCL.
Con[CodeBuild approvvigionamento](ag-works-prov-methods.md#ag-works-prov-methods-codebuild), AWS Proton genera un file di input che il codice può importare. Il file è un file JSON o HCL, a seconda di una proprietà nel manifesto del modello. Per ulteriori informazioni, consulta [CodeBuild dettagli ed esempi dei parametri di provisioning](parameters-codebuild.md).
È possibile fare riferimento ai parametri nei file IAc di ambiente, servizio e componente o al codice di provisioning con i seguenti requisiti:
+ La lunghezza di ogni nome di parametro non supera i 100 caratteri.
+ La lunghezza dello spazio dei nomi dei parametri e del nome della risorsa combinati non supera il limite di caratteri per il nome della risorsa.
AWS Proton il provisioning fallisce se queste quote vengono superate.
## Tipi di parametro
I seguenti tipi di parametri sono disponibili come riferimento nei AWS Proton file IAc:
**Parametro di input**
Gli ambienti e le istanze di servizio possono accettare parametri di input definiti in un [file di schema](ag-schema.md) associato all'ambiente o al modello di servizio. È possibile fare riferimento ai parametri di input di una risorsa nel file IAc della risorsa. I file IAc dei componenti possono fare riferimento ai parametri di input dell'istanza del servizio a cui è collegato il componente.
AWS Proton confronta i nomi dei parametri di input con il file di schema e li confronta con i parametri a cui si fa riferimento nei file IAc per inserire i valori di input forniti in un file di specifiche durante l'approvvigionamento delle risorse.
**Parametro di output**
È possibile definire gli output in qualsiasi file IAc. Un output può essere, ad esempio, un nome, un ID o un ARN di una delle risorse fornite dal modello oppure può essere un modo per passare attraverso uno degli input del modello. È possibile fare riferimento a questi output nei file IAc di altre risorse.
Nei file CloudFormation IAc, definite i parametri di output nel blocco. `Outputs:` In un file Terraform IAc, definisci ogni parametro di output utilizzando un'istruzione. `output`
**Parametro di risorsa**
AWS Proton crea automaticamente i parametri AWS Proton delle risorse. Questi parametri espongono le proprietà dell'oggetto AWS Proton risorsa. Un esempio di parametro di risorsa è`environment.name`.
## Utilizzo AWS Proton dei parametri nei file IAc
Per leggere il valore di un parametro in un file IAc, fate riferimento al nome del parametro nello spazio AWS Proton dei nomi dei parametri. Per i file AWS CloudFormation IAc, utilizzate la sintassi *Jinja* e racchiudete il parametro con coppie di parentesi graffe e virgolette.
La tabella seguente mostra la sintassi di riferimento per ogni linguaggio di template supportato, con un esempio.
| Linguaggio dei modelli | Sintassi | Esempio: input di ambiente denominato «VPC» |
| --- | --- | --- |
| CloudFormation | `"{{ parameter-name }}"` | `"{{ environment.inputs.VPC }}"` |
| Terraform | `var.parameter-name` | `var.environment.inputs.VPC` [Definizioni delle variabili Terraform generate](ag-infrastructure-tmp-files-terraform.md#compiled-tform) |
**Nota**
Se utilizzi [parametri CloudFormation dinamici](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html) nel tuo file IAc, devi [evitarli per evitare errori di interpretazione](https://jinja.palletsprojects.com/en/2.11.x/templates/#escaping) errata di Jinja. Per ulteriori informazioni, consulta [Risoluzione dei problemi AWS Proton](ag-troubleshooting.md)
La tabella seguente elenca i nomi dei namespace per tutti i parametri delle risorse. AWS Proton Ogni tipo di file modello può utilizzare un sottoinsieme diverso dello spazio dei nomi dei parametri.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/proton/latest/userguide/parameters.html)
Per ulteriori informazioni ed esempi, vedere i sottoargomenti relativi ai parametri nei file modello IAc per diversi tipi di risorse e linguaggi di modello.
**Topics**
+ [Tipi di parametro](#param-name-types)
+ [Utilizzo AWS Proton dei parametri nei file IAc](#param-name-spaces)
+ [Dettagli ed esempi dei parametri del file Environment CloudFormation IAc](env-parameters.md)
+ [Dettagli ed esempi dei parametri del file Service CloudFormation IAc](svc-parameters.md)
+ [Dettagli ed esempi dei parametri del file CloudFormation IAc del componente](comp-parameters.md)
+ [filtri parametrici per CloudFormation file IAc](parameter-filters.md)
+ [CodeBuild dettagli ed esempi dei parametri di provisioning](parameters-codebuild.md)
+ [Dettagli ed esempi dei parametri del file Terraform infrastructure as code (IaC)](env-parameters-tform.md)
# Dettagli ed esempi dei parametri del file Environment CloudFormation IAc
È possibile definire e fare riferimento ai parametri nell'infrastruttura ambientale come file di codice (IaC). Per una descrizione dettagliata dei AWS Proton parametri, dei tipi di parametri, dello spazio dei nomi dei parametri e di come utilizzare i parametri nei file IAc, vedere. [AWS Proton parametri](parameters.md)
## Definire i parametri dell'ambiente
È possibile definire i parametri di input e output per i file IAc di ambiente.
+ **Parametri di input**: definisci i parametri di input dell'ambiente nel tuo [file di schema](ag-schema.md).
L'elenco seguente include esempi di parametri di input ambientali per casi d'uso tipici.
+ Valori CIDR VPC
+ Impostazioni del bilanciamento del carico
+ Impostazioni del database
+ Un timeout per il controllo dello stato di salute
In qualità di amministratore, puoi fornire valori per i parametri di input quando [crei un ambiente](ag-create-env.md):
+ Utilizza la console per compilare un modulo basato su schemi che AWS Proton fornisce.
+ Utilizza la CLI per fornire una specifica che includa i valori.
+ **Parametri di output**: definisci gli output dell'ambiente nei file IAc del tuo ambiente. È quindi possibile fare riferimento a questi output nei file IAc di altre risorse.
## Leggi i valori dei parametri nei file IAc di ambiente
È possibile leggere i parametri relativi all'ambiente nei file IAc di ambiente. Si legge il valore di un parametro facendo riferimento al nome del parametro nello spazio dei nomi del AWS Proton parametro.
+ **Parametri di input**: legge un valore di input di ambiente facendo riferimento. `environment.inputs.input-name`
+ **Parametri delle** AWS Proton risorse: leggi i parametri delle risorse facendo riferimento a nomi come. `environment.name`
**Nota**
Nessun parametro di output di altre risorse è disponibile per i file IAc di ambiente.
## File IAc di ambiente e servizio di esempio con parametri
L'esempio seguente mostra la definizione e il riferimento dei parametri in un file IAc di ambiente. L'esempio mostra quindi come è possibile fare riferimento ai parametri di output dell'ambiente definiti nel file IAc di ambiente in un file IAc di servizio.
**Example File di ambiente IAc CloudFormation**
Nota quanto segue in questo esempio:
+ Lo spazio dei `environment.inputs.` nomi si riferisce ai parametri di input dell'ambiente.
+ Il parametro Amazon EC2 Systems Manager (SSM) `StoreInputValue` concatena gli input dell'ambiente.
+ L'`MyEnvParameterValue`output espone la stessa concatenazione di parametri di input di un parametro di output. Tre parametri di output aggiuntivi espongono inoltre i parametri di input singolarmente.
+ Sei parametri di output aggiuntivi espongono le risorse messe a disposizione dall'ambiente.
```
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 File CloudFormation IAc di servizio**
Il `environment.outputs.` namespace si riferisce agli output di ambiente di un file IAc di ambiente. Ad esempio, il nome `environment.outputs.ClusterName` legge il valore del parametro di output dell'ambiente. `ClusterName`
```
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'
[...]
```
# Dettagli ed esempi dei parametri del file Service CloudFormation IAc
È possibile definire e fare riferimento ai parametri nell'infrastruttura di servizio e di pipeline come file di codice (IaC). Per una descrizione dettagliata dei AWS Proton parametri, dei tipi di parametri, dello spazio dei nomi dei parametri e di come utilizzare i parametri nei file IAc, vedere. [AWS Proton parametri](parameters.md)
## Definire i parametri del servizio
È possibile definire i parametri di input e output per i file IAc di servizio.
+ **Parametri di input**: definisci i parametri di input dell'istanza di servizio nel [file di schema](ag-schema.md).
L'elenco seguente include esempi di parametri di input del servizio per casi d'uso tipici.
+ Porta
+ Dimensioni attività
+ Immagine
+ Conteggio desiderato
+ File Docker
+ Comando di test unitario
Fornisci valori per i parametri di input quando [crei un servizio](ag-create-svc.md):
+ Utilizza la console per compilare un modulo basato su schemi che AWS Proton fornisce.
+ Utilizza la CLI per fornire una specifica che includa i valori.
+ **Parametri di output**: definisci gli output delle istanze di servizio nei file IAc del servizio. È quindi possibile fare riferimento a questi output nei file IAc di altre risorse.
## Leggi i valori dei parametri nei file IAc di servizio
È possibile leggere i parametri relativi al servizio e ad altre risorse nei file IAc di servizio. È possibile leggere il valore di un parametro facendo riferimento al nome del parametro nello spazio dei nomi del AWS Proton parametro.
+ **Parametri di input**: legge il valore di input di un'istanza di servizio facendo riferimento. `service_instance.inputs.input-name`
+ **Parametri delle** AWS Proton risorse: legge i parametri delle risorse facendo riferimento a nomi come `service.name``service_instance.name`, e. `environment.name`
+ **Parametri di output**: leggi gli output di altre risorse facendo riferimento `environment.outputs.output-name` a o. `service_instance.components.default.outputs.output-name`
## Esempio di file IAc di servizio con parametri
L'esempio seguente è un frammento di un file IAc di servizio CloudFormation . Il `environment.outputs.` namespace si riferisce agli output del file IAc di ambiente. Lo spazio dei `service_instance.inputs.` nomi si riferisce ai parametri di input dell'istanza di servizio. La `service_instance.name` proprietà si riferisce a un parametro di AWS Proton risorsa.
```
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
```
# Dettagli ed esempi dei parametri del file CloudFormation IAc del componente
È possibile definire e fare riferimento ai parametri nell'infrastruttura dei componenti come file di codice (IaC). Per una descrizione dettagliata dei AWS Proton parametri, dei tipi di parametri, dello spazio dei nomi dei parametri e di come utilizzare i parametri nei file IAc, vedere. [AWS Proton parametri](parameters.md) Per ulteriori informazioni sui componenti, vedere. [AWS Proton componenti](ag-components.md)
## Definire i parametri di output dei componenti
È possibile definire i parametri di output nei file IAc dei componenti. È quindi possibile fare riferimento a queste uscite nei file IAc di servizio.
**Nota**
Non è possibile definire input per i file IAc dei componenti. I componenti collegati possono ricevere input dall'istanza di servizio a cui sono collegati. I componenti scollegati non dispongono di input.
## Leggi i valori dei parametri nei file IAc dei componenti
È possibile leggere i parametri relativi al componente e ad altre risorse nei file IAc dei componenti. È possibile leggere il valore di un parametro facendo riferimento al nome del parametro nello spazio dei nomi del AWS Proton parametro.
+ **Parametri di input**: legge il valore di input di un'istanza di servizio allegata mediante riferimento. `service_instance.inputs.input-name`
+ **Parametri** AWS Proton delle risorse: legge i parametri delle risorse facendo riferimento a nomi come`component.name`, `service.name``service_instance.name`, e. `environment.name`
+ **Parametri di output**: legge gli output dell'ambiente mediante riferimento. `environment.outputs.output-name`
## File IAc di esempio per componenti e servizi con parametri
L'esempio seguente mostra un componente che fornisce un bucket Amazon Simple Storage Service (Amazon S3) e la relativa policy di accesso ed espone gli Amazon Resource Names ARNs () di entrambe le risorse come output dei componenti. Un modello IAc di servizio aggiunge gli output dei componenti come variabili di ambiente del contenitore di un'attività Amazon Elastic Container Service (Amazon ECS) per rendere gli output disponibili per il codice in esecuzione nel contenitore e aggiunge la policy di accesso al bucket al ruolo dell'attività. Il nome del bucket si basa sui nomi dell'ambiente, del servizio, dell'istanza del servizio e del componente, il che significa che il bucket è associato a un'istanza specifica del modello di componente che estende un'istanza di servizio specifica. Gli sviluppatori possono creare più componenti personalizzati basati su questo modello di componenti, per fornire bucket Amazon S3 per diverse istanze di servizio ed esigenze funzionali.
L'esempio mostra come utilizzare la `{{ ... }}` sintassi Jinja per fare riferimento ai parametri dei componenti e ad altri parametri di risorse nel file IAc del servizio. È possibile utilizzare `{% if ... %}` le istruzioni per aggiungere blocchi di istruzioni solo quando un componente è collegato all'istanza del servizio. Le `proton_cfn_*` parole chiave sono *filtri* che è possibile utilizzare per disinfettare e formattare i valori dei parametri di output. Per ulteriori informazioni sui filtri, consultare [filtri parametrici per CloudFormation file IAc](parameter-filters.md).
In qualità di amministratore, sei l'autore del file modello IAc del servizio.
**Example file CloudFormation IAc di servizio che utilizza un componente**
```
# 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:
# ...
```
In qualità di sviluppatore, sei l'autore del file modello IAc del componente.
**Example file componente CloudFormation IAc**
```
# 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
```
Quando AWS Proton esegue il rendering di un CloudFormation modello per l'istanza del servizio e sostituisce tutti i parametri con valori effettivi, il modello potrebbe avere l'aspetto del file seguente.
**Example l'istanza di servizio ha CloudFormation reso il file IAc**
```
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:
# ...
```
# filtri parametrici per CloudFormation file IAc
Quando si fanno riferimenti ai [AWS Proton parametri](parameters.md) nei file AWS CloudFormation IAc, è possibile utilizzare i modificatori Jinja noti come *filtri* per convalidare, filtrare e formattare i valori dei parametri prima che vengano inseriti nel modello renderizzato. Le convalide dei filtri sono particolarmente utili quando si fa riferimento ai parametri di output dei [componenti](ag-components.md), poiché la creazione e il collegamento dei componenti vengono eseguiti dagli sviluppatori e un amministratore che utilizza gli output dei componenti in un modello di istanza di servizio potrebbe volerne verificare l'esistenza e la validità. Tuttavia, puoi utilizzare i filtri in qualsiasi file Jinja IAc.
Le sezioni seguenti descrivono e definiscono i filtri parametrici disponibili e forniscono esempi. AWS Proton definisce la maggior parte di questi filtri. Il `default` filtro è un filtro integrato Jinja.
## Proprietà dell'ambiente di formattazione per le attività di Amazon ECS
**Dichiarazione**
```
dict → proton_cfn_ecs_task_definition_formatted_env_vars (raw: boolean = True) → YAML list of dicts
```
**Descrizione**
Questo filtro formatta un elenco di output da utilizzare in una [proprietà Environment nella `ContainerDefinition` sezione di una definizione](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-containerdefinitions.html#cfn-ecs-taskdefinition-containerdefinition-environment) di attività Amazon Elastic Container Service (Amazon ECS) Elastic Container Service (Amazon ECS).
Imposta su `raw` per `False` convalidare anche il valore del parametro. In questo caso, è necessario che il valore corrisponda all'espressione `^[a-zA-Z0-9_-]*$` regolare. Se il valore non supera questa convalida, il rendering del modello fallisce.
### Esempio
Con il seguente modello di componente personalizzato:
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
E il seguente modello di servizio:
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
{{ service_instance.components.default.outputs
| proton_cfn_ecs_task_definition_formatted_env_vars }}
```
Il modello di servizio reso è il seguente:
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
- Name: Output1
Value: hello
- Name: Output2
Value: world
```
## Proprietà di ambiente di formattazione per le funzioni Lambda
**Dichiarazione**
```
dict → proton_cfn_lambda_function_formatted_env_vars (raw: boolean = True) → YAML dict
```
**Descrizione**
Questo filtro formatta un elenco di output da utilizzare in una [proprietà Environment](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-environment) nella `Properties` sezione di una definizione di AWS Lambda funzione.
Imposta su `raw` `False` per convalidare anche il valore del parametro. In questo caso, è necessario che il valore corrisponda all'espressione `^[a-zA-Z0-9_-]*$` regolare. Se il valore non supera questa convalida, il rendering del modello fallisce.
### Esempio
Con il seguente modello di componente personalizzato:
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
E il seguente modello di servizio:
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
{{ service_instance.components.default.outputs
| proton_cfn_lambda_function_formatted_env_vars }}
```
Il modello di servizio reso è il seguente:
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
Output1: hello
Output2: world
```
## Estrai la policy IAM ARNs da includere nei ruoli IAM
**Dichiarazione**
```
dict → proton_cfn_iam_policy_arns → YAML list
```
**Descrizione**
Questo filtro formatta un elenco di output da utilizzare in una [ManagedPolicyArns proprietà](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-managepolicyarns) nella `Properties` sezione di una definizione di ruolo AWS Identity and Access Management (IAM). Il filtro utilizza l'espressione regolare `^arn:[a-zA-Z-]+:iam::\d{12}:policy/` per estrarre una politica IAM valida ARNs dall'elenco dei parametri di output. È possibile utilizzare questo filtro per aggiungere le politiche nei valori dei parametri di output a una definizione di ruolo IAM in un modello di servizio.
### Esempio
Con il seguente modello di componente personalizzato:
```
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
```
E il seguente modello di servizio:
```
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:
# ...
```
Il modello di servizio reso è il seguente:
```
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:
# ...
```
## Disinfetta i valori delle proprietà
**Dichiarazione**
```
string → proton_cfn_sanitize → string
```
**Descrizione**
Si tratta di un filtro generico. Utilizzatelo per convalidare la sicurezza del valore di un parametro. Il filtro verifica che il valore corrisponda all'espressione regolare `^[a-zA-Z0-9_-]*$` o sia un Amazon Resource Name (ARN) valido. Se il valore non supera questa convalida, il rendering del modello non riesce.
### Esempio
Con il seguente modello di componente personalizzato:
```
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
```
+ Il seguente riferimento in un modello di servizio:
```
# ...
{{ service_instance.components.default.outputs.Output1
| proton_cfn_sanitize }}
```
Viene visualizzato come segue:
```
# ...
This-is_valid_37
```
+ Il seguente riferimento in un modello di servizio:
```
# ...
{{ service_instance.components.default.outputs.Output2
| proton_cfn_sanitize }}
```
Risultati con il seguente errore di rendering:
```
Illegal character(s) detected in "this::is::incorrect". Must match regex ^[a-zA-Z0-9_-]*$ or be a valid ARN
```
+ Il seguente riferimento in un modello di servizio:
```
# ...
{{ service_instance.components.default.outputs.SomeArn
| proton_cfn_sanitize }}
```
Viene visualizzato come segue:
```
# ...
arn:aws:some-service::123456789012:some-resource/resource-name
```
## Fornite valori predefiniti per riferimenti inesistenti
**Descrizione**
Il `default` filtro fornisce un valore predefinito quando non esiste un riferimento allo spazio dei nomi. Utilizzatelo per scrivere modelli robusti in grado di eseguire il rendering senza errori anche quando manca il parametro a cui fate riferimento.
### Esempio
Il riferimento seguente in un modello di servizio fa sì che il rendering del modello non riesca se all'istanza del servizio non è associato un componente definito direttamente (predefinito) o se il componente allegato non ha un output denominato`test`.
```
# ...
{{ service_instance.components.default.outputs.test }}
```
Per evitare questo problema, aggiungi il `default` filtro.
```
# ...
{{ service_instance.components.default.outputs.test | default("[optional-value]") }}
```
# CodeBuild dettagli ed esempi dei parametri di provisioning
È possibile definire i parametri nei modelli per AWS Proton le risorse CodeBuild basate e fare riferimento a tali parametri nel codice di provisioning. Per una descrizione dettagliata dei AWS Proton parametri, dei tipi di parametri, dello spazio dei nomi dei parametri e di come utilizzare i parametri nei file IAc, vedere. [AWS Proton parametri](parameters.md)
**Nota**
È possibile utilizzare il CodeBuild provisioning con ambienti e servizi. Al momento non è possibile effettuare il provisioning dei componenti in questo modo.
## Parametri di input
Quando crei una AWS Proton risorsa, come un ambiente o un servizio, fornisci valori per i parametri di input definiti nel [file di schema](ag-schema.md) del modello. Quando la risorsa che crei utilizza[CodeBuild approvvigionamento](ag-works-prov-methods.md#ag-works-prov-methods-codebuild), AWS Proton rende questi valori di input in un file di input. Il codice di provisioning può importare e ottenere valori dei parametri da questo file.
Per un esempio di CodeBuild modello, vedi[CodeBuild pacchetto di modelli di provisioning](ag-infrastructure-tmp-files-codebuild.md). Per ulteriori informazioni sui file manifest, consulta [Raccogli i file modello per AWS Proton](ag-wrap-up.md).
L'esempio seguente è un file di input JSON generato durante il provisioning CodeBuild basato su base di un'istanza di servizio.
### Esempio: utilizzo di with provisioning AWS CDK CodeBuild
```
{
"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"
}
}
}
```
## Parametri di output
[Per comunicare gli output del provisioning delle risorse a AWS Proton, il codice di provisioning può generare un file JSON denominato `proton-outputs.json` con i valori per i parametri di output definiti nel file di schema del modello.](ag-schema.md) Ad esempio, il `cdk deploy` comando ha l'`--outputs-file`argomento che indica di generare un file JSON AWS CDK con output di provisioning. Se la tua risorsa utilizza il AWS CDK, specifica il seguente comando nel manifesto del modello: CodeBuild
```
aws proton notify-resource-deployment-status-change
```
AWS Proton cerca questo file JSON. Se il file esiste dopo che il codice di provisioning è stato completato correttamente, ne AWS Proton legge i valori dei parametri di output.
# Dettagli ed esempi dei parametri del file Terraform infrastructure as code (IaC)
Puoi includere le variabili di input Terraform nei `variable.tf` file del tuo pacchetto di modelli. Puoi anche creare uno schema per creare variabili AWS Proton gestite. AWS Proton crea una variabile `.tf files` dal tuo file di schema. Per ulteriori informazioni, consulta [file Terraform iAC](ag-infrastructure-tmp-files-terraform.md).
Per fare riferimento alle AWS Proton variabili definite dallo schema nella vostra infrastruttura`.tf files`, utilizzate i AWS Proton namespace mostrati nella tabella *Parametri e namespace* per Terraform IAc. Per esempio, è possibile utilizzare `var.environment.inputs.vpc_cidr`. All'interno delle virgolette, racchiudi queste variabili tra parentesi singole e aggiungi il simbolo del dollaro davanti alla prima parentesi (ad esempio,). `“${var.environment.inputs.vpc_cidr}”`
L'esempio seguente mostra come utilizzare i namespace per includere parametri in un ambiente. AWS Proton `.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
}
```