Creazione di risorse Amazon ECS utilizzando la console AWS CloudFormation

Un modo per utilizzare Amazon ECS con AWS CloudFormation è tramite. AWS Management Console Qui puoi creare i tuoi AWS CloudFormation stack per i componenti di Amazon ECS come definizioni di attività, cluster e servizi e distribuirli direttamente dalla console. Il seguente tutorial mostra come utilizzare la AWS CloudFormation console per creare un servizio Amazon ECS, una definizione di attività e un cluster.

Prerequisiti

Questo tutorial presuppone che siano stati soddisfatti i seguenti prerequisiti.

• Hai completato le fasi descritte in Configurazione per l'uso di Amazon ECS.

• Il tuo utente IAM dispone delle autorizzazioni richieste specificate nell'esempio di Amazon ECS_ FullAccess policy IAM.

Fase 1: Creare un modello di stack

Utilizza i seguenti passaggi per creare un modello di AWS CloudFormation stack per un servizio Amazon ECS e altre risorse correlate.

1. Utilizzando un editor di testo a tua scelta, crea un file chiamato. ecs-tutorial-template.yaml

2. Nel ecs-tutorial-template.yaml file, incolla il seguente modello e salva le modifiche.

   AWSTemplateFormatVersion: 2010-09-09
   Description: A template that deploys an application that is built on an Apache web server Docker image by creating an Amazon ECS cluster, task definition, and service. The template also creates networking and logging resources, and an Amazon ECS task execution role.
   Parameters:
     ClusterName:
       Type: String
       Default: CFNCluster
       Description: Name of the ECS Cluster
     TaskFamily:
       Type: String
       Default: task-definition-cfn
       Description: Family name for the Task Definition
     ServiceName:
       Type: String
       Default: cfn-service
       Description: Name of the ECS Service
     ContainerImage:
       Type: String
       Default: public.ecr.aws/docker/library/httpd:2.4
       Description: Container image to use for the task
     TaskCpu:
       Type: Number
       Default: 256
       AllowedValues: [256, 512, 1024, 2048, 4096]
       Description: CPU units for the task
     TaskMemory:
       Type: Number
       Default: 512
       AllowedValues: [512, 1024, 2048, 4096, 8192, 16384]
       Description: Memory (in MiB) for the task
     DesiredCount:
       Type: Number
       Default: 1
       Description: Desired number of tasks to run
     LogGroupName:
       Type: String
       Default: /ecs/fargate-task-definition
       Description: CloudWatch Log Group name
     VpcCidr:
       Type: String
       Default: 10.0.0.0/16
       Description: CIDR block for the VPC
     PublicSubnet1Cidr:
       Type: String
       Default: 10.0.0.0/24
       Description: CIDR block for public subnet 1
     PublicSubnet2Cidr:
       Type: String
       Default: 10.0.1.0/24
       Description: CIDR block for public subnet 2
   Resources:
     # VPC and Networking Resources
     VPC:
       Type: AWS::EC2::VPC
       Properties:
         CidrBlock: !Ref VpcCidr
         EnableDnsSupport: true
         EnableDnsHostnames: true
         Tags:
           - Key: Name
             Value: !Sub ${AWS::StackName}-VPC
     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
     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}-PublicSubnet1
     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}-PublicSubnet2
     PublicRouteTable:
       Type: AWS::EC2::RouteTable
       Properties:
         VpcId: !Ref VPC
         Tags:
           - Key: Name
             Value: !Sub ${AWS::StackName}-PublicRouteTable
     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
     # Security Group
     ECSSecurityGroup:
       Type: AWS::EC2::SecurityGroup
       Properties:
         GroupDescription: Security group for ECS tasks
         VpcId: !Ref VPC
         SecurityGroupIngress:
           - IpProtocol: tcp
             FromPort: 80
             ToPort: 80
             CidrIp: 0.0.0.0/0
           - IpProtocol: tcp
             FromPort: 443
             ToPort: 443
             CidrIp: 0.0.0.0/0
     # IAM Roles
     ECSTaskExecutionRole:
       Type: AWS::IAM::Role
       Properties:
         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
     # CloudWatch Logs
     TaskLogGroup:
       Type: AWS::Logs::LogGroup
       DeletionPolicy: Retain
       UpdateReplacePolicy: Retain
       Properties:
         LogGroupName: !Ref LogGroupName
         RetentionInDays: 30
     # ECS Resources
     ECSCluster:
       Type: AWS::ECS::Cluster
       Properties:
         ClusterName: !Ref ClusterName
     ECSTaskDefinition:
       Type: AWS::ECS::TaskDefinition
       Properties:
         ContainerDefinitions:
           - Command:
               - >-
                 /bin/sh -c "echo '<html> <head> <title>Amazon ECS Sample
                 App</title> <style>body {margin-top: 40px; background-color:
                 #333;} </style> </head><body> <div
                 style=color:white;text-align:center> <h1>Amazon ECS Sample
                 App</h1> <h2>Congratulations!</h2> <p>Your application is now
                 running on a container in Amazon ECS.</p> </div></body></html>' > 
                 /usr/local/apache2/htdocs/index.html && httpd-foreground"s
             EntryPoint:
               - sh
               - '-c'
             Essential: true
             Image: !Ref ContainerImage
             LogConfiguration:
               LogDriver: awslogs
               Options:
                 mode: non-blocking
                 max-buffer-size: 25m
                 awslogs-create-group: 'true'
                 awslogs-group: !Ref LogGroupName
                 awslogs-region: !Ref 'AWS::Region'
                 awslogs-stream-prefix: ecs
             Name: sample-fargate-app
             PortMappings:
               - ContainerPort: 80
                 HostPort: 80
                 Protocol: tcp
         Cpu: !Ref TaskCpu
         ExecutionRoleArn: !GetAtt ECSTaskExecutionRole.Arn
         Family: !Ref TaskFamily
         Memory: !Ref TaskMemory
         NetworkMode: awsvpc
         RequiresCompatibilities:
           - FARGATE
         RuntimePlatform:
           OperatingSystemFamily: LINUX
     ECSService:
       Type: AWS::ECS::Service
       DependsOn: 
         - PublicSubnet1RouteTableAssociation
         - PublicSubnet2RouteTableAssociation
       Properties:
         ServiceName: !Ref ServiceName
         Cluster: !Ref ECSCluster
         DesiredCount: !Ref DesiredCount
         LaunchType: FARGATE
         NetworkConfiguration:
           AwsvpcConfiguration:
             AssignPublicIp: ENABLED
             SecurityGroups:
               - !Ref ECSSecurityGroup
             Subnets:
               - !Ref PublicSubnet1
               - !Ref PublicSubnet2
         TaskDefinition: !Ref ECSTaskDefinition
   Outputs:
     ClusterName:
       Description: The name of the ECS cluster
       Value: !Ref ECSCluster
     TaskDefinitionArn:
       Description: The ARN of the task definition
       Value: !Ref ECSTaskDefinition
     ServiceName:
       Description: The name of the ECS service
       Value: !Ref ECSService
     VpcId:
       Description: The ID of the VPC
       Value: !Ref VPC  
     PublicSubnet1:
       Description: The ID of public subnet 1
       Value: !Ref PublicSubnet1
     PublicSubnet2:
       Description: The ID of public subnet 2
       Value: !Ref PublicSubnet2 
     SecurityGroup:
       Description: The ID of the security group
       Value: !Ref ECSSecurityGroup  
     ExecutionRoleArn:
       Description: The ARN of the task execution role
       Value: !GetAtt ECSTaskExecutionRole.Arn

Fase 2: creare uno stack per le risorse Amazon ECS

Dopo aver creato un file per il modello, puoi seguire questi passaggi per creare uno stack con il modello utilizzando la console. AWS CloudFormation

1. Accedi AWS Management Console e apri la AWS CloudFormation console all'indirizzo https://console.aws.amazon.com/cloudformazione.

2. Nella pagina Stacks, nell'angolo in alto a destra, scegli Crea stack, quindi scegli con nuove risorse (standard).

3. Scegli un modello esistente.

4. Scegli Carica un file modello, quindi scegli Scegli file per scegliere il ecs-tutorial-template file.

   Dopo aver caricato il file in un bucket Amazon S3, puoi scegliere View in Infrastructure Composer per visualizzare il modello in Infrastructure Composer. Per ulteriori informazioni sui AWS CloudFormation modelli e Infrastructure Composer, consulta Creare modelli visivamente con Infrastructure Composer nella Guida per l'utente.AWS CloudFormation

5. Scegli Next (Successivo).

6. Nella pagina Specificare i dettagli dello stack, in Nome dello stack, fornisci il seguente nome per lo stack:. ecs-tutorial-stack Lasciate tutti i valori dei parametri in Parametri come predefiniti, quindi scegliete Avanti.

7. Nella pagina Configura le opzioni dello stack, in Capacità, seleziona la casella di controllo per confermare AWS CloudFormation la creazione di risorse IAM. Questo riconoscimento è necessario per creare il ruolo di esecuzione delle attività di Amazon ECS come definito nel modello. Lascia le altre impostazioni come predefinite e scegli Avanti.

8. Controlla i dettagli dello stack nella pagina Rivedi e crea, quindi scegli Invia per avviare la creazione dello stack.

Fase 3: Verifica

Utilizza i seguenti passaggi per verificare la creazione di risorse Amazon ECS utilizzando il modello fornito.

1. Accedi AWS Management Console e apri la AWS CloudFormation console all'indirizzo https://console.aws.amazon.com/cloudformazione.

2. Nella pagina Stacks, scegli. ecs-tutorial-stack

3. Scegli la scheda Eventi. Se gli stati dell'evento lo diconoCREATE_IN_PROGRESS, attendi che la creazione sia completata e che gli stati cambino in. CREATE_COMPLETE

4. Dopo aver cambiato gli stati degli eventiCREATE_COMPLETE, scegli la scheda Risorse. Vedrai le risorse con l'ID logicoECSCluster,ECSTaskDefinition, rispettivamenteECSService.

5. Per verificare la creazione di un cluster Amazon ECS, scegli l'ID fisico associato ECSCluster a. Verrai reindirizzato alla console Amazon ECS dove potrai vedere il cluster creato chiamato. CFNCluster

6. Per verificare la creazione di un servizio Amazon ECS, scegli l'ID fisico associato ECSService a. Verrai reindirizzato alla console Amazon ECS dove potrai vedere il servizio chiamato cfn-service creato nel cluster. cfnCluster

7. Per verificare la creazione di una definizione di attività Amazon ECS, scegli l'ID fisico associato ECSTaskDefinition a. Verrai reindirizzato alla console Amazon ECS dove potrai vedere la revisione della definizione dell'attività con il nome. task-definition-cfn

Fase 4: Eliminazione delle risorse

Per ripulire le risorse ed evitare di incorrere in ulteriori costi, segui questi passaggi.

1. Accedi AWS Management Console e apri la AWS CloudFormation console all'indirizzo https://console.aws.amazon.com /cloudformazione.

2. Nella pagina Stacks, scegli. ecs-tutorial-stack

3. Scegliere Delete (Elimina).

4. Quando viene richiesta la conferma, scegli nuovamente Elimina.

5. Scegli la scheda Eventi. Lo stato delle ecs-tutorial-stack modifiche a DELETE_IN_PROGRESS e quindi a DELETE_COMPLETE dopo l'eliminazione o la cancellazione delle risorse. L'eliminazione richiede un paio di minuti.

6. Scegliere la scheda Resources (Risorse). Verrà ora visualizzato un elenco di ID logici con lo stato aggiornato a DELETE_COMPLETE.