既存のAWSアカウントを新しい設定に移行する

import argparse
import requests
import time
import csv
import json
import boto3
import random
from botocore.exceptions import ClientError
import concurrent.futures
from datetime import datetime


STACK_UP_TO_DATE = 'No updates are to be performed'
STACK_NOT_EXIST = 'does not exist'
MAX_RETRIES = 8
MIN_STACK_WAIT = 1
MAX_STACK_WAIT = 10
CLOUDFORMATION_SERVICE = 'cloudformation'
STACK_NAME = 'netskopeCAR'
STACK_SUCC_STATES = ['CREATE_COMPLETE','UPDATE_COMPLETE']
IN_PROGRESS = 'IN_PROGRESS'
ROLLED_BACK = 'ROLLBACK_COMPLETE'
FAILED = 'FAILED'
STACKS = 'Stacks'
STACK_STATUS = 'StackStatus'
STACK_ID = 'StackId'
STACK_STATUS_REASON = 'StackStatusReason'

APP = "aws"
PATH = "/api/v1/public_cloud/account"


def get_instance(hostname, app, instance_name, token):
    """
    Get instance details
    :param hostname: tenant host
    :param app: app name 'aws'
    :param instance_name: name of the instance
    :param token: REST API token
    :return: instance details or Exception
    """
    print("Getting info for {}".format(instance_name))
    params = {
        "app": app,
        "instance_name": instance_name,
        "token": token
    }
    headers = { "Content-Type" : "application/json", "Accept" : "application/json" }
    get_response = requests.get("https://{}/api/v1/introspection_instance".format(hostname), headers=headers, params=params, verify=False)
    response_data = {}
    json_output = json.loads(get_response.text)
    if json_output.get("status") == "error":
        raise Exception('Errors: {}'.format(json_output.get("errors")))
    response_data["use_for"] = json_output["data"]["instance"]["use_for"]
    response_data["admin_email"] = json_output["data"]["instance"]["admin_email"]
    if "securityscan" in response_data["use_for"]:
        response_data["securityscan_interval"] =  json_output["data"]["instance"]["securityscan_interval"]
    print("Returning info for name {}: {}".format(instance_name, response_data))
    return response_data

def download_cft(hostname, token, app, instance_name, admin_email, usefor, securityscan_interval):
    """
    call the download of the migration CFT for the instance
    :param hostname: tenant host
    :param token: REST API token
    :param app: app name 'aws'
    :param instance_name: instance name
    :param admin_email: admin email for the instance
    :param usefor: services used by the instance
    :param securityscan_interval: security scan interval
    :return: CFT content or Exception
    """
    print("Downloading Migration Template for {}".format(instance_name))
    qparams = {"token":token, "op":"download"}
    headers = { "Content-Type" : "application/json" }
    data = {
        "app": app,
        "type": "cft",
        "use_for": usefor,
        "mode" : "migrate",
        "admin_email" : admin_email,
        "instance_name": instance_name,
        "securityscan_interval": securityscan_interval
    }
    res = requests.post("https://{}{}".format(hostname, PATH), headers=headers, params=qparams, data=json.dumps(data), verify=False)
    response = res.text
    if response.startswith("{"):
        json_output = json.loads(response)
        if json_output.get("status") == "error":
            raise Exception('For instance "{}" errors received: {}'.format(instance_name, json_output.get("errors")))
    return response

def create_resource(instance_name, region, access_key, secret_key, template):
    """
    Call stack creation and wait the stack creation to be completed
    :param instance_name: name of the instance
    :param region: region in which the stack will be created
    :param access_key: access key id for target aws account
    :param secret_key: secret key for the target aws account
    :param template: CFT template
    :return: Exception if encountered
    """
    try:
        print("creating stacks....")
        client = boto3.client(CLOUDFORMATION_SERVICE,
                                    aws_access_key_id=access_key,
                                    aws_secret_access_key=secret_key,
                                    region_name=region)
        if not stack_exists(client, STACK_NAME, region):
            print("stack does not exist, creating stack")
            response = client.create_stack(
                StackName=STACK_NAME,
                TemplateBody=template,
                Capabilities=['CAPABILITY_NAMED_IAM']
            )
            now = datetime.now()
            start_time = datetime.timestamp(now)
        else:
            raise Exception("Stack already present for instance: {}".format(instance_name))
        print("Waiting Stack creation to be completed for {}".format(instance_name))
        while True:
            time.sleep(random.randint(MIN_STACK_WAIT, MAX_STACK_WAIT))
            stacks = client.describe_stacks(StackName=response[STACK_ID])
            stack_status = stacks[STACKS][0][STACK_STATUS]
            if stack_status in STACK_SUCC_STATES:
                print("Stack creation for {} was successful".format(instance_name))
                break
            if IN_PROGRESS not in stack_status:
                if stack_status == ROLLED_BACK or FAILED in stack_status:
                    reason = stacks[STACKS][0].get(STACK_STATUS_REASON)
                    if reason:
                        raise Exception("Exception received while creating stack {} for instance : {} , {}".format(STACK_NAME, instance_name, reason))
                    else:
                        raise
            current_time = datetime.timestamp(datetime.now())
            if start_time + 600 < current_time:
                raise Exception("Stack creation for {} took longer than expected, please check the AWS console".format(instance_name))
    except ClientError as exc:
        if STACK_UP_TO_DATE not in str(exc):
            raise
        else:
            print("{} Stack {} already up to date and no updates are to be performed".format(instance_name, STACK_NAME))
    except Exception as exc:
        raise

