Jusqu'à présent, j'ai créé AWS Lambda principalement en Python, et parfois en Node.js, mais pour un changement, j'ai étudié comment développer en Java, je vais donc le résumer.
Cette fois, j'ai créé le code source de la fonction Lambda écrit en Java avec Gradle et l'ai déployé avec AWS SAM. AWS Toolkit for Eclipse (https://docs.aws.amazon.com/ja_jp/toolkit-for-eclipse/v1/user-guide/welcome.html) est également fourni pour le développement dans Eclipse, Je développe généralement avec Vim et déploie avec CLI, donc je vais m'adapter à cela.
~~ Comme vous pouvez le voir dans la documentation officielle ci-dessous, le seul runtime Java fourni est Java 8 ( JDK 8).
Si vous utilisez une autre version, vous devrez attendre qu'elle soit prise en charge ou utiliser un runtime personnalisé. ~~
Java 11 a été ajouté le 19 novembre 2019 et le runtime peut être sélectionné parmi Java 8 (JDK 8) et Java 11 (JDK 11).
Création de fonctions Lambda avec Java-AWS Lambda
Empaquetez et déployez une application écrite en Java dans un fichier zip ou un fichier jar autonome.
La documentation officielle montre comment déployer sur un jar autonome en utilisant Maven et un fichier zip en utilisant Gradle. Cette fois, j'ai essayé la méthode d'empaquetage et de déploiement dans un fichier zip avec Gradle.
Java AWS Lambda Deployment Package-AWS Lambda
Il existe plusieurs méthodes pour recevoir la demande de la fonction de gestionnaire et renvoyer la réponse comme suit.
La manière d'écrire la fonction de gestionnaire est différente pour chacun. En d'autres termes, il existe trois façons d'écrire des fonctions de gestionnaire.
Il semble qu'il soit utilisé correctement du point de vue du type de données envoyées, plutôt que de la manière de décider "Si vous utilisez ce déclencheur d'événement, ce type". Il ne semble pas y avoir de telle chose dans cette situation, il est donc nécessaire de considérer la méthode à utiliser lors du développement de fonctions Lambda en Java.
Cette fois, nous avons adopté le "type POJO".
Type de gestionnaire d'E / S (Java) --AWS Lambda
J'ai créé une application Web simple qui utilise ʻAPI Gateway` comme déclencheur pour les fonctions Lambda. C'est une API simple qui envoie simplement une requête POST et renvoie "Hello".
Le code que j'ai créé est ici. https://github.com/mmclsntr/awslambda-javagradle
.
├── build/
│ ├── distributions/
│ │ └── awslambda-javagradle.zip #Déployer le package généré par build
│ └── ...
├── build.gradle #Fichier de configuration de construction Gradle
├── src/main/java/awslambda/javagradle
│ ├── Greeting.java #La partie centrale de l'application
│ ├── Handler.java #Stocke les fonctions du gestionnaire Lambda
│ └── Response.java #Formater la réponse Lambda
└── template.yml #Fichier de modèle CloudFormation
└── Autres fichiers Gradle
Handler.java
package awslambda.javagradle;
import java.util.Collections;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class Handler implements RequestHandler<Map<String, Object>, Response> {
private static final Logger LOG = Logger.getLogger(Handler.class.getName());
@Override
public Response handleRequest(Map<String, Object> input, Context context) {
LOG.info("received: " + input);
LOG.setLevel(Level.INFO);
Greeting greetingBody = new Greeting("Hello");
return Response.builder()
.setStatusCode(200)
.setObjectBody(greetingBody)
.build();
}
}
Response.java
package awslambda.javagradle;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Collections;
import java.util.Map;
import org.apache.log4j.Logger;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Response {
private final int statusCode;
private final String body;
private final Map<String, String> headers;
private final boolean isBase64Encoded;
public Response(int statusCode, String body, Map<String, String> headers, boolean isBase64Encoded) {
this.statusCode = statusCode;
this.body = body;
this.headers = headers;
this.isBase64Encoded = isBase64Encoded;
}
...
}
Créez une application super simple qui renvoie Hello comme exemple.
Greeting.java
package awslambda.javagradle;
public class Greeting {
private String greetings;
public Greeting(String greetings) {
this.greetings = greetings;
}
public String getGreetings() {
return greetings;
}
public void setGreetings(String greetings) {
this.greetings = greetings;
}
}
template.yml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
AWS Lambda Java with Gradle
Globals:
Function:
Timeout: 20
Resources:
PostGreetingFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: build/distributions/awslambda-javagradle.zip
Handler: awslambda.javagradle.Handler::handleRequest
Runtime: java8
Events:
GetOrder:
Type: Api
Properties:
Path: /
Method: post
Outputs:
ApiEndpoint:
Description: "API Gateway endpoint URL for Prod stage"
Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/"
PostGreetingFunction:
Description: "PostGreeting Lambda Function ARN"
Value: !GetAtt PostGreetingFunction.Arn
build.gradle
apply plugin: 'java'
repositories {
mavenCentral()
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
compile (
'com.amazonaws:aws-lambda-java-core:1.1.0',
'com.amazonaws:aws-lambda-java-log4j:1.0.0',
'com.amazonaws:aws-lambda-java-events:1.1.0',
'com.fasterxml.jackson.core:jackson-core:2.8.5',
'com.fasterxml.jackson.core:jackson-databind:2.8.5',
'com.fasterxml.jackson.core:jackson-annotations:2.8.5'
)
}
// Task for building the zip file for upload
task buildZip(type: Zip) {
from compileJava
from processResources
into('lib') {
from configurations.runtime
}
}
build.dependsOn buildZip
Construisez avec la commande Gradle.
gradle build
aws s3 mb s3://<Déployer le compartiment S3 de destination> --aws-profile=<Profil AWS>
Avec sam package, téléchargez le fichier exécutable dans le compartiment S3 créé ci-dessus et générez un fichier modèle pour le déploiement.
sam package \
--s3-bucket <Déployer le nom du compartiment S3 de destination> \
--s3-prefix <Nom du dossier S3 de destination du déploiement(Préfixe)※Tout> \
--output-template-file output.yml \
--profile <Profil AWS>
En sortie, un fichier ʻoutput.yml` est créé.
Utilisez sam deploy pour déployer Lambda et API Gateway.
sam deploy \
--template-file output.yml \
--stack-name awslambda-javagradle-greeting \
--capabilities CAPABILITY_IAM \
--profile <Profil AWS>
Maintenant que la fonction Lambda et la passerelle API ont été créées sur AWS, lançons une requête POST au point de terminaison.
demande
curl -X POST https://xxxx.execute-api.ap-northeast-1.amazonaws.com/Prod/
réponse
{"greetings":"Hello"}
Je n'utilise généralement pas Java, donc ça m'a pris du temps, mais j'ai l'impression que c'était facile à faire. Bien sûr, la quantité de code est plus importante que l'écriture avec un langage de script tel que Python, mais il est intéressant de pouvoir faire un développement rigoureux sans serveur.
Cette fois seulement, je ne pouvais pas saisir pleinement les spécifications spécifiques pour l'écriture en Java, telles que plusieurs types d'écriture de fonctions de gestionnaire. Lorsque je l'utilise réellement, j'aimerais le concevoir en détail tout en tenant compte de cette zone.
De plus, selon la rumeur, le démarrage initial est lent (environ 5 secondes jusqu'à ce qu'il réponde). Référence: https://cero-t.hatenadiary.jp/entry/20160106/1452090214
J'ai pu saisir les caractéristiques et le sens du codage du développement de fonctions Lambda à l'aide de Java. Si vous migrez depuis une servlet, je pense que cela nécessitera une rénovation assez importante, mais il semble que cela puisse être utilisé comme substitut.
Je suis un peu inquiet pour le support là-bas, si le runtime est Java 8 tel quel. .. J'ai utilisé API Gateway comme déclencheur, mais j'aimerais également essayer d'autres services.
https://qiita.com/kamata1729/items/8d88ea10dd3bb61fa6cc https://qiita.com/riversun/items/7fcc06617b469aed8f27
Recommended Posts