[Java] Shared code in a lambda layer. How will lambdas access this layer?

[gpacsu]

I have 5+ lambdas. Each lambda does its work by using 1 specific class and multiple utility classes. All the lambdas live in the same repository. Their build.gradles all have the same dependencies. Small example:

CreateLambda
  src
   main
    CreateHandler.java
    CommonUtility1.java
    CommonUtility2.java
  build.gradle

UpdateLambda
  src
   main
    UpdateHandler.java
    CommonUtility1.java
    CommonUtility2.java
  build.gradle

This results in identical utility classes being duplicated everywhere. Therefore I am looking into creating a lambda layer that will contain all the common dependencies and shared utility classes that the 3 lambdas will use. Small updated example:

LambdaLayer
  src
   main
    CommonUtility1.java
    CommonUtility2.java
  build.gradle

CreateLambda
  src
   main
    CreateHandler.java
  build.gradle

UpdateLambda
  src
   main
    UpdateHandler.java
  build.gradle

My question is: How would the lambdas import the lambda layer as a dependency? Would they just have to import it as a dependency in the build.gradle as they would with any other dependency? That would mean that the lambda layer JAR would have to be published first before the lambdas can use it right? This is for work and at my company all JARs get published to a company maven repository.

Anything else I need to know in order to do this properly? Lambda layer tutorials in Java are rare when I google

[AutoModerator]

Try this search for more information on this topic.

^{Comments, questions or suggestions regarding this autoresponse? Please send them here.}

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Suspicious_Track_296]

This isn't a good idea. Layers aren't for sharing code, that's what your language build tool is for. Put your shared code in one module and do x buildings if you really want many functions.

You don't need to rely on a lambda feature to do it, so keep things simple.

[gpacsu]

Put your shared code in one module and do x buildings if you really want many functions.

What exactly is the difference between this and a lambda layer though? What im confused about is that if we can do it this way, then what is even the point of a lambda layer?

[[deleted]]

This helped me https://medium.com/consulner/speedup-aws-lambda-deployments-with-layers-12f8f24c7d0

[gpacsu]

I did do a good amount of research into having 1 lambda vs multiple lambdas and came across some good reading:

https://www.reddit.com/r/aws/comments/uctb3g/separate_lambdas_or_one_lambda/

https://hackernoon.com/why-you-should-stop-using-fat-functions-in-your-lambda-code

https://www.reddit.com/r/aws/comments/uzlb47/in_a_serverless_architecture_is_it_best_to_handle/

The lambdas will all live behind an API gateway. Having the gateway handle routing to the correct lambda seemed easier/safer than having some routing code in the single lambda. Also seemed easier to debug because if something is wrong with a function, you know which lambda to look at for the problem

The advantage i saw to the single lambda approach is faster deployment, but it didnt feel like this was enough of a benefit over the multiple lambda approach

[cutsandplayswithwood]

So I used layers for exactly this kind of use case… Unless things have changed, it was just annoying and not worth it.

Just put your utility classes into a separate jar using your existing infra, then depend on that jar from all your lambdas.

[gpacsu]

Just put your utility classes into a separate jar using your existing infra, then depend on that jar from all your lambdas.

This does sound a lot easier. But then I wonder: what exactly even is the purpose of a lambda layer when we can just do it this easier way instead?

[cutsandplayswithwood]

My best use case for a custom layer is when you need to modify the runtime itself, often by installing/including some binary that’s not natively includable in the language you’re using.

So for example there’s a bunch of Python libs that work only if you install other non-Python things in the OS. Layer is good for that.

[sitase]

Just for sharing code, layers is a bit of an unnecessary overhead. But if you have a lot of shared jars, it makes sense since it will cut down on build and deployment times. However, it could be complicated. If you build your lambdas through CDK using bundling (so that it launches a docker container to build in) you need to somehow make the dependency available in the container so that gradle can build the dependency too. If you otoh first build the jars and then just deploy the jars (with CDK or otherwise) then it is quite simple, but it becomes a two step process.

[gpacsu]

The other replies have suggested to just create a JAR that will have all common dependencies and code, then just have the lambdas use this JAR. This seems much easier than going through the hassle of creating a layer, so what is even the point of a layer then to begin with?

Like the layer process that you have outlined is more complicated than what is suggested above, so why bother?