cloudmason 0.0.1

package/commands/init_org.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+const { S3Client,HeadBucketCommand } = require("@aws-sdk/client-s3");
+const { EC2Client, DescribeVpcsCommand } = require("@aws-sdk/client-ec2");
+
+const CF = require('./helpers/cf');
+
+
+exports.main = async function(args){
+    console.log(`Setting up ${args.name}@ ${args.domain} in ${args.region}`)
+
+    // Check if bucket exists
+    const isBucket = await bucketExists(`infra.${args.domain}`);
+    if (isBucket.name){
+        console.log('ERR: Bucket infra.${args.domain} already exists in ${existingBucket.region}')
+        console.log('Org already set up or rollback still in progress')
+        throw {message: 'Org exists', at: 'init_org check for existing org'}
+    }
+
+    // Get VPC ID
+    const VpcId = await getDefaultVPC(args.region);
+    
+    // Deploy Stack
+    const success = await CF.deployOrgStack('infra', 'infra',args.region, {orgName: args.name, orgDomain: args.domain, VpcId: VpcId}, {purpose: 'infra'})
+    if (success === false){
+        console.log('ERR: Org already exists. Only one org permitted per account');
+        throw new Error('Org already exists')
+    }
+
+    // Set org.txt
+    const orgPath = path.resolve(__dirname,'..','org.txt');
+    const orgData = `${args.name},${args.region},infra.${args.domain}`;
+    fs.writeFileSync(orgPath,orgData,'utf-8')
+    console.log('Set up org:',orgData)
+    return true;
+}
+
+
+/////////////////////////////////////////
+////////////// FUNCS ////////////////////
+////////////////////////////////////////
+
+async function bucketExists(bucketName,region){
+    const client = new S3Client({region});
+    try {
+        await client.send(new HeadBucketCommand({ Bucket: bucketName }));
+        return true;
+    } catch (e){
+        return false;
+    }
+}
+
+async function getDefaultVPC(region){
+    const ec2Client = new EC2Client({ region }); 
+    const response = await ec2Client.send(new DescribeVpcsCommand({ Filters: [{ Name: "isDefault", Values: ["true"] }] }));
+    return response.Vpcs[0].VpcId;
+}
+
+
+
+

package/commands/launch_app.js

@@ -0,0 +1,57 @@
+const Params = require('./helpers/params');
+const EC2 = require('./helpers/ec2');
+const CF = require('./helpers/cf')
+
+exports.main = async function(args){
+    const app = await Params.getApp(args.app);
+    if (!app){ console.log('No app named ' + args.app); throw new Error('Invalid App Name')}
+
+    const targetInstance = app.instances.find(ins=>{ return ins.name.toLowerCase() == args.i.toLowerCase() });
+    const targetVersion = app.versions[args.v];
+    
+    if (!targetInstance){ console.log(`No instance of ${args.app} named ${args.i}`); throw new Error('Invalid Instance')}
+    if (!targetVersion){ console.log(`No version ${args.v} of ${args.app}`); throw new Error('Invalid Version')}
+
+    // --- I GET AMI ---
+    // Get Instance Region
+    const targetRegion = targetInstance.region;
+    // Get Latest AMI Build
+    const latestBuild = targetVersion.baseAMI_Name;
+    // Check for AMI Build in Instance Region
+    let targetAMI = await EC2.findAMI(latestBuild,targetRegion);
+    // Copy AMI from Org Region to Instance Region
+    if (!targetAMI){
+        console.log(`Copying ${latestBuild} from ${process.env.orgRegion} to ${targetRegion}`);
+        targetAMI = await EC2.copyAMI(latestBuild,targetVersion.baseAMI_Id,process.env.orgRegion,targetRegion)
+    } else {
+        console.log('Found existing image ' + targetAMI)
+    }
+    // Update Instance CF Params to Instance Region AMI ID
+    targetInstance.cfParams.AmiId = targetAMI;
+    await Params.editInstance(args.app,args.i,latestBuild,targetInstance.cfParams);
+    // console.log(targetInstance.cfParams);
+
+    // --- II DEPLOY CF STACK ---
+    // Get Stack URL
+    // https://s3.us-east-2.amazonaws.com/infra.orgtheorem.xyz/apps/ssdemo/1/stack.json
+    const stackName = (`${args.app}-${args.i}`).toLowerCase();
+    const stackURL = `https://s3.${process.env.orgRegion}.amazonaws.com/${process.env.orgBucket}/apps/${args.app.toLowerCase()}/${args.v}/stack.yaml`
+
+    // Check whether stack exists
+    const stackExists = await CF.stackExists(stackName,targetRegion);
+    // console.log(stackName,stackURL,targetInstance.cfParams,targetRegion);
+
+    // Update Stack
+    let stackId;
+    if (stackExists){
+        console.log(`Updating stack ${stackName} in ${targetRegion}`);
+        stackId = await CF.updateStack(stackName,stackURL,targetInstance.cfParams,targetRegion);
+    // Deploy Stack
+    } else {
+        console.log(`Deploying stack ${stackName} in ${targetRegion}`);
+        const tags = {purpose: 'app', app: args.app, instance: args.i};
+        stackId = await CF.deployS3Stack(stackName,stackURL,targetInstance.cfParams,tags,targetRegion)
+    }
+    console.log('Deployed stack ' + stackId)
+    return true;
+}

