Usar o AWS CloudFormation Designer para modificar o modelo de uma pilha

Abra o console do CloudFormation em https://console.aws.amazon.com/cloudformation/.

Na lista de pilhas, selecione a BasicWebServerStack.

Escolha Actions (Ações) e, em seguida, View/Edit template in Designer (Visualizar/editar modelo no Designer).

Remova o recurso WebServerInstance.

1. Clique com o botão direito do mouse no recurso WebServerInstance.

2. No menu de recursos, escolha Excluir (ícone da lixeira).

3. Escolha OK para confirmar.

No painel Tipos de recurso, adicione o seguinte ao recurso PublicSubnet: AutoScalingGroup, LaunchConfiguration e LoadBalancer. Antes de adicionar recursos, pode ser necessário expandir a sub-rede para incluir todos os recursos.

Os recursos são organizados por categorias de recursos. O grupo do Auto Scaling e a configuração de execução estão na categoria AutoScaling e o load balancer está na categoria ElasticLoadBalancing.

No painel Tipos de recurso da categoria EC2, adicione o recurso SecurityGroup em qualquer lugar do VPC, exceto na sub-rede.

Esse security group controlará o tráfego de entrada e saída do load balancer.

Renomeie os recursos para facilitar a identificação deles:

Crie associações para os recursos que você adicionou.

1. Associe o load balancer e os recursos do grupo do Auto Scaling à sub-rede pública:

   • No recurso PublicElasticLoadBalancer, arraste a conexão AWS::EC2::Subnet (Property: Subnets) para o recurso PublicSubnet.

   • No recurso WebServerFleet, arraste a conexão AWS::EC2::Subnet (Property: VPCZoneIdentifier) para o recurso PublicSubnet.

2. Associe o load balancer ao respectivo security group:

   • No recurso PublicElasticLoadBalancer, arraste a conexão AWS::EC2::SecurityGroup (Property: SecurityGroups) para o recurso PublicLoadBalancerSecurityGroup.

3. Associe o grupo do Auto Scaling ao load balancer e à configuração de execução:

   • No recurso WebServerFleet, arraste a conexão AWS::ElasticLoadBalancing::LoadBalancer (Property: LoadBalancerNames) para o recurso PublicElasticLoadBalancer.

   • No recurso WebServerFleet, arraste a conexão AWS::ElasticLoadBalancing::LaunchConfiguration (Property: LaunchConfigurationName) para o recurso WebServerLaunchConfig.

4. Associe a configuração de execução ao security group:

   • No recurso WebServerLaunchConfig, arraste a conexão AWS::EC2::SecurityGroup (Property: SecurityGroups) para o recurso WebServerSecurityGroup.

5. Defina uma dependência do grupo do Auto Scaling para a rota pública:

   • No recurso WebServerFleet, arraste a conexão DependsOn para o recurso PublicRoute.

   Essa dependência significa que o CloudFormation não criará o recurso WebServerFleet até que a rota pública esteja concluída. Caso contrário, se a rota pública não estiver disponível quando as instâncias de servidor web estiverem inicializando, elas não poderão enviar sinais (usando o script auxiliar cfn-signal) para notificar o CloudFormation quando as implantações de configurações aplicativos estiverem concluídas.

Especifique as propriedades dos recursos que você adicionou.

1. Na tela do AWS CloudFormation Designer, selecione o recurso PublicElasticLoadBalancer.

2. No painel do editor integrado, selecione a guia Propriedades e, em seguida, copie o snippet a seguir e cole-o entre as chaves Propriedades ({}).

   O AWS CloudFormation Designer adicionou automaticamente a associação de grupo de segurança e sub-rede, assim você precisa adicionar apenas as propriedades Listeners e HealthCheck. A propriedade Listeners especifica onde e que tipo de tráfego escutar, e a propriedade HealthCheck descreve as configurações para determinar o estado de integridade do load balancer.

   JSON

             "Listeners": [
             {
               "LoadBalancerPort": "80",
               "InstancePort": "80",
               "Protocol": "HTTP"
             }
           ],
           "HealthCheck": {
             "Target": "HTTP:80/",
             "HealthyThreshold": "3",
             "UnhealthyThreshold": "5",
             "Interval": "90",
             "Timeout": "60"
           },
           "SecurityGroups": [
             {
               "Ref": "PublicLoadBalancerSecurityGroup"
             }
           ],
           "Subnets": [
             {
               "Ref": "PublicSubnet"
             }
           ]

   YAML

         Listeners:
           - LoadBalancerPort: '80'
             InstancePort: '80'
             Protocol: HTTP
         HealthCheck:
           Target: 'HTTP:80/'
           HealthyThreshold: '3'
           UnhealthyThreshold: '5'
           Interval: '90'
           Timeout: '60'
         SecurityGroups:
           - !Ref PublicLoadBalancerSecurityGroup
         Subnets:
           - !Ref PublicSubnet

