Version AWS SDK for Java 1.x wurde am 31. Juli 2024 in den Wartungsmodus versetzt und wird end-of-supportam 31. Dezember 2025 verfügbar sein. Wir empfehlen Ihnen, auf den zu migrieren AWS SDK for Java 2.x, um weiterhin neue Funktionen, Verfügbarkeitsverbesserungen und Sicherheitsupdates zu erhalten.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Tutorial: Amazon EC2 Spot-Instances

Übersicht

Mit Spot-Instances können Sie auf ungenutzte Amazon Elastic Compute Cloud (Amazon EC2)-Kapazität auf bis zu 90 % im Vergleich zum On-Demand-Instance-Preis bieten und alle erworbenen Instances so lange ausführen, wie Ihr Gebot den aktuellen Spot-Preis übersteigt. Amazon EC2 ändert den Spot-Preis regelmäßig abhängig von Angebot und Nachfrage. Kunden, deren Gebote den Spot-Preis erreichen oder übersteigen, erhalten Zugriff auf die verfügbaren Spot-Instances. Wie mit On-Demand-Instances und Reserved Instances erhalten Sie mit Spot-Instances eine weitere Möglichkeit, mehr Rechenkapazität zu erhalten.

Spot-Instances können die Amazon EC2-Kosten für Stapelverarbeitung, wissenschaftliche Forschung, Bildverarbeitung, Videocodierung, Daten- und Web-Crawling, Finanzanalysen und Tests spürbar senken. Darüber hinaus ermöglichen Spot-Instances Zugriff auf große Mengen an zusätzlicher Kapazität in Situationen, in denen diese Kapazität nicht dringend benötigt wird.

Senden Sie zur Nutzung von Spot-Instances eine Spot-Instance-Anforderung und geben Sie den Höchstpreis an, den Sie pro Instance-Stunde zu zahlen bereit sind; dies ist Ihr Gebot. Wenn Ihr Höchstgebot den aktuellen Spot-Preis übersteigt, wird Ihrer Anforderung stattgegeben. Ihre Instances werden so lange ausgeführt, bis Sie sie entweder beenden oder bis der Spot-Preis Ihr Höchstgebot übersteigt.

Wichtiger Hinweis:

Bei der Ausführung liefern Spot-Instances genau dieselbe Leistung wie andere Amazon EC2-Instances. Sie lassen sich auch genau so beenden wie andere Amazon EC2-Instances, wenn Sie sie nicht mehr benötigen. Beim Beenden einer Instance zahlen Sie für die angefangene Stunde (wie bei On-Demand- und Reserved Instances). Steigt der Spot-Preis allerdings über Ihr Gebot und Ihre Instance wird von Amazon EC2 beendet, wird Ihnen keine angefangene Nutzungsstunde in Rechnung gestellt.

In dieser Anleitung erfahren Sie, wie Sie mit AWS SDK for Java die folgenden Aufgaben ausführen:

Voraussetzungen

Um diese Anleitung nutzen zu können, sollten Sie das AWS SDK for Java installiert haben und die grundlegenden Installationsvoraussetzungen erfüllen. Siehe .Einrichten derAWS SDK for JavaWeitere Informationen finden Sie unter.

Schritt 1: Einrichten Ihrer Anmeldeinformationen

Um dieses Codebeispiel verwenden zu können, müssen Sie eine EinrichtungAWS-Anmeldeinformationen. Siehe .EinrichtenAWSAnmeldeinformationen und Region für die EntwicklungEine entsprechende Anleitung finden Sie unter.

Nachdem Sie Ihre Einstellungen eingerichtet haben, können Sie mit dem Beispiel-Code loslegen.

Schritt 2: Einrichten einer Sicherheitsgruppe

Eine Sicherheitsgruppe agiert als Firewall, die den zulässigen Verkehr zu und von einer Gruppe Instances steuert. Standardmäßig wird eine Instance ohne eine Sicherheitsgruppe gestartet. Sämtlicher eingehender IP-Datenverkehr auf allen TCP-Ports wird daher verweigert. Vor dem Absenden unserer Spot-Anforderung richten wir also eine Sicherheitsgruppe ein, die den nötigen Netzwerkverkehr zulässt. Für die Zwecke dieser Anleitung erstellen wir eine neue Sicherheitsgruppe mit dem Namen "GettingStarted", mit der Secure Shell (SSH)-Datenverkehr von der IP-Adresse, von der Sie die Anwendung ausführen, zugelassen wird. Zur Einrichtung einer neuen Sicherheitsgruppe sollten Sie das folgende Codebeispiel einschließen oder ausführen. Dadurch wird die Sicherheitsgruppe per Programm eingerichtet.

