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.
# Erstellen von Amazon ECS-Ressourcen mithilfe von AWS CLI Befehlen für CloudFormation
Eine andere Möglichkeit, Amazon ECS mit zu verwenden, CloudFormation ist die AWS CLI. Sie können Befehle verwenden, um Ihre CloudFormation Stacks für Amazon ECS-Komponenten wie Aufgabendefinitionen, Cluster und Services zu erstellen und bereitzustellen. Das folgende Tutorial zeigt, wie Sie Amazon ECS-Ressourcen mithilfe einer CloudFormation Vorlage erstellen können. AWS CLI
## Voraussetzungen
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
## Schritt 1: Erstellen eines Stacks
Führen Sie den folgenden Befehl aus, um einen Stack unter Verwendung der in einer Datei AWS CLI gespeicherten Datei namens `ecs-tutorial-template.yaml` zu erstellen.
```
cat << 'EOF' > ecs-tutorial-template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Description: '[AWSDocs] ECS: load-balanced-web-application'
Parameters:
VpcCidr:
Type: String
Default: '10.0.0.0/16'
Description: CIDR block for the VPC
ContainerImage:
Type: String
Default: 'public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest'
Description: Container image to use in task definition
PublicSubnet1Cidr:
Type: String
Default: '10.0.1.0/24'
Description: CIDR block for public subnet 1
PublicSubnet2Cidr:
Type: String
Default: '10.0.2.0/24'
Description: CIDR block for public subnet 2
PrivateSubnet1Cidr:
Type: String
Default: '10.0.3.0/24'
Description: CIDR block for private subnet 1
PrivateSubnet2Cidr:
Type: String
Default: '10.0.4.0/24'
Description: CIDR block for private subnet 2
ServiceName:
Type: String
Default: 'tutorial-app'
Description: Name of the ECS service
ContainerPort:
Type: Number
Default: 80
Description: Port on which the container listens
DesiredCount:
Type: Number
Default: 2
Description: Desired number of tasks
MinCapacity:
Type: Number
Default: 1
Description: Minimum number of tasks for auto scaling
MaxCapacity:
Type: Number
Default: 10
Description: Maximum number of tasks for auto scaling
Resources:
# VPC and Networking
VPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: !Ref VpcCidr
EnableDnsHostnames: true
EnableDnsSupport: true
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-vpc'
# Internet Gateway
InternetGateway:
Type: AWS::EC2::InternetGateway
Properties:
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-igw'
InternetGatewayAttachment:
Type: AWS::EC2::VPCGatewayAttachment
Properties:
InternetGatewayId: !Ref InternetGateway
VpcId: !Ref VPC
# Public Subnets for ALB
PublicSubnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref VPC
AvailabilityZone: !Select [0, !GetAZs '']
CidrBlock: !Ref PublicSubnet1Cidr
MapPublicIpOnLaunch: true
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-public-subnet-1'
PublicSubnet2:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref VPC
AvailabilityZone: !Select [1, !GetAZs '']
CidrBlock: !Ref PublicSubnet2Cidr
MapPublicIpOnLaunch: true
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-public-subnet-2'
# Private Subnets for ECS Tasks
PrivateSubnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref VPC
AvailabilityZone: !Select [0, !GetAZs '']
CidrBlock: !Ref PrivateSubnet1Cidr
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-private-subnet-1'
PrivateSubnet2:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref VPC
AvailabilityZone: !Select [1, !GetAZs '']
CidrBlock: !Ref PrivateSubnet2Cidr
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-private-subnet-2'
# NAT Gateways for private subnet internet access
NatGateway1EIP:
Type: AWS::EC2::EIP
DependsOn: InternetGatewayAttachment
Properties:
Domain: vpc
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-nat-eip-1'
NatGateway2EIP:
Type: AWS::EC2::EIP
DependsOn: InternetGatewayAttachment
Properties:
Domain: vpc
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-nat-eip-2'
NatGateway1:
Type: AWS::EC2::NatGateway
Properties:
AllocationId: !GetAtt NatGateway1EIP.AllocationId
SubnetId: !Ref PublicSubnet1
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-nat-1'
NatGateway2:
Type: AWS::EC2::NatGateway
Properties:
AllocationId: !GetAtt NatGateway2EIP.AllocationId
SubnetId: !Ref PublicSubnet2
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-nat-2'
# Route Tables
PublicRouteTable:
Type: AWS::EC2::RouteTable
Properties:
VpcId: !Ref VPC
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-public-routes'
DefaultPublicRoute:
Type: AWS::EC2::Route
DependsOn: InternetGatewayAttachment
Properties:
RouteTableId: !Ref PublicRouteTable
DestinationCidrBlock: 0.0.0.0/0
GatewayId: !Ref InternetGateway
PublicSubnet1RouteTableAssociation:
Type: AWS::EC2::SubnetRouteTableAssociation
Properties:
RouteTableId: !Ref PublicRouteTable
SubnetId: !Ref PublicSubnet1
PublicSubnet2RouteTableAssociation:
Type: AWS::EC2::SubnetRouteTableAssociation
Properties:
RouteTableId: !Ref PublicRouteTable
SubnetId: !Ref PublicSubnet2
PrivateRouteTable1:
Type: AWS::EC2::RouteTable
Properties:
VpcId: !Ref VPC
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-private-routes-1'
DefaultPrivateRoute1:
Type: AWS::EC2::Route
Properties:
RouteTableId: !Ref PrivateRouteTable1
DestinationCidrBlock: 0.0.0.0/0
NatGatewayId: !Ref NatGateway1
PrivateSubnet1RouteTableAssociation:
Type: AWS::EC2::SubnetRouteTableAssociation
Properties:
RouteTableId: !Ref PrivateRouteTable1
SubnetId: !Ref PrivateSubnet1
PrivateRouteTable2:
Type: AWS::EC2::RouteTable
Properties:
VpcId: !Ref VPC
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-private-routes-2'
DefaultPrivateRoute2:
Type: AWS::EC2::Route
Properties:
RouteTableId: !Ref PrivateRouteTable2
DestinationCidrBlock: 0.0.0.0/0
NatGatewayId: !Ref NatGateway2
PrivateSubnet2RouteTableAssociation:
Type: AWS::EC2::SubnetRouteTableAssociation
Properties:
RouteTableId: !Ref PrivateRouteTable2
SubnetId: !Ref PrivateSubnet2
# Security Groups
ALBSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupName: !Sub '${AWS::StackName}-alb-sg'
GroupDescription: Security group for Application Load Balancer
VpcId: !Ref VPC
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
Description: Allow HTTP traffic from internet
SecurityGroupEgress:
- IpProtocol: -1
CidrIp: 0.0.0.0/0
Description: Allow all outbound traffic
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-alb-sg'
ECSSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupName: !Sub '${AWS::StackName}-ecs-sg'
GroupDescription: Security group for ECS tasks
VpcId: !Ref VPC
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: !Ref ContainerPort
ToPort: !Ref ContainerPort
SourceSecurityGroupId: !Ref ALBSecurityGroup
Description: Allow traffic from ALB
SecurityGroupEgress:
- IpProtocol: -1
CidrIp: 0.0.0.0/0
Description: Allow all outbound traffic
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-ecs-sg'
# Application Load Balancer
ApplicationLoadBalancer:
Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
Name: !Sub '${AWS::StackName}-alb'
Scheme: internet-facing
Type: application
Subnets:
- !Ref PublicSubnet1
- !Ref PublicSubnet2
SecurityGroups:
- !Ref ALBSecurityGroup
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-alb'
ALBTargetGroup:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
Name: !Sub '${AWS::StackName}-tg'
Port: !Ref ContainerPort
Protocol: HTTP
VpcId: !Ref VPC
TargetType: ip
HealthCheckIntervalSeconds: 30
HealthCheckPath: /
HealthCheckProtocol: HTTP
HealthCheckTimeoutSeconds: 5
HealthyThresholdCount: 2
UnhealthyThresholdCount: 5
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-tg'
ALBListener:
Type: AWS::ElasticLoadBalancingV2::Listener
Properties:
DefaultActions:
- Type: forward
TargetGroupArn: !Ref ALBTargetGroup
LoadBalancerArn: !Ref ApplicationLoadBalancer
Port: 80
Protocol: HTTP
# ECS Cluster
ECSCluster:
Type: AWS::ECS::Cluster
Properties:
ClusterName: !Sub '${AWS::StackName}-cluster'
CapacityProviders:
- FARGATE
- FARGATE_SPOT
DefaultCapacityProviderStrategy:
- CapacityProvider: FARGATE
Weight: 1
- CapacityProvider: FARGATE_SPOT
Weight: 4
ClusterSettings:
- Name: containerInsights
Value: enabled
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-cluster'
# IAM Roles
ECSTaskExecutionRole:
Type: AWS::IAM::Role
Properties:
RoleName: !Sub '${AWS::StackName}-task-execution-role'
AssumeRolePolicyDocument:
Version: '2012-10-17 '
Statement:
- Effect: Allow
Principal:
Service: ecs-tasks.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-task-execution-role'
ECSTaskRole:
Type: AWS::IAM::Role
Properties:
RoleName: !Sub '${AWS::StackName}-task-role'
AssumeRolePolicyDocument:
Version: '2012-10-17 '
Statement:
- Effect: Allow
Principal:
Service: ecs-tasks.amazonaws.com
Action: sts:AssumeRole
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-task-role'
# CloudWatch Log Group
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub '/ecs/${AWS::StackName}'
RetentionInDays: 7
# ECS Task Definition
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
Family: !Sub '${AWS::StackName}-task'
Cpu: '256'
Memory: '512'
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
ExecutionRoleArn: !GetAtt ECSTaskExecutionRole.Arn
TaskRoleArn: !GetAtt ECSTaskRole.Arn
ContainerDefinitions:
- Name: !Ref ServiceName
Image: !Ref ContainerImage
PortMappings:
- ContainerPort: !Ref ContainerPort
Protocol: tcp
Essential: true
LogConfiguration:
LogDriver: awslogs
Options:
awslogs-group: !Ref LogGroup
awslogs-region: !Ref AWS::Region
awslogs-stream-prefix: ecs
HealthCheck:
Command:
- CMD-SHELL
- curl -f http://localhost/ || exit 1
Interval: 30
Timeout: 5
Retries: 3
StartPeriod: 60
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-task'
# ECS Service
ECSService:
Type: AWS::ECS::Service
DependsOn: ALBListener
Properties:
ServiceName: !Sub '${AWS::StackName}-service'
Cluster: !Ref ECSCluster
TaskDefinition: !Ref TaskDefinition
DesiredCount: !Ref DesiredCount
LaunchType: FARGATE
PlatformVersion: LATEST
NetworkConfiguration:
AwsvpcConfiguration:
AssignPublicIp: DISABLED
SecurityGroups:
- !Ref ECSSecurityGroup
Subnets:
- !Ref PrivateSubnet1
- !Ref PrivateSubnet2
LoadBalancers:
- ContainerName: !Ref ServiceName
ContainerPort: !Ref ContainerPort
TargetGroupArn: !Ref ALBTargetGroup
DeploymentConfiguration:
MaximumPercent: 200
MinimumHealthyPercent: 50
DeploymentCircuitBreaker:
Enable: true
Rollback: true
EnableExecuteCommand: true # For debugging
Tags:
- Key: Name
Value: !Sub '${AWS::StackName}-service'
# Auto Scaling Target
ServiceScalingTarget:
Type: AWS::ApplicationAutoScaling::ScalableTarget
Properties:
MaxCapacity: !Ref MaxCapacity
MinCapacity: !Ref MinCapacity
ResourceId: !Sub 'service/${ECSCluster}/${ECSService.Name}'
RoleARN: !Sub 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService'
ScalableDimension: ecs:service:DesiredCount
ServiceNamespace: ecs
# Auto Scaling Policy - CPU Utilization
ServiceScalingPolicy:
Type: AWS::ApplicationAutoScaling::ScalingPolicy
Properties:
PolicyName: !Sub '${AWS::StackName}-cpu-scaling-policy'
PolicyType: TargetTrackingScaling
ScalingTargetId: !Ref ServiceScalingTarget
TargetTrackingScalingPolicyConfiguration:
PredefinedMetricSpecification:
PredefinedMetricType: ECSServiceAverageCPUUtilization
TargetValue: 70.0
ScaleOutCooldown: 300
ScaleInCooldown: 300
Outputs:
VPCId:
Description: VPC ID
Value: !Ref VPC
Export:
Name: !Sub '${AWS::StackName}-VPC-ID'
LoadBalancerURL:
Description: URL of the Application Load Balancer
Value: !Sub 'http://${ApplicationLoadBalancer.DNSName}'
Export:
Name: !Sub '${AWS::StackName}-ALB-URL'
ECSClusterName:
Description: Name of the ECS Cluster
Value: !Ref ECSCluster
Export:
Name: !Sub '${AWS::StackName}-ECS-Cluster'
ECSServiceName:
Description: Name of the ECS Service
Value: !GetAtt ECSService.Name
Export:
Name: !Sub '${AWS::StackName}-ECS-Service'
PrivateSubnet1:
Description: Private Subnet 1 ID
Value: !Ref PrivateSubnet1
Export:
Name: !Sub '${AWS::StackName}-Private-Subnet-1'
PrivateSubnet2:
Description: Private Subnet 2 ID
Value: !Ref PrivateSubnet2
Export:
Name: !Sub '${AWS::StackName}-Private-Subnet-2'
EOF
```
Die in diesem Tutorial verwendete Vorlage erstellt einen Amazon-ECS-Service mit zwei Aufgaben, die in Fargate ausgeführt werden. Die Aufgaben führen jeweils eine Amazon-ECS-Beispielanwendung aus. Die Vorlage erstellt außerdem einen Application Load Balancer, der den Anwendungsdatenverkehr verteilt, und eine Richtlinie für Application Auto Scaling, die die Anwendung auf der Grundlage der CPU-Auslastung skaliert. Die Vorlage erstellt auch die Netzwerkressourcen, die für die Bereitstellung der Anwendung erforderlich sind, die Protokollierungsressourcen für Container-Protokolle und eine IAM-Rolle für die Amazon-ECS-Aufgabenausführung. Weitere Informationen zur Aufgabenausführungsrolle finden Sie unter [IAM-Rolle für die Amazon-ECS-Aufgabenausführung](task_execution_IAM_role.md). Weitere Informationen zu Auto Scaling finden Sie unter [Automatisches Skalieren Ihres Amazon-ECS-Service](service-auto-scaling.md).
Verwenden Sie nach dem Erstellen einer Vorlagendatei den folgenden Befehl, um einen Stack zu erstellen. Das `--capabilities`-Flag ist erforderlich, um eine Amazon-ECS-Aufgabenausführungsrolle zu erstellen, wie in der Vorlage angegeben. Sie können auch das `--parameters`-Flag angeben, um die Vorlagenparameter anzupassen.
```
aws cloudformation create-stack \
--stack-name ecs-tutorial-stack \
--template-body file://ecs-tutorial-template.yaml \
--region aws-region \
--capabilities CAPABILITY_NAMED_IAM
```
Nachdem Sie den `create-stack`-Befehl ausgeführt haben, können Sie `describe-stacks` verwenden, um den Status der Stack-Erstellung zu überprüfen.
```
aws cloudformation describe-stacks \
--stack-name ecs-tutorial-stack \
--region aws-region
```
## Schritt 2: Amazon-ECS-Ressourcenerstellung überprüfen
Gehen Sie wie folgt vor, um sicherzustellen, dass die Amazon-ECS-Ressourcen korrekt erstellt wurden.
1. Führen Sie den folgenden Befehl aus, um alle Aufgabendefinitionen in einer AWS-Region aufzulisten.
```
aws ecs list-task-definitions
```
Der Befehle gibt eine Liste mit Amazon-Ressourcennamen (ARN) von Aufgabendefinitionen zurück. Der ARN der Aufgabendefinition, die Sie mit der Vorlage erstellt haben, wird im folgenden Format angezeigt.
```
{
"taskDefinitionArns": [
.....
"arn:aws:ecs:aws-region:111122223333:task-definition/ecs-tutorial-stack-task:1",
.....
]
}
```
1. Führen Sie den folgenden Befehl aus, um alle Cluster in einer AWS-Region aufzulisten.
```
aws ecs list-clusters
```
Der Befehl gibt eine Liste von Clustern zurück ARNs. Der ARN des Clusters, das Sie mit der Vorlage erstellt haben, wird im folgenden Format angezeigt.
```
{
"clusterArns": [
.....
"arn:aws:ecs:aws-region:111122223333:cluster/ecs-tutorial-stack-cluster",
.....
]
}
```
1. Führen Sie den folgenden Befehl aus, um alle Services im Cluster `ecs-tutorial-stack-cluster` aufzulisten.
```
aws ecs list-services \
--cluster ecs-tutorial-stack-cluster
```
Der Befehl gibt eine Liste von Diensten zurück ARNs. Der ARN des Service, den Sie mit der Vorlage erstellt haben, wird im folgenden Format angezeigt.
```
{
"serviceArns": [
"arn:aws:ecs:aws-region:111122223333:service/ecs-tutorial-stack-cluster/ecs-tutorial-stack-service"
]
}
```
Sie können auch den DNS-Namen des erstellten Application Load Balancer abrufen und ihn verwenden, um die Erstellung von Ressourcen zu überprüfen. Führen Sie den folgenden Befehl aus, um den DNS-Namen abzurufen:
Führen Sie den folgenden Befehl aus, um die Ausgaben des erstellten Stacks abzurufen.
```
aws cloudformation describe-stacks \
--stack-name ecs-tutorial-stack \
--region aws-region \
--query 'Stacks[0].Outputs[?OutputKey==`LoadBalancerURL`].OutputValue' \
--output text
```
Ausgabe:
```
http://ecs-tutorial-stack-alb-0123456789.aws-region.elb.amazonaws.com
```
Fügen Sie den DNS-Namen in einen Browser ein, um eine Webseite aufzurufen, auf der eine Amazon-ECS-Beispielanwendung angezeigt wird.
## Schritt 3: Bereinigen
Führen Sie den folgenden Befehl aus, um die von Ihnen erstellten Ressourcen zu bereinigen.
```
aws cloudformation delete-stack \
--stack-name ecs-stack
```
Der `delete-stack` Befehl initiiert das Löschen des CloudFormation Stacks, der in diesem Tutorial erstellt wurde, und löscht alle Ressourcen im Stack. Um das Löschen zu überprüfen, können Sie den Vorgang unter [Schritt 2: Amazon-ECS-Ressourcenerstellung überprüfen](#ecs-cloudformation-cli-verify) wiederholen. Die Liste ARNs der Ausgaben wird keine aufgerufene Aufgabendefinition `ecs-tutorial-stack-task` oder einen aufgerufenen Cluster mehr enthalten. `ecs-tutorial-stack-cluster` Der `list-services` Aufruf schlägt fehl.