amazon-web-services - east - aws tags

¿Cómo crear un número variable de recursos de instancia de EC2 en la plantilla de Cloudformation?

Question

¿Cómo crear un número variable de recursos de instancia de EC2 en la plantilla de Cloudformation, de acuerdo con un parámetro de plantilla?

La API de EC2 y las herramientas de administración permiten iniciar varias instancias de la misma AMI, pero no puedo encontrar la forma de hacerlo utilizando Cloudformation.

Answer 1

Creo que lo que buscaba el cartel original es algo así como:

"Parameters" : {
"InstanceCount" : {
"Description" : "Number of instances to start",
"Type" : "String"
},

...

"MyAutoScalingGroup" : {
"Type" : "AWS::AutoScaling::AutoScalingGroup",
"Properties" : {
"AvailabilityZones" : {"Fn::GetAZs" : ""},
"LaunchConfigurationName" : { "Ref" : "MyLaunchConfiguration" },
"MinSize" : "1",
"MaxSize" : "2",
"DesiredCapacity" : **{ "Ref" : "InstanceCount" }**,
}
},

... en otras palabras, inserte el número de instancias iniciales (la capacidad) de un parámetro.

Answer 2

La respuesta corta es: no puedes. No puede obtener exactamente el mismo resultado (N instancias EC2 idénticas, no vinculadas por un grupo de escalado automático).

Lanzar varias instancias por igual desde la consola no es como crear un grupo de escalado automático con N instancias como capacidad deseada. Es solo un atajo útil que tienes, en lugar de tener que pasar N veces por el mismo proceso de creación de EC2. Se llama "una reserva" (sin relación con la instancia reservada). Los grupos de escalado automático son una bestia diferente (aunque termine con N instancias EC2 idénticas).

Tu también puedes:

• duplicar (yuk) el recurso EC2 en la plantilla
• use una plantilla anidada, que hará la creación de EC2 por sí misma, y ​​la llamará N veces desde su pila maestra, alimentándola cada vez con los mismos parámetros

El problema es que el número de instancias de EC2 no será dinámico, no puede ser un parámetro.

• use una interfaz para las plantillas de CloudFormation, como la troposfera, que le permite escribir la descripción de EC2 dentro de una función, y llamar a la función N veces (mi elección ahora). Al final, tienes una plantilla de CloudFormation que hace el trabajo, pero has escrito el código de creación EC2 solo una vez. No es un parámetro de CloudFormation real , pero al final del día, obtienes tu número dinámico de EC2.

Answer 3

Mientras tanto, hay muchas Plantillas de ejemplo de AWS CloudFormation disponibles, y varias incluyen el lanzamiento de varias instancias, aunque generalmente muestran otras características en paralelo; por ejemplo, AutoScalingKeepAtNSample.template crea un sitio web de muestra con AutoScalingKeepAtNSample.template carga y AutoScalingKeepAtNSample.template automática y está configurado para iniciar 2 instancias de EC2 para este propósito según este extracto de plantilla:

"WebServerGroup": {
"Type": "AWS::AutoScaling::AutoScalingGroup",
"Properties": {
"AvailabilityZones": {
"Fn::GetAZs": ""
},
"LaunchConfigurationName": {
"Ref": "LaunchConfig"
},
"MinSize": "2",
"MaxSize": "2",
"LoadBalancerNames": [
{
"Ref": "ElasticLoadBalancer"
}
]
}
},

También hay más muestras avanzadas / completas disponibles, por ejemplo, la plantilla Drupal para un servidor web de alta disponibilidad con una instancia de base de datos Multi-AZ Amazon RDS y el uso de S3 para almacenar el contenido del archivo , que actualmente está configurado para permitir hablar de 1 a 5 instancias de servidor web a una instancia de base de datos de Amazon RDS MySQL Multi-AZ y ejecutándose detrás de un Elastic Load Balancer , que organiza las instancias del servidor web a través de Auto Scaling .

Answer 4

Utilice la función Ref .

http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-ref.html

Las variables definidas por el usuario se definen en la sección "Parameters" del archivo de configuración. En la sección "Resources" del archivo de configuración puede completar valores utilizando referencias a estos parámetros.

{
"AWSTemplateFormatVersion": "2010-09-09",
...
"Parameters": {
"MinNumInstances": {
"Type": "Number",
"Description": "Minimum number of instances to run.",
"Default": "1",
"ConstraintDescription": "Must be an integer less than MaxNumInstances."
},
"MaxNumInstances": {
"Type": "Number",
"Description": "Maximum number of instances to run.",
"Default": "5",
"ConstraintDescription": "Must be an integer greater than MinNumInstances."
},
"DesiredNumInstances": {
"Type": "Number",
"Description": "Number of instances that need to be running before creation is marked as complete in CloudFormation management console.",
"Default": "1",
"ConstraintDescription": "Must be an integer in the range specified by MinNumInstances..MaxNumInstances."
}
},
"Resources": {
"MyAutoScalingGroup": {
"Type": "AWS::AutoScaling::AutoScalingGroup",
"Properties": {
...
"MinSize": { "Ref": "MinNumInstances" },
"MaxSize": { "Ref": "MaxNumInstances" },
"DesiredCapacity": { "Ref": "DesiredNumInstances" },
...
},
},
...
},
...
}

En el ejemplo anterior, { "Ref": ... } se usa para llenar valores en la plantilla. En este caso, proporcionamos enteros como valores para "MinSize" y "MaxSize" .

Answer 5

AWS::EC2::Instance Resource no admite los parámetros MinCount / MaxCount de la API RunInstances subyacente, por lo que no es posible crear un número variable de instancias de EC2 pasando Parámetros a una sola copia de este Recurso.

Para crear un número variable de recursos de instancia de EC2 en la plantilla de CloudFormation de acuerdo con un Parámetro de plantilla, y sin implementar un Grupo de Auto Escalado, existen dos opciones:

1. Condiciones

Puede usar las Conditions para crear un número variable de Recursos de AWS::EC2::Instance en función del Parámetro.

Es un poco detallado (porque tienes que usar Fn::Equals ), pero funciona.

Este es un ejemplo práctico que permite al usuario especificar hasta un máximo de 5 instancias:

Description: Create a variable number of EC2 instance resources.
Parameters:
InstanceCount:
Description: Number of EC2 instances (must be between 1 and 5).
Type: Number
Default: 1
MinValue: 1
MaxValue: 5
ConstraintDescription: Must be a number between 1 and 5.
ImageId:
Description: Image ID to launch EC2 instances.
Type: AWS::EC2::Image::Id
# amzn-ami-hvm-2016.09.1.20161221-x86_64-gp2
Default: ami-9be6f38c
InstanceType:
Description: Instance type to launch EC2 instances.
Type: String
Default: m3.medium
AllowedValues: [ m3.medium, m3.large, m3.xlarge, m3.2xlarge ]
Conditions:
Launch1: !Equals [1, 1]
Launch2: !Not [!Equals [1, !Ref InstanceCount]]
Launch3: !Or
- !Not [!Equals [1, !Ref InstanceCount]]
- !Not [!Equals [2, !Ref InstanceCount]]
Launch4: !Or
- !Equals [4, !Ref InstanceCount]
- !Equals [5, !Ref InstanceCount]
Launch5: !Equals [5, !Ref InstanceCount]
Resources:
Instance1:
Condition: Launch1
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref ImageId
InstanceType: !Ref InstanceType
Instance2:
Condition: Launch2
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref ImageId
InstanceType: !Ref InstanceType
Instance3:
Condition: Launch3
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref ImageId
InstanceType: !Ref InstanceType
Instance4:
Condition: Launch4
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref ImageId
InstanceType: !Ref InstanceType
Instance5:
Condition: Launch5
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref ImageId
InstanceType: !Ref InstanceType

1a. Preprocesador de plantillas con condiciones

Como una variación de lo anterior, puede usar un preprocesador de plantillas como el Erb de Ruby para generar la plantilla anterior basada en un máximo específico, haciendo que su código fuente sea más compacto y eliminando la duplicación:

<%max = 10-%>
Description: Create a variable number of EC2 instance resources.
Parameters:
InstanceCount:
Description: Number of EC2 instances (must be between 1 and <%=max%>).
Type: Number
Default: 1
MinValue: 1
MaxValue: <%=max%>
ConstraintDescription: Must be a number between 1 and <%=max%>.
ImageId:
Description: Image ID to launch EC2 instances.
Type: AWS::EC2::Image::Id
# amzn-ami-hvm-2016.09.1.20161221-x86_64-gp2
Default: ami-9be6f38c
InstanceType:
Description: Instance type to launch EC2 instances.
Type: String
Default: m3.medium
AllowedValues: [ m3.medium, m3.large, m3.xlarge, m3.2xlarge ]
Conditions:
Launch1: !Equals [1, 1]
Launch2: !Not [!Equals [1, !Ref InstanceCount]]
<%(3..max-1).each do |x|
low = (max-1)/(x-1) <= 1-%>
Launch<%=x%>: !Or
<% (1..max).each do |i|
if low && i >= x-%>
- !Equals [<%=i%>, !Ref InstanceCount]
<% elsif !low && i < x-%>
- !Not [!Equals [<%=i%>, !Ref InstanceCount]]
<% end
end
end-%>
Launch<%=max%>: !Equals [<%=max%>, !Ref InstanceCount]
Resources:
<%(1..max).each do |x|-%>
Instance<%=x%>:
Condition: Launch<%=x%>
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref ImageId
InstanceType: !Ref InstanceType
<%end-%>

Para procesar la fuente anterior en una plantilla compatible con CloudFormation, ejecute:

ruby -rerb -e "puts ERB.new(ARGF.read, nil, ''-'').result" < template.yml > template-out.yml

Para su comodidad, aquí hay una idea general del YAML de salida generado para 10 instancias de EC2 variables .

2. Recurso personalizado

Un enfoque alternativo es implementar un recurso personalizado que llame directamente a las API RunInstances / TerminateInstances :

Description: Create a variable number of EC2 instance resources.
Parameters:
InstanceCount:
Description: Number of EC2 instances (must be between 1 and 10).
Type: Number
Default: 1
MinValue: 1
MaxValue: 10
ConstraintDescription: Must be a number between 1 and 10.
ImageId:
Description: Image ID to launch EC2 instances.
Type: AWS::EC2::Image::Id
# amzn-ami-hvm-2016.09.1.20161221-x86_64-gp2
Default: ami-9be6f38c
InstanceType:
Description: Instance type to launch EC2 instances.
Type: String
Default: m3.medium
AllowedValues: [ m3.medium, m3.large, m3.xlarge, m3.2xlarge ]
Resources:
EC2Instances:
Type: Custom::EC2Instances
Properties:
ServiceToken: !GetAtt EC2InstancesFunction.Arn
ImageId: !Ref ImageId
InstanceType: !Ref InstanceType
MinCount: !Ref InstanceCount
MaxCount: !Ref InstanceCount
EC2InstancesFunction:
Type: AWS::Lambda::Function
Properties:
Handler: index.handler
Role: !GetAtt LambdaExecutionRole.Arn
Code:
ZipFile: !Sub |
var response = require(''cfn-response'');
var AWS = require(''aws-sdk'');
exports.handler = function(event, context) {
var physicalId = event.PhysicalResourceId || ''none'';
function success(data) {
return response.send(event, context, response.SUCCESS, data, physicalId);
}
function failed(e) {
return response.send(event, context, response.FAILED, e, physicalId);
}
var ec2 = new AWS.EC2();
var instances;
if (event.RequestType == ''Create'') {
var launchParams = event.ResourceProperties;
delete launchParams.ServiceToken;
ec2.runInstances(launchParams).promise().then((data)=> {
instances = data.Instances.map((data)=> data.InstanceId);
physicalId = instances.join('':'');
return ec2.waitFor(''instanceRunning'', {InstanceIds: instances}).promise();
}).then((data)=> success({Instances: instances})
).catch((e)=> failed(e));
} else if (event.RequestType == ''Delete'') {
if (physicalId == ''none'') {return success({});}
var deleteParams = {InstanceIds: physicalId.split('':'')};
ec2.terminateInstances(deleteParams).promise().then((data)=>
ec2.waitFor(''instanceTerminated'', deleteParams).promise()
).then((data)=>success({})
).catch((e)=>failed(e));
} else {
return failed({Error: "In-place updates not supported."});
}
};
Runtime: nodejs4.3
Timeout: 300
LambdaExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: ''2012-10-17''
Statement:
- Effect: Allow
Principal: {Service: [lambda.amazonaws.com]}
Action: [''sts:AssumeRole'']
Path: /
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: EC2Policy
PolicyDocument:
Version: ''2012-10-17''
Statement:
- Effect: Allow
Action:
- ''ec2:RunInstances''
- ''ec2:DescribeInstances''
- ''ec2:DescribeInstanceStatus''
- ''ec2:TerminateInstances''
Resource: [''*'']
Outputs:
Instances:
Value: !Join ['','', !GetAtt EC2Instances.Instances]