Nach dem Erstellen eines AmazonEC2-Client-Objekts legen wir ein CreateSecurityGroupRequest-Objekt mit dem Namen "GettingStarted" und eine Beschreibung für die Sicherheitsgruppe an. Anschließend wird die ec2.createSecurityGroup-API zum Erstellen der Gruppe aufgerufen.

Zum Aktivieren des Zugriffs auf die Gruppe erstellen wir ein ipPermission-Objekt, bei dem der IP-Adressbereich des Subnetzes auf die CIDR-Darstellung des Subnetzes des lokalen Computers festgelegt ist. Das Suffix "/10" bei der IP-Adresse zeigt das Subnetz für die angegebene IP-Adresse an. Anschließend konfigurieren wir auch das ipPermission-Objekt mit dem TCP-Protokoll und dem Port 22 (SSH). Im letzten Schritt wird ec2.authorizeSecurityGroupIngress mit dem Namen der Sicherheitsgruppe und dem ipPermission-Objekt aufgerufen.

// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();

// Create a new security group.
try {
    CreateSecurityGroupRequest securityGroupRequest = new CreateSecurityGroupRequest("GettingStartedGroup", "Getting Started Security Group");
    ec2.createSecurityGroup(securityGroupRequest);
} catch (AmazonServiceException ase) {
    // Likely this means that the group is already created, so ignore.
    System.out.println(ase.getMessage());
}

String ipAddr = "0.0.0.0/0";

// Get the IP of the current host, so that we can limit the Security
// Group by default to the ip range associated with your subnet.
try {
    InetAddress addr = InetAddress.getLocalHost();

    // Get IP Address
    ipAddr = addr.getHostAddress()+"/10";
} catch (UnknownHostException e) {
}

// Create a range that you would like to populate.
ArrayList<String> ipRanges = new ArrayList<String>();
ipRanges.add(ipAddr);

// Open up port 22 for TCP traffic to the associated IP
// from above (e.g. ssh traffic).
ArrayList<IpPermission> ipPermissions = new ArrayList<IpPermission> ();
IpPermission ipPermission = new IpPermission();
ipPermission.setIpProtocol("tcp");
ipPermission.setFromPort(new Integer(22));
ipPermission.setToPort(new Integer(22));
ipPermission.setIpRanges(ipRanges);
ipPermissions.add(ipPermission);

try {
    // Authorize the ports to the used.
    AuthorizeSecurityGroupIngressRequest ingressRequest =
        new AuthorizeSecurityGroupIngressRequest("GettingStartedGroup",ipPermissions);
    ec2.authorizeSecurityGroupIngress(ingressRequest);
} catch (AmazonServiceException ase) {
    // Ignore because this likely means the zone has
    // already been authorized.
    System.out.println(ase.getMessage());
}

Hinweis: Sie müssen diese Anwendung nur einmal ausführen, um eine neue Sicherheitsgruppe zu erstellen.

Sie können die Sicherheitsgruppe auch mithilfe von AWS Toolkit for Eclipse erstellen. Siehe .Verwalten von SicherheitsgruppenAWS Cost ExplorerWeitere Informationen finden Sie unter.

Schritt 3: Senden Ihrer Spot-Anforderung

Zum Senden einer Spot-Anforderung sollten Sie zuerst den Instance-Typ, das Amazon Machine Image (AMI) und den Höchstpreis für Ihr Gebot festlegen. Sie müssen auch die zuvor konfigurierte Sicherheitsgruppe aufnehmen, damit Sie sich bei Bedarf bei der Instance anmelden können.

