Comment voir toutes les instances Amazon EC2 en cours d'exécution dans toutes les régions?

Je change fréquemment d'instance entre différentes régions et j'oublie parfois de désactiver mon instance en cours d'exécution à partir d'une autre région. Je n'ai trouvé aucun moyen de voir toutes les instances en cours d'exécution sur la console Amazon.
Existe-t-il un moyen d'afficher toutes les instances en cours d'exécution quelle que soit la région?

Une option d'interface graphique non évidente est Resource Groups > Tag Editor. Ici, vous pouvez trouver toutes les instances dans toutes les régions, même si les instances n'ont pas été balisées.

EDIT: Cet écran a été récemment repensé et a maintenant un nouveau look et une option "Toutes les régions".

Je ne pense pas que vous puissiez actuellement faire cela dans l'interface graphique AWS. Mais voici un moyen de répertorier toutes vos instances dans toutes les régions avec l'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

Tiré d' ici (si vous voulez voir la discussion complète)

De plus, si vous obtenez un

Vous devez spécifier une région. Vous pouvez également configurer votre région en exécutant "aws configure"

Vous pouvez le faire avec aws configure set region us-east-1, merci @Sabuncu pour le commentaire.

Mettre à jour

Maintenant (en 2019) la commande cut devrait être appliquée sur le 4ème champ: cut -f4

La solution @imTachu fonctionne bien. Pour ce faire via la console AWS ...

• Console AWS
• Prestations de service
• Mise en réseau et diffusion de contenu
• VPC
• Recherchez un bloc nommé "Running Instances", cela vous montrera la région actuelle
• Cliquez sur le lien "Voir toutes les régions" en dessous

1. Accédez d' abord à AWS Management Console et cliquez sur Groupe de ressources:

   

2. Puis recherchez Network and Content Deliveryet cliquez sur VPC:

   

3. Recherchez ensuite les instances en cours d'exécution et développez pour voir toutes les régions. Ici vous pouvez trouver toutes les instances en cours d'exécution de toutes les régions:

   

Dans la console

Accédez au tableau de bord VPC https://console.aws.amazon.com/vpc/homeet cliquez sur Running instances-> See all regions.

Dans CLI

Ajoutez ceci par exemple à .bashrc. Rechargez-le source ~/.bashrcet exécutez-le

Remarque: sauf pour AWS CLI, vous devez avoir installé jq

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
}

Exemple de sortie:

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

Chaque fois que vous créez une ressource, attribuez-lui un nom et vous pouvez désormais utiliser les groupes de ressources pour rechercher tous les types de ressources avec une étiquette de nom dans toutes les régions.

Basé sur la réponse imTaque mais moins verbeux, plus rapide. Vous devez avoir installé jq et 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

Le script exécute le aws ec2 describe-instancesen parallèle pour chaque région (maintenant 15!) Et extrait uniquement les bits pertinents (état, balises, zone de disponibilité) de la sortie json. Le set +mest nécessaire pour que les processus d'arrière-plan ne signalent pas lors du démarrage / de la fin.

Exemple de sortie:

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

Après avoir lu toutes les solutions et essayé un tas de choses, celle qui a fonctionné pour moi était-

1. Élément de liste
2. Aller au groupe de ressources
3. Éditeur de balises
4. Sélectionnez toutes les régions
5. Sélectionnez Instance EC2 dans le type de ressource
6. Cliquez sur Rechercher des ressources

Vous pouvez courir DescribeInstances()dans toutes les régions.

De plus, vous pouvez:

• Automatisez-le via Lambda et Cloud Watch.
• Créez un point de terminaison d'API à l'aide de Lambda et de la passerelle API et utilisez-le dans votre code

Un exemple dans NodeJS:

• Créez un tableau de régions (points de terminaison). [peut également utiliser AWS describeRegions () ]

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 (fonction (région) {
        getInstances (région);
    });

• Ensuite, en getInstancesfonction, DescribeInstances()peut être appelé.

function getInstances (région) {
            EC2.describeInstances (paramètres, fonction (err, données) {
                if (err) return console.log ("Erreur de connexion à AWS, aucune instance de ce type trouvée!");
                data.Reservations.forEach (fonction (réservation) {
                // faire n'importe quelle opération prévue
      });
    }

Et bien sûr, n'hésitez pas à utiliser ES6 et supérieur.

J'ai écrit une fonction lambda pour vous obtenir toutes les instances dans n'importe quel état [en cours d'exécution, arrêté] et de toutes les régions, donnera également des détails sur le type d'instance et divers autres paramètres.

Le script s'exécute dans toutes les régions et tous les appels AWS DescribeInstances()pour obtenir les instances.

Il vous suffit de créer une fonction lambda avec run-time nodejs. Vous pouvez même en créer une API et l'utiliser au besoin.

En outre, vous pouvez consulter la documentation officielle AWS pour DescribeInstances pour explorer de nombreuses autres options.

J'ai créé un script open source qui vous aide à répertorier toutes les instances AWS. https://github.com/Appnroll/aws-ec2-instances

C'est une partie du script qui répertorie les instances d'un profil en les enregistrant dans une base de données postgreSQL avec utilisation jqpour l'analyse 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

Mon script ci-dessous, basé sur divers conseils de cet article et d'ailleurs. Le script est plus facile à suivre (pour moi du moins) que les longues lignes de commande.

Le script suppose que le ou les profils d'identification sont stockés dans un fichier ~/.aws/credentialsressemblant à quelque chose comme:

[default]
aws_access_key_id = foobar
aws_secret_access_key = foobar

[work]
aws_access_key_id = foobar
aws_secret_access_key = foobar

Scénario:

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

Pour exécuter des travaux en parallèle et utiliser plusieurs profils, utilisez ce script.

#! / bin / bash
pour i dans profile1 profile2
faire
    OWNER_ID = `aws iam get-user --profile $ i --output text | awk -F ':' '{imprimer $ 5}' `
    tput setaf 2; echo "Profil: $ i"; tput sgr0
    tput setaf 2; echo "OwnerID: $ OWNER_ID"; tput sgr0
    pour la région dans `aws --profile $ i ec2 describe-regions --output text | couper -f4`
    faire
        tput setaf 1; echo "Liste des instances dans la région $ region"; tput sgr0
        aws ec2 describe-instances --query 'Reservations [*]. Instances [*]. [Tags [? Key == `Name`] .Value, InstanceId]' --profile $ i --region $ region --output text
    terminé &
terminé
attendre

Capture d'écran:

Sur la base du code @hansaplast, j'ai créé une version conviviale de Windows qui prend en charge plusieurs profils comme argument. Enregistrez simplement ce fichier en tant que fichier cmd ou bat. Vous devez également avoir la jqcommande.

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

Vous pouvez utiliser l'outil cli conçu pour énumérer les ressources cloud (analyse interrégionale et inter-comptes) - https://github.com/scopely-devops/skew

Après une brève configuration, vous pouvez utiliser le code suivant pour répertorier toutes les instances dans toutes les régions AWS américaines (en supposant que 123456789012 est votre numéro de compte AWS).

from skew import scan

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

Bon outil pour les ressources CRUD AWS . Recherchez [EC2 | RDS | IAM ..] dans toutes les régions. Il peut faire des opérations (arrêter | exécuter | terminer) sur les résultats des filtres.

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]