Come vedere tutte le istanze di Amazon EC2 in esecuzione in tutte le regioni?

Cambio frequentemente istanze tra regioni diverse e talvolta dimentico di disattivare la mia istanza in esecuzione da una regione diversa. Non sono riuscito a trovare alcun modo per vedere tutte le istanze in esecuzione sulla console Amazon.
C'è un modo per visualizzare tutte le istanze in esecuzione indipendentemente dalla regione?

Un'opzione GUI non ovvia è Resource Groups > Tag Editor. Qui puoi trovare tutte le istanze in tutte le regioni, anche se le istanze non erano contrassegnate.

MODIFICA: questa schermata è stata recentemente ridisegnata e ora ha un nuovo aspetto e un'opzione "Tutte le regioni".

Non penso che tu possa attualmente farlo nella GUI di AWS. Ma ecco un modo per elencare tutte le tue istanze in tutte le regioni con 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

Tratto da qui (se vuoi vedere la discussione completa)

Inoltre, se ricevi un file

Devi specificare una regione. Puoi anche configurare la tua regione eseguendo "aws configure"

Puoi farlo con aws configure set region us-east-1, grazie @Sabuncu per il commento.

Aggiornare

Ora (nel 2019) il comando di taglio dovrebbe essere applicato al 4 ° campo: cut -f4

La soluzione @imTachu funziona bene. Per farlo tramite la console AWS ...

• Console AWS
• Servizi
• Networking e distribuzione di contenuti
• VPC
• Cerca un blocco denominato "Running Instances", questo ti mostrerà la regione corrente
• Fare clic sul collegamento "Visualizza tutte le regioni" sottostante

1. Per prima cosa vai alla console di gestione AWS e fai clic su Gruppo di risorse:

   

2. Quindi trova Network and Content Deliverye fai clic su VPC:

   

3. Quindi trova Istanze in esecuzione ed espandi vedi tutte le regioni. Qui puoi trovare tutte le istanze in esecuzione di tutta la regione:

   

In Console

Vai alla dashboard VPC https://console.aws.amazon.com/vpc/homee fai clic su Running instances-> See all regions.

In CLI

Aggiungi questo ad esempio a .bashrc. Ricaricalo source ~/.bashrced eseguilo

Nota: ad eccezione della CLI di aws, è necessario che jq sia installato

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
}

Output di esempio:

$ 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'..

Ogni volta che crei una risorsa, contrassegnala con un nome e ora puoi utilizzare i gruppi di risorse per trovare tutti i tipi di risorse con un'etichetta nome in tutte le regioni.

Basato sulla risposta di imTachus ma meno prolisso e più veloce. È necessario che siano installati jq e aws-cli .

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

Lo script esegue aws ec2 describe-instancesin parallelo per ogni regione (ora 15!) Ed estrae solo i bit rilevanti (stato, tag, zona di disponibilità) dall'output json. Ilset +m operazione è necessaria per i processi in background non segnalano quando si avvia / fine.

Output di esempio:

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

Dopo aver letto tutte le soluzioni e provato un sacco di cose, quello che ha funzionato per me è stato-

1. Voce di elenco
2. Vai a Gruppo di risorse
3. Editor di tag
4. Seleziona tutte le regioni
5. Seleziona Istanza EC2 nel tipo di risorsa
6. Fare clic su Cerca risorse

Puoi correre DescribeInstances()in tutte le regioni.

Inoltre puoi:

• Automatizzalo tramite Lambda e Cloud Watch.
• Crea un endpoint API utilizzando Lambda e il gateway API e usalo nel tuo codice

Un esempio in NodeJS:

• Crea un array di regioni (endpoint). [può anche usare AWS DescriviRegions () ]

var regionNames = ['us-west-1', 'us-west-2', 'us-east-1', 'eu-west-1', 'eu-central-1', 'sa-east-1 "," ap-sud-est-1 "," ap-sud-est-2 "," ap-nord-est-1 "," ap-nord-est-2 "];

    regionNames.forEach (function (region) {
        getInstances (regione);
    });

• Quindi, in getInstancesfunzione, DescribeInstances()può essere chiamato.

function getInstances (region) {
            EC2.describeInstances (params, function (err, data) {
                if (err) return console.log ("Errore di connessione ad AWS, nessuna istanza di questo tipo trovata!");
                data.Reservations.forEach (function (reservation) {
                // esegue qualsiasi operazione prevista
      });
    }

E fuori rotta, sentiti libero di usare ES6 e versioni successive.

Ho scritto una funzione lambda per ottenere tutte le istanze in qualsiasi stato [in esecuzione, arrestato] e da qualsiasi regione, fornirà anche dettagli sul tipo di istanza e vari altri parametri.

Lo script viene eseguito in tutte le regioni e chiamate AWS DescribeInstances()per ottenere le istanze.

Hai solo bisogno di creare una funzione lambda con run-time nodejs. Puoi persino creare API da esso e usarlo come e quando richiesto.

Inoltre, puoi consultare i documenti ufficiali di AWS per descrizione per esplorare molte altre opzioni.

Ho creato uno script open source che ti aiuta a elencare tutte le istanze AWS. https://github.com/Appnroll/aws-ec2-instances

Questa è una parte dello script che elenca le istanze per un profilo registrandole in un database postgreSQL con l'utilizzo jqper l'analisi json:

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

Il mio script di seguito, basato su vari suggerimenti da questo post e altrove. Lo script è più facile da seguire (almeno per me) rispetto alle lunghe righe di comando.

Lo script presume che i profili delle credenziali siano archiviati in un file ~/.aws/credentialssimile a:

[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

Per eseguire lavori in parallelo e utilizzare più profili, utilizzare questo script.

#! / Bin / bash
per i in profilo1 profilo2
fare
    OWNER_ID = `aws iam get-user --profile $ i --output text | awk -F ':' '{print $ 5}' `
    tput setaf 2; echo "Profilo: $ i"; tput sgr0
    tput setaf 2; echo "OwnerID: $ OWNER_ID"; tput sgr0
    per la regione in `aws --profile $ i ec2 descrivere-regioni --output testo | cut -f4`
    fare
        tput setaf 1; echo "Elenco delle istanze nella regione $ region"; tput sgr0
        aws ec2 descrizione-istanze --query 'Prenotazioni [*]. Istanze [*]. [Tag [? Key == `Nome`] .Value, InstanceId]' --profile $ i --region $ regione --output text
    fatto &
fatto
aspettare

Immagine dello schermo:

Sulla base del codice @hansaplast ho creato una versione amichevole di Windows che supporta più profili come argomento. Basta salvare quel file come cmd o file bat. Devi anche avere il jqcomando.

@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}"
)

È possibile utilizzare lo strumento cli progettato per enumerare le risorse cloud (scansione su più regioni e su più account): https://github.com/scopely-devops/skew

Dopo una breve configurazione è possibile utilizzare il codice seguente per elencare tutte le istanze in tutte le regioni AWS degli Stati Uniti (supponendo che 123456789012 sia il numero di account AWS).

from skew import scan

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

Ottimo strumento per le risorse AWS CRUD . Trova [EC2 | RDS | IAM ..] in tutte le regioni. È possibile eseguire operazioni (stop | run | terminate) sui risultati dei filtri.

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]