Wie erhalte ich die Instanz-ID aus einer ec2-Instanz?

Wie kann ich die instance ideiner ec2-Instanz innerhalb der ec2-Instanz herausfinden?

Siehe die EC2-Dokumentation zu diesem Thema .

Lauf:

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

Wenn Sie innerhalb eines Skripts programmgesteuerten Zugriff auf die Instanz-ID benötigen,

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: $?\"`"

Ein Beispiel für eine erweiterte Verwendung (Abrufen der Instanz-ID sowie der Verfügbarkeitszone und -region usw.):

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:'`"

Sie können auch curlanstelle von verwenden wget, je nachdem, was auf Ihrer Plattform installiert ist.

Auf Amazon Linux AMIs können Sie Folgendes tun:

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

Oder unter Ubuntu und einigen anderen Linux-Varianten ec2metadata --instance-id(Dieser Befehl ist unter Ubuntu möglicherweise nicht standardmäßig installiert, aber Sie können ihn mit hinzufügen sudo apt-get install cloud-utils).

Wie der Name schon sagt, können Sie mit dem Befehl auch andere nützliche Metadaten abrufen.

Unter Ubuntu können Sie:

sudo apt-get install cloud-utils

Und dann können Sie:

EC2_INSTANCE_ID=$(ec2metadata --instance-id)

Sie können die meisten mit der Instanz verknüpften Metadaten folgendermaßen abrufen:

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

Abfragen und Anzeigen von EC2-Metadaten.

Wenn keine Optionen angegeben sind, werden alle Optionen angezeigt

Optionen:
    -h --help zeigt diese Hilfe

    --kernel-id zeigt die Kernel-ID an
    --ramdisk-id zeigt die Ramdisk-ID an
    --reservation-id zeigt die Reservierungs-ID an

    --ami-id zeigt die ami id an
    --ami-launch-index zeigt den ami-Startindex an
    --ami-manifest-path zeigt den ami-manifest-Pfad an
    --ancestor-ami-ids zeigen die ami-Vorfahren-ID an
    --Produktcodes zeigen die ami zugeordneten Produktcodes an
    --Verfügbarkeitszone Zeigt die Ami-Platzierungszone an

    --instance-id zeigt die Instanz-ID an
    --instance-type zeigt den Instanztyp an

    --local-hostname zeigt den lokalen Hostnamen an
    --public-hostname zeigt den öffentlichen Hostnamen an

    --local-ipv4 zeigt die lokale IPv4-IP-Adresse an
    --public-ipv4 zeigt die öffentliche IPv4-IP-Adresse an

    --block-device-Mapping zeigt die Block-Geräte-ID an
    --Sicherheitsgruppen zeigen die Sicherheitsgruppen an

    --mac zeigt die Mac-Adresse der Instanz an
    --profile zeigt das Instanzprofil an
    --instance-action zeigt die Instanzaktion an

    --public-keys zeigen die öffentlichen openssh-Schlüssel an
    --user-data zeigt die Benutzerdaten an (keine Metadaten)

Verwenden Sie die /dynamic/instance-identity/documentURL, wenn Sie auch mehr als nur Ihre Instanz-ID abfragen müssen.

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

Auf diese Weise erhalten Sie JSON- Daten wie diese - mit nur einer einzigen Anfrage .

{
    "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"
}

Für .NETMenschen:

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

unter AWS Linux:

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

Ausgabe:

i-33400429

Verwenden in Variablen:

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

Für Powershell-Leute:

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

Für Python:

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

was auf den Einzeiler hinausläuft:

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

Anstelle von local_hostname können Sie auch public_hostname verwenden oder:

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

Für alle ec2-Maschinen befindet sich die Instanz-ID in der Datei:

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

Sie können die Instanz-ID auch abrufen, indem Sie den folgenden Befehl ausführen:

    ec2metadata --instance-id

Siehe diesen Beitrag - beachten Sie, dass die IP-Adresse in der angegebenen URL konstant ist (was mich zunächst verwirrte), die zurückgegebenen Daten jedoch spezifisch für Ihre Instanz sind.

Für 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]

Eine zeitgemäßere Lösung.

Unter Amazon Linux ist der Befehl ec2-metadata bereits installiert.

Vom Terminal

ec2-metadata -help

Gibt Ihnen die verfügbaren Optionen

