CODEWITHSUNDEEP
amazon-web-servicesamazon-ec2ec2-ami
GorvGoyl
GorvGoyl

Reputation: 49220

How to see all running Amazon EC2 instances across all regions?

I switch instances between different regions frequently and sometimes I forget to turn off my running instance from a different region. I couldn't find any way to see all the running instances on Amazon console.
Is there any way to display all the running instances regardless of region?

Upvotes: 230

Views: 155596

Answers (19)

Md Riadul Islam
Md Riadul Islam

Reputation: 1471

From VPC Dashboard:

  1. First go to VPC Dashboard

  2. Then find Running instances and expand see all regions. Here you can find all the running instances of all region:

    enter image description here

From EC2 Global view:

  • Also you can use AWS EC2 Global View to watch Resource summary and Resource counts per Region.

    enter image description here

Upvotes: 36

sobi3ch
sobi3ch

Reputation: 2823

AWS has recently launched the Amazon EC2 Global View with initial support for Instances, VPCs, Subnets, Security Groups, and Volumes.

To see all running instances go to EC2 or VPC console and click EC2 Global View in the top left corner.

enter image description here

Then click on Global Search tab and filter by Resource type and select Instance. Unfortunately, this will show instances in all states:

pending
running
stopping
stopped
shutting-down
terminated

enter image description here

Upvotes: 4

Heinrich Filter
Heinrich Filter

Reputation: 6158

Nov 2021 Edit: AWS has recently launched the Amazon EC2 Global View with initial support for Instances, VPCs, Subnets, Security Groups and Volumes.

See the announcement or documentation for more details

A non-obvious GUI option is the Tag Editor in the Resource Groups console. Here you can find all instances across all regions, even if the instances were not tagged. Screen capture of

Upvotes: 215

Duncan Bayne
Duncan Bayne

Reputation: 3949

Using bash-my-aws:

region-each instances

Upvotes: 2

Alistair R
Alistair R

Reputation: 926

Not sure how long this option's been here, but you can see a global view of everything by searching for EC2 Global View

https://console.aws.amazon.com/ec2globalview/home#

Global View Search

Upvotes: 1

once
once

Reputation: 1399

A quick bash oneliner command to print all the instance IDs in all regions:

$ aws ec2 describe-regions --query "Regions[].{Name:RegionName}" --output text |xargs -I {} aws ec2 describe-instances --query Reservations[*].Instances[*].[InstanceId] --output text --region {}

# Example output
i-012344b918d75abcd
i-0156780dad25fefgh
i-0490122cfee84ijkl
...

Upvotes: 4

sobi3ch
sobi3ch

Reputation: 2823

In Console

Go to VPC dashboard https://console.aws.amazon.com/vpc/home and click on Running instances -> See all regions.

enter image description here

In CLI

Add this for example to .bashrc. Reload it source ~/.bashrc, and run it

Note: Except for aws CLI you need to have jq installed

function aws.print-all-instances() {
  REGIONS=`aws ec2 describe-regions --region us-east-1 --output text --query Regions[*].[RegionName]`
  for REGION in $REGIONS
  do
    echo -e "\nInstances in '$REGION'..";
    aws ec2 describe-instances --region $REGION | \
      jq '.Reservations[].Instances[] | "EC2: \(.InstanceId): \(.State.Name)"'
  done
}

Example output:

$ aws.print-all-instances 

Listing Instances in region: 'eu-north-1'..
"EC2: i-0548d1de00c39f923: terminated"
"EC2: i-0fadd093234a1c21d: running"

Listing Instances in region: 'ap-south-1'..

Listing Instances in region: 'eu-west-3'..

Listing Instances in region: 'eu-west-2'..

Listing Instances in region: 'eu-west-1'..

Listing Instances in region: 'ap-northeast-2'..

Listing Instances in region: 'ap-northeast-1'..

Listing Instances in region: 'sa-east-1'..

Listing Instances in region: 'ca-central-1'..

Listing Instances in region: 'ap-southeast-1'..

Listing Instances in region: 'ap-southeast-2'..

Listing Instances in region: 'eu-central-1'..

Listing Instances in region: 'us-east-1'..

Listing Instances in region: 'us-east-2'..

Listing Instances in region: 'us-west-1'..

Listing Instances in region: 'us-west-2'..

Upvotes: 67

Rahul Talreja
Rahul Talreja

Reputation: 199

After reading through all the solutions and trying bunch of stuff, the one that worked for me was-

  1. List item
  2. Go to Resource Group
  3. Tag Editor
  4. Select All Regions
  5. Select EC2 Instance in resource type
  6. Click Search Resources

Snapshot of the solution

Upvotes: 8

Akhil
Akhil

Reputation: 1040

To run jobs in parallel and use multiple profiles use this script.

