

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Crie uma infraestrutura de frota com um grupo Amazon EC2 Auto Scaling
<a name="create-auto-scaling"></a>

Esta seção explica como criar uma frota do Amazon EC2 Auto Scaling.

Use o modelo CloudFormation YAML abaixo para criar um grupo do Amazon EC2 Auto Scaling (Auto Scaling), uma Amazon Virtual Private Cloud (Amazon VPC) com duas sub-redes, um perfil de instância e uma função de acesso à instância. Eles são necessários para iniciar a instância usando o Auto Scaling nas sub-redes.

Você deve revisar e atualizar a lista de tipos de instância para atender às suas necessidades de renderização.

Para obter uma explicação completa dos recursos e parâmetros usados no modelo CloudFormation YAML, consulte a [referência do tipo de recurso do Deadline Cloud](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Deadline.html) no *Guia do AWS CloudFormation usuário*.

**Para criar uma frota do Amazon EC2 Auto Scaling**

1. Use o exemplo a seguir para criar um CloudFormation modelo que define os `AMIId` parâmetros `FarmID``FleetID`, e. Salve o modelo em um `.YAML` arquivo no seu computador local.

   ```
   AWSTemplateFormatVersion: 2010-09-09
   Description: Amazon Deadline Cloud customer-managed fleet
   Parameters:
     FarmId:
       Type: String
       Description: Farm ID
     FleetId:
       Type: String
       Description: Fleet ID
     AMIId:
       Type: String
       Description: AMI ID for launching workers
   Resources:
     deadlineVPC:
       Type: 'AWS::EC2::VPC'
       Properties:
         CidrBlock: 100.100.0.0/16
     deadlineWorkerSecurityGroup:
       Type: 'AWS::EC2::SecurityGroup'
       Properties:
         GroupDescription: !Join
           - ' '
           - - Security group created for Deadline Cloud workers in the fleet
             - !Ref FleetId
         GroupName: !Join
           - ''
           - - deadlineWorkerSecurityGroup-
             - !Ref FleetId
         SecurityGroupEgress:
           - CidrIp: 0.0.0.0/0
             IpProtocol: '-1'
         SecurityGroupIngress: []
         VpcId: !Ref deadlineVPC
     deadlineIGW:
       Type: 'AWS::EC2::InternetGateway'
       Properties: {}
     deadlineVPCGatewayAttachment:
       Type: 'AWS::EC2::VPCGatewayAttachment'
       Properties:
         VpcId: !Ref deadlineVPC
         InternetGatewayId: !Ref deadlineIGW
     deadlinePublicRouteTable:
       Type: 'AWS::EC2::RouteTable'
       Properties:
         VpcId: !Ref deadlineVPC
     deadlinePublicRoute:
       Type: 'AWS::EC2::Route'
       Properties:
         RouteTableId: !Ref deadlinePublicRouteTable
         DestinationCidrBlock: 0.0.0.0/0
         GatewayId: !Ref deadlineIGW
       DependsOn:
         - deadlineIGW
         - deadlineVPCGatewayAttachment
     deadlinePublicSubnet0:
       Type: 'AWS::EC2::Subnet'
       Properties:
         VpcId: !Ref deadlineVPC
         CidrBlock: 100.100.16.0/22
         AvailabilityZone: !Join
           - ''
           - - !Ref 'AWS::Region'
             - a
     deadlineSubnetRouteTableAssociation0:
       Type: 'AWS::EC2::SubnetRouteTableAssociation'
       Properties:
         RouteTableId: !Ref deadlinePublicRouteTable
         SubnetId: !Ref deadlinePublicSubnet0
     deadlinePublicSubnet1:
       Type: 'AWS::EC2::Subnet'
       Properties:
         VpcId: !Ref deadlineVPC
         CidrBlock: 100.100.20.0/22
         AvailabilityZone: !Join
           - ''
           - - !Ref 'AWS::Region'
             - c
     deadlineSubnetRouteTableAssociation1:
       Type: 'AWS::EC2::SubnetRouteTableAssociation'
       Properties:
         RouteTableId: !Ref deadlinePublicRouteTable
         SubnetId: !Ref deadlinePublicSubnet1
     deadlineInstanceAccessAccessRole:
       Type: 'AWS::IAM::Role'
       Properties:
         RoleName: !Join
           - '-'
           - - deadline
             - InstanceAccess
             - !Ref FleetId
         AssumeRolePolicyDocument:
           Statement:
             - Effect: Allow
               Principal:
                 Service: ec2.amazonaws.com
               Action:
                 - 'sts:AssumeRole'
         Path: /     
         ManagedPolicyArns:
           - 'arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy'
           - 'arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore'
           - 'arn:aws:iam::aws:policy/AWSDeadlineCloud-WorkerHost'  
     deadlineInstanceProfile:
       Type: 'AWS::IAM::InstanceProfile'
       Properties:
         Path: /
         Roles:
           - !Ref deadlineInstanceAccessAccessRole
     deadlineLaunchTemplate:
       Type: 'AWS::EC2::LaunchTemplate'
       Properties:
         LaunchTemplateName: !Join
           - ''
           - - deadline-LT-
             - !Ref FleetId
         LaunchTemplateData:
           NetworkInterfaces:
             - DeviceIndex: 0
               AssociatePublicIpAddress: true
               Groups:
                 - !Ref deadlineWorkerSecurityGroup
               DeleteOnTermination: true
           ImageId: !Ref AMIId
           InstanceInitiatedShutdownBehavior: terminate
           IamInstanceProfile:
             Arn: !GetAtt
               - deadlineInstanceProfile
               - Arn
           MetadataOptions:
             HttpTokens: required
             HttpEndpoint: enabled
   
     deadlineAutoScalingGroup:
       Type: 'AWS::AutoScaling::AutoScalingGroup'
       Properties:
         AutoScalingGroupName: !Join
           - ''
           - - deadline-ASG-autoscalable-
             - !Ref FleetId
         MinSize: 0
         MaxSize: 10
         VPCZoneIdentifier:
           - !Ref deadlinePublicSubnet0
           - !Ref deadlinePublicSubnet1
         NewInstancesProtectedFromScaleIn: true
         MixedInstancesPolicy:
           InstancesDistribution:
             OnDemandBaseCapacity: 0
             OnDemandPercentageAboveBaseCapacity: 0
             SpotAllocationStrategy: capacity-optimized
             OnDemandAllocationStrategy: lowest-price
           LaunchTemplate:
             LaunchTemplateSpecification:
               LaunchTemplateId: !Ref deadlineLaunchTemplate
               Version: !GetAtt
                 - deadlineLaunchTemplate
                 - LatestVersionNumber
             Overrides:
               - InstanceType: m5.large
               - InstanceType: m5d.large
               - InstanceType: m5a.large
               - InstanceType: m5ad.large
               - InstanceType: m5n.large
               - InstanceType: m5dn.large
               - InstanceType: m4.large
               - InstanceType: m3.large
               - InstanceType: r5.large
               - InstanceType: r5d.large
               - InstanceType: r5a.large
               - InstanceType: r5ad.large
               - InstanceType: r5n.large
               - InstanceType: r5dn.large
               - InstanceType: r4.large
         MetricsCollection:
           - Granularity: 1Minute
             Metrics:
               - GroupMinSize
               - GroupMaxSize
               - GroupDesiredCapacity
               - GroupInServiceInstances
               - GroupTotalInstances
               - GroupInServiceCapacity
               - GroupTotalCapacity
   ```

1. Abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

   Use o CloudFormation console para criar uma pilha usando as instruções para carregar o arquivo de modelo que você criou. Para obter mais informações, consulte [Criação de uma pilha no CloudFormation console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html) no *Guia do AWS CloudFormation usuário*.

**nota**  
As credenciais da função do IAM que estão anexadas à instância do Amazon EC2 do seu trabalhador estão disponíveis *para* todos os processos em execução nesse trabalhador, o que inclui trabalhos. O trabalhador deve ter o mínimo de privilégios para operar: `deadline:CreateWorker` e `deadline:AssumeFleetRoleForWorker.`
O agente de trabalho obtém as credenciais para a função de fila e as configura para uso na execução de trabalhos. A função do perfil da instância do Amazon EC2 não deve incluir as permissões necessárias para seus trabalhos.

## Escale automaticamente sua frota do Amazon EC2 com o recurso de recomendação de escala Deadline Cloud
<a name="autoscale-ec2-fleet"></a>

O Deadline Cloud utiliza um grupo do Amazon EC2 Auto Scaling (Auto Scaling) para escalar automaticamente a frota gerenciada pelo cliente (CMF) do Amazon EC2. Você precisa configurar o modo de frota e implantar a infraestrutura necessária em sua conta para que sua frota seja dimensionada automaticamente. A infraestrutura que você implantou funcionará para todas as frotas, então você só precisa configurá-la uma vez.

