Hinweis zum Ende des Supports: Am 7. Oktober 2026 AWS endet der Support für AWS Proton. Nach dem 7. Oktober 2026 können Sie nicht mehr auf die AWS Proton Konsole oder AWS Proton die Ressourcen zugreifen. Ihre bereitgestellte Infrastruktur bleibt intakt. Weitere Informationen finden Sie im [AWS Proton Service Deprecation and Migration Guide](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# AWS Proton Parameter
Sie können Parameter in Ihrer Infrastruktur als Codedateien (IaC) definieren und verwenden, um sie flexibel und wiederverwendbar zu machen. *Sie lesen einen Parameterwert in Ihren IaC-Dateien, indem Sie auf den Namen des Parameters im Parameter-Namespace verweisen. AWS Proton * AWS Proton fügt Parameterwerte in die gerenderten IaC-Dateien ein, die es bei der Ressourcenbereitstellung generiert. [Verwendet Jinja, um AWS CloudFormation IaC-Parameter zu verarbeiten. AWS Proton](https://jinja.palletsprojects.com/en/2.11.x/) AWS Proton Generiert zur Verarbeitung von Terraform-IaC-Parametern eine Terraform-Parameterwertdatei und stützt sich dabei auf die in HCL integrierte Parametrisierungsfunktion.
Mit AWS Proton generiert eine [CodeBuild Bereitstellung](ag-works-prov-methods.md#ag-works-prov-methods-codebuild) Eingabedatei, die Ihr Code importieren kann. Die Datei ist eine JSON- oder HCL-Datei, abhängig von einer Eigenschaft im Manifest Ihrer Vorlage. Weitere Informationen finden Sie unter [CodeBuild Details und Beispiele für Bereitstellungsparameter](parameters-codebuild.md).
Sie können auf Parameter in Ihren Umgebungs-, Service- und Komponenten-IaC-Dateien oder im Bereitstellungscode mit den folgenden Anforderungen verweisen:
+ Die Länge der einzelnen Parameternamen darf 100 Zeichen nicht überschreiten.
+ Die Länge des Parameter-Namespaces und des Ressourcennamens zusammen überschreitet nicht die Zeichenbeschränkung für den Ressourcennamen.
AWS Proton Die Bereitstellung schlägt fehl, wenn diese Kontingente überschritten werden.
## Parametertypen
Die folgenden Parametertypen stehen Ihnen als Referenz in AWS Proton IaC-Dateien zur Verfügung:
**Eingabeparameter**
Umgebungen und Dienstinstanzen können Eingabeparameter verwenden, die Sie in einer [Schemadatei](ag-schema.md) definieren, die Sie der Umgebung oder Dienstvorlage zuordnen. Sie können auf die Eingabeparameter einer Ressource in der IaC-Datei der Ressource verweisen. Komponenten-IaC-Dateien können sich auf Eingabeparameter der Dienstinstanz beziehen, an die die Komponente angehängt ist.
AWS Proton überprüft die Namen der Eingabeparameter anhand Ihrer Schemadatei und ordnet sie den Parametern zu, auf die in Ihren IaC-Dateien verwiesen wird, um die Eingabewerte einzufügen, die Sie bei der Ressourcenbereitstellung in eine Spezifikationsdatei eingeben.
**Ausgabeparameter**
Sie können Ausgaben in jeder Ihrer IaC-Dateien definieren. Eine Ausgabe kann beispielsweise ein Name, eine ID oder ein ARN einer der Ressourcen sein, die die Vorlage bereitstellt, oder sie kann eine Möglichkeit sein, eine der Eingaben der Vorlage zu übergeben. Sie können in IaC-Dateien anderer Ressourcen auf diese Ausgaben verweisen.
Definieren Sie in CloudFormation IaC-Dateien die Ausgabeparameter im `Outputs:` Block. Definieren Sie in einer Terraform-IaC-Datei jeden Ausgabeparameter mit einer Anweisung. `output`
**Ressourcenparameter**
AWS Proton erstellt automatisch AWS Proton Ressourcenparameter. Diese Parameter machen die Eigenschaften des AWS Proton Ressourcenobjekts verfügbar. Ein Beispiel für einen Ressourcenparameter ist`environment.name`.
## Verwenden von AWS Proton Parametern in Ihren IaC-Dateien
Um einen Parameterwert in einer IaC-Datei zu lesen, verweisen Sie auf den Namen des Parameters im AWS Proton Parameter-Namespace. Für AWS CloudFormation IaC-Dateien verwenden Sie die *Jinja-Syntax* und umgeben den Parameter mit Paaren aus geschweiften Klammern und Anführungszeichen.
Die folgende Tabelle zeigt die Referenzsyntax für jede unterstützte Vorlagensprache mit einem Beispiel.
| Sprache der Vorlage | Syntax | Beispiel: Umgebungseingabe mit dem Namen „VPC“ |
| --- | --- | --- |
| CloudFormation | `"{{ parameter-name }}"` | `"{{ environment.inputs.VPC }}"` |
| Terraform | `var.parameter-name` | `var.environment.inputs.VPC` [Generierte Terraform-Variablendefinitionen](ag-infrastructure-tmp-files-terraform.md#compiled-tform) |
**Anmerkung**
Wenn Sie [CloudFormation dynamische Parameter](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html) in Ihrer IaC-Datei verwenden, müssen Sie [sie maskieren, um Fehlinterpretationsfehler](https://jinja.palletsprojects.com/en/2.11.x/templates/#escaping) durch Jinja zu vermeiden. Weitere Informationen finden Sie unter [Problembehebung AWS Proton](ag-troubleshooting.md).
In der folgenden Tabelle sind die Namespace-Namen für alle Ressourcenparameter aufgeführt. AWS Proton Jeder Vorlagendateityp kann eine andere Teilmenge des Parameter-Namespaces verwenden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/proton/latest/userguide/parameters.html)
Weitere Informationen und Beispiele finden Sie in den Unterthemen zu Parametern in IaC-Vorlagendateien für verschiedene Ressourcentypen und Vorlagensprachen.
**Topics**
+ [Parametertypen](#param-name-types)
+ [Verwenden von AWS Proton Parametern in Ihren IaC-Dateien](#param-name-spaces)
+ [Details und Beispiele zu den Parametern der CloudFormation IaC-Datei in der Umgebung](env-parameters.md)
+ [Details und Beispiele zu den Parametern der CloudFormation Service-IaC-Datei](svc-parameters.md)
+ [Parameterdetails und Beispiele für die CloudFormation IaC-Komponentendatei](comp-parameters.md)
+ [Parameterfilter für CloudFormation IaC-Dateien](parameter-filters.md)
+ [CodeBuild Details und Beispiele für Bereitstellungsparameter](parameters-codebuild.md)
+ [Details und Beispiele für die Terraform-Infrastruktur-as-Code-Datei (IaC)](env-parameters-tform.md)
# Details und Beispiele zu den Parametern der CloudFormation IaC-Datei in der Umgebung
Sie können Parameter in Ihrer Umgebungsinfrastruktur als Codedateien (IaC) definieren und referenzieren. Eine ausführliche Beschreibung der AWS Proton Parameter, Parametertypen, des Parameter-Namespace und der Verwendung von Parametern in Ihren IaC-Dateien finden Sie unter. [AWS Proton Parameter](parameters.md)
## Definieren Sie Umgebungsparameter
Sie können sowohl Eingabe- als auch Ausgabeparameter für IaC-Umgebungsdateien definieren.
+ **Eingabeparameter** — Definieren Sie Eingabeparameter für die Umgebung in Ihrer [Schemadatei](ag-schema.md).
Die folgende Liste enthält Beispiele für Umgebungseingabeparameter für typische Anwendungsfälle.
+ VPC CIDR-Werte
+ Load Balancer-Einstellungen
+ Datenbank-Einstellungen
+ Ein Timeout bei der Integritätsprüfung
Als Administrator können Sie Werte für Eingabeparameter angeben, wenn Sie [eine Umgebung erstellen](ag-create-env.md):
+ Verwenden Sie die Konsole, um ein schemabasiertes Formular auszufüllen, das AWS Proton Folgendes bietet:
+ Verwenden Sie die CLI, um eine Spezifikation bereitzustellen, die die Werte enthält.
+ **Ausgabeparameter** — Definieren Sie die Umgebungsausgaben in den IaC-Dateien Ihrer Umgebung. Sie können dann in IaC-Dateien anderer Ressourcen auf diese Ausgaben verweisen.
## Lesen Sie Parameterwerte in IaC-Umgebungsdateien
Sie können Parameter, die sich auf die Umgebung beziehen, in IaC-Umgebungsdateien lesen. Sie lesen einen Parameterwert, indem Sie im Parameter-Namespace auf den Namen des AWS Proton Parameters verweisen.
+ **Eingabeparameter** — Lesen Sie einen Umgebungseingabewert, indem Sie ihn referenzieren. `environment.inputs.input-name`
+ **Ressourcenparameter** — Lesen Sie AWS Proton Ressourcenparameter, indem Sie auf Namen wie verweisen. `environment.name`
**Anmerkung**
Für IaC-Umgebungsdateien sind keine Ausgabeparameter anderer Ressourcen verfügbar.
## IaC-Beispieldateien für Umgebungen und Dienste mit Parametern
Das folgende Beispiel zeigt die Parameterdefinition und Referenz in einer IaC-Umgebungsdatei. Das Beispiel zeigt dann, wie in der IaC-Umgebungsdatei definierte Umgebungsausgabeparameter in einer Service-IaC-Datei referenziert werden können.
**Example IaC-Datei für die Umgebung CloudFormation**
Beachten Sie in diesem Beispiel Folgendes:
+ Der `environment.inputs.` Namespace bezieht sich auf Eingabeparameter der Umgebung.
+ Der Amazon EC2 Systems Manager (SSM) -Parameter `StoreInputValue` verkettet die Umgebungseingaben.
+ Die `MyEnvParameterValue` Ausgabe stellt dieselbe Verkettung von Eingabeparametern wie ein Ausgabeparameter bereit. Drei zusätzliche Ausgabeparameter machen die Eingabeparameter ebenfalls einzeln verfügbar.
+ Sechs zusätzliche Ausgabeparameter machen Ressourcen verfügbar, die die Umwelt bereitstellt.
```
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 CloudFormation IaC-Datei für den Dienst**
Der `environment.outputs.` Namespace bezieht sich auf Umgebungsausgaben aus einer IaC-Umgebungsdatei. Beispielsweise `environment.outputs.ClusterName` liest der Name den Wert des `ClusterName` Umgebungsausgabeparameters.
```
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'
[...]
```
# Details und Beispiele zu den Parametern der CloudFormation Service-IaC-Datei
Sie können Parameter in Ihrer Service- und Pipeline-Infrastruktur als Codedateien (IaC) definieren und referenzieren. Eine ausführliche Beschreibung der AWS Proton Parameter, Parametertypen, des Parameter-Namespace und der Verwendung von Parametern in Ihren IaC-Dateien finden Sie unter. [AWS Proton Parameter](parameters.md)
## Definieren Sie Serviceparameter
Sie können sowohl Eingabe- als auch Ausgabeparameter für Service-IaC-Dateien definieren.
+ **Eingabeparameter** — Definieren Sie Eingabeparameter für die Dienstinstanz in Ihrer [Schemadatei](ag-schema.md).
Die folgende Liste enthält Beispiele für Service-Eingabeparameter für typische Anwendungsfälle.
+ Port
+ Aufgabengröße
+ Image
+ Gewünschte Anzahl
+ Docker-Datei
+ Befehl zum Komponententest
Sie geben Werte für Eingabeparameter an, wenn Sie [einen Dienst erstellen](ag-create-svc.md):
+ Verwenden Sie die Konsole, um ein schemabasiertes Formular auszufüllen, das AWS Proton Folgendes bietet:
+ Verwenden Sie die CLI, um eine Spezifikation bereitzustellen, die die Werte enthält.
+ **Ausgabeparameter** — Definieren Sie die Ausgaben der Serviceinstanz in Ihren Service-IaC-Dateien. Sie können dann in IaC-Dateien anderer Ressourcen auf diese Ausgaben verweisen.
## Lesen Sie Parameterwerte in Service-IaC-Dateien
Sie können Parameter lesen, die sich auf den Dienst und andere Ressourcen beziehen, in Service-IaC-Dateien. Sie lesen einen Parameterwert, indem Sie im Parameter-Namespace auf den Namen des AWS Proton Parameters verweisen.
+ **Eingabeparameter** — Lesen Sie den Eingabewert einer Dienstinstanz durch Verweisen. `service_instance.inputs.input-name`
+ **Ressourcenparameter** — Lesen Sie AWS Proton Ressourcenparameter, indem Sie auf Namen wie `service.name``service_instance.name`, und verweisen. `environment.name`
+ **Ausgabeparameter** — Lesen Sie Ausgaben anderer Ressourcen, indem Sie auf oder verweisen`environment.outputs.output-name`. `service_instance.components.default.outputs.output-name`
## Beispiel für eine Service-IaC-Datei mit Parametern
Das folgende Beispiel ist ein Ausschnitt aus einer CloudFormation Service-IaC-Datei. Der `environment.outputs.` Namespace bezieht sich auf Ausgaben aus der IaC-Umgebungsdatei. Der `service_instance.inputs.` Namespace bezieht sich auf Eingabeparameter der Dienstinstanz. Die `service_instance.name` Eigenschaft bezieht sich auf einen AWS Proton Ressourcenparameter.
```
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
```
# Parameterdetails und Beispiele für die CloudFormation IaC-Komponentendatei
Sie können Parameter in Ihrer Komponenteninfrastruktur als Codedateien (IaC) definieren und referenzieren. Eine ausführliche Beschreibung der AWS Proton Parameter, Parametertypen, des Parameter-Namespace und der Verwendung von Parametern in Ihren IaC-Dateien finden Sie unter. [AWS Proton Parameter](parameters.md) Weitere Informationen zu Komponenten finden Sie unter. [AWS Proton Komponenten](ag-components.md)
## Definieren Sie Ausgabeparameter für Komponenten
Sie können Ausgabeparameter in Ihren IaC-Komponentendateien definieren. Sie können dann in Service-IaC-Dateien auf diese Ausgaben verweisen.
**Anmerkung**
Sie können keine Eingaben für Komponenten-IaC-Dateien definieren. Angehängte Komponenten können Eingaben von der Dienstinstanz erhalten, an die sie angehängt sind. Getrennte Komponenten haben keine Eingaben.
## Lesen Sie Parameterwerte in IaC-Dateien von Komponenten
Sie können Parameter lesen, die sich auf die Komponente und andere Ressourcen beziehen, in Komponenten-IaC-Dateien. Sie lesen einen Parameterwert, indem Sie im Parameter-Namespace auf den Namen des AWS Proton Parameters verweisen.
+ **Eingabeparameter** — Lesen Sie den Eingabewert einer angehängten Dienstinstanz durch Referenzierung. `service_instance.inputs.input-name`
+ **Ressourcenparameter** — Lesen Sie AWS Proton Ressourcenparameter, indem Sie auf Namen wie`component.name`, `service.name``service_instance.name`, und verweisen. `environment.name`
+ **Ausgabeparameter** — Lesen Sie die Umgebungsausgaben durch `environment.outputs.output-name` Referenzierung.
## IaC-Beispieldateien für Komponenten und Dienste mit Parametern
Das folgende Beispiel zeigt eine Komponente, die einen Amazon Simple Storage Service (Amazon S3) -Bucket und zugehörige Zugriffsrichtlinien bereitstellt und die Amazon-Ressourcennamen (ARNs) beider Ressourcen als Komponentenausgaben verfügbar macht. Eine Service-IaC-Vorlage fügt die Komponentenausgaben als Container-Umgebungsvariablen einer Amazon Elastic Container Service (Amazon ECS) -Aufgabe hinzu, um die Ausgaben für Code verfügbar zu machen, der im Container ausgeführt wird, und fügt der Rolle der Aufgabe die Bucket-Zugriffsrichtlinie hinzu. Der Bucket-Name basiert auf den Namen der Umgebung, des Dienstes, der Service-Instance und der Komponente, was bedeutet, dass der Bucket mit einer bestimmten Instance der Komponentenvorlage verknüpft ist, die eine bestimmte Service-Instance erweitert. Entwickler können auf der Grundlage dieser Komponentenvorlage mehrere benutzerdefinierte Komponenten erstellen, um Amazon S3 S3-Buckets für verschiedene Service-Instances und funktionale Anforderungen bereitzustellen.
Das Beispiel zeigt, wie Sie die `{{ ... }}` Jinja-Syntax verwenden, um auf Komponenten- und andere Ressourcenparameter in Ihrer Service-IaC-Datei zu verweisen. Sie können `{% if ... %}` Anweisungen nur dann verwenden, um Anweisungsblöcke hinzuzufügen, wenn eine Komponente an die Dienstinstanz angehängt ist. Bei den `proton_cfn_*` Schlüsselwörtern handelt es sich um *Filter*, mit denen Sie die Werte der Ausgabeparameter bereinigen und formatieren können. Weitere Informationen zu Filtern finden Sie unter [Parameterfilter für CloudFormation IaC-Dateien](parameter-filters.md).
Als Administrator erstellen Sie die IaC-Vorlagendatei für den Dienst.
**Example CloudFormation Service-IaC-Datei mithilfe einer Komponente**
```
# 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:
# ...
```
Als Entwickler erstellen Sie die IaC-Vorlagendatei für Komponenten.
**Example CloudFormation Komponenten-IaC-Datei**
```
# 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
```
Wenn eine CloudFormation Vorlage für Ihre Dienstinstanz AWS Proton gerendert und alle Parameter durch tatsächliche Werte ersetzt werden, sieht die Vorlage möglicherweise wie die folgende Datei aus.
**Example Die Dienstinstanz hat eine CloudFormation IAC-Datei gerendert**
```
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:
# ...
```
# Parameterfilter für CloudFormation IaC-Dateien
Wenn Sie in Ihren AWS CloudFormation IaC-Dateien auf [AWS Proton Parameter](parameters.md) verweisen, können Sie Jinja-Modifikatoren, sogenannte *Filter*, verwenden, um Parameterwerte zu überprüfen, zu filtern und zu formatieren, bevor sie in die gerenderte Vorlage eingefügt werden. Filtervalidierungen sind besonders nützlich, wenn auf Ausgabeparameter von [Komponenten](ag-components.md) verwiesen wird, da die Erstellung und das Anhängen von Komponenten von Entwicklern vorgenommen werden und ein Administrator, der Komponentenausgaben in einer Service-Instanzvorlage verwendet, möglicherweise deren Existenz und Gültigkeit überprüfen möchte. Sie können jedoch Filter in jeder Jinja-IaC-Datei verwenden.
In den folgenden Abschnitten werden die verfügbaren Parameterfilter beschrieben und definiert und es werden Beispiele bereitgestellt. AWS Proton definiert die meisten dieser Filter. Der `default` Filter ist ein eingebauter Jinja-Filter.
## Umgebungseigenschaften für Amazon ECS-Aufgaben formatieren
**Deklaration**
```
dict → proton_cfn_ecs_task_definition_formatted_env_vars (raw: boolean = True) → YAML list of dicts
```
**Beschreibung**
Dieser Filter formatiert eine Liste von Ausgaben, die in einer [Environment-Eigenschaft](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-containerdefinitions.html#cfn-ecs-taskdefinition-containerdefinition-environment) im `ContainerDefinition` Abschnitt einer Amazon Elastic Container Service (Amazon ECS) -Aufgabendefinition verwendet werden sollen.
Wird `raw` auf gesetzt`False`, um auch den Parameterwert zu überprüfen. In diesem Fall muss der Wert mit dem regulären Ausdruck übereinstimmen`^[a-zA-Z0-9_-]*$`. Wenn der Wert diese Überprüfung nicht besteht, schlägt das Rendern der Vorlage fehl.
### Beispiel
Mit der folgenden benutzerdefinierten Komponentenvorlage:
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
Und die folgende Servicevorlage:
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
{{ service_instance.components.default.outputs
| proton_cfn_ecs_task_definition_formatted_env_vars }}
```
Die Vorlage für den gerenderten Dienst sieht wie folgt aus:
```
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
# ...
ContainerDefinitions:
- Name: MyServiceName
# ...
Environment:
- Name: Output1
Value: hello
- Name: Output2
Value: world
```
## Formatieren Sie Umgebungseigenschaften für Lambda-Funktionen
**Deklaration**
```
dict → proton_cfn_lambda_function_formatted_env_vars (raw: boolean = True) → YAML dict
```
**Beschreibung**
Dieser Filter formatiert eine Liste von Ausgaben, die in einer [Environment-Eigenschaft](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-environment) im `Properties` Abschnitt einer AWS Lambda Funktionsdefinition verwendet werden sollen.
Wird `raw` auf gesetzt`False`, um auch den Parameterwert zu überprüfen. In diesem Fall muss der Wert mit dem regulären Ausdruck übereinstimmen`^[a-zA-Z0-9_-]*$`. Wenn der Wert diese Überprüfung nicht besteht, schlägt das Rendern der Vorlage fehl.
### Beispiel
Mit der folgenden benutzerdefinierten Komponentenvorlage:
```
Resources:
# ...
Outputs:
Output1:
Description: "Example component output 1"
Value: hello
Output2:
Description: "Example component output 2"
Value: world
```
Und die folgende Servicevorlage:
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
{{ service_instance.components.default.outputs
| proton_cfn_lambda_function_formatted_env_vars }}
```
Die Vorlage für den gerenderten Dienst sieht wie folgt aus:
```
Resources:
Lambda:
Type: AWS::Lambda::Function
Properties:
Environment:
Variables:
Output1: hello
Output2: world
```
## Extrahieren Sie die IAM-Richtlinie ARNs , um sie in IAM-Rollen aufzunehmen
**Erklärung**
```
dict → proton_cfn_iam_policy_arns → YAML list
```
**Beschreibung**
Dieser Filter formatiert eine Liste von Ausgaben, die in einer [ManagedPolicyArns Eigenschaft](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-managepolicyarns) im `Properties` Abschnitt einer AWS Identity and Access Management (IAM-) Rollendefinition verwendet werden sollen. Der Filter verwendet den regulären Ausdruck`^arn:[a-zA-Z-]+:iam::\d{12}:policy/`, um eine gültige IAM-Richtlinie ARNs aus der Liste der Ausgabeparameter zu extrahieren. Sie können diesen Filter verwenden, um Richtlinien in Ausgabeparameterwerten an eine IAM-Rollendefinition in einer Dienstvorlage anzuhängen.
### Beispiel
Mit der folgenden benutzerdefinierten Komponentenvorlage:
```
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
```
Und die folgende Servicevorlage:
```
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:
# ...
```
Die Vorlage für den gerenderten Dienst sieht wie folgt aus:
```
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:
# ...
```
## Desinfizieren Sie die Immobilienwerte
**Erklärung**
```
string → proton_cfn_sanitize → string
```
**Beschreibung**
Dies ist ein Allzweckfilter. Verwenden Sie ihn, um die Sicherheit eines Parameterwerts zu überprüfen. Der Filter überprüft, ob der Wert entweder dem regulären Ausdruck entspricht `^[a-zA-Z0-9_-]*$` oder ob es sich um einen gültigen Amazon-Ressourcennamen (ARN) handelt. Wenn der Wert diese Überprüfung nicht besteht, schlägt das Rendern der Vorlage fehl.
### Beispiel
Mit der folgenden benutzerdefinierten Komponentenvorlage:
```
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
```
+ Die folgende Referenz in einer Dienstvorlage:
```
# ...
{{ service_instance.components.default.outputs.Output1
| proton_cfn_sanitize }}
```
Wird wie folgt gerendert:
```
# ...
This-is_valid_37
```
+ Die folgende Referenz in einer Dienstvorlage:
```
# ...
{{ service_instance.components.default.outputs.Output2
| proton_cfn_sanitize }}
```
Ergebnisse mit dem folgenden Renderfehler:
```
Illegal character(s) detected in "this::is::incorrect". Must match regex ^[a-zA-Z0-9_-]*$ or be a valid ARN
```
+ Die folgende Referenz in einer Dienstvorlage:
```
# ...
{{ service_instance.components.default.outputs.SomeArn
| proton_cfn_sanitize }}
```
Wird wie folgt gerendert:
```
# ...
arn:aws:some-service::123456789012:some-resource/resource-name
```
## Geben Sie Standardwerte für nicht existierende Verweise an
**Beschreibung**
Der `default` Filter stellt einen Standardwert bereit, wenn kein Namespace-Verweis vorhanden ist. Verwenden Sie ihn, um robuste Vorlagen zu schreiben, die auch dann fehlerfrei gerendert werden können, wenn der Parameter, auf den Sie verweisen, fehlt.
### Beispiel
Der folgende Verweis in einer Dienstvorlage führt dazu, dass das Rendern von Vorlagen fehlschlägt, wenn der Dienstinstanz keine direkt definierte (Standard-) Komponente angehängt ist oder wenn die angehängte Komponente keine Ausgabe mit dem Namen hat`test`.
```
# ...
{{ service_instance.components.default.outputs.test }}
```
Um dieses Problem zu vermeiden, fügen Sie den `default` Filter hinzu.
```
# ...
{{ service_instance.components.default.outputs.test | default("[optional-value]") }}
```
# CodeBuild Details und Beispiele für Bereitstellungsparameter
Sie können Parameter in Ihren Vorlagen für CodeBuild basierte AWS Proton Ressourcen definieren und in Ihrem Bereitstellungscode auf diese Parameter verweisen. Eine ausführliche Beschreibung der AWS Proton Parameter, Parametertypen, des Parameter-Namespace und der Verwendung von Parametern in Ihren IaC-Dateien finden Sie unter. [AWS Proton Parameter](parameters.md)
**Anmerkung**
Sie können die CodeBuild Bereitstellung mit Umgebungen und Diensten verwenden. Derzeit können Sie Komponenten auf diese Weise nicht bereitstellen.
## Eingabeparameter
Wenn Sie eine AWS Proton Ressource erstellen, z. B. eine Umgebung oder einen Dienst, geben Sie Werte für Eingabeparameter an, die in der [Schemadatei](ag-schema.md) Ihrer Vorlage definiert sind. Wenn die Ressource, die Sie erstellen[CodeBuild Bereitstellung](ag-works-prov-methods.md#ag-works-prov-methods-codebuild), verwendet, AWS Proton diese Eingabewerte in einer Eingabedatei wiedergibt. Ihr Bereitstellungscode kann Parameterwerte aus dieser Datei importieren und abrufen.
Ein Beispiel für CodeBuild Vorlagen finden Sie unter[CodeBuild Vorlagenpaket für die Bereitstellung](ag-infrastructure-tmp-files-codebuild.md). Weitere Informationen zu Manifestdateien finden Sie unter [Verpacken Sie die Vorlagendateien für AWS Proton](ag-wrap-up.md).
Das folgende Beispiel ist eine JSON-Eingabedatei, die während der CodeBuild basierten Bereitstellung einer Dienstinstanz generiert wurde.
### Beispiel: Verwendung von AWS CDK with provisioning 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"
}
}
}
```
## Ausgabeparameter
[Um die Ausgaben der Ressourcenbereitstellung zurück an zu übermitteln AWS Proton, kann Ihr Bereitstellungscode eine JSON-Datei `proton-outputs.json` mit Werten für Ausgabeparameter generieren, die in der Schemadatei Ihrer Vorlage definiert sind.](ag-schema.md) Der `cdk deploy` Befehl hat beispielsweise das `--outputs-file` Argument, das die anweist, eine JSON-Datei mit Bereitstellungsausgaben AWS CDK zu generieren. Wenn Ihre Ressource den verwendet AWS CDK, geben Sie den folgenden Befehl in Ihrem CodeBuild Vorlagenmanifest an:
```
aws proton notify-resource-deployment-status-change
```
AWS Proton sucht nach dieser JSON-Datei. Wenn die Datei existiert, nachdem Ihr Bereitstellungscode erfolgreich abgeschlossen wurde, AWS Proton liest die Ausgabeparameterwerte aus ihr.
# Details und Beispiele für die Terraform-Infrastruktur-as-Code-Datei (IaC)
Sie können Terraform-Eingabevariablen in `variable.tf` Dateien in Ihrem Vorlagenpaket aufnehmen. Sie können auch ein Schema erstellen, um AWS Proton verwaltete Variablen zu erstellen. AWS Proton erstellt eine Variable `.tf files` aus Ihrer Schemadatei. Weitere Informationen finden Sie unter [Terraform-IaC-Dateien](ag-infrastructure-tmp-files-terraform.md).
Um auf Ihre vom Schema definierten AWS Proton Variablen in Ihrer Infrastruktur zu verweisen`.tf files`, verwenden Sie die AWS Proton Namespaces, die in der Tabelle *Parameter und Namespaces* für Terraform IaC aufgeführt sind. Sie können beispielsweise die Datei `var.environment.inputs.vpc_cidr` verwenden. Umschließen Sie diese Variablen innerhalb von Anführungszeichen mit einfachen Klammern und fügen Sie vor der ersten Klammer ein Dollarzeichen hinzu (z. B.). `“${var.environment.inputs.vpc_cidr}”`
Das folgende Beispiel zeigt, wie Namespaces verwendet werden, um AWS Proton Parameter in eine Umgebung einzubeziehen. `.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
}
```