{"id":98679,"date":"2019-09-30T09:35:10","date_gmt":"2019-09-30T06:35:10","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=98679"},"modified":"2019-10-14T12:47:49","modified_gmt":"2019-10-14T09:47:49","slug":"easy-spring-boot-deployment-aws-elastic-beanstalk","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2019\/09\/easy-spring-boot-deployment-aws-elastic-beanstalk.html","title":{"rendered":"Easy Spring Boot Deployment with AWS Elastic Beanstalk"},"content":{"rendered":"

Friends don\u2019t let friends write user auth. Tired of managing your own users?<\/strong> Try Okta\u2019s API and Java SDKs today. Authenticate, manage, and secure users in any application within minutes.<\/a><\/span><\/p>\n

Nearly all applications rely on authentication. Developers, and the companies that employ them, want to confirm who is making the request and are they who they say they are. And, this needs to happen fast enough for a good user experience. Fortunately, there are great tools to help.<\/p>\n

Spring Boot with Spring Security is a fantastic solution for Java-based web development. With relatively little code, developers can implement, test, update, and expand authentication schemes easily and securely.<\/p>\n

In this tutorial, you will build a very simple \u201cHello World\u201d app in Spring Boot with OAuth 2.0 \/ OpenID Connect and Okta as the OAuth provider. It will use AWS as the cloud provider, deploying through AWS Elastic Beanstalk.<\/p>\n

Why AWS Elastic Beanstalk?<\/h2>\n

When it comes to cloud infrastructure providers, AWS has always been the market leader and their services make it fast and easy to deploy a cloud application. Elastic Beanstalk is a deployment and provisioning service that allows you to deploy an entire infrastructure with a few clicks by automating the process of getting applications set up on AWS infrastructure. Additionally, it helps manage the resource utilization of your app with automatic Provisioning, load balancing, autoscaling, and health monitoring.<\/p>\n

Create a Spring Boot Application<\/h2>\n

Before you start a cloud deployment, you\u2019ll need the app itself. The first version of your app will have a simple page, which will show Hello, {user}!<\/code> if you input a user\u2019s name, or it will show Hello, World!<\/code> otherwise. You\u2019re going to use Spring MVC and Thymeleaf to do the task.<\/p>\n

Thymeleaf is a server-side template engine. It allows you to pass server arguments to your HTML before rendering it in the client\u2019s web browser.<\/p>\n

Could you create a project from scratch? Sure, but you don\u2019t need to. You can use Spring Initializr instead. It will help you generate your project with all the dependencies you need.<\/p>\n

Go to the Spring Initializr website<\/a>, and type the following information:<\/p>\n

- Project: Maven Project\n- Language: Java\n- Group: com.okta\n- Artifact: hello-world\n- Dependencies: Spring Web Starter, Thymeleaf\n<\/pre>\n
You can choose either to generate the project using Maven or Gradle. This tutorial shows the steps using Maven, but you can easily follow it on Gradle.<\/p>\n
After you provide the information, click on Generate the project<\/strong>. The site will generate a zip file you can download and extract. Open the project in your favorite IDE, and you\u2019re good to go!<\/p>\n
Create The Web Page<\/h2>\n
With Spring MVC, you need to create a Controller to represent the web page. It will map to the endpoint \/hello<\/code>, and also to \/<\/code>, which represents the homepage. It returns the hello-world<\/code> template as a response.<\/p>\n
Create the class HelloWorldController<\/code>:<\/p>\n
@Controller\npublic class HelloWorldController {\n\n    @GetMapping({\"\/\", \"hello\"})\n    public String helloWorld(@RequestParam(required = false, defaultValue = \"World\") String name, Model model) {\n        model.addAttribute(\"name\", name);\n        return \"hello-world\";\n    }\n}\n<\/pre>\n
So far, so good. Next, you create the html template. What is this template, though? Why do you need it?<\/p>\n
The template is an HTML page Spring MVC uses to render the information in the user\u2019s browser.<\/p>\n
You define a Thymeleaf HTML page to receive all attributes defined in the model<\/code> object.<\/p>\n
Inside src\\main\\resources\\templates<\/code>, create the file hello-world.html<\/code>:<\/p>\n
<!DOCTYPE html>\n<html xmlns:th=\"http:\/\/www.thymeleaf.org\">\n    <body>\n        <h1 th:text=\"'Hello, ' + ${name} + '!'\"><\/h1>\n    <\/body>\n<\/html>\n<\/pre>\n
This creates an HTML page that displays a <h1><\/code> tag in the body, with a greeting message. The ${name}<\/code> attribute is not native HTML, it is part of Thymeleaf and receives the value from the model<\/code> object to render the information before sending it to the browser.<\/p>\n
Now you have created both the controller and the template, you can run it, and see if it works! Open the HelloWorldApplication<\/code> class and execute the main<\/code> method.<\/p>\n
Or, from the command line, execute:<\/p>\n
.\/mvnw spring-boot:run\n<\/pre>\n
If you go to http:\/\/localhost:8080\/<\/strong> in your web browser, you will see the following message:<\/p>\n
Hello, World!\n<\/pre>\n
If you want a custom message, you can add the name<\/code> parameter. For instance, http:\/\/localhost:8080\/?name=Daniel<\/strong> will return:<\/p>\n
Hello, Daniel\n<\/pre>\n
Add Spring Security<\/h2>\n
When it comes to SaaS, developers want to make sure their application is secure. Users shouldn\u2019t be able to see user data from other users.<\/p>\n
Spring Security handles authentication, authorization, and other security aspects. To add it in your project, go to the pom.xml<\/code> file, and add the following code inside the <dependencies><\/code> tag:<\/p>\n
<dependency>\n    <groupId>org.springframework.boot<\/groupId>\n    <artifactId>spring-boot-starter-security<\/artifactId>\n<\/dependency>\n<\/pre>\n
That\u2019s it! When you add Spring Security as a dependency, it enables security by default. When you try to access your endpoints, you\u2019ll have to log in before continuing.<\/p>\n
Let\u2019s test it. Run the application, then go to http:\/\/localhost:8080\/<\/strong>. You will see the following result:<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
As expected, now it redirects you to the login page, which will ask for a username and password. You must be asking yourself right now: which username and password should I use?<\/p>\n
The default username is user<\/code>. Instead of setting a default password, Spring changes it every time the application starts. You can see the current one by looking at the applications logs. Look for something like this:<\/p>\n
Using generated security password: 29aa0d09-eaca-47ae-bcad-e5b22affd466\n<\/pre>\n
This behavior is not what you want in a real application. Users expect the password to remain the same unless they change it themselves. Let\u2019s add a configuration to make it happen.
 
<\/div> <\/div><\/p>\n
Create the class SecurityConfiguration<\/code>:<\/p>\n
@EnableWebSecurity\npublic class SecurityConfiguration extends WebSecurityConfigurerAdapter {\n\n    private PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();\n\n    @Override\n    protected void configure(AuthenticationManagerBuilder auth) throws Exception {\n        auth.inMemoryAuthentication()\n            .passwordEncoder(passwordEncoder())\n            .withUser(\"john.doe\")\n            .password(passwordEncoder().encode(\"secret\"))\n            .roles(\"USER\");\n    }\n\n    @Bean\n    public PasswordEncoder passwordEncoder() {\n        return passwordEncoder;\n    }\n}\n<\/pre>\n
The class above extends WebSecurityConfigurerAdapter<\/code>, and allows you to change the authentication management method. In this example, you create a single user, but you can create as many as you want. Just append a new withUser<\/code> call after the first one.<\/p>\n
Now that the user has authenticated to your application, you don\u2019t need to ask for a username anymore. Instead, you will display the information based on the current user. Inside the HelloWorldController<\/code>, make these changes in the code:<\/p>\n
@Controller\npublic class HelloWorldController {\n\n    @GetMapping({\"\/\", \"hello\"})\n    public String helloWorld(Model model, Principal principal) {\n        model.addAttribute(\"name\", principal.getName());\n        return \"hello-world\";\n    }\n}\n<\/pre>\n
The Principal<\/code> interface stores the name of the current user. Spring Security takes care of the dirty work: you only need to add it as an argument, and the method receives the correct value.<\/p>\n
To see this change, stop the application and run it again. If you access http:\/\/localhost:8080\/<\/strong>, it will ask you to log in again. Use john.doe<\/code> as the username secret<\/code> as the password. After submitting the information, you will see the following text:<\/p>\n
Hello, john.doe!\n<\/pre>\n
Now you\u2019re ready to deploy your application in the cloud!<\/p>\n
Deploy The Application To AWS Elastic Beanstalk<\/h2>\n
To deploy the service, you will use AWS Elastic Beanstalk. If you don\u2019t have an AWS account go ahead and create one here.<\/a><\/p>\n
After logging into the AWS console<\/a>, go to Services and type Elastic Beanstalk<\/strong> in the search. Click on it, and it will redirect you to a Welcome page. Click on the Get started<\/strong> button to start creating your application in the cloud. You will see the following screen:<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
Here you will create a web application. Put the following information in the fields above:<\/p>\n
Application name:  hello-world\nPlatform: Java\nApplication code: Upload Your code\n<\/pre>\n
Before you upload your code you will need to export it as a JAR file. Go inside your application folder and type the following command:<\/p>\n
.\/mvnw package -DskipTests\n<\/pre>\n
After it runs, upload the file hello-world-0.0.1-SNAPSHOT.jar<\/code> under the target<\/code> folder.<\/p>\n
When the upload completes, click on the Create application<\/code> button. AWS will start to create the environment, displaying the logs of what is happening in the process.<\/p>\n
Once the environment is set up, AWS will redirect you to the Dashboard. Above the dashboard menu, you\u2019ll find the URL to access the application. Open it in a new tab, and it will load your web page.<\/p>\n
Right now, you get a 502<\/code> error response, which is expected. By default, Elastic Beanstalk runs the application on port 5000, while Spring Boot executes on port 8080. Let\u2019s direct your app run on port 5000 to fix the issue.<\/p>\n
Click on Configuration<\/strong> the dashboard menu. You will see the screen below:<\/p>\n
\n
\"\"<\/figure>\n<\/div>\n
You can change many variables and features in your environment: add a load balancer, increase the number of instances, or in this case add environment variables.<\/p>\n
Go to the Software<\/strong> card and click on Modify<\/strong>. Look for Environment properties<\/code> and add the following value to the list:<\/p>\n
SERVER_PORT<\/code> : 5000<\/code><\/p>\n
After changing it, click on the Apply<\/strong> button and wait for AWS to apply the changes in the environment. When the message Environment update completed successfully.<\/code> appears, open the URL again.<\/p>\n
Now it worked! Type the username and password you defined in your code, john.doe<\/code> and secret<\/code>. It will then redirect you to the hello page, which will show you the same result as your local environment:<\/p>\n
Hello, john.doe!\n<\/pre>\n
If you have problems, you can always check the logs.<\/p>\n