Serverless most often refers to applications that don't require you to provision or manage any servers. You can focus on your core product and business logic instead of responsibilities like operating system (OS) access control, OS patching, provisioning, right-sizing, scaling, and availability.
It's a revolution in the current technological trend. A detailed post on serverless can be found below:

Today, we will see how to create a serverless upload API using Serverless and AWS Java SDK
Prerequisites
- Install NodeJs and npm
- Install Serverless Framework with AWS account
- Install JDK and export to User or System Path
- Install Apache Maven and export to User or System Path
Bootstrap serverless project
- The first step is to bootstrap the serverless project
Use the below code to generate the bootstrapped codebase
serverless create --template aws-java-maven --name uploads-api -p uploads-api
- Update the pom file with the correct artifactId and name and package name as per requirement
- Try building the application
You should see the application build successfully with the command -
mvn clean package

Restructure codebase
- Restructure the app to look something like below

- Folder details -
dto - Data Transfer Objects(POJO) goes here
entity - Bean Java POJO goes here
handler - Lambda Handler goes here
service - Service Interface and Implementation goes here
utility - The utility code goes here
Create the Handler
- We will create a new handler CreatePersignedURLHandler under the handler package
- Handler is the entry point for the Lambda function
Create S3 Utility
Now we will create the most important part of the code which will help us create the Presigned URL
- First, add the required dependency
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-java-sdk-s3</artifactId>
<version>1.12.249</version>
</dependency>
- Next, we will create a class singleton S3Util
- This will contain a function createPresignedURL which accepts - bucket name, key/name of the file, and time to live for the presigned URL

Add Service
- Let's first create an Interface called UploadService which will hold the contract for generating the presigned URL
public interface UploadService {
AppResponse processCreatePresignedURL(Map<String, Object> input);
}
- Next, we will implement this Interface for actual functionality
For detailed code see -
- Now we will call this service from our handler

- The response from the service will be responded to calling the client
Serverless Config
Finally, we need the serverless.yml config which will create the necessary resources in AWS for our serverless stack
Our serverless.yml will look like this -
# This name will appear in AWS cloud formation
service: uploads-api
# Serverless Framework Version
frameworkVersion: '3'
custom:
bucketName: test-upload-bucket123
region: us-east-2
# General Lambda configuration goes here
provider:
name: aws
runtime: java8.al2 # AWS Linux 2 Corretto 8
stage: dev
region: ${self:custom.region}
# IAM Policies for the function goes here
iam:
role:
statements:
- Effect: "Allow"
Action:
- "s3:*"
Resource: !Sub
- arn:aws:s3:::${self:custom.bucketName}/*
- BucketName: !Ref UploadBucket
# Package artifact to use for deployment
package:
artifact: target/uploads-api-dev.jar
# Lambda function configuration
functions:
hello:
# Handler location
handler: in.bitmaskers.handler.GetPresignedURLHandler
# Environment variables
environment:
BUCKET_NAME: ${self:custom.bucketName}
REGION: ${self:custom.region}
# Use AWS Gateway HTTP API as lambda trigger
events:
- httpApi:
path: /create-presigned-url # Path of API
method: post # Method type
# Cloudformation Resource Template
resources:
Resources:
UploadBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: ${self:custom.bucketName}
The comments added will give details on each node in yml
Deployment
Deployment is the easiest part for a serverless app since everything is managed by AWS.
After configuring everything, we need to package our app and deploy it.
- Package the app
mvn clean package
- Serverless deploy
sls deploy
We will see stack getting created and deployed

Let's take it for a spin 🚀
- Pass required param as JSON and do a POST call

- Use the presigned URL returned to do another PUT operation with the binary file. We will receive a 200 status code, which means the file was uploaded successfully 🎊

- PUT call on presigned URL after TTL expiry throws error as below

- We can now see the file created in S3

That's all folks! Pretty lengthy blog but hope you liked it.
Cheer! 🍻