3. Repita este processo para os recursos a seguir.

   WebServerFleet

   Adicione as propriedades MaxSize, MinSize e DesiredCapacity. Essas propriedades especificam o número máximo e mínimo de instâncias que você pode executar no grupo do Auto Scaling e o número inicial de instâncias. O valor de capacidade desejado refere-se a um novo parâmetro, que adicionaremos posteriormente neste procedimento.

   JSON

           "MinSize": "1",
           "MaxSize": "10",
           "DesiredCapacity": {
             "Ref": "WebServerCount"
           },
           "VPCZoneIdentifier": [
             {
               "Ref": "PublicSubnet"
             }
           ],
           "LaunchConfigurationName": {
             "Ref": "WebServerLaunchConfig"
           },
           "LoadBalancerNames": [
             {
               "Ref": "PublicElasticLoadBalancer"
             }
           ]

   YAML

         MinSize: '1'
         MaxSize: '10'
         DesiredCapacity: !Ref WebServerCount
         VPCZoneIdentifier:
           - !Ref PublicSubnet
         LaunchConfigurationName: !Ref WebServerLaunchConfig
         LoadBalancerNames:
           - !Ref PublicElasticLoadBalancer

   PublicLoadBalancerSecurityGroup

   Adicione as regras de entrada e de saída a seguir, que determinam o tráfego que pode alcançar e deixar o load balancer. As regras permitem que todo o tráfego HTTP alcance e deixe o load balancer.

   JSON

           "GroupDescription": "Public Elastic Load Balancing security group with HTTP access on port 80 from the Internet",
           "SecurityGroupIngress": [
             {
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "CidrIp": "0.0.0.0/0"
             }
           ],
           "SecurityGroupEgress": [
             {
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "CidrIp": "0.0.0.0/0"
             }
           ],
           "VpcId": {
             "Ref": "VPC"
           }

   YAML

         GroupDescription: >-
           Public Elastic Load Balancing security group with HTTP access on port 80
           from the Internet
         SecurityGroupIngress:
           - IpProtocol: tcp
             FromPort: 80
             ToPort: 80
             CidrIp: 0.0.0.0/0
         SecurityGroupEgress:
           - IpProtocol: tcp
             FromPort: 80
             ToPort: 80
             CidrIp: 0.0.0.0/0
         VpcId: !Ref VPC

   WebServerSecurityGroup

   Modifique a regra de entrada HTTP para permitir apenas o tráfego do load balancer.

   JSON

           "GroupDescription": "Allow access from load balancer and SSH traffic",
           "SecurityGroupIngress": [
             {
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "SourceSecurityGroupId": {
                 "Ref": "PublicLoadBalancerSecurityGroup"
               }
             },
             {
               "IpProtocol": "tcp",
               "FromPort": 22,
               "ToPort": 22,
               "CidrIp": {
                 "Ref": "SSHLocation"
               }
             }
           ],
           "VpcId": {
             "Ref": "VPC"
           }

   YAML

         VpcId: !Ref VPC
         GroupDescription: Allow access from load balancer and SSH traffic
         SecurityGroupIngress:
           - IpProtocol: tcp
             FromPort: 80
             ToPort: 80
             SourceSecurityGroupId: !Ref PublicLoadBalancerSecurityGroup
           - IpProtocol: tcp
             FromPort: 22
             ToPort: 22
             CidrIp: !Ref SSHLocation

   WebServerLaunchConfig

   A configuração de execução tem várias propriedades diferentes que você precisa especificar, portanto, vamos destacar apenas algumas delas. As propriedades InstanceType e ImageId usam valores de parâmetro e mapeamento que já foram especificados no modelo. Você especifica o tipo de instância como um valor de parâmetro ao criar uma pilha. O valor ImageId é um mapeamento que é baseado na sua região da pilha e no tipo de instância que você especificou.

   Na propriedade UserData, especificamos os scripts de configuração que são executados depois que a instância está ativa e em execução. As informações de configuração são definidas nos metadados da instância, que adicionaremos na próxima etapa.

   JSON

           "InstanceType": {
             "Ref": "InstanceType"
           },
           "ImageId": {
             "Fn::FindInMap": [
               "AWSRegionArch2AMI",
               {
                 "Ref": "AWS::Region"
               },
               {
                 "Fn::FindInMap": [
                   "AWSInstanceType2Arch",
                   {
                     "Ref": "InstanceType"
                   },
                   "Arch"
                 ]
               }
             ]
           },
           "KeyName": {
             "Ref": "KeyName"
           },
           "AssociatePublicIpAddress": "true",
           "UserData": {
             "Fn::Base64": {
               "Fn::Join": [
                 "",
                 [
                   "#!/bin/bash -xe\n",
                   "yum install -y aws-cfn-bootstrap\n",
                   "# Install the files and packages from the metadata\n",
                   "/opt/aws/bin/cfn-init -v ",
                   "         --stack ",
                   {
                     "Ref": "AWS::StackName"
                   },
                   "         --resource WebServerLaunchConfig ",
                   "         --configsets All ",
                   "         --region ",
                   {
                     "Ref": "AWS::Region"
                   },
                   "\n",
                   "# Signal the status from cfn-init\n",
                   "/opt/aws/bin/cfn-signal -e $? ",
                   "         --stack ",
                   {
                     "Ref": "AWS::StackName"
                   },
                   "         --resource WebServerFleet ",
                   "         --region ",
                   {
                     "Ref": "AWS::Region"
                   },
                   "\n"
                 ]
               ]
             }
           },
           "SecurityGroups": [
             {
               "Ref": "WebServerSecurityGroup"
             }
           ]

   YAML

         InstanceType: !Ref InstanceType
         ImageId: !FindInMap 
           - AWSRegionArch2AMI
           - !Ref 'AWS::Region'
           - !FindInMap 
             - AWSInstanceType2Arch
             - !Ref InstanceType
             - Arch
         KeyName: !Ref KeyName
         AssociatePublicIpAddress: 'true'
         UserData: !Base64 
           'Fn::Join':
             - ''
             - - |
                 #!/bin/bash -xe
               - |
                 yum install -y aws-cfn-bootstrap
               - |
                 # Install the files and packages from the metadata
               - '/opt/aws/bin/cfn-init -v '
               - '         --stack '
               - !Ref 'AWS::StackName'
               - '         --resource WebServerLaunchConfig '
               - '         --configsets All '
               - '         --region '
               - !Ref 'AWS::Region'
               - |+
   
               - |
                 # Signal the status from cfn-init
               - '/opt/aws/bin/cfn-signal -e $? '
               - '         --stack '
               - !Ref 'AWS::StackName'
               - '         --resource WebServerFleet '
               - '         --region '
               - !Ref 'AWS::Region'
               - |+
   
         SecurityGroups:
           - !Ref WebServerSecurityGroup