Sie können zwischen verschiedenen Instance-Typen wählen.Amazon EC2Instance-Typen für eine vollständige Liste. Für diese Anleitung verwenden wir t1.micro, den günstigsten verfügbaren Instance-Typ. Als Nächstes bestimmen wir, welches AMI wir nutzen möchten. Hier verwenden wir ami-a9d09ed1, das aktuelle Amazon Linux-AMI, das zum Erstellungszeitpunkt dieser Anleitung verfügbar war. Von Zeit zu Zeit kann es neuere AMIs geben. Die jeweils neueste AMI-Version lässt sich mit folgenden Schritten ermitteln:

Es gibt viele Wege zur Gebotsgestaltung für Spot-Instances. Eine gute Übersicht der unterschiedlichen Ansätze finden Sie im Video Bieten für Spot-Instances. Allerdings beschreiben wir drei allgemeine Strategien für den Einstieg: Gebote, um sicherzustellen, dass die Kosten geringer sind als bei On-Demand-Preisen; Gebote basierend auf dem Wert der resultierenden Berechnung; Gebote, um Rechenkapazität so schnell wie möglich zu erwerben.

Nachdem Sie den Gebotspreis ausgewählt haben, können Sie eine Spot-Instance anfordern. Für diese Anleitung bieten wir den On-Demand-Preis (0,03 USD) und maximieren so die Chancen, dass das Gebot erfüllt wird. Sie können die Typen verfügbarer Instances sowie die On-Demand-Preise für Instances ermitteln, indem Sie einenAmazon EC2Seite „Preisgestaltung“. Für die Dauer der Ausführung der Instances zahlen Sie bei Spot-Instances den bei der Anforderung angegebenen Stundensatz. Die Spot-Instance-Preise werden von Amazon EC2 festgelegt und ändern sich schrittweise entsprechend der langfristigen Trends bei Angebot und Nachfrage zu Spot-Instance-Kapazitäten. Sie können auch den Betrag, den Sie für eine Spot-Instance zu zahlen bereit sind, als % des On-Demand-Instance-Preises angeben. Um eine Spot-Instance anzufordern, müssen Sie Ihre Anfrage einfach mit den zuvor ausgewählten Parametern erstellen. Als Erstes erstellen wir ein RequestSpotInstanceRequest-Objekt. Für das Anforderungsobjekt sind die Anzahl der zu startenden Instances sowie der Gebotspreis nötig. Außerdem müssen Sie die LaunchSpecification für die Anforderung festlegen. Sie umfasst den Instance-Typ, die AMI-ID sowie die Sicherheitsgruppe, die Sie verwenden möchten. Sobald die Anforderung vorbereitet ist, rufen Sie die Methode requestSpotInstances des Objekts AmazonEC2Client auf. Das folgende Beispiel zeigt, wie Sie eine Spot-Instance anfordern.

// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();

// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();

// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));

// Setup the specifications of the launch. This includes the
// instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);

// Add the security group to the request.
ArrayList<String> securityGroups = new ArrayList<String>();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);

// Add the launch specifications to the request.
requestRequest.setLaunchSpecification(launchSpecification);

// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);

Beim Ausführen dieses Codes wird eine neue Spot-Instance-Anforderung ausgeführt. Mit weiteren Optionen können Sie Spot-Anforderungen konfigurieren. Um mehr zu erfahren, besuchen Sie bitteTutorial: AdvancedAmazon EC2Verwaltung der Spot-Anforderungenoder dasRequestSpotInstances-Klasse imAWS SDK for Java-API-Referenz.

Schritt 4: Ermitteln des Status Ihrer Spot-Anforderung

Als Nächstes erstellen wir einen Code, der darauf wartet, dass die Spot-Anforderung den Status "active" erreicht, bevor wir zum letzten Schritt wechseln. Zur Ermittlung des Status unserer Spot-Anforderung rufen wir die Methode describeSpotInstanceRequests ab und lesen den Status der Spot-Anforderungs-ID aus, die wir überwachen möchten.

Die in Schritt 2 erstellte Anforderungs-ID ist in der Antwort auf unsere requestSpotInstances-Anforderung enthalten. Im folgenden Beispielcode wird gezeigt, wie sich Anforderungs-IDs aus der requestSpotInstances-Antwort auslesen und zur Vorbereitung einer ArrayList nutzen lassen.

// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
List<SpotInstanceRequest> requestResponses = requestResult.getSpotInstanceRequests();

// Setup an arraylist to collect all of the request ids we want to
// watch hit the running state.
ArrayList<String> spotInstanceRequestIds = new ArrayList<String>();

