This post shows step by step how to deploy your serverless Java AWS Lambas continuously to production. Moving from pull request, merge, build, deploy and finally test.

Overview

Project Setup

For our project we are going to assume a standard Maven Java project structure, with Cloudformation and build specification config in the root of the project.

Within the Maven pom.xml file, you must include the lambda core libraries.

• <dependencies>
•       <dependency>
•           <groupId>com.amazonaws</groupId>
•           <artifactId>aws-lambda-java-core</artifactId>
•           <version>1.2.0</version>
•       </dependency>
• And also include the AWS SDK Java BOM
• <!–https://aws.amazon.com/blogs/developer/managing-dependencies-with-aws-sdk-for-java-bill-of-materials-module-bom/–>
•    <dependencyManagement>
•        <dependencies>
•            <dependency>
•                <groupId>com.amazonaws</groupId>
•                <artifactId>aws-java-sdk-bom</artifactId>
•                <version>${com.amazonaws.version}</version>
•                <type>pom</type>
•                <scope>import</scope>
•            </dependency>
•        </dependencies>
•    </dependencyManagement>
• Next you also need to ensure that the JAR artifact is built flat
• <build>
•       <plugins>
•           <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>
•                       <configuration>
•                           <transformers>
•                               <transformer
•                                     implementation=”com.github.edwgiz.mavenShadePlugin.log4j2CacheTransformer.PluginsCacheFileTransformer”>
•                               </transformer>
•                           </transformers>
•                       </configuration>
•                   </execution>
•               </executions>
•               <dependencies>
•                   <dependency>
•                       <groupId>com.github.edwgiz</groupId>
•                       <artifactId>maven-shade-plugin.log4j2-cachefile-transformer</artifactId>
•                       <version>2.8.1</version>
•                   </dependency>
•               </dependencies>
•           </plugin>
• …

Build Pipeline using AWS CodePipeline

Source Step

The first step in the AWS CodePipeline is to fetch the source from the S3 bucket

• Action Name: Source
• Action Provider: S3
• Bucket: <your release bucket>
• S3 Object Key <path of your application>.zip
• Output Artifact: MyApp

Build Step

Next step in the pipeline, you need to configure a CodeBuild project.

Set the current environment image to aws/codebuild/java:openjdk-8

Use the following buildspec.yml in the root of your project:

• version: 0.2
• phases:
• build:
•   commands:
•     – echo Build started on `date`
•     # Unit tests, Code analysis and dependencies check (maven lifecycle phases: validate, compile, test, package, verify)
•     – mvn verify shade:shade -B -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=error
•     – mv target/MyApp-1.0.jar .
•     – unzip MyApp-1.0.jar
•     – rm -rf target tst src buildspec.yml pom.xml MyApp-1.0.jar
•     – aws cloudformation package –template-file main.yaml –output-template-file transformed_main.yaml –s3-bucket myapp-prod-outputbucket-xxxxxxxx
• cache:
• paths:
•   – ‘/root/.m2/**/*’
• artifacts:
• type: zip
• files:
•   – transformed_main.yaml

Staging Step

After the artifact is built, we now want to create a change set using CloudFormation.

• Action mode: Create or replace a change set
• Template: MyAppBuildOut::transformed_main.yaml
• Stackname: <name of your created stack here>

Define your Lambda function using Java (using serverless format), in your Cloudformation config file, placed in the root of your Maven project.

LambaFunctionName:
      Type: AWS::Serverless::Function
      Properties:
        Handler: au.com.nuamedia.camlinpayment.handler.MenuHandler
        Runtime: java8
        Timeout: 10
        MemorySize: 1024
        Events:
          GetEvent:
            Type: Api
            Properties:
              Path: /menu
              Method: get

Deploy Step

The ChangeSet can then be executed and the changes automatically rolled out to production safely. Any problems encountered and an automatic rollback occurs.

• Action Mode: Execute changeset
• Stackname: <name of your created stack here>
• Change set name: <change set name from previous step>

Outcome

Congratulations! you now have your Java AWS Lamba functions deploying to production using Continuous Deployment. AWS CodePipeline is easily configurable via the UI and can also be defined as code and stored in version control.