337 lines
10 KiB
Python
337 lines
10 KiB
Python
#!/usr/bin/python
|
|
# Copyright: Ansible Project
|
|
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
|
|
|
|
from __future__ import absolute_import, division, print_function
|
|
__metaclass__ = type
|
|
|
|
|
|
ANSIBLE_METADATA = {'metadata_version': '1.1',
|
|
'status': ['stableinterface'],
|
|
'supported_by': 'core'}
|
|
|
|
|
|
DOCUMENTATION = '''
|
|
---
|
|
module: ec2_vpc_net
|
|
short_description: Configure AWS virtual private clouds
|
|
description:
|
|
- Create or terminate AWS virtual private clouds. This module has a dependency on python-boto.
|
|
version_added: "2.0"
|
|
author: Jonathan Davila (@defionscode)
|
|
options:
|
|
name:
|
|
description:
|
|
- The name to give your VPC. This is used in combination with the cidr_block parameter to determine if a VPC already exists.
|
|
required: yes
|
|
cidr_block:
|
|
description:
|
|
- The CIDR of the VPC
|
|
required: yes
|
|
tenancy:
|
|
description:
|
|
- Whether to be default or dedicated tenancy. This cannot be changed after the VPC has been created.
|
|
required: false
|
|
default: default
|
|
choices: [ 'default', 'dedicated' ]
|
|
dns_support:
|
|
description:
|
|
- Whether to enable AWS DNS support.
|
|
required: false
|
|
default: yes
|
|
choices: [ 'yes', 'no' ]
|
|
dns_hostnames:
|
|
description:
|
|
- Whether to enable AWS hostname support.
|
|
required: false
|
|
default: yes
|
|
choices: [ 'yes', 'no' ]
|
|
dhcp_opts_id:
|
|
description:
|
|
- the id of the DHCP options to use for this vpc
|
|
default: null
|
|
required: false
|
|
tags:
|
|
description:
|
|
- The tags you want attached to the VPC. This is independent of the name value, note if you pass a 'Name' key it would override the Name of
|
|
the VPC if it's different.
|
|
default: None
|
|
required: false
|
|
aliases: [ 'resource_tags' ]
|
|
state:
|
|
description:
|
|
- The state of the VPC. Either absent or present.
|
|
default: present
|
|
required: false
|
|
choices: [ 'present', 'absent' ]
|
|
multi_ok:
|
|
description:
|
|
- By default the module will not create another VPC if there is another VPC with the same name and CIDR block. Specify this as true if you want
|
|
duplicate VPCs created.
|
|
default: false
|
|
required: false
|
|
|
|
extends_documentation_fragment:
|
|
- aws
|
|
- ec2
|
|
'''
|
|
|
|
EXAMPLES = '''
|
|
# Note: These examples do not set authentication details, see the AWS Guide for details.
|
|
|
|
# Create a VPC with dedicate tenancy and a couple of tags
|
|
|
|
- ec2_vpc_net:
|
|
name: Module_dev2
|
|
cidr_block: 10.10.0.0/16
|
|
region: us-east-1
|
|
tags:
|
|
module: ec2_vpc_net
|
|
this: works
|
|
tenancy: dedicated
|
|
|
|
'''
|
|
|
|
RETURN = '''
|
|
vpc.id:
|
|
description: VPC resource id
|
|
returned: success
|
|
type: string
|
|
sample: vpc-b883b2c4
|
|
vpc.cidr_block:
|
|
description: The CIDR of the VPC
|
|
returned: success
|
|
type: string
|
|
sample: "10.0.0.0/16"
|
|
vpc.state:
|
|
description: state of the VPC
|
|
returned: success
|
|
type: string
|
|
sample: available
|
|
vpc.tags:
|
|
description: tags attached to the VPC, includes name
|
|
returned: success
|
|
type: dict
|
|
sample: {"Name": "My VPC", "env": "staging"}
|
|
vpc.classic_link_enabled:
|
|
description: indicates whether ClassicLink is enabled
|
|
returned: success
|
|
type: boolean
|
|
sample: false
|
|
vpc.dhcp_options_id:
|
|
description: the id of the DHCP options assocaited with this VPC
|
|
returned: success
|
|
type: string
|
|
sample: dopt-67236184
|
|
vpc.instance_tenancy:
|
|
description: indicates whther VPC uses default or dedicated tenancy
|
|
returned: success
|
|
type: string
|
|
sample: default
|
|
vpc.is_default:
|
|
description: indicates whether this is the default VPC
|
|
returned: success
|
|
type: boolean
|
|
sample: false
|
|
'''
|
|
|
|
try:
|
|
import boto.vpc
|
|
from boto.exception import BotoServerError, NoAuthHandlerFound
|
|
except ImportError:
|
|
pass # Taken care of by ec2.HAS_BOTO
|
|
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible.module_utils.ec2 import (HAS_BOTO, AnsibleAWSError, boto_exception, connect_to_aws,
|
|
ec2_argument_spec, get_aws_connection_info)
|
|
|
|
|
|
def vpc_exists(module, vpc, name, cidr_block, multi):
|
|
"""Returns None or a vpc object depending on the existence of a VPC. When supplied
|
|
with a CIDR, it will check for matching tags to determine if it is a match
|
|
otherwise it will assume the VPC does not exist and thus return None.
|
|
"""
|
|
matched_vpc = None
|
|
|
|
try:
|
|
matching_vpcs = vpc.get_all_vpcs(filters={'tag:Name': name, 'cidr-block': cidr_block})
|
|
except Exception as e:
|
|
e_msg = boto_exception(e)
|
|
module.fail_json(msg=e_msg)
|
|
|
|
if multi:
|
|
return None
|
|
elif len(matching_vpcs) == 1:
|
|
matched_vpc = matching_vpcs[0]
|
|
elif len(matching_vpcs) > 1:
|
|
module.fail_json(msg='Currently there are %d VPCs that have the same name and '
|
|
'CIDR block you specified. If you would like to create '
|
|
'the VPC anyway please pass True to the multi_ok param.' % len(matching_vpcs))
|
|
|
|
return matched_vpc
|
|
|
|
|
|
def update_vpc_tags(vpc, module, vpc_obj, tags, name):
|
|
|
|
if tags is None:
|
|
tags = dict()
|
|
|
|
tags.update({'Name': name})
|
|
try:
|
|
current_tags = dict((t.name, t.value) for t in vpc.get_all_tags(filters={'resource-id': vpc_obj.id}))
|
|
if tags != current_tags:
|
|
if not module.check_mode:
|
|
vpc.create_tags(vpc_obj.id, tags)
|
|
return True
|
|
else:
|
|
return False
|
|
except Exception as e:
|
|
e_msg = boto_exception(e)
|
|
module.fail_json(msg=e_msg)
|
|
|
|
|
|
def update_dhcp_opts(connection, module, vpc_obj, dhcp_id):
|
|
|
|
if vpc_obj.dhcp_options_id != dhcp_id:
|
|
if not module.check_mode:
|
|
connection.associate_dhcp_options(dhcp_id, vpc_obj.id)
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
def get_vpc_values(vpc_obj):
|
|
|
|
if vpc_obj is not None:
|
|
vpc_values = vpc_obj.__dict__
|
|
if "region" in vpc_values:
|
|
vpc_values.pop("region")
|
|
if "item" in vpc_values:
|
|
vpc_values.pop("item")
|
|
if "connection" in vpc_values:
|
|
vpc_values.pop("connection")
|
|
return vpc_values
|
|
else:
|
|
return None
|
|
|
|
|
|
def main():
|
|
argument_spec = ec2_argument_spec()
|
|
argument_spec.update(dict(
|
|
name=dict(type='str', default=None, required=True),
|
|
cidr_block=dict(type='str', default=None, required=True),
|
|
tenancy=dict(choices=['default', 'dedicated'], default='default'),
|
|
dns_support=dict(type='bool', default=True),
|
|
dns_hostnames=dict(type='bool', default=True),
|
|
dhcp_opts_id=dict(type='str', default=None, required=False),
|
|
tags=dict(type='dict', required=False, default=None, aliases=['resource_tags']),
|
|
state=dict(choices=['present', 'absent'], default='present'),
|
|
multi_ok=dict(type='bool', default=False)
|
|
)
|
|
)
|
|
|
|
module = AnsibleModule(
|
|
argument_spec=argument_spec,
|
|
supports_check_mode=True
|
|
)
|
|
|
|
if not HAS_BOTO:
|
|
module.fail_json(msg='boto is required for this module')
|
|
|
|
name = module.params.get('name')
|
|
cidr_block = module.params.get('cidr_block')
|
|
tenancy = module.params.get('tenancy')
|
|
dns_support = module.params.get('dns_support')
|
|
dns_hostnames = module.params.get('dns_hostnames')
|
|
dhcp_id = module.params.get('dhcp_opts_id')
|
|
tags = module.params.get('tags')
|
|
state = module.params.get('state')
|
|
multi = module.params.get('multi_ok')
|
|
|
|
changed = False
|
|
|
|
region, ec2_url, aws_connect_params = get_aws_connection_info(module)
|
|
|
|
if region:
|
|
try:
|
|
connection = connect_to_aws(boto.vpc, region, **aws_connect_params)
|
|
except (NoAuthHandlerFound, AnsibleAWSError) as e:
|
|
module.fail_json(msg=str(e))
|
|
else:
|
|
module.fail_json(msg="region must be specified")
|
|
|
|
if dns_hostnames and not dns_support:
|
|
module.fail_json(msg='In order to enable DNS Hostnames you must also enable DNS support')
|
|
|
|
if state == 'present':
|
|
|
|
# Check if VPC exists
|
|
vpc_obj = vpc_exists(module, connection, name, cidr_block, multi)
|
|
|
|
if vpc_obj is None:
|
|
try:
|
|
changed = True
|
|
if not module.check_mode:
|
|
vpc_obj = connection.create_vpc(cidr_block, instance_tenancy=tenancy)
|
|
else:
|
|
module.exit_json(changed=changed)
|
|
except BotoServerError as e:
|
|
module.fail_json(msg=e)
|
|
|
|
if dhcp_id is not None:
|
|
try:
|
|
if update_dhcp_opts(connection, module, vpc_obj, dhcp_id):
|
|
changed = True
|
|
except BotoServerError as e:
|
|
module.fail_json(msg=e)
|
|
|
|
if tags is not None or name is not None:
|
|
try:
|
|
if update_vpc_tags(connection, module, vpc_obj, tags, name):
|
|
changed = True
|
|
except BotoServerError as e:
|
|
module.fail_json(msg=e)
|
|
|
|
# Note: Boto currently doesn't currently provide an interface to ec2-describe-vpc-attribute
|
|
# which is needed in order to detect the current status of DNS options. For now we just update
|
|
# the attribute each time and is not used as a changed-factor.
|
|
try:
|
|
if not module.check_mode:
|
|
connection.modify_vpc_attribute(vpc_obj.id, enable_dns_support=dns_support)
|
|
connection.modify_vpc_attribute(vpc_obj.id, enable_dns_hostnames=dns_hostnames)
|
|
except BotoServerError as e:
|
|
e_msg = boto_exception(e)
|
|
module.fail_json(msg=e_msg)
|
|
|
|
if not module.check_mode:
|
|
# get the vpc obj again in case it has changed
|
|
try:
|
|
vpc_obj = connection.get_all_vpcs(vpc_obj.id)[0]
|
|
except BotoServerError as e:
|
|
e_msg = boto_exception(e)
|
|
module.fail_json(msg=e_msg)
|
|
|
|
module.exit_json(changed=changed, vpc=get_vpc_values(vpc_obj))
|
|
|
|
elif state == 'absent':
|
|
|
|
# Check if VPC exists
|
|
vpc_obj = vpc_exists(module, connection, name, cidr_block, multi)
|
|
|
|
if vpc_obj is not None:
|
|
try:
|
|
if not module.check_mode:
|
|
connection.delete_vpc(vpc_obj.id)
|
|
vpc_obj = None
|
|
changed = True
|
|
except BotoServerError as e:
|
|
e_msg = boto_exception(e)
|
|
module.fail_json(msg="%s. You may want to use the ec2_vpc_subnet, ec2_vpc_igw, "
|
|
"and/or ec2_vpc_route_table modules to ensure the other components are absent." % e_msg)
|
|
|
|
module.exit_json(changed=changed, vpc=get_vpc_values(vpc_obj))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|