aws-amicleaner 1.0.6 → 1.1.0

package/README.md

@@ -68,7 +68,7 @@ npx aws-amicleaner --include-name 'amiprefix-*' --exclude-newest 0 --exclude-day
 --exclude-days EXCLUDEDAYS
                       Exclude AMIs from deletion that are younger than N days
 --exclude-in-use, --no-exclude-in-use
-                      Exclude AMIs from deletion that are in use by EC2 instances, ASGs, Launch Configurations, and Launch Templates (default: true)
+                      Exclude AMIs from deletion that are in use by EC2 instances, Launch Configurations, and Launch Templates (default: true)
 -f, --force-delete, --no-force-delete
                       Skip confirmation before deletion (default: false)
 --verbose, --no-verbose

package/eslint.config.js

@@ -0,0 +1,25 @@
+import {defineConfig} from 'eslint/config';
+import globals from 'globals';
+import js from '@eslint/js';
+
+export default defineConfig([{
+  files: ['**/*.js'],
+  plugins: {
+    js,
+  },
+  extends: ['js/recommended'],
+  languageOptions: {
+    globals: {
+      ...globals.commonjs,
+      ...globals.node,
+      ...globals.mocha
+    },
+    ecmaVersion: 2022,
+  },
+  rules: {
+    indent: ['error', 2],
+    'linebreak-style': ['error', 'unix'],
+    quotes: ['error', 'single'],
+    semi: ['error', 'always'],
+  },
+}]);