Adicione os metadados da configuração de execução ao recurso WebServerLaunchConfig, que instrui o script auxiliar cfn-init a iniciar o servidor web e criar uma página web básica.

1. Escolha o recurso WebServerLaunchConfig e depois a guia Metadata (Metadados) no editor integrado.

2. Se você estiver criando seu modelo em JSON: nas chaves Metadata ({}), depois da chave de fechamento AWS::CloudFormation::Designer, adicione uma vírgula (,).

3. Após a propriedade AWS::CloudFormation::Designer, adicione o snippet a seguir, que instrui o script auxiliar cfn-init a iniciar o servidor web e criar uma página web básica.

   JSON

           "AWS::CloudFormation::Init" : {
             "configSets" : {
               "All" : [ "ConfigureSampleApp" ]
             },
             "ConfigureSampleApp" : {
               "packages" : {
                 "yum" : {
                   "httpd" : []
                 }
               },
               "files" : {
                 "/var/www/html/index.html" : {
                   "content" : { "Fn::Join" : ["\n", [
                     "<h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>"
                   ]]},
                   "mode"    : "000644",
                   "owner"   : "root",
                   "group"   : "root"
                 }
               },
               "services" : {
                 "sysvinit" : {
                   "httpd"    : { "enabled" : "true", "ensureRunning" : "true" }
                 }
               }
             }
           }

   YAML

         'AWS::CloudFormation::Init':
           configSets:
             All:
               - ConfigureSampleApp
           ConfigureSampleApp:
             packages:
               yum:
                 httpd: []
             files:
               /var/www/html/index.html:
                 content: !Join 
                   - |+
   
                   - - >-
                       <h1>Congratulations, you have successfully launched the AWS
                       CloudFormation sample.</h1>
                 mode: '000644'
                 owner: root
                 group: root
             services:
               sysvinit:
                 httpd:
                   enabled: 'true'
                   ensureRunning: 'true'