// Add all of the request ids to the hashset, so we can determine when they hit the
// active state.
for (SpotInstanceRequest requestResponse : requestResponses) {
    System.out.println("Created Spot Request: "+requestResponse.getSpotInstanceRequestId());
    spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());
}

Rufen Sie zur Überwachung Ihrer Anforderungs-ID die Methode describeSpotInstanceRequests auf und ermitteln Sie so den Status der Anforderung. Warten Sie dann in einer Schleife, bis die Anforderung nicht mehr den Zustand "open" aufweist. Hinweis: Wir überprüfen hier, ob der Zustand ungleich "open" ist, anstatt etwa auf "active" zu überprüfen. Der Grund ist, dass die Anforderung direkt zu "closed" übergehen kann, wenn ein Problem mit den Argumenten der Anforderung vorliegt. Im folgenden Codebeispiel sehen Sie im Detail, wie diese Aufgabe umgesetzt wird.

// Create a variable that will track whether there are any
// requests still in the open state.
boolean anyOpen;

do {
    // Create the describeRequest object with all of the request ids
    // to monitor (e.g. that we started).
    DescribeSpotInstanceRequestsRequest describeRequest = new DescribeSpotInstanceRequestsRequest();
    describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);

    // Initialize the anyOpen variable to false - which assumes there
    // are no requests open unless we find one that is still open.
    anyOpen=false;

    try {
        // Retrieve all of the requests we want to monitor.
        DescribeSpotInstanceRequestsResult describeResult = ec2.describeSpotInstanceRequests(describeRequest);
        List<SpotInstanceRequest> describeResponses = describeResult.getSpotInstanceRequests();

        // Look through each request and determine if they are all in
        // the active state.
        for (SpotInstanceRequest describeResponse : describeResponses) {
            // If the state is open, it hasn't changed since we attempted
            // to request it. There is the potential for it to transition
            // almost immediately to closed or cancelled so we compare
            // against open instead of active.
        if (describeResponse.getState().equals("open")) {
            anyOpen = true;
            break;
        }
    }
} catch (AmazonServiceException e) {
      // If we have an exception, ensure we don't break out of
      // the loop. This prevents the scenario where there was
      // blip on the wire.
      anyOpen = true;
    }

    try {
        // Sleep for 60 seconds.
        Thread.sleep(60*1000);
    } catch (Exception e) {
        // Do nothing because it woke up early.
    }
} while (anyOpen);

Nachdem dieser Code ausgeführt wird, ist Ihre Spot-Instance-Anforderung entweder abgeschlossen oder mit einem Fehler gescheitert, der auf dem Bildschirm angezeigt wird. In beiden Fällen können wir mit dem nächsten Schritt fortfahren, alle aktiven Anforderungen bereinigen und alle laufenden Instances beenden.

Schritt 5: Bereinigen der Spot-Anforderungen und ‑Instances

Schließlich müssen wir unsere Anforderungen und Instances bereinigen. Es ist wichtig, sowohl ausstehende Anforderungen zu stornieren als auch etwaige Instances zu beenden. Wenn Sie nur die Anforderungen stornieren, werden Ihre Instances nicht beendet und Sie müssen weiter für sie zahlen. Wenn Sie die Instances beenden, können Ihre Spot-Anforderungen storniert werden. In einigen Fällen – etwa dann, wenn Sie persistente Gebote nutzen –, reicht das Beenden Ihrer Instances nicht aus, damit Ihre Anforderung nicht erneut erfüllt wird. Daher ist es eine bewährte Methode, sowohl die aktiven Gebote zu stornieren als auch alle laufenden Instances zu beenden.

Im folgenden Beispiel wird gezeigt, wie Sie Ihre Anforderungen stornieren.

try {
    // Cancel requests.
    CancelSpotInstanceRequestsRequest cancelRequest =
       new CancelSpotInstanceRequestsRequest(spotInstanceRequestIds);
    ec2.cancelSpotInstanceRequests(cancelRequest);
} catch (AmazonServiceException e) {
    // Write out any exceptions that may have occurred.
    System.out.println("Error cancelling instances");
    System.out.println("Caught Exception: " + e.getMessage());
    System.out.println("Reponse Status Code: " + e.getStatusCode());
    System.out.println("Error Code: " + e.getErrorCode());
    System.out.println("Request ID: " + e.getRequestId());
}