def stack_exists(client, name, region):
    """
    Check if the stack with the provided name is already present
    :param client: client
    :param name: name of the stack
    :param region: region in which the stack is to be deployed
    :return: true if stack exists
    """
    try:
        while True:
            stacks = client.describe_stacks(StackName=name)
            stack_status = stacks[STACKS][0][STACK_STATUS]
            if 'IN_PROGRESS' in stack_status:
                time.sleep(random.randint(MIN_STACK_WAIT, MAX_STACK_WAIT))
            elif ROLLED_BACK == stack_status or FAILED in stack_status:
                print("Stack in {} state. Stack cannot be recovered, triggering
                     deleting stack in region : {}".format(stack_status, region))
                client.delete_stack(StackName=STACK_NAME)
                time.sleep(random.randint(MIN_STACK_WAIT, MAX_STACK_WAIT))
            else:
                return True
    except ClientError as exc:
        if STACK_NOT_EXIST in str(exc):
            return False
        else:
            raise

def start_migration(row):
    """
    Caller method for gathering the instance details
    call methods for
    Getting instance details
    Download migration CFT
    call creation of stack
    :param row: single row containing the instance details
    :return:
    """
    details = {
            "instance_name": row[0],
            "apitoken": row[1],
            "tenant_url": row[2],
            "access_key_id" : row[3],
            "secret_key": row[4],
            "region": row[5]
    }
    hostname = details["tenant_url"]
    instance_name = details["instance_name"]
    apitoken = details["apitoken"]
    region = details["region"]
    access_key_id = details["access_key_id"]
    secret_key = details["secret_key"]
    try:
        response_data = get_instance(hostname, APP, instance_name, apitoken)
        use_for = response_data["use_for"]
        admin_email = response_data["admin_email"]
        securityscan_interval = response_data.get("securityscan_interval")
        print("{}, {}".format(use_for, admin_email))
        cft_yaml_body = download_cft(hostname, apitoken, APP, instance_name,
                                     admin_email, use_for, securityscan_interval)
        create_resource(instance_name, region, access_key_id, secret_key, cft_yaml_body)
        print('Migration triggered successfully for : {}'.format(instance_name))
    except Exception as exc:
        return "For {} Exception received : {}".format(instance_name, str(exc))

if __name__ == "__main__":
    """
    Customer will create and provide location of the csv file from which each instance
    migration will be triggered. Migration contains the following parts
    1-> get instance details for the instance
    2-> download migration CFT for the instance
    3-> trigger create of stack with the downloaded CFT
    4-> Wait for the stack creation to be completed
    5-> post success or failure of the migration
    """
    PARSER = argparse.ArgumentParser()
    PARSER.add_argument("--file", help="csv file", required=True)
    ARGS = PARSER.parse_args()
    file_path = ARGS.file
    results = []
    if str(file_path).endswith(".csv"):
        with open(file_path) as f:
            reader = csv.reader(f)
            with concurrent.futures.ThreadPoolExecutor(max_workers=200) as executor:
                futures = [executor.submit(start_migration, row) for row in reader]
                for idx, future in enumerate(concurrent.futures.as_completed(futures)):
                    try:
                        res = future.result(timeout=600)
                        results.append(res)
                    except concurrent.futures._base.TimeoutError as exc:
                        print("timeout_error {} {}".format(str(exc), future))
        print("FAILED RESULTS : {}".format(results))
    else:
        print("Expected a csv file and file path: {} is not a csv file".format(file_path))

python migration_script.py --file <path-to-csv>