¿Cómo ver todas las instancias Amazon EC2 en ejecución en todas las regiones?

Cambio instancias entre diferentes regiones con frecuencia y, a veces, me olvido de apagar mi instancia en ejecución desde una región diferente. No pude encontrar ninguna forma de ver todas las instancias en ejecución en la consola de Amazon.
¿Hay alguna forma de mostrar todas las instancias en ejecución independientemente de la región?

Una opción de GUI no obvia es Resource Groups > Tag Editor. Aquí puede encontrar todas las instancias en todas las regiones, incluso si las instancias no fueron etiquetadas.

EDITAR: Esta pantalla fue rediseñada recientemente y ahora tiene un nuevo aspecto y una opción "Todas las regiones".

No creo que pueda hacer esto actualmente en la GUI de AWS. Pero aquí hay una forma de enumerar todas sus instancias en todas las regiones con la 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

Tomado de aquí (si desea ver la discusión completa)

Además, si obtiene un

Debes especificar una región. También puede configurar su región ejecutando "aws configure"

Puedes hacerlo con aws configure set region us-east-1, gracias @Sabuncu por el comentario.

Actualizar

Ahora (en 2019) el comando de corte debería aplicarse en el cuarto campo: cut -f4

La solución @imTachu funciona bien. Para hacer esto a través de la consola de AWS ...

• Consola de AWS
• Servicios
• Redes y entrega de contenido
• VPC
• Busque un bloque llamado "Ejecución de instancias", esto le mostrará la región actual
• Haga clic en el vínculo "Ver todas las regiones" debajo.

1. Primero vaya a la consola de administración de AWS y haga clic en Grupo de recursos:

   

2. Luego busque Network and Content Deliveryy haga clic en VPC:

   

3. Luego, busque Instancias en ejecución y expanda Ver todas las regiones. Aquí puede encontrar todas las instancias en ejecución de todas las regiones:

   

En consola

Vaya al panel de VPC https://console.aws.amazon.com/vpc/homey haga clic en Running instances-> See all regions.

En CLI

Agregue esto, por ejemplo, a .bashrc. Recargarlo source ~/.bashrcy ejecutarlo

Nota: a excepción de la CLI de AWS , debe tener jq instalado

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
}

Salida de ejemplo:

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

Cada vez que cree un recurso, etiquételo con un nombre y ahora puede usar Grupos de recursos para encontrar todo tipo de recursos con una etiqueta de nombre en todas las regiones.

Basado en la respuesta de imTachus pero menos detallado y más rápido. Necesita tener jq y aws-cli instalados.

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

El script se ejecuta aws ec2 describe-instancesen paralelo para cada región (¡ahora 15!) Y extrae solo los bits relevantes (estado, etiquetas, zona de disponibilidad) de la salida json. El set +mes necesario para que los procesos en segundo plano no informen al inicio / finalización.

Salida de ejemplo:

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

Después de leer todas las soluciones y probar muchas cosas, la que funcionó para mí fue-

1. Elemento de lista
2. Ir al grupo de recursos
3. Editor de etiquetas
4. Seleccionar todas las regiones
5. Seleccione la instancia EC2 en el tipo de recurso
6. Haga clic en Buscar recursos

Puede ejecutar DescribeInstances()en todas las regiones.

Además, puede:

• Automatícelo a través de Lambda y Cloud Watch.
• Cree un punto final de API utilizando Lambda y una puerta de enlace de API y utilícelo en su código

Una muestra en NodeJS:

• Crear una matriz de regiones (puntos finales). [también puede usar AWS describeRegions () ]

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

    regionNames.forEach (función (región) {
        getInstances (región);
    });

• Entonces, en getInstancesfunción, DescribeInstances()se puede llamar.

function getInstances (region) {
            EC2.describeInstances (params, function (err, data) {
                if (err) return console.log ("Error al conectarse a AWS, no se encontró ninguna instancia");
                data.Reservations.forEach (función (reserva) {
                // realizar cualquier operación prevista
      });
    }

Y, por supuesto, siéntase libre de usar ES6 y superior.

Escribí una función lambda para obtener todas las instancias en cualquier estado [en ejecución, detenido] y de cualquier región, también daré detalles sobre el tipo de instancia y varios otros parámetros.

El script se ejecuta en todas las regiones y llamadas de AWS DescribeInstances()para obtener las instancias.

Solo necesita crear una función lambda con tiempo de ejecución nodejs. Incluso puede crear una API a partir de ella y usarla cuando sea necesario.

Además, puede consultar los documentos oficiales de AWS para DescribeInstances para explorar muchas más opciones.

Creé un script de código abierto que le ayuda a enumerar todas las instancias de AWS. https://github.com/Appnroll/aws-ec2-instances

Esa es una parte del script que enumera las instancias para un perfil que las registra en una base de datos postgreSQL con el uso jqpara el análisis 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

Mi guión a continuación, basado en varios consejos de esta publicación y en otros lugares. El guión es más fácil de seguir (al menos para mí) que las largas líneas de comando.

El script asume que los perfiles de credenciales están almacenados en un archivo con un ~/.aws/credentialsaspecto similar a:

[default]
aws_access_key_id = foobar
aws_secret_access_key = foobar

[work]
aws_access_key_id = foobar
aws_secret_access_key = foobar

Guión:

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

Para ejecutar trabajos en paralelo y utilizar varios perfiles, utilice este script.

#! / bin / bash
para yo en profile1 profile2
hacer
    OWNER_ID = `aws iam get-user --profile $ i --output text | awk -F ':' '{imprimir $ 5}' `
    tput setaf 2; echo "Perfil: $ i"; tput sgr0
    tput setaf 2; echo "OwnerID: $ OWNER_ID"; tput sgr0
    para región en `aws --profile $ i ec2 describe-regiones - texto de salida | cortar -f4`
    hacer
        tput setaf 1; echo "Listado de instancias en la región $ región"; tput sgr0
        aws ec2 describe-instances --query 'Reservas [*]. Instancias [*]. [Etiquetas [? Key == `Name`] .Value, InstanceId]' --profile $ i --region $ region - texto de salida
    hecho &
hecho
Espere

Captura de pantalla:

Basado en el código @hansaplast, creé una versión compatible con Windows que admite múltiples perfiles como argumento. Simplemente guarde ese archivo como archivo cmd o bat. También necesitas tener el jqmando.

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

Puede usar la herramienta cli diseñada para enumerar recursos en la nube (escaneo entre regiones y cuentas): https://github.com/scopely-devops/skew

Después de una breve configuración, puede usar el siguiente código para enumerar todas las instancias en todas las regiones de AWS de EE. UU. (Asumiendo que 123456789012 es su número de cuenta de AWS).

from skew import scan

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

Buena herramienta para CRUD AWS recursos . Busque [EC2 | RDS | IAM ..] en todas las regiones. Se pueden realizar operaciones (detener | ejecutar | terminar) en los resultados de los filtros.

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]