#!/bin/bash
for i in profile1 profile2
do
    OWNER_ID=`aws iam get-user --profile $i --output text | awk -F ':' '{print $5}'`
    tput setaf 2;echo "Profile : $i";tput sgr0
    tput setaf 2;echo "OwnerID : $OWNER_ID";tput sgr0
    for region in `aws --profile $i ec2  describe-regions --output text | cut -f4`
    do
        tput setaf 1;echo  "Listing Instances in region $region";tput sgr0
        aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Tags[?Key==`Name`].Value , InstanceId]' --profile $i --region $region --output text
    done &
done
wait

Screenshot:

screenshot

Upvotes: 1

Ed R
Ed R

Reputation: 178

My script below, based on various tips from this post and elsewhere. The script is easier to follow (for me at least) than the long command lines.

The script assumes credential profile(s) are stored in file ~/.aws/credentials looking something like:

[default]
aws_access_key_id = foobar
aws_secret_access_key = foobar

[work]
aws_access_key_id = foobar
aws_secret_access_key = foobar

Script:

#!/usr/bin/env bash

#------------------------------------#
# Script to display AWS EC2 machines #
#------------------------------------#

# NOTES:
# o Requires 'awscli' tools (for ex. on MacOS: $ brew install awscli)
# o AWS output is tabbed - we convert to spaces via 'column' command


#~~~~~~~~~~~~~~~~~~~~#
# Assemble variables #
#~~~~~~~~~~~~~~~~~~~~#

regions=$(aws ec2 describe-regions --output text | cut -f4 | sort)

query_mach='Reservations[].Instances[]'
query_flds='PrivateIpAddress,InstanceId,InstanceType'
query_tags='Tags[?Key==`Name`].Value[]'
query_full="$query_mach.[$query_flds,$query_tags]"


#~~~~~~~~~~~~~~~~~~~~~~~~#
# Output AWS information #
#~~~~~~~~~~~~~~~~~~~~~~~~#

# Iterate through credentials profiles
for profile in 'default' 'work'; do

    # Print profile header
    echo -e "\n"
    echo -e "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    echo -e "Credentials profile:'$profile'..."
    echo -e "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"

    # Iterate through all regions
    for region in $regions; do

        # Print region header
        echo -e "\n"
        echo -e "Region: $region..."
        echo -e "--------------------------------------------------------------"

        # Output items for the region
        aws ec2 describe-instances    \
          --profile $profile          \
          --region  $region           \
          --query   $query_full       \
          --output  text              \
          | sed     's/None$/None\n/' \
          | sed     '$!N;s/\n/ /'     \
          | column  -t -s $'\t'

    done
done

Upvotes: 2

imTachu
imTachu

Reputation: 3809

I don't think you can currently do this in the AWS GUI. But here is a way to list all your instances across all regions with the AWS CLI:

for region in `aws ec2 describe-regions --region us-east-1 --output text | cut -f4`
do
     echo -e "\nListing Instances in region:'$region'..."
     aws ec2 describe-instances --region $region
done

Taken from here (If you want to see full discussion)

Also, if you're getting a

You must specify a region. You can also configure your region by running "aws configure"

You can do so with aws configure set region us-east-1, thanks @Sabuncu for the comment.

Update

Now (in 2019) the cut command should be applied on the 4th field: cut -f4

Upvotes: 89

tuhaj
tuhaj

Reputation: 537

I created an open-source script that helps you to list all AWS instances. https://github.com/Appnroll/aws-ec2-instances

That's a part of the script that lists the instances for one profile recording them into an postgreSQL database with using jq for json parsing:

DATABASE="aws_instances"
TABLE_NAME="aws_ec2"
SAVED_FIELDS="state, name, type, instance_id, public_ip, launch_time, region, profile, publicdnsname"
# collects the regions to display them in the end of script
REGIONS_WITH_INSTANCES=""

for region in `aws ec2 describe-regions --output text | cut -f3`
do
   # this mappping depends on describe-instances command output
   INSTANCE_ATTRIBUTES="{
        state: .State.Name,
        name: .KeyName, type: .InstanceType,
        instance_id: .InstanceId,
        public_ip: .NetworkInterfaces[0].Association.PublicIp,
        launch_time: .LaunchTime,
        \"region\": \"$region\",
        \"profile\": \"$AWS_PROFILE\",
        publicdnsname: .PublicDnsName
   }"

   echo -e "\nListing AWS EC2 Instances in region:'$region'..."
   JSON=".Reservations[] | ( .Instances[] | $INSTANCE_ATTRIBUTES)"
   INSTANCE_JSON=$(aws ec2 describe-instances --region $region)

   if echo $INSTANCE_JSON | jq empty; then
      # "Parsed JSON successfully and got something other than false/null"
      OUT="$(echo $INSTANCE_JSON | jq $JSON)"

      # check if empty
      if [[ ! -z "$OUT" ]] then
        for row in $(echo "${OUT}" | jq -c "." ); do
          psql -c "INSERT INTO $TABLE_NAME($SAVED_FIELDS) SELECT $SAVED_FIELDS from json_populate_record(NULL::$TABLE_NAME, '${row}') ON CONFLICT (instance_id)
            DO UPDATE
            SET state = EXCLUDED.state,
            name = EXCLUDED.name,
            type = EXCLUDED.type,
            launch_time = EXCLUDED.launch_time,
            public_ip = EXCLUDED.public_ip,
            profile = EXCLUDED.profile,
            region = EXCLUDED.region,
            publicdnsname = EXCLUDED.publicdnsname
            " -d $DATABASE
        done

        REGIONS_WITH_INSTANCES+="\n$region"
      else
        echo "No instances"
      fi
   else
        echo "Failed to parse JSON, or got false/null"
   fi
