amazon-ec2 - son - tipos de cloud computing ejemplos

Crea una imagen AMI como parte de una pila de formación de nubes.

Question

Quiero crear una pila de información en la nube EC2 que básicamente se puede describir en los siguientes pasos:

1.- Lanzar instancia.

2.- Aprovisionar la instancia.

3.- Detenga la instancia y cree una imagen AMI a partir de ella.

4.- Cree un grupo de autoescala con la imagen AMI creada como fuente para iniciar nuevas instancias.

Básicamente puedo hacer 1 y 2 en una plantilla de formación de nubes y 4 en una segunda plantilla. Lo que no puedo hacer es crear una imagen AMI desde una instancia dentro de una plantilla de formación de nubes, lo que básicamente genera el problema de tener que eliminar manualmente la AMI si quiero eliminar la pila.

Dicho esto, mis preguntas son:

1.- ¿Hay una manera de crear una imagen AMI desde una instancia DENTRO de la plantilla de formación de nubes?

2.- Si la respuesta a 1 es no, ¿hay una manera de agregar una imagen AMI (o cualquier otro recurso para esa materia) para que sea parte de una pila completa?

EDITAR:

Solo para aclarar, ya resolví el problema de crear la AMI y usarla en una plantilla de información en la nube, simplemente no puedo crear la AMI DENTRO de la plantilla de la nube o agregarla de alguna manera a la pila creada.

Como comenté en la respuesta de Rico, lo que hago ahora es usar un libro de jugabilidad ansible que básicamente tiene 3 pasos:

1.- Crear una instancia base con una plantilla de formación de nubes.

2.- Cree, utilizando ansible, una AMI de la instancia creada en el paso 1

3.- Cree el resto de la pila (ELB, grupos de autoescalado, etc.) con una segunda plantilla de formación de nubes que actualice la creada en el paso 1 y que use la AMI creada en el paso 2 para iniciar instancias.

Así es como lo gestiono ahora, pero quería saber si hay alguna forma de crear un AMI DENTRO de una plantilla de formación de nubes o si es posible agregar el AMI creado a la pila (algo así como decirle a la pila, "Oye, esto pertenece a Tú también, así que manéjalo ").

Answer 1

1. No.
2. Supongo que sí. Una vez que la pila puede utilizar la operación "Actualizar pila". Debe proporcionar la plantilla JSON completa de la pila inicial + sus cambios en el mismo archivo (AMI modificado). Primero ejecutaría esto en un entorno de prueba (no de producción), ya que no estoy realmente seguro de lo que hace la operación al Instancias existentes.

¿Por qué no crea una AMI inicialmente fuera de la formación de nubes y luego la utiliza en la plantilla final de la nube?

Otra opción es escribir algo de automatización para crear dos pilas de información en la nube y puede eliminar la primera una vez que finalice la AMI que ha creado.

Answer 2

Para lo que vale, aquí está la variante de Python de la definición AMIFunction de AMIFunction en la respuesta original . Todos los otros recursos en el yaml original permanecen sin cambios:

AMIFunction:
  Type: AWS::Lambda::Function
  Properties:
    Handler: index.handler
    Role: !GetAtt LambdaExecutionRole.Arn
    Code:
      ZipFile: !Sub |
        import logging
        import cfnresponse
        import json
        import boto3
        from threading import Timer
        from botocore.exceptions import WaiterError

        logger = logging.getLogger()
        logger.setLevel(logging.INFO)

        def handler(event, context):

          ec2 = boto3.resource(''ec2'')
          physicalId = event[''PhysicalResourceId''] if ''PhysicalResourceId'' in event else None

          def success(data={}):
            cfnresponse.send(event, context, cfnresponse.SUCCESS, data, physicalId)

          def failed(e):
            cfnresponse.send(event, context, cfnresponse.FAILED, str(e), physicalId)

          logger.info(''Request received: %s/n'' % json.dumps(event))

          try:
            instanceId = event[''ResourceProperties''][''InstanceId'']
            if (not instanceId):
              raise ''InstanceID required''

            if not ''RequestType'' in event:
              success({''Data'': ''Unhandled request type''})
              return

            if event[''RequestType''] == ''Delete'':
              if (not physicalId.startswith(''ami-'')):
                raise ''Unknown PhysicalId: %s'' % physicalId

              ec2client = boto3.client(''ec2'')
              images = ec2client.describe_images(ImageIds=[physicalId])
              for image in images[''Images'']:
                ec2.Image(image[''ImageId'']).deregister()
                snapshots = ([bdm[''Ebs''][''SnapshotId''] 
                              for bdm in image[''BlockDeviceMappings''] 
                              if ''Ebs'' in bdm and ''SnapshotId'' in bdm[''Ebs'']])
                for snapshot in snapshots:
                  ec2.Snapshot(snapshot).delete()

              success({''Data'': ''OK''})
            elif event[''RequestType''] in set([''Create'', ''Update'']):
              if not physicalId:  # AMI creation has not been requested yet
                instance = ec2.Instance(instanceId)
                instance.wait_until_stopped()

                image = instance.create_image(Name="Automatic from CloudFormation stack ${AWS::StackName}")

                physicalId = image.image_id
              else:
                logger.info(''Continuing in awaiting image available: %s/n'' % physicalId)

              ec2client = boto3.client(''ec2'')
              waiter = ec2client.get_waiter(''image_available'')

              try:
                waiter.wait(ImageIds=[physicalId], WaiterConfig={''Delay'': 30, ''MaxAttempts'': 6})
              except WaiterError as e:
                # Request the same event but set PhysicalResourceId so that the AMI is not created again
                event[''PhysicalResourceId''] = physicalId
                logger.info(''Timeout reached, continuing function: %s/n'' % json.dumps(event))
                lambda_client = boto3.client(''lambda'')
                lambda_client.invoke(FunctionName=context.invoked_function_arn, 
                                      InvocationType=''Event'',
                                      Payload=json.dumps(event))
                return

              success({''Data'': ''OK''})
            else:
              success({''Data'': ''OK''})
          except Exception as e:
            failed(e)
    Runtime: python2.7
    Timeout: 300

Answer 3

Sí, puede crear una AMI a partir de una instancia de EC2 dentro de una plantilla de CloudFormation implementando un recurso personalizado que llama a la API CreateImage en la creación (y llama a las API DeleteSnapshot y DeleteSnapshot en la eliminación).

Como las AMI a veces pueden tardar mucho tiempo en crearse, un recurso personalizado respaldado por Lambda tendrá que volver a invocarse a sí mismo si la espera no se ha completado antes de que la función Lambda se agote.

Aquí hay un ejemplo completo:

Description: Create an AMI from an EC2 instance.
Parameters:
  ImageId:
    Description: Image ID for base EC2 instance.
    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:
  # Completes when the instance is fully provisioned and ready for AMI creation.
  AMICreate:
    Type: AWS::CloudFormation::WaitCondition
    CreationPolicy:
      ResourceSignal:
        Timeout: PT10M
  Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: !Ref ImageId
      InstanceType: !Ref InstanceType
      UserData:
        "Fn::Base64": !Sub |
          #!/bin/bash -x
          yum -y install mysql # provisioning example
          /opt/aws/bin/cfn-signal /
            -e $? /
            --stack ${AWS::StackName} /
            --region ${AWS::Region} /
            --resource AMICreate
          shutdown -h now
  AMI:
    Type: Custom::AMI
    DependsOn: AMICreate
    Properties:
      ServiceToken: !GetAtt AMIFunction.Arn
      InstanceId: !Ref Instance
  AMIFunction:
    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) {
            console.log("Request received:/n", JSON.stringify(event));
            var physicalId = event.PhysicalResourceId;
            function success(data) {
              return response.send(event, context, response.SUCCESS, data, physicalId);
            }
            function failed(e) {
              return response.send(event, context, response.FAILED, e, physicalId);
            }
            // Call ec2.waitFor, continuing if not finished before Lambda function timeout.
            function wait(waiter) {
              console.log("Waiting: ", JSON.stringify(waiter));
              event.waiter = waiter;
              event.PhysicalResourceId = physicalId;
              var request = ec2.waitFor(waiter.state, waiter.params);
              setTimeout(()=>{
                request.abort();
                console.log("Timeout reached, continuing function. Params:/n", JSON.stringify(event));
                var lambda = new AWS.Lambda();
                lambda.invoke({
                  FunctionName: context.invokedFunctionArn,
                  InvocationType: ''Event'',
                  Payload: JSON.stringify(event)
                }).promise().then((data)=>context.done()).catch((err)=>context.fail(err));
              }, context.getRemainingTimeInMillis() - 5000);
              return request.promise().catch((err)=>
                (err.code == ''RequestAbortedError'') ?
                  new Promise(()=>context.done()) :
                  Promise.reject(err)
              );
            }
            var ec2 = new AWS.EC2(),
                instanceId = event.ResourceProperties.InstanceId;
            if (event.waiter) {
              wait(event.waiter).then((data)=>success({})).catch((err)=>failed(err));
            } else if (event.RequestType == ''Create'' || event.RequestType == ''Update'') {
              if (!instanceId) { failed(''InstanceID required''); }
              ec2.waitFor(''instanceStopped'', {InstanceIds: [instanceId]}).promise()
              .then((data)=>
                ec2.createImage({
                  InstanceId: instanceId,
                  Name: event.RequestId
                }).promise()
              ).then((data)=>
                wait({
                  state: ''imageAvailable'',
                  params: {ImageIds: [physicalId = data.ImageId]}
                })
              ).then((data)=>success({})).catch((err)=>failed(err));
            } else if (event.RequestType == ''Delete'') {
              if (physicalId.indexOf(''ami-'') !== 0) { return success({});}
              ec2.describeImages({ImageIds: [physicalId]}).promise()
              .then((data)=>
                (data.Images.length == 0) ? success({}) :
                ec2.deregisterImage({ImageId: physicalId}).promise()
              ).then((data)=>
                ec2.describeSnapshots({Filters: [{
                  Name: ''description'',
                  Values: ["*" + physicalId + "*"]
                }]}).promise()
              ).then((data)=>
                (data.Snapshots.length === 0) ? success({}) :
                ec2.deleteSnapshot({SnapshotId: data.Snapshots[0].SnapshotId}).promise()
              ).then((data)=>success({})).catch((err)=>failed(err));
            }
          };
      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
      - arn:aws:iam::aws:policy/service-role/AWSLambdaRole
      Policies:
      - PolicyName: EC2Policy
        PolicyDocument:
          Version: ''2012-10-17''
          Statement:
            - Effect: Allow
              Action:
              - ''ec2:DescribeInstances''
              - ''ec2:DescribeImages''
              - ''ec2:CreateImage''
              - ''ec2:DeregisterImage''
              - ''ec2:DescribeSnapshots''
              - ''ec2:DeleteSnapshot''
              Resource: [''*'']
Outputs:
  AMI:
    Value: !Ref AMI

Answer 4

Si bien la solución de @ wjdordan es buena para casos de uso simples, la actualización de los Datos del usuario no actualizará la AMI.

(DESCARGO DE RESPONSABILIDAD: Soy el autor original) cloudformation-ami tiene como objetivo permitirle declarar las AMI en CloudFormation que se pueden crear, actualizar y eliminar de forma confiable. Uso de cloudformation-ami Puede declarar AMI personalizadas de la siguiente manera:

MyAMI:
  Type: Custom::AMI
  Properties:
    ServiceToken: !ImportValue AMILambdaFunctionArn
    Image:
      Name: my-image
      Description: some description for the image
    TemplateInstance:
      ImageId: ami-467ca739
      IamInstanceProfile:
        Arn: arn:aws:iam::1234567890:instance-profile/MyProfile-ASDNSDLKJ
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -x
          yum -y install mysql # provisioning example
          # Signal that the instance is ready
          INSTANCE_ID=`wget -q -O - http://169.254.169.254/latest/meta-data/instance-id`
          aws ec2 create-tags --resources $INSTANCE_ID --tags Key=UserDataFinished,Value=true --region ${AWS::Region}
      KeyName: my-key
      InstanceType: t2.nano
      SecurityGroupIds:
      - sg-d7bf78b0
      SubnetId: subnet-ba03aa91
      BlockDeviceMappings:
      - DeviceName: "/dev/xvda"
        Ebs:
          VolumeSize: ''10''
          VolumeType: gp2