O fluxo de trabalho básico é: você configura seu modo de frota para escalar automaticamente e, em seguida, o Deadline Cloud enviará um EventBridge evento para essa frota sempre que o tamanho recomendado da frota mudar (um evento contém o ID da frota, o tamanho recomendado da frota e outros metadados). Você terá uma EventBridge regra para filtrar os eventos relevantes e ter um Lambda para consumi-los. O Lambda se integrará ao Amazon EC2 Auto `AutoScalingGroup` Scaling para escalar automaticamente a frota do Amazon EC2.

### Defina o modo de frota como `EVENT_BASED_AUTO_SCALING`
<a name="set-fleet-mode"></a>

Configure seu modo de frota para`EVENT_BASED_AUTO_SCALING`. Você pode usar o console para fazer isso ou usar o AWS CLI para chamar diretamente a `UpdateFleet` API `CreateFleet` ou. Depois que o modo é configurado, o Deadline Cloud começa a enviar EventBridge eventos sempre que o tamanho recomendado da frota mudar.
+ Exemplo de `UpdateFleet` comando: 

  ```
  aws deadline update-fleet \
    --farm-id FARM_ID \
    --fleet-id FLEET_ID \
    --configuration file://configuration.json
  ```
+ Exemplo de `CreateFleet` comando: 

  ```
  aws deadline create-fleet \
    --farm-id FARM_ID \
    --display-name "Fleet name" \
    --max-worker-count 10 \
    --configuration file://configuration.json
  ```

A seguir está um exemplo de `configuration.json` uso nos comandos da CLI acima ()`--configuration file://configuration.json`.
+ Para ativar o Auto Scaling em sua frota, você deve definir o modo como. `EVENT_BASED_AUTO_SCALING`
+ Esses `workerCapabilities` são os valores padrão atribuídos ao CMF quando você o criou. Você pode alterar esses valores se precisar aumentar os recursos disponíveis para seu CMF.

 Depois de configurar o modo de frota, o Deadline Cloud começa a emitir eventos de recomendação de tamanho de frota para essa frota.

```
{
    "customerManaged": {
        "mode": "EVENT_BASED_AUTO_SCALING",       
        "workerCapabilities": {
            "vCpuCount": {
                "min": 1,
                "max": 4
            },
            "memoryMiB": {
                "min": 1024,
                "max": 4096
            },
            "osFamily": "linux",
            "cpuArchitectureType": "x86_64"
        }
    }
}
```

#### Implante a pilha de Auto Scaling usando o modelo CloudFormation
<a name="deploy-stack"></a>

Você pode configurar uma EventBridge regra para filtrar eventos, um Lambda para consumir os eventos e controlar o Auto Scaling e uma fila SQS para armazenar eventos não processados. Use o CloudFormation modelo a seguir para implantar tudo em uma pilha. Depois de implantar os recursos com sucesso, você pode enviar um trabalho e a frota aumentará automaticamente.

