AWS Toolkit for Eclipse - Benutzerhandbuch - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
AWS Toolkit for Eclipse
Benutzerhandbuch
AWS Toolkit for Eclipse: Benutzerhandbuch
Copyright © 2020 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 discredits Amazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to, or sponsored by Amazon.
AWS Toolkit for Eclipse Benutzerhandbuch
Table of Contents
Was ist AWS Toolkit for Eclipse? ......................................................................................................... 1
Zusätzliche Dokumentation und Ressourcen ................................................................................... 1
Erste Schritte ..................................................................................................................................... 3
Einrichten des Toolkits ............................................................................................................... 3
Voraussetzungen ................................................................................................................ 3
Installieren des AWS Toolkit for Eclipse ................................................................................. 3
Upgraden des AWS Toolkit for Eclipse .................................................................................. 4
Einrichten der AWS-Anmeldeinformationen .................................................................................... 4
Abrufen Ihrer AWS-Zugriffsschlüssel ...................................................................................... 4
Hinzufügen Ihres AWS-Zugriffsschlüssels zum AWS Toolkit for Eclipse ....................................... 5
Verwenden mehrerer AWS-Konten mit dem AWS Toolkit for Eclipse ........................................... 6
Ändern des Speicherorts der Datei mit den AWS-Anmeldeinformationen ...................................... 7
Zuordnen von privaten Schlüsseln zu Ihren Amazon Amazon EC2-Schlüsselpaaren ............................. 8
AWS Toolkit for Eclipse-Grundlagen ................................................................................................... 10
Erstellen einer AWS Java-Anwendung ........................................................................................ 10
Erstellen und Ausführen des Amazon Simple Queue Service-Beispiels ...................................... 10
Serverlose Projekte ................................................................................................................... 12
Erstellen eines serverlosen Projekts ..................................................................................... 12
Pläne für serverlose Projekte .............................................................................................. 13
Struktur serverloser Projekte ............................................................................................... 13
Bereitstellen eines serverlosen Projekts ................................................................................ 14
Weitere Informationen finden Sie auch unter: ........................................................................ 14
Differenzierung von AWS-Ressourcen mittels Benennung .............................................................. 14
Arbeiten mit AWS-Services ............................................................................................................... 18
Zugreifen auf AWS Explorer ...................................................................................................... 18
Verwenden von Lambda mit dem AWS Toolkit for Eclipse .............................................................. 19
Tutorial: Erstellen, Hochladen und Aufrufen einer AWS Lambda-Funktion .................................. 20
AWS Lambda-Benutzeroberflächenreferenz ......................................................................... 29
Der AWS CloudFormation-Vorlageneditor .................................................................................... 36
Hinzufügen von und Zugreifen auf AWS CloudFormation-Vorlagen in Eclipse ............................. 37
Bereitstellen einer AWS CloudFormation-Vorlage in Eclipse .................................................... 39
Aktualisieren einer AWS CloudFormation-Vorlage in Eclipse ................................................... 42
Validieren einer AWS CloudFormation-Vorlage in Eclipse ....................................................... 45
Verwenden von DynamoDB mit AWS Explorer ............................................................................. 45
Erstellen einer DynamoDB-Tabelle ...................................................................................... 46
Anzeigen einer DynamoDB-Tabelle als Raster ...................................................................... 46
Bearbeiten von Attributen und Werten .................................................................................. 46
Scannen einer DynamoDB-Tabelle ...................................................................................... 47
Starten einer Amazon EC2-Instance aus einem Amazon Machine Image .......................................... 48
Verwalten von Sicherheitsgruppen im AWS Explorer ..................................................................... 49
Erstellen einer neuen Sicherheitsgruppe ............................................................................... 49
Hinzufügen von Berechtigungen zu einer Sicherheitsgruppe .................................................... 50
Anzeigen und Hinzufügen von Amazon SNS-Benachrichtigungen .................................................... 51
Anzeigen einer Amazon SNS-Benachrichtigung ..................................................................... 51
Hinzufügen einer Amazon SNS-Benachrichtigung .................................................................. 52
Herstellen einer Verbindung zu Amazon Relational Database Service (Amazon RDS) ......................... 53
Identity and Access Management ............................................................................................... 54
Über AWS Identity and Access Management ........................................................................ 54
Erstellen eines IAM-Benutzers ............................................................................................ 54
Erstellen einer IAM-Gruppe ................................................................................................ 55
Hinzufügen eines IAM-Benutzers zu einer IAM-Gruppe ........................................................... 57
Verwalten von Anmeldeinformationen für einen IAM-Benutzer .................................................. 59
Erstellen einer IAM-Rolle .................................................................................................... 62
Anfügen einer IAM-Richtlinie an Benutzer, Gruppen oder Rollen ............................................... 65
iii
AWS Toolkit for Eclipse Benutzerhandbuch
Festlegen von Passwortrichtlinien ........................................................................................ 68
Debuggen von serverlosen Anwendungen mit AWS SAM Local ...................................................... 69
Voraussetzungen ................................................................................................................ 3
Importieren der SAM-Anwendung von AWS CodeStar ............................................................ 70
Lokales Debuggen der Lambda-Funktion .............................................................................. 71
API Gateway lokal testen ................................................................................................... 75
Erweiterte Einstellungen ..................................................................................................... 77
Weitere Infos .................................................................................................................... 29
Fehlerbehebung ................................................................................................................................ 80
AWS CodeCommit-Plugin — Eclipse konnte nicht in den sicheren Speicher schreiben. ......................... 80
Dokumentverlauf ............................................................................................................................... 81
iv
AWS Toolkit for Eclipse Benutzerhandbuch
Zusä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 Development
Environment, integrierte Entwicklungsumgebung), das es Entwicklern vereinfacht, Java-Anwendungen mit
Amazon Web Services zu entwickeln, zu debuggen und bereitzustellen. Es erweitert die Eclipse-IDE um
zusätzliche Funktionen:
• AWS SDK for Java ist in Maven enthalten und wird davon verwaltet, wenn Sie mit AWS Toolkit for
Eclipse ein neues AWS-Projekt erstellen.
• Der AWS Explorer ist eine Schnittstelle zu Amazon Web Services, mit der Sie Ihre AWS-Ressourcen
innerhalb 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 oder
Verwendung 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ällig werden. Mit
AWS Einfacher Monatsrechner können Sie die Kosten für die Verwendung verschiedener AWS-
Ressourcen abschätzen.
Zusätzliche Dokumentation und Ressourcen
Zusä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
AWS Toolkit for Eclipse Benutzerhandbuch
Zusätzliche Dokumentation und Ressourcen
• Using AWS Elastic Beanstalk with the AWS Toolkit for Eclipse (Verwenden des AWS Elastic Beanstalk
mit dem AWS Toolkit for Eclipse) (Video)
• AWS Toolkit for Eclipse: Amazon EC2 Management (Video)
2
AWS Toolkit for Eclipse Benutzerhandbuch
Einrichten des Toolkits
Erste Schritte
In 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 der AWS-Anmeldeinformationen (p. 4)
• Zuordnen von privaten Schlüsseln zu Ihren Amazon Amazon EC2-Schlüsselpaaren (p. 8)
Einrichten des Toolkits
In diesem Abschnitt wird das Installieren bzw. Upgraden des AWS Toolkit for Eclipse beschrieben.
Voraussetzungen
Folgende 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 Sie
auf die AWS-Homepage und klicken Sign Up Now (Jetzt registrieren). Wenn Sie sich registrieren, können
Sie alle von AWS angebotenen Services nutzen.
• Ein unterstütztes Betriebssystem: Das AWS Toolkit for Eclipse wird auf Windows, Linux, macOS, or Unix
unterstü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 die
Installation von Eclipse IDE for Enterprise Java Developers. Dazu gehören auch die für Elastic
Beanstalk erforderliche Eclipse Web Tools Platform, die für die Amazon SimpleDB-Funktionen
erforderliche Eclipse Data Tools Platform, Eclipse EGit und M2Eclipse. Wenn Sie eine
andere Version von Eclipse installieren, sollten Sie sich vergewissern, dass diese Funktionen
unterstützt werden (oder dass Sie Support für diese Funktionen anhand der bereitgestellten
Links installieren).
• (Optional) Google Android Development Tools (ADT): Wenn Sie möchten , dass AWS Toolkit for Eclipse
AWS Mobile SDK for Android (AWS Mobile SDK für Android) unterstützt, müssen Sie zunächst die ADT
installieren.
Installieren des AWS Toolkit for Eclipse
So 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
AWS Toolkit for Eclipse Benutzerhandbuch
Upgraden des AWS Toolkit for Eclipse
Note
• AWS Toolkit for Eclipse Core (AWS Toolkit für Eclipse Core) (im Abschnitt AWS Core
Management Tools (AWS Core-Verwaltungstools) ist obligatorisch. Alle anderen
Komponenten 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. Wenn
Sie 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 die
Eclipse Data Tools Platform (DTP) installiert sein. Die DTP wird standardmäßig mit der
Version „Java EE Developers“ von Eclipse installiert. Sie können sie jedoch auch separat
installieren.
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-Anmeldeinformationen
konfigurieren (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 Installation
abgeschlossen ist.
Upgraden des AWS Toolkit for Eclipse
Für Upgrades oder die erneute Installation des AWS Toolkit for Eclipse befolgen Sie dieselben
Anweisungen wie für das Installieren des Toolkits (p. 3).
Manche Versionen von Eclipse, insbesondere Mars und Neon, rufen aufgrund eines Fehlers in alten
Versionen des Oomph-Plug-Ins nicht die neuesten Artefakte ab. Gehen Sie wie folgt vor, um dieses
Problem zu umgehen:
1. Stellen Sie sicher, dass Sie https://aws.amazon.com/eclipse/site.xml als Website für die
Aktualisierung von AWS Toolkit for Eclipse verwenden.
2. Löschen Sie das ~/.eclipse/org.eclipse.oomph.p2/cache/-Verzeichnis, um
zwischengespeicherten Inhalt zu entfernen.
3. Installieren Sie die neueste Version von Oomph (Eclipse Installer).
Einrichten der AWS-Anmeldeinformationen
Für den Zugriff auf Amazon Web Services mit dem AWS Toolkit for Eclipse müssen Sie das AWS Toolkit
for Eclipse mit den Anmeldeinformationen für das AWS-Konto konfigurieren.
Abrufen Ihrer AWS-Zugriffsschlüssel
Zugriffsschlüssel bestehen aus einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel.
Diese werden zum Signieren der von Ihnen ausgeführten programmgesteuerten Anforderungen an
AWS 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 von
AWS-Stammkonto-Zugriffsschlüsseln. Mit IAM können Sie den Zugriff auf AWS-Services und -Ressourcen
in Ihrem AWS-Konto sicher steuern.
4
AWS Toolkit for Eclipse Benutzerhandbuch
Hinzufügen Ihres AWS-Zugriffsschlüssels
zum AWS Toolkit for Eclipse
Note
Um Zugriffsschlüssel zu erstellen, müssen Sie Berechtigungen zum Ausführen der erforderlichen
IAM-Aktionen besitzen. Weitere Informationen finden Sie im IAM User Guide im Abschnitt
zum Gewähren von Berechtigungen für IAM-Benutzer zur Verwaltung von Richtlinien und
Anmeldeinformationen.
So erhalten Sie Ihre Zugriffsschlüssel-ID und Ihren geheimen
Zugriffsschlüssel
1. Ö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 die
Schlüssel
an einem sicheren Ort.
Important
Behandeln Sie die Schlüssel vertraulich, um Ihr AWS-Konto zu schützen, und senden Sie sie
niemals per E-Mail. Geben Sie die Schlüssel nicht außerhalb Ihrer Organisation weiter, auch
nicht im Falle von Anfragen, die von AWS oder Amazon.com zu kommen scheinen. Niemand, der
Amazon 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 AWS
Toolkit for Eclipse
Das 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 Eclipse
IDE 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. Weitere
Informationen zum Festlegen des Speicherorts für diese Datei finden Sie unter Ändern des
Speicherorts der Datei mit den AWS-Anmeldeinformationen (p. 7).
Wenn Sie Ihre AWS-Anmeldeinformationen bereits mit der AWS-Befehlszeilenschnittstelle (CLI) festgelegt
haben, 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
AWS Toolkit for Eclipse Benutzerhandbuch
Verwenden 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 auf
AWS Toolkit.
2. Geben Sie Ihre AWS-Zugriffsschlüssel-ID im Feld Access Key ID (Zugriffsschlüssel-ID) ein oder fügen
Sie sie ein.
3. Geben Sie Ihren geheimen AWS-Zugriffsschlüssel im Feld Secret Access Key (Geheimer
Zugriffsschlüssel) ein oder fügen Sie ihn ein.
4. Klicken Sie auf Apply (Anwenden) oder OK, um die Informationen zu Ihren Zugriffsschlüsseln zu
speichern.
Ein Beispiel für einen konfigurierten Satz von Standardanmeldeinformationen:
Verwenden mehrerer AWS-Konten mit dem AWS
Toolkit for Eclipse
Sie 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ür
die Entwicklung und für die Freigabe/Veröffentlichung bereitzustellen.
Die getrennten Sätze von AWS-Anmeldeinformationen werden in der freigegebenen Datei mit den
AWS-Anmeldeinformationen, die in Hinzufügen Ihres AWS-Zugriffsschlüssels zum AWS Toolkit for
Eclipse (p. 5) beschrieben wird, als Profile gespeichert. Alle konfigurierten Profile werden in der
Dropdown-Liste oben auf dem Bildschirm „AWS Toolkit Preferences Global Configuration“ (AWS Toolkit-
Präferenzen für die globale Konfiguration) unter Default 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 Dialogfeld
Preferences (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 die
Informationen zu Ihrem Zugriffsschlüssel in die Felder Access Key ID (Zugriffsschlüssel-ID) und Secret
Access Key (Geheimer Zugriffsschlüssel) ein.
6AWS 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 zu
speichern.
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 der
Dropdown-Liste Default Profile (Standardprofil) aus. AWS Explorer zeigt die dem Standardkonto
zugeordneten 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. 14) 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 dem
das 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, in
der Ihre AWS-Anmeldeinformationen gespeichert werden sollen.
Important
Es wird ausdrücklich empfohlen, dass Sie Ihre AWS-Anmeldeinformationen nicht innerhalb eines
im Netzwerk freigegebenen Verzeichnisses oder in Projekten mit Quellcodeverwaltung speichern.
Wenden Sie immer strenge Sicherheitsregeln für Ihre AWS-Zugriffsschlüssel an.
7AWS Toolkit for Eclipse Benutzerhandbuch
Zuordnen von privaten Schlüsseln zu Ihren
Amazon Amazon EC2-Schlüsselpaaren
Zuordnen von privaten Schlüsseln zu Ihren Amazon
Amazon EC2-Schlüsselpaaren
Das AWS Toolkit for Eclipse kann Ihre Amazon EC2-Schlüsselpaare von AWS abrufen. Sie müssen jedoch
private 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 private
Schlüssel zu
1. Öffnen Sie das Dialogfeld Preferences (Präferenzen) von Eclipse und klicken Sie auf das Dreieck neben
AWS Toolkit in der Seitenleiste, um weitere Kategorien von AWS Toolkit for Eclipse-Einstellungen
anzuzeigen.
2. Wählen Sie Key Pairs (Schlüsselpaare) aus.
Eclipse zeigt eine scrollbare Liste Ihrer Schlüsselpaare an. Wenn ein Schlüsselpaar mit einem roten
X gekennzeichnet ist, müssen Sie dem Schlüsselpaar einen privaten Schlüssel zuordnen, um es zu
verwenden.
3. Klicken Sie mit der rechten Maustaste auf das Schlüsselpaar und wählen Sie im Kontextmenü Select
Private Key File (Private Schlüsseldatei auswählen) aus.
8AWS Toolkit for Eclipse Benutzerhandbuch
Zuordnen von privaten Schlüsseln zu Ihren
Amazon Amazon EC2-Schlüsselpaaren
4. Navigieren Sie zu der Datei mit dem privaten Schlüssel und wählen Sie diese aus, um sie Ihrem
Schlüsselpaar zuzuordnen.
9AWS Toolkit for Eclipse Benutzerhandbuch
Erstellen einer AWS Java-Anwendung
AWS Toolkit for Eclipse-Grundlagen
Dieser Abschnitt enthält Informationen zum Durchführen von häufigen Entwicklungsaufgaben mit dem AWS
Toolkit for Eclipse.
Themen
• Erstellen einer AWS Java-Anwendung (p. 10)
• Serverlose Projekte (p. 12)
• Differenzierung von AWS-Ressourcen mittels Benennung (p. 14)
Erstellen einer AWS Java-Anwendung
In 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 for
Eclipse AWS-Anwendungen in Java erstellen und ausführen können. Der mit dem AWS Toolkit for Eclipse
bereitgestellte 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 und
können sie auch unter GitHub aufrufen. Weitere Informationen über das AWS SDK for Java selbst
finden Sie im AWS SDK for Java-Entwicklerhandbuch.
Erstellen und Ausführen des Amazon Simple Queue
Service-Beispiels
So 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 ein
und wählen Sie Amazon Simple Queue Service Sample (Amazon Simple Queue Service-Beispiel).
10AWS Toolkit for Eclipse Benutzerhandbuch
Erstellen 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 Toggle
Breakpoint (Haltepunkt umschalten).
11AWS Toolkit for Eclipse Benutzerhandbuch
Serverlose Projekte
7. Klicken Sie mit der rechten Maustaste auf den Projektknoten in Project Explorer (Projekt-Explorer) – in
diesem 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-Anwendung
aus 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 AWS
Explorer 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 Sie F8. Die Java-Clientanwendung wird weiter ausgeführt und ordnungsgemäß beendet.
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 die
Anwendung geschlossen wird.
Note
Wenn Sie diese Beispielanwendung wiederholt ausführen, sollten Sie zwischen den einzelnen
Durchläufen mindestens 60 Sekunden warten. Amazon SQS erfordert, dass nach dem Löschen
einer Warteschlange mindestens 60 Sekunden verstreichen, bevor eine Warteschlange mit
demselben Namen erstellt wird.
Serverlose Projekte
Das AWS Toolkit for Eclipse umfasst einen Projekterstellungs-Assistenten, mit dem Sie schnell serverlose
Projekte konfigurieren und erstellen können, um diese auf AWS CloudFormation bereitzustellen und
Lambda-Funktionen als Reaktion auf RESTful-Webanforderungen auszuführen.
Erstellen eines serverlosen Projekts
So erstellen Sie ein serverloses Projekt
1. Wählen Sie das AWS-Symbol in der Symbolleiste und anschließend im angezeigten Menü New AWS
serverless project (Neues serverloses AWS-Projekt) aus.
2. Geben Sie in Project name (Projektname) einen Projektnamen ein.
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.
12AWS Toolkit for Eclipse Benutzerhandbuch
Pläne für serverlose Projekte
4. Wählen Sie Select a blueprint (Planauswahl) oder Select a serverless template file (Serverlose
Vorlagendatei auswählen) aus:
Auswählen eines Plans
Wählen Sie einen vordefinierten Projektplan (p. 13) 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 der
aktuellen Version der Spezifikation auf GitHub.
5. Klicken Sie auf die Schaltfläche Finish (Beenden), um Ihr neues serverloses Projekt zu erstellen.
Der Assistent für serverlose Projekte
Pläne für serverlose Projekte
Die 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-Tabelle
fü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. Die
Ausgabe ist Hello, value , wobei value die übergebene Zeichenfolge ist oder World, wenn keine
Zeichenfolge an die Funktion übergeben wurde.
Struktur serverloser Projekte
Der Assistent für serverlose Projekte erstellt ein neues Eclipse-Projekt für Sie, das die folgenden
Komponenten 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 definiert
werden.
mynamespace.model
Enthält allgemeine ServerlessInput- und ServerlessOutput-Klassen, die das Eingabe- und
Ausgabemodell für Ihre Lambda-Funktionen definieren.
Note
Weitere Informationen zu den verwendeten Eingabe- und Ausgabeformaten in den
Modellklassen finden Sie auf der Seite Einrichten der Proxy-Integration mit einer Proxy-
Ressource im API Gateway Developer Guide.
13AWS Toolkit for Eclipse Benutzerhandbuch
Bereitstellen eines serverlosen Projekts
• Die Datei serverless.template definiert die AWS-Ressourcen und Lambda-Funktionen (eine
Ressource vom Typ „AWS::Serverless:Function“) für Ihr Projekt.
Bereitstellen eines serverlosen Projekts
So stellen Sie das serverlose Projekt bereit
1. Wählen Sie Ihr Projekt in Eclipse im Fenster Project Explorer (Projekt-Explorer) aus und öffnen Sie das
Kontextmenü (rechte Maustaste oder langes Klicken).
2. Wählen Sie im Kontextmenü Amazon Web Services ‣ Deploy Serverless Project (Serverloses Projekt
bereitstellen) 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 Standort
des bereitgestellten AWS CloudFormation-Stacks.
4. Wählen Sie einen S3 Bucket (S3-Bucket) für die Speicherung Ihres Lambda-Funktionscodes oder die
Schaltfläche Create (Erstellen) aus, um einen neuen S3-Bucket für die Speicherung Ihres Codes zu
erstellen.
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.
Das Dialogfeld für die Bereitstellung serverloser Projekte
Bei der Bereitstellung Ihres Projekts wird ein Fenster mit den Details zum AWS CloudFormation-Stack
angezeigt, das Informationen zur Bereitstellung und zum aktuellen Status enthält. Zu Beginn wird als Status
CREATE_IN_PROGRESS angezeigt. Wenn der Status CREATE_COMPLETE lautet, ist die Bereitstellung aktiv.
Sie können dieses Fenster jederzeit öffnen. Wählen Sie dazu im AWS Explorer den Knoten AWS
CloudFormation 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ängig
gemacht werden. Weitere Informationen zur Diagnose von Fehlern bei der Stack-Bereitstellung
finden 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. 36)
• Verwenden von Lambda mit dem AWS Toolkit for Eclipse (p. 19)
Differenzierung von AWS-Ressourcen mittels
Benennung
Während der Entwicklung neuer Produkte und Funktionen ist es nützlich, AWS-Ressourcen, die für die
Entwicklung verwendet werden, von den Ressourcen für die Produktion zu trennen. Eine Möglichkeit
zum Aufrechterhalten dieser Trennung wurde unter Einrichten der AWS-Anmeldeinformationen (p. 4)
erläutert und besteht darin, unterschiedliche Konten für die Entwicklungs- und Produktionsressourcen zu
nutzen. Dieser Ansatz eignet sich besonders bei der Verwendung von AWS Explorer, da die Ressourcen
14AWS Toolkit for Eclipse Benutzerhandbuch
Differenzierung von AWS-Ressourcen mittels Benennung
im AWS Explorer basierend auf den Konto-Anmeldeinformationen angezeigt werden. In diesem Abschnitt
wird ein alternatives Verfahren beschrieben, bei dem eine Benennungskonvention für die Differenzierung
zwischen Entwicklungs- und Produktionsressourcen—verwendet wird und bei der der Support für die
Benennungskonvention 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 Zeichenfolgewert
hinzugefü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 Sie
Entwicklungscodes 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 ein
mühsamer und fehleranfälliger Vorgang. Effizienter wäre, Support für die Benennungskonvention im Code
hinzuzufügen.
Die StageUtils-Klasse stellt die folgende Methode bereit:
public static String getResourceSuffixForCurrentStage()
15AWS Toolkit for Eclipse Benutzerhandbuch
Differenzierung von AWS-Ressourcen mittels Benennung
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 getResourceSuffixForCurrentStage
in diesen Namen eingebettet wird.
private String getTopicName (Entry entry) {
return "entry" + StageUtils.getResourceSuffixForCurrentStage() + "-" + entry.getId();
}
Der von getResourceSuffixForCurrentStage zurückgegebene Wert wird von der Javasystem-
Eigenschaft "application.stage", abgerufen. Sie können diesen Wert festlegen, indem Sie die
Systemeigenschaft 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ührungsbereit
sein, damit Sie auf die Containerkonfiguration zugreifen können. Das Ändern und Speichern der
Konfiguration führt dazu, dass die Anwendung automatisch mit der geänderten Konfiguration neu
gestartet 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, dass
der Zeichenfolgewert "beta" sein soll.
-Dapplication.stage=beta
Beachten Sie, dass getResourceSuffixForCurrentStage automatisch jedem Zeichenfolgewert
einen Bindestrich voranstellt.
16AWS Toolkit for Eclipse Benutzerhandbuch
Differenzierung von AWS-Ressourcen mittels Benennung
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 Anwendung
sollte automatisch neu gestartet werden. Im unteren Bereich des Eclipse-Editors können Sie in der
Registerkarte Veranstaltungen überprüfen, ob die neue Konfiguration erfolgreich in der Umgebung
bereitgestellt wurde.
7. Erweitern Sie nach dem Neustart der Anwendung den Amazon SimpleDB-Knoten im AWS Explorer. Sie
sollten nun eine Reihe neuer Domänen sehen, die den Zeichenfolgewert verwenden, den Sie festgelegt
haben.
Note
Weitere Informationen über das Konfigurieren des Containers finden Sie unter Erstellen und
Bereitstellen von Java-Anwendungen in AWS Elastic Beanstalk im AWS Elastic Beanstalk
Developer Guide.
17AWS Toolkit for Eclipse Benutzerhandbuch
Zugreifen auf AWS Explorer
Arbeiten mit AWS-Services
Im AWS Explorer können Sie gleichzeitig mehrere Amazon Web Services anzeigen und bearbeiten. In
diesem Abschnitt finden Sie Informationen dazu, wie Sie in Eclipse auf die AWS Explorer-Ansicht zugreifen
und diese verwenden.
Es wird davon ausgegangen, dass Sie das AWS Toolkit for Eclipse bereits auf Ihrem System
installiert (p. 3) haben.
Themen
• Zugreifen auf AWS Explorer (p. 18)
• Verwenden von Lambda mit dem AWS Toolkit for Eclipse (p. 19)
• Der AWS CloudFormation-Vorlageneditor (p. 36)
• Verwenden von DynamoDB mit AWS Explorer (p. 45)
• Starten einer Amazon EC2-Instance aus einem Amazon Machine Image (p. 48)
• Verwalten von Sicherheitsgruppen im AWS Explorer (p. 49)
• Anzeigen und Hinzufügen von Amazon SNS-Benachrichtigungen (p. 51)
• Herstellen einer Verbindung zu Amazon Relational Database Service (Amazon RDS) (p. 53)
• Identity and Access Management (p. 54)
• Debuggen von serverlosen Anwendungen mit AWS SAM Local (p. 69)
Zugreifen auf AWS Explorer
Um den AWS Explorer anzuzeigen, klicken Sie in der Symbolleiste auf das AWS-Symbol und wählen Show
AWS Explorer View (AWS-Explorer-Ansicht anzeigen) aus.
Menü des AWS-Symbols
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). Klicken
Sie in der Liste der Eclipse-Perspektiven auf AWS Management.
Sie können jeden Knoten im AWS Explorer erweitern, um die Ihrem Konto zugeordneten Ressourcen in
AWS anzuzeigen. Wenn Sie beispielsweise auf das weiße Dreieck links neben dem Knoten Amazon EC2
klicken, werden die Amazon EC2;-Ressourcen, die mit Ihrem AWS-Konto verknüpft sind, erweitert und
angezeigt. Das AWS Toolkit for Eclipse ermittelt mithilfe des AWS-Kontos, das Sie unter Einrichten der
AWS-Anmeldeinformationen (p. 4) eingerichtet haben, welche Ressourcen angezeigt werden sollen.
18AWS Toolkit for Eclipse Benutzerhandbuch
Verwenden von Lambda mit dem AWS Toolkit for Eclipse
Wenn Sie Unterknoten von Amazon EC2 auswählen, öffnet Eclipse eine Ansicht mit ausführlichen
Informationen zu diesen Ressourcen. Wenn Sie beispielsweise auf Instances doppelklicken, wird eine
Ansicht 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 dem AWS Toolkit for
Eclipse
Das AWS Toolkit for Eclipse bietet Unterstützung für den Erstellungscode für AWS Lambda. Lambda
ist ein vollständig verwalteter Datenverarbeitungsservice, der Ihren Code beim Eintreten bestimmter
Ereignisse ausführt, die von einem benutzerdefiniertem Code oder von verschiedenen AWS-Services
wie z. B. Amazon S3, DynamoDB, Kinesis, Amazon SNS und Amazon Cognito erzeugt werden. Weitere
Informationen 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
• Tutorial: Erstellen, Hochladen und Aufrufen einer AWS Lambda-Funktion (p. 20)
• AWS Lambda-Benutzeroberflächenreferenz (p. 29)
19AWS Toolkit for Eclipse Benutzerhandbuch
Tutorial: Erstellen, Hochladen und
Aufrufen einer AWS Lambda-Funktion
Tutorial: Erstellen, Hochladen und Aufrufen einer AWS
Lambda-Funktion
Dieses Tutorial führt Sie durch einen typischen AWS Lambda-Workflow und bietet Ihnen aus erster Hand
Informationen 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, das
AWS Toolkit for Eclipse installiert haben (p. 3) und dass Sie die grundlegenden Konzepte und
Funktionen von Lambda kennen. Wenn Sie noch nicht mit Lambda vertraut sind, finden Sie auf der
Lambda-Homepage und im AWS Lambda-Entwicklerhandbuch weitere Informationen.
Erstellen eines AWS Lambda-Projekts
Fü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 neuen
Handler-Klasse hilft. Das Lambda-Projekt ist ein Maven-Projekt, das eine POM.xml-Datei verwendet, um
Paket-Abhängigkeiten zu verwalten. Sie können das Maven Befehlszeilen-Tool zum Erstellen, Testen
und 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 das
AWS-Homepage-Symbol gekennzeichnet) und wählen Sie New AWS Lambda Java project (Neues
AWS Lambda-Projekt) Oder wählen Sie in der Eclipse-Menüleiste File (Datei), New (Neu), AWS
Lambda Java Project (AWS Lambda Java-Projekt).
2. Tragen Sie einen Projektnamen, eine Gruppen-ID, eine Artefakt-ID und einen Klassennamen in die
entsprechenden 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 (Projektname): HelloLambda
• Group ID (Gruppen-ID): com.example.lambda
• Artifact ID (Artefakt-ID): demo
• Class name (Klassenname): Hello
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 Artifact
ID, wobei die Konventionen für Maven-Projekte eingehalten werden. Dieses Feld wird automatisch
aktualisiert, 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. Weitere
Informationen über die verfügbaren Eingabetypen finden Sie unter Dialogfeld „New AWS Lambda Java
Project“ (p. 29).
4. Vergewissern Sie sich, dass die Einträge den folgenden Screenshots entsprechen (und nehmen Sie
ggf. die erforderlichen Änderungen vor) und klicken Sie dann auf Finish (Beenden).
20AWS Toolkit for Eclipse Benutzerhandbuch
Tutorial: Erstellen, Hochladen und
Aufrufen einer AWS Lambda-Funktion
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 Quelldateien
in Ihrem Eclipse-Workspace erstellt. Ein neues Webbrowser-Fenster wird geöffnet und zeigt
README.html an (die für Sie im Root-Verzeichnis Ihres Projekts erstellt wurde). README.html
enthält Anweisungen, die Sie durch die nächsten Schritte beim Implementieren, Testen, Hochladen
und Aufrufen Ihrer neuen Lambda-Funktion führen. Lesen Sie die Datei erneut durch, um sich mit den
nächsten Schritten vertraut zu machen, die hier beschrieben werden.
21AWS Toolkit for Eclipse Benutzerhandbuch
Tutorial: Erstellen, Hochladen und
Aufrufen einer AWS Lambda-Funktion
Als Nächstes implementieren Sie die Funktion in dem HelloLambda-Javaprojekt, das gerade für Sie in
Eclipse erstellt wurde.
Implementieren der Handler-Methode
Im Dialogfeld Create New Project (Neues Projekt erstellen) erstellen Sie ein Projekt-Skelett. Jetzt tragen
Sie den Code ein, der ausgeführt wird, wenn Ihre Lambda-Funktion aufgerufen wird. (In diesem Fall von
einem benutzerdefinierten Ereignis, das eine Zeichenfolge an Ihre Funktion sendet, wie beim Festlegen der
Eingabeparameter Ihrer Methode angegeben.)
So implementieren Sie die Lambda-Handler-Methode
1. Öffnen Sie mit dem Project Explorer (Projekt-Explorer) von Eclipse Hello.java im Projekt
HelloLambda. 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 {
@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.
@Override
public String handleRequest(String input, Context context) {
context.getLogger().log("Input: " + input);
String output = "Hello, " + input + "!";
return output;
}
Lambda das Annehmen einer IAM-Rolle erlauben
Damit Lambda auf Ihre Lambda-Funktion zugreifen kann, müssen Sie eine IAM-Rolle erstellen, die
den 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 Abschnitt
wird beschrieben, wie Sie die IAM-Rolle mit der Konsole erstellen. Weitere Informationen zum Erstellen mit
AWS Toolkit for Eclipse finden Sie unter Hochladen des Codes (p. 23).
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ählen
Sie dann Next: Permissions aus.
22AWS Toolkit for Eclipse Benutzerhandbuch
Tutorial: Erstellen, Hochladen und
Aufrufen einer AWS Lambda-Funktion
5. Wählen Sie für Attach permissions policy (Berechtigungsrichtlinie anfügen) die Option
AWSLambdaBasicExecutionRole. Auf diese Weise erhält Lambda Schreibzugriff auf Ihre CloudWatch-
Logs-Ressourcen. Wählen Sie dann Next: Review aus.
6. Geben Sie einen Namen für die Rolle ein, beispielsweise hello-lambda-role, ebenso wie eine
Beschreibung. Anschließend wählen Sie Create role (Rolle erstellen), um die Erstellung der IAM-Rolle
abzuschließen.
Erstellen eines Amazon S3-Buckets für Ihren Lambda-Code
AWS Lambda erfordert einen Amazon S3-Bucket, in dem Ihr Java-Projekt gespeichert wird, wenn Sie es
hochladen. Sie können entweder einen Bucket verwenden, der bereits in der AWS-Region vorhanden ist, in
der 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 Management
Console oder über AWS Toolkit for Eclipse. In diesem Abschnitt wird beschrieben, wie Sie einen Amazon
S3-Bucket mit der Konsole erstellen. Weitere Informationen zum Erstellen mit AWS Toolkit for Eclipse
finden Sie unter Hochladen des Codes (p. 23).
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 Liste
der von Lambda unterstützten Regionen finden Sie unter Regionen und Endpunkte von AWS in der
Amazon Web Services General Reference.
5. Wählen Sie Create (Erstellen), um die Erstellung Ihres Buckets abzuschließen.
Hochladen des Codes
Als Nächstes laden Sie Ihren Code auf AWS Lambda hoch, um sein Aufrufen mit der AWS Management
Console 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 dann
Upload 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. 23)
gewählt haben.
23AWS Toolkit for Eclipse Benutzerhandbuch
Tutorial: Erstellen, Hochladen und
Aufrufen einer AWS Lambda-Funktion
3. Wählen Sie Create a new Lambda function (Neue Lambda-Funktion erstellen) und geben Sie dann
einen Namen für Ihre Funktion ein (z. B. HelloFunction).
4. Wählen Sie Next.
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 Ihre
Funktion verwendet.
24AWS Toolkit for Eclipse Benutzerhandbuch
Tutorial: Erstellen, Hochladen und
Aufrufen einer AWS Lambda-Funktion
Weitere Informationen zu den verfügbaren Optionen finden Sie unter Dialogfeld zum Hochladen der
Funktion in AWS Lambda (p. 31).
6. Wählen Sie auf der Seite Function Configuration (Funktionskonfiguration) unter Function Role
(Funktionsrolle) die Option Create (Erstellen), wenn Sie eine neue IAM-Rolle für Ihre Lambda-Funktion
erstellen möchten. Geben Sie im Dialogfeld Create Role (Rolle erstellen) einen Rollennamen ein.
25AWS Toolkit for Eclipse Benutzerhandbuch
Tutorial: Erstellen, Hochladen und
Aufrufen einer AWS Lambda-Funktion
7. Wählen Sie auf der Seite Function Configuration (Funktionskonfiguration) die Option Publish new
version (Neue Version veröffentlichen), wenn der Upload eine neue Version der Lambda-Funktion
erstellen soll. Weitere Informationen zu Versioning und Aliasnamen in Lambda finden Sie unter
Funktions-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 new
version (Alias für diese neue Version bereitstellen) aktiviert. Wählen Sie diese Option, wenn dieser
Version der Lambda-Funktion ein Alias zugeordnet werden soll.
9. Wählen Sie auf der Seite Function Configuration (Funktionskonfiguration) im Abschnitt S3 Bucket for
Function Code (S3-Bucket für Funktionscode) die Option Create (Erstellen), wenn Sie einen neuen
Amazon S3-Bucket für Ihre Lambda-Funktion erstellen möchten. Geben Sie einen Bucket-Namen im
Dialogfeld Create 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 durch
Verschlüsselung schützen im Amazon S3 Developer Guide.
11. Behalten Sie die Optionen in Advanced Settings (Erweiterte Einstellungen) unverändert bei. AWS
Toolkit for Eclipse wählt Standardwerte für Sie aus. Wählen Sie Finish (Beenden), um Ihre Lambda-
Funktion in AWS hochzuladen.
26Sie können auch lesen
