Comment obtenir l'ID d'instance depuis une instance ec2?

StackOverflow https://stackoverflow.com/questions/625644

  •  05-07-2019
  •  | 
  •  

Question

Comment puis-je connaître le identificateur d'instance d'une instance ec2 à partir de l'instance ec2?

Était-ce utile?

La solution

Voir la documentation EC2 sur le sujet .

Exécuter: 

wget -q -O - http://169.254.169.254/latest/meta-data/instance-id

Si vous avez besoin d'un accès programmatique à l'ID d'instance à partir d'un script, 

die() { status=$1; shift; echo "FATAL: $*"; exit $status; }
EC2_INSTANCE_ID="`wget -q -O - http://169.254.169.254/latest/meta-data/instance-id || die \"wget instance-id has failed: $?\"`"

Exemple d'utilisation plus avancée (récupération de l'ID d'instance, de la zone de disponibilité et de la région, etc.): 

EC2_INSTANCE_ID="`wget -q -O - http://169.254.169.254/latest/meta-data/instance-id || die \"wget instance-id has failed: $?\"`"
test -n "$EC2_INSTANCE_ID" || die 'cannot obtain instance-id'
EC2_AVAIL_ZONE="`wget -q -O - http://169.254.169.254/latest/meta-data/placement/availability-zone || die \"wget availability-zone has failed: $?\"`"
test -n "$EC2_AVAIL_ZONE" || die 'cannot obtain availability-zone'
EC2_REGION="`echo \"$EC2_AVAIL_ZONE\" | sed -e 's:\([0-9][0-9]*\)[a-z]*\$:\\1:'`"

Vous pouvez également utiliser curl au lieu de wget , en fonction de ce qui est installé sur votre plate-forme.

Autres conseils

Sur les AMI Amazon Linux, vous pouvez effectuer les opérations suivantes: 

$ ec2-metadata -i
instance-id: i-1234567890abcdef0

Ou, sous Ubuntu et d'autres versions de Linux, ec2metadata --instance-id (cette commande peut ne pas être installée par défaut sur ubuntu, mais vous pouvez l'ajouter avec sudo apt- obtenir installer cloud-utils )

Comme son nom l’indique, vous pouvez également utiliser la commande pour obtenir d’autres métadonnées utiles.

Sur Ubuntu, vous pouvez: 

sudo apt-get install cloud-utils

Et ensuite vous pouvez: 

EC2_INSTANCE_ID=$(ec2metadata --instance-id)

Vous pouvez obtenir la plupart des métadonnées associées à l'instance de cette manière: 

ec2metadata --help
Syntax: /usr/bin/ec2metadata [options]

Query and display EC2 metadata.

If no options are provided, all options will be displayed

Options:
    -h --help               show this help

    --kernel-id             display the kernel id
    --ramdisk-id            display the ramdisk id
    --reservation-id        display the reservation id

    --ami-id                display the ami id
    --ami-launch-index      display the ami launch index
    --ami-manifest-path     display the ami manifest path
    --ancestor-ami-ids      display the ami ancestor id
    --product-codes         display the ami associated product codes
    --availability-zone     display the ami placement zone

    --instance-id           display the instance id
    --instance-type         display the instance type

    --local-hostname        display the local hostname
    --public-hostname       display the public hostname

    --local-ipv4            display the local ipv4 ip address
    --public-ipv4           display the public ipv4 ip address

    --block-device-mapping  display the block device id
    --security-groups       display the security groups

    --mac                   display the instance mac address
    --profile               display the instance profile
    --instance-action       display the instance-action

    --public-keys           display the openssh public keys
    --user-data             display the user data (not actually metadata)

Utilisez l'URL / dynamic / instance-identity / document si vous devez également interroger davantage que votre ID d'instance.

wget -q -O - http://169.254.169.254/latest/dynamic/instance-identity/document

Vous obtiendrez des données JSON telles que celle-ci, avec uniquement une requête unique . 

