Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Créez une infrastructure de flotte avec un groupe Amazon EC2 Auto Scaling
Cette section explique comment créer une flotte Amazon EC2 Auto Scaling.
Utilisez le modèle CloudFormation YAML ci-dessous pour créer un groupe Amazon EC2 Auto Scaling (Auto Scaling), un Amazon Virtual Private Cloud (Amazon VPC) avec deux sous-réseaux, un profil d'instance et un rôle d'accès à l'instance. Ils sont nécessaires pour lancer une instance à l'aide d'Auto Scaling dans les sous-réseaux.
Vous devez revoir et mettre à jour la liste des types d'instances en fonction de vos besoins de rendu.
Pour une explication complète des ressources et des paramètres utilisés dans le modèle CloudFormation YAML, consultez la [référence au type de ressource Deadline Cloud](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Deadline.html) dans le *guide de l'AWS CloudFormation utilisateur*.
**Pour créer une flotte Amazon EC2 Auto Scaling**
1. Utilisez l'exemple suivant pour créer un CloudFormation modèle qui définit les `AMIId` paramètres `FarmID``FleetID`, et. Enregistrez le modèle dans un `.YAML` fichier sur votre ordinateur 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. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
Utilisez la CloudFormation console pour créer une pile en suivant les instructions de téléchargement du fichier modèle que vous avez créé. Pour plus d'informations, consultez la section [Création d'une pile sur la CloudFormation console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html) dans le *Guide de AWS CloudFormation l'utilisateur*.
**Note**
Les informations d'identification du rôle IAM associées à l'instance Amazon EC2 de votre travailleur sont disponibles *pour* tous les processus exécutés sur ce travailleur, y compris les tâches. Le travailleur doit avoir le moins de privilèges pour opérer : `deadline:CreateWorker` et `deadline:AssumeFleetRoleForWorker.`
L'agent de travail obtient les informations d'identification pour le rôle de file d'attente et les configure pour les utiliser lors de l'exécution de tâches. Le rôle de profil d'instance Amazon EC2 ne doit pas inclure les autorisations nécessaires à vos tâches.
## Faites évoluer automatiquement votre flotte Amazon EC2 grâce à la fonction de recommandation de dimensionnement de Deadline Cloud
Deadline Cloud s'appuie sur un groupe Amazon EC2 Auto Scaling (Auto Scaling) pour dimensionner automatiquement le parc géré par le client (CMF) Amazon EC2. Vous devez configurer le mode flotte et déployer l'infrastructure requise dans votre compte pour que votre flotte évolue automatiquement. L'infrastructure que vous avez déployée fonctionnera pour toutes les flottes, vous ne devez donc la configurer qu'une seule fois.
Le flux de travail de base est le suivant : vous configurez le mode flotte pour qu'il évolue automatiquement, puis Deadline Cloud envoie un EventBridge événement pour cette flotte chaque fois que la taille recommandée change (un événement contient l'identifiant de la flotte, la taille de flotte recommandée et d'autres métadonnées). Vous aurez une EventBridge règle pour filtrer les événements pertinents et disposerez d'un Lambda pour les consommer. Le Lambda s'intégrera à Amazon EC2 Auto Scaling `AutoScalingGroup` pour dimensionner automatiquement le parc Amazon EC2.
### Réglez le mode flotte sur `EVENT_BASED_AUTO_SCALING`
Configurez votre mode flotte pour`EVENT_BASED_AUTO_SCALING`. Pour ce faire, vous pouvez utiliser la console ou utiliser le AWS CLI pour appeler directement l'`UpdateFleet`API `CreateFleet` or. Une fois le mode configuré, Deadline Cloud commence à envoyer EventBridge des événements chaque fois que la taille de flotte recommandée change.
+ Exemple de `UpdateFleet` commande :
```
aws deadline update-fleet \
--farm-id FARM_ID \
--fleet-id FLEET_ID \
--configuration file://configuration.json
```
+ Exemple de `CreateFleet` commande :
```
aws deadline create-fleet \
--farm-id FARM_ID \
--display-name "Fleet name" \
--max-worker-count 10 \
--configuration file://configuration.json
```
Voici un exemple d'`configuration.json`utilisation dans les commandes CLI ci-dessus (`--configuration file://configuration.json`).
+ Pour activer Auto Scaling sur votre flotte, vous devez régler le mode sur`EVENT_BASED_AUTO_SCALING`.
+ `workerCapabilities`Il s'agit des valeurs par défaut attribuées au CMF lorsque vous l'avez créé. Vous pouvez modifier ces valeurs si vous avez besoin d'augmenter les ressources disponibles pour votre CMF.
Une fois que vous avez configuré le mode flotte, Deadline Cloud commence à émettre des événements de recommandation de taille de flotte pour cette flotte.
```
{
"customerManaged": {
"mode": "EVENT_BASED_AUTO_SCALING",
"workerCapabilities": {
"vCpuCount": {
"min": 1,
"max": 4
},
"memoryMiB": {
"min": 1024,
"max": 4096
},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
}
}
}
```
#### Déployez la pile Auto Scaling à l'aide du CloudFormation modèle
Vous pouvez configurer une EventBridge règle pour filtrer les événements, un Lambda pour consommer les événements et contrôler Auto Scaling, et une file d'attente SQS pour stocker les événements non traités. Utilisez le CloudFormation modèle suivant pour déployer tous les éléments d'une pile. Une fois les ressources déployées avec succès, vous pouvez soumettre une tâche et la flotte augmentera automatiquement.
```
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
```
## Procéder à un bilan de santé de la flotte
Après avoir créé votre flotte, vous devez établir un bilan de santé personnalisé pour vous assurer que votre flotte reste saine et exempte d'instances bloquées afin d'éviter des coûts inutiles. Consultez la section [Déploiement d'un bilan de santé de la flotte Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/cmf_templates) GitHub. Un bilan de santé peut réduire le risque qu'une modification accidentelle de votre configurationAmazon Machine Image, de votre modèle de lancement ou de votre réseau passe inaperçue.