Step 1: Prerequisites

Before starting, ensure the following are installed on your machine:

• Java Development Kit (JDK): To compile and run Java code.
• Docker: To create and manage containers. What is docker?
• Install Docker: https://docs.docker.com/
• Text Editor or IDE: For writing Java code (e.g., IntelliJ IDEA).

Step 2: Write a Simple Java Program

Create a file named HelloWorld.java with the following content:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Docker and Java!");
    }
}

Step 3: Build Project

Click on Build => Build Project. It will create a out folder on your project directory

This will generate a Main.class file.

Step 4: Create a Dockerfile

A Dockerfile is a script that contains instructions for building a Docker image. Create a file named Dockerfile in the same directory as your Java program with the following content:

                # Use the OpenJDK 23 image as the base image
                FROM openjdk:23
                
                # Create a new app directory for my application files
                RUN mkdir /app
                
                # Copy the app files from host machine to image filesystem
                COPY out/production/HelloWorldDocker/ /app
                
                # Set the directory for executing future commands
                WORKDIR /app
                
                # Run the Main class
                CMD java Main

Step 5: Build the Docker Image

Open a terminal or command prompt and navigate to the directory containing the Dockerfile and HelloWorld.class. Then, build the Docker image:

docker build -t hello-java .

• -t hello-java: Tags the image with the name hello-java.
• .: Specifies the current directory as the build context.

Step 6: Run the Docker Container

Once the image is built, you can run it as a container:

docker run hello-java

You should see the output:

Hello, Docker and Java!

Step 7: Key Concepts

While working through this guide, keep the following key concepts in mind:

• Dockerfile: A script that defines how to build a Docker image.
• Base Image: The starting point for building a Docker image (e.g., openjdk:11-jre-slim).
• Layers: Each instruction in the Dockerfile creates a new layer in the image.
• Multi-Stage Builds: Used to reduce the size of the final image by separating the build environment from the runtime environment.
• Docker Commands:
  • docker build: Builds an image from a Dockerfile.
  • docker run: Runs a container from an image.
  • docker images: Lists all images on the system.
  • docker ps: Lists running containers.

Step 8: Practice Exercise

Try the following tasks to practice what you've learned:

1. Modify the HelloWorld.java program to print your name.
2. Update the Dockerfile to use a different base image (e.g., openjdk:17-jre-slim).
3. Build and run the updated Docker image.

Step 9: Additional Resources

Explore these resources to learn more about Docker and Java:

• Docker Documentation: https://docs.docker.com/
• Java Documentation: https://docs.oracle.com/en/java/
• Docker Hub: https://hub.docker.com/ (to find base images)
• Tutorial: Tutorial

💡 How to Submit on Blackboard?