Pemberitahuan akhir dukungan: Pada 7 Oktober 2026, AWS akan mengakhiri dukungan untuk AWS Proton. Setelah 7 Oktober 2026, Anda tidak akan lagi dapat mengakses AWS Proton konsol atau AWS Proton sumber daya. Infrastruktur yang Anda gunakan akan tetap utuh. Untuk informasi selengkapnya, lihat Panduan [AWS Proton Pengakhiran Layanan dan Migrasi](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html).

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Rincian dan contoh parameter file CloudFormation IAC lingkungan
<a name="env-parameters"></a>

Anda dapat menentukan dan mereferensikan parameter di infrastruktur lingkungan Anda sebagai file kode (IAc). Untuk penjelasan rinci tentang AWS Proton parameter, jenis parameter, namespace parameter, dan cara menggunakan parameter dalam file IAC Anda, lihat. [AWS Proton parameter](parameters.md)

## Tentukan parameter lingkungan
<a name="env-parameters.define"></a>

Anda dapat menentukan parameter input dan output untuk file iAC lingkungan.
+ **Parameter input** - Tentukan parameter input lingkungan dalam [file skema](ag-schema.md) Anda.

  Daftar berikut mencakup contoh parameter input lingkungan untuk kasus penggunaan umum.
  + Nilai VPC CIDR
  + Pengaturan penyeimbang beban
  + Pengaturan basis data
  + Batas waktu pemeriksaan kesehatan

  Sebagai administrator, Anda dapat memberikan nilai untuk parameter masukan saat [membuat lingkungan](ag-create-env.md):
  + Gunakan konsol untuk mengisi formulir berbasis skema yang AWS Proton menyediakan.
  + Gunakan CLI untuk memberikan spesifikasi yang menyertakan nilai.
+ **Parameter keluaran** — Tentukan output lingkungan di file iAC lingkungan Anda. Anda kemudian dapat merujuk ke output ini dalam file IAC dari sumber daya lain.

## Baca nilai parameter dalam file iAc lingkungan
<a name="env-parameters.refer"></a>

Anda dapat membaca parameter yang terkait dengan lingkungan di lingkungan file IAC. Anda membaca nilai parameter dengan mereferensikan nama parameter di namespace AWS Proton parameter.
+ **Parameter masukan** — Baca nilai input lingkungan dengan referensi`environment.inputs.input-name`.
+ **Parameter sumber daya** — Baca parameter AWS Proton sumber daya dengan mereferensikan nama seperti`environment.name`.

**catatan**  
Tidak ada parameter output dari sumber daya lain yang tersedia untuk file iAC lingkungan.

## Contoh lingkungan dan layanan file IAc dengan parameter
<a name="env-parameters.example"></a>

Contoh berikut menunjukkan definisi parameter dan referensi dalam file iAc lingkungan. Contoh kemudian menunjukkan bagaimana parameter keluaran lingkungan yang didefinisikan dalam file iAc lingkungan dapat direferensikan dalam file iAc layanan.

**Example File CloudFormation iAc lingkungan**  
Perhatikan hal berikut dalam contoh ini:  
+ `environment.inputs.`Namespace mengacu pada parameter input lingkungan.
+ Parameter Amazon EC2 Systems Manager (SSM) `StoreInputValue` menggabungkan input lingkungan.
+ `MyEnvParameterValue`Output memperlihatkan rangkaian parameter input yang sama sebagai parameter output. Tiga parameter output tambahan juga mengekspos parameter input secara individual.
+ Enam parameter output tambahan mengekspos sumber daya yang disediakan lingkungan.

```
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 Layanan file CloudFormation iAc**  
`environment.outputs.`Namespace mengacu pada output lingkungan dari file iAc lingkungan. Misalnya, nama `environment.outputs.ClusterName` membaca nilai parameter keluaran `ClusterName` lingkungan.  

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