QuickStart: Deploy a Java application to Elastic Beanstalk

This QuickStart tutorial walks you through the process of creating a Java application and deploying it to an Amazon Elastic Beanstalk environment.

Your Amazon account

If you're not already an Amazon customer, you need to create an Amazon account. Signing up enables you to access Elastic Beanstalk and other Amazon services that you need.

If you already have an Amazon account, you can move on to Prerequisites.

Prerequisites

To follow the procedures in this guide, you will need a command line terminal or shell to run commands. Commands are shown in listings preceded by a prompt symbol ($) and the name of the current directory, when appropriate.

~/eb-project$ this is a command
this is output

On Linux and macOS, you can use your preferred shell and package manager. On Windows you can install the Windows Subsystem for Linux to get a Windows-integrated version of Ubuntu and Bash.

EB CLI

This tutorial uses the Elastic Beanstalk Command Line Interface (EB CLI). For details on installing and configuring the EB CLI, see Install EB CLI with setup script (recommended)and Configure the EB CLI.

Java and Maven

If you don't have Amazon Corretto installed on your local machine, you can install it by following the installation instructions in the Amazon Corretto User Guide.

Verify your Java installation by running the following command.

~$ java -version 

This tutorial uses Maven. Follow the download and installation instructions on the Apache Maven Project website. For more information about Maven see the Maven Users Centre on the Apache Maven Project website.

Verify your Maven installation by running the following command.

~$ mvn -v

Step 1: Create a Java application

Create a project directory.

~$ mkdir eb-java
~$ cd eb-java

Next, create an application that you'll deploy using Elastic Beanstalk. We'll create a "Hello World" RESTful web service.

This example uses the Spring Boot framework. This application opens a listener on port 5000. Elastic Beanstalk forward requests to your application on port 5000 by default.

Create the following files:

This file creates a simple Spring Boot application.

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

This file creates a mapping that returns a String that we define here.

package com.example;
    
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
    
@RestController
public class Controller {
    
    @GetMapping("/")
    public String index() {
       return "Hello Elastic Beanstalk!";
    }
}

This file defines the Maven project configuration.

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.3</version>
  </parent>

  <groupId>com.example</groupId>
  <artifactId>BeanstalkJavaExample</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <java.version>21</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

This properties file overrides the default port to be 5000. This is the default port that Elastic Beanstalk sends traffic to for Java applications.

server.port=5000

Step 2: Run your application locally

Package your application with the following command:

~/eb-java$ mvn clean package

Run your application locally with the following command:

~/eb-java$ java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar

While the application is running, navigate to http://127.0.0.1:5000/ in your browser. You should see the text “Hello Elastic Beanstalk!”.

Step 3: Deploy your Java application with the EB CLI

Before deploying your Java application to Elastic Beanstalk, let’s clean the build application from your directory and create a Buildfile and a Procfile to control how the application is built and run on your Elastic Beanstalk environment.

Now that you have set up the configuration files to build and start your application, you're ready to deploy it.

Step 4: Run your application on Elastic Beanstalk

When the process to create your environment completes, open your website with eb open.

~/eb-java eb open

Congratulations! You've deployed a Java application with Elastic Beanstalk! This opens a browser window using the domain name created for your application.

Step 5: Clean up

You can terminate your environment when you finish working with your application. Elastic Beanstalk terminates all Amazon resources associated with your environment.

To terminate your Elastic Beanstalk environment with the EB CLI run the following command.

~/eb-java$ eb terminate

Amazon resources for your application

You just created a single instance application. It serves as a straightforward sample application with a single EC2 instance, so it doesn't require load balancing or auto scaling. For single instance applications Elastic Beanstalk creates the following Amazon resources:

Elastic Beanstalk manages all of these resources. When you terminate your environment, Elastic Beanstalk terminates all the resources that it contains.

Next steps

After you have an environment running an application, you can deploy a new version of the application or a different application at any time. Deploying a new application version is very quick because it doesn't require provisioning or restarting EC2 instances. You can also explore your new environment using the Elastic Beanstalk console. For detailed steps, see Explore your environment in the Getting started chapter of this guide.

After you deploy a sample application or two and are ready to start developing and running Java applications locally, see Setting up your Java development environment.

Deploy with the Elastic Beanstalk console

You can also use the Elastic Beanstalk console to launch the sample application. For detailed steps, see Create an example application in the Getting started chapter of this guide.