Aviso de fin del soporte: el 7 de octubre de 2026 AWS finalizará el soporte para AWS Proton. Después del 7 de octubre de 2026, ya no podrás acceder a la AWS Proton consola ni a AWS Proton los recursos. La infraestructura implementada permanecerá intacta. Para obtener más información, consulte la [Guía AWS Proton de obsolescencia y migración del servicio](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html).
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# AWS Proton parámetros
Puede definir y usar los parámetros de su infraestructura como archivos de código (IaC) para hacerlos flexibles y reutilizables. *Para leer el valor de un parámetro en los archivos IaC, consulte el nombre del parámetro en el espacio de nombres del parámetro. AWS Proton * AWS Proton inyecta valores de parámetros en los archivos IaC renderizados que genera durante el aprovisionamiento de recursos. [Para procesar los parámetros de AWS CloudFormation IaC, usa Jinja. AWS Proton](https://jinja.palletsprojects.com/en/2.11.x/) Para procesar los parámetros del IaC de Terraform, AWS Proton genera un archivo de valores de parámetros de Terraform y se basa en la capacidad de parametrización integrada en el HCL.
Con[CodeBuild aprovisionamiento](ag-works-prov-methods.md#ag-works-prov-methods-codebuild), AWS Proton genera un archivo de entrada que su código puede importar. El archivo es un archivo JSON o HCL, según una propiedad del manifiesto de la plantilla. Para obtener más información, consulte [CodeBuild detalles y ejemplos de los parámetros de aprovisionamiento](parameters-codebuild.md).
Puede hacer referencia a los parámetros de los archivos IaC de su entorno, servicio y componente o al código de aprovisionamiento si cumple los siguientes requisitos:
+ La longitud del nombre de cada parámetro no supera los 100 caracteres.
+ La longitud combinada del espacio de nombres del parámetro y del nombre del recurso no supera el límite de caracteres del nombre del recurso.
AWS Proton el aprovisionamiento falla si se superan estas cuotas.
## Tipos de parámetros
Los siguientes tipos de parámetros están disponibles como referencia en los archivos AWS Proton IaC:
**Parámetro de entrada**
Los entornos y las instancias de servicio pueden tomar los parámetros de entrada que usted defina en un [archivo de esquema](ag-schema.md) que asocie a la plantilla de entorno o servicio. Puede hacer referencia a los parámetros de entrada de un recurso en el archivo IaC del recurso. Los archivos IaC de los componentes pueden hacer referencia a los parámetros de entrada de la instancia de servicio a la que está conectado el componente.
AWS Proton compara los nombres de los parámetros de entrada con el archivo de esquema y los compara con los parámetros a los que se hace referencia en los archivos IaC para introducir los valores de entrada que se proporcionan en un archivo de especificaciones durante el aprovisionamiento de recursos.
**Parámetro de salida**
Puede definir las salidas en cualquiera de sus archivos IaC. Una salida puede ser, por ejemplo, el nombre, el ID o el ARN de uno de los recursos que proporciona la plantilla, o puede ser una forma de pasar por una de las entradas de la plantilla. Puede hacer referencia a estas salidas en los archivos de IaC de otros recursos.
En los archivos CloudFormation IaC, defina los parámetros de salida en el `Outputs:` bloque. En un archivo IaC de Terraform, defina cada parámetro de salida mediante una sentencia. `output`
**Parámetro de recurso**
AWS Proton crea automáticamente los parámetros AWS Proton de los recursos. Estos parámetros exponen las propiedades del objeto AWS Proton de recurso. Un ejemplo de parámetro de recurso es`environment.name`.
## Uso de AWS Proton parámetros en los archivos IaC
Para leer el valor de un parámetro en un archivo IaC, consulte el nombre del parámetro en el espacio de nombres del AWS Proton parámetro. En los archivos AWS CloudFormation IaC, se utiliza la sintaxis *Jinja* y se coloca el parámetro entre pares de llaves y comillas.
En la siguiente tabla se muestra la sintaxis de referencia para cada lenguaje de plantillas compatible, con un ejemplo.
| Lenguaje de plantillas | Sintaxis | Ejemplo: entrada de entorno denominada «VPC» |
| --- | --- | --- |
| CloudFormation | `"{{ parameter-name }}"` | `"{{ environment.inputs.VPC }}"` |
| Terraform | `var.parameter-name` | `var.environment.inputs.VPC` [Definiciones de variables de Terraform generadas](ag-infrastructure-tmp-files-terraform.md#compiled-tform) |
**nota**
Si utiliza [parámetros CloudFormation dinámicos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html) en su archivo IaC, debe [evitarlos para evitar errores de](https://jinja.palletsprojects.com/en/2.11.x/templates/#escaping) interpretación errónea de Jinja. Para obtener más información, consulte [Solución de problemas AWS Proton](ag-troubleshooting.md)
En la siguiente tabla se muestran los nombres de los espacios de nombres de todos los parámetros de los recursos. AWS Proton Cada tipo de archivo de plantilla puede utilizar un subconjunto diferente del espacio de nombres de parámetros.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/proton/latest/userguide/parameters.html)
Para obtener más información y ejemplos, consulte los subtemas sobre los parámetros de los archivos de plantilla de IaC para los distintos tipos de recursos y lenguajes de plantillas.
**Topics**
+ [Tipos de parámetros](#param-name-types)
+ [Uso de AWS Proton parámetros en los archivos IaC](#param-name-spaces)
+ [Detalles y ejemplos de los parámetros del archivo CloudFormation IaC de entorno](env-parameters.md)
+ [Detalles y ejemplos de los parámetros del archivo CloudFormation IAC del servicio](svc-parameters.md)
+ [Detalles y ejemplos de los parámetros del archivo CloudFormation IaC del componente](comp-parameters.md)
+ [Filtros de parámetros para archivos CloudFormation IaC](parameter-filters.md)
+ [CodeBuild detalles y ejemplos de los parámetros de aprovisionamiento](parameters-codebuild.md)
+ [Detalles y ejemplos de los parámetros del archivo de infraestructura como código (IaC) de Terraform](env-parameters-tform.md)
# Detalles y ejemplos de los parámetros del archivo CloudFormation IaC de entorno
Puede definir y hacer referencia a los parámetros de la infraestructura de su entorno como archivos de código (IaC). Para obtener una descripción detallada de AWS Proton los parámetros, los tipos de parámetros, el espacio de nombres de los parámetros y cómo utilizar los parámetros en los archivos de IaC, consulte. [AWS Proton parámetros](parameters.md)
## Defina los parámetros del entorno
Puede definir los parámetros de entrada y salida para los archivos IaC del entorno.
+ **Parámetros de entrada**: defina los parámetros de entrada del entorno en el [archivo de esquema](ag-schema.md).
La siguiente lista incluye ejemplos de parámetros de entrada del entorno para casos de uso típicos.
+ Valores CIDR de VPC
+ Configuración del balanceador de carga
+ Configuración de base de datos
+ Se ha agotado el tiempo de espera de un chequeo
Como administrador, puede proporcionar valores para los parámetros de entrada al [crear un entorno](ag-create-env.md):
+ Utilice la consola para rellenar un formulario basado en un esquema que AWS Proton proporciona.
+ Utilice la CLI para proporcionar una especificación que incluya los valores.
+ **Parámetros de salida**: defina las salidas del entorno en los archivos IaC de su entorno. A continuación, puede consultar estos resultados en los archivos IaC de otros recursos.
## Lea los valores de los parámetros en los archivos IaC del entorno
Puede leer los parámetros relacionados con el entorno en los archivos IaC del entorno. Para leer el valor de un parámetro, haga referencia al nombre del parámetro en el espacio de nombres del AWS Proton parámetro.
+ **Parámetros de entrada**: lee un valor de entrada del entorno haciendo referencia a él. `environment.inputs.input-name`
+ **Parámetros de recursos**: lea los parámetros de los AWS Proton recursos haciendo referencia a nombres como. `environment.name`
**nota**
No hay parámetros de salida de otros recursos disponibles para los archivos IaC del entorno.
## Ejemplos de archivos IaC de entorno y servicio con parámetros
El siguiente ejemplo muestra la definición y la referencia de los parámetros en un archivo IaC de un entorno. A continuación, el ejemplo muestra cómo se puede hacer referencia a los parámetros de salida del entorno definidos en el archivo IaC del entorno en un archivo IaC de servicio.
**Example Medio ambiente CloudFormation (archivo IaC)**
Tenga en cuenta lo siguiente en este ejemplo:
+ El espacio de `environment.inputs.` nombres hace referencia a los parámetros de entrada del entorno.
+ El parámetro Amazon EC2 Systems Manager (SSM) `StoreInputValue` concatena las entradas del entorno.
+ La `MyEnvParameterValue` salida expone la misma concatenación de parámetros de entrada que un parámetro de salida. Tres parámetros de salida adicionales también exponen los parámetros de entrada de forma individual.
+ Seis parámetros de salida adicionales exponen los recursos que proporciona el entorno.
```
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 Archivo CloudFormation IaC del servicio**
El espacio de nombres `environment.outputs.` se refiere a las salidas del entorno de un archivo de IaC del entorno. Por ejemplo, el nombre `environment.outputs.ClusterName` lee el valor del parámetro de salida del `ClusterName` entorno.
```
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'
[...]
```
# Detalles y ejemplos de los parámetros del archivo CloudFormation IAC del servicio
Puede definir y hacer referencia a los parámetros de su infraestructura de servicios y canalizaciones como archivos de código (IaC). Para obtener una descripción detallada de AWS Proton los parámetros, los tipos de parámetros, el espacio de nombres de los parámetros y cómo utilizar los parámetros en los archivos de IaC, consulte. [AWS Proton parámetros](parameters.md)
## Defina los parámetros de servicio
Puede definir los parámetros de entrada y salida para los archivos IaC del servicio.
+ **Parámetros de entrada**: defina los parámetros de entrada de la instancia de servicio en el [archivo de esquema](ag-schema.md).
La siguiente lista incluye ejemplos de parámetros de entrada del servicio para casos de uso típicos.
+ Puerto
+ Tamaño de tarea
+ Imagen
+ Recuento deseado
+ Archivo de Docker
+ Comando de prueba unitaria
Al [crear un servicio, se proporcionan valores para los parámetros de](ag-create-svc.md) entrada:
+ Utilice la consola para rellenar un formulario basado en un esquema que AWS Proton proporciona.
+ Utilice la CLI para proporcionar una especificación que incluya los valores.
+ **Parámetros de salida**: defina las salidas de las instancias de servicio en sus archivos IaC de servicio. A continuación, puede consultar estos resultados en los archivos IaC de otros recursos.
## Lea los valores de los parámetros en los archivos IaC del servicio
Puede leer los parámetros relacionados con el servicio y con otros recursos en los archivos IaC del servicio. Para leer el valor de un parámetro, haga referencia al nombre del parámetro en el espacio de nombres del AWS Proton parámetro.
+ **Parámetros de entrada**: lee el valor de entrada de una instancia de servicio haciendo referencia a él. `service_instance.inputs.input-name`
+ **Parámetros de recursos**: lea los parámetros de los AWS Proton recursos haciendo referencia a nombres como `service.name``service_instance.name`, y. `environment.name`
+ **Parámetros de salida**: lea las salidas de otros recursos haciendo referencia a `environment.outputs.output-name` o. `service_instance.components.default.outputs.output-name`
## Ejemplo de archivo IaC de servicio con parámetros
El siguiente ejemplo es un fragmento de un archivo IaC de un servicio CloudFormation . El espacio de `environment.outputs.` nombres hace referencia a las salidas del archivo IaC del entorno. El espacio de `service_instance.inputs.` nombres hace referencia a los parámetros de entrada de la instancia de servicio. La `service_instance.name` propiedad hace referencia a un parámetro de AWS Proton recurso.
```
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
```
# Detalles y ejemplos de los parámetros del archivo CloudFormation IaC del componente
Puede definir los parámetros de la infraestructura de componentes y hacer referencia a ellos como archivos de código (IaC). Para obtener una descripción detallada de AWS Proton los parámetros, los tipos de parámetros, el espacio de nombres de los parámetros y cómo utilizar los parámetros en los archivos de IaC, consulte. [AWS Proton parámetros](parameters.md) Para obtener más información sobre los componentes, consulte [AWS Proton componentes](ag-components.md).
## Definición de los parámetros de salida de los componentes
Puede definir los parámetros de salida en los archivos iAc de sus componentes. A continuación, puede hacer referencia a estas salidas en los archivos IaC de servicio.
**nota**
No puede definir las entradas para los archivos IaC de los componentes. Los componentes conectados pueden obtener entradas de la instancia de servicio a la que están conectados. Los componentes separados no tienen entradas.
## Lea los valores de los parámetros en los archivos IaC de los componentes
Puede leer los parámetros relacionados con el componente y con otros recursos en los archivos IaC del componente. Para leer el valor de un parámetro, haga referencia al nombre del parámetro en el espacio de nombres del AWS Proton parámetro.
+ **Parámetros de entrada**: lee el valor de entrada de una instancia de servicio adjunta haciendo referencia a él. `service_instance.inputs.input-name`
+ **Parámetros** de AWS Proton recursos: lea los parámetros de los recursos haciendo referencia a nombres como`component.name`, `service.name``service_instance.name`, y. `environment.name`
+ **Parámetros de salida**: lea los resultados del entorno haciendo referencia `environment.outputs.output-name` a ellos.
## Ejemplos de archivos IaC de componentes y servicios con parámetros
El siguiente ejemplo muestra un componente que aprovisiona un bucket de Amazon Simple Storage Service (Amazon S3) y una política de acceso relacionada, y expone los ARNs nombres de recursos de Amazon () de ambos recursos como salidas de componentes. Una plantilla de IaC de servicio añade las salidas de los componentes como variables de entorno de contenedor de una tarea de Amazon Elastic Container Service (Amazon ECS) para que las salidas estén disponibles para el código que se ejecute en el contenedor, y añade la política de acceso del bucket al rol de la tarea. El nombre del bucket se basa en los nombres del entorno, el servicio, la instancia de servicio y el componente, lo que significa que el bucket está asociado a una instancia específica de la plantilla del componente que amplía una instancia de servicio específica. Los desarrolladores pueden crear varios componentes personalizados en función de esta plantilla de componentes para aprovisionar buckets de Amazon S3 para distintas instancias de servicio y necesidades funcionales.
El ejemplo muestra cómo se utiliza la sintaxis `{{ ... }}` de Jinja para hacer referencia a los parámetros de los componentes y de otros recursos en el archivo de IaC del servicio. Puede utilizar instrucciones `{% if ... %}` para añadir bloques de instrucciones solo cuando un componente esté conectado a la instancia del servicio. Las palabras clave `proton_cfn_*` son *filtros* que se pueden utilizar para borrar y formatear los valores de los parámetros de salida. Para obtener más información acerca de los filtros, consulte [Filtros de parámetros para archivos CloudFormation IaC](parameter-filters.md).
Como administrador, usted crea el archivo de plantilla IaC del servicio.
**Example CloudFormation repare el archivo IaC mediante 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:
# ...
```
Como desarrollador, usted crea el archivo de plantilla IaC del componente.
**Example fichero CloudFormation IaC del componente**
```
# 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
```
Al AWS Proton renderizar una CloudFormation plantilla para la instancia de servicio y reemplazar todos los parámetros por valores reales, la plantilla podría tener un aspecto similar al siguiente archivo.
**Example la instancia de servicio CloudFormation renderizó un archivo 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:
# ...
```
# Filtros de parámetros para archivos CloudFormation IaC
Al hacer referencia a [AWS Proton los parámetros](parameters.md) de los archivos AWS CloudFormation IaC, puede utilizar los modificadores de Jinja, conocidos como *filtros*, para validar, filtrar y formatear los valores de los parámetros antes de insertarlos en la plantilla renderizada. Las validaciones de filtros son especialmente útiles cuando se hace referencia a los parámetros de salida de los [componentes](ag-components.md), ya que los desarrolladores se encargan de crear y conectar los componentes, y un administrador que utilice las salidas de los componentes en una plantilla de instancia de servicio podría querer comprobar su existencia y validez. Sin embargo, puede utilizar filtros en cualquier archivo IaC de Jinja.
En las siguientes secciones se describen y definen los filtros de parámetros disponibles y se proporcionan ejemplos. AWS Proton define la mayoría de estos filtros. El `default` filtro es un filtro integrado por Jinja.
## Propiedades del entorno de formato para las tareas de Amazon ECS
**Declaración**
```
dict → proton_cfn_ecs_task_definition_formatted_env_vars (raw: boolean = True) → YAML list of dicts
```
**Descripción**
Este filtro da formato a una lista de salidas que se van a utilizar en una [propiedad del entorno](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-containerdefinitions.html#cfn-ecs-taskdefinition-containerdefinition-environment) en la `ContainerDefinition` sección de una definición de tarea de Amazon Elastic Container Service (Amazon ECS).
`raw``False`Configúrelo para validar también el valor del parámetro. En este caso, el valor debe coincidir con la expresión regular`^[a-zA-Z0-9_-]*$`. Si el valor no pasa esta validación, se produce un error en la representación de la plantilla.
### Ejemplo
Con la siguiente plantilla de componentes personalizados:
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
Y la siguiente plantilla de servicio:
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
{{ service_instance.components.default.outputs
| proton_cfn_ecs_task_definition_formatted_env_vars }}
```
La plantilla de servicio renderizada es la siguiente:
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
- Name: Output1
Value: hello
- Name: Output2
Value: world
```
## Propiedades del entorno de formato para funciones Lambda
**Declaración**
```
dict → proton_cfn_lambda_function_formatted_env_vars (raw: boolean = True) → YAML dict
```
**Descripción**
Este filtro formatea una lista de salidas que se utilizarán en una [propiedad de entorno](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-environment) en la `Properties` sección de la definición de una AWS Lambda función.
`raw``False`Configúrelo en para validar también el valor del parámetro. En este caso, el valor debe coincidir con la expresión regular`^[a-zA-Z0-9_-]*$`. Si el valor no pasa esta validación, se produce un error en la representación de la plantilla.
### Ejemplo
Con la siguiente plantilla de componentes personalizados:
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
Y la siguiente plantilla de servicio:
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
{{ service_instance.components.default.outputs
| proton_cfn_lambda_function_formatted_env_vars }}
```
La plantilla de servicio renderizada es la siguiente:
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
Output1: hello
Output2: world
```
## Extraiga la política de IAM ARNs para incluirla en las funciones de IAM
**Declaración**
```
dict → proton_cfn_iam_policy_arns → YAML list
```
**Descripción**
Este filtro formatea una lista de resultados que se van a utilizar en una [ManagedPolicyArns propiedad](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-managepolicyarns) en la `Properties` sección de una definición de rol AWS Identity and Access Management (IAM). El filtro utiliza la expresión regular `^arn:[a-zA-Z-]+:iam::\d{12}:policy/` para extraer una política de IAM válida ARNs de la lista de parámetros de salida. Puede utilizar este filtro para añadir políticas en los valores de los parámetros de salida a una definición de rol de IAM en una plantilla de servicio.
### Ejemplo
Con la siguiente plantilla de componentes personalizados:
```
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
```
Y la siguiente plantilla de servicio:
```
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:
# ...
```
La plantilla de servicio renderizada es la siguiente:
```
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:
# ...
```
## Desinfecte los valores de las propiedades
**Declaración**
```
string → proton_cfn_sanitize → string
```
**Descripción**
Se trata de un filtro de uso general. Utilícelo para validar la seguridad del valor de un parámetro. El filtro valida que el valor coincide con la expresión regular `^[a-zA-Z0-9_-]*$` o que es un nombre de recurso de Amazon (ARN) válido. Si el valor no pasa esta validación, se produce un error en la representación de la plantilla.
### Ejemplo
Con la siguiente plantilla de componentes personalizados:
```
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 siguiente referencia en una plantilla de servicio:
```
# ...
{{ service_instance.components.default.outputs.Output1
| proton_cfn_sanitize }}
```
Se representa de la siguiente manera:
```
# ...
This-is_valid_37
```
+ La siguiente referencia en una plantilla de servicio:
```
# ...
{{ service_instance.components.default.outputs.Output2
| proton_cfn_sanitize }}
```
Resultados con el siguiente error de representación:
```
Illegal character(s) detected in "this::is::incorrect". Must match regex ^[a-zA-Z0-9_-]*$ or be a valid ARN
```
+ La siguiente referencia en una plantilla de servicio:
```
# ...
{{ service_instance.components.default.outputs.SomeArn
| proton_cfn_sanitize }}
```
Se representa de la siguiente manera:
```
# ...
arn:aws:some-service::123456789012:some-resource/resource-name
```
## Provisión de valores predeterminados para referencias inexistentes
**Descripción**
El `default` filtro proporciona un valor predeterminado cuando no existe una referencia a un espacio de nombres. Úselo para escribir plantillas sólidas que puedan renderizarse sin errores incluso cuando falte el parámetro al que hace referencia.
### Ejemplo
La siguiente referencia en una plantilla de servicio provoca un error en la representación de la plantilla si la instancia de servicio no tiene un componente adjunto definido directamente (predeterminado) o si el componente adjunto no tiene un nombre de salida`test`.
```
# ...
{{ service_instance.components.default.outputs.test }}
```
Para evitar este problema, agrega el `default` filtro.
```
# ...
{{ service_instance.components.default.outputs.test | default("[optional-value]") }}
```
# CodeBuild detalles y ejemplos de los parámetros de aprovisionamiento
Puede definir los parámetros en las plantillas para los AWS Proton recursos CodeBuild basados y hacer referencia a estos parámetros en el código de aprovisionamiento. Para obtener una descripción detallada de AWS Proton los parámetros, los tipos de parámetros, el espacio de nombres de los parámetros y cómo utilizar los parámetros en los archivos de IaC, consulte. [AWS Proton parámetros](parameters.md)
**nota**
Puede utilizar el CodeBuild aprovisionamiento con entornos y servicios. En este momento, no puede aprovisionar componentes de esta forma.
## Parámetros de entrada
Cuando crea un AWS Proton recurso, como un entorno o un servicio, proporciona valores para los parámetros de entrada que se definen en el [archivo de esquema](ag-schema.md) de la plantilla. Cuando el recurso que cree los utiliza[CodeBuild aprovisionamiento](ag-works-prov-methods.md#ag-works-prov-methods-codebuild), AWS Proton renderiza estos valores de entrada en un archivo de entrada. El código de aprovisionamiento puede importar y obtener valores de parámetros de este archivo.
Para ver un ejemplo de CodeBuild plantilla, consulte[CodeBuild paquete de plantillas de aprovisionamiento](ag-infrastructure-tmp-files-codebuild.md). Para obtener más información sobre los archivos de manifiesto, consulte [Resuelva los archivos de plantilla para AWS Proton](ag-wrap-up.md).
El siguiente ejemplo es un archivo de entrada JSON generado durante el aprovisionamiento CodeBuild basado de una instancia de servicio.
### Ejemplo: usar el AWS CDK con aprovisionamiento 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"
}
}
}
```
## Parámetros de salida
[Para volver a comunicar los resultados del aprovisionamiento de recursos AWS Proton, el código de aprovisionamiento puede generar un archivo JSON `proton-outputs.json` con el nombre de los valores de los parámetros de salida definidos en el archivo de esquema de la plantilla.](ag-schema.md) Por ejemplo, el `cdk deploy` comando tiene el `--outputs-file` argumento que le indica que genere un archivo JSON con AWS CDK los resultados del aprovisionamiento. Si tu recurso usa el AWS CDK, especifica el siguiente comando en el manifiesto de la CodeBuild plantilla:
```
aws proton notify-resource-deployment-status-change
```
AWS Proton busca este archivo JSON. Si el archivo existe después de que el código de aprovisionamiento se haya completado correctamente, AWS Proton lee los valores de los parámetros de salida del mismo.
# Detalles y ejemplos de los parámetros del archivo de infraestructura como código (IaC) de Terraform
Puede incluir variables de entrada de Terraform en `variable.tf` los archivos de su paquete de plantillas. También puedes crear un esquema para crear variables AWS Proton administradas. AWS Proton crea una variable `.tf files` a partir del archivo de esquema. Para obtener más información, consulte [Archivos iAC de Terraform](ag-infrastructure-tmp-files-terraform.md).
Para hacer referencia a AWS Proton las variables definidas por el esquema en su infraestructura`.tf files`, utilice los espacios de AWS Proton nombres que se muestran en la tabla *Parámetros y espacios de nombres de Terraform IaC*. Por ejemplo, puede utilizar `var.environment.inputs.vpc_cidr`. Entre comillas, ponga estas variables entre corchetes simples y añada un signo de dólar delante del primer corchete (por ejemplo,). `“${var.environment.inputs.vpc_cidr}”`
El siguiente ejemplo muestra cómo utilizar los espacios de nombres para incluir AWS Proton parámetros en un entorno. `.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
}
```