Zum Stornieren ausstehender Anforderungen brauchen Sie die jeweilige Instance-ID. Sie ist mit der Anforderung verknüpft, die sie gestartet hat. Im folgenden Codebeispiel ergänzen wir unseren Originalcode zur Überwachung der Instances um eine ArrayList. Darin speichern wir die Instance-ID aus der describeInstance-Antwort.

// Create a variable that will track whether there are any requests
// still in the open state.
boolean anyOpen;
// Initialize variables.
ArrayList<String> instanceIds = new ArrayList<String>();

do {
   // Create the describeRequest with all of the request ids to
   // monitor (e.g. that we started).
   DescribeSpotInstanceRequestsRequest describeRequest = new DescribeSpotInstanceRequestsRequest();
   describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);

   // Initialize the anyOpen variable to false, which assumes there
   // are no requests open unless we find one that is still open.
   anyOpen = false;

   try {
         // Retrieve all of the requests we want to monitor.
         DescribeSpotInstanceRequestsResult describeResult =
            ec2.describeSpotInstanceRequests(describeRequest);

         List<SpotInstanceRequest> describeResponses =
            describeResult.getSpotInstanceRequests();

         // Look through each request and determine if they are all
         // in the active state.
         for (SpotInstanceRequest describeResponse : describeResponses) {
           // If the state is open, it hasn't changed since we
           // attempted to request it. There is the potential for
           // it to transition almost immediately to closed or
           // cancelled so we compare against open instead of active.
           if (describeResponse.getState().equals("open")) {
              anyOpen = true; break;
           }
           // Add the instance id to the list we will
           // eventually terminate.
           instanceIds.add(describeResponse.getInstanceId());
         }
   } catch (AmazonServiceException e) {
      // If we have an exception, ensure we don't break out
      // of the loop. This prevents the scenario where there
      // was blip on the wire.
      anyOpen = true;
   }

    try {
        // Sleep for 60 seconds.
        Thread.sleep(60*1000);
    } catch (Exception e) {
        // Do nothing because it woke up early.
    }
} while (anyOpen);

Mithilfe der in der ArrayList gespeicherten Instance-IDs können Sie laufende Instances mit dem folgenden Codeausschnitt beenden:

try {
    // Terminate instances.
    TerminateInstancesRequest terminateRequest = new TerminateInstancesRequest(instanceIds);
    ec2.terminateInstances(terminateRequest);
} catch (AmazonServiceException e) {
    // Write out any exceptions that may have occurred.
    System.out.println("Error terminating instances");
    System.out.println("Caught Exception: " + e.getMessage());
    System.out.println("Reponse Status Code: " + e.getStatusCode());
    System.out.println("Error Code: " + e.getErrorCode());
    System.out.println("Request ID: " + e.getRequestId());
}

Zusammenfassung

Abschließend erstellen wir eine verbesserte objektorientierte Version. Sie kombiniert die zuvor gezeigten Schritte: Initialisierung des EC2-Clients; Senden der Spot-Anforderung; Ermittlung, wann die Spot-Anforderungen nicht mehr den Zustand "offen" aufweisen; sowie schließlich die Bereinigung ausstehender Spot-Anforderungen und zugehöriger Instances. Wir erstellen eine Klasse namens Requests, die diese Aktionen ausführt.

Zudem legen wir eine Klasse GettingStartedApp mit einer main-Methode an, in der wir die High-Level-Funktionsaufrufe durchführen. Insbesondere initialisieren wir das zuvor beschriebene Requests-Objekt. Wir senden die Spot-Instance-Anforderung. Anschließend warten wir, bis die Spot-Anforderung den Zustand "active" erreicht. Schließlich bereinigen wir die Anforderungen und Instances.

Den vollständigen Quelltext dieses Beispiels finden Sie zum Lesen und Herunterladen auf GitHub.

Herzlichen Glückwunsch! Sie haben jetzt die Erste-Schritte-Anleitung zur Entwicklung von Spot-Instance-Software mit dem AWS SDK for Java abgeschlossen.

Nächste Schritte

Fahren Sie mit fortTutorial: AdvancedAmazon EC2Verwaltung der Spot-Anforderungenaus.