__ __ __ __ _____ _ _ _____ _ _ _ | \/ | \ \ / / | __ \ (_) | | / ____| | | | | | \ / |_ __\ V / | |__) | __ ___ ____ _| |_ ___ | (___ | |__ ___| | | | |\/| | '__|> < | ___/ '__| \ \ / / _` | __/ _ \ \___ \| '_ \ / _ \ | | | | | | |_ / . \ | | | | | |\ V / (_| | || __/ ____) | | | | __/ | | |_| |_|_(_)_/ \_\ |_| |_| |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1 if you need WebShell for Seo everyday contact me on Telegram Telegram Address : @jackleetFor_More_Tools:
# This file is part of Ansible
# 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
DOCUMENTATION = '''
---
module: dms_endpoint
version_added: 1.0.0
short_description: Creates or destroys a data migration services endpoint
description:
- Creates or destroys a data migration services endpoint,
that can be used to replicate data.
options:
state:
description:
- State of the endpoint.
default: present
choices: ['present', 'absent']
type: str
endpointidentifier:
description:
- An identifier name for the endpoint.
type: str
required: true
endpointtype:
description:
- Type of endpoint we want to manage.
- Required when I(state=present).
choices: ['source', 'target']
type: str
enginename:
description:
- Database engine that we want to use, please refer to
the AWS DMS for more information on the supported
engines and their limitations.
- Required when I(state=present).
choices: ['mysql', 'oracle', 'postgres', 'mariadb', 'aurora',
'redshift', 's3', 'db2', 'azuredb', 'sybase',
'dynamodb', 'mongodb', 'sqlserver']
type: str
username:
description:
- Username our endpoint will use to connect to the database.
type: str
password:
description:
- Password used to connect to the database
this attribute can only be written
the AWS API does not return this parameter.
type: str
servername:
description:
- Servername that the endpoint will connect to.
type: str
port:
description:
- TCP port for access to the database.
type: int
databasename:
description:
- Name for the database on the origin or target side.
type: str
extraconnectionattributes:
description:
- Extra attributes for the database connection, the AWS documentation
states " For more information about extra connection attributes,
see the documentation section for your data store."
type: str
kmskeyid:
description:
- Encryption key to use to encrypt replication storage and
connection information.
type: str
tags:
description:
- A list of tags to add to the endpoint.
type: dict
certificatearn:
description:
- Amazon Resource Name (ARN) for the certificate.
type: str
sslmode:
description:
- Mode used for the SSL connection.
default: none
choices: ['none', 'require', 'verify-ca', 'verify-full']
type: str
serviceaccessrolearn:
description:
- Amazon Resource Name (ARN) for the service access role that you
want to use to create the endpoint.
type: str
externaltabledefinition:
description:
- The external table definition.
type: str
dynamodbsettings:
description:
- Settings in JSON format for the target Amazon DynamoDB endpoint
if source or target is dynamodb.
type: dict
s3settings:
description:
- S3 buckets settings for the target Amazon S3 endpoint.
type: dict
dmstransfersettings:
description:
- The settings in JSON format for the DMS transfer type of
source endpoint.
type: dict
mongodbsettings:
description:
- Settings in JSON format for the source MongoDB endpoint.
type: dict
kinesissettings:
description:
- Settings in JSON format for the target Amazon Kinesis
Data Streams endpoint.
type: dict
elasticsearchsettings:
description:
- Settings in JSON format for the target Elasticsearch endpoint.
type: dict
wait:
description:
- Whether Ansible should wait for the object to be deleted when I(state=absent).
type: bool
default: false
timeout:
description:
- Time in seconds we should wait for when deleting a resource.
- Required when I(wait=true).
type: int
retries:
description:
- number of times we should retry when deleting a resource
- Required when I(wait=true).
type: int
author:
- "Rui Moreira (@ruimoreira)"
extends_documentation_fragment:
- amazon.aws.aws
- amazon.aws.ec2
- amazon.aws.boto3
- amazon.aws.tags
'''
EXAMPLES = '''
# Note: These examples do not set authentication details
- name: Endpoint Creation
community.aws.dms_endpoint:
state: absent
endpointidentifier: 'testsource'
endpointtype: source
enginename: aurora
username: testing1
password: testint1234
servername: testing.domain.com
port: 3306
databasename: 'testdb'
sslmode: none
wait: false
'''
RETURN = '''
endpoint:
description:
- A description of the DMS endpoint.
returned: success
type: dict
contains:
database_name:
description:
- The name of the database at the endpoint.
type: str
returned: success
example: "exampledb"
endpoint_arn:
description:
- The ARN that uniquely identifies the endpoint.
type: str
returned: success
example: "arn:aws:dms:us-east-1:123456789012:endpoint:1234556789ABCDEFGHIJKLMNOPQRSTUVWXYZ012"
endpoint_identifier:
description:
- The database endpoint identifier.
type: str
returned: success
example: "ansible-test-12345678-dms"
endpoint_type:
description:
- The type of endpoint. Valid values are C(SOURCE) and C(TARGET).
type: str
returned: success
example: "SOURCE"
engine_display_name:
description:
- The expanded name for the engine name.
type: str
returned: success
example: "Amazon Aurora MySQL"
engine_name:
description:
- The database engine name.
type: str
returned: success
example: "aurora"
kms_key_id:
description:
- An KMS key ID that is used to encrypt the connection parameters for the endpoint.
type: str
returned: success
example: "arn:aws:kms:us-east-1:123456789012:key/01234567-abcd-12ab-98fe-123456789abc"
port:
description:
- The port used to access the endpoint.
type: str
returned: success
example: 3306
server_name:
description:
- The name of the server at the endpoint.
type: str
returned: success
example: "ansible-test-123456789.example.com"
ssl_mode:
description:
- The SSL mode used to connect to the endpoint.
type: str
returned: success
example: "none"
tags:
description:
- A dictionary representing the tags attached to the endpoint.
type: dict
returned: success
example: {"MyTagKey": "MyTagValue"}
username:
description:
- The user name used to connect to the endpoint.
type: str
returned: success
example: "example-username"
dms_transfer_settings:
description:
- Additional transfer related settings.
type: dict
returned: when additional DMS Transfer settings have been configured.
s3_settings:
description:
- Additional settings for S3 endpoints.
type: dict
returned: when the I(endpoint_type) is C(s3)
mongo_db_settings:
description:
- Additional settings for MongoDB endpoints.
type: dict
returned: when the I(endpoint_type) is C(mongodb)
kinesis_settings:
description:
- Additional settings for Kinesis endpoints.
type: dict
returned: when the I(endpoint_type) is C(kinesis)
kafka_settings:
description:
- Additional settings for Kafka endpoints.
type: dict
returned: when the I(endpoint_type) is C(kafka)
elasticsearch_settings:
description:
- Additional settings for Elasticsearch endpoints.
type: dict
returned: when the I(endpoint_type) is C(elasticsearch)
neptune_settings:
description:
- Additional settings for Amazon Neptune endpoints.
type: dict
returned: when the I(endpoint_type) is C(neptune)
redshift_settings:
description:
- Additional settings for Redshift endpoints.
type: dict
returned: when the I(endpoint_type) is C(redshift)
postgre_sql_settings:
description:
- Additional settings for PostgrSQL endpoints.
type: dict
returned: when the I(endpoint_type) is C(postgres)
my_sql_settings:
description:
- Additional settings for MySQL endpoints.
type: dict
returned: when the I(endpoint_type) is C(mysql)
oracle_settings:
description:
- Additional settings for Oracle endpoints.
type: dict
returned: when the I(endpoint_type) is C(oracle)
sybase_settings:
description:
- Additional settings for Sybase endpoints.
type: dict
returned: when the I(endpoint_type) is C(sybase)
microsoft_sql_server_settings:
description:
- Additional settings for Microsoft SQL Server endpoints.
type: dict
returned: when the I(endpoint_type) is C(sqlserver)
i_b_m_db_settings:
description:
- Additional settings for IBM DB2 endpoints.
type: dict
returned: when the I(endpoint_type) is C(db2)
doc_db_settings:
description:
- Additional settings for DocumentDB endpoints.
type: dict
returned: when the I(endpoint_type) is C(documentdb)
redis_settings:
description:
- Additional settings for Redis endpoints.
type: dict
returned: when the I(endpoint_type) is C(redshift)
'''
try:
import botocore
except ImportError:
pass # caught by AnsibleAWSModule
from ansible.module_utils.common.dict_transformations import camel_dict_to_snake_dict
from ansible_collections.amazon.aws.plugins.module_utils.core import AnsibleAWSModule
from ansible_collections.amazon.aws.plugins.module_utils.core import is_boto3_error_code
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import AWSRetry
from ansible_collections.amazon.aws.plugins.module_utils.tagging import ansible_dict_to_boto3_tag_list
from ansible_collections.amazon.aws.plugins.module_utils.tagging import boto3_tag_list_to_ansible_dict
from ansible_collections.amazon.aws.plugins.module_utils.tagging import compare_aws_tags
backoff_params = dict(retries=5, delay=1, backoff=1.5)
@AWSRetry.jittered_backoff(**backoff_params)
def dms_describe_tags(connection, **params):
""" checks if the endpoint exists """
tags = connection.list_tags_for_resource(**params).get('TagList', [])
return boto3_tag_list_to_ansible_dict(tags)
@AWSRetry.jittered_backoff(**backoff_params)
def dms_describe_endpoints(connection, **params):
try:
endpoints = connection.describe_endpoints(**params)
except is_boto3_error_code('ResourceNotFoundFault'):
return None
return endpoints.get('Endpoints', None)
def describe_endpoint(connection, endpoint_identifier):
""" checks if the endpoint exists """
endpoint_filter = dict(Name='endpoint-id',
Values=[endpoint_identifier])
try:
endpoints = dms_describe_endpoints(connection, Filters=[endpoint_filter])
except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg="Failed to describe the DMS endpoint.")
if not endpoints:
return None
endpoint = endpoints[0]
try:
tags = dms_describe_tags(connection, ResourceArn=endpoint['EndpointArn'])
endpoint['tags'] = tags
except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg="Failed to describe the DMS endpoint tags")
return endpoint
@AWSRetry.jittered_backoff(**backoff_params)
def dms_delete_endpoint(client, **params):
"""deletes the DMS endpoint based on the EndpointArn"""
if module.params.get('wait'):
return delete_dms_endpoint(client)
else:
return client.delete_endpoint(**params)
@AWSRetry.jittered_backoff(**backoff_params)
def dms_create_endpoint(client, **params):
""" creates the DMS endpoint"""
return client.create_endpoint(**params)
@AWSRetry.jittered_backoff(**backoff_params)
def dms_modify_endpoint(client, **params):
""" updates the endpoint"""
return client.modify_endpoint(**params)
@AWSRetry.jittered_backoff(**backoff_params)
def get_endpoint_deleted_waiter(client):
return client.get_waiter('endpoint_deleted')
@AWSRetry.jittered_backoff(**backoff_params)
def dms_remove_tags(client, **params):
return client.remove_tags_from_resource(**params)
@AWSRetry.jittered_backoff(**backoff_params)
def dms_add_tags(client, **params):
return client.add_tags_to_resource(**params)
def endpoint_exists(endpoint):
""" Returns boolean based on the existence of the endpoint
:param endpoint: dict containing the described endpoint
:return: bool
"""
return bool(len(endpoint['Endpoints']))
def delete_dms_endpoint(connection, endpoint_arn):
try:
delete_arn = dict(
EndpointArn=endpoint_arn
)
if module.params.get('wait'):
delete_output = connection.delete_endpoint(**delete_arn)
delete_waiter = get_endpoint_deleted_waiter(connection)
delete_waiter.wait(
Filters=[{
'Name': 'endpoint-arn',
'Values': [endpoint_arn]
}],
WaiterConfig={
'Delay': module.params.get('timeout'),
'MaxAttempts': module.params.get('retries')
}
)
return delete_output
else:
return connection.delete_endpoint(**delete_arn)
except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg="Failed to delete the DMS endpoint.")
def create_module_params():
"""
Reads the module parameters and returns a dict
:return: dict
"""
endpoint_parameters = dict(
EndpointIdentifier=module.params.get('endpointidentifier'),
EndpointType=module.params.get('endpointtype'),
EngineName=module.params.get('enginename'),
Username=module.params.get('username'),
Password=module.params.get('password'),
ServerName=module.params.get('servername'),
Port=module.params.get('port'),
DatabaseName=module.params.get('databasename'),
SslMode=module.params.get('sslmode')
)
if module.params.get('EndpointArn'):
endpoint_parameters['EndpointArn'] = module.params.get('EndpointArn')
if module.params.get('certificatearn'):
endpoint_parameters['CertificateArn'] = \
module.params.get('certificatearn')
if module.params.get('dmstransfersettings'):
endpoint_parameters['DmsTransferSettings'] = \
module.params.get('dmstransfersettings')
if module.params.get('extraconnectionattributes'):
endpoint_parameters['ExtraConnectionAttributes'] =\
module.params.get('extraconnectionattributes')
if module.params.get('kmskeyid'):
endpoint_parameters['KmsKeyId'] = module.params.get('kmskeyid')
if module.params.get('tags'):
endpoint_parameters['Tags'] = module.params.get('tags')
if module.params.get('serviceaccessrolearn'):
endpoint_parameters['ServiceAccessRoleArn'] = \
module.params.get('serviceaccessrolearn')
if module.params.get('externaltabledefinition'):
endpoint_parameters['ExternalTableDefinition'] = \
module.params.get('externaltabledefinition')
if module.params.get('dynamodbsettings'):
endpoint_parameters['DynamoDbSettings'] = \
module.params.get('dynamodbsettings')
if module.params.get('s3settings'):
endpoint_parameters['S3Settings'] = module.params.get('s3settings')
if module.params.get('mongodbsettings'):
endpoint_parameters['MongoDbSettings'] = \
module.params.get('mongodbsettings')
if module.params.get('kinesissettings'):
endpoint_parameters['KinesisSettings'] = \
module.params.get('kinesissettings')
if module.params.get('elasticsearchsettings'):
endpoint_parameters['ElasticsearchSettings'] = \
module.params.get('elasticsearchsettings')
if module.params.get('wait'):
endpoint_parameters['wait'] = module.boolean(module.params.get('wait'))
if module.params.get('timeout'):
endpoint_parameters['timeout'] = module.params.get('timeout')
if module.params.get('retries'):
endpoint_parameters['retries'] = module.params.get('retries')
return endpoint_parameters
def compare_params(param_described):
"""
Compares the dict obtained from the describe DMS endpoint and
what we are reading from the values in the template We can
never compare the password as boto3's method for describing
a DMS endpoint does not return the value for
the password for security reasons ( I assume )
"""
param_described = dict(param_described)
modparams = create_module_params()
# modify can't update tags
param_described.pop('Tags', None)
modparams.pop('Tags', None)
changed = False
for paramname in modparams:
if paramname == 'Password' or paramname in param_described \
and param_described[paramname] == modparams[paramname] or \
str(param_described[paramname]).lower() \
== modparams[paramname]:
pass
else:
changed = True
return changed
def modify_dms_endpoint(connection, endpoint):
arn = endpoint['EndpointArn']
try:
params = create_module_params()
# modify can't update tags
params.pop('Tags', None)
return dms_modify_endpoint(connection, EndpointArn=arn, **params)
except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg="Failed to update DMS endpoint.", params=params)
def ensure_tags(connection, endpoint):
desired_tags = module.params.get('tags', None)
if desired_tags is None:
return False
current_tags = endpoint.get('tags', {})
tags_to_add, tags_to_remove = compare_aws_tags(current_tags, desired_tags,
module.params.get('purge_tags'))
if not tags_to_remove and not tags_to_add:
return False
if module.check_mode:
return True
arn = endpoint.get('EndpointArn')
try:
if tags_to_remove:
dms_remove_tags(connection, ResourceArn=arn, TagKeys=tags_to_remove)
if tags_to_add:
tag_list = ansible_dict_to_boto3_tag_list(tags_to_add)
dms_add_tags(connection, ResourceArn=arn, Tags=tag_list)
except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg="Failed to update DMS endpoint tags.")
return True
def create_dms_endpoint(connection):
"""
Function to create the dms endpoint
:param connection: boto3 aws connection
:return: information about the dms endpoint object
"""
try:
params = create_module_params()
return dms_create_endpoint(connection, **params)
except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg="Failed to create DMS endpoint.")
def main():
argument_spec = dict(
state=dict(choices=['present', 'absent'], default='present'),
endpointidentifier=dict(required=True),
endpointtype=dict(choices=['source', 'target']),
enginename=dict(choices=['mysql', 'oracle', 'postgres', 'mariadb',
'aurora', 'redshift', 's3', 'db2', 'azuredb',
'sybase', 'dynamodb', 'mongodb', 'sqlserver'],
required=False),
username=dict(),
password=dict(no_log=True),
servername=dict(),
port=dict(type='int'),
databasename=dict(),
extraconnectionattributes=dict(),
kmskeyid=dict(no_log=False),
tags=dict(type='dict', aliases=['resource_tags']),
purge_tags=dict(type='bool', default=True),
certificatearn=dict(),
sslmode=dict(choices=['none', 'require', 'verify-ca', 'verify-full'],
default='none'),
serviceaccessrolearn=dict(),
externaltabledefinition=dict(),
dynamodbsettings=dict(type='dict'),
s3settings=dict(type='dict'),
dmstransfersettings=dict(type='dict'),
mongodbsettings=dict(type='dict'),
kinesissettings=dict(type='dict'),
elasticsearchsettings=dict(type='dict'),
wait=dict(type='bool', default=False),
timeout=dict(type='int'),
retries=dict(type='int')
)
global module
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=[
["state", "present", ["endpointtype"]],
["state", "present", ["enginename"]],
["state", "absent", ["wait"]],
["wait", "True", ["timeout"]],
["wait", "True", ["retries"]],
],
supports_check_mode=False
)
exit_message = None
changed = False
state = module.params.get('state')
dmsclient = module.client('dms')
endpoint = describe_endpoint(dmsclient,
module.params.get('endpointidentifier'))
if state == 'present':
if endpoint:
changed |= ensure_tags(dmsclient, endpoint)
params_changed = compare_params(endpoint)
if params_changed:
updated_dms = modify_dms_endpoint(dmsclient, endpoint)
exit_message = updated_dms
endpoint = exit_message.get('Endpoint')
changed = True
else:
exit_message = "Endpoint Already Exists"
else:
exit_message = create_dms_endpoint(dmsclient)
endpoint = exit_message.get('Endpoint')
changed = True
if changed:
# modify and create don't return tags
tags = dms_describe_tags(dmsclient, ResourceArn=endpoint['EndpointArn'])
endpoint['tags'] = tags
elif state == 'absent':
if endpoint:
delete_results = delete_dms_endpoint(dmsclient, endpoint['EndpointArn'])
exit_message = delete_results
endpoint = None
changed = True
else:
changed = False
exit_message = 'DMS Endpoint does not exist'
endpoint = camel_dict_to_snake_dict(endpoint or {}, ignore_list=['tags'])
module.exit_json(changed=changed, endpoint=endpoint, msg=exit_message)
if __name__ == '__main__':
main()