Como ver todas as instâncias do Amazon EC2 em execução em todas as regiões?

Eu alterno instâncias entre diferentes regiões com frequência e às vezes me esqueço de desligar minha instância em execução em uma região diferente. Não consegui encontrar nenhuma maneira de ver todas as instâncias em execução no console da Amazon.
Existe alguma maneira de exibir todas as instâncias em execução, independentemente da região?

Uma opção de GUI não óbvia é Resource Groups > Tag Editor. Aqui você pode encontrar todas as instâncias em todas as regiões, mesmo se as instâncias não foram marcadas.

EDITAR: Esta tela foi redesenhada recentemente e agora tem um novo visual e uma opção "Todas as regiões".

Não acho que você possa fazer isso atualmente na AWS GUI. Mas aqui está uma maneira de listar todas as suas instâncias em todas as regiões com o 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

Retirado daqui (se você quiser ver a discussão completa)

Além disso, se você estiver recebendo um

Você deve especificar uma região. Você também pode configurar sua região executando "aws configure"

Você pode fazer isso com aws configure set region us-east-1, obrigado @Sabuncu pelo comentário.

Atualizar

Agora (em 2019) o comando de corte deve ser aplicado no 4º campo: cut -f4

A solução @imTachu funciona bem. Para fazer isso por meio do console AWS ...

• Console AWS
• Serviços
• Rede e distribuição de conteúdo
• VPC
• Procure por um bloco chamado "Running Instances", isso irá mostrar a você a região atual
• Clique no link "Ver todas as regiões" abaixo

1. Primeiro, vá para o console de gerenciamento da AWS e clique em Grupo de recursos:

   

2. Em seguida, localize Network and Content Deliverye clique em VPC:

   

3. Em seguida, encontre instâncias em execução e expanda para ver todas as regiões. Aqui você pode encontrar todas as instâncias em execução de todas as regiões:

   

No console

Vá para o painel VPC https://console.aws.amazon.com/vpc/homee clique em Running instances-> See all regions.

Em CLI

Adicione isso, por exemplo, a .bashrc. Recarregue-o source ~/.bashrce execute-o

Nota: Exceto para aws CLI, você precisa ter o 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
}

Exemplo de saída:

$ 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 você criar um recurso, marque-o com um nome e agora você pode usar grupos de recursos para localizar todos os tipos de recursos com uma marca de nome em todas as regiões.

Com base na resposta do imTachus, mas menos prolixo e mais rápido. Você precisa ter o jq e o 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

O script é executado aws ec2 describe-instancesem paralelo para cada região (agora 15!) E extrai apenas os bits relevantes (estado, tags, zona de disponibilidade) da saída json. O set +mé necessário para que os processos em segundo plano não relatem ao iniciar / terminar.

Exemplo de saída:

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

Depois de ler todas as soluções e tentar várias coisas, a que funcionou para mim foi-

1. Item da lista
2. Vá para o Grupo de Recursos
3. Editor de Tag
4. Selecione todas as regiões
5. Selecione a instância EC2 no tipo de recurso
6. Clique em Pesquisar Recursos

Você pode correr DescribeInstances()em todas as regiões.

Além disso, você pode:

• Automatize-o através do Lambda e Cloud watch.
• Crie um endpoint api usando Lambda e api gateway e use-o em seu código

Uma amostra em NodeJS:

• Crie uma matriz de regiões (pontos de extremidade). [também pode usar AWS describeRegions () ]

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

    regionNames.forEach (function (region) {
        getInstances (região);
    });

• Então, em getInstancesfunção, DescribeInstances()pode ser chamado.

function getInstances (region) {
            EC2.describeInstances (params, function (err, data) {
                if (err) return console.log ("Erro ao conectar a AWS, nenhuma instância encontrada!");
                data.Reservations.forEach (função (reserva) {
                // faça qualquer operação pretendida
      });
    }

E fora do curso, sinta-se à vontade para usar o ES6 e superior.

Eu escrevi uma função lambda para obter a você todas as instâncias em qualquer estado [executando, interrompido] e de quaisquer regiões, também fornecerá detalhes sobre o tipo de instância e vários outros parâmetros.

O script é executado em todas as regiões e chamadas da AWS DescribeInstances()para obter as instâncias.

Você só precisa criar uma função lambda com tempo de execução nodejs. Você pode até criar uma API a partir dele e usá-lo como e quando necessário.

Além disso, você pode ver os documentos oficiais da AWS para DescribeInstances para explorar muitas outras opções.

Criei um script de código aberto que ajuda você a listar todas as instâncias da AWS. https://github.com/Appnroll/aws-ec2-instances

Essa é uma parte do script que lista as instâncias de um perfil gravando-as em um banco de dados postgreSQL com o uso jqpara análise 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

Meu roteiro abaixo, baseado em várias dicas deste post e de outros lugares. O script é mais fácil de seguir (pelo menos para mim) do que as longas linhas de comando.

O script assume que os perfis de credencial estão armazenados no arquivo com a ~/.aws/credentialsaparência de:

[default]
aws_access_key_id = foobar
aws_secret_access_key = foobar

[work]
aws_access_key_id = foobar
aws_secret_access_key = foobar

Roteiro:

#!/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 executar trabalhos em paralelo e usar vários perfis, use este script.

#! / bin / bash
para i no perfil1 perfil2
Faz
    OWNER_ID = `aws iam get-user --profile $ i --output text | awk -F ':' '{print $ 5}' `
    tput setaf 2; echo "Perfil: $ i"; tput sgr0
    tput setaf 2; echo "OwnerID: $ OWNER_ID"; tput sgr0
    para região em `aws --profile $ i ec2 describe-regiões --output text | cut -f4`
    Faz
        tput setaf 1; echo "Listando Instâncias na região $ region"; tput sgr0
        aws ec2 describe-instances --query 'Reservas [*]. Instâncias [*]. [Tags [? Key == `Name`] .Value, InstanceId]' --perfile $ i --region $ region --output text
    feito &
feito
esperar

Captura de tela:

Com base no código @hansaplast, criei uma versão amigável do Windows que suporta vários perfis como argumento. Basta salvar esse arquivo como cmd ou arquivo bat. Você também precisa ter o 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}"
)

Você pode usar a ferramenta CLI projetada para enumerar recursos de nuvem (verificação entre regiões e contas cruzadas) - https://github.com/scopely-devops/skew

Após uma breve configuração, você pode usar o código a seguir para listar todas as instâncias em todas as regiões AWS dos EUA (presumindo que 123456789012 seja o número da sua conta AWS).

from skew import scan

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

Boa ferramenta para recursos CRUD AWS . Encontre [EC2 | RDS | IAM ..] em todas as regiões. Podem ser realizadas operações (parar | executar | encerrar) nos resultados dos 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]