package/commands/list_apps.js

@@ -0,0 +1,22 @@
+const Params = require('./helpers/params');
+
+
+exports.main = async function(){
+    const apps = await Params.listApps();
+    for(let i=0; i<apps.length; i++){
+        const app = apps[i];
+        console.log(`${app.name} <${app.stack}>`);
+        console.log('\tVERSIONS')
+        const spaces = 10;
+        Object.entries(app.versions).forEach((k)=>{
+            const s = k[0].length > 5 ? 1 : (5 - k[0].length);
+            console.log(`\t\t[${k[0]}]${' '.repeat(s)}ami:${k[1].baseAMI_Name} | build: ${k[1].currentBuild} `)
+        })
+        console.log('\tINSTANCES')
+        app.instances.forEach(ins=>{
+            const s = ins.name.length > 7 ? 1 : (7 - ins.name.length);
+            console.log(`\t\t[${ins.name}]${' '.repeat(s)}domain:${ins.domain} | region:${ins.region} | version:${ins.version}`)
+        })
+        console.log('--------------')
+    }
+}

package/commands/new_app.js

@@ -0,0 +1,50 @@
+const { S3Client,PutObjectCommand } = require("@aws-sdk/client-s3");
+const fs = require('fs');
+const path = require('path')
+const Params = require('./helpers/params');
+const S3 = require('./helpers/s3');
+
+const nodeScript = `npm run start .`
+const pyScript = `py`
+
+exports.main = async function(args){
+    // Check for existing app
+    const existingApp = await Params.getApp(args.name);
+    if (existingApp){
+        console.log('Err: App already exists ' + args.name);
+        throw new Error('App exists')
+    }
+
+    // Check Lang Selection
+    if (args.py && args.node){
+        console.log('Cannot set both nodejs and python. Select one.');
+        throw new Error('Invalid language selection')
+    }
+
+    // Prep Stack
+    let bootScript = `#!/bin/bash -xe\ncd /home/ec2-user/app\n`;
+    let startScript = args.py ? pyScript : nodeScript;
+    bootScript += startScript;
+    const stackText = prepStack(args.type,bootScript)
+
+    // Upload Stack
+    console.log(`Uploading ${args.type} to ${process.env.orgBucket}`)
+    const stackKey = `apps/${args.name.toLowerCase()}/default_stack.yaml`
+    await S3.uploadInfraText(stackKey,stackText);
+
+    // Update app config
+    console.log('Adding app params');
+    const nodev = args.node || '';
+    const pyv = args.py || '';
+    await Params.addApp(args.name,args.type,stackKey,nodev,pyv);
+    console.log(`Added ${args.name} with ${args.type} stack`)
+}
+
+function prepStack(stackType,bootScript){
+    const stackPath = path.resolve(__dirname, 'helpers', 'stacks', `${stackType}.yaml`);
+    if (!fs.existsSync(stackPath)){ throw new Error('Invalid stack ' + args.type); }
+    
+    const b64Script = Buffer.from(bootScript, 'utf8').toString('base64');
+    const stackTxt = fs.readFileSync(stackPath, 'utf-8').replace(/{{user_data}}/, b64Script)
+    return stackTxt;
+}

package/commands/new_instance.js

