AWS Toolkit for Eclipse - Benutzerhandbuch - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com

 
AWS Toolkit for Eclipse - Benutzerhandbuch - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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 - AWS Toolkit for Eclipse: Benutzerhandbuch - Amazon.com
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.

                                               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 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.

                                              7
AWS 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.

                                                    8
AWS 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.

                                              9
AWS 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).

                                                  10
AWS 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).

                                              11
AWS 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.

                                                  12
AWS 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.

                                                 13
AWS 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

                                                   14
AWS 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()

                                             15
AWS 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.

                                              16
AWS 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.

                                             17
AWS 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.

                                                 18
AWS 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)

                                                 19
AWS 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).

                                                20
AWS 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.

                                             21
AWS 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.

                                               22
AWS 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.

                                              23
AWS 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.

                                              24
AWS 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.

                                              25
AWS 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.

                                               26
Sie können auch lesen
NÄCHSTE FOLIEN ... Stornieren