Skip to main content

Run Spring boot application on Docker

In this blog, I will explain how to  run the .jar file on Docker Engine

Docker containers are the fastest growing cloud-enabling technology and driving a new era of computing and application architecture with their lightweight approach to bundle applications and dependencies into isolated, yet highly portable application packages.

What you need?

  • Docker running on your computer.
Initial Plan

I will create a simple spring boot application and then create a Dockerfile to build the docker image. finally, I will run the application on Docker container

If you don't have Docker running on your computer. Here is the link to install the Docker 



Step 1: Create Spring-boot application

 Navigate this link to create the initial spring-boot application.

Import the project to the Eclipse IDE or whatever you like and create the simple rest endpoint. Here is my code.

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/rest/docker/hello")
public class HelloController {

 @RequestMapping
 public String hello() {
  return "Hello Docker...!";
 }
}
application.properties

server.port=8085
Build the project to create the .jar file. I have the .jar file in the target/docker-jar.jar

Step 2: Create the Dockerfile

 I have created the Dockerfile in the project folder

 
FROM openjdk:8
ADD target/docker-jar.jar docker-jar.jar
EXPOSE 8085
ENTRYPOINT ["java", "-jar", "docker-jar.jar"
Step 3: Build the Docker image and run the application on Docker

Use below command to build the docker image from the Dockerfile

docker build -f Dockerfile -t docker-spring-boot .
Check the docker images using the below command

 
docker images
output:
REPOSITORY           TAG                 IMAGE ID            CREATED             SIZE
docker-spring-boot   latest              73f02cac7fca        About an hour ago   640MB
<none>               <none>              f410a262a2df        About an hour ago   640MB
openjdk              8                   5f4603da3fbc        12 days ago         624MB
hello-world          latest              fce289e99eb9        4 weeks ago         1.84kB
Okay, Let's run Docker image 


docker run -p 8085:8085 docker-spring-boot
Now the spring-boot Application is running on the docker.

check the http://localhost:8085/rest/docker/hello, you will see this output "Hello Docker...!"
Labels:

Comments

Post a Comment

Popular posts from this blog

Java Increment Operations: `n++` vs `n = n + 1` vs `n += 1`

In Java, incrementing a variable by one can be done in several ways: n++ , n = n + 1 , and n += 1 . While these expressions achieve the same end result, they differ slightly in syntax and use cases. Let's explore each one and discuss their performance. 1. n++ Post-Increment Operator : Increments the value of n by 1 after its current value has been used. Common Usage : Typically used in loops and other contexts where the current value needs to be used before incrementing. int n = 5; n++; // n is now 6 2. n = n + 1 Addition Assignment : Explicitly sets n to its current value plus 1. Readability : Straightforward and clear, though slightly more verbose. int n = 5; n = n + 1; // n is now 6 3. n += 1 Compound Assignment Operator : Equivalent to n = n + 1 , but more concise. Usage : Combines addition and assignment into one step. int n = 5; n += 1; // n is
Post a Comment
Read more

Understanding C1 and C2 Compilers in Java

Understanding C1 and C2 Compilers in Java Understanding C1 and C2 Compilers in Java In Java, the Just-In-Time (JIT) compiler is a part of the Java Virtual Machine (JVM) that improves the performance of Java applications by compiling bytecode into native machine code at runtime. The JIT compiler includes two different compilers, known as the C1 and C2 compilers, each with distinct optimization strategies and purposes. C1 Compiler (Client Compiler) The C1 compiler, also known as the client compiler, is designed for fast startup times and lower memory consumption. It performs lighter and quicker optimizations, which makes it suitable for applications that require quick startup and responsiveness. Key characteristics of the C1 compiler include: Quick Compilation: Prioritizes fast compilation times over deep optimizations. Low Overhead: Consumes less memory and resources during compilation. Profile-Guided Optimization: Ca
Post a Comment
Read more

When To Use Indexes In MySQL

When deciding when and how to create an index in your MySQL database, it's important to consider how the data is being used. Let's say you have a database of  students . We will create it like this: CREATE TABLE `students` ( `id` int ( 11 ) NOT NULL AUTO_INCREMENT , `first_name` varchar ( 255 ) DEFAULT NULL , `last_name` varchar ( 255 ) DEFAULT NULL , `class` varchar ( 255 ) DEFAULT NULL , PRIMARY KEY ( `id` ) ) ENGINE = InnoDB Indexes are best used on columns that are frequently used in where clauses, and in any kind of sorting, such as "order by". You should also pay attention to whether or not this information will change frequently, because it will slow down your updates and inserts. Since you wont frequently be adding students, you don't have to worry about the inserts Let's say that you will be looking up the students with a web interface and the end user will be typing in the students name to find them, since r
Post a Comment
Read more