Wie werden alle laufenden Amazon EC2-Instanzen in allen Regionen angezeigt?

Ich wechsle häufig zwischen verschiedenen Regionen und vergesse manchmal, meine laufende Instanz aus einer anderen Region auszuschalten. Ich konnte keine Möglichkeit finden, alle laufenden Instanzen auf der Amazon-Konsole anzuzeigen.
Gibt es eine Möglichkeit, alle laufenden Instanzen unabhängig von der Region anzuzeigen?

Eine nicht offensichtliche GUI-Option ist Resource Groups > Tag Editor. Hier finden Sie alle Instanzen in allen Regionen, auch wenn die Instanzen nicht markiert wurden.

BEARBEITEN: Dieser Bildschirm wurde kürzlich neu gestaltet und hat jetzt ein neues Aussehen und die Option "Alle Regionen".

Ich glaube nicht, dass Sie dies derzeit in der AWS-GUI tun können. Mit der AWS-CLI können Sie jedoch alle Ihre Instanzen in allen Regionen auflisten:

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

Von hier aus aufgenommen (Wenn Sie die vollständige Diskussion sehen möchten)

Auch wenn Sie eine bekommen

Sie müssen eine Region angeben. Sie können Ihre Region auch konfigurieren, indem Sie "aws configure" ausführen.

Sie können dies mit tun aws configure set region us-east-1, danke @Sabuncu für den Kommentar.

Aktualisieren

Jetzt (2019) sollte der Befehl cut auf das 4. Feld angewendet werden: cut -f4

Die @ imTachu-Lösung funktioniert gut. Dazu über die AWS-Konsole ...

• AWS-Konsole
• Dienstleistungen
• Networking & Content Delivery
• VPC
• Suchen Sie nach einem Block mit dem Namen "Running Instances". Hier wird die aktuelle Region angezeigt
• Klicken Sie unten auf den Link "Alle Regionen anzeigen"

1. Gehen Sie zuerst zur AWS Management-Konsole und klicken Sie auf Ressourcengruppe:

   

2. Dann finden Network and Content Deliveryund klicken Sie auf VPC:

   

3. Suchen Sie dann Laufende Instanzen und erweitern Sie Alle Regionen anzeigen. Hier finden Sie alle laufenden Instanzen aller Regionen:

   

In der Konsole

Gehen Sie zum VPC-Dashboard https://console.aws.amazon.com/vpc/homeund klicken Sie auf Running instances-> See all regions.

In der CLI

Fügen Sie dies zum Beispiel hinzu .bashrc. Laden Sie es neu source ~/.bashrcund führen Sie es aus

Hinweis: Mit Ausnahme von aws CLI muss jq installiert sein

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
}

Beispielausgabe:

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

Kennzeichnen Sie eine Ressource jedes Mal mit einem Namen, und jetzt können Sie mithilfe von Ressourcengruppen alle Arten von Ressourcen mit einem Namensschild in allen Regionen suchen.

Basierend auf der imTachus-Antwort, aber weniger ausführlich und schneller. Sie müssen jq und aws-cli installiert haben.

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

Das Skript führt die aws ec2 describe-instancesparallele Ausführung für jede Region (jetzt 15!) Aus und extrahiert nur die relevanten Bits (Status, Tags, Verfügbarkeitszone) aus der JSON-Ausgabe. Das set +mwird benötigt, damit die Hintergrundprozesse beim Starten / Beenden nicht berichten.

Beispielausgabe:

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

Nachdem ich alle Lösungen durchgelesen und ein paar Sachen ausprobiert hatte, war die, die für mich funktionierte,

1. Listenpunkt
2. Gehen Sie zur Ressourcengruppe
3. Tag-Editor
4. Wählen Sie Alle Regionen
5. Wählen Sie im Ressourcentyp die EC2-Instanz aus
6. Klicken Sie auf Ressourcen durchsuchen

Sie können DescribeInstances()über alle Regionen laufen .

Zusätzlich können Sie:

• Automatisieren Sie es durch Lambda und Cloud Watch.
• Erstellen Sie einen API-Endpunkt mit Lambda und dem API-Gateway und verwenden Sie ihn in Ihrem Code

Ein Beispiel in NodeJS:

• Erstellen und Anordnen von Regionen (Endpunkten). [kann auch AWS descriptionRegions () verwenden ]

