Aggiornamento AMIs per i gruppi Amazon EC2 Auto Scaling

L'esempio seguente aggiorna un gruppo Amazon EC2 Auto Scaling con una nuova patch. AMI Questo approccio garantisce che le nuove immagini vengano rese automaticamente disponibili per diversi ambienti di elaborazione che utilizzano gruppi Amazon EC2 Auto Scaling.

La fase finale dell'automazione in questo esempio utilizza una funzione Python per creare un nuovo modello di avvio che utilizza la nuova AMI con patch applicate. Quindi il gruppo Amazon EC2 Auto Scaling viene aggiornato per utilizzare il nuovo modello di lancio. In questo tipo di scenario di Amazon EC2 Auto Scaling, gli utenti possono terminare le istanze esistenti nel gruppo Amazon Auto Scaling EC2 per forzare l'avvio di una nuova istanza che utilizza la nuova immagine. In alternativa, gli utenti possono attendere che siano gli eventi di scalabilità verticale o orizzontale ad avviare le istanze più recenti.

Prima di iniziare

Prima di iniziare a utilizzare questo esempio, completare le attività descritte di seguito.

Configura i ruoli IAM per Automation, uno strumento in. AWS Systems Manager Systems Manager richiede un ruolo del profilo dell'istanza e un ARN del ruolo di servizio per elaborare le automazioni. Per ulteriori informazioni, consulta Configurazione del servizio di automazione.

Crea il runbook Patch AMIAnd UpdateASG

Utilizzate la procedura seguente per creare il runbook Patch AMIAnd UpdateASG che applica le patch specificate per il AMI parametro SourceAMI. Il runbook aggiorna anche un gruppo Amazon EC2 Auto Scaling per utilizzare la versione più recente, con patch. AMI

Per creare ed eseguire il runbook

Apri la console all' AWS Systems Manager indirizzo. https://console.aws.amazon.com/systems-manager/
Nel riquadro di navigazione, scegli Documenti.
Nel menu a disces Create document (Crea un documento), scegliere Automation (Automazione).
Nel campo Name (Nome), inserire PatchAMIAndUpdateASG.
Scegliere la scheda Editor, quindi Edit (Modifica).
Scegliere OK quando richiesto ed eliminare il contenuto nel campo Document editor (Editor di documenti).

Nel campo Document editor (Editor di documenti) incollare il seguente contenuto del runbook di esempio YAML.


---
description: Systems Manager Automation Demo - Patch AMI and Update ASG
schemaVersion: '0.3'
assumeRole: '{{ AutomationAssumeRole }}'
parameters:
  AutomationAssumeRole:
    type: String
    description: '(Required) The ARN of the role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to execute this document.'
    default: ''
  SourceAMI:
    type: String
    description: '(Required) The ID of the AMI you want to patch.'
  SubnetId:
    type: String
    description: '(Required) The ID of the subnet where the instance from the SourceAMI parameter is launched.'
  SecurityGroupIds:
    type: StringList
    description: '(Required) The IDs of the security groups to associate with the instance launched from the SourceAMI parameter.'
  NewAMI:
    type: String
    description: '(Optional) The name of of newly patched AMI.'
    default: 'patchedAMI-{{global:DATE_TIME}}'
  TargetASG:
    type: String
    description: '(Required) The name of the Auto Scaling group you want to update.'
  InstanceProfile:
    type: String
    description: '(Required) The name of the IAM instance profile you want the source instance to use.'
  SnapshotId:
    type: String
    description: (Optional) The snapshot ID to use to retrieve a patch baseline snapshot.
    default: ''
  RebootOption:
    type: String
    description: '(Optional) Reboot behavior after a patch Install operation. If you choose NoReboot and patches are installed, the instance is marked as non-compliant until a subsequent reboot and scan.'
    allowedValues:
      - NoReboot
      - RebootIfNeeded
    default: RebootIfNeeded
  Operation:
    type: String
    description: (Optional) The update or configuration to perform on the instance. The system checks if patches specified in the patch baseline are installed on the instance. The install operation installs patches missing from the baseline.
    allowedValues:
      - Install
      - Scan
    default: Install