@@ -0,0 +1,186 @@
+const { EC2Client, DescribeVpcsCommand, DescribeSubnetsCommand } = require("@aws-sdk/client-ec2");
+const { ACMClient, ListCertificatesCommand,RequestCertificateCommand } = require("@aws-sdk/client-acm");
+const { Route53Client, ListHostedZonesByNameCommand } = require("@aws-sdk/client-route-53");
+
+const Params = require('./helpers/params')
+
+exports.main = async function(args){
+    console.log(`Adding ${args.app} instance ${args.name} in ${args.region} @${args.domain}`)
+    // Get App
+    const existingApp = await Params.getApp(args.app);
+    if (!existingApp){
+        console.log('Err: No app named ' + args.app);
+        throw new Error('Err: No app named ' + args.app)
+    }
+    // Get Instance
+    const existingInstance = existingApp.instances.find(ins=>{ return ins.name.toLowerCase() === args.name.toLowerCase() })
+    if (existingInstance){
+        console.log('Err: Existing Intance with name ' + args.name);
+        throw new Error('Existing Instance')
+    }
+    // Get Hosted Zone
+    const rootDomain = parseDomain(args.domain);
+    const hostedZoneId = await getHostedZoneId(rootDomain);
+    if (!hostedZoneId){
+        console.log('Err: Hosted zone/domain not found ' + rootDomain);
+        throw new Error('Domain not found')
+    }
+
+    const instanceParams = {
+        name: args.name,
+        domain: args.domain,
+        region: args.region,
+        version: null,
+        cfParams: {
+            AmiId: null,
+            ACMDomainCert: null,
+            VpcId: null,
+            InstanceSubnets: [],
+            InstanceRootDomain: hostedZoneId,
+            InstanceDomain: args.domain,
+            MaxEc2Instances: args.max || 2
+        }
+    }
+
+    // Certificate
+    let cert = await getCertificate(args.domain,rootDomain,args.region);
+    if (cert === 'none'){
+        cert = await requestCert(rootDomain,args.region)
+    }
+    instanceParams.cfParams.ACMDomainCert = cert;
+
+    // Get VPC & Subnets
+    instanceParams.cfParams.VpcId = await getVPC(args.region);
+    instanceParams.cfParams.InstanceSubnets = await getSubnets(args.region)
+
+    // Update SSM
+    console.log('Updating instance params')
+    await Params.addInstance(args.app,args.name,instanceParams);
+    
+    console.log(`Added instance ${args.name}`);
+    return true;
+}
+
+//////////////////////////////////////////////////
+//////////////////////////////////////////////////
+/////////////////////////////////////////////////
+
+
+function parseDomain(domain){
+    const domainArray = domain.split('.');
+    const rootDomainName = domainArray.length === 2 ? domainArray[0] : domainArray[domainArray.length-2]
+    const rootDomain = rootDomainName + '.'+ domainArray[domainArray.length-1];
+    return rootDomain;
+}
+
+async function getCertificate(domain,rootDomain,region){
+    const acmClient = new ACMClient({ region }); // Replace with your desired region.
+
+    // Get All Certs
+    const certificates = [];
+    let params = {};
+    do {
+      // Call ListCertificatesCommand to list certificates.
+      const data = await acmClient.send(new ListCertificatesCommand(params));
+
+      // Add the listed certificates to the array.
+      certificates.push(...(data.CertificateSummaryList || []));
+
+      // If NextToken is present, set it in params for the next iteration.
+      params.NextToken = data.NextToken;
+    } while (params.NextToken);
+
+    // Find Cert
+    let arn = null;
+    const cert = certificates.find(c=>{ return c.DomainName == rootDomain && c.Status == 'ISSUED'})
+    if (cert){
+        console.log('Found certificate');
+        if (domain == rootDomain){ 
+            arn = cert.CertificateArn; 
+        } else if (cert.SubjectAlternativeNameSummaries && cert.SubjectAlternativeNameSummaries.includes(`*.${rootDomain}`)){
+            arn = cert.CertificateArn; 
+        } else {
+            console.log('Certificate does not cover subdomain ' + domain);
+            arn = 'none';
+        }
+    } else {
+        const pendingCert = certificates.find(c=>{ return c.DomainName == rootDomain && c.Status.toLowerCase().includes('validation')});
+        if (pendingCert){
+            console.log('WARNING: Cert still pending validation ' + pendingCert.Status)
+            arn = pendingCert.CertificateArn;
+        } else {
+            const invalidCert = certificates.find(c=>{ return c.DomainName == rootDomain });
+            if (invalidCert){
+                console.log('WARNING: Certificate not in valid status: ' + invalidCert.Status)
+                console.log('Use renew-certs command to renew')
+                arn = invalidCert.CertificateArn;
+            } else {
+                console.log('No certificate found for ' + domain);
+                arn = 'none';       
+            }
+        }
+    }
+
+    return arn;
+}
+
+async function requestCert(rootDomain,region){
+    console.log(`Requesting new certificate for ${rootDomain} in ${region}`)
+    const acmClient = new ACMClient({ region }); // Replace with your desired region.
+
+    const params = {
+        DomainName: rootDomain,
+        ValidationMethod: "DNS",
+        SubjectAlternativeNames: [ `*.${rootDomain}` ],
+      };
+
+    const data = await acmClient.send(new RequestCertificateCommand(params));
+    return data.CertificateArn;
+}
+
+async function getVPC(region){
+    console.log('Getting default VPC ID')
+    // Initialize an Amazon EC2 client object.
+    const ec2Client = new EC2Client({ region }); // replace with your desired region
+    const data = await ec2Client.send(new DescribeVpcsCommand({}));
+    
+    // Find the default VPC from the list of VPCs.
+    const defaultVpc = data.Vpcs.find(vpc => vpc.IsDefault);
+    
+    // Return the VPC ID if the default VPC is found.
+    return defaultVpc.VpcId;
+}
+
+async function getSubnets(region){
+    console.log('Retrieving Subnets')
+    const ec2Client = new EC2Client({ region }); 
+    const subnetsData = await ec2Client.send(new DescribeSubnetsCommand({}));
+    const subNets = subnetsData.Subnets.filter(s=>{ return s.DefaultForAz === true });
+    const subnetList = subNets.map(subnet => subnet.SubnetId  );
+    return subnetList;
+}
+
+async function getHostedZoneId(hostedZoneName){
+    hostedZoneName += '.';
+    const client = new Route53Client({ region: "us-east-1" });
+    const command = new ListHostedZonesByNameCommand({ DNSName: hostedZoneName });
+    let response;
+    try {
+        response = await client.send(command);
+    } catch(e){
+        console.log(e);
+        return false;
+    }
+    
+
+    // Check if we have the desired hosted zone in the response
+    if (response.HostedZones && response.HostedZones.length > 0) {
+        for (let zone of response.HostedZones) {
+            if (zone.Name === hostedZoneName) {
+                return zone.Id.split("/").pop(); // Extracting the ID part from the full ARN
+            }
+        }
+    } else {
+        return false;
+    }
+}

