AWS Lambda mit Java startet jetzt

Wir werden ein schrittweises Beispiel für das Schreiben einer AWS Lambda-Funktion in Java8, das Hochladen als Lambda-Funktion in AWS und das Aufrufen von einem Java-Client vorstellen.

Angenommener Leser

Personen, die Java schreiben und AWS Lambda zum ersten Mal verwenden können ――Ich habe Lambda-Funktionen mit node.js erstellt, aber aus irgendeinem Grund versuche ich, es mit Java zu erstellen (= wie ich).

Artikelstruktur

TL; DR Ich werde im ersten Teil und im zweiten Teil schreiben

** [Teil 1] Einfach zu erstellende Lambda-Funktion (Cloud-Seite) und Client (lokale Seite) mit Java ** ← Dieser Artikel
[Teil 2] Synchroner Typ der Lambda-Funktion (Cloud-Seite), Aufruftyp des asynchronen Typs (Aufrufart), synchroner Java-Client, asynchroner Aufruf, Offenlegung auf dem API-Gateway

Was ist AWS Lambda?

――Es ist ein wunderbarer Dienst, der verschiedene Anforderungen (Ereignisse) verarbeiten kann, indem er den Code an AWS Lambda weitergibt, ohne den Server selbst erstellen und verwalten zu müssen.

http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/welcome.html 　https://aws.amazon.com/jp/lambda/faqs/

--Alexas Fähigkeiten ist ebenfalls AWS Lambda Sie können es mit erstellen.

Java und AWS Lambda

Es ist möglich, AWS Lambda-Verarbeitung (Lambda-Funktion) in Java zu schreiben
Es ist auch möglich, Lambda-Funktionen direkt von einem Java-Client aus aufzurufen
Nicht auf Java beschränkt, aber durch die Verknüpfung mit einem Dienst namens API Gateway können Sie einen Endpunkt in der Lambda-Funktion erstellen und veröffentlichen. Sie können ihn auch über HTTP (S) wie GET oder POST wie die Web-API aufrufen.

Inhaltsverzeichnis

Wir werden die folgenden Schritte nacheinander ausführen.

Code AWS Lambda funktioniert in Java
Erstellen Sie eine JAR-Datei zum Hochladen
Registrieren Sie die JAR-Datei bei AWS Lambda, um sie ausführbar (aufrufbar) zu machen.
Testen Sie auf der AWS-Konsole
Rufen Sie AWS Lambda-Funktionen von lokalem Java aus auf

1. Codieren Sie die AWS Lambda-Funktion

Laden Sie die Java-Bibliothek

aws-lambda-java-core Fügen Sie die Bibliothek hinzu. Fügen Sie bei Verwendung von maven die folgende Beschreibung hinzu

`maven`


<dependency>
	<groupId>com.amazonaws</groupId>
	<artifactId>aws-lambda-java-core</artifactId>
	<version>1.1.0</version>
</dependency>

Codieren Sie den Inhalt der Lambda-Funktion

Hier erstellen wir eine Lambda-Funktion vom Typ Request Response Type (Request Response), die beim Aufruf der Funktion ein Ergebnis zurückgibt.

Diesmal aws-lambda-java-core ** RequestHandler ** -Schnittstelle, die von der Bibliothek bereitgestellt wird Implementieren Sie eine Lambda-Funktion, die POJO eingeben und ausgeben kann.

Unten finden Sie eine Lambda-Beispielfunktion, die den vollständigen Namen druckt, wenn Sie den Nachnamen und den Vornamen eingeben.

`MyLambda.java`


package lambda.cloud;

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

import lambda.cloud.MyLambda.Input;
import lambda.cloud.MyLambda.Output;

public class MyLambda implements RequestHandler<Input, Output> {

  @Override
  public Output handleRequest(Input in, Context context) {

    final Output out = new Output();
    out.in = in;
    out.fullName = in.firstName + "_" + in.lastName;

    return out;
  }

