def get_account_info(module, region=None, endpoint=None, **aws_connect_kwargs):
"""return the account information (account id and partition) we are currently working on
get_account_info tries too find out the account that we are working
on. It's not guaranteed that this will be easy so we try in
several different ways. Giving either IAM or STS privileges to
the account should be enough to permit this.
"""
account_id = None
partition = None
try:
sts_client = boto3_conn(module, conn_type='client', resource='sts',
region=region, endpoint=endpoint, **aws_connect_kwargs)
caller_id = sts_client.get_caller_identity()
account_id = caller_id.get('Account')
partition = caller_id.get('Arn').split(':')[1]
except ClientError:
try:
iam_client = boto3_conn(module, conn_type='client', resource='iam',
region=region, endpoint=endpoint, **aws_connect_kwargs)
arn, partition, service, reg, account_id, resource = iam_client.get_user()['User']['Arn'].split(':')
except ClientError as e:
if (e.response['Error']['Code'] == 'AccessDenied'):
except_msg = to_native(e.message)
m = except_msg.search(r"arn:(aws(-([a-z\-]+))?):iam::([0-9]{12,32}):\w+/")
account_id = m.group(4)
partition = m.group(1)
if account_id is None:
module.fail_json_aws(e, msg="getting account information")
if partition is None:
module.fail_json_aws(e, msg="getting account information: partition")
except Exception as e:
module.fail_json_aws(e, msg="getting account information")
return account_id, partition
def run(self):
if not HAS_BOTO3:
return 'the boto3 python module is required to use this module', None, None
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
self.module, boto3=True)
self.region = region
self.al = boto3_conn(self.module,
conn_type='client',
resource='lambda',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
self.sts = boto3_conn(self.module,
conn_type='client',
resource='sts',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
choice_map = dict(
present=self.alias_present,
absent=self.alias_absent,
)
return choice_map.get(self.params['state'])()
def run(self):
if not HAS_BOTO3:
return 'the boto3 python module is required to use this module', None, None
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
self.module, boto3=True)
self.events = boto3_conn(self.module,
conn_type='client',
resource='events',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
self.iam = boto3_conn(self.module,
conn_type='resource',
resource='iam',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
self.account_id = self.iam.CurrentUser().arn.split(':')[4]
if not self.params['function_name'].startswith('arn:aws:iam:'):
self.params[
'function_name'] = 'arn:aws:lambda:%s:%s:function:%s' % (
region, self.account_id, self.params['function_name'])
choice_map = dict(
enabled=self.function_present,
disabled=self.function_present,
absent=self.function_absent,
)
return choice_map.get(self.params['state'])()
def run(self):
if not HAS_BOTO3:
return 'the boto3 python module is required to use this module', None, None
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
self.module, boto3=True)
self.al = boto3_conn(self.module,
conn_type='client',
resource='lambda',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
self.iam = boto3_conn(self.module,
conn_type='resource',
resource='iam',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
self.account_id = self.iam.CurrentUser().arn.split(':')[4]
self.params['function_arn'] = 'arn:aws:lambda:%s:%s:function:%s' % (
region, self.account_id, self.params['function_name'])
if self.params['qualifier']:
self.params['function_arn'] += ':%s' % self.params['qualifier']
choice_map = dict(
present=self.policy_present,
absent=self.policy_absent,
)
return choice_map.get(self.params['state'])()
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(dict(
state=dict(default='present', choices=['present', 'absent']),
name=dict(required=True, type='str'),
hash_key_name=dict(type='str'),
hash_key_type=dict(default='STRING', type='str', choices=['STRING', 'NUMBER', 'BINARY']),
range_key_name=dict(type='str'),
range_key_type=dict(default='STRING', type='str', choices=['STRING', 'NUMBER', 'BINARY']),
read_capacity=dict(default=1, type='int'),
write_capacity=dict(default=1, type='int'),
indexes=dict(default=[], type='list'),
tags=dict(type='dict'),
wait_for_active_timeout=dict(default=60, type='int'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_BOTO:
module.fail_json(msg='boto required for this module')
if not HAS_BOTO3 and module.params.get('tags'):
module.fail_json(msg='boto3 required when using tags for this module')
region, ec2_url, aws_connect_params = get_aws_connection_info(module)
if not region:
module.fail_json(msg='region must be specified')
try:
connection = connect_to_aws(boto.dynamodb2, region, **aws_connect_params)
except (NoAuthHandlerFound, AnsibleAWSError) as e:
module.fail_json(msg=str(e))
if module.params.get('tags'):
try:
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
boto3_dynamodb = boto3_conn(module, conn_type='client', resource='dynamodb', region=region, endpoint=ec2_url, **aws_connect_kwargs)
if not hasattr(boto3_dynamodb, 'tag_resource'):
module.fail_json(msg='boto3 connection does not have tag_resource(), likely due to using an old version')
boto3_sts = boto3_conn(module, conn_type='client', resource='sts', region=region, endpoint=ec2_url, **aws_connect_kwargs)
except botocore.exceptions.NoCredentialsError as e:
module.fail_json(msg='cannot connect to AWS', exception=traceback.format_exc())
else:
boto3_dynamodb = None
boto3_sts = None
state = module.params.get('state')
if state == 'present':
create_or_update_dynamo_table(connection, module, boto3_dynamodb, boto3_sts, region)
elif state == 'absent':
delete_dynamo_table(connection, module)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(dict(log_group_name=dict(), ))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'cloudwatchlogs_log_group_facts':
module.deprecate(
"The 'cloudwatchlogs_log_group_facts' module has been renamed to 'cloudwatchlogs_log_group_info'",
version='2.13')
if not HAS_BOTO3:
module.fail_json(msg='boto3 is required.')
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module,
boto3=True)
logs = boto3_conn(module,
conn_type='client',
resource='logs',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
desc_log_group = describe_log_group(
client=logs,
log_group_name=module.params['log_group_name'],
module=module)
final_log_group_snake = []
for log_group in desc_log_group['logGroups']:
final_log_group_snake.append(camel_dict_to_snake_dict(log_group))
desc_log_group_result = dict(changed=False,
log_groups=final_log_group_snake)
module.exit_json(**desc_log_group_result)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(
name=dict(required=False, default=[], type='list'),
sort=dict(required=False, default=None,
choices=['launch_configuration_name', 'image_id', 'created_time', 'instance_type', 'kernel_id', 'ramdisk_id', 'key_name']),
sort_order=dict(required=False, default='ascending',
choices=['ascending', 'descending']),
sort_start=dict(required=False, type='int'),
sort_end=dict(required=False, type='int'),
)
)
module = AnsibleModule(argument_spec=argument_spec)
if module._name == 'ec2_lc_facts':
module.deprecate("The 'ec2_lc_facts' module has been renamed to 'ec2_lc_info'", version='2.13')
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
if region:
connection = boto3_conn(module, conn_type='client', resource='autoscaling', region=region, endpoint=ec2_url, **aws_connect_params)
else:
module.fail_json(msg="region must be specified")
list_launch_configs(connection, module)
def __init__(self, ansible_obj, resources, boto3=True):
ansible_obj.deprecate(
"The 'ansible.module_utils.aws.batch.AWSConnection' class is deprecated please use 'AnsibleAWSModule.client()'",
version='2.14')
self.region, self.endpoint, aws_connect_kwargs = get_aws_connection_info(
ansible_obj, boto3=boto3)
self.resource_client = dict()
if not resources:
resources = ['batch']
resources.append('iam')
for resource in resources:
aws_connect_kwargs.update(
dict(region=self.region,
endpoint=self.endpoint,
conn_type='client',
resource=resource))
self.resource_client[resource] = boto3_conn(
ansible_obj, **aws_connect_kwargs)
# if region is not provided, then get default profile/session region
if not self.region:
self.region = self.resource_client['batch'].meta.region_name
# set account ID
try:
self.account_id = self.resource_client['iam'].get_user(
)['User']['Arn'].split(':')[4]
except (ClientError, ValueError, KeyError, IndexError):
self.account_id = ''
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(load_balancer_arns=dict(type='list'), names=dict(type='list')))
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[['load_balancer_arns',
'names']],
supports_check_mode=True)
if module._name == 'elb_application_lb_facts':
module.deprecate(
"The 'elb_application_lb_facts' module has been renamed to 'elb_application_lb_info'",
version='2.13')
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
region, ec2_url, aws_connect_params = get_aws_connection_info(module,
boto3=True)
if region:
connection = boto3_conn(module,
conn_type='client',
resource='elbv2',
region=region,
endpoint=ec2_url,
**aws_connect_params)
else:
module.fail_json(msg="region must be specified")
list_load_balancers(connection, module)
def main():
argument_spec = dict(load_balancer_arns=dict(type='list', elements='str'),
names=dict(type='list', elements='str'))
module = AnsibleAWSModule(
argument_spec=argument_spec,
mutually_exclusive=[['load_balancer_arns', 'names']],
supports_check_mode=True,
)
if module._name == 'elb_application_lb_facts':
module.deprecate(
"The 'elb_application_lb_facts' module has been renamed to 'elb_application_lb_info'",
date='2021-12-01',
collection_name='community.aws')
region, ec2_url, aws_connect_params = get_aws_connection_info(module,
boto3=True)
if region:
connection = boto3_conn(module,
conn_type='client',
resource='elbv2',
region=region,
endpoint=ec2_url,
**aws_connect_params)
else:
module.fail_json(msg="region must be specified")
list_load_balancers(connection, module)
def __init__(self, module):
self.module = module
# self.ecs = boto3.client('ecs')
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
self.ecs = boto3_conn(module, conn_type='client', resource='ecs',
region=region, endpoint=ec2_url, **aws_connect_kwargs)
def __init__(self, ansible_obj, resources, boto3_=True):
try:
self.region, self.endpoint, aws_connect_kwargs = get_aws_connection_info(ansible_obj, boto3=boto3_)
self.resource_client = dict()
if not resources:
resources = ['lambda']
resources.append('iam')
for resource in resources:
aws_connect_kwargs.update(dict(region=self.region,
endpoint=self.endpoint,
conn_type='client',
resource=resource
))
self.resource_client[resource] = boto3_conn(ansible_obj, **aws_connect_kwargs)
# if region is not provided, then get default profile/session region
if not self.region:
self.region = self.resource_client['lambda'].meta.region_name
except (ClientError, ParamValidationError, MissingParametersError) as e:
ansible_obj.fail_json(msg="Unable to connect, authorize or access resource: {0}".format(e))
try:
self.account_id = self.resource_client['iam'].get_user()['User']['Arn'].split(':')[4]
except (ClientError, ValueError, KeyError, IndexError):
self.account_id = ''
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(
deregister_unused=dict(type='bool', default=False),
target_az=dict(type='str'),
target_group_arn=dict(type='str'),
target_group_name=dict(type='str'),
target_id=dict(type='str', required=True),
target_port=dict(type='int'),
target_status=dict(choices=['initial', 'healthy', 'unhealthy', 'unused', 'draining', 'unavailable'], type='str'),
target_status_timeout=dict(type='int', default=60),
state=dict(required=True, choices=['present', 'absent'], type='str'),
)
)
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[['target_group_arn', 'target_group_name']]
)
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
connection = boto3_conn(module, conn_type='client', resource='elbv2', region=region, endpoint=ec2_url, **aws_connect_params)
state = module.params.get("state")
if state == 'present':
register_target(connection, module)
else:
deregister_target(connection, module)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(filters=dict(type='dict'),
pending_deletion=dict(type='bool', default=False)))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'aws_kms_facts':
module.deprecate(
"The 'aws_kms_facts' module has been renamed to 'aws_kms_info'",
version='2.13')
if not HAS_BOTO3:
module.fail_json(msg='boto3 and botocore are required for this module')
region, ec2_url, aws_connect_params = get_aws_connection_info(module,
boto3=True)
if region:
connection = boto3_conn(module,
conn_type='client',
resource='kms',
region=region,
endpoint=ec2_url,
**aws_connect_params)
else:
module.fail_json(msg="region must be specified")
all_keys = get_kms_info(connection, module)
module.exit_json(keys=[
key for key in all_keys
if key_matches_filters(key, module.params['filters'])
])
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(filters=dict(type='dict', default={}),
dry_run=dict(type='bool', default=False, aliases=['DryRun']),
dhcp_options_ids=dict(type='list', aliases=['DhcpOptionIds'])))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'ec2_vpc_dhcp_option_facts':
module.deprecate(
"The 'ec2_vpc_dhcp_option_facts' module has been renamed to 'ec2_vpc_dhcp_option_info'",
version='2.13')
# Validate Requirements
if not HAS_BOTO3:
module.fail_json(msg='boto3 and botocore are required.')
try:
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
module, boto3=True)
connection = boto3_conn(module,
conn_type='client',
resource='ec2',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
except botocore.exceptions.NoCredentialsError as e:
module.fail_json(msg="Can't authorize connection - " + str(e))
# call your function here
results = list_dhcp_options(connection, module)
module.exit_json(dhcp_options=results)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(source_region=dict(required=True),
source_snapshot_id=dict(required=True),
description=dict(default=''),
encrypted=dict(type='bool', default=False, required=False),
kms_key_id=dict(type='str', required=False),
wait=dict(type='bool', default=False),
wait_timeout=dict(type='int', default=600),
tags=dict(type='dict')))
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_BOTO3:
module.fail_json(msg='botocore and boto3 are required.')
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module,
boto3=True)
client = boto3_conn(module,
conn_type='client',
resource='ec2',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
copy_snapshot(module, client)
def main():
argument_spec = dict(
filters=dict(type='dict'),
pending_deletion=dict(type='bool', default=False),
)
module = AnsibleAWSModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'aws_kms_facts':
module.deprecate(
"The 'aws_kms_facts' module has been renamed to 'aws_kms_info'",
date='2021-12-01',
collection_name='community.aws')
region, ec2_url, aws_connect_params = get_aws_connection_info(module,
boto3=True)
if region:
connection = boto3_conn(module,
conn_type='client',
resource='kms',
region=region,
endpoint=ec2_url,
**aws_connect_params)
else:
module.fail_json(msg="region must be specified")
all_keys = get_kms_info(connection, module)
module.exit_json(keys=[
key for key in all_keys
if key_matches_filters(key, module.params['filters'])
])
def main():
argument_spec = dict(instance_ids=dict(default=[],
type='list',
elements='str'),
filters=dict(default={}, type='dict'))
module = AnsibleAWSModule(
argument_spec=argument_spec,
mutually_exclusive=[['instance_ids', 'filters']],
supports_check_mode=True,
)
if module._name == 'ec2_instance_facts':
module.deprecate(
"The 'ec2_instance_facts' module has been renamed to 'ec2_instance_info'",
date='2021-12-01',
collection_name='community.aws')
region, ec2_url, aws_connect_params = get_aws_connection_info(module,
boto3=True)
if region:
connection = boto3_conn(module,
conn_type='client',
resource='ec2',
region=region,
endpoint=ec2_url,
**aws_connect_params)
else:
module.fail_json(msg="region must be specified")
list_ec2_instances(connection, module)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(
filters=dict(default={}, type='dict'),
nat_gateway_ids=dict(default=[], type='list'),
)
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'ec2_vpc_nat_gateway_facts':
module.deprecate("The 'ec2_vpc_nat_gateway_facts' module has been renamed to 'ec2_vpc_nat_gateway_info'", version='2.13')
# Validate Requirements
if not HAS_BOTO3:
module.fail_json(msg='botocore/boto3 is required.')
try:
region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
if region:
connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_params)
else:
module.fail_json(msg="region must be specified")
except botocore.exceptions.NoCredentialsError as e:
module.fail_json(msg=str(e))
results = get_nat_gateways(connection, module)
module.exit_json(result=results)
def main():
argument_spec = dict(
filters=dict(default={}, type='dict'),
nat_gateway_ids=dict(default=[], type='list', elements='str'),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
if module._name == 'ec2_vpc_nat_gateway_facts':
module.deprecate(
"The 'ec2_vpc_nat_gateway_facts' module has been renamed to 'ec2_vpc_nat_gateway_info'",
date='2021-12-01',
collection_name='community.aws')
try:
region, ec2_url, aws_connect_params = get_aws_connection_info(
module, boto3=True)
if region:
connection = boto3_conn(module,
conn_type='client',
resource='ec2',
region=region,
endpoint=ec2_url,
**aws_connect_params)
else:
module.fail_json(msg="region must be specified")
except botocore.exceptions.NoCredentialsError as e:
module.fail_json(msg=str(e))
results = get_nat_gateways(connection, module)
module.exit_json(result=results)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(name=dict(required=True),
image_id=dict(),
instance_id=dict(),
key_name=dict(),
security_groups=dict(default=[], type='list'),
user_data=dict(),
user_data_path=dict(type='path'),
kernel_id=dict(),
volumes=dict(type='list'),
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'),
associate_public_ip_address=dict(
type='bool',
removed_at_date='2022-06-01',
removed_from_collection='community.aws'),
instance_monitoring=dict(default=False, type='bool'),
assign_public_ip=dict(type='bool'),
classic_link_vpc_security_groups=dict(type='list'),
classic_link_vpc_id=dict(),
vpc_id=dict(),
placement_tenancy=dict(choices=['default', 'dedicated'])))
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[['user_data',
'user_data_path']])
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
try:
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
module, boto3=True)
connection = boto3_conn(module,
conn_type='client',
resource='autoscaling',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
except botocore.exceptions.NoRegionError:
module.fail_json(msg=(
"region must be specified as a parameter in AWS_DEFAULT_REGION environment variable or in boto configuration file"
))
except botocore.exceptions.ClientError as e:
module.fail_json(msg="unable to establish connection - " + str(e),
exception=traceback.format_exc(),
**camel_dict_to_snake_dict(e.response))
state = module.params.get('state')
if state == 'present':
create_launch_config(connection, module)
elif state == 'absent':
delete_launch_config(connection, module)
def main():
argument_spec = dict(log_group_name=dict(), )
module = AnsibleAWSModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'cloudwatchlogs_log_group_facts':
module.deprecate(
"The 'cloudwatchlogs_log_group_facts' module has been renamed to 'cloudwatchlogs_log_group_info'",
date='2021-12-01',
collection_name='community.aws')
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module,
boto3=True)
logs = boto3_conn(module,
conn_type='client',
resource='logs',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
desc_log_group = describe_log_group(
client=logs,
log_group_name=module.params['log_group_name'],
module=module)
final_log_group_snake = []
for log_group in desc_log_group['logGroups']:
final_log_group_snake.append(camel_dict_to_snake_dict(log_group))
desc_log_group_result = dict(changed=False,
log_groups=final_log_group_snake)
module.exit_json(**desc_log_group_result)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(state=dict(default='present', choices=['present', 'absent']),
name=dict(),
amazon_asn=dict(),
virtual_gateway_id=dict(),
direct_connect_gateway_id=dict(),
wait_timeout=dict(type='int', default=320)))
required_if = [('state', 'present', ['name', 'amazon_asn']),
('state', 'absent', ['direct_connect_gateway_id'])]
module = AnsibleModule(argument_spec=argument_spec,
required_if=required_if)
if not HAS_BOTO3:
module.fail_json(msg='boto3 is required for this module')
state = module.params.get('state')
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module,
boto3=True)
client = boto3_conn(module,
conn_type='client',
resource='directconnect',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
if state == 'present':
(changed, results) = ensure_present(client, module)
elif state == 'absent':
changed = ensure_absent(client, module)
results = {}
module.exit_json(changed=changed, **camel_dict_to_snake_dict(results))
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(dict(user_name=dict(required=False, default=None)))
module = AnsibleModule(argument_spec=argument_spec)
if module._name == 'iam_mfa_device_facts':
module.deprecate(
"The 'iam_mfa_device_facts' module has been renamed to 'iam_mfa_device_info'",
version='2.13')
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module,
boto3=True)
if region:
connection = boto3_conn(module,
conn_type='client',
resource='iam',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
else:
module.fail_json(msg="region must be specified")
list_mfa_devices(connection, module)
def main():
"""
Get list of S3 buckets
:return:
"""
# Ensure we have an empty dict
result = {}
# Including ec2 argument spec
module = AnsibleModule(argument_spec=ec2_argument_spec(), supports_check_mode=True)
is_old_facts = module._name == 'aws_s3_bucket_facts'
if is_old_facts:
module.deprecate("The 'aws_s3_bucket_facts' module has been renamed to 'aws_s3_bucket_info', "
"and the renamed one no longer returns ansible_facts", version='2.13')
# Verify Boto3 is used
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
# Set up connection
region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=HAS_BOTO3)
connection = boto3_conn(module, conn_type='client', resource='s3', region=region, endpoint=ec2_url,
**aws_connect_params)
# Gather results
result['buckets'] = get_bucket_list(module, connection)
# Send exit
if is_old_facts:
module.exit_json(msg="Retrieved s3 facts.", ansible_facts=result)
else:
module.exit_json(msg="Retrieved s3 info.", **result)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(
query=dict(choices=['services', 'endpoints'], required=True),
filters=dict(default={}, type='dict'),
vpc_endpoint_ids=dict(type='list'),
)
)
module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
if module._name == 'ec2_vpc_endpoint_facts':
module.deprecate("The 'ec2_vpc_endpoint_facts' module has been renamed to 'ec2_vpc_endpoint_info'", date='2021-12-01', collection_name='community.aws')
# Validate Requirements
if not HAS_BOTO3:
module.fail_json(msg='botocore and boto3 are required.')
try:
region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
if region:
connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_params)
else:
module.fail_json(msg="region must be specified")
except botocore.exceptions.NoCredentialsError as e:
module.fail_json(msg=str(e))
invocations = {
'services': get_supported_services,
'endpoints': get_endpoints,
}
results = invocations[module.params.get('query')](connection, module)
module.exit_json(**results)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(
instance_ids=dict(default=[], type='list'),
filters=dict(default={}, type='dict')
)
)
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[
['instance_ids', 'filters']
],
supports_check_mode=True
)
if module._name == 'ec2_instance_facts':
module.deprecate("The 'ec2_instance_facts' module has been renamed to 'ec2_instance_info'", version='2.13')
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
if region:
connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_params)
else:
module.fail_json(msg="region must be specified")
list_ec2_instances(connection, module)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(dict(
state=dict(default='present', choices=['present', 'absent']),
name=dict(),
vpn_gateway_id=dict(),
vpc_id=dict(),
asn=dict(type='int'),
wait_timeout=dict(type='int', default=320),
type=dict(default='ipsec.1', choices=['ipsec.1']),
tags=dict(default=None, required=False, type='dict', aliases=['resource_tags']),
)
)
module = AnsibleModule(argument_spec=argument_spec,
required_if=[['state', 'present', ['name']]])
if not HAS_BOTO3:
module.fail_json(msg='json and boto3 is required.')
state = module.params.get('state').lower()
try:
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
client = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_kwargs)
except botocore.exceptions.NoCredentialsError as e:
module.fail_json(msg="Can't authorize connection - %s" % to_native(e), exception=traceback.format_exc())
if state == 'present':
(changed, results) = ensure_vgw_present(client, module)
else:
(changed, results) = ensure_vgw_absent(client, module)
module.exit_json(changed=changed, vgw=results)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(
dict(filters=dict(type='dict', default=dict()),
vpn_gateway_ids=dict(type='list', default=None)))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'ec2_vpc_vgw_facts':
module.deprecate(
"The 'ec2_vpc_vgw_facts' module has been renamed to 'ec2_vpc_vgw_info'",
version='2.13')
# Validate Requirements
if not HAS_BOTO3:
module.fail_json(msg='json and boto3 is required.')
try:
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
module, boto3=True)
connection = boto3_conn(module,
conn_type='client',
resource='ec2',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
except botocore.exceptions.NoCredentialsError as e:
module.fail_json(msg="Can't authorize connection - " + str(e))
# call your function here
results = list_virtual_gateways(connection, module)
module.exit_json(virtual_gateways=results)
def main():
argument_spec = ec2_argument_spec()
argument_spec.update(dict(name=dict(type='str'), ))
module = AnsibleModule(argument_spec=argument_spec, )
if module._name == 'iam_server_certificate_facts':
module.deprecate(
"The 'iam_server_certificate_facts' module has been renamed to 'iam_server_certificate_info'",
date='2021-12-01',
collection_name='community.aws')
if not HAS_BOTO3:
module.fail_json(msg='boto3 required for this module')
try:
region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
module, boto3=True)
iam = boto3_conn(module,
conn_type='client',
resource='iam',
region=region,
endpoint=ec2_url,
**aws_connect_kwargs)
except botocore.exceptions.ClientError as e:
module.fail_json(msg="Boto3 Client Error - " + str(e.msg))
cert_name = module.params.get('name')
results = get_server_certs(iam, cert_name)
module.exit_json(results=results)