Adicione o parâmetro WebServerCount. Esse parâmetro especifica quantas instâncias serão criadas quando o CloudFormation criar o grupo do Auto Scaling.

1. Selecione uma área aberta na tela do AWS CloudFormation Designer.

2. No painel do editor integrado, escolha a guia Parâmetros.

3. Adicione o parâmetro a seguir no editor integrado. Se você está criando o modelo em JSON, adicione uma vírgula conforme necessário.

   JSON

       "WebServerCount": {
         "Description": "Number of Amazon EC2 instances to launch for the WebServer server",
         "Type": "Number",
         "Default": "1"
       }

   YAML

     WebServerCount:
       Description: Number of Amazon EC2 instances to launch for the WebServer server
       Type: Number
       Default: '1'

Modifique a saída do modelo para mostrar o nome DNS do load balancer.

1. No painel do editor integrado, escolha a guia Saídas.

2. Modifique o JSON para usar o nome DNS do load balancer, como mostrado no snippet a seguir.

   JSON

   {
     "Outputs": {
       "URL": {
         "Value": {
           "Fn::GetAtt": [
             "PublicElasticLoadBalancer",
             "DNSName"
           ]
         },
         "Description": "Newly created application URL"
       }
     }
   }

   Se você está criando seu modelo em YAML, use o snippet a seguir.

   Outputs:
     URL:
       Value: !GetAtt 
         - PublicElasticLoadBalancer
         - DNSName
       Description: Newly created application URL

Na barra de ferramentas do AWS CloudFormation Designer, escolha Validar modelo (ícone da caixa de seleção) para verificar erros de sintaxe no seu modelo.

Visualize e corrija os erros no painel Mensagens e, em seguida, valide o modelo novamente. Se você não visualizar erros, seu modelo é sintaticamente válido.

Na barra de ferramentas do AWS CloudFormation Designer, salve o modelo localmente selecionando o menu Arquivo (o ícone de arquivo) e, em seguida, Salvar.

Na barra de ferramentas do AWS CloudFormation Designer, escolha Criar pilha (o ícone de seta para cima).

O AWS CloudFormation Designer salva o modelo aberto em um bucket do S3 e, em seguida, inicia o Assistente de criação de pilha do CloudFormation. Como modificamos o modelo da pilha BasicWebServerStack, o CloudFormation inicia o assistente de atualização de pilha para ela.

O CloudFormation preenche automaticamente o URL do modelo; escolha Next.

Na seção Pilha, no campo Nome, verifique se o nome da pilha é BasicWebServerStack.

Na seção Parâmetros, use os valores existentes e, em seguida, escolha Próximo.

Para esta demonstração, você não precisa adicionar tags ou especificar configurações avançadas, portanto escolha Próximo.

Certifique-se de que o nome da pilha está correto e, em seguida, selecione Atualizar.

No console do CloudFormation, escolha a pilha BasicWebServerStack.

Escolha Delete Stack.

Na mensagem de confirmação, escolha Sim, excluir.