web-dev-qa-db-fra.com

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

Je change souvent d'instance entre différentes régions et parfois j'oublie de désactiver mon instance en cours d'exécution dans 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 indépendamment de la région?

amazon-web-servicesamazon-ec2ec2-ami
45
JerryGoyal

Je ne pense pas que vous puissiez actuellement le faire 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 --output text | cut -f3`
do
     echo -e "\nListing Instances in region:'$region'..."
     aws ec2 describe-instances --region $region
done

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

42
imTachu

EDIT: Comme @breakpoint le souligne dans les commentaires, il semble que l'éditeur de balises ait été mis à jour et que la fonctionnalité de recherche entre régions ait été supprimée: - /

Je mettrai cela à jour si je trouve une alternative.

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 l’instance n’a pas été taguée . enter image description here

38
Heinrich Filter

Chaque fois que vous créez une ressource, associez-lui un nom et identifiez-la. Vous pouvez maintenant utiliser Groupes de ressources pour rechercher tous les types de ressources portant une balise de nom dans toutes les régions.

7
Mallikarjuna Reddy

Basé sur imTachus, mais répondez moins, et plus rapidement. Vous devez avoir jq et aws-cli installé.

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-instances en 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 +m est nécessaire pour que les processus en arrière-plan ne fassent pas état du début/de la fin.

Exemple de sortie:

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

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

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

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

De plus, vous pouvez:

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

Un exemple dans NodeJS: 

  • Créez et mettez en réseau des régions (points d'extrémité). [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 (region) {
 getInstances (region); 
});
  • Ensuite, dans la fonction getInstances, DescribeInstances() peut être appelé Appelé.
fonction getInstances (région) {
 EC2.describeInstances (params, fonction (err, données) {
 If (err) renvoie console.log ("Erreur de connexion à AWS, aucune instance trouvée!"); 
 Data.Reservations.forEach (fonction ( réservation) {
 // effectuer toute opération voulue 
}); 
}

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

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

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

Il vous suffit de créer une fonction lambda avec nodejs..__ au moment de l'exécution. Vous pouvez même créer une API à partir de celle-ci et l'utiliser au besoin.

De plus, vous pouvez consulter le document officiel AWS pour DescribeInstances pour explorer de nombreuses autres options.

2
J. Parashar

  1. Tout d'abord, allez dans AWS Management Console et cliquez sur Groupe de ressources:

     enter image description here

  2. Ensuite, trouvez Network and Content Delivery et cliquez sur la VPC:

     enter image description here

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

     enter image description here

0
rdhawladar

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

Après une courte configuration, vous pouvez utiliser le code suivant pour répertorier toutes les instances de 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)
0
Dmytro

Sur la base du code @hansaplast, j'ai créé une version conviviale de Windows prenant en charge plusieurs profils en tant qu'argument. Il suffit de sauvegarder ce fichier en tant que fichier cmd ou bat. Vous devez également avoir la commande jq.

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

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

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

[default]
aws_access_key_id = ODJFDOIOIJIJFJDIOFHJ
aws_secret_access_key = spdofksdpfok345opdfkgfdpogkdsfjsd

[work]
aws_access_key_id = GF6TPDWBZMZWCZ8P1002
aws_secret_access_key = fpoksdfopdskf4350sdfsjdfkosdfjlfs

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 -f3 | 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
0
Eduard Rozenberg

Bon outil pour ressources CRUD AWS . Trouvez [EC2 | RDS | IAM ..] dans toutes les régions. Il peut faire des opérations (stop | run | terminate) 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]
0
Rafal

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 qui les enregistre dans une base de données postgreSQL en utilisant jq pour 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
0
tuhaj