package/commands/reset_stack.js

@@ -0,0 +1,28 @@
+const S3 = require('./helpers/s3')
+const Params= require('./helpers/params');
+const Stacks = require('./helpers/stacks')
+
+exports.main = async function(args){
+    // Get App
+    const app = await Params.getApp(args.app);
+    if (!app){
+        console.log('Err: No app named ' + args.app);
+        throw new Error('Err: No app named ' + args.app)
+    }
+    // Get Stack
+    const stackText = Stacks.get('asg', {lang: 'node'});
+    const stackKey = `apps/${args.app.toLowerCase()}/default_stack.yaml`
+    
+    // Reset Default
+    console.log('Resetting default stack @ ', stackKey)
+    await S3.uploadInfraText(stackKey,stackText);
+
+    if (!app.versions){ return }
+    const versions = Object.keys(app.versions);
+    for (let i=0; i<versions.length; i++){
+        let k = versions[i]
+        let vStackPath = `apps/${args.app.toLowerCase()}/${k}/stack.yaml`
+        console.log('Resetting v',k, '@', vStackPath);
+        await S3.uploadInfraText(vStackPath,stackText);
+    }
+}

package/commands/update_app.js

@@ -0,0 +1,272 @@
+const path = require('path');
+const fs = require('fs')
+const { EC2Client, RunInstancesCommand,CreateImageCommand,TerminateInstancesCommand,DescribeInstanceStatusCommand,DeregisterImageCommand,DescribeImagesCommand,CopyImageCommand } = require("@aws-sdk/client-ec2");
+
+const AdmZip = require("adm-zip");
+
+const Params = require('./helpers/params')
+const S3 = require('./helpers/s3');
+
+
+const INSTANCE_TYPE="t2.micro"
+
+exports.main = async function(args){
+    console.log(`Updating ${args.app} v${args.v}`)
+    
+    // Get App
+    const app = await Params.getApp(args.app);
+    if (!app){
+        console.log('Err: No app named ' + args.app);
+        throw new Error('Err: No app named ' + args.app)
+    }
+
+    // --- I PREP ZIP ---
+    const zipPath = path.resolve(args.path);
+    if (!fs.existsSync(zipPath)){ throw new Error("Path not found:" + args.path)}
+    const zipFilePath = await prepZip(zipPath);
+    await S3.uploadInfraFile(`apps/${args.app}/${args.v}/app.zip`,zipFilePath);
+
+    // --- II UPDATE STACK ---
+    // If stack arg, upload stack
+    const stackKey = `apps/${args.app}/${args.v}/stack.yaml`;
+    if (args.stack){
+        console.log(`Upating stack: ${stackPath} to ${stackKey}`)
+        const stackPath = path.resolve(args.stack);
+        if (!fs.existsSync(stackPath)){ throw new Error("Stack file not found:" + args.stack)}
+        await S3.uploadInfraFile(stackKey,stackPath)
+    } else {
+        // If no stack arg, upload default stack if none exists
+        const stackExists = await S3.infraFileExists(stackKey)
+        if (!stackExists){
+            console.log('Using default stack');
+            await S3.copyInfraFile(app.stackKey,stackKey)
+        } else {
+            console.log('Skipping stack update')
+        }
+    }
+
+    // --- III BUILD IMAGE ---
+    // Launch ec2
+    const orgParams = await Params.getOrgConfig();
+
+    const awsLinuxAMI = await findLinuxAMI(process.env.orgRegion);
+    const instance_id = await launchInstance({
+        app: app.name,
+        linuxAMI: awsLinuxAMI,
+        version: args.v,
+        sec_group: orgParams.buildSecGroup,
+        iam: orgParams.buildInstanceProfile
+    });
+
+    await waitUntilInstanceReady(instance_id,process.env.orgRegion);
+    
+    // Create AMI
+    const buildNumber = (app.versions[args.v]?.currentBuild || 0) + 1;
+    const appVID = `${app.name}-v${args.v}.${buildNumber}`;
+    console.log(appVID);
+
+    var success = false;
+    let ami_id;
+    try {
+        ami_id = await createAMI(instance_id, appVID,process.env.orgRegion)
+        success = true;
+    } catch(e){
+        console.log("Error Creating AMI:" + e)
+    }
+    await terminateInstance(instance_id,process.env.orgRegion)
+    if (success === false){ throw new Error("Error - Build Not Complete") }
+
+    // --- IV UPDATE PARAMS ---
+    const versionInfo = {
+        baseAMI_Name: appVID,
+        baseAMI_Id: ami_id,
+        currentBuild: buildNumber,
+        updated: Date.now()
+    }
+    await Params.updateAppV(app.name,args.v,versionInfo);
+    return true;
+}
+
+
+
+///////////////////////////////////////////////
+///////////////////////////////////////////////
+///////////////////////////////////////////////
+
+async function prepZip(appPath){
+    console.log('Zipping ' + appPath);
+    const inPath = path.resolve(appPath);
+    let zipPath = path.resolve(`./app.zip`);
+
+    const pathStat = fs.statSync(inPath);
+    // If dir, zip
+    if (!pathStat.isFile()){
+        const zip = new AdmZip();
+        zip.addLocalFolder(inPath);
+        zip.writeZip(zipPath);
+    } else {
+        // If not zip, throw error
+        if (path.extname(inPath) !== '.zip'){
+            console.log('ERROR:Not a .zip file >>' + inPath)
+            throw 'ERROR:Not a .zip file >>' + inPath;
+        }
+        // Copy .zip file
+        fs.copyFileSync(inPath,zipPath);
+    }
+    process.on('exit', function(){ fs.unlinkSync(zipPath) });
+    return zipPath;
+}
+
+async function findLinuxAMI(region){
+    // aws ec2 describe-images --owners amazon --filters "Name=name,Values=amzn*" --query 'sort_by(Images, &CreationDate)[].Name'
+    console.log('Locating AMI for AWS Linux in ' + region)
+    const client = new EC2Client({region});
+    const input = { // DescribeImagesRequest
+        Owners: ['amazon'],
+        Filters: [
+            {
+                Name: "name",
+                Values: ["al2023-ami-2023.2.20230920.1-kernel-6.1-x86_64"], // Pattern for Amazon Linux 2 AMI
+            },
+            {
+                Name: "state",
+                Values: ["available"],
+            },
+            { 
+                Name: "architecture",
+                Values: [ "x86_64" ],
+            },
+            {
+                Name: "virtualization-type",
+                Values: ["hvm"]
+            }
+        ],
+        // al2023-ami-2023.2.20230920.1-kernel-6.1-x86_64
+        // ImageIds: ['ami-03a6eaae9938c858c'],
+        IncludeDeprecated: false,
+        DryRun: false,
+        // MaxResults: 16
+    };
+    const command = new DescribeImagesCommand(input);
+    const response = await client.send(command);
+    const images = response.Images;
+
+    if (!images[0]){ 
+        console.log('Could not find AWS Linux 2023 base image')
+        throw 'Could not find AWS Linux 2023 base image'
+    };
+
+    return images[0].ImageId;
+}
+
+async function launchInstance(launchParams){
+    console.log('Launching Instance in ' + process.env.orgRegion);
+
+    const user_data = [
+        `#!/bin/bash -xe`,
+        `yum -y install nodejs`,
+        `yum -y install unzip`,
+        `cd /home/ec2-user`,
+        `aws s3 cp s3://${process.env.orgBucket}/apps/${launchParams.app.toLowerCase()}/${launchParams.version}/app.zip .`,
+        `unzip app.zip -d app`,
+        `rm -r app.zip`
+    ].join('\n')
+
+    const ud_b64 = Buffer.from(user_data).toString('base64');
+
+    const client = new EC2Client({region: process.env.orgRegion });
+
+    const createInstanceParams = {
+        ImageId: launchParams.linuxAMI,
+        InstanceType: INSTANCE_TYPE,
+        SecurityGroupIds: [
+            launchParams.sec_group
+        ],
+        MinCount: 1,
+        MaxCount: 1,
+        UserData: ud_b64,
+        IamInstanceProfile: {
+            Arn: launchParams.iam
+        }
+    };
+    const command = new RunInstancesCommand(createInstanceParams);
+    const response = await client.send(command);
+    const instance_id = response.Instances[0].InstanceId
+   
+    console.log('Instance Launched:',instance_id);
+    return instance_id;
+}
+
+async function waitUntilInstanceReady(instance_id,region){
+    console.log(`Awaiting ${instance_id} status of ok`)
+    const client = new EC2Client({region});
+    const input = { // DescribeInstanceStatusRequest
+        InstanceIds: [ // InstanceIdStringList
+            instance_id
+        ],
+        DryRun: false,
+        IncludeAllInstances: true
+    };
+    
+    let totalSleepTime = 0;
+    let ok = false;
+    const command = new DescribeInstanceStatusCommand(input);
+    for (let i=0; i<50; i++){
+        const response = await client.send(command);
+        const status = response.InstanceStatuses[0].InstanceStatus.Status;
+        console.log(`\tCheck ${i+1} @ ${totalSleepTime}s: EC2 Status is ${status}`)
+        if (status !== 'ok'){
+            await sleep(10000);
+            totalSleepTime += 10;
+        } else {
+            console.log('Ec2 Instance Ready:' + status);
+            ok = true;
+            break;
+        }
+    }
+
+    if (ok === false){
+        console.log('ERR:::', `Ec2 Instance Not Ready After ${totalSleepTime}s`)
+        throw `Ec2 Instance Not Ready After ${totalSleepTime}s`
+    } else {
+        console.log(`Instance Ready After ${totalSleepTime}s. Waiting 30s to Proceed`);
+        await sleep(30);
+    }
+    return true;
+}
+
+async function createAMI(instance_id,image_name,region){
+    console.log(`Building ${image_name} in ${region}`)
+    const client = new EC2Client({region});
+    const input = { // CreateImageRequest
+        Description: `Base Application Image`,
+        DryRun: false,
+        InstanceId: instance_id, // required
+        Name: image_name, // required
+        NoReboot: true
+      };
+      const command = new CreateImageCommand(input);
+      const response = await client.send(command);
+      console.log(`Created Image ${image_name} ID:${response.ImageId}`)
+      return response.ImageId;
+}
+
+async function terminateInstance(instance_id,region){
+    console.log('Terminating Instance ' + instance_id)
+    const client = new EC2Client({region});
+    const input = { // TerminateInstancesRequest
+        InstanceIds: [ instance_id ],
+        DryRun: false,
+    };
+    const command = new TerminateInstancesCommand(input);
+    const response = await client.send(command);
+    return true;
+}
+
+
+async function sleep(time){
+    return new Promise(function (resolve, reject) {
+        setTimeout(function () { resolve(true);
+        }, time);
+    });
+}