def update_rds_databases(self):
        """Update list of RDS Databases for the account / region

        Returns:
            `None`
        """
        self.log.info('Updating RDS Databases for {} / {}'.format(
            self.account, self.region
        ))
        # All RDS resources are polled via a Lambda collector in a central account
        rds_collector_account = AWSAccount.get(self.rds_collector_account)
        rds_session = get_aws_session(rds_collector_account)
        # Existing RDS resources come from database
        existing_rds_dbs = RDSInstance.get_all(self.account, self.region)

        try:
            # Special session pinned to a single account for Lambda invocation so we
            # don't have to manage lambdas in every account & region
            lambda_client = rds_session.client('lambda', region_name=self.rds_collector_region)

            # The AWS Config Lambda will collect all the non-compliant resources for all regions
            # within the account
            input_payload = json.dumps({"account_id": self.account.account_number,
                                        "region": self.region,
                                        "role": self.rds_role,
                                        "config_rule_name": self.rds_config_rule_name
                                        }).encode('utf-8')
            response = lambda_client.invoke(FunctionName=self.rds_function_name, InvocationType='RequestResponse',
                                            Payload=input_payload
                                            )
            response_payload = json.loads(response['Payload'].read().decode('utf-8'))
            if response_payload['success']:
                rds_dbs = response_payload['data']
                if rds_dbs:
                    for db_instance in rds_dbs:
                        tags = {t['Key']: t['Value'] for t in db_instance['tags'] or {}}
                        properties = {
                            'tags': tags,
                            'metrics': None,
                            'engine': db_instance['engine'],
                            'creation_date': db_instance['creation_date']
                        }
                        if db_instance['resource_name'] in existing_rds_dbs:
                            rds = existing_rds_dbs[db_instance['resource_name']]
                            if rds.update(db_instance, properties):
                                self.log.debug('Change detected for RDS instance {}/{} '
                                               .format(db_instance['resource_name'], properties))
                        else:
                            RDSInstance.create(
                                db_instance['resource_name'],
                                account_id=self.account.account_id,
                                location=db_instance['region'],
                                properties=properties,
                                tags=tags
                            )
                    # Removal of RDS instances
                    rk = set()
                    erk = set()
                    for database in rds_dbs:
                        rk.add(database['resource_name'])
                    for existing in existing_rds_dbs.keys():
                        erk.add(existing)

                    for resource_id in erk - rk:
                        db.session.delete(existing_rds_dbs[resource_id].resource)
                        self.log.debug('Removed RDS instances {}/{}'.format(
                            self.account.account_name,
                            resource_id
                        ))
                    db.session.commit()

            else:
                self.log.error('RDS Lambda Execution Failed / {} / {} / {}'.
                                format(self.account.account_name, self.region, response_payload))

        except Exception as e:
            self.log.exception('There was a problem during RDS collection for {}/{}/{}'.format(
                self.account.account_name, self.region, e
            ))
            db.session.rollback()
Update list of RDS Databases for the account / region

        Returns:
            `None`