aws toolkit for eclipse - benutzerhandbuch...• eclipse ide for java developers 4.2 oder höher:...

AWS Toolkit for EclipseBenutzerhandbuch

AWS Toolkit for Eclipse: BenutzerhandbuchCopyright © 2021 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

AWS Toolkit for Eclipse Benutzerhandbuch

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.


Table of ContentsWas ist AWS Toolkit for Eclipse? ......................................................................................................... 1

Zusätzliche Dokumentation und Ressourcen ................................................................................... 1Erste Schritte ..................................................................................................................................... 3

Einrichten des Toolkits ............................................................................................................... 3Prerequisites ...................................................................................................................... 3Installieren der AWS Toolkit for Eclipse .................................................................................. 3Upgraden des AWS Toolkit for Eclipse .................................................................................. 4

Einrichten von AWS-Anmeldeinformationen ................................................................................... 4Abrufen Ihrer AWS-Zugriffsschlüssel ...................................................................................... 4Hinzufügen Ihres AWS-Zugriffsschlüssels zum AWS Toolkit for Eclipse ....................................... 5Verwenden mehrerer AWS-Konten mit dem AWS Toolkit for Eclipse ........................................... 6Ändern des Speicherorts der Datei mit den AWS-Anmeldeinformationen ...................................... 7

Private Schlüssel mit Ihrem verknüpfen Amazon EC2 Key Pairs ....................................................... 8AWS Toolkit for Eclipse-Grundlagen ................................................................................................... 10

Erstellen einer AWS Java-Anwendung ........................................................................................ 10Erstellen und Ausführen des Amazon Simple Queue Service-Beispiels ...................................... 10

Serverlose Projekte ................................................................................................................... 12Erstellen eines serverlosen Projekts ..................................................................................... 12Pläne für serverlose Projekte .............................................................................................. 14Struktur serverloser Projekte ............................................................................................... 15Bereitstellen eines serverlosen Projekts ................................................................................ 15Weitere Informationen finden Sie auch unter: ........................................................................ 16

Differenzierung von AWS-Ressourcen mittels Benennung .............................................................. 17Arbeiten mit AWS-Services ............................................................................................................... 21

Zugreifen auf AWS Explorer ...................................................................................................... 21Verwenden von Lambda mit AWS Toolkit for Eclipse ..................................................................... 23

Praktische Anleitung So erstellen, laden und rufen Sie ein AWS Lambda Funktion ...................... 24AWS Lambda-Benutzeroberflächenreferenz ......................................................................... 33

Die AWS CloudFormation Schablonen-Editor ............................................................................... 40Hinzufügen und Zugreifen AWS CloudFormation Templates in Eclipse ..................................... 41Bereitstellung eines AWS CloudFormation Vorlage bei Eclipse ................................................ 43Aktualisieren AWS CloudFormation Vorlage bei Eclipse ......................................................... 46Validierung AWS CloudFormation Vorlage bei Eclipse ........................................................... 48

Verwendung DynamoDB mit AWS Explorer ................................................................................. 49Erstellen einer DynamoDB-Tabelle ...................................................................................... 50Anzeigen einer DynamoDB-Tabelle als Raster ...................................................................... 51Bearbeiten von Attributen und Werten .................................................................................. 52Scannen einer DynamoDB-Tabelle ...................................................................................... 53

Starten Sie eine Amazon EC2 Instanz von einem Amazon Machine Image ........................................ 54Verwalten von Sicherheitsgruppen im AWS Explorer ..................................................................... 58

Erstellen einer neuen Sicherheitsgruppe ............................................................................... 58Hinzufügen von Berechtigungen zu einer Sicherheitsgruppe .................................................... 59

Anzeigen und Hinzufügen Amazon SNS Benachrichtigungen .......................................................... 61Anzeigen einer Amazon SNS-Benachrichtigung ..................................................................... 61Hinzufügen einer Amazon SNS-Benachrichtigung .................................................................. 62