mainSteps:
  - name: startInstances
    action: 'aws:runInstances'
    timeoutSeconds: 1200
    maxAttempts: 1
    onFailure: Abort
    inputs:
      ImageId: '{{ SourceAMI }}'
      InstanceType: m5.large
      MinInstanceCount: 1
      MaxInstanceCount: 1
      IamInstanceProfileName: '{{ InstanceProfile }}'
      SubnetId: '{{ SubnetId }}'
      SecurityGroupIds: '{{ SecurityGroupIds }}'
  - name: verifyInstanceManaged
    action: 'aws:waitForAwsResourceProperty'
    timeoutSeconds: 600
    inputs:
      Service: ssm
      Api: DescribeInstanceInformation
      InstanceInformationFilterList:
        - key: InstanceIds
          valueSet:
            - '{{ startInstances.InstanceIds }}'
      PropertySelector: '$.InstanceInformationList[0].PingStatus'
      DesiredValues:
        - Online
    onFailure: 'step:terminateInstance'
  - name: installPatches
    action: 'aws:runCommand'
    timeoutSeconds: 7200
    onFailure: Abort
    inputs:
      DocumentName: AWS-RunPatchBaseline
      Parameters:
        SnapshotId: '{{SnapshotId}}'
        RebootOption: '{{RebootOption}}'
        Operation: '{{Operation}}'
      InstanceIds:
        - '{{ startInstances.InstanceIds }}'
  - name: stopInstance
    action: 'aws:changeInstanceState'
    maxAttempts: 1
    onFailure: Continue
    inputs:
      InstanceIds:
        - '{{ startInstances.InstanceIds }}'
      DesiredState: stopped
  - name: createImage
    action: 'aws:createImage'
    maxAttempts: 1
    onFailure: Continue
    inputs:
      InstanceId: '{{ startInstances.InstanceIds }}'
      ImageName: '{{ NewAMI }}'
      NoReboot: false
      ImageDescription: Patched AMI created by Automation
  - name: terminateInstance
    action: 'aws:changeInstanceState'
    maxAttempts: 1
    onFailure: Continue
    inputs:
      InstanceIds:
        - '{{ startInstances.InstanceIds }}'
      DesiredState: terminated
  - name: updateASG
    action: 'aws:executeScript'
    timeoutSeconds: 300
    maxAttempts: 1
    onFailure: Abort
    inputs:
      Runtime: python3.11
      Handler: update_asg
      InputPayload:
        TargetASG: '{{TargetASG}}'
        NewAMI: '{{createImage.ImageId}}'
      Script: |-
        from __future__ import print_function
        import datetime
        import json
        import time
        import boto3

        # create auto scaling and ec2 client
        asg = boto3.client('autoscaling')
        ec2 = boto3.client('ec2')

        def update_asg(event, context):
            print("Received event: " + json.dumps(event, indent=2))

            target_asg = event['TargetASG']
            new_ami = event['NewAMI']

            # get object for the ASG we're going to update, filter by name of target ASG
            asg_query = asg.describe_auto_scaling_groups(AutoScalingGroupNames=[target_asg])
            if 'AutoScalingGroups' not in asg_query or not asg_query['AutoScalingGroups']:
                return 'No ASG found matching the value you specified.'

            # gets details of an instance from the ASG that we'll use to model the new launch template after
            source_instance_id = asg_query.get('AutoScalingGroups')[0]['Instances'][0]['InstanceId']
            instance_properties = ec2.describe_instances(
                InstanceIds=[source_instance_id]
            )
            source_instance = instance_properties['Reservations'][0]['Instances'][0]

            # create list of security group IDs
            security_groups = []
            for group in source_instance['SecurityGroups']:
                security_groups.append(group['GroupId'])

            # create a list of dictionary objects for block device mappings
            mappings = []
            for block in source_instance['BlockDeviceMappings']:
                volume_query = ec2.describe_volumes(
                    VolumeIds=[block['Ebs']['VolumeId']]
                )
                volume_details = volume_query['Volumes']
                device_name = block['DeviceName']
                volume_size = volume_details[0]['Size']
                volume_type = volume_details[0]['VolumeType']
                device = {'DeviceName': device_name, 'Ebs': {'VolumeSize': volume_size, 'VolumeType': volume_type}}
                mappings.append(device)

            # create new launch template using details returned from instance in the ASG and specify the newly patched AMI
            time_stamp = time.time()
            time_stamp_string = datetime.datetime.fromtimestamp(time_stamp).strftime('%m-%d-%Y_%H-%M-%S')
            new_template_name = f'{new_ami}_{time_stamp_string}'
            try:
                ec2.create_launch_template(
                    LaunchTemplateName=new_template_name,
                    LaunchTemplateData={
                        'BlockDeviceMappings': mappings,
                        'ImageId': new_ami,
                        'InstanceType': source_instance['InstanceType'],
                        'IamInstanceProfile': {
                            'Arn': source_instance['IamInstanceProfile']['Arn']
                        },
                        'KeyName': source_instance['KeyName'],
                        'SecurityGroupIds': security_groups
                    }
                )
            except Exception as e:
                return f'Exception caught: {str(e)}'
            else:
                # update ASG to use new launch template
                asg.update_auto_scaling_group(
                    AutoScalingGroupName=target_asg,
                    LaunchTemplate={
                        'LaunchTemplateName': new_template_name
                    }
                )
                return f'Updated ASG {target_asg} with new launch template {new_template_name} which uses AMI {new_ami}.'
outputs:
- createImage.ImageId

Scegliere Create automation (Crea automazione).
Nel pannello di navigazione, scegliere Automation (Automazione), quindi Execute automation (Esegui automazione).
Nella pagina Choose document (Scegli il documento), scegli la scheda Owned by me (Di mia proprietà).
Cerca il runbook Patch AMIAnd UpdateASG e seleziona il pulsante nella scheda Patch AMIAnd UpdateASG.
Scegli Next (Successivo).
Scegliere Simple execution (Esecuzione semplice).
Specifica i valori per il parametro di input. Assicurarsi che SubnetId e SecurityGroupIds da te specificati consentano l'accesso agli endpoint pubblici di Systems Manager o agli endpoint dell'interfaccia per Systems Manager.
Scegli Execute (Esegui).
Al termine dell'automazione, nella EC2 console Amazon, scegli Amazon EC2 Auto Scaling, quindi scegli Launch Templates. Controllare che il nuovo modello di avvio sia visualizzato e utilizzato dalla nuova AMI.
Scegli Amazon EC2 Auto Scaling, quindi scegli Amazon Auto EC2 Scaling Groups. Verifica che il gruppo Amazon EC2 Auto Scaling utilizzi il nuovo modello di lancio.
Termina una o più istanze nel tuo gruppo Amazon Auto EC2 Scaling. Le istanze di sostituzione verranno avviate utilizzando la nuova AMI.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Aggiornamento delle AMIs tramite automazione e Jenkins

Utilizzo dei runbook self-service di Supporto AWS