#!/usr/bin/python # -*- coding: utf-8 -*- # Copyright: Contributors to the Ansible project # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) DOCUMENTATION = r""" --- module: autoscaling_launch_config version_added: 1.0.0 short_description: Create or delete AWS Autoscaling Launch Configurations description: - Can create or delete AWS Autoscaling Configurations. - Works with the M(community.aws.autoscaling_group) module to manage Autoscaling Groups. - Prior to release 5.0.0 this module was called C(community.aws.ec2_lc). The usage did not change. notes: - Amazon ASG Autoscaling Launch Configurations are immutable once created, so modifying the configuration after it is changed will not modify the launch configuration on AWS. You must create a new config and assign it to the ASG instead. author: - "Gareth Rushgrove (@garethr)" - "Willem van Ketwich (@wilvk)" options: state: description: - Register or deregister the instance. default: present choices: ['present', 'absent'] type: str name: description: - Unique name for configuration. required: true type: str instance_type: description: - Instance type to use for the instance. - Required when creating a new Launch Configuration. type: str image_id: description: - The AMI unique identifier to be used for the group. type: str key_name: description: - The SSH key name to be used for access to managed instances. type: str security_groups: description: - A list of security groups to apply to the instances. - You can specify either security group names or IDs or a mix. type: list elements: str default: [] volumes: description: - A list dictionaries defining the volumes to create. - For any volume, a volume size less than C(1) will be interpreted as a request not to create the volume. type: list elements: dict suboptions: device_name: type: str description: - The name for the volume (For example C(/dev/sda)). required: true no_device: type: bool description: - When I(no_device=true) the device will not be created. snapshot: type: str description: - The ID of an EBS snapshot to copy when creating the volume. - Mutually exclusive with the I(ephemeral) parameter. ephemeral: type: str description: - Whether the volume should be ephemeral. - Data on ephemeral volumes is lost when the instance is stopped. - Mutually exclusive with the I(snapshot) parameter. volume_size: type: int description: - The size of the volume (in GiB). - Required unless one of I(ephemeral), I(snapshot) or I(no_device) is set. volume_type: type: str description: - The type of volume to create. - See U(https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html) for more information on the available volume types. delete_on_termination: type: bool default: false description: - Whether the volume should be automatically deleted when the instance is terminated. iops: type: int description: - The number of IOPS per second to provision for the volume. - Required when I(volume_type=io1). throughput: type: int description: - The throughput to provision for a gp3 volume. - Valid Range is a minimum value of 125 and a maximum value of 1000. version_added: 3.1.0 encrypted: type: bool default: false description: - Whether the volume should be encrypted using the 'aws/ebs' KMS CMK. user_data: description: - Opaque blob of data which is made available to the ec2 instance. Mutually exclusive with I(user_data_path). type: str user_data_path: description: - Path to the file that contains userdata for the ec2 instances. Mutually exclusive with I(user_data). type: path kernel_id: description: - Kernel id for the EC2 instance. type: str spot_price: description: - The spot price you are bidding. Only applies for an autoscaling group with spot instances. type: float instance_monitoring: description: - Specifies whether instances are launched with detailed monitoring. type: bool default: false assign_public_ip: description: - Used for Auto Scaling groups that launch instances into an Amazon Virtual Private Cloud. Specifies whether to assign a public IP address to each instance launched in a Amazon VPC. type: bool ramdisk_id: description: - A RAM disk id for the instances. type: str instance_profile_name: description: - The name or the Amazon Resource Name (ARN) of the instance profile associated with the IAM role for the instances. type: str ebs_optimized: description: - Specifies whether the instance is optimized for EBS I/O (true) or not (false). default: false type: bool classic_link_vpc_id: description: - Id of ClassicLink enabled VPC type: str classic_link_vpc_security_groups: description: - A list of security group IDs with which to associate the ClassicLink VPC instances. type: list elements: str vpc_id: description: - VPC ID, used when resolving security group names to IDs. type: str instance_id: description: - The Id of a running instance to use as a basis for a launch configuration. Can be used in place of I(image_id) and I(instance_type). type: str placement_tenancy: description: - Determines whether the instance runs on single-tenant hardware or not. - When not set AWS will default to C(default). type: str choices: ['default', 'dedicated'] extends_documentation_fragment: - amazon.aws.common.modules - amazon.aws.region.modules - amazon.aws.boto3 """ EXAMPLES = r""" - name: create a launch configuration with an encrypted volume community.aws.autoscaling_launch_config: name: special image_id: ami-XXX key_name: default security_groups: - 'group' - 'group2' instance_type: t1.micro volumes: - device_name: /dev/sda1 volume_size: 100 volume_type: io1 iops: 3000 delete_on_termination: true encrypted: true - device_name: /dev/sdb ephemeral: ephemeral0 - name: create a launch configuration using a running instance id as a basis community.aws.autoscaling_launch_config: name: special instance_id: i-00a48b207ec59e948 key_name: default security_groups: - 'launch-wizard-2' volumes: - device_name: /dev/sda1 volume_size: 120 volume_type: io1 iops: 3000 delete_on_termination: true - name: create a launch configuration to omit the /dev/sdf EBS device that is included in the AMI image community.aws.autoscaling_launch_config: name: special image_id: ami-XXX key_name: default security_groups: - 'group' - 'group2' instance_type: t1.micro volumes: - device_name: /dev/sdf no_device: true - name: Use EBS snapshot ID for volume block: - name: Set Volume Facts ansible.builtin.set_fact: volumes: - device_name: /dev/sda1 volume_size: 20 ebs: snapshot: snap-XXXX volume_type: gp2 delete_on_termination: true encrypted: false - name: Create launch configuration community.aws.autoscaling_launch_config: name: lc1 image_id: ami-xxxx assign_public_ip: true instance_type: t2.medium key_name: my-key security_groups: - 'sg-xxxx' volumes: "{{ volumes }}" register: lc_info """ RETURN = r""" arn: description: The Amazon Resource Name of the launch configuration. returned: when I(state=present) type: str sample: arn:aws:autoscaling:us-east-1:123456789012:launchConfiguration:888d9b58-d93a-40c4-90cf-759197a2621a:launchConfigurationName/launch_config_name changed: description: Whether the state of the launch configuration has changed. returned: always type: bool sample: false created_time: description: The creation date and time for the launch configuration. returned: when I(state=present) type: str sample: '2017-11-03 23:46:44.841000' image_id: description: The ID of the Amazon Machine Image used by the launch configuration. returned: when I(state=present) type: str sample: ami-9be6f38c instance_type: description: The instance type for the instances. returned: when I(state=present) type: str sample: t1.micro name: description: The name of the launch configuration. returned: when I(state=present) type: str sample: launch_config_name result: description: The specification details for the launch configuration. returned: when I(state=present) type: complex contains: PlacementTenancy: description: The tenancy of the instances, either default or dedicated. returned: when I(state=present) type: str sample: default associate_public_ip_address: description: (EC2-VPC) Indicates whether to assign a public IP address to each instance. returned: when I(state=present) type: bool sample: false block_device_mappings: description: A block device mapping, which specifies the block devices. returned: when I(state=present) type: complex contains: device_name: description: The device name exposed to the EC2 instance (for example, /dev/sdh or xvdh). returned: when I(state=present) type: str sample: /dev/sda1 ebs: description: The information about the Amazon EBS volume. returned: when I(state=present) type: complex contains: snapshot_id: description: The ID of the snapshot. returned: when I(state=present) type: str volume_size: description: The volume size, in GiB. returned: when I(state=present) type: str sample: '100' virtual_name: description: The name of the virtual device (for example, ephemeral0). returned: when I(state=present) type: str sample: ephemeral0 classic_link_vpc_id: description: The ID of a ClassicLink-enabled VPC to link your EC2-Classic instances to. returned: when I(state=present) type: str classic_link_vpc_security_groups: description: The IDs of one or more security groups for the VPC specified in ClassicLinkVPCId. returned: when I(state=present) type: list sample: [] created_time: description: The creation date and time for the launch configuration. returned: when I(state=present) type: str sample: '2017-11-03 23:46:44.841000' delete_on_termination: description: Indicates whether the volume is deleted on instance termination. returned: when I(state=present) type: bool sample: true ebs_optimized: description: Indicates whether the instance is optimized for EBS I/O C(true) or not C(false). returned: when I(state=present) type: bool sample: false image_id: description: The ID of the Amazon Machine Image used by the launch configuration. returned: when I(state=present) type: str sample: ami-9be6f38c instance_monitoring: description: Indicates whether instances in this group are launched with detailed C(true) or basic C(false) monitoring. returned: when I(state=present) type: bool sample: true instance_profile_name: description: The name or Amazon Resource Name (ARN) of the instance profile associated with the IAM role for the instance. returned: when I(state=present) type: str sample: null instance_type: description: The instance type for the instances. returned: when I(state=present) type: str sample: t1.micro iops: description: The number of I/O operations per second (IOPS) to provision for the volume. returned: when I(state=present) type: int kernel_id: description: The ID of the kernel associated with the AMI. returned: when I(state=present) type: str sample: '' key_name: description: The name of the key pair. returned: when I(state=present) type: str sample: testkey launch_configuration_arn: description: The Amazon Resource Name (ARN) of the launch configuration. returned: when I(state=present) type: str sample: arn:aws:autoscaling:us-east-1:123456789012:launchConfiguration:888d9b58-d93a-40c4-90cf-759197a2621a:launchConfigurationName/launch_config_name member: description: "" returned: when I(state=present) type: str sample: "\n " name: description: The name of the launch configuration. returned: when I(state=present) type: str sample: launch_config_name ramdisk_id: description: The ID of the RAM disk associated with the AMI. returned: when I(state=present) type: str sample: '' security_groups: description: The security groups to associate with the instances. returned: when I(state=present) type: list sample: - sg-5e27db2f spot_price: description: The price to bid when launching Spot Instances. returned: when I(state=present) type: float use_block_device_types: description: Indicates whether to suppress a device mapping. returned: when I(state=present) type: bool sample: false user_data: description: The user data available to the instances. returned: when I(state=present) type: str sample: '' volume_type: description: The volume type (one of standard, io1, gp2). returned: when I(state=present) type: str sample: io1 security_groups: description: The security groups to associate with the instances. returned: when I(state=present) type: list sample: - sg-5e27db2f """ import traceback try: import botocore except ImportError: pass # Handled by AnsibleAWSModule from ansible.module_utils._text import to_text from ansible.module_utils.common.dict_transformations import camel_dict_to_snake_dict from ansible.module_utils.common.dict_transformations import snake_dict_to_camel_dict from ansible_collections.amazon.aws.plugins.module_utils.ec2 import get_ec2_security_group_ids_from_names from ansible_collections.community.aws.plugins.module_utils.modules import AnsibleCommunityAWSModule as AnsibleAWSModule def create_block_device_meta(module, volume): if "snapshot" not in volume and "ephemeral" not in volume and "no_device" not in volume: if "volume_size" not in volume: module.fail_json(msg="Size must be specified when creating a new volume or modifying the root volume") if "snapshot" in volume: if volume.get("volume_type") == "io1" and "iops" not in volume: module.fail_json(msg="io1 volumes must have an iops value set") if "ephemeral" in volume: if "snapshot" in volume: module.fail_json(msg="Cannot set both ephemeral and snapshot") return_object = {} if "ephemeral" in volume: return_object["VirtualName"] = volume.get("ephemeral") if "device_name" in volume: return_object["DeviceName"] = volume.get("device_name") if "no_device" in volume: return_object["NoDevice"] = volume.get("no_device") if any( key in volume for key in [ "snapshot", "volume_size", "volume_type", "delete_on_termination", "iops", "throughput", "encrypted", ] ): return_object["Ebs"] = {} if "snapshot" in volume: return_object["Ebs"]["SnapshotId"] = volume.get("snapshot") if "volume_size" in volume: return_object["Ebs"]["VolumeSize"] = int(volume.get("volume_size", 0)) if "volume_type" in volume: return_object["Ebs"]["VolumeType"] = volume.get("volume_type") if "delete_on_termination" in volume: return_object["Ebs"]["DeleteOnTermination"] = volume.get("delete_on_termination", False) if "iops" in volume: return_object["Ebs"]["Iops"] = volume.get("iops") if "throughput" in volume: if volume.get("volume_type") != "gp3": module.fail_json(msg="The throughput parameter is supported only for GP3 volumes.") return_object["Ebs"]["Throughput"] = volume.get("throughput") if "encrypted" in volume: return_object["Ebs"]["Encrypted"] = volume.get("encrypted") return return_object def create_launch_config(connection, module): name = module.params.get("name") vpc_id = module.params.get("vpc_id") try: ec2_connection = module.client("ec2") except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e: module.fail_json_aws(e, msg="Failed to connect to AWS") try: security_groups = get_ec2_security_group_ids_from_names( module.params.get("security_groups"), ec2_connection, vpc_id=vpc_id ) except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e: module.fail_json_aws(e, msg="Failed to get Security Group IDs") except ValueError: module.fail_json(msg="Failed to get Security Group IDs", exception=traceback.format_exc()) user_data = module.params.get("user_data") user_data_path = module.params.get("user_data_path") volumes = module.params["volumes"] instance_monitoring = module.params.get("instance_monitoring") assign_public_ip = module.params.get("assign_public_ip") instance_profile_name = module.params.get("instance_profile_name") ebs_optimized = module.params.get("ebs_optimized") classic_link_vpc_id = module.params.get("classic_link_vpc_id") classic_link_vpc_security_groups = module.params.get("classic_link_vpc_security_groups") block_device_mapping = [] convert_list = [ "image_id", "instance_type", "instance_type", "instance_id", "placement_tenancy", "key_name", "kernel_id", "ramdisk_id", "spot_price", ] launch_config = snake_dict_to_camel_dict( dict((k.capitalize(), str(v)) for k, v in module.params.items() if v is not None and k in convert_list) ) if user_data_path: try: with open(user_data_path, "r") as user_data_file: user_data = user_data_file.read() except IOError: module.fail_json(msg="Failed to open file for reading", exception=traceback.format_exc()) if volumes: for volume in volumes: if "device_name" not in volume: module.fail_json(msg="Device name must be set for volume") # Minimum volume size is 1GiB. We'll use volume size explicitly set to 0 to be a signal not to create this volume if "volume_size" not in volume or int(volume["volume_size"]) > 0: block_device_mapping.append(create_block_device_meta(module, volume)) try: launch_configs = connection.describe_launch_configurations(LaunchConfigurationNames=[name]).get( "LaunchConfigurations" ) except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e: module.fail_json_aws(e, msg="Failed to describe launch configuration by name") changed = False result = {} launch_config["LaunchConfigurationName"] = name if security_groups is not None: launch_config["SecurityGroups"] = security_groups if classic_link_vpc_id is not None: launch_config["ClassicLinkVPCId"] = classic_link_vpc_id if instance_monitoring is not None: launch_config["InstanceMonitoring"] = {"Enabled": instance_monitoring} if classic_link_vpc_security_groups is not None: launch_config["ClassicLinkVPCSecurityGroups"] = classic_link_vpc_security_groups if block_device_mapping: launch_config["BlockDeviceMappings"] = block_device_mapping if instance_profile_name is not None: launch_config["IamInstanceProfile"] = instance_profile_name if assign_public_ip is not None: launch_config["AssociatePublicIpAddress"] = assign_public_ip if user_data is not None: launch_config["UserData"] = user_data if ebs_optimized is not None: launch_config["EbsOptimized"] = ebs_optimized if len(launch_configs) == 0: try: connection.create_launch_configuration(**launch_config) launch_configs = connection.describe_launch_configurations(LaunchConfigurationNames=[name]).get( "LaunchConfigurations" ) changed = True if launch_configs: launch_config = launch_configs[0] except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e: module.fail_json_aws(e, msg="Failed to create launch configuration") result = dict( (k, v) for k, v in launch_config.items() if k not in ["Connection", "CreatedTime", "InstanceMonitoring", "BlockDeviceMappings"] ) result["CreatedTime"] = to_text(launch_config.get("CreatedTime")) try: result["InstanceMonitoring"] = module.boolean(launch_config.get("InstanceMonitoring").get("Enabled")) except AttributeError: result["InstanceMonitoring"] = False result["BlockDeviceMappings"] = [] for block_device_mapping in launch_config.get("BlockDeviceMappings", []): result["BlockDeviceMappings"].append( dict( device_name=block_device_mapping.get("DeviceName"), virtual_name=block_device_mapping.get("VirtualName") ) ) if block_device_mapping.get("Ebs") is not None: result["BlockDeviceMappings"][-1]["ebs"] = dict( snapshot_id=block_device_mapping.get("Ebs").get("SnapshotId"), volume_size=block_device_mapping.get("Ebs").get("VolumeSize"), ) if user_data_path: result["UserData"] = "hidden" # Otherwise, we dump binary to the user's terminal return_object = { "Name": result.get("LaunchConfigurationName"), "CreatedTime": result.get("CreatedTime"), "ImageId": result.get("ImageId"), "Arn": result.get("LaunchConfigurationARN"), "SecurityGroups": result.get("SecurityGroups"), "InstanceType": result.get("InstanceType"), "Result": result, } module.exit_json(changed=changed, **camel_dict_to_snake_dict(return_object)) def delete_launch_config(connection, module): try: name = module.params.get("name") launch_configs = connection.describe_launch_configurations(LaunchConfigurationNames=[name]).get( "LaunchConfigurations" ) if launch_configs: connection.delete_launch_configuration( LaunchConfigurationName=launch_configs[0].get("LaunchConfigurationName") ) module.exit_json(changed=True) else: module.exit_json(changed=False) except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e: module.fail_json_aws(e, msg="Failed to delete launch configuration") def main(): argument_spec = dict( name=dict(required=True), image_id=dict(), instance_id=dict(), key_name=dict(), security_groups=dict(default=[], type="list", elements="str"), user_data=dict(), user_data_path=dict(type="path"), kernel_id=dict(), volumes=dict(type="list", elements="dict"), instance_type=dict(), state=dict(default="present", choices=["present", "absent"]), spot_price=dict(type="float"), ramdisk_id=dict(), instance_profile_name=dict(), ebs_optimized=dict(default=False, type="bool"), instance_monitoring=dict(default=False, type="bool"), assign_public_ip=dict(type="bool"), classic_link_vpc_security_groups=dict(type="list", elements="str"), classic_link_vpc_id=dict(), vpc_id=dict(), placement_tenancy=dict(choices=["default", "dedicated"]), ) module = AnsibleAWSModule( argument_spec=argument_spec, mutually_exclusive=[["user_data", "user_data_path"]], ) try: connection = module.client("autoscaling") except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e: module.fail_json_aws(e, msg="unable to establish connection") state = module.params.get("state") if state == "present": create_launch_config(connection, module) elif state == "absent": delete_launch_config(connection, module) if __name__ == "__main__": main()