Verbinden mit Amazon Relational Database Service ( ( (Amazon RDS) ............................................ 63Identitäts- und Zugriffsverwaltung ............................................................................................... 65

Informationen zu AWS Identity and Access Management ........................................................ 65Erstellen eines &IAM;-Benutzers ......................................................................................... 66Erstellen einer IAM-Gruppe ................................................................................................ 67Hinzufügen eines IAM-Benutzers zu einer IAM-Gruppe ........................................................... 69Verwalten von Anmeldeinformationen für einen IAM-Benutzer .................................................. 70Erstellen einer IAM-Rolle .................................................................................................... 73Anfügen einer IAM-Richtlinie an Benutzer, Gruppen oder Rollen ............................................... 77

iii


Festlegen von Passwortrichtlinien ........................................................................................ 80Debuggen von serverlosen Anwendungen mit AWS SAM Local ...................................................... 81

Prerequisites ...................................................................................................................... 3Importieren der SAM-Anwendung von AWS CodeStar ............................................................ 82Lokales Debuggen der Lambda-Funktion .............................................................................. 83API Gateway lokal testen ................................................................................................... 87Erweiterte Einstellungen ..................................................................................................... 89Weitere Infos .................................................................................................................... 33

Fehlerbehebung ................................................................................................................................ 92AWS CodeCommit-Plugin — Eclipse konnte nicht in den sicheren Speicher schreiben. ......................... 92

Dokumentverlauf ............................................................................................................................... 93.................................................................................................................................................... xciv

iv

AWS Toolkit for Eclipse BenutzerhandbuchZusätzliche Dokumentation und Ressourcen

Was ist AWS Toolkit for Eclipse?Das AWS Toolkit for Eclipse ist ein Open-Source-Plug-in für die Eclipse-IDE (Integrated DevelopmentEnvironment, integrierte Entwicklungsumgebung), das es Entwicklern vereinfacht, Java-Anwendungen mitAmazon Web Services zu entwickeln, zu debuggen und bereitzustellen. Es erweitert die Eclipse-IDE umzusätzliche Funktionen:

• AWS SDK for Java ist in Maven enthalten und wird davon verwaltet, wenn Sie mit AWS Toolkit forEclipse ein neues AWS-Projekt erstellen.

• Der AWS Explorer ist eine Schnittstelle zu Amazon Web Services, mit der Sie Ihre AWS-Ressourceninnerhalb der Eclipse-Umgebung verwalten können.

• Blueprint-Erstellung des AWS Lambda Java-Projekts und des Serverless Application Model (SAM)-Projekts, Bereitstellung und Debugging

• Klonen des AWS CodeCommit-Repositorys• Integration in AWS CodeStar• AWS Elastic Beanstalk dient Bereitstellung und Debugging.• Ein AWS CloudFormation-Vorlageneditor• Unterstützung für mehrere AWS-Konten

Important

Es fallen keine Gebühren für die Nutzung des AWS Toolkit for Eclipse an. Für die Erstellung oderVerwendung von kostenpflichtigen AWS-Ressourcen, z. B. Ausführen von Amazon EC2-Instances oder Verwenden von Amazon S3-Speicher, können jedoch AWS-Gebühren fälligwerden. Mit dem AWS-Preisrechner können Sie die Kosten für die Verwendung verschiedenerAWSRessourcen

Zusätzliche Dokumentation und RessourcenZusätzlich zu diesem Handbuch gibt es eine Reihe von anderen Ressourcen für AWS Toolkit for Eclipse-Benutzer:

• AWS SDK for Java-Entwicklerhandbuch• AWS SDK for Java API Reference• Java-Entwicklerblog• Java-Entwicklerforen• GitHub

• Dokumentationsquelle• Dokumentationsprobleme• Toolkit-Quelle• Toolkit-Probleme

• @awsforjava (Twitter)• Toolkit-Lizenz• Toolkit-FAQ• Erste Schritte mit AWS SDK for Java

1

https://aws.amazon.com/eclipse/

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#chargeable-resources

https://calculator.aws/#/

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/

https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/

http://aws.amazon.com/blogs/developer/category/java

https://forums.aws.amazon.com/forum.jspa?forumID=70

https://github.com/awsdocs/aws-toolkit-eclipse-user-guide

https://github.com/awsdocs/aws-toolkit-eclipse-user-guide/issues

https://github.com/aws/aws-toolkit-eclipse

https://github.com/aws/aws-toolkit-eclipse/issues

https://twitter.com/awsforjava

https://aws.amazon.com/apache-2-0/

https://aws.amazon.com/eclipse/faqs/

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html

AWS Toolkit for Eclipse BenutzerhandbuchZusätzliche Dokumentation und Ressourcen

• Using AWS Elastic Beanstalk with the AWS Toolkit for Eclipse (Verwenden des AWS Elastic Beanstalkmit dem AWS Toolkit for Eclipse) (Video)

• AWS-Toolkit für Eclipse: Amazon EC2 Management (Video)

2

https://d1un85p0f2qstc.cloudfront.net/eclipse/elasticbeanstalk/index.html

https://d1un85p0f2qstc.cloudfront.net/eclipse/elasticbeanstalk/index.html

http://d1un85p0f2qstc.cloudfront.net/eclipse/ec2/index.html

AWS Toolkit for Eclipse BenutzerhandbuchEinrichten des Toolkits

Erste SchritteIn diesem Abschnitt finden Sie Informationen zu den ersten Schritten mit dem AWS Toolkit for Eclipse,einschließlich Anweisungen zum Installieren und Konfigurieren des AWS Toolkit for Eclipse.

Themen• Einrichten des Toolkits (p. 3)• Einrichten von AWS-Anmeldeinformationen (p. 4)• Private Schlüssel mit Ihrem verknüpfen Amazon EC2 Key Pairs (p. 8)

Einrichten des ToolkitsIn diesem Abschnitt wird das Installieren bzw. Upgraden des AWS Toolkit for Eclipse beschrieben.

PrerequisitesFolgende Voraussetzungen des AWS Toolkit for Eclipse müssen dafür erfüllt sein:

• Sie müssen über ein Amazon Web Services-Konto verfügen: Um ein AWS-Konto zu erstellen, gehen Sieauf die AWS-Homepage und klicken Sign Up Now (Jetzt registrieren). Wenn Sie sich registrieren, könnenSie alle von AWS angebotenen Services nutzen.

• Ein unterstütztes Betriebssystem: Das AWS Toolkit for Eclipse wird auf Windows, Linux, macOS, or Unixunterstützt.

• Java 1.8• Eclipse IDE for Java Developers 4.2 oder höher: Wir versuchen, AWS Toolkit for Eclipse auf dem Stand

der auf der Eclipse-Downloadseite verfügbaren Standardversion zu halten.Note

Eclipse stellt eine Reihe verschiedener Downloads zur Verfügung. Wir empfehlen dieInstallation von Eclipse IDE for Enterprise Java Developers. Dazu gehören auch die für ElasticBeanstalk erforderliche Eclipse Web Tools Platform, die für die Amazon SimpleDB-Funktionenerforderliche Eclipse Data Tools Platform, Eclipse EGit und M2Eclipse. Wenn Sie eineandere Version von Eclipse installieren, sollten Sie sich vergewissern, dass diese Funktionenunterstützt werden (oder dass Sie Support für diese Funktionen anhand der bereitgestelltenLinks installieren).

• (Optional) Google Android Development Tools (ADT): Wenn Sie möchten , dass AWS Toolkit for EclipseAWS Mobile SDK for Android (AWS Mobile SDK für Android) unterstützt, müssen Sie zunächst die ADTinstallieren.

Installieren der AWS Toolkit for EclipseSo installieren Sie das AWS Toolkit for Eclipse:

1. Klicken Sie in Eclipse auf Help (Hilfe) und dann auf Install New Software (Neue Software installieren).2. Geben Sie in das Feld Work with (Arbeiten mit) https://aws.amazon.com/eclipse ein und drücken Sie

anschließend Enter.3. Wählen Sie die Komponenten des AWS Toolkit for Eclipse aus, die Sie installieren möchten. Klicken

Sie auf Select All (Alle auswählen), um alle Komponenten gleichzeitig zu installieren.

3

https://aws.amazon.com/

https://eclipse.org/downloads/

https://projects.eclipse.org/projects/webtools

http://www.eclipse.org/datatools/

http://www.eclipse.org/egit/

http://www.eclipse.org/m2e/

https://aws.amazon.com/mobile/sdk/

https://developer.android.com/studio/tools/sdk/eclipse-adt.html

AWS Toolkit for Eclipse BenutzerhandbuchUpgraden des AWS Toolkit for Eclipse

Note

• AWS Toolkit for Eclipse Core (AWS Toolkit für Eclipse Core) (im Abschnitt AWS CoreManagement Tools (AWS Core-Verwaltungstools) ist obligatorisch. Alle anderenKomponenten sind optional.

• Damit AWS Mobile SDK for Android (AWS Mobile SDK für Android) unterstützt wird,müssen Sie zunächst Google Android Developer Tools (ADT) für Eclipse installieren. WennSie die ADT noch nicht installiert haben, stellen Sie sicher, dass AWS SDK for Android(AWS SDK für Android) deaktiviert ist. Ansonsten schlägt die Installation fehl.

• Damit die Amazon RDS- oder Amazon SimpleDB-Manager unterstützt werden, muss dieEclipse Data Tools Platform (DTP) installiert sein. Die DTP wird standardmäßig mit derVersion „Java EE Developers“ von Eclipse installiert. Sie können sie jedoch auch separatinstallieren.

4. Klicken Sie, nachdem Sie Ihre Auswahl getroffen haben, auf Next (Weiter) (oder auf Finish (Beenden)),um die Installation abzuschließen.

Nach dem Einrichten des AWS Toolkit for Eclipse sollten Sie Ihre AWS-Anmeldeinformationenkonfigurieren (p. 4).

Note

Abhängig von der ausgewählten Optionen und von Faktoren wie Netzwerkgeschwindigkeit,Server-Latenz und Systemkapazität kann es bis zu 30 Minuten dauern, bis die Installationabgeschlossen ist.

Upgraden des AWS Toolkit for EclipseFür Upgrades oder die erneute Installation des AWS Toolkit for Eclipse befolgen Sie dieselbenAnweisungen wie für das Installieren des Toolkits (p. 3).

Manche Versionen von Eclipse, insbesondere Mars und Neon, rufen aufgrund eines Fehlers in altenVersionen des Oomph-Plug-Ins nicht die neuesten Artefakte ab. Gehen Sie wie folgt vor, um diesesProblem zu umgehen:

1. Stellen Sie sicher, dass Sie https://aws.amazon.com/eclipse/site.xml als Website für dieAktualisierung von AWS Toolkit for Eclipse verwenden.

2. Löschen Sie das ~/.eclipse/org.eclipse.oomph.p2/cache/-Verzeichnis, umzwischengespeicherten Inhalt zu entfernen.

3. Installieren Sie die neueste Version von Oomph (Eclipse Installer).

Einrichten von AWS-AnmeldeinformationenFür den Zugriff auf Amazon Web Services mit dem AWS Toolkit for Eclipse müssen Sie das AWS Toolkitfor Eclipse mit den Anmeldeinformationen für das AWS-Konto konfigurieren.

Abrufen Ihrer AWS-ZugriffsschlüsselZugriffsschlüssel bestehen aus einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel.Diese werden zum Signieren der von Ihnen ausgeführten programmgesteuerten Anforderungen anAWS verwendet. Wenn Sie noch keine Zugriffsschlüssel besitzen, können Sie diese über die AWS-Managementkonsole erstellen. Wir empfehlen die Verwendung von IAM-Zugriffsschlüsseln anstelle vonAWS-Stammkonto-Zugriffsschlüsseln. Mit IAM können Sie den Zugriff auf AWS-Services und -Ressourcenin Ihrem AWS-Konto sicher steuern.

4

https://aws.amazon.com/mobile/sdk/

https://eclipse.org/datatools/downloads.php

https://eclipse.org/datatools/downloads.php

https://projects.eclipse.org/projects/tools.oomph

https://wiki.eclipse.org/Eclipse_Installer

https://console.aws.amazon.com/console/home


AWS Toolkit for Eclipse BenutzerhandbuchHinzufügen Ihres AWS-Zugriffsschlüssels

zum AWS Toolkit for Eclipse

Note

Um Zugriffsschlüssel zu erstellen, müssen Sie Berechtigungen zum Ausführen der erforderlichenIAM-Aktionen besitzen. Weitere Informationen finden Sie unter Gewähren von Berechtigungenfür IAM-Benutzer zur Verwaltung von Passwortrichtlinien und Anmeldeinformationen im IAM UserGuide.

So erhalten Sie Ihre Zugriffsschlüssel-ID und Ihren geheimenZugriffsschlüssel1. Öffnen Sie die IAM-Konsole.2. Wählen Sie im Navigationsmenü Users (Benutzer).3. Wählen Sie Ihren IAM-Benutzernamen (nicht das Kontrollkästchen).4. Öffnen Sie die Registerkarte Security credentials (Sicherheitsanmeldeinformationen) und wählen Sie

Create access key (Zugriffsschlüssel erstellen) aus.5. Wählen Sie zum Anzeigen des neuen Zugriffsschlüssels Show aus. Ihre Anmeldeinformationen sehen in

etwa wie folgt aus:• Zugriffsschlüssel-ID: AKIAIOSFODNN7EXAMPLE• Geheimer Zugriffsschlüssel: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

6. Wählen Sie zum Herunterladen des Schlüsselpaares Download .csv file aus. Speichern Sie dieSchlüssel

an einem sicheren Ort.Important

Behandeln Sie die Schlüssel vertraulich, um Ihr AWS-Konto zu schützen, und senden Sie sieniemals per E-Mail. Geben Sie die Schlüssel nicht außerhalb Ihrer Organisation weiter, auchnicht im Falle von Anfragen, die von AWS oder Amazon.com zu kommen scheinen. Niemand, derAmazon legitim vertritt, wird Sie nach dem geheimen Schlüssel fragen.

Verwandte Themen:• Was ist IAM? im IAM User Guide.• AWS-Sicherheitsanmeldeinformationen in Amazon Web Services General Reference.

Hinzufügen Ihres AWS-Zugriffsschlüssels zum AWSToolkit for EclipseDas AWS Toolkit for Eclipse verwendet dasselbe System zum Suchen und Verwenden von AWS-Zugriffsschlüsseln wie die AWS-Befehlszeilenschnittstelle und das AWS-SDK für Java. Die in der EclipseIDE eingegebenen Zugriffsschlüssel werden in einer freigegebenen Datei mit AWS-Anmeldeinformationen(mit der Bezeichnung credentials) im Unterverzeichnis .aws Ihres Benutzerverzeichnisses gespeichert.

Note

Der Speicherort der Datei mit den Anmeldeinformationen kann geändert werden. WeitereInformationen zum Festlegen des Speicherorts für diese Datei finden Sie unter Ändern desSpeicherorts der Datei mit den AWS-Anmeldeinformationen (p. 7).

Wenn Sie Ihre AWS-Anmeldeinformationen bereits mit der AWS-Befehlszeilenschnittstelle (CLI) festgelegthaben, erkennt und verwendet das AWS Toolkit for Eclipse diese Anmeldeinformationen automatisch.Weitere Informationen zur Verwendung der AWS-Befehlszeilenschnittstelle (CLI) finden Sie im AWS CLI-Benutzerhandbuch.

5

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_delegate-permissions.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_delegate-permissions.html

https://console.aws.amazon.com/iam/home

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html

https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html

https://docs.aws.amazon.com/cli/latest/userguide/

https://docs.aws.amazon.com/cli/latest/userguide/

AWS Toolkit for Eclipse BenutzerhandbuchVerwenden mehrerer AWS-Konten

mit dem AWS Toolkit for Eclipse

So fügen Sie dem AWS Toolkit for Eclipse Ihre Zugriffsschlüssel hinzu

1. Öffnen Sie das Dialogfeld Preferences (Präferenzen) in Eclipse und klicken Sie in der Seitenleiste aufAWS Toolkit.

2. Geben Sie Ihre AWS-Zugriffsschlüssel-ID im Feld Access Key ID (Zugriffsschlüssel-ID) ein oder fügenSie sie ein.

3. Geben Sie Ihren geheimen AWS-Zugriffsschlüssel im Feld Secret Access Key (GeheimerZugriffsschlüssel) ein oder fügen Sie ihn ein.

4. Klicken Sie auf Apply (Anwenden) oder OK, um die Informationen zu Ihren Zugriffsschlüsseln zuspeichern.

Ein Beispiel für einen konfigurierten Satz von Standardanmeldeinformationen:

Verwenden mehrerer AWS-Konten mit dem AWSToolkit for EclipseSie können im Dialogfeld Preferences (Präferenzen) Informationen für mehr als ein AWS-Konto hinzufügen.Mehrere Konten können z. B. nützlich sein, um Entwicklern und Administratoren separate Ressourcen fürdie Entwicklung und für die Freigabe/Veröffentlichung bereitzustellen.

Getrennte Sätze von AWS-Anmeldeinformationen werden gespeichert als Profile innerhalb der gemeinsambeschriebenen AWS-Berechtigungsdatei Fügen Sie Ihre AWS-Zugriffstasten zum AWS-Toolkit für Eclipsehinzu (p. 5). Alle konfigurierten Profile werden in der Dropdown-Liste oben auf dem Bildschirm „AWSToolkit Preferences Global Configuration“ (AWS Toolkit-Präferenzen für die globale Konfiguration) unterDefault Profile (Standardprofil) angezeigt.

So fügen Sie einen neuen Satz von Zugriffsschlüsseln hinzu

1. Klicken Sie auf dem Bildschirm AWS Toolkit Preferences (AWS Toolkit-Präferenzen) im DialogfeldPreferences (Präferenzen) in Eclipse auf Add profile (Profil hinzufügen).

2. Fügen Sie Ihre neuen Kontoinformationen im Abschnitt Profile Details (Profilinformationen) hinzu.

Wählen Sie einen aussagekräftigen Namen für Profile Name (Profilname) aus und geben Sie dieInformationen zu Ihrem Zugriffsschlüssel in die Felder Access Key ID (Zugriffsschlüssel-ID) und SecretAccess Key (Geheimer Zugriffsschlüssel) ein.

6

AWS Toolkit for Eclipse BenutzerhandbuchÄndern des Speicherorts der Datei

mit den AWS-Anmeldeinformationen

3. Klicken Sie auf Apply (Anwenden) oder OK, um die Informationen zu Ihren Zugriffsschlüsseln zuspeichern.

Wiederholen Sie dieses Verfahren für alle benötigten Sätze von AWS-Kontoinformationen.

Wenn Sie alle AWS-Kontoinformationen eingegeben haben, wählen Sie das Standardkonto in derDropdown-Liste Default Profile (Standardprofil) aus. AWS Explorer zeigt die dem Standardkontozugeordneten Ressourcen an. Wenn Sie über das AWS Toolkit for Eclipse eine neue Anwendung erstellen,verwendet die Anwendung die für das Standardkonto konfigurierten Anmeldeinformationen.

Note

Ein anderer Ansatz zur Trennung von AWS-Ressourcen wird unter Differenzierung von AWS-Ressourcen mittels Benennung (p. 17) beschrieben.

Ändern des Speicherorts der Datei mit den AWS-AnmeldeinformationenÜber den Bildschirm „Preferences“ im AWS Toolkit for Eclipse können Sie den Speicherort ändern, an demdas Toolkit Anmeldeinformationen speichert und lädt.

So ändern Sie den Speicherort der Datei mit den AWS-Anmeldeinformationen• Suchen Sie im Dialogfeld „Preferences“ (Präferenzen) des AWS-Toolkits den Abschnitt Credentials file

location (Speicherort der Anmeldeinformationen-Datei) und geben Sie den Pfadnamen der Datei ein, inder Ihre AWS-Anmeldeinformationen gespeichert werden sollen.

Important

Es wird ausdrücklich empfohlen, dass Sie Ihre AWS-Anmeldeinformationen nicht innerhalb einesim Netzwerk freigegebenen Verzeichnisses oder in Projekten mit Quellcodeverwaltung speichern.Wenden Sie immer strenge Sicherheitsregeln für Ihre AWS-Zugriffsschlüssel an.

7

AWS Toolkit for Eclipse BenutzerhandbuchPrivate Schlüssel mit Ihrem

verknüpfen Amazon EC2 Key Pairs

Private Schlüssel mit Ihrem verknüpfen AmazonEC2 Key Pairs

Das AWS Toolkit for Eclipse kann Ihre Amazon EC2-Schlüsselpaare von AWS abrufen. Sie müssen jedochprivate Schlüssel verknüpfen, damit sie mit dem AWS Toolkit for Eclipse verwendet werden können.

So zeigen Sie Ihre Amazon EC2-Schlüsselpaare im AWS Toolkit for Eclipse an und ordnen ihnen privateSchlüssel zu

1. Öffnen Sie das Dialogfeld Preferences (Präferenzen) von Eclipse und klicken Sie auf das Dreieck nebenAWS Toolkit in der Seitenleiste, um weitere Kategorien von AWS Toolkit for Eclipse-Einstellungenanzuzeigen.

2. Wählen Sie Key Pairs (Schlüsselpaare) aus.

Eclipse zeigt eine scrollbare Liste Ihrer Schlüsselpaare an. Wenn ein Schlüsselpaar mit einem rotenX gekennzeichnet ist, müssen Sie dem Schlüsselpaar einen privaten Schlüssel zuordnen, um es zuverwenden.

3. Klicken Sie mit der rechten Maustaste auf das Schlüsselpaar und wählen Sie im Kontextmenü SelectPrivate Key File (Private Schlüsseldatei auswählen) aus.

8

AWS Toolkit for Eclipse BenutzerhandbuchPrivate Schlüssel mit Ihrem

verknüpfen Amazon EC2 Key Pairs

4. Navigieren Sie zu der Datei mit dem privaten Schlüssel und wählen Sie diese aus, um sie IhremSchlüsselpaar zuzuordnen.

9

AWS Toolkit for Eclipse BenutzerhandbuchErstellen einer AWS Java-Anwendung

AWS Toolkit for Eclipse-GrundlagenDieser Abschnitt enthält Informationen zum Durchführen von häufigen Entwicklungsaufgaben mit dem AWSToolkit for Eclipse.

Themen• Erstellen einer AWS Java-Anwendung (p. 10)• Serverlose Projekte (p. 12)• Differenzierung von AWS-Ressourcen mittels Benennung (p. 17)

Erstellen einer AWS Java-AnwendungIn diesem Abschnitt wird das AWS Toolkit for Eclipse für das Erstellen und Ausführen einer lokalen Java-Anwendung mit Zugriff auf AWS-Ressourcen verwendet.

Das AWS Toolkit for Eclipse umfasst das AWS SDK for Java sowie eine Reihe von Java-Beispielprogrammen. Das AWS Toolkit for Eclipse erleichtert das Erstellen und Ausführen dieser Beispiele.Am Beispiel von AmazonSimpleQueueService wird veranschaulicht, wie Sie mithilfe des AWS Toolkit forEclipse AWS-Anwendungen in Java erstellen und ausführen können. Der mit dem AWS Toolkit for Eclipsebereitgestellte AWS Explorer kann zum Ausführen der Amazon SQS-Warteschlange verwendet werden.

Note

Sie finden die AWS SDK for Java-Beispiele im samples-Verzeichnis im SDK-Download undkönnen sie auch unter GitHub aufrufen. Weitere Informationen über das AWS SDK for Java selbstfinden Sie im AWS SDK for Java-Entwicklerhandbuch.

Erstellen und Ausführen des Amazon Simple QueueService-BeispielsSo erstellen Sie ein Amazon Simple Queue Service-Beispiel und führen es aus:

1. Klicken Sie auf das AWS-Symbol in der Eclipse-Symbolleiste und dann auf New AWS Java Project(Neues AWS Java-Projekt).

2. Geben Sie im angezeigten Dialogfeld in Project name (Projektname) einen Namen für das Projekt einund wählen Sie Amazon Simple Queue Service Sample (Amazon Simple Queue Service-Beispiel).

10

https://github.com/aws/aws-sdk-java/tree/master/src/samples

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/

AWS Toolkit for Eclipse BenutzerhandbuchErstellen und Ausführen des Amazon

Simple Queue Service-Beispiels

3. Klicken Sie auf Finish (Beenden).4. Die Beispielanwendung wird im Project Explorer (Projekt-Explorer) angezeigt. Erweitern Sie die

Strukturansicht für dieses Projekt.5. Doppelklicken Sie unter dem src-Knoten auf die SimpleQueueService.java-Quelldatei, um sie im

Editorbereich zu öffnen. Suchen Sie die folgende Zeile:

System.out.println("Receiving messages from MyQueue.\n");

6. Klicken Sie mit der rechten Maustaste auf den linken Rand des Editorbereichs und wählen Sie ToggleBreakpoint (Haltepunkt umschalten).

11

AWS Toolkit for Eclipse BenutzerhandbuchServerlose Projekte

7. Klicken Sie mit der rechten Maustaste auf den Projektknoten in Project Explorer (Projekt-Explorer) – indiesem Beispiel wäre das der Knoten namens myJavaSqsApp – und klicken Sie dann auf Debug As(Debuggen als) > Java Application (Java-Anwendung).

8. Wählen Sie im Dialogfeld Select Java Application (Java-Anwendung auswählen) die SQS-Anwendungaus und klicken Sie dann auf OK.

9. Wenn die Anwendung am Haltepunkt stoppt, zeigt Eclipse die Frage an, ob Sie zur Debugging-Perspektive wechseln möchten. Klicken Sie auf No (Nein) (die Debugging-Perspektive enthält den AWSExplorer nicht).

10.Rufen Sie den AWS Explorer auf und erweitern Sie den Amazon SQS-Knoten.11.Doppelklicken Sie auf MyQueue und sehen Sie sich den Inhalt der Warteschlange an, die von der Java-

Client-Anwendung erstellt wurde.

12.Drücken F8. Die Java-Client-Anwendung läuft und endet normal.13.Aktualisieren Sie die Ansicht im AWS Explorer. Sie werden feststellen, dass die MyQueue-

Warteschlange nicht mehr vorhanden ist. Die Anwendung löscht die Warteschlange, bevor dieAnwendung geschlossen wird.

Note

Wenn Sie diese Beispielanwendung wiederholt ausführen, sollten Sie zwischen den einzelnenDurchläufen mindestens 60 Sekunden warten. Amazon SQS erfordert, dass nach dem Löscheneiner Warteschlange mindestens 60 Sekunden verstreichen, bevor eine Warteschlange mitdemselben Namen erstellt wird.

Serverlose ProjekteDas AWS Toolkit for Eclipse umfasst einen Projekterstellungs-Assistenten, mit dem Sie schnell serverloseProjekte konfigurieren und erstellen können, um diese auf AWS CloudFormation bereitzustellen undLambda-Funktionen als Reaktion auf RESTful-Webanforderungen auszuführen.

Erstellen eines serverlosen ProjektsSo erstellen Sie ein serverloses Projekt

1. Wählen Sie das AWS-Symbol in der Symbolleiste und anschließend im angezeigten Menü New AWSserverless project (Neues serverloses AWS-Projekt) aus.

2. Geben Sie in Project name (Projektname) einen Projektnamen ein.

12

AWS Toolkit for Eclipse BenutzerhandbuchErstellen eines serverlosen Projekts

3. Geben Sie in Package namespace (Paket-Namespace) einen Paket-Namespace für das Projekt ein.Dieser wird als Präfix für den Quell-Namespaces verwendet, der für das Projekt erstellt wird.

4. Wählen Sie Select a blueprint (Planauswahl) oder Select a serverless template file (ServerloseVorlagendatei auswählen) aus:

Auswählen eines Plans

Wählen Sie einen vordefinierten Projektplan (p. 14) für Ihr serverloses Projekt aus.Auswählen einer serverlosen Vorlagendatei

Wählen Sie in Ihrem Dateisystem eine .template-Datei für ein serverloses Anwendungsmodell(SAM) im JSON-Format aus, um Ihr serverloses Projekt umfassend anzupassen.

Note

Weitere Informationen zu Struktur und Inhalt einer .template-Datei finden Sie in deraktuellen Version der Spezifikation auf GitHub.

5. Klicken Sie auf die Schaltfläche Finish (Beenden), um Ihr neues serverloses Projekt zu erstellen.

13

https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md

AWS Toolkit for Eclipse BenutzerhandbuchPläne für serverlose Projekte

The serverless project wizard

Pläne für serverlose ProjekteDie folgenden Pläne für serverlose Projekte stehen für die Verwendung zur Verfügung:

article

Dieser Plan erstellt einen S3-Bucket zum Speichern von Artikelinhalten und eine DynamoDB-Tabellefür die Artikel-Metadaten. Er enthält Lambda-Funktionen zum Abrufen (GetArticle) und Speichern(PutArticle) von Artikeln, die von API Gateway-Ereignissen ausgelöst werden.

hello-world

Ein einfacher Plan, der eine Lambda-Funktion erstellt, die eine einzelne Zeichenfolge übernimmt. DieAusgabe ist Hello, value , wobei value die übergebene Zeichenfolge ist oder World, wenn keineZeichenfolge an die Funktion übergeben wurde.

14

AWS Toolkit for Eclipse BenutzerhandbuchStruktur serverloser Projekte

Struktur serverloser ProjekteDer Assistent für serverlose Projekte erstellt ein neues Eclipse-Projekt für Sie, das die folgendenKomponenten enthält:

• Das Verzeichnis src enthält zwei Unterverzeichnisse, denen jeweils der von Ihnen ausgewählte Paket-Namespace vorangestellt ist:mynamespace.function

Enthält Klassendateien für die Lambda-Funktionen, die durch Ihre serverlose Vorlage definiertwerden.

mynamespace.model

Enthält allgemeine ServerlessInput- und ServerlessOutput-Klassen, die das Eingabe- undAusgabemodell für Ihre Lambda-Funktionen definieren.

Note

Weitere Informationen zu den verwendeten Eingabe- und Ausgabeformaten in denModellklassen finden Sie auf der Seite Einrichten der Proxy-Integration mit einer Proxy-Ressource im API Gateway Developer Guide.

• Die Datei serverless.template definiert die AWS-Ressourcen und Lambda-Funktionen (eineRessource vom Typ „AWS::Serverless:Function“) für Ihr Projekt.

Bereitstellen eines serverlosen ProjektsSo stellen Sie das serverlose Projekt bereit

1. Wählen Sie Ihr Projekt in Eclipse im Fenster Project Explorer (Projekt-Explorer) aus und öffnen Sie dasKontextmenü (rechte Maustaste oder langes Klicken).

2. Wählen Sie im Kontextmenü Amazon Web Services ‣ Deploy Serverless Project (Serverloses Projektbereitstellen) aus. Damit zeigen Sie das Dialogfeld Deploy Serverless to AWS CloudFormation(Serverloses Projekt in AWS CloudFormation bereitstellen) an.

3. Wählen Sie die zu verwendenden AWS Regions (AWS-Regionen) aus. Dies bestimmt den Standortdes bereitgestellten AWS CloudFormation-Stacks.

4. Wählen Sie einen S3 Bucket (S3-Bucket) für die Speicherung Ihres Lambda-Funktionscodes oder dieSchaltfläche Create (Erstellen) aus, um einen neuen S3-Bucket für die Speicherung Ihres Codes zuerstellen.

5. Wählen Sie einen Namen für Ihren AWS CloudFormation-Stack aus.6. Klicken Sie auf die Schaltfläche Finish (Beenden), um Ihre Lambda-Funktionen in Amazon S3

hochzuladen und Ihre Projektvorlage in AWS CloudFormation bereitzustellen.

15

https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-set-up-simple-proxy.html

https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-set-up-simple-proxy.html

AWS Toolkit for Eclipse BenutzerhandbuchWeitere Informationen finden Sie auch unter:

The serverless project deployment dialog

Bei der Bereitstellung Ihres Projekts wird ein Fenster mit den Details zum AWS CloudFormation-Stackangezeigt, das Informationen zur Bereitstellung und zum aktuellen Status enthält. Sie wird den Statusanfangs als CREATE_IN_PROGRESS. Wenn der Status CREATE_COMPLETE, Ihre Bereitstellung ist aktiv.

Sie können dieses Fenster jederzeit öffnen. Wählen Sie dazu im AWS Explorer den Knoten AWSCloudFormation und dann den Namen Ihres AWS CloudFormation-Stacks aus.

Note

Wenn während der Bereitstellung Ihres Stacks ein Fehler aufgetreten ist, kann diese rückgängiggemacht werden. Weitere Informationen zur Diagnose von Fehlern bei der Stack-Bereitstellungfinden Sie im AWS CloudFormation User Guide unter Troubleshooting (Fehlersuche).

Weitere Informationen finden Sie auch unter:• AWS Serverless Application Model (GitHub) (Serverloses Anwendungsmodell von AWS)• Der AWS CloudFormation-Vorlageneditor (p. 40)• Verwenden von Lambda mit dem AWS Toolkit for Eclipse (p. 23)

16

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html

https://github.com/awslabs/serverless-application-model

AWS Toolkit for Eclipse BenutzerhandbuchDifferenzierung von AWS-Ressourcen mittels Benennung

Differenzierung von AWS-Ressourcen mittelsBenennung

Während der Entwicklung neuer Produkte und Funktionen ist es nützlich, AWS-Ressourcen, die für dieEntwicklung verwendet werden, von den Ressourcen für die Produktion zu trennen. Eine Möglichkeitzum Aufrechterhalten dieser Trennung wurde unter Einrichten der AWS-Anmeldeinformationen (p. 4)erläutert und besteht darin, unterschiedliche Konten für die Entwicklungs- und Produktionsressourcen zunutzen. Dieser Ansatz eignet sich besonders bei der Verwendung von AWS Explorer, da die Ressourcenim AWS Explorer basierend auf den Konto-Anmeldeinformationen angezeigt werden. In diesem Abschnittwird ein alternatives Verfahren beschrieben, bei dem eine Benennungskonvention für die Differenzierungzwischen Entwicklungs- und Produktionsressourcen—verwendet wird und bei der der Support für dieBenennungskonvention im Code implementiert wird.

Der Grundgedanke ist, Ihre AWS-Ressourcen, z. B. Amazon Simple Storage Service-Buckets (Amazon S3)oder Amazon SimpleDB-Domänen, zu unterscheiden, indem dem Ressourcennamen ein Zeichenfolgewerthinzugefügt wird. So würden Sie Ihre Amazon SimpleDB-Domäne beispielsweise nicht einfach nur"customers" nennen sondern "customers-dev", wenn die Domäne für die Entwicklung verwendet wird, oder"customers-prod", wenn sie in der Produktion eingesetzt wird. Allerdings tritt ein Problem auf, wenn SieEntwicklungscodes in die Produktion verschieben müssen. Dann müssten Sie alle diese Zeichenfolgenändern, möglicherweise mit einer Reihe von globalen Such- und Ersetzen-Operationen. Das wäre einmühsamer und fehleranfälliger Vorgang. Effizienter wäre, Support für die Benennungskonvention im Codehinzuzufügen.

17


Die StageUtils-Klasse stellt die folgende Methode bereit:

public static String getResourceSuffixForCurrentStage()

Die getResourceSuffixForCurrentStage-Methode gibt eine Zeichenfolge zurück, die der "Stufe"im Software-Lebenszyklus entspricht, für die die Ressource verwendet wird, also z. B. "dev", "beta" oder"prod". Diese Zeichenfolge kann dann an die im Code verwendeten Ressourcen-IDs angehängt werden.Sie können getResourceSuffixForCurrentStage zum Erstellen von Ressourcennamen verwenden.Zum Beispiel wird mit der folgenden Methode, getTopicName, ein eindeutiger Name für ein Amazon SNS-Thema ausgegeben. Beachten Sie, wie der Rückgabewert von getResourceSuffixForCurrentStagein diesen Namen eingebettet wird.

private String getTopicName (Entry entry) { return "entry" + StageUtils.getResourceSuffixForCurrentStage() + "-" + entry.getId();}

18


Der von getResourceSuffixForCurrentStage zurückgegebene Wert wird von der Javasystem-Eigenschaft "application.stage", abgerufen. Sie können diesen Wert festlegen, indem Sie dieSystemeigenschaft für in der Container-Konfiguration für AWS Elastic Beanstalk konfigurieren.

Note

Im AWS Toolkit for Eclipse muss Ihre AWS Elastic Beanstalk-Anwendung ausführungsbereitsein, damit Sie auf die Containerkonfiguration zugreifen können. Das Ändern und Speichern derKonfiguration führt dazu, dass die Anwendung automatisch mit der geänderten Konfiguration neugestartet wird.

So greifen Sie auf den Container/JVM-Optionsbereich für Ihre AWS Elastic Beanstalk-Anwendung zu:

1. Erweitern Sie im AWS Explorer den AWS Elastic Beanstalk-Knoten sowie Ihren Anwendungsknoten.2. Doppelklicken Sie unter dem Anwendungsknoten auf Ihre AWS Elastic Beanstalk-Umgebung.3. Klicken Sie unten im Bereich Overview (Übersicht) auf die Registerkarte Configuration (Konfiguration).4. Konfigurieren Sie im Bereich Container die Containeroptionen.5. Geben Sie im Feld Additional Tomcat JVM command line options (Zusätzliche Tomcat JVM-

Befehlszeilenoptionen) den Wert für die Systemeigenschaft „application.stage“ an, indem Sie eine -D-Befehlszeilenoption hinzufügen. Sie könnten z. B. die folgende Syntax verwenden, um festzulegen, dassder Zeichenfolgewert "beta" sein soll.

-Dapplication.stage=beta

Beachten Sie, dass getResourceSuffixForCurrentStage automatisch jedem Zeichenfolgewerteinen Bindestrich voranstellt.

6. Klicken Sie, nachdem Sie den Systemeigenschaftswert hinzugefügt haben, auf das Menü File (Datei)und dann auf Save (Speichern). Eclipse speichert daraufhin die neue Konfiguration. Die Anwendungsollte automatisch neu gestartet werden. Sie können das Ereignisse Registerkarte—unten im Eclipse-Editor—für das Ereignis, das anzeigt, dass die neue Konfiguration erfolgreich auf die Umgebungimplementiert wurde.

7. Erweitern Sie nach dem Neustart der Anwendung den Amazon SimpleDB-Knoten im AWS Explorer. Siesollten nun eine Reihe neuer Domänen sehen, die den Zeichenfolgewert verwenden, den Sie festgelegthaben.

19


Note

Weitere Informationen über das Konfigurieren des Containers finden Sie unter Erstellen undBereitstellen von Java-Anwendungen in AWS Elastic Beanstalk im AWS Elastic BeanstalkDeveloper Guide.

20

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_Java.html

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_Java.html

AWS Toolkit for Eclipse BenutzerhandbuchZugreifen auf AWS Explorer

Arbeiten mit AWS-ServicesIm AWS Explorer können Sie gleichzeitig mehrere Amazon Web Services anzeigen und bearbeiten. Indiesem Abschnitt finden Sie Informationen dazu, wie Sie in Eclipse auf die AWS Explorer-Ansicht zugreifenund diese verwenden.

Es wird davon ausgegangen, dass Sie das AWS Toolkit for Eclipse bereits auf Ihrem Systeminstalliert (p. 3) haben.

Themen• Zugreifen auf AWS Explorer (p. 21)• Verwenden von Lambda mit AWS Toolkit for Eclipse (p. 23)• Die AWS CloudFormation Schablonen-Editor (p. 40)• Verwendung DynamoDB mit AWS Explorer (p. 49)• Starten Sie eine Amazon EC2 Instanz von einem Amazon Machine Image (p. 54)• Verwalten von Sicherheitsgruppen im AWS Explorer (p. 58)• Anzeigen und Hinzufügen Amazon SNS Benachrichtigungen (p. 61)• Verbinden mit Amazon Relational Database Service ( ( (Amazon RDS) (p. 63)• Identitäts- und Zugriffsverwaltung (p. 65)• Debuggen von serverlosen Anwendungen mit AWS SAM Local (p. 81)

Zugreifen auf AWS ExplorerUm den AWS Explorer anzuzeigen, klicken Sie in der Symbolleiste auf das AWS-Symbol und wählen ShowAWS Explorer View (AWS-Explorer-Ansicht anzeigen) aus.

21

AWS Toolkit for Eclipse BenutzerhandbuchZugreifen auf AWS Explorer

AWS Icon Menu

Note

Wenn das AWS-Symbol in der Symbolleiste nicht angezeigt wird, klicken Sie auf das MenüWindow (Fenster) und dann auf Open Perspective | Other (Perspektive öffnen | Andere). KlickenSie in der Liste der Eclipse-Perspektiven auf AWS Management.

Sie können jeden Knoten im AWS Explorer erweitern, um die Ihrem Konto zugeordneten Ressourcen inAWS anzuzeigen. Wenn Sie beispielsweise auf das weiße Dreieck links neben dem Knoten Amazon EC2klicken, werden die Amazon EC2;-Ressourcen, die mit Ihrem AWS-Konto verknüpft sind, erweitert undangezeigt. Das AWS Toolkit for Eclipse ermittelt mithilfe des AWS-Kontos, das Sie unter Einrichten derAWS-Anmeldeinformationen (p. 4) eingerichtet haben, welche Ressourcen angezeigt werden sollen.

22

AWS Toolkit for Eclipse BenutzerhandbuchVerwenden von Lambda mit AWS Toolkit for Eclipse

Wenn Sie Unterknoten von Amazon EC2 auswählen, öffnet Eclipse eine Ansicht mit ausführlichenInformationen zu diesen Ressourcen. Wenn Sie beispielsweise auf Instances doppelklicken, wird eineAnsicht mit Informationen zu den einzelnen Amazon EC2-Instances geöffnet, z. B. dem öffentlichen DNS-Namen, der Availability Zone und dem Startzeitpunkt.

Verwenden von Lambda mit AWS Toolkit forEclipse

Das AWS Toolkit for Eclipse bietet Unterstützung für den Erstellungscode für AWS Lambda. Lambdaist ein vollständig verwalteter Datenverarbeitungsservice, der Ihren Code beim Eintreten bestimmterEreignisse ausführt, die von einem benutzerdefiniertem Code oder von verschiedenen AWS-Serviceswie z. B. Amazon S3, DynamoDB, Kinesis, Amazon SNS und Amazon Cognito erzeugt werden. WeitereInformationen zu Lambda finden Sie im AWS Lambda-Entwicklerhandbuch.

Dieser Abschnitt des AWS Toolkit for Eclipse User Guide befasst sich mit den AWS Toolkit for Eclipse-Optionen zum Erstellen, Bereitstellen und Ausführen von Lambda-Funktionen.

Themen• Praktische Anleitung So erstellen, laden und rufen Sie ein AWS Lambda Funktion (p. 24)• AWS Lambda-Benutzeroberflächenreferenz (p. 33)

23

https://aws.amazon.com/lambda/

https://docs.aws.amazon.com/lambda/latest/dg/

AWS Toolkit for Eclipse BenutzerhandbuchPraktische Anleitung So erstellen, ladenund rufen Sie ein AWS Lambda Funktion

Praktische Anleitung So erstellen, laden und rufen Sieein AWS Lambda FunktionDieses Tutorial führt Sie durch einen typischen AWS Lambda-Workflow und bietet Ihnen aus erster HandInformationen zur Verwendung von Lambda mit dem AWS Toolkit for Eclipse.

Important

In diesem Tutorial wird davon ausgegangen, dass Sie über ein AWS-Konto verfügen, dasAWS Toolkit for Eclipse installiert haben (p. 3) und dass Sie die grundlegenden Konzepte undFunktionen von Lambda kennen. Wenn Sie noch nicht mit Lambda vertraut sind, finden Sie auf derLambda-Homepage und im AWS Lambda-Entwicklerhandbuch weitere Informationen.

Erstellen eines AWS Lambda-ProjektsFür ein Lambda-Projekt implementieren Sie zunächst den Code als eine Methode in einer Handler-Klasse.Das AWS Toolkit for Eclipse umfasst einen neuen Projektassistenten, der Ihnen beim Erstellen einer neuenHandler-Klasse hilft. Das Lambda-Projekt ist ein Maven-Projekt, das eine POM.xml-Datei verwendet, umPaket-Abhängigkeiten zu verwalten. Sie können das Maven Befehlszeilen-Tool zum Erstellen, Testenund Bereitstellen Ihrer Anwendung verwenden. Weitere Informationen zu Maven finden Sie in der Maven-Projektdokumentation.

Erstellen eines AWS Lambda-Projekts

1. Öffnen Sie in der Eclipse-Symbolleiste das Dropdown-Menü für Amazon Web Services (durch dasAWS-Homepage-Symbol gekennzeichnet) und wählen Sie New AWS Lambda Java project (NeuesAWS Lambda-Projekt) Oder wählen Sie in der Eclipse-Menüleiste File (Datei), New (Neu), AWSLambda Java Project (AWS Lambda Java-Projekt).

2. Tragen Sie einen Projektnamen, eine Gruppen-ID, eine Artefakt-ID und einen Klassennamen in dieentsprechenden Eingabefelder ein. Die Group-ID und Artifact-ID sind die IDs, die ein Maven Build-Artefakt identifizieren. In diesem Tutorial werden die folgenden Beispielwerte verwendet:

• Project name Hellolambda• Group ID (Gruppen-ID): com.example.lambda• Artifact ID (Artefakt-ID): demo• Klassenname: Hallo

Das Feld Package Name (Paketname) gibt den Paket-Namespace für die AWS Lambda-Handler-Klasse an. Der Standardwert für dieses Feld ist eine Verknüpfung der Group ID und der ArtifactID, wobei die Konventionen für Maven-Projekte eingehalten werden. Dieses Feld wird automatischaktualisiert, wenn die Felder Group ID (Gruppen-ID) und Artifact ID (Artefakt-ID) aktualisiert werden.

3. Wählen Sie für Input Type (Typ der Eingabe) die Option Custom (Benutzerdefiniert) aus. WeitereInformationen über die verfügbaren Eingabetypen finden Sie unter Dialogfeld „New AWS Lambda JavaProject“ (p. 33).

4. Vergewissern Sie sich, dass die Einträge den folgenden Screenshots entsprechen (und nehmen Sieggf. die erforderlichen Änderungen vor) und klicken Sie dann auf Finish (Beenden).

24

https://aws.amazon.com/lambda/

https://docs.aws.amazon.com/lambda/latest/dg/

https://maven.apache.org

https://maven.apache.org


Während der Eingabe ändert sich der Code in Source preview (Quellenvorschau) und zeigt IhreÄnderungen im Dialogfeld an.

5. Nachdem Sie Finish (Beenden) gewählt haben, werden Ihr Projektverzeichnis und die Quelldateienin Ihrem Eclipse-Workspace erstellt. Es öffnet sich ein neues Webbrowser-Fenster, das angezeigtwird README.html (die für Sie in Ihrem Projekt-Stammverzeichnis erstellt wurde). README.htmlAnweisungen zur Anleitung, zum Testen, Hochladen und Aufrufen Ihrer neuen Schritte LambdaFunktion. Lesen Sie die Datei erneut durch, um sich mit den nächsten Schritten vertraut zu machen,die hier beschrieben werden.

25


Als Nächstes implementieren Sie die Funktion in dem HelloLambda-Javaprojekt, das gerade für Sie inEclipse erstellt wurde.

Implementieren der Handler-MethodeIm Dialogfeld Create New Project (Neues Projekt erstellen) erstellen Sie ein Projekt-Skelett. Jetzt tragenSie den Code ein, der ausgeführt wird, wenn Ihre Lambda-Funktion aufgerufen wird. (In diesem Fall voneinem benutzerdefinierten Ereignis, das eine Zeichenfolge an Ihre Funktion sendet, wie beim Festlegen derEingabeparameter Ihrer Methode angegeben.)

So implementieren Sie die Lambda-Handler-Methode

1. Öffnen Sie mit dem Project Explorer (Projekt-Explorer) von Eclipse Hello.java im ProjektHelloLambda. Darin finden Sie einen ähnlichen Code wie diesen.

package com.example.lambda.demo;

import com.amazonaws.services.lambda.runtime.Context;import com.amazonaws.services.lambda.runtime.RequestHandler;

public class Hello implements RequestHandler<Object, String> {

@Override public String handleRequest(Object input, Context context) { context.getLogger().log("Input: " + input);

// TODO: implement your handler return "Hello from Lambda"; }

}

2. Ersetzen Sie den Inhalt der handleRequest-Funktion durch den folgenden Code.

@Overridepublic String handleRequest(String input, Context context) { context.getLogger().log("Input: " + input); String output = "Hello, " + input + "!"; return output;}

Lambda das Annehmen einer IAM-Rolle erlaubenDamit Lambda auf Ihre Lambda-Funktion zugreifen kann, müssen Sie eine IAM-Rolle erstellen, dieden Zugriff auf Ihre AWS-Ressourcen ermöglicht. Sie können die Rolle auf zweierlei Arten erstellen,entweder über die AWS Management Console oder über AWS Toolkit for Eclipse. In diesem Abschnittwird beschrieben, wie Sie die IAM-Rolle mit der Konsole erstellen. Weitere Informationen zum Erstellen mitAWS Toolkit for Eclipse finden Sie unter Hochladen des Codes (p. 27).

So erstellen Sie eine IAM-Rolle für Lambda

1. Melden Sie sich bei der AWS-Managementkonsole an.2. Öffnen Sie im Menü Services die IAM console (IAM-Konsole).3. Wählen Sie im Navigationsbereich Roles (Rollen) und dann Create role (Rolle erstellen).4. Wählen Sie für Select type of trusted entity (Typ der vertrauenswürdigen Entität auswählen) die Option

AWS service (AWS-Service) und dann Lambda für den Service, der diese Rolle verwendet. WählenSie anschließend Next (Weiter) aus. Permissions (Berechtigungen)

26


https://console.aws.amazon.com/iam/home


5. Wählen Sie für Attach permissions policy (Berechtigungsrichtlinie anfügen) die OptionAWSLambdaBasicExecutionRole. Auf diese Weise erhält Lambda Schreibzugriff auf Ihre CloudWatch-Logs-Ressourcen. Wählen Sie anschließend Next (Weiter) aus. Prüfen

6. Geben Sie einen Namen für die Rolle ein, beispielsweise hello-lambda-role, ebenso wie eineBeschreibung. Anschließend wählen Sie Create role (Rolle erstellen), um die Erstellung der IAM-Rolleabzuschließen.

Erstellen eines Amazon S3-Buckets für Ihren Lambda-CodeAWS Lambda erfordert einen Amazon S3-Bucket, in dem Ihr Java-Projekt gespeichert wird, wenn Sie eshochladen. Sie können entweder einen Bucket verwenden, der bereits in der AWS-Region vorhanden ist, inder Sie den Code ausführen, oder einen neuen Bucket speziell für die Verwendung durch Lambda erstellen(empfohlen).

Sie können einen Amazon S3-Bucket auf zweierlei Arten erstellen, entweder über die AWS ManagementConsole oder über AWS Toolkit for Eclipse. In diesem Abschnitt wird beschrieben, wie Sie einen AmazonS3-Bucket mit der Konsole erstellen. Weitere Informationen zum Erstellen mit AWS Toolkit for Eclipsefinden Sie unter Hochladen des Codes (p. 27).

So erstellen Sie einen Amazon S3-Bucket für die Verwendung mit Lambda:

1. Melden Sie sich bei der AWS-Managementkonsole an.2. Öffnen Sie im Menü Services die S3 console (S3-Konsole).3. Wählen Sie Create Bucket (Bucket erstellen) aus.4. Geben Sie einen Namen für den Bucket ein, und wählen Sie eine Region für Ihren Bucket aus. Sie

sollten dieselbe Region wählen, in der Sie auch Ihre Lambda Funktion ausführen möchten. Eine Listeder von Lambda unterstützten Regionen finden Sie unter Regionen und Endpunkte von AWS in derAmazon Web Services General Reference.

5. Wählen Sie Create (Erstellen), um die Erstellung Ihres Buckets abzuschließen.

Hochladen des CodesAls Nächstes laden Sie Ihren Code auf AWS Lambda hoch, um sein Aufrufen mit der AWS ManagementConsole vorzubereiten.

So laden Sie Ihre Funktion in Lambda hoch:

1. Klicken Sie mit der rechten Maustaste in Ihr Eclipse-Code-Fenster und wählen AWS Lambda und dannUpload function to AWS Lambda aus.

2. Wählen Sie auf der Seite Select Target Lambda Function die zu verwendende AWS-Region aus.Dabei sollte es sich um dieselbe Region handeln, die Sie auch für Ihren Amazon S3-Bucket (p. 27)gewählt haben.

27


https://console.aws.amazon.com/s3/home

https://docs.aws.amazon.com/general/latest/gr/rande.html#lambda_region


3. Wählen Sie Create a new Lambda function (Neue Lambda-Funktion erstellen) und geben Sie danneinen Namen für Ihre Funktion ein (z. B. HelloFunction).

4. Wählen Sie Next (weiter).5. Geben Sie auf der Seite Function Configuration (Funktionskonfiguration) eine Beschreibung für Ihre

Lambda-Zielfunktion ein und wählen Sie dann die IAM-Rolle und den Amazon S3-Bucket, die IhreFunktion verwendet.

28


Weitere Informationen zu den verfügbaren Optionen finden Sie unter Dialogfeld zum Hochladen derFunktion in AWS Lambda (p. 35).

6. Auf der Funktionskonfiguration Seite, wählen Sie Erstellen in Funktionsrolle wenn Sie eine neueIAM Rolle für Ihre Lambda Funktion. Geben Sie im Dialogfeld Create Role (Rolle erstellen) einenRollennamen ein.

29


7. Wählen Sie auf der Seite Function Configuration (Funktionskonfiguration) die Option Publish newversion (Neue Version veröffentlichen), wenn der Upload eine neue Version der Lambda-Funktionerstellen soll. Weitere Informationen zu Versioning und Aliasnamen in Lambda finden Sie unterFunktions-Versioning und Aliasse in AWS Lambda in der AWS Lambda Developer Guide.

8. Wenn Sie eine neue Version veröffentlichen möchten, wird die Option Provide an alias to this newversion (Alias für diese neue Version bereitstellen) aktiviert. Wählen Sie diese Option, wenn dieserVersion der Lambda-Funktion ein Alias zugeordnet werden soll.

9. Auf der Funktionskonfiguration Seite, wählen Sie Erstellen im S3 Bucket für Funktionscode wenn Sieeinen neuen Amazon S3 Eimer für Lambda Funktion. Geben Sie einen Bucket-Namen im DialogfeldCreate Bucket (Bucket erstellen) ein.

10. Im Abschnitt S3 Bucket for Function Code (S3-Bucket für Funktionscode) können Sie auch auswählen,ob der hochgeladene Code verschlüsselt werden soll. Behalten Sie in diesem Beispiel den Wert None(Keine) bei. Weitere Informationen über die Amazon S3-Verschlüsselung finden Sie unter Daten durchVerschlüsselung schützen im Amazon S3 Developer Guide.

11. Behalten Sie die Optionen in Advanced Settings (Erweiterte Einstellungen) unverändert bei. AWSToolkit for Eclipse wählt Standardwerte für Sie aus. Wählen Sie Finish (Beenden), um Ihre Lambda-Funktion in AWS hochzuladen.

30

https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html



Wenn das Hochladen erfolgreich war, wird der Name, den Sie für Ihre Lambda-Funktion ausgewählt haben,neben Ihrer Java-Handler-Klasse im Project Explorer (Projekt-Explorer) angezeigt:

Falls Sie den Namen nicht sehen, öffnen Sie die Ansicht Error Log (Fehlerprotokoll) in Eclipse. Lambdaschreibt Informationen über Fehler beim Hochladen oder beim Ausführen Ihrer Funktion in dasFehlerprotokoll, sodass Sie ein Debugging ausführen können.

Aufrufen der Lambda-FunktionSie können die Funktion jetzt in AWS Lambda aufrufen.

So rufen Sie Ihre Lambda-Funktion auf:

1. Klicken Sie mit der rechten Maustaste in Ihr Eclipse-Code-Fenster und wählen AWS Lambda und dannRun Function on AWS Lambda (Funktion in AWS Lambda ausführen) aus.

2. Wählen Sie die Handler-Klasse, die Sie aufrufen möchten.3. Geben Sie in das Eingabefeld eine gültige JSON-Zeichenfolge, z. B. "AWS Lambda", ein.

31


Note

Sie können Ihrem Projekt neue JSON-Eingabedateien hinzufügen, die dann in diesemDialogfeld angezeigt werden, wenn der Dateiname mit .json endet. Sie können diese Funktionverwenden, um Standard-Eingabedateien für Ihre Lambda Funktionen bereitzustellen.

4. Das Feld Show Live Log (Live-Protokoll anzeigen) ist standardmäßig markiert. Dies zeigt die Protokolleaus der Lambda-Funktionsausgabe in der Console (Konsole) von Eclipse an.

5. Wählen Sie Invoke (Aufrufen), damit Ihre Eingabedaten an die Lambda-Funktion gesendet werden.Wenn Sie alles richtig eingerichtet haben, sollten Sie den Rückgabewert der Funktion ausgedrucktin der Ansicht Console (Konsole) von Eclipse sehen (öffnet sich automatisch, wenn sie nicht bereitsangezeigt wird).

Glückwunsch, Sie haben soeben Ihre erste Lambda-Funktion direkt über die Eclipse IDE ausgeführt!

Nächste Schritte:Versuchen Sie, nachdem Sie Ihre Funktion hochgeladen und bereitgestellt haben, den Code zu ändern unddie Funktion erneut auszuführen. Lambda lädt die Funktion automatisch erneut hoch, ruft sie für Sie aufund druckt die Ausgabe in die Console (Konsole) von Eclipse.

32

AWS Toolkit for Eclipse BenutzerhandbuchAWS Lambda-Benutzeroberflächenreferenz

Weitere InfosWeitere Informationen zu den in diesem Tutorial beschriebenen Seiten sowie einevollständige Beschreibung der einzelnen Optionen finden Sie in der AWS Lambda-Benutzeroberflächenreferenz (p. 33).

Weitere Informationen über Lambda und das Schreiben von Java-Code für Lambda finden Sie unterErstellen von Lambda-Funktionen mit Eclipse-IDE und AWS-SDK-Plug-in (Java) im AWS LambdaDeveloper Guide.

AWS Lambda-BenutzeroberflächenreferenzDieser Abschnitt enthält detaillierte Informationen über die einzelnen Benutzeroberflächenelemente, dieEclipse vom AWS Toolkit for Eclipse für AWS Lambda hinzugefügt wurden.

Themen• Neu AWS Lambda Java-Projekt-Dialog (p. 33)• Funktion hochladen in AWS Lambda Dialogfeld (p. 35)• Lauf AWS Lambda Funktionsdialog (p. 39)

Neu AWS Lambda Java-Projekt-DialogIm Dialogfeld New Lambda Java Project (Neues Lambda Java-Projekt) können Sie ein neues Java-Projekterstellen und konfigurieren, mit dem Sie eine Lambda-Funktion erstellen können.

Öffnen des Dialogfelds

Das Dialogfeld New Lambda Java Project (Neues Lambda Java-Projekt) kann wie folgt geöffnet werden:

• Durch Öffnen des AWS-Menüs auf der Eclipse-Symbolleiste und Auswählen von New AWS LambdaJava project… (Neues AWS Lambda Java-Projekt…)

• Durch Auswählen von File (Datei) ‣ New (Neu) ‣ Other (Sonstiges) im Eclipse-Menü und von AWS ‣ AWSLambda Java Project (AWS Lambda Java-Projekt) im daraufhin angezeigten Dialogfeld

33

https://docs.aws.amazon.com/lambda/latest/dg/lambda-java-how-to-create-deployment-package.html


Benutzeroberfläche zum Erstellen von Projekten

Project name

Erforderlich Sie müssen einen Namen für Ihr Projekt angeben.Package name

Ein optionaler Name für das Java-Paket. Dies muss ein gültiger Java-Paketname sein, z. B.„com.mycompany.myproject“. Wenn Sie den Paketnamen in das Texteingabefeld eingeben, wird er imFenster Source Preview (Quellenvorschau) hinzugefügt.

Standard: Keine, dieser Parameter ist optional.Class name

Erforderlich Der Name zur Identifikation der Java-Klasse mit Ihrem Lambda-Code. Dies muss eingültiger Java-Klassenname sein. Der Standardwert ist generisch. Sie können hier einen eigenenNamen angeben oder den Package name (Paketnamen) ändern, um Konflikte mit ähnlichenKlassennamen zu vermeiden.

Standard: Lambdafunktionhandler

34


Input type

Erforderlich Der Typ der Eingabedaten, der zum Aufrufen Ihrer Lambda-Funktion verwendet wird. Siekönnen eine Kategorie in der Dropdown-Liste auswählen:• S3-Ereignis: empfängt ein Ereignis vom Amazon S3-Ereignis.• SNS-Ereignis: empfängt ein Ereignis von Amazon SNS.• Kinesis-Ereignis: empfängt ein Ereignis aus einem Amazon Kinesis-Stream.• Cognito-Ereignis: empfängt ein Ereignis von Amazon Cognito.• Benutzerdefiniert– erhält ein Ereignis aus dem benutzerdefinierten Code. Wenn Sie den Eingabetyp

Benutzerdefiniert festlegen, können Sie neben dem Feld für die Typauswahl auch einen Namenfür den benutzerdefinierten Eingabetyp angeben. Standardmäßig wird der generische Typ Objektverwendet.

Important

Der benutzerdefinierte Eingabetyp muss ein gültiger Java-Klassenname sein. Er darfkein primitiver Typ wie int, float usw. sein. Sie können für diese Fälle die gepacktenStandardtypen von Java (Integer, Float, ...) verwenden.

Verwenden Sie den benutzerdefinierten Eingabetyp für die Einrichtung von Ereignisquellen wie denfolgenden:• Benutzeranwendungen• Mobilanwendungen• Die AWS Management Console• Der Befehl „invoke“ an der AWS-Befehlszeilenschnittstelle(CLI).

Standard: S3-EreignisOutput type

Der Ausgabetyp. Dieser muss ein gültiges Java-Objekt sein.

Standard: Objekt

Funktion hochladen in AWS Lambda DialogfeldDas Dialogfeld Upload Function to AWS Lambda (Funktion in AWS Lambda hochladen) erstellt eineLambda-Funktion und lädt Ihren Code hoch, der ausgeführt werden soll, wenn die Lambda-Funktionaufgerufen wird.

Starten des Dialogfelds

Es gibt zwei Möglichkeiten, das Dialogfeld Upload Function to AWS Lambda (Funktion in AWS Lambdahochladen) zu starten:

• Durch Öffnen des Kontextmenüs in der Ansicht Project Explorer (Projekt-Explorer) für Ihr AWS Lambda-Java-Projekt in Eclipse und Auswählen von Amazon Web Services > Upload function to AWS Lambda(Funktion in AWS Lambda hochladen)

• Durch Öffnen des Kontextmenüs im Code-Fenster für Ihre Java-Klasse und Auswählen von AWSLambda > Upload function to AWS Lambda (Funktion in AWS Lambda hochladen)

Das Dialogfeld Upload Function to AWS Lambda (Funktion in AWS Lambda hochladen) enthält zweiSeiten:

• Select Target Lambda Function (Zielfunktion in Lambda auswählen) (p. 36)

35

https://docs.aws.amazon.com/lambda/latest/dg/with-s3.html

https://docs.aws.amazon.com/sns/latest/dg/sns-lambda.html

https://docs.aws.amazon.com/lambda/latest/dg/with-kinesis.html

https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-events.html

https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html

https://docs.aws.amazon.com/lambda/latest/dg/with-on-demand-custom-android.html

https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html

https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html


• Funktionskonfiguration (p. 37)

Optionen für die Auswahl einer Lambda-Zielfunktion

Auswahl des Handlers

(Erforderlich) Die Handler-Klasse, die den Lambda-Funktionscode enthält, den Sie hochladenmöchten.

(Standard) Der zuletzt hochgeladene Handler oder der erste, der gefunden wird, falls zuvor keinerhochgeladen wurde.

Auswählen der AWS-Region

(Erforderlich) Die Region, in der Sie Ihre Lambda Funktion erstellen möchten.

(Standard) Die AWS Management Console-Standardregion für Ihr AWS-KontoAuswählen oder Erstellen einer Lambda-Funktion

(Erforderlich) Sie müssen auswählen, ob Sie eine vorhandene Lambda-Funktion aus der Dropdown-Liste verwenden oder eine neue erstellen möchten, indem Sie deren Namen eingeben.

(Standard) Create a new Lambda function (Neue Lambda-Funktion erstellen)

Wenn Sie Next (Weiter) wählen, wird die Seite Function Configuration (Funktionskonfiguration) geöffnet.

36


Optionen für die Funktionskonfiguration

Die Seite ist in fünf Abschnitte unterteilt, die jeweils über eigene Einstellungen verfügen.

Grundlegende Einstellungen

Dieser Abschnitt zeigt den Funktionsnamen und ermöglicht das Hinzufügen einer Beschreibung.

37


Name

(Unveränderlich) Der Name wird durch den auf der Seite Select Target Lambda Function (Zielfunktionin Lambda auswählen) ausgewählten Namen festgelegt. Sie können ihn nicht ändern, können aberBack (Zurück) wählen, um ihn auf der vorherigen Seite erneut einzugeben.

Description (Beschreibung)

(Optional) Eine Textbeschreibung der Funktion.

(Standard) Die Beschreibung ist leer.

Funktionsrolle

In diesem Abschnitt können Sie die IAM-Rolle auswählen, die auf die Funktion angewendet werden soll.Sie können mit der Schaltfläche Create (Erstellen) auch eine neue IAM-Rolle erstellen. Die IAM-Rolle, dieSie über AWS Toolkit for Eclipse erstellen, ist eine grundlegende Rolle, die Zugriff auf Amazon S3 bietet.Wenn Sie mehr Zugriff auf AWS-Ressourcen benötigen, müssen Sie Zugriff auf alle Services bereitstellen,die in der AWS Management Console verwendet werden.

IAM Role (IAM-Rolle)

(Erforderlich) Die Rolle, die Lambda bei der Ausführung Ihrer Funktion für den Zugriff auf Ihre AWS-Ressourcen verwendet.

(Standard) Die erste IAM-Rolle aus Ihrem AWS-Konto.

Funktions-Versioning und Aliase

In diesem Abschnitt können Sie eine neue Version Ihrer Lambda-Funktion veröffentlichen und einen Aliasfür die betreffende Version eingeben. Weitere Informationen zu Versioning und Aliasnamen in Lambdafinden Sie unter Funktions-Versioning und Aliasse in AWS Lambda in der AWS Lambda Developer Guide.

Eine neue Version veröffentlichen

(Standard) Nicht ausgewählt. Wenn Sie diese Option auswählen, wird eine neue Version der Lambda-Funktion erstellt, anstatt sie zu ersetzen.

Bereitstellung eines Alias für diese neue Version

(Standard) Nicht ausgewählt. Wenn Sie diese Option auswählen, können Sie einen neuen Aliaseingeben oder einen vorhandenen verwenden.

S3-Bucket für Funktionscode

In diesem Abschnitt können Sie einen Amazon S3-Bucket einrichten, der von Ihrer Lambda-Funktionverwendet wird. Sie können auch mit der Schaltfläche Create (Erstellen) einen neuen Bucket erstellen undEinstellungen für die Verschlüsselung Ihrer Lambda-Funktion beim Hochladen in Amazon S3 auswählen.

S3::Bucket

(Erforderlich) Ein Amazon S3-Bucket, den Ihr Funktionscode verwenden kann. Hier werden nurBuckets in derselben Region, in der Sie die Funktion ausführen, angezeigt.

(Standard) Die erste Bucket in der Liste oder den letzten Bucket, in den Sie Ihre Lambda Funktionhochgeladen haben.

Verschlüsselungseinstellung

(Standard) Nichts ausgewählt. Weitere Informationen über die Amazon S3-Verschlüsselung finden Sieunter Daten durch Verschlüsselung schützen im Amazon S3 Developer Guide.

38

https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html



Erweiterte Einstellungen

Dieser Abschnitt enthält Einstellungen, die Sie möglicherweise weniger häufig benötigen. Sie können Ihnenmehr Kontrolle über die Ausführungsumgebung Ihrer Funktion bieten als die Einstellungen im AbschnittFunction Execution (Funktionsausführung).

Arbeitsspeicher (MB)

(Erforderlich) Die Anzahl von Megabyte an verfügbarem Speicherplatz für die Lambda-Funktion.

(Standard) 512 MB.Timeout (s)

(Erforderlich) Das Timeout in Sekunden, nach dem die Funktion als fehlgeschlagen gilt, wenn sie dieAusführung beendet hat.

(Standard) 15 s

Lauf AWS Lambda FunktionsdialogDas Dialogfeld Run Lambda Function (Lambda-Funktion ausführen) ermöglicht das Aufrufen einer Lambda-Funktion direkt über die Eclipse-Benutzeroberfläche.

Öffnen des Dialogfelds

Das Dialogfeld Run Lambda Function (Lambda-Funktion ausführen) kann wie folgt geöffnet werden:

• Durch Öffnen des Kontextmenüs in der Ansicht Project Explorer (Projekt-Explorer) für Ihr AWS Lambda-Java-Projekt in Eclipse und Auswählen von Amazon Web Services > Run function on AWS Lambda(Funktion in AWS Lambda ausführen)

• Durch Öffnen des Kontextmenüs im Code-Fenster für Ihre Java-Klasse und Auswählen von AWSLambda > Run function on AWS Lambda (Funktion in AWS Lambda ausführen)

Das Dialogfeld für das Aufrufen von Funktionen wird wie folgt angezeigt:

39

AWS Toolkit for Eclipse BenutzerhandbuchDie AWS CloudFormation Schablonen-Editor

Options

Es gibt zwei Möglichkeiten, Daten für Ihre Funktion bereitzustellen. Eine der beiden ist erforderlich.

• Wählen Sie eine der JSON-Dateien als Eingabe aus: Wenn Sie .json-Dateien an Ihr Projekt angefügthaben, können Sie eine in der angezeigten Liste auswählen. Andernfalls ist diese Option deaktiviert.

• Oder geben Sie die JSON-Eingabe für Ihre Funktion ein– You can directly enter valid JSON input foryour function here. Der eingegebene Datentyp muss dem Eingabeparameter der Java-Methode in IhrerHandler-Klasse entsprechen.

Nachdem Sie eine Auswahl getroffen und Ihre Eingabedaten bereitgestellt haben, klicken Sie auf Finish(Beenden), um Ihre Lambda-Funktion aufzurufen, oder klicken Sie auf Cancel (Abbrechen), um dasDialogfeld ohne eine Ausführung zu schließen.

Die AWS CloudFormation Schablonen-EditorDas AWS Toolkit for Eclipse umfasst einen integrierten AWS CloudFormation-Vorlageneditor. Dieserunterstützt u. a.:

• Das Erstellen und Aktualisieren von Stacks direkt in der Eclipse IDE aus der aktuell bearbeiteten Vorlageheraus

• Eine JSON-Validierung soll sicherstellen, dass Ihre Vorlage den Regeln für JSON-Format und -Inhaltentspricht.

Themen• Hinzufügen und Zugreifen AWS CloudFormation Templates in Eclipse (p. 41)

40

AWS Toolkit for Eclipse BenutzerhandbuchHinzufügen und Zugreifen AWS

CloudFormation Templates in Eclipse

• Bereitstellung eines AWS CloudFormation Vorlage bei Eclipse (p. 43)• Aktualisieren AWS CloudFormation Vorlage bei Eclipse (p. 46)• Validierung AWS CloudFormation Vorlage bei Eclipse (p. 48)

Hinzufügen und Zugreifen AWS CloudFormationTemplates in EclipseSo fügen Sie Ihrem Eclipse-Projekt eine CloudFormation-Vorlage hinzu

1. Suchen Sie im Dateimanager Ihres Systems die Vorlage, die Sie dem Projekt hinzufügen möchten, undziehen Sie die Datei im Fenster Package Explorer in Ihr Projekt.

2. Wählen Sie aus, wie Sie die Datei Ihrem Projekt hinzufügen möchten, und klicken Sie auf OK.

41

AWS Toolkit for Eclipse BenutzerhandbuchHinzufügen und Zugreifen AWS

CloudFormation Templates in Eclipse

So greifen Sie in Ihrem Eclipse-Projekt auf eine CloudFormation-Vorlage zu

• Doppelklicken Sie im Package Explorer (Paket-Explorer) auf den Namen der Vorlage, um mit demBearbeiten der Datei zu beginnen.

Note

Dateien mit den Endungen .template oder .json werden automatisch im AWSCloudFormation-Vorlageneditor geöffnet. Wenn Ihre Datei nicht automatisch als eine AWS

42

AWS Toolkit for Eclipse BenutzerhandbuchBereitstellung eines AWS

CloudFormation Vorlage bei Eclipse

CloudFormation-Vorlage erkannt wird, können Sie den Editor auswählen, indem Sie imPackage Explorer (Paket-Explorer) mit der rechten Maustaste auf den Dateinamen klickenoder indem Sie mit der rechten Maustaste auf das Editor-Fenster mit der geladenen Dateiklicken und anschließend Open With (Öffnen mit) und dann CloudFormation Template Editor(CloudFormation-Vorlageneditor) auswählen.

Bereitstellung eines AWS CloudFormation Vorlage beiEclipse

Note

Nur Dateien, die auf .template enden, können mit der Eclipse IDE gestartet werden. Wenn IhreDatei mit einer anderen Erweiterung endet, wie z. B. .json, müssen Sie die Datei zunächst miteiner .template-Erweiterung umbenennen, um diese Funktion nutzen zu können.

So stellen Sie eine CloudFormation-Vorlage in Eclipse bereit:

1. Öffnen Sie Ihre AWS CloudFormation.template-Datei im AWS CloudFormation-Vorlageneditor(weitere Informationen hierzu finden Sie unter Hinzufügen von und Zugreifen auf AWS CloudFormation-Vorlagen in Eclipse (p. 41)), klicken Sie mit der rechten Maustaste auf die geöffnete Vorlage undwählen Sie im Kontextmenü Run on AWS (In AWS ausführen) und dann Create Stack (Stack erstellen)aus.

2. Geben Sie im Dialogfeld Create New CloudFormation Stack (Neuen CloudFormation-Stack erstellen)den Stacknamen in das Feld Stack Name (Stack-Name) ein. Ihre Vorlagendatei sollte automatisch imFeld Template File (Vorlagendatei) ausgewählt werden.

43



3. Wählen Sie beliebige der folgenden Optionen (oder keine) aus:

SNS Topic (SNS-Thema): –Wählen Sie ein vorhandenes SNS-Thema aus der Liste aus, umBenachrichtigungen über den Stackfortschritt zu erhalten, oder erstellen Sie ein neues Thema, indemSie eine E-Mail-Adresse in das Feld eingeben und auf Create New Topic (Neues Thema erstellen)klicken.

Creation Timeout (Erstellungs-Timeout): Wählen Sie aus, wie viel Zeit AWS CloudFormation für dieStack-Erstellung gewähren soll, bevor der Vorgang als fehlgeschlagen gilt (und rückgängig gemachtwird, außer, die Option Rollback on failure (Rollback bei Fehler) ist nicht markiert).

Rollback beim Fehler– Wenn Sie möchten, dass der Stapel beim Zurücksetzen zurückgefahren (löschen)ist, markieren Sie diese Option. Lassen Sie sie deaktiviert, wenn der Stack für Debugging-Zwecke aktivbleiben soll, auch wenn er nicht vollständig gestartet wurde.

4. Klicken Sie auf Next (Weiter), um mit der Eingabe von Parameterwerten fortzufahren.5. Wenn Ihr Stack Parameter aufweist, geben Sie als Nächstes Werte für diese ein. Für Parameter mit

einer vordefinierten Liste möglicher Antworten können Sie in der Liste einen Wert auswählen.

44



6. Klicken Sie auf Finish (Beenden), um Ihren Stack zu starten.

Während der Stack gestartet wird, können Sie seinen Status durch Doppelklicken auf den Stacknamenunter dem CloudFormation-Knoten in der AWS Explorer-Ansicht oder durch Rechtsklick auf denStacknamen und Auswählen von Open in Stack Editor (Im Stack-Editor öffnen) im Kontextmenü abrufen.

Note

Falls Sie den gestarteten Stack nicht in AWS Explorer sehen können, müssen Sie die Ansichtmöglicherweise manuell aktualisieren, indem Sie auf das Symbol Refresh AWS Explorer (AWSExplorer aktualisieren) oben in der AWS Explorer-Ansicht klicken.

45

AWS Toolkit for Eclipse BenutzerhandbuchAktualisieren AWS CloudFormation Vorlage bei Eclipse

Aktualisieren AWS CloudFormation Vorlage beiEclipseSo aktualisieren Sie eine CloudFormation-Vorlage in Eclipse

1. Öffnen Sie Ihre AWS CloudFormation.template-Datei im AWS CloudFormation-Vorlageneditor(weitere Informationen hierzu finden Sie unter Hinzufügen von und Zugreifen auf AWS CloudFormation-Vorlagen in Eclipse (p. 41)), klicken Sie mit der rechten Maustaste auf die geöffnete Vorlageund wählen Sie im Kontextmenü Run on AWS (In AWS ausführen) und dann Update Stack (Stackaktualisieren) aus.

2. Wählen Sie im Dialogfeld Update CloudFormation Stack (CloudFormation-Stack aktualisieren) IhrenStack-Namen im Feld Stack Name (Stack-Name) aus, sofern er nicht bereits automatisch ausgewähltwurde. Ihre Vorlagendatei sollte außerdem automatisch im Feld Template File (Vorlagendatei)ausgewählt werden.

46

AWS Toolkit for Eclipse BenutzerhandbuchAktualisieren AWS CloudFormation Vorlage bei Eclipse

3. Wählen Sie beliebige der folgenden Optionen (oder keine) aus:

SNS Topic (SNS-Thema): –Wählen Sie ein vorhandenes SNS-Thema aus der Liste aus, umBenachrichtigungen über den Stackfortschritt zu erhalten, oder erstellen Sie ein neues Thema, indemSie eine E-Mail-Adresse in das Feld eingeben und auf Create New Topic (Neues Thema erstellen)klicken.

Creation Timeout (Erstellungs-Timeout): Wählen Sie aus, wie viel Zeit AWS CloudFormation für dieStack-Erstellung gewähren soll, bevor der Vorgang als fehlgeschlagen gilt (und rückgängig gemachtwird, außer, die Option Rollback on failure (Rollback bei Fehler) ist nicht markiert).

Rollback beim Fehler– Wenn Sie möchten, dass der Stapel beim Zurücksetzen zurückgefahren (löschen)ist, markieren Sie diese Option. Lassen Sie sie deaktiviert, wenn der Stack für Debugging-Zwecke aktivbleiben soll, auch wenn er nicht vollständig gestartet wurde.

4. Klicken Sie auf Next (Weiter), um mit der Eingabe von Parameterwerten fortzufahren.5. Wenn Ihr Stack Parameter aufweist, geben Sie als Nächstes Werte für diese ein. Für Parameter mit

einer vordefinierten Liste möglicher Antworten können Sie in der Liste einen Wert auswählen.

47

AWS Toolkit for Eclipse BenutzerhandbuchValidierung AWS CloudFormation Vorlage bei Eclipse

6. Klicken Sie auf Finish (Beenden), um Ihren Stack zu aktualisieren.

Während der Stack aktualisiert wird, können Sie seinen Status durch Doppelklicken auf den Stack-Namenunter dem Knoten CloudFormation in der Ansicht im AWS Explorer oder durch Klicken mit der rechtenMaustaste auf den Stack-Namen und Auswählen von Open in Stack Editor (Im Stack-Editor öffnen) imKontextmenü abrufen.

Validierung AWS CloudFormation Vorlage bei EclipseSo validieren Sie eine CloudFormation-Vorlage in Eclipse:

48

AWS Toolkit for Eclipse BenutzerhandbuchVerwendung DynamoDB mit AWS Explorer

• Führen Sie eine der folgenden Aktionen durch:• Klicken Sie mit der rechten Maustaste auf den Vorlagenname in der Ansicht Package Explorer und

klicken Sie anschließend im Kontextmenü auf Validate (Validieren).

• Klicken Sie mit der rechten Maustaste auf die Vorlage, die Sie im Editorbereich bearbeiten und klickenSie im Kontextmenü auf Validate (Validieren).

Important

Ihre Vorlage wird ausschließlich für JSON correctness validiert, jedoch nicht für CloudFormationcorrectness (CloudFormation-Korrektheit). Bei einer auf diese Weise validierten Stackvorlagekönnen dennoch Fehler beim Starten oder Aktualisieren auftreten.

Verwendung DynamoDB mit AWS ExplorerAmazon DynamoDB ist ein schneller, hochgradig skalierbarer, hochverfügbarer, wirtschaftlicher,nicht relationaler Datenbank-Service. Mit DynamoDB werden Einschränkungen derDatenspeicherungsskalierbarkeit eliminiert, die Latenz niedrig gehalten und die Leistung ist vorhersehbar.Das AWS Toolkit for Eclipse verfügt über die Funktionalität für das Arbeiten mit DynamoDB in einemEntwicklungskontext. Weitere Informationen finden Sie auf der AWS-Website unter DynamoDB.

Im AWS Toolkit for Eclipse zeigt AWS Explorer alle mit dem aktiven AWS-Konto verknüpften DynamoDB-Tabellen an.

49

https://aws.amazon.com/dynamodb/

AWS Toolkit for Eclipse BenutzerhandbuchErstellen einer DynamoDB-Tabelle

Display Amazon DynamoDB tables in AWS Explorer.

Erstellen einer DynamoDB-TabelleMithilfe des AWS Toolkit for Eclipse können Sie eine neue DynamoDB-Tabelle erstellen.

So erstellen Sie eine neue Tabelle im AWS Explorer

1. Klicken Sie im AWS Explorer mit der rechten Maustaste auf Amazon DynamoDB und anschließendauf Create Table (Tabelle erstellen). Daraufhin öffnet sich der Assistent Create New DynamoDB Table(Erstellen einer neuen DynamoDB-Tabelle).

2. Geben Sie einen Tabellennamen in das Feld Table Name (Tabellenname) ein.3. Geben Sie ein primäres Hash-Schlüsselattribut in das Feld Hash key attribute (Hash-Schlüsselattribut)

ein und wählen Sie aus der Dropdown-Liste Hash key type (Hash-Schlüsseltyp) den Hash-Schlüsseltypaus. DynamoDB erstellt mit dem Primärschlüssel-Attribut einen ungeordneten Hash-Index und mitdem primären Schlüsselattribut einen optionalen sortierten Bereichsindex. Weitere Informationen zumprimären Hash-Schlüsselattribut finden Sie unter Partitions and Data Distribution (Partitionen undDatenverteilung) im Amazon DynamoDB Developer Guide.

4. Optional können Sie einen primären Bereichsschlüssel festlegen, indem Sie Use a range key(Bereichsschlüssel verwenden) auswählen. Geben Sie ein Bereichsschlüsselattribut in das Feld Rangekey attribute (Bereichsschlüsselattribut) ein und wählen Sie aus der Dropdown-Liste Range key type(Bereichsschlüsseltyp) einen Bereichsschlüsseltyp aus.

5. Geben Sie in das Feld Read capacity units (Lesekapazitätseinheiten) die Anzahl vonLesekapazitätseinheiten und in das Feld Write capacity units (Schreibkapazitätseinheiten) dieAnzahl der Schreibkapazitätseinheiten ein. Sie müssen mindestens 3 Lesekapazitätseinheiten und 5Schreibkapazitätseinheiten angeben. Weitere Informationen zu Lese- und Schreibkapazitätseinheitenfinden Sie unter Provisioned Throughput (Bereitgestellter Durchsatz) im Amazon DynamoDB DeveloperGuide.

6. Klicken Sie auf Finish (Beenden) um die Tabelle zu erstellen. Klicken Sie im AWS Explorer auf dieSchaltfläche zum Aktualisieren, damit die neue Tabelle in der Tabellenliste angezeigt wird.

50

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.Partitions.html

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.Partitions.html

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ProvisionedThroughput.html

AWS Toolkit for Eclipse BenutzerhandbuchAnzeigen einer DynamoDB-Tabelle als Raster

Creating a table

Anzeigen einer DynamoDB-Tabelle als RasterDoppelklicken Sie im AWS Explorer auf den Subknoten einer Ihrer DynamoDB-Tabellen, um diese alsRaster anzuzeigen. In der Rasteransicht können Sie die in der Tabelle gespeicherten Elemente, Attributeund Werte sehen. Jede Zeile entspricht einem Element in der Tabelle. Die Tabellenspalten entsprechenAttributen. Jede Zelle der Tabelle enthält die mit diesem Elementattribut verknüpften Werte.

Der Wert eines Attributs kann eine Zeichenfolge oder eine Zahl sein. Manche Attribute verfügen übereinen Wert, der aus einem Satz von Zeichenfolgen oder Zahlen besteht. Satzwerte werden als eine durchKomma getrennte Liste in eckigen Klammern angezeigt.

51

AWS Toolkit for Eclipse BenutzerhandbuchBearbeiten von Attributen und Werten

Amazon DynamoDB Grid View

Bearbeiten von Attributen und WertenDie Tabellen-Rasteransicht ist bearbeitbar. Sie können die Werte für das entsprechende Attribut einesElements bearbeiten, indem Sie auf eine Zelle doppelklicken. Bei Satzwertattributen können Sie aucheinzelne Werte des Satzes hinzufügen oder löschen.

Cell editing in Amazon DynamoDB Grid View

Anhand der Bearbeitungsbenutzeroberfläche können Sie nicht nur den Wert eines Attributs ändern,sondern – mit einigen Einschränkungen – auch das Format des Attributwerts. Beispielsweise kann einbeliebiger Zahlenwert in eine Zeichenfolge umgewandelt werden. Bei einem Zeichenfolgenwert, dessenInhalt eine Zahl ist, z. B. "125", haben Sie mit der Bearbeitungsbenutzeroberfläche die Möglichkeit,das Format des Werts von Zeichen in Zahlen umzuwandeln. Darüber hinaus können Sie mit dieserBenutzeroberfläche einen Einzelwert in einen Satzwert konvertieren. In der Regel können Sie jedoch keineUmwandlungen von einem Satzwert in eine Einzelwert vornehmen, ausgenommen, der Satzwert bestehtaus nur einem Element.

52

AWS Toolkit for Eclipse BenutzerhandbuchScannen einer DynamoDB-Tabelle

Editing set values in Amazon DynamoDB Grid View

Wenn Sie einen Satz von Werten bearbeiten, öffnet sich das Dialogfeld Edit Values (Werte bearbeiten).Klicken Sie nach dem Bearbeiten des Attributwerts auf Save set (Einstellungen speichern), um IhreÄnderungen zu bestätigen. Wenn Sie die Änderungen verwerfen möchten, klicken Sie auf Cancel(Abbrechen).

Nachdem Sie Ihre Änderungen bestätigt haben, wird der Attributwert rot angezeigt. Dies bedeutet, dassdas Attribut aktualisiert wurde, der neue Wert jedoch noch nicht in die Amazon DynamoDB-Datenbankgeschrieben wurde. Um Ihre Änderungen zurück in die DynamoDB zu schreiben, klicken Sie auf File(Datei) und anschließend auf Save (Speichern) oder drücken Sie die entsprechende Taste auf der Tastatur.Um Ihre Änderungen zu verwerfen, klicken Sie auf Scan Table (Tabelle scannen) und wenn Sie vom Toolkitgefragt werden, ob Sie die Änderungen vor dem Scannen speichern möchten, klicken Sie auf No (Nein).

Scannen einer DynamoDB-Tabelle

Scan button

Sie können Ihre DynamoDB-Tabellen mit dem Toolkit scannen. In einem Scan definieren Sie eineReihe von Kriterien und der Scan führt alle Elemente in der Tabelle auf, die den Kriterien entsprechen.Scans sind teure Operationen und sollten daher mit Vorsicht verwendet werden, um zu vermeiden, dassProduktionsdatenverkehr mit höherer Priorität in der Tabelle unterbrochen wird. Weitere Empfehlungen zursicheren Verwendung der Scan-Operation finden Sie im Amazon DynamoDB-Entwicklerhandbuch.

So führen Sie im AWS Explorer den Scan einer Amazon DynamoDB-Tabelle aus

1. Klicken Sie in der Rasteransicht auf Add scan condition (Scan-Bedingung hinzufügen). Daraufhin wirdeine Benutzeroberfläche angezeigt, mit der Sie eine neue Scan-Klausel bearbeiten können.

2. Geben Sie im Scan-Klauseleditor das Attribut an, mit dem eine Übereinstimmung abgeglichen werdensoll, wie diese Übereinstimmung sein soll (Beginnt mit, Enthält etc.), welchem Literalwert entsprochenwerden muss und ob es sich bei dem Wert um eine Zeichenfolge oder um Zahlen handelt.

3. Fügen Sie so viele Scan-Klauseln hinzu, wie für Ihre Suche erforderlich. In den Ergebnissen werden nurdie Elemente aufgeführt, die den Kriterien aller Scan-Klauseln entsprechen. Beachten Sie, dass bei demScan ein Vergleich unter Berücksichtigung der Groß- und Kleinschreibung durchgeführt wird, wenn mitZeichenfolgewerten abgeglichen wird.

53

AWS Toolkit for Eclipse BenutzerhandbuchStarten Sie eine Amazon EC2 Instanzvon einem Amazon Machine Image

4. Klicken Sie in der Schaltflächenleiste im oberen Bereich der Rasteransicht auf die grüneWiedergabeschaltfläche, um den Scan auszuführen.

Zum Entfernen einer Scan-Klausel klicken Sie auf das rote X links neben jeder Klausel.

Scan button

Um wieder die Tabellenansicht mit allen Elementen aufzurufen, doppelklicken Sie auf Amazon DynamoDBim AWS Explorer.

Paginierung von Scan-Ergebnissen

Am oberen Rand der Ansicht sehen Sie drei Schaltflächen.

Paginate and export buttons

Mit der zweiten Schaltfläche können Scan-Ergebnisse paginiert werden. Wenn Sie auf die Schaltflächeganz rechts klicken, werden die Ergebnisse des aktuellen Scans in eine CSV-Datei exportiert.

Starten Sie eine Amazon EC2 Instanz von einemAmazon Machine Image

Bevor Sie eine EC2 Instance starten, sollten Sie eine Sicherheitsgruppe erstellen, die den erforderlichenNetzwerkverkehr für Verbindungen von Ihrer Anwendung mit der Instance zulässt. Die Sicherheitsgruppesollte mindestens den Zugriff auf Port 22 erlauben, damit Sie per SSH eine Verbindung mit der EC2Instance herstellen können. Sie können auch ein Schlüsselpaar erstellen. Das Schlüsselpaar könnenSie aber auch beim Durchlaufen des Startassistenten erstellen. Schließlich sollten Sie sich auchüberlegen, welcher Instance-Typ für Ihre Anwendung geeignet ist. Der Preis für eine EC2 Instance ist fürleistungsstärkere Instance-Typen i. d. R. höher. Eine Liste der Instance-Typen sowie Preisinformationenfinden Sie auf der Seite EC2 Pricing.

54

https://aws.amazon.com/ec2/pricing/


So starten Sie eine Amazon EC2 Instance

1. Erweitern Sie im AWS Explorer den Knoten Amazon EC2. Klicken Sie mit der rechten Maustaste aufden Unterknoten Amazon Machine Images (AMIs) und wählen Sie Open EC2 AMIs View (EC2-AMIs-Ansicht öffnen) aus.

AMI configuration dialog box2. Konfigurieren Sie die Ansicht der AMIs so, dass das in diesem Beispiel verwendete AMI angezeigt

wird. Geben Sie im Filterfeld start ebs ein. Damit wird die Liste der AMIs gefiltert, sodass nurAMIs, deren Namen sowohl „start“ als auch „ebs“ enthalten, angezeigt werden.

Klicken Sie mit der rechten Maustaste auf das AMI amazon/getting-started-with-ebs und wählen Sie imKontextmenü Start aus.

Select the Getting Started with EBS AMI3. Konfigurieren Sie im Dialogfeld Launch EC2 Instance (EC2-Instance starten) das AMI für Ihre

Anwendung.

55


Anzahl der Hosts

Legen Sie diesen Wert auf die Anzahl der zu startenden EC2 Instances fest.Instance-Typ

Wählen Sie den Typ der zu startenden EC2 Instance aus. Eine Liste der Instance-Typen sowiePreisinformationen finden Sie auf der Seite EC2 Pricing.

Verfügbarkeitszone

Wählen Sie eine Availability Zone (AZ) aus, in der die Instance gestartet werden soll. BeachtenSie, dass nicht alle AZs in allen Regionen zur Verfügung stehen. Wenn die ausgewählte AZnicht verfügbar ist, gibt das Toolkit eine Meldung dazu aus, dass Sie eine andere AZ auswählenmüssen. Weitere Informationen zu AZs finden Sie in den Häufig gestellten Fragen zu Regionenund Availability Zones im Amazon EC2 User Guide for Linux Instances.

Schlüsselpaar

Ein Schlüsselpaar ist ein Satz von öffentlichen und privaten Verschlüsselungsschlüsseln, mitderen Hilfe Sie authentifiziert werden, wenn Sie per SSH eine Verbindung mit der EC2 Instanceherstellen. Wählen Sie ein Schlüsselpaar aus, für das Sie Zugriff auf den privaten Schlüsselhaben.

Sicherheitsgruppe

Die Sicherheitsgruppe steuert den Netzwerkverkehrstyp, den die EC2 Instance akzeptiert. WählenSie eine Sicherheitsgruppe aus, die eingehenden Datenverkehr an Port 22 zulässt, dem von SSHverwendeten Port, damit Sie eine Verbindung mit der EC2 Instance herstellen können. WeitereInformationen zum Erstellen von Sicherheitsgruppen mit dem Toolkit finden Sie unter Verwaltenvon Sicherheitsgruppen im AWS Explorer (p. 58).

Instance-Profil

Das Instance-Profil ist ein logischer Container für eine IAM-Rolle. Wenn Sie ein Instance-Profil auswählen, ordnen Sie der EC2 Instance die entsprechende IAM-Rolle zu. IAM-Rollenwerden anhand von Richtlinien konfiguriert, die den Zugriff auf bestimmte AWS-Servicesund Kontoressourcen regeln. Wenn eine EC2 Instance einer IAM-Rolle zugeordnet ist, wirdAnwendungssoftware, die auf der Instance ausgeführt wird, mit den durch die IAM-Rollefestgelegten Berechtigungen ausgeführt. Auf diese Weise kann Anwendungssoftware ausgeführtwerden, ohne dass eigene AWS-Anmeldeinformationen angegeben werden müssen. Die Softwarewird dadurch sicherer. Detaillierte Informationen zu IAM-Rollen finden Sie unter Arbeiten mitRollen im IAM User Guide.

User Data

Benutzerdaten sind Daten, die Sie für die auf Ihrer EC2 Instance ausgeführteAnwendungssoftware bereitstellen. Die Anwendungssoftware kann auf diese Daten über denInstance Meta Data Service (IMDS) zugreifen.

56

https://aws.amazon.com/ec2/pricing/

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html


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


Launching an AMI from AWS Explorer

57

AWS Toolkit for Eclipse BenutzerhandbuchVerwalten von Sicherheitsgruppen im AWS Explorer

4. Klicken Sie auf Finish (Beenden).5. Klicken Sie im AWS Explorer unter dem Knoten Amazon EC2 mit der rechten Maustaste auf den

Unterknoten Instances und wählen Sie Open EC2 Instances View (EC2-Instances-Ansicht aufrufen)aus.

Ihre EC2 Instance sollte in der Ansicht EC2 Instances angezeigt werden. Es kann einige Minutendauern, bis die Instance in den Ausführungsstatus wechselt. Sobald die Instance ausgeführt wird,können Sie mit der rechten Maustaste auf die Instance klicken, um ein Kontextmenü mit Vorgängenanzuzeigen, die Sie für die Instance ausführen können. Beispielsweise können Sie die Instance überdieses Menü beenden. Sie können auch die öffentliche DNS-Adresse der Instance kopieren. Mit dieserAdresse können Sie per SSH eine Verbindung mit der Instance herstellen.

List of Amazon EC2 instances

Verwalten von Sicherheitsgruppen im AWS ExplorerDas AWS Toolkit for Eclipse ermöglicht das Erstellen und Konfigurieren von Sicherheitsgruppen, die mitAmazon Elastic Compute Cloud-Instances (Amazon EC2) verwendet werden können. Wenn Sie eineAmazon EC2 Instance starten, müssen Sie eine zugeordnete Sicherheitsgruppe angeben.

Eine Sicherheitsgruppe ist wie eine Firewall für eingehenden Netzwerkverkehr. Mit der Sicherheitsgruppewird angegeben, welche Netzwerkverkehrstypen auf einer Amazon EC2 Instance empfangen werdendürfen. Sie können auch festlegen, dass nur eingehender Datenverkehr von bestimmten IP-Adressen odernur von angegebenen Sicherheitsgruppen akzeptiert wird.

Erstellen einer neuen SicherheitsgruppeIn diesem Abschnitt erstellen Sie eine neue Sicherheitsgruppe. Für die Sicherheitsgruppe sind direkt nachihrer Erstellung noch keine Berechtigungen konfiguriert. Das Konfigurieren von Berechtigungen erfolgt übereinen zusätzlichen Arbeitsschritt.

: Zum Erstellen einer neuen Sicherheitsgruppe.

1. Klicken Sie im AWS Explorer unter dem Knoten Amazon EC2 mit der rechten Maustaste auf SecurityGroups (Sicherheitsgruppen) und klicken Sie dann auf Open EC2 Security Groups View (EC2-Sicherheitsgruppenansicht öffnen).

58

AWS Toolkit for Eclipse BenutzerhandbuchHinzufügen von Berechtigungen zu einer Sicherheitsgruppe

2. Klicken Sie mit der rechten Maustaste in den linken Bereich der Registerkarte EC2 Security Groups(EC2-Sicherheitsgruppen) und klicken Sie dann auf New Group (Neue Gruppe).

3. Geben Sie im Dialogfeld einen Namen und eine Beschreibung für die neue Sicherheitsgruppe ein.Klicken Sie auf OK.

Hinzufügen von Berechtigungen zu einerSicherheitsgruppeIn diesem Abschnitt fügen Sie der neuen Sicherheitsgruppe Berechtigungen hinzu, damit andere Computereine Verbindung mit der Amazon EC2 Instance über das SSH-Protokoll (Secure Shell) herstellen können.

So fügen Sie einer Sicherheitsgruppe Berechtigungen hinzu

1. Klicken Sie mit der rechten Maustaste im rechten Bereich auf der Registerkarte EC2 Security Groups(EC2-Sicherheitsgruppen) und klicken Sie dann auf Add Permissions (Berechtigungen hinzufügen).

59

AWS Toolkit for Eclipse BenutzerhandbuchHinzufügen von Berechtigungen zu einer Sicherheitsgruppe

Invoke Add Permissions UI2. Wählen Sie im Dialogfeld Protocol, port and network (Protokoll, Port und Netzwerk) aus. Klicken TCP

aus der Protokoll Dropdown-Menü. Geben Sie 22 für Port or Port Range (Port oder Port-Bereich) ein.Port 22 ist der Standard-Port für SSH. Das Feld Network Mask (Netzwerkmaske) gibt die zulässigenQuell-IP-Adressen im CIDR-Format an. Der Standardwert lautet 0.0.0.0/0 und gibt an, dass dieSicherheitsgruppe TCP-Verbindungen an Port 22 (SSH) von allen externen IP-Adressen zulässt.

Sie können beispielsweise auch angeben, dass nur Verbindungen von Computern in Ihrem lokalenComputer-Subnetz zugelassen werden. In diesem Fall geben Sie die IP-Adresse Ihres lokalenComputers gefolgt von “/10“ an. Im Beispiel “xxx.xxx.xxx.xxx/10“ steht “xxx“ jeweils für die einzelnenOktett-Werte der IP-Adresse Ihres lokalen Computers.

Klicken Sie auf OK.

Sie können auch Berechtigungen für die Sicherheitsgruppe festlegen, indem Sie eine Benutzer-ID undeinen Sicherheitsgruppennamen angeben. In diesem Fall akzeptieren Amazon EC2-Instances in dieser

60

AWS Toolkit for Eclipse BenutzerhandbuchAnzeigen und Hinzufügen Amazon SNS Benachrichtigungen

Sicherheitsgruppe eingehenden Netzwerkverkehr von Amazon EC2-Instances in der angegebenenSicherheitsgruppe. Sie müssen auch die Benutzer-ID angeben, um den Sicherheitsgruppennameneindeutig zu machen. Die Namen von Sicherheitsgruppen müssen in AWS insgesamt nicht eindeutig sein.Weitere Informationen zu Sicherheitsgruppen finden Sie im Amazon EC2 User Guide for Linux Instancesunter Network and Security (Netzwerk und Sicherheit).

Anzeigen und Hinzufügen Amazon SNSBenachrichtigungen

Sie können das AWS Toolkit for Eclipse verwenden, um Amazon Simple Notification Service-Themen(Amazon SNS) in Zusammenhang mit Ihrer Anwendung aufzurufen. Amazon SNS ist ein Service, mit demIhre Anwendung im Falle von spezifizierten Ereignissen eine Benachrichtigung über ein Protokoll, wie z. B.E-Mail, senden kann. Weitere Informationen zu Amazon SNS finden Sie im Amazon SNS Developer Guide.

Anzeigen einer Amazon SNS-BenachrichtigungDas folgende Verfahren veranschaulicht, wie Sie eine Amazon SNS-Benachrichtigung ansehen können.

So sehen Sie eine Benachrichtigung an:

1. Klicken Sie im AWS Explorer auf das Dreieck links neben dem Amazon SNS-Knoten, um ihn zuerweitern und die enthaltenen Amazon SNS-Themen zu sehen.

2. Doppelklicken Sie auf dieses SNS-Thema, um eine Detailansicht im Eclipse-Editorbereich zu öffnen.In diesem Beispiel wird in der Spalte Subscription ARN (Abonnement-ARN) angegeben, dass für dasThema noch die Bestätigung aussteht. Amazon SNS fordert eine Bestätigung von der Person an, derenE-Mail-Adresse angegeben wurde, bevor E-Mail-Benachrichtigungen an diese Person gesendet werden.

61

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_Network_and_Security.html

https://docs.aws.amazon.com/sns/latest/dg/

AWS Toolkit for Eclipse BenutzerhandbuchHinzufügen einer Amazon SNS-Benachrichtigung

Hinzufügen einer Amazon SNS-BenachrichtigungÜber AWS Explorer können Sie neue Amazon SNS-Benachrichtigungen hinzufügen.

So fügen Sie eine neue Benachrichtigung hinzu:

1. Klicken Sie in AWS Explorer mit der rechten Maustaste auf Amazon SNS und dann auf Create NewTopic (Neues Thema erstellen). Geben Sie einen Namen für das neue Thema ein und klicken Sie aufOK.

2. Doppelklicken Sie auf das neue Thema, um die Detailansicht für das Thema anzuzeigen. Klicken Sie mitder rechten Maustaste auf den Bereich Abonnements und dann auf Create Subscription (Abonnementerstellen). Belassen Sie das Feld Subscription Protocol (Abonnement-Protokoll) als Email (plain text)(E-Mail (reiner Text)) und geben Sie eine E-Mail-Adresse für den Endpunkt ein. Klicken Sie auf OK. DieDetailansicht für die Benachrichtigung schließt jetzt dieses Abonnement mit ein.

62

AWS Toolkit for Eclipse BenutzerhandbuchVerbinden mit Amazon Relational

Database Service ( ( (Amazon RDS)

Select the notification protocol and endpoint.3. Um das Abonnement zu löschen, klicken Sie mit der rechten Maustaste in die Spalte Protokoll des

Abonnements und klicken dann auf Delete Subscription (Abonnement löschen).

Note

Nach der Erstellung des Abonnements wird eine E-Mail zur Verifizierung an die Person geschickt,deren E-Mail-Adresse im Abonnement-"Endpunkt" angegeben wurde. AWS sendet an diese E-Mail-Adresse ausschließlich Benachrichtigungen. Die E-Mail-Adresse wird von AWS oder vonAmazon.com für keine anderen Zwecke verwendet.

Verbinden mit Amazon Relational Database Service( ( (Amazon RDS)

In diesem Abschnitt verwenden wir das AWS Toolkit for Eclipse zum Herstellen einer Verbindung miteiner Datenbank-Instance auf Amazon Relational Database Service (Amazon RDS). Bevor Sie den untenbeschriebenen Prozess durchführen können, müssen Sie Ihrem AWS-Konto eine RDS-Datenbank-Instancezuordnen. Sie können eine Datenbank-Instance in RDS über die AWS Management Console erstellen.Wenn Sie eine Datenbank-Instance erstellen, legen Sie für den TCP-Port, den die Datenbank für denEmpfang von Verbindungen verwendet, einen Wert fest, auf den von Ihrem Standort aus zugegriffenwerden kann. Wenn Sie sich z. B. hinter einer Firewall befinden, wählen Sie einen TCP-Port aus, zu demIhre Firewall Verbindungen zulässt. Weitere Informationen finden Sie im Amazon RDS-Benutzerhandbuch.

1. Erweitern Sie im AWS Explorer den Knoten Amazon RDS. Es sollte eine Liste der Datenbank-Instancesangezeigt werden, die Ihrem AWS-Konto zugeordnet sind. Klicken Sie mit der rechten Maustaste aufeine dieser Instances und klicken Sie dann auf Connect (Verbinden).

63


https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/

AWS Toolkit for Eclipse BenutzerhandbuchVerbinden mit Amazon Relational

Database Service ( ( (Amazon RDS)

Connect in context menu in AWS Explorer2. Das AWS Toolkit for Eclipse zeigt ein Dialogfeld zur Authentifizierung an. Geben Sie das

Masterpasswort ein, das Sie beim Erstellen der Datenbank-Instance festgelegt haben. Klicken Sie aufFinish (Beenden).

Authenticate against the database instance3. Das AWS Toolkit for Eclipse stellt die Verbindung mit der Datenbank-Instance im Eclipse Data Source

Explorer her. Hier können Sie die Struktur und Daten in der Datenbank untersuchen.

64

AWS Toolkit for Eclipse BenutzerhandbuchIdentitäts- und Zugriffsverwaltung

Data Source Explorer

Identitäts- und ZugriffsverwaltungMit AWS Identity and Access Management (IAM) können Sie steuern, wer Zugriff auf Ihre AWS-Ressourcen hat und welche Aktionen möglich sind. Im AWS Explorer können Sie IAM-Benutzer, -Gruppenund -Rollen erstellen und verwalten. Sie können auch eine Passwortrichtlinie für Benutzer festlegen, mit derSie Passwortanforderungen angeben können, z. B. die Mindestlänge und ob Benutzer ihr eigenes Passwortändern dürfen.

Note

Es ist eine bewährte Methode, dass alle Benutzer – auch der Kontoinhaber – auf AWS-Ressourcen als IAM-Benutzer zugreifen. Auf diese Weise wird sichergestellt, dass bei einerKompromittierung die Anmeldeinformationen für einen der IAM-Benutzer widerrufen werdenkönnen, ohne dass die Root-Anmeldeinformationen für das Konto geändert werden müssen.

Informationen zu AWS Identity and AccessManagementAnstelle einer Freigabe des Passworts und der Anmeldeinformationen für Ihr Konto (Zugriffsschlüssel-IDund geheimer Zugriffsschlüssel) können Sie IAM-Benutzer erstellen, die jeweils über eigene Passwörterund Sicherheitsanmeldeinformationen verfügen können. Sie können dann den Benutzern Richtlinienzuweisen. In den Richtlinien geben Sie Berechtigungen an, die festlegen, welche Aktionen ein Benutzerdurchführen und auf welche Ressourcen er zugreifen darf.

Der Einfachheit halber weisen Sie Richtlinien nicht einzelnen Benutzern zu, sondern können IAM-Gruppenerstellen (z. B. Administratoren und Entwickler) und diesen Gruppen dann Richtlinien zuordnen und

65

AWS Toolkit for Eclipse BenutzerhandbuchErstellen eines &IAM;-Benutzers

Benutzer hinzufügen. Sie können auch Rollen erstellen, die Richtlinien mit Berechtigungen enthalten.Rollen können Services, Benutzern in anderen Konten und Benutzern ohne IAM-Identität zugewiesenwerden. Weitere Informationen zu IAM finden Sie im IAM-Benutzerhandbuch.

Erstellen eines &IAM;-BenutzersSie erstellen IAM-Benutzer, damit andere Personen in Ihrer Organisation eine eigene AWS-Identitätverwenden können. Sie können einem IAM-Benutzer Berechtigungen zuweisen, indem Sie eine IAM-Richtlinie für den Benutzer anfügen oder den Benutzer einer Gruppe zuweisen. IAM-Benutzer, die einerGruppe zugewiesen sind, erhalten alle Berechtigungen von den Richtlinien, die der Gruppe zugeordnetsind. Weitere Informationen finden Sie unter Create an IAM Group (Erstellen einer IAM-Gruppe) (p. 67)und Add an IAM User to an IAM Group (Hinzufügen eines IAM-Benutzers zu einer IAM-Gruppe) (p. 69).

Sie können über das Toolkit auch AWS-Anmeldeinformationen (Zugriffsschlüssel-ID und geheimenSchlüssel) für die IAM-Benutzer generieren. Weitere Informationen finden Sie unter Manage Credentials foran IAM User (Verwalten von Anmeldeinformationen eines IAM-Benutzers) (p. 70).

So erstellen Sie einen IAM-Benutzer

1. Erweitern Sie im AWS Explorer den Knoten AWS Identity and Access Management, klicken Sie mit derrechten Maustaste auf den Knoten Users (Benutzer) und wählen Sie dann Create New Users (NeuenBenutzer erstellen) aus.

2. Geben Sie im Dialogfeld Create New Users (Neuen Benutzer erstellen) bis zu fünf Namen für neueIAM-Benutzer ein und klicken Sie dann auf Finish (Beenden). Informationen zu Einschränkungenbei Namen für IAM-Benutzer finden Sie im IAM User Guide unter Limitations on IAM Entities(Einschränkungen für IAM-Entitäten).

66

https://docs.aws.amazon.com/IAM/latest/UserGuide/

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html

AWS Toolkit for Eclipse BenutzerhandbuchErstellen einer IAM-Gruppe

Informationen zum Hinzufügen eines Benutzers zu einer Gruppe finden Sie unter Add an IAM User to anIAM Group (Hinzufügen eines IAM-Benutzers zu einer IAM-Gruppe) (p. 69). Informationen zum Erstelleneiner Richtlinie und zum Zuweisen dieser zu einem Benutzer finden Sie unter Attach an IAM Policy to aUser, Group, or Role (Anfügen einer IAM-Richtlinie an Benutzer, Gruppen oder Rollen) (p. 77).

Erstellen einer IAM-GruppeSie können IAM-Benutzer Gruppen hinzufügen, um das Verwalten von Berechtigungen zu vereinfachen.Alle Berechtigungen, die der Gruppe zugewiesen werden, gelten dann für alle Benutzer in dieser Gruppe.Weitere Informationen zu IAM-Gruppen finden Sie im IAM User Guide unter Working with IAM Users andGroups (Arbeiten mit IAM-Benutzern und -Gruppen).

Wenn Sie eine Gruppe erstellt haben, können Sie eine Richtlinie erstellen, die alle Berechtigungen enthält,die den Mitgliedern der Gruppe zugewiesen werden sollen.

So erstellen Sie eine IAM-Gruppe

1. Erweitern Sie im AWS Explorer den Knoten AWS Identity and Access Management, klicken Sie mit derrechten Maustaste auf den Knoten Groups (Gruppen) und wählen Sie dann Create New Group (NeueGruppe erstellen) aus.

67

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html


AWS Toolkit for Eclipse BenutzerhandbuchErstellen einer IAM-Gruppe

2. Geben Sie einen Namen für die neue IAM-Gruppe ein und klicken Sie dann auf Next (Weiter).

3. Geben Sie einen Namen für die Richtlinie ein, die festlegt, welche Aktionen Mitglieder der Gruppedurchführen dürfen. Geben Sie die Richtlinie als ein JSON-Dokument ein und klicken Sie dann auf OK.

Richtliniennamen müssen innerhalb Ihres Kontos eindeutig sein. Das JSON-Dokument, das Siefür die Richtlinie eingeben, muss überprüft werden, bevor die Richtlinie gespeichert werden kann.Informationen dazu, wie Sie eine Richtlinie erstellen, finden Sie im IAM User Guide unter Overview ofPolicies (Übersicht über Richtlinien).

4. Klicken Sie auf Finish (Beenden).

Informationen zum Anfügen zusätzlicher Richtlinien an eine IAM-Gruppe finden Sie unter Attachan IAM Policy to a User, Group, or Role (Anfügen einer IAM-Richtlinie an Benutzer, Gruppen oderRollen) (p. 77).

68

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html


AWS Toolkit for Eclipse BenutzerhandbuchHinzufügen eines IAM-Benutzers zu einer IAM-Gruppe

Hinzufügen eines IAM-Benutzers zu einer IAM-GruppeWenn einer Gruppe ein IAM-Benutzer hinzugefügt wird, gelten alle Richtlinien, die der Gruppe zugewiesensind, auch für den Benutzer. Weitere Informationen zu IAM-Benutzern finden Sie im IAM User Guide unterUsers and Groups (Benutzer und Gruppen).

So fügen Sie einen IAM-Benutzer einer IAM-Gruppe hinzu

1. Erweitern Sie im AWS Explorer den Knoten AWS Identity and Access Management, klicken Sie mitder rechten Maustaste auf den Knoten Groups (Gruppen) und wählen Sie dann Open Groups Editor(Gruppen-Editor öffnen) aus. Beachten Sie, dass Sie IAM-Gruppen die IAM-Benutzer aus dem KnotenGroups (Gruppen) im AWS Explorer hinzufügen – nicht aus dem Knoten Users (Benutzer).

2. Wählen Sie im Groups (Gruppen)-Editor die Gruppe aus, der Sie Benutzer hinzufügen möchten, undklicken Sie dann auf die Registerkarte Users (Benutzer).

3. Klicken Sie auf der rechten Seite im unteren Bereich auf die Schaltfläche Add Users (Benutzerhinzufügen).

4. Wählen Sie im Dialogfeld Add Users to Group (Benutzer zur Gruppe hinzufügen) die Benutzer aus, dieSie hinzufügen möchten, und klicken Sie dann auf OK.

69


AWS Toolkit for Eclipse BenutzerhandbuchVerwalten von Anmeldeinformationen

für einen IAM-Benutzer

Verwalten von Anmeldeinformationen für einen IAM-BenutzerSie können für jeden Benutzer ein Passwort hinzufügen. IAM-Benutzer verwenden ein Passwort, um in derAWS Management Console mit AWS-Ressourcen zu arbeiten.

So erstellen Sie ein Passwort für einen IAM-Benutzer

1. Erweitern Sie im AWS Explorer den Knoten AWS Identity and Access Management, klicken Sie mitder rechten Maustaste auf den Knoten Users (Benutzer) und wählen Sie dann Open Users Editor(Benutzer-Editor öffnen) aus.

2. Wählen Sie in der Benutzerliste den Benutzer aus, für den Sie ein Passwort erstellen möchten, undklicken Sie dann auf die Registerkarte Summary (Zusammenfassung).

3. Klicken Sie auf der rechten Seite im unteren Bereich auf die Schaltfläche Update Password (Passwortaktualisieren).

70



4. Geben Sie im Dialogfeld Update User Password (Benutzerpasswort aktualisieren) ein Passwort einund klicken Sie dann auf OK.

Note

Das neue Passwort überschreibt ein eventuell vorhandenes Passwort.

Sie können auch für jeden Benutzer eine Reihe von Zugriffsschlüsseln (eine Zugriffsschlüssel-ID undeinen geheimen Zugriffsschlüssel) generieren. Diese Schlüssel können verwendet werden, um denBenutzer beim programmgesteuerten Zugriff auf AWS zu identifizieren. Sie können so z. B. an der AWS-Befehlszeilenschnittstelle (CLI) programmgesteuerte Anforderungen mit dem SDK signieren oder über dasToolkit auf AWS-Services zugreifen. (Weitere Informationen zur Angabe von Anmeldeinformationen für dieVerwendung mit dem Toolkit finden Sie unter Einrichten der AWS-Anmeldeinformationen (p. 4).)

So generieren Sie Zugriffsschlüssel für einen IAM-Benutzer


2. Wählen Sie in der Benutzerliste den Benutzer aus, für den Sie Schlüssel generieren möchten, undklicken Sie dann auf die Registerkarte Summary (Zusammenfassung).

3. Klicken Sie auf die Schaltfläche Manage Access Keys (Zugriffsschlüssel verwalten).

71



Ein Fenster wird angezeigt, in dem Sie Zugriffsschlüssel für den Benutzer verwalten können.

4. Klicken Sie auf die Schaltfläche Create Access Key (Zugriffsschlüssel erstellen).

Das Dialogfeld Manage Access Key (Zugriffsschlüssel verwalten) wird angezeigt.

5. Klicken Sie auf die Schaltfläche Download (Herunterladen), um eine CSV-Datei mit den generiertenAnmeldeinformationen herunterzuladen.

Note

Dies ist die einzige Möglichkeit, um diese Zugriffsschlüssel anzuzeigen und herunterzuladen.Wenn Sie diese Schlüssel verlieren, müssen Sie sie löschen und einen neuen Satz vonZugriffsschlüsseln erstellen.

Sie können nur zwei Sätze von Anmeldeinformationen pro IAM-Benutzer generieren. Wenn Sie bereitszwei Sätze von Anmeldeinformationen generiert haben und einen weiteren erstellen möchten, müssen Siezunächst einen der vorhandenen Sätze löschen.

Sie können Anmeldeinformationen auch deaktivieren. In diesem Fall bleiben die Anmeldeinformationenerhalten, aber Anforderungen an AWS, die mit diesen Anmeldeinformationen durchgeführt werden,schlagen fehl. Dies ist nützlich, wenn Sie den Zugriff auf AWS für diesen Satz von Anmeldeinformationen

72

AWS Toolkit for Eclipse BenutzerhandbuchErstellen einer IAM-Rolle

vorübergehend deaktivieren möchten. Sie können Anmeldeinformationen, die zuvor deaktiviert wurden,wieder reaktivieren.

So löschen, deaktivieren oder reaktivieren Sie Zugriffsschlüssel für einen IAM-Benutzer


2. Wählen Sie in der Benutzerliste den Benutzer aus, dessen Zugriffsschlüssel Sie verwalten möchten,klicken Sie auf die Registerkarte Summary (Zusammenfassung) und dann auf die Schaltfläche ManageAccess Keys (Zugriffsschlüssel verwalten).

3. Klicken Sie im Fenster mit der Liste der Zugriffsschlüssel für diesen Benutzer mit der rechtenMaustaste auf die Anmeldeinformationen, die Sie verwalten möchten, und wählen Sie eine derfolgenden Aktionen aus:

• Delete Access Key (Zugriffsschlüssel löschen)• Make Inactive (Deaktivieren)• Make Active (Aktivieren)

Erstellen einer IAM-RolleSie können mit dem AWS Toolkit IAM-Rollen erstellen. Die Rolle kann dann Entitäten zugewiesen werden,denen Sie Zugriff auf Ihre AWS-Ressourcen gewähren möchten. Richtlinien, die Sie der Rolle hinzufügen,legen fest, wem die Rolle zugewiesen werden kann (die vertrauenswürdige Entität oder der Prinzipal) undwelche Aktionen diese Entitäten durchführen dürfen.

Sie können im Toolkit die folgenden vertrauenswürdigen Entitäten angeben:

• Einen AWS-Service. Sie können beispielsweise festlegen, dass eine Amazon EC2-Instance andereAWS-Services aufrufen kann oder dass AWS Data Pipeline Amazon EC2-Instances verwalten darf. Dieswird als eine Servicerolle bezeichnet.

• Ein anderes Konto, das Sie besitzen. Wenn Sie über mehrere AWS-Konten verfügen, können SieBenutzern in einem Konto eine Rolle zuweisen, damit sie die Berechtigungen für den Zugriff aufRessourcen in einem anderen Ihrer Konten erhalten.

• Ein Drittanbieter-Konto. Sie können einem Drittanbieter das Verwalten Ihrer AWS-Ressourcen erlauben.In diesem Fall können Sie eine Rolle erstellen, in der die vertrauenswürdige Entität das AWS-Konto desDrittanbieters ist.

73


Nachdem Sie festgelegt haben, wer die vertrauenswürdige Entität darstellt, können Sie eine Richtlinieangeben, die steuert, welche Aktionen die Rolle ausführen darf.

Sie könnten beispielsweise eine Rolle erstellen und dieser eine Richtlinie zuweisen, die den Zugriff auf IhreAmazon S3-Buckets beschränkt. Dann können Sie die Rolle einer Amazon EC2 Instance zuordnen. Wenneine Anwendung in einer Amazon EC2-Instance ausgeführt wird, kann sie nur auf den Amazon S3-Bucketzugreifen, für den Sie den Zugriff in der Richtlinie der Rolle zugelassen haben.

Weitere Informationen zu IAM-Rollen finden Sie unter IAM-Rollen im IAM User Guide.

So erstellen Sie eine IAM-Rolle

1. Erweitern Sie im AWS Explorer den Knoten AWS Identity and Access Management, klicken Sie mit derrechten Maustaste auf den Knoten Roles (Rollen) und wählen Sie dann Create New Role (Neue Rolleerstellen) aus.

2. Geben Sie einen Namen für die IAM-Rolle ein und klicken Sie dann auf Next (Weiter).

3. Wählen Sie die vertrauenswürdige Entität für die Rolle aus. Wählen Sie zum Erstellen einerServicerolle AWS Service Roles (AWS-Servicerollen) und dann eine Servicerolle in der Dropdown-Liste aus.

74



Um einem Benutzer, der in einem anderen Ihrer AWS-Konten definiert ist, den Zugriff zu gewähren,wählen Sie Account ID (Konto-ID) aus und geben dann die AWS-Kontonummer des anderen Kontosein.

Um einem Drittanbieter-Konto Zugriff zu gewähren, wählen Sie Account ID (Konto-ID) aus undgeben dann die AWS-Kontonummer des Drittanbieters ein. Wenn der Drittanbieter eine externe IDbereitgestellt hat, geben Sie diese ebenfalls ein.

75

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html


4. Klicken Sie auf Next (Weiter).5. Geben Sie einen Namen für die Richtlinie ein, die festlegt, welche Aktionen die Rolle durchführen darf.

Geben Sie dann die Richtlinie als ein JSON-Dokument ein und klicken Sie auf OK.

76

AWS Toolkit for Eclipse BenutzerhandbuchAnfügen einer IAM-Richtlinie anBenutzer, Gruppen oder Rollen

Richtliniennamen müssen innerhalb Ihres Kontos eindeutig sein. Das JSON-Dokument, das Siefür die Richtlinie eingeben, muss überprüft werden, bevor die Richtlinie gespeichert werden kann.Informationen dazu, wie Sie eine Richtlinie erstellen, finden Sie im Handbuch zum Verwenden von IAMunter Overview of Policies.

6. Klicken Sie auf Finish (Beenden).

Die neue IAM-Rolle wird im Rollen-Editor angezeigt.

Beispiele, die verdeutlichen, wie der Zugriff auf AWS mithilfe der IAM-Rolle einer Amazon EC2-Instanceerfolgt, finden Sie im AWS SDK for Java Developer Guide unter Verwenden einer IAM-Rolle zum Erteilenvon Berechtigungen für Anwendungen, die auf Amazon EC2-Instances ausgeführt werden.

Anfügen einer IAM-Richtlinie an Benutzer, Gruppenoder RollenRichtlinien sind Dokumente, die Berechtigungen definieren. So kann beispielsweise eine Richtlinie, dieeinem Benutzer zugeordnet ist, angeben, welche AWS-Aktionen der Benutzer für welche Ressourcendurchführen darf. Wenn die Richtlinie einer Gruppe zugewiesen ist, gelten die Berechtigungen für dieBenutzer in der Gruppe. Wenn die Richtlinie einer Rolle zugewiesen ist, gelten die Berechtigungen für alleBenutzer, denen diese Rolle zugeordnet wird.

77


https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-roles.html

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-roles.html


Das Zuweisen einer Richtlinie zu Benutzern oder Gruppen ist ähnlich. Für Rollen können Sie eine Richtlinieanfügen, die festlegt, welche Aktionen die Rolle ausführen darf. In einem anderen Schritt können Siedie Richtlinie anfügen oder bearbeiten, die festlegt, wem die Rolle zugewiesen werden darf (also dieVerwaltung der Vertrauensstellung).

Note

Wenn Sie einem Benutzer, einer Gruppe oder einer Rolle eine Richtlinie zuweisen, können Siediese Vorgehensweise für das Zuweisen einer zusätzlichen Richtlinie verwenden. Wenn Sieeine vorhandene Richtlinie für einen Benutzer, eine Gruppe oder eine Rolle bearbeiten möchten,verwenden Sie die IAM-Konsole, Befehlszeilen-Tools oder API-Aufrufe.

So erstellen Sie eine IAM-Richtlinie für Benutzer, Gruppen oder Rollen

1. Erweitern Sie im AWS Explorer den Knoten AWS Identity and Access Management und doppelklickenSie dann auf den Knoten Groups (Gruppen), den Knoten Users (Benutzer) oder den Knoten Roles(Rollen).

2. Wählen Sie die Gruppe, den Benutzer oder die Rolle aus, der oder dem Sie die Richtlinie zuweisenmöchten, und klicken Sie dann auf die Registerkarte Permissions (Berechtigungen).

3. Klicken Sie auf der rechten Seite im unteren Bereich auf die Schaltfläche Attach Policy (Richtlinieanfügen).

4. Geben Sie im Dialogfeld Manage Group Policy (Gruppenrichtlinie verwalten), Manage User Policy(Benutzerrichtlinie verwalten) oder Manage Role Permissions (Rollenberechtigungen verwalten) einenNamen für die Richtlinie ein. Geben Sie dann die Richtlinie als ein JSON-Dokument ein und klicken Sieauf OK.

78


Richtliniennamen müssen innerhalb Ihres Kontos eindeutig sein. Das JSON-Dokument, das Siefür die Richtlinie eingeben, muss überprüft werden, bevor die Richtlinie gespeichert werden kann.Informationen dazu, wie Sie eine Richtlinie erstellen, finden Sie im IAM User Guide unter Overview ofIAM Policies (Übersicht über IAM-Richtlinien).

So erstellen oder verwalten Sie eine Vertrauensstellung für eine Rolle

1. Erweitern Sie im AWS Explorer den Knoten AWS Identity and Access Management und doppelklickenSie dann auf den Knoten Roles (Rollen).

2. Wählen Sie im Rollen-Editor die Rolle aus, die Sie verwalten möchten, und klicken Sie dann auf dieRegisterkarte Trust Relationships (Vertrauensstellungen).

79



AWS Toolkit for Eclipse BenutzerhandbuchFestlegen von Passwortrichtlinien

3. Klicken Sie auf der rechten Seite im unteren Bereich auf die Schaltfläche Edit Trust Relationship(Vertrauensstellung bearbeiten).

4. Bearbeiten Sie im Dialogfeld Edit Trust Relationship (Vertrauensstellung bearbeiten) das JSON-Richtliniendokument und klicken Sie dann auf OK.

Festlegen von PasswortrichtlinienSie können im AWS Toolkit for Eclipse eine Passwortrichtlinie für Ihr Konto festlegen. Dadurch könnenSie sicherstellen, dass die für IAM-Benutzer erstellten Passwörter bestimmte Anforderungen an Längeund Komplexität erfüllen. Außerdem können Sie angeben, ob Benutzer ihre eigenen Passwörter änderndürfen. Weitere Informationen finden Sie im IAM User Guide unter Managing an IAM Password Policy(IAM-Passwortrichtlinien verwalten).

So erstellen Sie eine IAM-Richtlinie für einen Benutzer oder eine Gruppe

1. Doppelklicken Sie im AWS Explorer unter Identity and Access Management auf den Knoten PasswordPolicy (Passwortrichtlinien).

2. Geben Sie im Bereich Password Policy (Passwortrichtlinien) die Richtlinienoptionen für Ihr AWS-Kontoan und klicken Sie dann auf Apply Password Policy (Passwortrichtlinien anwenden).

80

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_passwords_account-policy.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_passwords_account-policy.html

AWS Toolkit for Eclipse BenutzerhandbuchDebuggen von serverlosen

Anwendungen mit AWS SAM Local

Debuggen von serverlosen Anwendungen mit AWSSAM Local

Dieses Tutorial führt Sie durch das Debugging einer serverlosen Anwendung mit AWS Toolkit for Eclipseunter Verwendung von AWS SAM Local. SAM Local ist das AWS CLI-Tool für die Verwaltung vonserverlosen Anwendungen, die mit dem AWS SAM (AWS Serverless Application Model) geschriebenwurden. Weitere Informationen finden Sie in der README von SAM Local.

PrerequisitesUm dieses Tutorial nutzen zu können, müssen Sie AWS Toolkit for Eclipse, Docker und AWS SAM Localinstalliert haben. Weitere Anweisungen zur Installation von Docker und SAM Local finden Sie in derREADME von AWS SAM Local. Weitere Anweisungen zur Installation und Einrichtung von AWS Toolkit forEclipse finden Sie unter Erste Schritte (p. 3).

Note

Um die AWS SAM Local-Funktion von AWS Toolkit for Eclipse nutzen zu können, muss Ihr Projektein gültiges Maven-Projekt mit einer gültigen pom.xml-Datei sein.

Nach der Installation der erforderlichen Tools öffnen Sie das Dialogfeld Preferences (Präferenzen) vonEclipse über das Menü Eclipse. Konfigurieren Sie den SAM Local Executable-Pfad wie gezeigt. Auf dieseWeise erkennt AWS Toolkit for Eclipse, wo Ihre SAM Local-Installation zu finden ist.

81

https://github.com/awslabs/aws-sam-local

https://github.com/awslabs/aws-sam-local#installation

AWS Toolkit for Eclipse BenutzerhandbuchImportieren der SAM-Anwendung von AWS CodeStar

Importieren der SAM-Anwendung von AWS CodeStarFür dieses Tutorial benötigen Sie eine Beispielprojekt AWS CodeStar. Wie Sie ein Beispielprojekt anlegen,sehen Sie im Tutorial Creating a Serverless Project in AWS CodeStar (Erstellen eines serverlosen Projektsin AWS CodeStar) im AWS CodeStar User Guide.

Importieren einer SAM-Anwendung aus AWS CodeStar

1. Öffnen Sie in der Eclipse-Symbolleiste das Dropdown-Menü für Amazon Web Services (durch dasAWS-Homepage-Symbol gekennzeichnet) und wählen Sie Import AWS CodeStar Project (AWSCodeStar-Projekt importieren) Oder wählen Sie in der Menüleiste von Eclipse die Optionen File (Datei),Import (Importieren), AWS, AWS CodeStar Project (AWS CodeStar-Projekt).

2. Wählen Sie die Region, in der die Beispielanwendung erstellt wurde.3. Wählen Sie Ihr Beispielprojekt aus der Liste Project Name (Projektname).4. Fügen Sie Ihre Git-Anmeldeinformationen hinzu. Weitere Informationen darüber, wie Sie Git-

Anmeldeinformationen für CodeCommit erhalten, finden Sie im AWS CodeCommit-Benutzerhandbuch.

82

https://docs.aws.amazon.com/codestar/latest/userguide/sam-tutorial.html#sam-tutorial-create-project

https://docs.aws.amazon.com/codestar/latest/userguide/sam-tutorial.html#sam-tutorial-create-project

https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-gc.html

AWS Toolkit for Eclipse BenutzerhandbuchLokales Debuggen der Lambda-Funktion

5. Wählen Sie Next (weiter).6. Wählen Sie Next auf der Seite Branch Selection.7. Wählen Sie Finish auf der Seite Local Destination.

Anschließend können Sie diese serverlose Anwendung lokal mit SAM Local in Eclipse debuggen.

Lokales Debuggen der Lambda-FunktionErstellen Sie eine Debug-Konfiguration für Ihre serverlose Anwendung und führen Sie die Anwendung lokalmit SAM Local aus.

83


So Debuggen Sie die Lambda-Funktion lokal

1. Öffnen Sie im Eclipse Project Explorer (Projekt-Explorer) die Datei HelloWorldHandler.java.2. Klicken Sie mit der rechten Maustaste auf die Option Debug As (Debuggen als) und wählen Sie dann

AWS SAM Local.

84


3. Verändern Sie für dieses Beispiel nicht die Werte für Project (Projekt) und Template (Vorlage).4. Wählen Sie Lambda Function im Feld Run as.5. Wählen Sie GetHelloWorld im Feld Function identifier (Funktionskennung).

85


6. In diesem Beispiel stellen wir ein Amazon S3-Ereignis bereit. Wählen Sie Generate (Generieren)neben dem Eingabefeld Event (Ereignis).

7. Wählen Sie eine Region, die Ihr Amazon S3-Bucket unterstützt8. Geben Sie einen gültigen Amazon S3-Bucket-Name ein.9. Geben Sie einen gültigen Amazon S3-Objektschlüssel ein und wählen Sie dann OK.10. Wählen Sie auf der Seite Save As (Speichern unter) das aktuelle Projekt aus und geben Sie einen

Namen für die Ereignisdatei ein. In diesem Beispiel haben wir s3-event.json verwendet.

86

AWS Toolkit for Eclipse BenutzerhandbuchAPI Gateway lokal testen

11. Wählen Sie OK, um die Ereignisdatei zu speichern und zum Hauptdialogfeld zurückzukehren.12. Behalten Sie die erweiterten Einstellungen unverändert bei. Weitere Informationen über diese Felder

finden Sie unter Advanced Settings (Erweiterte Einstellungen) (p. 89).13. Wählen Sie erst Apply (Anwenden) und anschließend Debug (Debuggen) aus.

Damit wird die Lambda-Funktion lokal ausgeführt. Sie können Haltepunkte setzen, um den Code zudebuggen, genau wie bei anderen Anwendungen.

API Gateway lokal testenDie HTTP-Funktionalität für Anforderungen/Antworten können Sie ebenfalls mit SAM Local testen.

Das API Gateway lokal testen

1. Klicken Sie mit der rechten Maustaste im Eclipse-Fenster auf Debug As (Debuggen als), DebugConfiguration (Debug-Konfiguration).

87

AWS Toolkit for Eclipse BenutzerhandbuchAPI Gateway lokal testen

2. Erstellen Sie eine neue Debug-Konfiguration für diese Ausführung und geben Sie ihr einen anderenNamen.

3. Wählen Sie API Gateway im Feld Run as (Ausführen als).4. Wenn Sie alle anderen Felder unverändert beibehalten, sollte die Konfiguration wie folgt aussehen.

5. Wählen Sie erst Apply (Anwenden) und anschließend Debug (Debuggen) aus.

88

AWS Toolkit for Eclipse BenutzerhandbuchErweiterte Einstellungen

Damit wird ein lokaler API Gateway gestartet, den Sie verwenden können, um Ihre Anwendung zu testen.Die Debug-Ausgabe enthält HTTP-Links, die verwendet werden können, um die HTTP-Anforderung/Antwort-Funktionen Ihres Codes zu überprüfen.

Erweiterte EinstellungenDieser Abschnitt beschreibt die erweiterten Optionen, die auf der Debug-Konfigurationsseite von SAMLocal zur Verfügung stehen.

89

AWS Toolkit for Eclipse BenutzerhandbuchErweiterte Einstellungen

AWS-KonfigurationEin Profil wählen

(Erforderlich) Das Profil für AWS-Anmeldeinformationen.

(Standard) Das StandardprofilRegion auswählen

(Erforderlich) Die Region, der die Anwendung bereitgestellt wird.

(Standard) USA Ost (Virginia)

SAM Local – KonfigurationMaven-Ziele

(Erforderlich) Maven-Ziele zur Ausführung bei der Erstellung der Anwendung. Sie müssen diese Zieleanpassen, wenn die Standard keine JAR-Datei mit allen Abhängigkeiten generiert (Fat Jar). WeitereInformationen zur Verwendung des Plugins zum Erstellen eines Fat-Jar finden Sie unter Maven Shade-Plugin.

(Standard) Paket reinigen

90

https://maven.apache.org/plugins/maven-shade-plugin/

https://maven.apache.org/plugins/maven-shade-plugin/

AWS Toolkit for Eclipse BenutzerhandbuchWeitere Infos

SAM-Laufzeitumgebung

(Erforderlich) Pfad zur SAM-Programmdatei.

(Standard) /usr/local/bin/samDebugging-Port

(Erforderlich) Port, den der Eclipse-Debugger verwendet, um eine Verbindung zu SAM Localeinzurichten.

(Standard) 5858Umgebungsvariablen

(Optional) Pfad zu einer JSON-Datei mit Werten für Umgebungsvariablen, die von Lambda-Funktionenverwendet werden. Weitere Informationen über die erforderliche Syntax für diese Datei finden Sie unterUmgebungsvariablendateien im SAM Local-Benutzerhandbuch.

(Standard) Leer

Lambda-FunktionskonfigurationCode-URI

(Optional) Pfad zur Code-Archivdatei. Für das Beispiel auf dieser Seite wäre dies der Pfad zur JAR-Datei.

(Standard) Pfad in der template.yml-DateiTimeout

(Erforderlich) Timeout der Laufzeitumgebung für die Lambda-Funktion.

Standard: 300

Weitere InfosWeitere Informationen über AWS SAM Local finden Sie im AWS SAM Local-Benutzerhandbuch in GitHub.Weitere Informationen über das AWS Serverless Application Model (SAM) finden Sie im AWS SAM-Projektin GitHub.

91

https://github.com/awslabs/aws-sam-local#environment-variable-file

https://github.com/awslabs/aws-sam-local

https://github.com/awslabs/serverless-application-model

AWS Toolkit for Eclipse BenutzerhandbuchAWS CodeCommit-Plugin — Eclipse konnte

nicht in den sicheren Speicher schreiben.

FehlerbehebungAWS CodeCommit-Plugin — Eclipse konnte nicht inden sicheren Speicher schreiben.

Problem: Beim Aus- oder Einchecken bei einem AWS CodeCommit-Repository erhalte ich dieFehlermeldung Writing to secure store failed, No password provided. (Schreiben in den sicheren Speicherfehlgeschlagen. Kein Passwort angegeben.).

Solution: Öffnen Präferenzen -> Allgemeines -> Sicherheit -> Sicherheitsspeicher -> Inhalt -> GIT ->Löschen.

92


DokumentverlaufDie folgende Tabelle enthält wichtige Änderungen seit der letzten Veröffentlichung des AWS Toolkit forEclipse User Guide.

API-Version 2010-12-01

Letzte Aktualisierung der Dokumentation: 28. Apr. 2020

01. Dezember 2016

Neuer Abschnitt mit Details über den neuen Assistenten für serverlose Projekte (p. 12) hinzugefügt.22. Dezember 2015

Thema Weitere Ressourcen wurde entfernt:—Die Informationen aus dieser Seite befinden sichjetzt auf der ersten Seite des Handbuchs unter der Überschrift Zusätzliche Dokumentation undRessourcen (p. 1).

22. Oktober 2015• Das Handbuch wurde von "Getting Started Guide" (Erste Schritte) in "User

Guide" (Benutzerhandbuch) umbenannt, da dieser Titel der Funktion des Handbuchs besser gerechtwird.

• Die Installationsanweisungen wurden aktualisiert und damit an Änderungen bei der Auswahl vonKomponenten des zu installierenden Toolkits angepasst.

16. Juni 2014

Das AWS Toolkit for Eclipse bietet nun Unterstützung für die Erstellung von AWS Lambda-Funktionenmit Java. Weitere Informationen finden Sie unter Verwenden von Lambda mit dem AWS Toolkit forEclipse (p. 23).

27. September 2013• Das AWS Toolkit for Eclipse verwendet nun dasselbe System für die Speicherung und den Zugriff

auf AWS-Anmeldeinformationen wie AWS CLI und AWS SDKs. Daher besteht jetzt auch dieMöglichkeit, verschiedene Profile zu verwenden, um mehr als einen Satz an Anmeldeinformationenzu speichern. Informationen finden Sie im neu aktualisierten Thema: AWS-Anmeldeinformationeneinrichten (p. 4).

• Das AWS Toolkit for Eclipse-Handbuch „Erste Schritte“ wurde iim Einklang mit der weiterenAWS-SDK-Dokumentation umstrukturiert (insbesondere mit dem AWS-SDK für Java, von demdas AWS Toolkit for Eclipse abhängt). Ein Großteil der Umstrukturierungen sind logisch undselbstverständlich. Sie finden jedoch eine Beschreibung der einzelnen Hauptabschnitte desHandbuchs unter Was ist das AWS Toolkit for Eclipse? (p. 1).

• Erste Schritte (p. 3) wurde für Eclipse 4.3 („Kepler“) aktualisiert.9. September 2013

In diesem Thema werden die neuesten Änderungen im AWS Toolkit for Eclipse User Guidebeschrieben. Es handelt sich um ein begleitendes Dokument zu release notes history (Verlauf derVersionshinweise).

93

https://aws.amazon.com/releasenotes/Eclipse/

https://aws.amazon.com/releasenotes/Eclipse/


Sofern wir eine Übersetzung der englischsprachigen Version des Handbuchs bereitstellen, gilt im Fall vonWidersprüchen die englischsprachige Version des Handbuchs. Bei der Übersetzung handelt es sich umeine maschinelle Übersetzung.

xciv

aws toolkit for eclipse - benutzerhandbuch...• eclipse ide for java developers 4.2 oder höher:...

Documents