package/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
-const { createInterface } = require('node:readline');
-const { ArgumentParser, BooleanOptionalAction } = require('argparse');
-const { fetchAMIs, deleteAMI, fetchRegions} = require('./lib.js');
-const pLimit = require('p-limit');
-
-const AWS = require('aws-sdk');
-const PrettyTable = require('./prettytable.js');
+import {createInterface} from 'node:readline';
+import {ArgumentParser, BooleanOptionalAction} from 'argparse';
+import {fetchAMIs, deleteAMI, fetchRegions} from './lib.js';
+import pLimit from 'p-limit';
+import {AutoScalingClient} from '@aws-sdk/client-auto-scaling';
+import {EC2Client} from '@aws-sdk/client-ec2';
+import PrettyTable from './prettytable.js';
 
 const rl = createInterface({
   input: process.stdin,
@@ -36,13 +36,13 @@ async function run({
   const autoscaling = {};
   const ec2Client = (region) => {
     if (!(region in ec2)) {
-      ec2[region] = new AWS.EC2({apiVersion: '2016-11-15', region});
+      ec2[region] = new EC2Client({apiVersion: '2016-11-15', region});
     }
     return ec2[region];
   };
   const autoscalingClient = (region) => {
     if (!(region in autoscaling)) {
-      autoscaling[region] = new AWS.AutoScaling({apiVersion: '2011-01-01', region});
+      autoscaling[region] = new AutoScalingClient({apiVersion: '2011-01-01', region});
     }
     return autoscaling[region];
   };
@@ -119,7 +119,7 @@ aws-amicleaner --include-name 'amiprefix-*' --exclude-newest 0 --exclude-days 0
   parser.add_argument('--include-tag-value', {dest: 'includeTagValue', type: 'string', help: 'The tag value (for the tag key) that must be present, wildcard * supported'});
   parser.add_argument('--exclude-newest', {dest: 'excludeNewest', type: 'int', default: 5, help: 'Exclude the newest N AMIs'});
   parser.add_argument('--exclude-days', {dest: 'excludeDays', type: 'int', default: 7, help: 'Exclude AMIs from deletion that are younger than N days'});
-  parser.add_argument('--exclude-in-use', {dest: 'excludeInUse', default: true, action: BooleanOptionalAction, help: 'Exclude AMIs from deletion that are in use by EC2 instances, ASGs, Launch Configurations, and Launch Templates'});
+  parser.add_argument('--exclude-in-use', {dest: 'excludeInUse', default: true, action: BooleanOptionalAction, help: 'Exclude AMIs from deletion that are in use by EC2 instances, Launch Configurations, and Launch Templates'});
   parser.add_argument('-f', '--force-delete', {dest: 'forceDelete', default: false, action: BooleanOptionalAction, help: 'Skip confirmation before deletion'});
   parser.add_argument('--verbose', {dest: 'verbose', default: true, action: BooleanOptionalAction, help: 'Display additional information'});
   const args = parser.parse_args();

package/lib.js

@@ -1,17 +1,17 @@
-const wildcard = require('wildcard');
-const pLimit = require('p-limit');
-
-const MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE = 50;
+import wildcard from 'wildcard';
+import pLimit from 'p-limit';
+import {paginateDescribeLaunchConfigurations} from '@aws-sdk/client-auto-scaling';
+import {DescribeRegionsCommand, paginateDescribeInstances, DescribeLaunchTemplateVersionsCommand, paginateDescribeImages, DeregisterImageCommand, DeleteSnapshotCommand, paginateDescribeLaunchTemplates} from '@aws-sdk/client-ec2';
 
 function mapAMI(raw) {
   return {
     id: raw.ImageId,
     name: raw.Name,
     creationDate: Date.parse(raw.CreationDate),
-    tags: raw.Tags.reduce((acc, {Key: key, Value: value}) => {
+    tags: Array.isArray(raw.Tags) ? raw.Tags.reduce((acc, {Key: key, Value: value}) => {
       acc[key] = value;
       return acc;
-    }, {}),
+    }, {}) : {},
     blockDeviceMappings: raw.BlockDeviceMappings.filter(raw => raw.Ebs).map(raw => ({snapshotId: raw.Ebs.SnapshotId})),
     excluded: false,
     excludeReasons: [],
@@ -20,7 +20,7 @@ function mapAMI(raw) {
   };
 }
 
-async function fetchRegions(ec2, rawRegions) {
+export async function fetchRegions(ec2, rawRegions) {
   const regions = new Set();
 
   if (rawRegions.length === 0) {
@@ -31,7 +31,7 @@ async function fetchRegions(ec2, rawRegions) {
 
   const rawRegionsWithWildcard = rawRegions.filter(region => region.includes('*'));
   if (rawRegionsWithWildcard.length !== 0) {
-    const {Regions} = await ec2.describeRegions({}).promise();
+    const {Regions} = await ec2.send(new DescribeRegionsCommand({}));
     rawRegionsWithWildcard.forEach(rawRegionWithWildcard => {
       wildcard(rawRegionWithWildcard, Regions.map(r => r.RegionName)).forEach(region => regions.add(region));
     });
@@ -39,100 +39,78 @@ async function fetchRegions(ec2, rawRegions) {
 
   return regions;
 }
-exports.fetchRegions = fetchRegions;
 
-async function fetchInUseAMIIDs(ec2, autoscaling) {
+export async function fetchInUseAMIIDs(ec2, autoscaling) {
   const inUseAMIIDs = new Set();
 
-  for await (const reservation of (async function*() {
-    let nextToken = '';
-    while (nextToken !== undefined) {
-      const {Reservations: reservations, NextToken} = await ec2.describeInstances({
-        NextToken: (nextToken === '') ? undefined : nextToken,
-        Filters: [{
-          Name: 'instance-state-name',
-          Values: [
-            'pending',
-            'running',
-            'shutting-down',
-            'stopping',
-            'stopped'
-          ]
-        }]
-      }).promise();
-      yield* reservations;
-      nextToken = NextToken;
+  const instancePaginator = paginateDescribeInstances({
+    client: ec2
+  }, {
+    Filters: [{
+      Name: 'instance-state-name',
+      Values: [
+        'pending',
+        'running',
+        'shutting-down',
+        'stopping',
+        'stopped'
+      ]
+    }]
+  });
+  for await (const page of instancePaginator) {
+    for (const reservation of page.Reservations) {
+      reservation.Instances.forEach(instance => inUseAMIIDs.add(instance.ImageId));
     }
-  })()) {
-    reservation.Instances.forEach(instance => inUseAMIIDs.add(instance.ImageId));
   }
 
-  const asgs = [];
-  for await (const asg of (async function*() {
-    let nextToken = '';
-    while (nextToken !== undefined) {
-      const {AutoScalingGroups, NextToken} = await autoscaling.describeAutoScalingGroups({
-        NextToken: (nextToken === '') ? undefined : nextToken
-      }).promise();
-      yield* AutoScalingGroups;
-      nextToken = NextToken;
-    }
-  })()) {
-    asgs.push(asg);
+  const lcPaginator = paginateDescribeLaunchConfigurations({client: autoscaling}, {});
+  for await (const page of lcPaginator) {
+    page.LaunchConfigurations.forEach(lc => inUseAMIIDs.add(lc.ImageId));
   }
 
-  // in use by ASG -> Launch Configuration
-  const inUseLCNames = asgs.filter(asg => 'LaunchConfigurationName' in asg).map(asg => asg.LaunchConfigurationName);
-  if (inUseLCNames.length > 0) {
-    for (let i = 0; i < Math.ceil(inUseLCNames.length/MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE); i++) {
-      const {LaunchConfigurations: lcs} = await autoscaling.describeLaunchConfigurations({
-        LaunchConfigurationNames: inUseLCNames.slice(i*MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE, (i+1)*MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE)
-      }).promise();
-      lcs.forEach(lc => inUseAMIIDs.add(lc.ImageId));
-    }
+  const ltPaginator = paginateDescribeLaunchTemplates({client: ec2}, {});
+  const ltLimit = pLimit(5);
+  for await (const page of ltPaginator) {
+    await Promise.all(
+      page.LaunchTemplates.map(({LaunchTemplateId: id, DefaultVersionNumber: version}) => ltLimit(async () => {
+        const data = await ec2.send(new DescribeLaunchTemplateVersionsCommand({
+          LaunchTemplateId: id,
+          Versions: [version]
+        }));
+        inUseAMIIDs.add(data.LaunchTemplateVersions[0].LaunchTemplateData.ImageId);
+      }))
+    );
+    // CloudFormation does not update the default version of a launch template, therefore we are also considering the latest version as being used
+    await Promise.all(
+      page.LaunchTemplates.map(({LaunchTemplateId: id, LatestVersionNumber: version}) => ltLimit(async () => { 
+        const data = await ec2.send(new DescribeLaunchTemplateVersionsCommand({
+          LaunchTemplateId: id,
+          Versions: [version]
+        }));
+        inUseAMIIDs.add(data.LaunchTemplateVersions[0].LaunchTemplateData.ImageId);
+      }))
+    );
   }
 
-  const inUseLTs = [
-    ...asgs.filter(asg => 'LaunchTemplate' in asg).map(asg => ({id: asg.LaunchTemplate.LaunchTemplateId, version: asg.LaunchTemplate.Version})),
-    ...asgs.filter(asg => 'MixedInstancesPolicy' in asg).map(asg => ({id: asg.MixedInstancesPolicy.LaunchTemplate.LaunchTemplateSpecification.LaunchTemplateId, version: asg.MixedInstancesPolicy.LaunchTemplate.LaunchTemplateSpecification.Version}))
-  ];
-  const limit = pLimit(5);
-  await Promise.all(
-    inUseLTs.map(({id, version}) => limit(() => 
-      ec2.describeLaunchTemplateVersions({
-        LaunchTemplateId: id,
-        Versions: [version]
-      }).promise().then(data => data.LaunchTemplateVersions[0].LaunchTemplateData.ImageId))
-    )
-  ).then(amiIDs => amiIDs.forEach(amiID => inUseAMIIDs.add(amiID)));
-
   return inUseAMIIDs;
 }
-exports.fetchInUseAMIIDs = fetchInUseAMIIDs;
 
-async function fetchAMIs(now, ec2, autoscaling, includeName, includeTagKey, includeTagValue, excludeNewest, excludeInUse, excludeDays) {
+export async function fetchAMIs(now, ec2, autoscaling, includeName, includeTagKey, includeTagValue, excludeNewest, excludeInUse, excludeDays) {
   let amis = [];
-  for await (const rawAMI of (async function*() {
-    let nextToken = '';
-    while (nextToken !== undefined) {
-      const params = {
-        Owners: ['self']
-      };
-      if (includeTagKey !== undefined) {
-        params.Filters = [{
-          Name: 'tag-key',
-          Values: [includeTagKey]
-        }];
-      }
-      if (nextToken !== '') {
-        params.NextToken = nextToken;
-      }
-      const {Images, NextToken} = await ec2.describeImages(params).promise();
-      yield* Images;
-      nextToken = NextToken;
-    }
-  })()) {
-    amis.push(mapAMI(rawAMI));
+  const input = {
+    Owners: ['self']
+  };
+  if (includeTagKey !== undefined) {
+    input.Filters = [{
+      Name: 'tag-key',
+      Values: [includeTagKey]
+    }];
+  }
+  const paginator = paginateDescribeImages({
+    client: ec2
+  }, input);
+  for await (const page of paginator) {
+    page.Images.forEach(rawAMI => amis.push(mapAMI(rawAMI)));
   }
 
   if (includeName !== undefined) {
@@ -186,18 +164,16 @@ async function fetchAMIs(now, ec2, autoscaling, includeName, includeTagKey, incl
 
   return amis;
 }
-exports.fetchAMIs = fetchAMIs;
 
-async function deleteAMI(ec2, ami) {
-  await ec2.deregisterImage({
+export async function deleteAMI(ec2, ami) {
+  await ec2.send(new DeregisterImageCommand({
     ImageId: ami.id
-  }).promise();
+  }));
   console.log(`AMI ${ami.id} deregistered`);
   for (const blockDevice of ami.blockDeviceMappings) {
-    await ec2.deleteSnapshot({
+    await ec2.send(new DeleteSnapshotCommand({
       SnapshotId: blockDevice.snapshotId
-    }).promise();
+    }));
     console.log(`snapshot ${blockDevice.snapshotId} of AMI ${ami.id} deleted`);
   }
 }
-exports.deleteAMI = deleteAMI;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-amicleaner",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "To clean up your AWS AMIs: First, include AMIs by name or tag. Second, exclude AMIs in use, younger than N days, or the newest N images. Third, manually confirm the list of AMIs for deletion.",
   "main": "index.js",
   "bin": "index.js",
@@ -18,15 +18,19 @@
   },
   "homepage": "https://github.com/widdix/aws-amicleaner#readme",
   "dependencies": {
+    "@aws-sdk/client-auto-scaling": "3.777.0",
+    "@aws-sdk/client-ec2": "3.777.0",
     "argparse": "2.0.1",
-    "aws-sdk": "2.1552.0",
-    "p-limit": "3.1.0",
+    "p-limit": "6.2.0",
     "wildcard": "2.0.1"
   },
   "devDependencies": {
-    "c8": "9.1.0",
-    "eslint": "8.56.0",
-    "mocha": "10.2.0"
+    "@eslint/js": "9.23.0",
+    "aws-sdk-client-mock": "4.1.0",
+    "c8": "10.1.3",
+    "eslint": "9.23.0",
+    "globals": "16.0.0",
+    "mocha": "11.1.0"
   },
   "mocha": {
     "timeout": 10000
@@ -36,5 +40,6 @@
       "text",
       "html"
     ]
-  }
+  },
+  "type": "module"
 }

package/prettytable.js

@@ -37,7 +37,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-var PrettyTable = function () {
+export default function PrettyTable() {
   // Skeleton structure of table with list of column names, row and max width of each column element
   this.table = {
     'columnNames': [],
@@ -237,5 +237,3 @@ PrettyTable.prototype.deleteTable = function () {
     'maxWidth': []
   };
 };
-
-module.exports = PrettyTable;

package/renovate.json

@@ -0,0 +1,3 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json"
+}