  public static class Input {
    public String firstName;
    public String lastName;
  }

  public static class Output {
    public Input in;
    public String fullName;

  }

}

Implementieren Sie einfach die ** handleRequest ** -Methode wie unten gezeigt. Das Argument ** Eingabe ** ist die Anforderung und der Rückgabewert ** Ausgabe ** ist die Antwort.

 public Output handleRequest(Input in, Context context) {

2. Erstellen Sie eine JAR-Datei zum Hochladen

Um es mit AWS Lambda als Lambda-Funktion verwenden zu können, müssen Sie den Code in eine JAR-Datei (oder Zip) packen und auf AWS Lambda hochladen.

Zusätzlich zu dem soeben erstellten Code muss diese JAR-Datei die abhängigen Bibliotheken usw. integrieren.

Fügen Sie ** maven-shadow-plugin ** unter den Plugins in maven pom.xml hinzu, um eine einheitliche JAR-Datei (dh Fat JAR) zu erstellen.

	<plugin>
		<groupId>org.apache.maven.plugins</groupId>
		<artifactId>maven-shade-plugin</artifactId>
		<version>3.1.0</version>
		<configuration>
			<createDependencyReducedPom>false</createDependencyReducedPom>
		</configuration>
		<executions>
			<execution>
				<phase>package</phase>
				<goals>
					<goal>shade</goal>
				</goals>
			</execution>
		</executions>
	</plugin>

pom.xml

Die ganze pom.xml sieht so aus

`pom.xml`


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>lambda.cloud</groupId>
	<artifactId>mylambda</artifactId>
	<version>1.0.0</version>
	<packaging>jar</packaging>
	<name>AWS lambda example</name>
	<description>example of AWS lambda
	</description>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<dependency>
			<groupId>com.amazonaws</groupId>
			<artifactId>aws-lambda-java-core</artifactId>
			<version>1.1.0</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-shade-plugin</artifactId>
				<version>3.1.0</version>
				<configuration>
					<createDependencyReducedPom>false</createDependencyReducedPom>
				</configuration>
				<executions>
					<execution>
						<phase>package</phase>
						<goals>
							<goal>shade</goal>
						</goals>
					</execution>
				</executions>
			</plugin>

		</plugins>
	</build>

</project>

Quellcode herunterladen

Der vollständige Quellcode für das obige Beispiel ist unten https://github.com/riversun/aws_lambda_example_basic_client.git

** Beim Klonen mit Eclipse **

File>Import>Git>Projects from Git>Clone URI
** Geben Sie https://github.com/riversun/aws_lambda_example_basic_client.git an ** -Wählen Sie ** Import als allgemeines Projekt ** zum Importieren
Klicken Sie nach dem Importieren mit der rechten Maustaste auf das Projekt und führen Sie ** Konfigurieren> In Maven-Projekt konvertieren ** aus.

Jetzt, da Sie ein ** Maven-Projekt ** auf Eclipse haben, wird es einfacher zu handhaben sein.

Erstellen Sie mit maven ein Glas zum Hochladen

(1) ** Beim Erstellen eines Jars in der Befehlszeile **

Führen Sie den folgenden Befehl in dem Verzeichnis aus, das pom.xml enthält

mvn packgage

(2) ** Bei der Herstellung eines Glases auf Eclipse **

Schritt 1. Wählen Sie im Kontextmenü die Option ** Ausführen als> Maven-Build ** 　

Schritt 2. Geben Sie im Dialogfeld ** Konfigurationen bearbeiten ** in ** Ziele ** und ** Ausführen ** ** Schatten des Pakets ein: Schatten **. 　

In beiden Fällen (1) (2) wird ** mylambda-1.0.0.jar ** mit allen abhängigen Codebibliotheken unter ** / target ** generiert.

Dies ist die JAR-Datei für Ihren AWS Lambda-Upload.

3. Laden Sie die JAR-Datei hoch und registrieren Sie sie bei AWS Lambda

Schauen wir uns die Schritte zum Registrieren einer Lambda-Funktion über die AWS-Konsole an

** (1) Öffnen Sie AWS Lambda ** Öffnen Sie den Lambda-Dienst.

** (2) Erstellen Sie eine neue Lambda-Funktion ** Wenn Sie die Lambda-Funktion noch nicht erstellt haben, sieht der Bildschirm wie folgt aus.

Klicken Sie auf ** Funktion erstellen **.

** (3) [Von Grund auf neu erstellen] Lambda-Funktion **

Der Bildschirm zur Auswahl aus der Blaupausenliste wird wie folgt angezeigt. Wählen Sie ** Autor von Grund auf **.

** (4) Legen Sie den Namen und die Rolle auf dem Basisinformationsbildschirm fest **

Hier erstellen wir eine Lambda-Funktion mit dem Namen ** myFunction **.

--Name ist "** myFunction **"

Rolle ist "** Neue Rolle aus Vorlage erstellen " --Rollenname ist " myRole **"

Klicken Sie auf ** Funktion erstellen **, wenn Sie fertig sind

** (5) Laden Sie die JAR-Datei hoch **

STEP 1 Überprüfen Sie zunächst die ARN oben auf dem Bildschirm Notieren Sie sich den auf dem Bildschirm angezeigten Teil ** arn: aws: lambda: ap-northeast-1: 000000000000: function: myFunction **.

Wie Sie wissen, dient * ARN (Amazon Resource Name) zur eindeutigen Identifizierung von AWS-Ressourcen und wird zur Identifizierung dieser Ressourcen bei der Ausführung von Lambda-Funktionen verwendet. * *

STEP 2 Wählen Sie zur Laufzeit ** Java 8 ** aus

STEP 3 Geben Sie ** lambda.cloud.MyLambda ** in den Handler ein Der Handlername wird im Format ** Paketname.Klassenname :: Methodenname ** beschrieben. Gemäß dem zuvor erstellten Code lautet der Paketname ** lambda.cloud **, der Klassenname ** MyLambda ** und ** lambda.cloud.MyLambda **. In diesem Beispiel kann der Methodenname weggelassen werden.

STEP 4 Klicken Sie auf ** upload **, um das soeben erstellte ** mylambda-1.0.0.jar ** hochzuladen.

Ja, die zuvor erstellte Lambda-Funktion wurde bisher in AWS Lambda registriert.

4. Testen Sie auf der AWS-Konsole

Versuchen Sie nach dem Hochladen, über die Konsole zu testen.

** (1) Vorbereitung auf die Testveranstaltung **

Es gibt eine Idee, dass die Lambda-Funktion ** durch ein Ereignis ausgelöst wird. Sie können damit beispielsweise die durch das Ereignis ** ausgelöste Lambda-Funktion auslösen. ** Im S3-Bucket wird ein Objekt erstellt **.

Daher heißt der Eingang zum Ausführen der Lambda-Funktion ** event **.

Hier feuern Sie ** event ** von der Konsole ab und überprüfen die Funktion der Lambda-Funktion.

Wählen Sie oben auf dem Bildschirm ** Testereignisse konfigurieren **.

Anschließend wird der Bildschirm ** Testereignisse konfigurieren ** wie unten gezeigt geöffnet. Erstellen Sie hier ein Testereignis.

Sei ** Ereignisname ** ** MyEvent **, und das Bearbeitungsfeld darunter ist der Hauptteil, wenn die Lambda-Funktion angefordert wird.

In der Lambda-Funktion, die mit dem zuvor erstellten POJO eingegeben / ausgegeben wird, wird das POJO im tatsächlichen Aufruf automatisch JSON zugeordnet, und die Eingabe / Ausgabe erfolgt in JSON.

Geben Sie daher den Hauptteil des Ereignisses im JSON-Format wie unten gezeigt ein.

{
  "firstName": "john",
  "lastName": "doe"
}

Drücken Sie nach der Eingabe am unteren Bildschirmrand auf ** Erstellen **.

** (2) Durchführung des Testereignisses **

Führen Sie das soeben erstellte ** MyEvent ** sofort aus. Drücken Sie oben rechts auf dem Bildschirm auf ** Test **.

Übrigens ** "Die Lambda-Funktion" myFunction "kann nicht inline bearbeitet werden, da der im Handler angegebene Dateiname nicht mit dem Dateinamen des Bereitstellungspakets übereinstimmt. Machen Sie sich keine Sorgen, wenn die Meldung "**" angezeigt wird. Es ist in Ordnung. Die Lambda-Konsole bietet keine Inline-Editoren für vorkompilierte Sprachen wie Java und C #.

** (3) Überprüfen Sie das Ausführungsergebnis **

Nach längerem Drücken von ** Test ** wird der Ergebnisbildschirm angezeigt.

Bei Erfolg wird ** Ausführungsergebnis: erfolgreich ** angezeigt. Sie können die Details des Ergebnisses anzeigen, indem Sie ** ▼ Details ** darunter drücken, um es zu erweitern.

Die Ausgabe der Lambda-Funktion wird auch von der POJO ** Output ** -Klasse in den folgenden JSON konvertiert.

`POJO für Eingabe / Ausgabe`


public static class Input {
    public String firstName;
    public String lastName;
  }

  public static class Output {
    public Input in;
    public String fullName;

  }

`Ausführungsergebnis`


{
  "in": {
    "firstName": "john",
    "lastName": "doe"
  },
  "fullName": "john_doe"
}

5. Rufen Sie AWS Lambda-Funktionen von lokalem Java aus auf

Rufen Sie die zuvor aus einem Java-Programm erstellte Lambda-Funktion ** myFunction ** auf.

Laden Sie die Bibliothek

Wenn Sie die AWS Lambda-Funktion von Java aus aktivieren möchten, fügen Sie die Bibliothek aws-java-sdk-lambda hinzu. Wenn Sie maven verwenden, fügen Sie Folgendes hinzu

`maven`


<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-lambda</artifactId>
    <version>1.11.210</version>
</dependency>

Java-Client

Der Code sieht folgendermaßen aus: (Verschiedene Einstellwerte sind Dummy)

`Java-Client`


public class ExampleLambdaClient {

  public static void main(String[] args) {
    ExampleLambdaClient client = new ExampleLambdaClient();
    client.invokeLambdaFunction();

  }

  private void invokeLambdaFunction() {

    final String AWS_ACCESS_KEY_ID = "ANMNRR35KPTR7PLB3C7D";
    final String AWS_SECRET_ACCESS_KEY = "UKA6EsKY25LJQBEpUvXyYkj8aWKEDnynEZigVPhz";

    AWSCredentials credentials = new BasicAWSCredentials(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY);

    // ARN
    String functionName = "arn:aws:lambda:ap-northeast-1:000000000000:function:myFunction";

    String inputJSON = "{\"firstName\":\"john\",\"lastName\": \"doe\"}";

    InvokeRequest lmbRequest = new InvokeRequest()
        .withFunctionName(functionName)
        .withPayload(inputJSON);

    lmbRequest.setInvocationType(InvocationType.RequestResponse);

    AWSLambda lambda = AWSLambdaClientBuilder.standard()
        .withRegion(Regions.AP_NORTHEAST_1)
        .withCredentials(new AWSStaticCredentialsProvider(credentials)).build();

    InvokeResult lmbResult = lambda.invoke(lmbRequest);

    String resultJSON = new String(lmbResult.getPayload().array(), Charset.forName("UTF-8"));

    System.out.println(resultJSON);

  }
}

AWSCredentials credentials = new BasicAWSCredentials(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY);

--Erstellen Sie Anmeldeinformationen mit der Zugriffsschlüssel-ID (AWS_ACCESS_KEY_ID) und dem geheimen Zugriffsschlüssel (AWS_SECRET_ACCESS_KEY).

InvokeRequest lmbRequest = new InvokeRequest()
        .withFunctionName(functionName)
        .withPayload(inputJSON);

Generieren Sie eine Anfrage. ** # withFunctionName ** gibt den Funktionsnamen an. Geben Sie ARN (** arn: aws: lambda: ap-northeast-1: 000000000000: function: myFunction ) oder den Funktionsnamen ( myFunction **) an. Ich habe hier ** ARN ** angegeben
Geben Sie den Text (JSON) der Anforderung mit ** # withPayload ** an. Hier wird die JSON-Zeichenfolge ** "{" Vorname ":" John "," Nachname ":" Doe "}"; ** angegeben.

lmbRequest.setInvocationType(InvocationType.RequestResponse);

** Geben Sie die Aufrufart an ** Hier wird ** InvocationType.RequestResponse ** angegeben. Dies ist ein Aufruftyp vom Typ ** RequestResponse **. Wenn Sie RequestResponse festlegen, können Sie das Verarbeitungsergebnis erhalten.

InvokeResult lmbResult = lambda.invoke(lmbRequest);
String resultJSON = new String(lmbResult.getPayload().array(), Charset.forName("UTF-8"));

Rufen Sie die Lambda-Funktion auf und erhalten Sie das Ergebnis (JSON).

Java-Client-Quellcode

Der vollständige Quellcode auf der Client-Seite ist unten https://github.com/riversun/aws_lambda_example_basic_client.git

Zusammenfassung

Es war relativ einfach, AWS-Lambda-Funktionen in Java zu schreiben
Ich konnte die Lambda-Funktion direkt von einem Java-Client aus aufrufen

Die Probe wurde mit Eclipse (Oxygen) erstellt, es ist jedoch kein spezielles Plug-In erforderlich. (Sie benötigen nicht einmal das AWS SDK-Plugin für Eclipse, was es einfacher macht.)

Im zweiten Teil werde ich über Lambda-Funktionen und Java clientseitig synchron / asynchron und API Gateway schreiben.

Bonus

――Es war ungefähr 2009, aber ich war schockiert, als der ursprüngliche Dienst "** Google App Engine (GAE) **" mit der Aufschrift ** Ich schreibe nur den Code und überlasse ihn mir und bezahle nur für das, was ich benutze ** erscheint. Obwohl es viele besondere Einschränkungen gab, war es sehr hilfreich.

――Dieses Mal hat der ** Vorfahr!? ** ** Google Cloud-Funktionen ** eingeführt. Im Moment denke ich, dass β die Zukunft ist, aber es scheint, dass es in Zukunft eine Option sein wird.

AWS Lambda (Lambda) Teil 1 mit Java startet jetzt

AWS Lambda mit Java startet jetzt

Angenommener Leser

Artikelstruktur

Was ist AWS Lambda?

Java und AWS Lambda

Inhaltsverzeichnis

1. Codieren Sie die AWS Lambda-Funktion

Laden Sie die Java-Bibliothek

maven

Codieren Sie den Inhalt der Lambda-Funktion

MyLambda.java

2. Erstellen Sie eine JAR-Datei zum Hochladen

pom.xml

Quellcode herunterladen

Erstellen Sie mit maven ein Glas zum Hochladen

3. Laden Sie die JAR-Datei hoch und registrieren Sie sie bei AWS Lambda

4. Testen Sie auf der AWS-Konsole

POJO für Eingabe / Ausgabe

Ausführungsergebnis

5. Rufen Sie AWS Lambda-Funktionen von lokalem Java aus auf

Laden Sie die Bibliothek

maven

Java-Client

Java-Client

Java-Client-Quellcode

Zusammenfassung

Bonus

`maven`

`MyLambda.java`

`pom.xml`

`POJO für Eingabe / Ausgabe`

`Ausführungsergebnis`

`maven`

`Java-Client`