Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Cree una infraestructura de flota con un grupo de Amazon EC2 Auto Scaling
En esta sección se explica cómo crear una flota de Amazon EC2 Auto Scaling.
Utilice la plantilla CloudFormation YAML que aparece a continuación para crear un grupo de Amazon EC2 Auto Scaling (Auto Scaling), una Amazon Virtual Private Cloud (Amazon VPC) con dos subredes, un perfil de instancia y un rol de acceso a la instancia. Son necesarios para lanzar la instancia mediante Auto Scaling en las subredes.
Deberías revisar y actualizar la lista de tipos de instancias para adaptarla a tus necesidades de renderización.
Para obtener una explicación completa de los recursos y parámetros utilizados en la plantilla CloudFormation YAML, consulta la [referencia sobre los tipos de recursos de Deadline Cloud](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Deadline.html) en la *Guía del AWS CloudFormation usuario*.
**Para crear una flota de Amazon EC2 Auto Scaling**
1. Utilice el siguiente ejemplo para crear una CloudFormation plantilla que defina `FarmID` los `FleetID` `AMIId` parámetros y. Guarde la plantilla en un `.YAML` archivo de su equipo 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. Abre la CloudFormation consola en [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
Usa la CloudFormation consola para crear una pila siguiendo las instrucciones para cargar el archivo de plantilla que has creado. Para obtener más información, consulte [Crear una pila en la CloudFormation consola](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html) en la *Guía del AWS CloudFormation usuario*.
**nota**
Las credenciales del rol de IAM asociadas a la instancia Amazon EC2 del trabajador están disponibles *para* todos los procesos que se ejecutan en ese trabajador, incluidos los trabajos. El trabajador debe tener el mínimo de privilegios para operar: y `deadline:CreateWorker` `deadline:AssumeFleetRoleForWorker.`
El agente de trabajo obtiene las credenciales para la función de cola y las configura para que las utilice en la ejecución de trabajos. El rol del perfil de instancia de Amazon EC2 no debe incluir los permisos que necesitan sus trabajos.
## Amplíe automáticamente su flota de Amazon EC2 con la función de recomendación de escalado de Deadline Cloud
Deadline Cloud aprovecha un grupo de Amazon EC2 Auto Scaling (Auto Scaling) para escalar automáticamente la flota gestionada por el cliente (CMF) de Amazon EC2. Debe configurar el modo de flota e implementar la infraestructura requerida en su cuenta para que su flota se escale automáticamente. La infraestructura que implementaste funcionará en todas las flotas, por lo que solo tendrás que configurarla una vez.
El flujo de trabajo básico consiste en configurar el modo de flota para que se escale automáticamente y, a continuación, Deadline Cloud enviará un EventBridge evento para esa flota cada vez que cambie el tamaño de la flota recomendado (un evento contiene el identificador de la flota, el tamaño de la flota recomendado y otros metadatos). Dispondrá de una EventBridge regla para filtrar los eventos relevantes y dispondrá de una Lambda para consumirlos. La Lambda se integrará con Amazon EC2 Auto Scaling `AutoScalingGroup` para escalar automáticamente la flota de Amazon EC2.
### Configure el modo de flota en `EVENT_BASED_AUTO_SCALING`
Configura tu modo de flota para`EVENT_BASED_AUTO_SCALING`. Para ello, puede utilizar la consola o utilizar la AWS CLI para llamar directamente a la `UpdateFleet` API `CreateFleet` o. Una vez configurado el modo, Deadline Cloud comienza a enviar EventBridge eventos cada vez que cambia el tamaño de flota recomendado.
+ Ejemplo de `UpdateFleet` comando:
```
aws deadline update-fleet \
--farm-id FARM_ID \
--fleet-id FLEET_ID \
--configuration file://configuration.json
```
+ Ejemplo de `CreateFleet` comando:
```
aws deadline create-fleet \
--farm-id FARM_ID \
--display-name "Fleet name" \
--max-worker-count 10 \
--configuration file://configuration.json
```
El siguiente es un ejemplo del `configuration.json` uso en los comandos CLI anteriores (`--configuration file://configuration.json`).
+ Para activar Auto Scaling en su flota, debe configurar el modo en`EVENT_BASED_AUTO_SCALING`.
+ Estos `workerCapabilities` son los valores predeterminados que se asignaron al CMF cuando lo creó. Puede cambiar estos valores si necesita aumentar los recursos disponibles para su CMF.
Después de configurar el modo de flota, Deadline Cloud comienza a emitir eventos de recomendación sobre el tamaño de la flota para esa flota.
```
{
"customerManaged": {
"mode": "EVENT_BASED_AUTO_SCALING",
"workerCapabilities": {
"vCpuCount": {
"min": 1,
"max": 4
},
"memoryMiB": {
"min": 1024,
"max": 4096
},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
}
}
}
```
#### Implemente la pila de Auto Scaling mediante la CloudFormation plantilla
Puede configurar una EventBridge regla para filtrar los eventos, una Lambda para consumir los eventos y controlar Auto Scaling y una cola SQS para almacenar los eventos sin procesar. Utilice la siguiente CloudFormation plantilla para implementar todo en una pila. Una vez que hayas desplegado los recursos correctamente, puedes enviar un trabajo y la flota se ampliará automáticamente.
```
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
```
## Realice un chequeo del estado de la flota
Después de crear tu flota, debes crear un chequeo de estado personalizado para asegurarte de que tu flota se mantenga en buen estado y libre de atascos, a fin de evitar costes innecesarios. Consulte Cómo [implementar una revisión del estado de la flota en GitHub Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/cmf_templates). Un chequeo de estado puede reducir el riesgo de que un cambio accidental en su configuraciónAmazon Machine Image, plantilla de lanzamiento o red pase desapercibido.