```
Resources:
  AutoScalingLambda:
    Type: 'AWS::Lambda::Function'
    Properties:
      Code:
        ZipFile: |-
          """
          This lambda is configured to handle "Fleet Size Recommendation Change"
          messages. It will handle all such events, and requires
          that the ASG is named based on the fleet id. It will scale up/down the fleet
          based on the recommended fleet size in the message.
          
          Example EventBridge message:
          {
              "version": "0",
              "id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718",
              "detail-type": "Fleet Size Recommendation Change",
              "source": "aws.deadline",
              "account": "111122223333",
              "time": "2017-12-22T18:43:48Z",
              "region": "us-west-1",
              "resources": [],
              "detail": {
                  "farmId": "farm-12345678900000000000000000000000",
                  "fleetId": "fleet-12345678900000000000000000000000",
                  "oldFleetSize": 1,
                  "newFleetSize": 5,
              }
          }
          """
          
          import json
          import boto3
          import logging

          logger = logging.getLogger()
          logger.setLevel(logging.INFO)

          auto_scaling_client = boto3.client("autoscaling")

          def lambda_handler(event, context):
              logger.info(event)
              event_detail = event["detail"]
              fleet_id = event_detail["fleetId"]
              desired_capacity = event_detail["newFleetSize"]

              asg_name = f"deadline-ASG-autoscalable-{fleet_id}"
              auto_scaling_client.set_desired_capacity(
                  AutoScalingGroupName=asg_name,
                  DesiredCapacity=desired_capacity,
                  HonorCooldown=False,
              )

              return {
                  'statusCode': 200,
                  'body': json.dumps(f'Successfully set desired_capacity for {asg_name} to {desired_capacity}')
              }
      Handler: index.lambda_handler
      Role: !GetAtt 
        - AutoScalingLambdaServiceRole
        - Arn
      Runtime: python3.11
    DependsOn:
      - AutoScalingLambdaServiceRoleDefaultPolicy
      - AutoScalingLambdaServiceRole
  AutoScalingEventRule:
    Type: 'AWS::Events::Rule'
    Properties:
      EventPattern:
        source:
          - aws.deadline
        detail-type:
          - Fleet Size Recommendation Change
      State: ENABLED
      Targets:
        - Arn: !GetAtt 
            - AutoScalingLambda
            - Arn
          DeadLetterConfig:
            Arn: !GetAtt 
              - UnprocessedAutoScalingEventQueue
              - Arn
          Id: Target0
          RetryPolicy:
            MaximumRetryAttempts: 15
  AutoScalingEventRuleTargetPermission:
    Type: 'AWS::Lambda::Permission'
    Properties:
      Action: 'lambda:InvokeFunction'
      FunctionName: !GetAtt 
        - AutoScalingLambda
        - Arn
      Principal: events.amazonaws.com
      SourceArn: !GetAtt 
        - AutoScalingEventRule
        - Arn
  AutoScalingLambdaServiceRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action: 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
        Version: 2012-10-17
      ManagedPolicyArns:
        - !Join 
          - ''
          - - 'arn:'
            - !Ref 'AWS::Partition'
            - ':iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
  AutoScalingLambdaServiceRoleDefaultPolicy:
    Type: 'AWS::IAM::Policy'
    Properties:
      PolicyDocument:
        Statement:
          - Action: 'autoscaling:SetDesiredCapacity'
            Effect: Allow
            Resource: '*'
        Version: 2012-10-17
      PolicyName: AutoScalingLambdaServiceRoleDefaultPolicy
      Roles:
        - !Ref AutoScalingLambdaServiceRole
  UnprocessedAutoScalingEventQueue:
    Type: 'AWS::SQS::Queue'
    Properties:
      QueueName: deadline-unprocessed-autoscaling-events
    UpdateReplacePolicy: Delete
    DeletionPolicy: Delete
  UnprocessedAutoScalingEventQueuePolicy:
    Type: 'AWS::SQS::QueuePolicy'
    Properties:
      PolicyDocument:
        Statement:
          - Action: 'sqs:SendMessage'
            Condition:
              ArnEquals:
                'aws:SourceArn': !GetAtt 
                  - AutoScalingEventRule
                  - Arn
            Effect: Allow
            Principal:
              Service: events.amazonaws.com
            Resource: !GetAtt 
              - UnprocessedAutoScalingEventQueue
              - Arn
        Version: 2012-10-17
      Queues:
        - !Ref UnprocessedAutoScalingEventQueue
```

## Realize uma verificação de integridade da frota
<a name="fleet-health-check"></a>

Depois de criar sua frota, você deve criar uma verificação de saúde personalizada para garantir que sua frota permaneça íntegra e livre de instâncias paralisadas para ajudar a evitar custos desnecessários. Consulte [Implantação de uma verificação de integridade da frota do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/cmf_templates). GitHub Uma verificação de integridade pode reduzir o risco de uma alteração acidental em seu Amazon Machine Image modelo de lançamento ou configuração de rede ser executada sem ser detectada.