Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Crea un'infrastruttura per il parco veicoli con un gruppo Amazon EC2 Auto Scaling
Questa sezione spiega come creare una flotta Amazon EC2 Auto Scaling.
Utilizza il modello CloudFormation YAML riportato di seguito per creare un gruppo Amazon EC2 Auto Scaling (Auto Scaling), un Amazon Virtual Private Cloud (Amazon VPC) con due sottoreti, un profilo di istanza e un ruolo di accesso all'istanza. Questi sono necessari per avviare l'istanza utilizzando Auto Scaling nelle sottoreti.
È necessario rivedere e aggiornare l'elenco dei tipi di istanze per adattarlo alle proprie esigenze di rendering.
*Per una spiegazione completa delle risorse e dei parametri utilizzati nel modello CloudFormation YAML, consulta il [riferimento al tipo di risorsa Deadline Cloud](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Deadline.html) nella Guida per l'AWS CloudFormation utente.*
**Per creare una flotta Amazon EC2 Auto Scaling**
1. Usa l'esempio seguente per creare un CloudFormation modello che definisca i parametri `FarmID``FleetID`, e`AMIId`. Salvate il modello in un `.YAML` file sul computer locale.
```
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. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
Usa la CloudFormation console per creare uno stack utilizzando le istruzioni per caricare il file modello che hai creato. *Per ulteriori informazioni, consulta [Creazione di uno stack sulla CloudFormation console nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html) per l'AWS CloudFormation utente.*
**Nota**
Le credenziali del ruolo IAM collegate all'istanza Amazon EC2 del lavoratore sono disponibili *per* tutti i processi in esecuzione su quel lavoratore, compresi i job. Il lavoratore deve avere i privilegi minimi per operare: e `deadline:CreateWorker` `deadline:AssumeFleetRoleForWorker.`
L'agente di lavoro ottiene le credenziali per il ruolo di coda e le configura per l'utilizzo da parte dell'esecuzione dei job. Il ruolo del profilo dell'istanza Amazon EC2 non dovrebbe includere le autorizzazioni necessarie per i tuoi lavori.
## Ridimensiona automaticamente la tua flotta Amazon EC2 con la funzionalità di raccomandazione di scalabilità Deadline Cloud
Deadline Cloud sfrutta un gruppo Amazon EC2 Auto Scaling (Auto Scaling) per scalare automaticamente la flotta gestita dai clienti (CMF) di Amazon EC2. Devi configurare la modalità flotta e implementare l'infrastruttura richiesta nel tuo account per far sì che la tua flotta si ridimensioni automaticamente. L'infrastruttura che hai implementato funzionerà per tutte le flotte, quindi dovrai configurarla una sola volta.
Il flusso di lavoro di base è: configuri la modalità flotta per la scalabilità automatica, quindi Deadline Cloud invierà un EventBridge evento per quella flotta ogni volta che la dimensione della flotta consigliata cambia (un evento contiene l'ID della flotta, la dimensione della flotta consigliata e altri metadati). Avrai una EventBridge regola per filtrare gli eventi rilevanti e avrai una Lambda per consumarli. Lambda si integrerà con Amazon EC2 Auto `AutoScalingGroup` Scaling per scalare automaticamente la flotta Amazon EC2.
### Imposta la modalità flotta su `EVENT_BASED_AUTO_SCALING`
Configura la modalità flotta su`EVENT_BASED_AUTO_SCALING`. Puoi utilizzare la console per eseguire questa operazione oppure utilizzare la AWS CLI per chiamare direttamente l'`UpdateFleet`API `CreateFleet` or. Dopo aver configurato la modalità, Deadline Cloud inizia a inviare EventBridge eventi ogni volta che la dimensione della flotta consigliata cambia.
+ `UpdateFleet`Comando di esempio:
```
aws deadline update-fleet \
--farm-id FARM_ID \
--fleet-id FLEET_ID \
--configuration file://configuration.json
```
+ `CreateFleet`Comando di esempio:
```
aws deadline create-fleet \
--farm-id FARM_ID \
--display-name "Fleet name" \
--max-worker-count 10 \
--configuration file://configuration.json
```
Di seguito è riportato un esempio di `configuration.json` utilizzo dei comandi CLI precedenti ()`--configuration file://configuration.json`.
+ Per abilitare Auto Scaling sulla tua flotta, devi impostare la modalità su. `EVENT_BASED_AUTO_SCALING`
+ `workerCapabilities`Sono i valori predefiniti assegnati al CMF al momento della sua creazione. È possibile modificare questi valori se è necessario aumentare le risorse disponibili per il CMF.
Dopo aver configurato la modalità flotta, Deadline Cloud inizia a emettere eventi di raccomandazione sulle dimensioni della flotta per quella flotta.
```
{
"customerManaged": {
"mode": "EVENT_BASED_AUTO_SCALING",
"workerCapabilities": {
"vCpuCount": {
"min": 1,
"max": 4
},
"memoryMiB": {
"min": 1024,
"max": 4096
},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
}
}
}
```
#### Implementa lo stack Auto Scaling utilizzando il modello CloudFormation
Puoi impostare una EventBridge regola per filtrare gli eventi, una Lambda per consumare gli eventi e controllare l'Auto Scaling e una coda SQS per archiviare gli eventi non elaborati. Usa il seguente CloudFormation modello per distribuire tutto in uno stack. Dopo aver distribuito correttamente le risorse, puoi inviare un lavoro e la flotta aumenterà 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
```
## Esegui un controllo dello stato della flotta
Dopo aver creato la tua flotta, dovresti creare un controllo sanitario personalizzato per assicurarti che la flotta rimanga integra e priva di istanze bloccate per evitare costi inutili. Vedi [Implementazione di un controllo dello stato della flotta Deadline Cloud su](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/cmf_templates). GitHub Un controllo dello stato di salute può ridurre il rischio che una modifica accidentale della configurazione di reteAmazon Machine Image, del modello di lancio o della configurazione di rete venga eseguita inosservata.