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.

# Detalles y ejemplos de los parámetros del archivo CloudFormation IaC de entorno
<a name="env-parameters"></a>

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
<a name="env-parameters.define"></a>

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
<a name="env-parameters.refer"></a>

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
<a name="env-parameters.example"></a>

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'
[...]
```