Search for a command to run...
Hey there! I'm currently working as an Associate DevOps Engineer, and I'm diving into popular DevOps tools like Azure Devops,Linux, Docker, Kubernetes,Terraform and Ansible. I'm also on the learning track with AWS certifications to amp up my cloud game. If you're into tech collaborations and exploring new horizons, let's connect!
No comments yet. Be the first to comment.
In this guide, we’ll walk through two methods to run a .NET 6.0 application: Running the application manually on your local machine. Using Docker to containerize and run the application efficiently. By the end, you’ll have a clear understanding o...
In this guide, we will go through the steps to deploy a Node.js application using Nginx as a reverse proxy. We'll also show how to manage the app using PM2 for process management and auto-starting the app on boot. Table of Contents: What is Nginx? ...
Prerequisites Before we begin, make sure you have the following: An AWS account. eksctl installed on your local machine. kubectl installed on your local machine. Git for version control. https://archive.eksworkshop.com/intermediate/290_argocd/co...
Step1: Launch an Ec2 Instance To launch an AWS EC2 instance with Ubuntu 22.04 using the AWS Management Console, sign in to your AWS account, access the EC2 dashboard, and click "Launch Instances." In "Step 1," select "Ubuntu 22.04" as the AMI, and in...
Devops projects
11 posts
If you're working with Java applications, Maven is a popular choice for managing dependencies and automating the build process. Once you have a working application, you may want to containerize it using Docker, which can make deploying your app more manageable and portable. This guide will walk you through running a Maven application manually and then show you how to package it with Docker using a multi-stage Dockerfile for an optimized final image.
Before starting, ensure that you have the following installed:
Java Development Kit (JDK): Make sure it’s compatible with the project.
Apache Maven: Verify it’s installed by running mvn -v.
Docker: To containerize and run the application in a container.
Since you've already cloned the project, navigate to your project directory. Here’s a quick reminder:
git clone https://github.com/your-repository/BankApp.git
cd BankApp
You should see the following structure in the project:
BankApp/
├── pom.xml
└── src/
├── main/
└── test/
pom.xml contains your project’s dependencies and build instructions, while the src/ folder contains the Java source code.
Let's start by building and running the application manually.
In your project directory, run:
./mvnw clean install
or if the mvnw script isn’t available, use:
mvn clean install
This will:
Download dependencies specified in pom.xml.
Compile the code and run any tests.
Package the application as a .jar file in the target/ directory.
After a successful build, you should see something like BankApp-0.0.1-SNAPSHOT.jar in the target/ folder.
To start the application, use:
java -jar target/BankApp-0.0.1-SNAPSHOT.jar
The application should now be running, and you can access it (if it’s a web app) by navigating to http://localhost:8080.
Now, let’s make the application easier to deploy by containerizing it with Docker. A multi-stage Dockerfile will help us build and run the application more efficiently.
A multi-stage Dockerfile separates the build and runtime environments. We use a Maven-based image to compile the project, then copy only the compiled .jar file to a minimal Java runtime image, resulting in a smaller, more efficient Docker image.
In the project’s root directory, create a file named Dockerfile and add the following contents:
# Stage 1: Build the application
FROM maven:3.8.7-openjdk-17 AS build
# Set the working directory in the container
WORKDIR /app
# Copy the pom.xml and source code
COPY pom.xml .
COPY src ./src
# Build the application
RUN mvn clean install -DskipTests
# Stage 2: Run the application
FROM openjdk:17-jdk-alpine
# Set the working directory
WORKDIR /app
# Copy the jar file from the build stage
COPY --from=build /app/target/BankApp-0.0.1-SNAPSHOT.jar app.jar
# Expose the port (update if the app uses a different port)
EXPOSE 8080
# Command to run the application
CMD ["java", "-jar", "app.jar"]
Stage 1 (Build Stage):
We use maven:3.8.7-openjdk-17 as the base image.
The source code and pom.xml are copied into the container.
The mvn clean install -DskipTests command compiles the application and skips tests for faster builds.
The compiled .jar file is created in /app/target.
Stage 2 (Runtime Stage):
We use a smaller image, openjdk:17-jdk-alpine, to run the app.
The .jar file from the build stage is copied over.
The container exposes port 8080 (adjust as needed).
The CMD instruction starts the app.
Now that the Dockerfile is ready, let’s build and run the Docker image.
Run the following command to build the Docker image:
docker build -t bankapp:latest .
The -t bankapp:latest option tags the image as bankapp with the latest tag.
Start a container from the Docker image:
docker run -p 8080:81 bankapp:latest
The -p 81:8080 option maps port 81 on your machine to port 8080 in the container.
Your application should now be accessible at http://localhost:81.
To verify that everything is working:
Open a web browser or use a tool like curl to access http://localhost:81.
Check the logs in your terminal to ensure there are no errors.
Here’s what we covered in this guide:
Manual Build and Run: Built and ran the application locally using Maven.
Containerized Build and Run: Used a multi-stage Dockerfile to build a Docker image and run it in a container.
By containerizing the application, you’ve made it easier to deploy across environments consistently, without the need for a specific JDK or Maven installation. The multi-stage Dockerfile ensures the final image is optimized for size and performance, containing only what’s needed to run the application.