

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 Sie eine Flotteninfrastruktur mit einer Amazon EC2 Auto Scaling Scaling-Gruppe
<a name="create-auto-scaling"></a>

In diesem Abschnitt wird erklärt, wie Sie eine Amazon EC2 Auto Scaling Scaling-Flotte erstellen.

Verwenden Sie die folgende CloudFormation YAML-Vorlage, um eine Amazon EC2 Auto Scaling (Auto Scaling) -Gruppe, eine Amazon Virtual Private Cloud (Amazon VPC) mit zwei Subnetzen, einem Instance-Profil und einer Instance-Zugriffsrolle zu erstellen. Diese sind erforderlich, um die Instance mithilfe von Auto Scaling in den Subnetzen zu starten.

Sie sollten die Liste der Instance-Typen überprüfen und aktualisieren, damit sie Ihren Rendering-Anforderungen entspricht.

Eine vollständige Erläuterung der in der CloudFormation YAML-Vorlage verwendeten Ressourcen und Parameter finden Sie in der [Referenz zum Deadline Cloud-Ressourcentyp](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Deadline.html) im *AWS CloudFormation Benutzerhandbuch*.

**So erstellen Sie eine Amazon EC2 Auto Scaling Scaling-Flotte**

1. Verwenden Sie das folgende Beispiel, um eine CloudFormation Vorlage zu erstellen, die die `AMIId` Parameter `FarmID``FleetID`, und definiert. Speichern Sie die Vorlage in einer `.YAML` Datei auf Ihrem lokalen Computer.

   ```
   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. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

   Verwenden Sie die CloudFormation Konsole, um einen Stack anhand der Anweisungen zum Hochladen der von Ihnen erstellten Vorlagendatei zu erstellen. Weitere Informationen finden Sie im *AWS CloudFormation Benutzerhandbuch* unter [Erstellen eines Stacks auf der CloudFormation Konsole](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html).

**Anmerkung**  
Anmeldeinformationen aus der IAM-Rolle, die an die Amazon EC2 EC2-Instance Ihres Workers angehängt sind, sind für *alle* Prozesse verfügbar, die auf diesem Worker ausgeführt werden, einschließlich Jobs. Der Mitarbeiter sollte über die geringsten Betriebsberechtigungen verfügen: und `deadline:CreateWorker` `deadline:AssumeFleetRoleForWorker.`
Der Worker-Agent ruft die Anmeldeinformationen für die Warteschlangenrolle ab und konfiguriert sie für die Verwendung bei der Ausführung von Jobs. Die Amazon EC2 EC2-Instance-Profilrolle sollte keine Berechtigungen enthalten, die für Ihre Jobs erforderlich sind.

## Skalieren Sie Ihre Amazon EC2 EC2-Flotte automatisch mit der Deadline Cloud-Funktion für Skalierungsempfehlungen
<a name="autoscale-ec2-fleet"></a>

Deadline Cloud nutzt eine Amazon EC2 Auto Scaling (Auto Scaling) -Gruppe, um die vom Kunden verwaltete Amazon EC2 EC2-Flotte (CMF) automatisch zu skalieren. Sie müssen den Flottenmodus konfigurieren und die erforderliche Infrastruktur in Ihrem Konto bereitstellen, damit Ihre Flotte auto skaliert werden kann. Die von Ihnen bereitgestellte Infrastruktur funktioniert für alle Flotten, sodass Sie sie nur einmal einrichten müssen.

Der grundlegende Arbeitsablauf ist: Sie konfigurieren Ihren Flottenmodus so, dass er auto skaliert, und dann sendet Deadline Cloud ein EventBridge Ereignis für diese Flotte aus, wenn sich die empfohlene Flottengröße ändert (ein Ereignis enthält die Flotten-ID, die empfohlene Flottengröße und andere Metadaten). Sie werden eine EventBridge Regel haben, um die relevanten Ereignisse zu filtern, und ein Lambda, um sie zu verarbeiten. Das Lambda wird in Amazon EC2 Auto Scaling integriert, `AutoScalingGroup` um die Amazon EC2 EC2-Flotte automatisch zu skalieren.

### Stellen Sie den Flottenmodus auf `EVENT_BASED_AUTO_SCALING`
<a name="set-fleet-mode"></a>

Konfigurieren Sie Ihren Flottenmodus auf`EVENT_BASED_AUTO_SCALING`. Sie können dazu die Konsole verwenden oder die verwenden, AWS CLI um die `CreateFleet` `UpdateFleet` OR-API direkt aufzurufen. Nachdem der Modus konfiguriert wurde, beginnt Deadline Cloud mit dem Senden von EventBridge Ereignissen, sobald sich die empfohlene Flottengröße ändert.
+ `UpdateFleet`Beispielbefehl: 

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

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

Das Folgende ist ein Beispiel für die `configuration.json` Verwendung in den obigen CLI-Befehlen (`--configuration file://configuration.json`).
+ Um Auto Scaling für Ihre Flotte zu aktivieren, sollten Sie den Modus auf einstellen`EVENT_BASED_AUTO_SCALING`.
+ Dies `workerCapabilities` sind die Standardwerte, die dem CMF bei der Erstellung zugewiesen wurden. Sie können diese Werte ändern, wenn Sie mehr Ressourcen benötigen, die Ihrem CMF zur Verfügung stehen.

 Nachdem Sie den Flottenmodus konfiguriert haben, sendet Deadline Cloud Ereignisse mit Empfehlungen zur Flottengröße für diese Flotte aus.

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

#### Stellen Sie den Auto Scaling Scaling-Stack mithilfe der CloudFormation Vorlage bereit
<a name="deploy-stack"></a>

Sie können eine EventBridge Regel zum Filtern von Ereignissen, ein Lambda zum Verwerten der Ereignisse und zur Steuerung von Auto Scaling und eine SQS-Warteschlange zum Speichern unverarbeiteter Ereignisse einrichten. Verwenden Sie die folgende CloudFormation Vorlage, um alles in einem Stack bereitzustellen. Nachdem Sie die Ressourcen erfolgreich bereitgestellt haben, können Sie einen Auftrag einreichen und die Flotte wird automatisch skaliert.

```
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
```

## Führen Sie einen Flottenzustandscheck durch
<a name="fleet-health-check"></a>

Nachdem Sie Ihre Flotte erstellt haben, sollten Sie einen individuellen Zustandscheck erstellen, um sicherzustellen, dass Ihre Flotte fehlerfrei bleibt und keine blockierten Instanzen auftreten, um unnötige Kosten zu vermeiden. Weitere Informationen finden Sie unter [Bereitstellung eines Deadline Cloud-Flottenzustandschecks](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/cmf_templates). GitHub Eine Integritätsprüfung kann das Risiko verringernAmazon Machine Image, dass eine versehentliche Änderung Ihrer Startvorlage oder Netzwerkkonfiguration unentdeckt ausgeführt wird.