ec2-metadata -i

wird zurückkehren

instance-id: yourid

Tippe einfach:

ec2metadata --instance-id

Sie können dies versuchen:

#!/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]\)"`

Eine c # .net-Klasse, die ich für EC2-Metadaten aus der http-API geschrieben habe. Ich werde es mit Funktionalität nach Bedarf aufbauen. Sie können damit laufen, wenn Sie es mögen.

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
*************************************************************/
    }
}

Das neueste Java SDK hat EC2MetadataUtils :

In Java:

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

In Scala:

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

Für C ++ (mit 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

Überprüfen Sie einfach den var/lib/cloud/instanceSymlink, er sollte zeigen, /var/lib/cloud/instances/{instance-id}wo {instance_id}sich Ihre Instanz-ID befindet.

Wenn Sie die ID-Liste aller Instanzen in Python erhalten möchten, finden Sie hier den 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 Ich habe ein FUSE-Dateisystem geschrieben, um den Zugriff auf den EC2-Metadatendienst zu ermöglichen: https://bitbucket.org/dgc/ec2mdfs . Ich führe dies auf allen benutzerdefinierten AMIs aus. es erlaubt mir, diese Redewendung zu verwenden: cat / ec2 / meta-data / ami-id

In Go können Sie das Goamz-Paket verwenden .

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
}

Hier ist die GetMetaData-Quelle.

In der Frage, die Sie den Benutzer als root erwähnt haben, sollte ich erwähnen, dass die Instanz-ID nicht vom Benutzer abhängig ist.

Für Node- Entwickler

var meta  = new AWS.MetadataService();

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

Verwenden Sie zum Abrufen der Instanzmetadaten

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

Sie können einfach eine HTTP-Anforderung zum Abrufen von Metadaten stellen, indem Sie Ihre Metadatenparameter übergeben.

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

oder

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

HTTP-Anforderungen zum Abrufen von Metadaten und Benutzerdaten werden Ihnen nicht in Rechnung gestellt.

Sonst

Sie können das Abfrage-Tool für EC2-Instanz-Metadaten verwenden, ein einfaches Bash-Skript, das mithilfe von Curl die Metadaten der EC2-Instanz aus einer laufenden EC2-Instanz abfragt, wie in der Dokumentation beschrieben.

Laden Sie das Tool herunter:

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

Führen Sie nun den Befehl aus, um die erforderlichen Daten abzurufen.

$ec2metadata -i

Verweisen:

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

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

Freue mich zu helfen.. :)

Alternativer Ansatz für PHP:

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

Dadurch werden viele Daten über die Instanz bereitgestellt, die alle gut in ein Array gepackt sind und keine externen Abhängigkeiten aufweisen. Da es sich um eine Anfrage handelt, die für mich nie fehlgeschlagen oder verzögert wurde, sollte es sicher sein, dies so zu tun, sonst würde ich mich für curl () entscheiden.

Für PHP:

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

Bearbeiten per @John

Führen Sie Folgendes aus:

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

Sie können verschiedene Arten von Attributen sehen, die von aws bereitgestellt werden.

Verwenden Sie diesen Link, um weitere Informationen anzuzeigen

Auf alle Metadaten, die sich auf die EC2-Ressource beziehen, kann die EC2-Instanz selbst mit Hilfe des folgenden ausgeführten Befehls zugreifen:

CURL:

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

Für Ihren Fall: " Metadaten angefordert " sollte Instanz-ID sein , " API-Version " ist normalerweise die neueste , die verwendet werden kann.

Zusätzlicher Hinweis: Mit dem obigen Befehl können Sie auch Informationen zu den folgenden EC2-Attributen abrufen.

Ami-ID, Ami-Start-Index, Ami-Manifest-Pfad, Block-Geräte-Mapping /, Hostname, iam /, Instanz-Aktion, Instanz-ID, Instanz-Typ, lokaler Hostname, lokaler IPv4, Mac, Metriken /, Netzwerk /, Platzierung /, Profil, öffentlicher Hostname, öffentliches IPv4, öffentliche Schlüssel /, Reservierungs-ID, Sicherheitsgruppen, Dienste /,

Weitere Informationen finden Sie unter folgendem Link: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html

Für eine Windows-Instanz:

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

oder

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

Für AWS elastische Bohnenstange eb cli run eb tags --list