{
    "devpayProductCodes" : null,
    "privateIp" : "10.1.2.3",
    "region" : "us-east-1",
    "kernelId" : "aki-12345678",
    "ramdiskId" : null,
    "availabilityZone" : "us-east-1a",
    "accountId" : "123456789abc",
    "version" : "2010-08-31",
    "instanceId" : "i-12345678",
    "billingProducts" : null,
    "architecture" : "x86_64",
    "imageId" : "ami-12345678",
    "pendingTime" : "2014-01-23T45:01:23Z",
    "instanceType" : "m1.small"
}

Pour .NET Personnes: 

string instanceId = new StreamReader(
      HttpWebRequest.Create("http://169.254.169.254/latest/meta-data/instance-id")
      .GetResponse().GetResponseStream())
    .ReadToEnd();

sur AWS Linux:

ec2-metadata --instance-id | couper-d " " -f 2

Sortie:

i-33400429

Utilisation des variables internes: 

ec2InstanceId=$(ec2-metadata --instance-id | cut -d " " -f 2);
ls "log/${ec2InstanceId}/";

Pour Python: 

import boto.utils
region=boto.utils.get_instance_metadata()['local-hostname'].split('.')[1]

qui se résume à une ligne: 

python -c "import boto.utils; print boto.utils.get_instance_metadata()['local-hostname'].split('.')[1]"

Au lieu de nom_hôte_local, vous pouvez également utiliser nom_hôte_public ou: 

boto.utils.get_instance_metadata()['placement']['availability-zone'][:-1]

Pour les gens PowerShell: 

(New-Object System.Net.WebClient).DownloadString("http://169.254.169.254/latest/meta-data/instance-id")