var regionNames = ['us-west-1', 'us-west-2', 'us-east-1', 'eu-west-1', 'eu-central-1', 'sa-east-1 ',' ap-südost-1 ',' ap-südost-2 ',' ap-nordost-1 ',' ap-nordost-2 '];

    regionNames.forEach (Funktion (Region) {
        getInstances (Region);
    });

• Dann kann in getInstancesFunktion DescribeInstances()aufgerufen werden.

Funktion getInstances (Region) {
            EC2.describeInstances (params, function (err, data) {
                if (err) return console.log ("Fehler beim Herstellen einer Verbindung zu AWS, keine solche Instanz gefunden!");
                data.Reservations.forEach (Funktion (Reservierung) {
                // mache jede beabsichtigte Operation
      });
    }}

Und natürlich können Sie ES6 und höher verwenden.

Ich habe eine Lambda-Funktion geschrieben, mit der Sie alle Instanzen in einem beliebigen Zustand [ausgeführt, gestoppt] und aus beliebigen Regionen abrufen können. Außerdem werden Details zum Instanztyp und zu verschiedenen anderen Parametern angegeben.

Das Skript wird in allen AWS-Regionen und -Aufrufen ausgeführt DescribeInstances(), um die Instanzen abzurufen.

Sie müssen nur eine Lambda-Funktion mit Laufzeit erstellen nodejs. Sie können sogar eine API daraus erstellen und bei Bedarf verwenden.

Darüber hinaus können Sie die offiziellen AWS-Dokumente für DescribeInstances anzeigen , um viele weitere Optionen zu erkunden.

Ich habe ein Open-Source-Skript erstellt, mit dem Sie alle AWS-Instanzen auflisten können. https://github.com/Appnroll/aws-ec2-instances

Dies ist ein Teil des Skripts, das die Instanzen für ein Profil auflistet, die sie in einer PostgreSQL-Datenbank aufzeichnen und jqfür die JSON-Analyse verwenden:

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

Mein Skript unten basiert auf verschiedenen Tipps aus diesem Beitrag und anderswo. Das Skript ist (zumindest für mich) einfacher zu befolgen als die langen Befehlszeilen.

Das Skript geht davon aus, dass Anmeldeinformationsprofile in einer Datei gespeichert sind, die ~/.aws/credentialsungefähr so ​​aussieht:

[default]
aws_access_key_id = foobar
aws_secret_access_key = foobar

[work]
aws_access_key_id = foobar
aws_secret_access_key = foobar

Skript:

#!/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

Verwenden Sie dieses Skript, um Jobs parallel auszuführen und mehrere Profile zu verwenden.

#! / bin / bash
für i in profile1 profile2
machen
    OWNER_ID = `aws iam get-user --profile $ i --output text | awk -F ':' '{print $ 5}' `
    tput setaf 2; echo "Profil: $ i"; tput sgr0
    tput setaf 2; echo "OwnerID: $ OWNER_ID"; tput sgr0
    für region in `aws --profile $ i ec2 beschreiben-regionen --ausgabetext | -f4` schneiden
    machen
        tput setaf 1; echo "Listing Instances in region $ region"; tput sgr0
        aws ec2 description-instance - Abfrage 'Reservierungen [*]. Instanzen [*]. [Tags [? Key == `Name`] .Value, InstanceId]' --profile $ i --region $ region --output text
    getan &
getan
warten

Bildschirmfoto:

Basierend auf @ hansaplast-Code habe ich eine Windows-freundliche Version erstellt, die mehrere Profile als Argument unterstützt. Speichern Sie diese Datei einfach als cmd- oder bat-Datei. Sie müssen auch jqBefehl haben.

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

Sie können das CLI-Tool verwenden, das zum Auflisten von Cloud-Ressourcen (bereichs- und kontenübergreifender Scan) entwickelt wurde - https://github.com/scopely-devops/skew

Nach einer kurzen Konfiguration können Sie den folgenden Code verwenden, um alle Instanzen in allen US-amerikanischen AWS-Regionen aufzulisten (vorausgesetzt, 123456789012 ist Ihre AWS-Kontonummer).

from skew import scan

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

Gutes Tool zum CRUD AWS-Ressourcen . Finden Sie [EC2 | RDS | IAM ..] in allen Regionen. Es können Operationen (stop | run | terminate) an Filterergebnissen ausgeführt werden.

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]