done

Upvotes: 1

Rafal
Rafal

Reputation: 573

Good tool to CRUD AWS resources. Find [EC2|RDS|IAM..] in all regions. There can do operations (stop|run|terminate) on filters results. 

python3 awsconsole.py ec2 all // return list of all instances
python3 awsconsole.py ec2 all -r eu-west-1
python3 awsconsole.py ec2 find -i i-0552e09b7a54fa2cf --[terminate|start|stop]

Upvotes: 0

Dmytro
Dmytro

Reputation: 191

You may use cli tool designed for enumerating cloud resources (cross-region and cross-accounts scan) - https://github.com/scopely-devops/skew

After short configuration you may use the following code for list all instances in all US AWS regions (assuming 123456789012 is your AWS account number).

from skew import scan

arn = scan('arn:aws:ec2:us-*:123456789012:instance/*')
for resource in arn:
    print(resource.data)

Upvotes: 0

J. Parashar
J. Parashar

Reputation: 1497

You can run DescribeInstances() across all regions.

Additionally, you can:

  • Automate it through Lambda and Cloud watch.
  • Create api endpoint using Lambda and api gateway and use it in your code

A sample in NodeJS: 

var regionNames = ['us-west-1', 'us-west-2', 'us-east-1', 'eu-west-1', 'eu-central-1', 'sa-east-1', 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1', 'ap-northeast-2'];

    regionNames.forEach(function(region) {
        getInstances(region);
    });
  • Then, in getInstances function, DescribeInstances() can be called.
function getInstances(region) {
            EC2.describeInstances(params, function(err, data) {
                if (err) return console.log("Error connecting to AWS, No Such Instance Found!");
                data.Reservations.forEach(function(reservation) {
                //do any operation intended
      });
    }

And Off Course, feel free to use ES6 and above.

I wrote a lambda function to get you all the instances in any state [running, stopped] and from any regions, will also give details about instance type and various other parameters.

The Script runs across all AWS regions and calls DescribeInstances(), to get the instances.

You just need to create a lambda function with run-time nodejs. You can even create API out of it and use it as and when required.

Additionally, You can see AWS official Docs For DescribeInstances to explore many more options.

Upvotes: 5

Carlton
Carlton

Reputation: 5721

@imTachu solution works well. To do this via the AWS console...

  • AWS console
  • Services
  • Networking & Content Delivery
  • VPC
  • Look for a block named "Running Instances", this will show you the current region
  • Click the "See all regions" link underneath

Upvotes: 22

Mallikarjuna Reddy
Mallikarjuna Reddy

Reputation: 109

Every time you create a resource, tag it with a name and now you can use Resource Groups to find all types of resources with a name tag across all regions.

Upvotes: 10

Pawel
Pawel

Reputation: 3802

Based on @hansaplast code I created Windows friendly version that supports multiple profiles as an argument. Just save that file as cmd or bat file. You also need to have jq command.

@echo off 
setlocal enableDelayedExpansion

set PROFILE=%1
IF "%1"=="" (SET PROFILE=default)

echo checkin instances in all regions for %PROFILE% account
FOR /F "tokens=* USEBACKQ" %%F IN (`aws ec2 describe-regions --query Regions[*].[RegionName] --output text --profile %PROFILE%`) DO (
echo === region: %%F
aws ec2 describe-instances --region %%F --profile %PROFILE%| jq ".Reservations[].Instances[] | {type: .InstanceType, state: .State.Name, tags: .Tags, zone: .Placement.AvailabilityZone}"
)

Upvotes: 0

hansaplast
hansaplast

Reputation: 11573

Based on imTachus answer but less verbose, plus faster. You need to have jq and aws-cli installed.

set +m
for region in $(aws ec2 describe-regions --query "Regions[*].[RegionName]" --output text); do 
  aws ec2 describe-instances --region "$region" | jq ".Reservations[].Instances[] | {type: .InstanceType, state: .State.Name, tags: .Tags, zone: .Placement.AvailabilityZone}" &
done; wait; set -m

The script runs the aws ec2 describe-instances in parallel for each region (now 15!) and extracts only the relevant bits (state, tags, availability zone) from the json output. The set +m is needed so the background processes don't report when starting/ending.

Example output:

{
  "type": "t2.micro",
  "state": "stopped",
  "tags": [
    {
      "Key": "Name",
      "Value": "MyEc2WebServer"
    },
  ],
  "zone": "eu-central-1b"
}

Upvotes: 7

Related Questions