Voir ce message - Notez que l'adresse IP dans l'URL donnée est constante (ce qui m'a confondu au début), mais les données renvoyées sont spécifiques à votre instance.

Une solution plus contemporaine.

Sur Amazon Linux, la commande ec2-metadata est déjà installée.

À partir du terminal 

ec2-metadata -help

Vous donnera les options disponibles 

ec2-metadata -i

reviendra 

instance-id: yourid

Il suffit de taper: 

ec2metadata --instance-id

Pour toutes les machines ec2, l'identifiant d'instance se trouve dans le fichier: 

    /var/lib/cloud/data/instance-id

Vous pouvez également obtenir l'ID d'instance en exécutant la commande suivante: 

    ec2metadata --instance-id

Vous pouvez essayer ceci: 

#!/bin/bash
aws_instance=$(wget -q -O- http://169.254.169.254/latest/meta-data/instance-id)
aws_region=$(wget -q -O- http://169.254.169.254/latest/meta-data/hostname)
aws_region=${aws_region#*.}
aws_region=${aws_region%%.*}
aws_zone=`ec2-describe-instances $aws_instance --region $aws_region`
aws_zone=`expr match "$aws_zone" ".*\($aws_region[a-z]\)"`

Pour Ruby: 

require 'rubygems'
require 'aws-sdk'
require 'net/http'

metadata_endpoint = 'http://169.254.169.254/latest/meta-data/'
instance_id = Net::HTTP.get( URI.parse( metadata_endpoint + 'instance-id' ) )

ec2 = AWS::EC2.new()
instance = ec2.instances[instance_id]

Une classe c # .net que j'ai écrite pour les métadonnées EC2 à partir de l'API http. Je vais le construire avec des fonctionnalités au besoin. Vous pouvez courir avec si vous l'aimez. 

using Amazon;
using System.Net;

namespace AT.AWS
{
    public static class HttpMetaDataAPI
    {
        public static bool TryGetPublicIP(out string publicIP)
        {
            return TryGetMetaData("public-ipv4", out publicIP);
        }
        public static bool TryGetPrivateIP(out string privateIP)
        {
            return TryGetMetaData("local-ipv4", out privateIP);
        }
        public static bool TryGetAvailabilityZone(out string availabilityZone)
        {
            return TryGetMetaData("placement/availability-zone", out availabilityZone);
        }

        /// <summary>
        /// Gets the url of a given AWS service, according to the name of the required service and the AWS Region that this machine is in
        /// </summary>
        /// <param name="serviceName">The service we are seeking (such as ec2, rds etc)</param>
        /// <remarks>Each AWS service has a different endpoint url for each region</remarks>
        /// <returns>True if the operation was succesful, otherwise false</returns>
        public static bool TryGetServiceEndpointUrl(string serviceName, out string serviceEndpointStringUrl)
        {
            // start by figuring out what region this instance is in.
            RegionEndpoint endpoint;
            if (TryGetRegionEndpoint(out endpoint))
            {
                // now that we know the region, we can get details about the requested service in that region
                var details = endpoint.GetEndpointForService(serviceName);
                serviceEndpointStringUrl = (details.HTTPS ? "https://" : "http://") + details.Hostname;
                return true;
            }
            // satisfy the compiler by assigning a value to serviceEndpointStringUrl
            serviceEndpointStringUrl = null;
            return false;
        }
        public static bool TryGetRegionEndpoint(out RegionEndpoint endpoint)
        {
            // we can get figure out the region end point from the availability zone
            // that this instance is in, so we start by getting the availability zone:
            string availabilityZone;
            if (TryGetAvailabilityZone(out availabilityZone))
            {
                // name of the availability zone is <nameOfRegionEndpoint>[a|b|c etc]
                // so just take the name of the availability zone and chop off the last letter
                var nameOfRegionEndpoint = availabilityZone.Substring(0, availabilityZone.Length - 1);
                endpoint = RegionEndpoint.GetBySystemName(nameOfRegionEndpoint);
                return true;
            }
            // satisfy the compiler by assigning a value to endpoint
            endpoint = RegionEndpoint.USWest2;
            return false;
        }
        /// <summary>
        /// Downloads instance metadata
        /// </summary>
        /// <returns>True if the operation was successful, false otherwise</returns>
        /// <remarks>The operation will be unsuccessful if the machine running this code is not an AWS EC2 machine.</remarks>
        static bool TryGetMetaData(string name, out string result)
        {
            result = null;
            try { result = new WebClient().DownloadString("http://169.254.169.254/latest/meta-data/" + name); return true; }
            catch { return false; }
        }

/************************************************************
 * MetaData keys.
 *   Use these keys to write more functions as you need them
 * **********************************************************
ami-id
ami-launch-index
ami-manifest-path
block-device-mapping/
hostname
instance-action
instance-id
instance-type
local-hostname
local-ipv4
mac
metrics/
network/
placement/
profile
public-hostname
public-ipv4
public-keys/
reservation-id
security-groups
*************************************************************/
    }
}

Le dernier SDK Java contient EC2MetadataUtils :

En Java: 

import com.amazonaws.util.EC2MetadataUtils;
String myId = EC2MetadataUtils.getInstanceId();

En Scala: 

import com.amazonaws.util.EC2MetadataUtils
val myid = EC2MetadataUtils.getInstanceId

Pour C ++ (à l'aide de cURL): 

    #include <curl/curl.h>

    //// cURL to string
    size_t curl_to_str(void *contents, size_t size, size_t nmemb, void *userp) {
        ((std::string*)userp)->append((char*)contents, size * nmemb);
        return size * nmemb;
    };

    //// Read Instance-id 
    curl_global_init(CURL_GLOBAL_ALL); // Initialize cURL
    CURL *curl; // cURL handler
    CURLcode res_code; // Result
    string response;
    curl = curl_easy_init(); // Initialize handler
    curl_easy_setopt(curl, CURLOPT_URL, "http://169.254.169.254/latest/meta-data/instance-id");
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_to_str);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
    res_code = curl_easy_perform(curl); // Perform cURL
    if (res_code != CURLE_OK) { }; // Error
    curl_easy_cleanup(curl); // Cleanup handler
    curl_global_cleanup(); // Cleanup cURL

Si vous souhaitez obtenir la liste de tous les identificateurs d'instance disponibles à l'aide de python, voici le code: 

import boto3

ec2=boto3.client('ec2')
instance_information = ec2.describe_instances()

for reservation in instance_information['Reservations']:
   for instance in reservation['Instances']:
      print(instance['InstanceId'])

FWIW J'ai écrit un système de fichiers FUSE pour fournir un accès au service de métadonnées EC2: https://bitbucket.org/dgc / ec2mdfs . Je lance ceci sur toutes les AMI personnalisées; cela me permet d’utiliser cet idiome: cat / ec2 / meta-data / ami-id

Dans Go, vous pouvez utiliser le package goamz . 

import (
    "github.com/mitchellh/goamz/aws"
    "log"
)

func getId() (id string) {
    idBytes, err := aws.GetMetaData("instance-id")
    if err != nil {
        log.Fatalf("Error getting instance-id: %v.", err)
    }

    id = string(idBytes)

    return id
}

Voici la source GetMetaData.

Vérifiez simplement le lien symbolique var / lib / cloud / instance , il devrait pointer sur / var / lib / cloud / instances / {instance-id} où {instance_id} est votre identifiant d'instance.

Vous pouvez simplement faire une requête HTTP pour obtenir des métadonnées en transmettant vos paramètres de métadonnées. 

curl http://169.254.169.254/latest/meta-data/instance-id

ou 

wget -q -O - http://169.254.169.254/latest/meta-data/instance-id

Les requêtes HTTP pour obtenir les métadonnées et les données utilisateur ne seront pas facturées.

Sinon

Vous pouvez utiliser l'outil de requête de métadonnées d'instance EC2, un simple script bash utilisant curl pour interroger l'instance EC2 à partir d'une instance EC2 en cours d'exécution, comme indiqué dans la documentation.

Téléchargez l'outil: 

$ wget http://s3.amazonaws.com/ec2metadata/ec2-metadata

exécutez maintenant la commande pour obtenir les données requises. 

$ec2metadata -i

Référez-vous:

http: //docs.aws.amazon .com / AWSEC2 / latest / UserGuide / ec2-instance-metadata.html

https://aws.amazon.com/items/1825?externalID=1825

Heureux de vous aider ..:)

Dans la question que vous avez mentionnée en tant qu'utilisateur root, il convient de mentionner que l'ID d'instance ne dépend pas de l'utilisateur.

Pour les nœuds , 

var meta  = new AWS.MetadataService();

meta.request("/latest/meta-data/instance-id", function(err, data){
    console.log(data);
});

Approche alternative pour PHP: 

$instance = json_decode(file_get_contents('http://169.254.169.254/latest/dynamic/instance-identity/document'),true);
$id = $instance['instanceId'];
print_r($instance);

Cela fournira beaucoup de données sur l'instance, le tout bien emballé dans un tableau, pas de dépendances externes. Comme c'est une demande qui n'a jamais échoué ou qui a été retardée pour moi, il devrait être sûr de le faire de cette façon, sinon je choisirais curl ()

Pour PHP: 

$instance = json_decode(file_get_contents('http://169.254.169.254/latest/dynamic/instance-identity/document));
$id = $instance['instanceId'];

Modifier par @John

Exécutez ceci: 

curl http://169.254.169.254/latest/meta-data/

Vous pourrez voir différents types d'attributs fournis par aws.

Utilisez ce lien pour en voir plus

Toutes les métadonnées relatives à la ressource EC2 sont accessibles par l'instance EC2 elle-même à l'aide de la commande suivante en cours d'exécution:

CURL: 

http://169.254.169.254/<api-version>/meta-data/<metadata-requested>

Dans votre cas, " les métadonnées demandées " doit être instance-id , " api-version ". est généralement le dernier utilisable.

Remarque supplémentaire: vous pouvez également obtenir des informations sur les attributs EC2 ci-dessous à l’aide de la commande ci-dessus.

ami-id, ami-launch-index, ami-manifest-path, mappage de périphériques en bloc /, nom d'hôte, je suis/, instance-action, instance-id, type d'instance, nom d'hôte local, local-ipv4, Mac, métrique/, réseau/, placement/, profil, public-hostname, public-ipv4, clés publiques /, réservation-id, groupes de sécurité, services /,

Pour plus de détails, suivez ce lien: https : //docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html

Pour obtenir les métadonnées d'instance, utilisez 

wget -q -O - http://169.254.169.254/latest/meta-data/instance-id

Pour une instance Windows: 

(wget http://169.254.169.254/latest/meta-data/instance-id).Content

ou 

(ConvertFrom-Json (wget http://169.254.169.254/latest/dynamic/instance-identity/document).Content).instanceId

Pour AWS elastic beanstalk, eb cli run balises eb --list

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top