Skip to main content

Java 8 (OpenJDK 1.8.0) with Maven 3.6.3 (CentOS Stream 9) AMI Administrator Guide

1. Quick Start Information​

Connection Methods:

  • Access the instance via SSH using the ec2-user user. Use sudo to run commands requiring root privileges. To switch to the root user, use sudo su - root.

Install Information:

  • OS: CentOS Stream 9
  • Java version: OpenJDK 1.8.0_472
  • Maven version: 3.6.3
  • Java Home: /usr/lib/jvm/java-1.8.0-openjdk
  • Maven Home: /usr/local/maven

Quick Verification Commands:

  • Check Java version: java -version
  • Check Java compiler: javac -version
  • Check Maven version: mvn -version
  • Check environment: echo $JAVA_HOME && echo $M2_HOME

Development Tools Included:

  • Java Runtime (JRE): OpenJDK 1.8.0
  • Java Compiler (JDK): javac 1.8.0
  • Maven Build Tool: 3.6.3
  • Environment Configuration: System-wide /etc/profile.d/ setup

Firewall Configuration:

  • Please allow SSH port 22.
  • For security, it is recommended to limit SSH access to trusted IPs only.

2. Overview​

Welcome to this Java 8 + Maven 3.6.3 AMI. This image is based on CentOS Stream 9 and provides a complete, production-ready development environment for building enterprise Java applications.

This guide explains how to use this AMI and details its internal configuration.

What is Java 8?

Java 8 (released in 2014) is a Long-Term Support (LTS) version of the Java programming language. It introduced major features like lambda expressions, the Stream API, and the new Date/Time API. Despite being over a decade old, Java 8 remains widely used in enterprise environments due to its stability and extensive library support.

What is Maven?

Apache Maven is a build automation and project management tool for Java projects. It uses a Project Object Model (POM) to manage dependencies, build processes, documentation, and more. Maven 3.6.3 is the last 3.x series release before Maven 4.0.

Core Features of This AMI:

  • Java 8 OpenJDK 1.8.0_472: Latest patch release from Red Hat
  • Maven 3.6.3: Stable, widely-tested build tool
  • System-wide Configuration: All users have access to Java and Maven
  • Symbolic Link Strategy: Easy Maven upgrades without changing environment variables
  • Complete Development Kit: Includes JDK (compiler) not just JRE (runtime)

Target Use Cases:

  • Building Spring Boot / Spring Framework applications
  • Developing Jakarta EE (formerly Java EE) applications
  • Creating microservices with popular Java frameworks
  • Maintaining legacy Java 8 applications
  • Building Android applications (requires additional Android SDK)

3. First Launch & Verification​

Step 1: Connect to Your Instance​

  1. Launch your instance in your cloud provider's console (e.g., AWS EC2)
  2. Ensure SSH port 22 is allowed in your security group
  3. Connect via SSH: 
    ssh -i your-key.pem ec2-user@YOUR_PUBLIC_IP

Step 2: Verify Java Installation​

Check Java Runtime Environment (JRE):

java -version

Expected Output:

openjdk version "1.8.0_472"
OpenJDK Runtime Environment (build 1.8.0_472-b08)
OpenJDK 64-Bit Server VM (build 25.472-b08, mixed mode)

Output Explained:

  • 1.8.0_472: Java 8 Update 472 (patch level)
  • build 1.8.0_472-b08: Build identifier
  • OpenJDK 64-Bit Server VM: 64-bit server-optimized JVM
  • mixed mode: Uses JIT (Just-In-Time) compiler for performance

Check Java Development Kit (JDK):

javac -version

Expected Output:

javac 1.8.0_472

Step 3: Verify Environment Variables​

Check Java environment:

echo "JAVA_HOME: $JAVA_HOME"
echo "JRE_HOME: $JRE_HOME"
echo "CLASSPATH: $CLASSPATH"

Expected Output:

JAVA_HOME: /usr/lib/jvm/java-1.8.0-openjdk
JRE_HOME: /usr/lib/jvm/java-1.8.0-openjdk/jre
CLASSPATH: .:/usr/lib/jvm/java-1.8.0-openjdk/lib:/usr/lib/jvm/java-1.8.0-openjdk/jre/lib

Check Maven environment:

echo "M2_HOME: $M2_HOME"
echo "MAVEN_HOME: $MAVEN_HOME"

Expected Output:

M2_HOME: /usr/local/maven
MAVEN_HOME: /usr/local/maven

Step 4: Verify Maven Installation​

Check Maven version:

mvn -version

Expected Output:

Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)
Maven home: /usr/local/maven
Java version: 1.8.0_472, vendor: Red Hat, Inc., runtime: /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.472.b08-2.el9.x86_64/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "5.14.0-669.el9.x86_64", arch: "amd64", family: "unix"

Critical Check: Verify "Java version: 1.8.0_472" shows the correct Java version Maven is using.

Step 5: Test Maven Functionality​

Run Maven's system diagnostic:

mvn help:system

What This Does:

  1. Downloads Maven plugins from Maven Central repository
  2. Displays all system properties
  3. Shows environment variables
  4. Verifies Maven can communicate with remote repositories

Expected Ending:

[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

Step 6: Create and Compile a Test Program​

Create a simple Java program:

mkdir -p ~/hello-java
cd ~/hello-java

Create HelloWorld.java:

cat > HelloWorld.java << 'EOF'
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello from Java 8!");
        System.out.println("Running on: " + System.getProperty("java.version"));
    }
}
EOF

Compile with javac:

javac HelloWorld.java

Run the program:

java HelloWorld

Expected Output:

Hello from Java 8!
Running on: 1.8.0_472

Clean up:

cd ~
rm -rf ~/hello-java

4. Architecture & Detailed Configuration​

4.1. Component Locations​

ComponentInstallation PathPurpose
Java Home/usr/lib/jvm/java-1.8.0-openjdkJDK root directory
JRE Home/usr/lib/jvm/java-1.8.0-openjdk/jreJava Runtime Environment
Java Binaries/usr/lib/jvm/java-1.8.0-openjdk/bin/java, javac, jar, etc.
Maven Installation/usr/local/apache-maven-3.6.3/Actual Maven directory
Maven Symlink/usr/local/mavenPoints to Maven installation
Maven Binaries/usr/local/maven/bin/mvn, mvnDebug
Maven Repository~/.m2/repository/Downloaded dependencies (per-user)
Java Environment/etc/profile.d/java.shSystem-wide Java configuration
Maven Environment/etc/profile.d/maven.shSystem-wide Maven configuration

4.2. Java Environment Configuration​

File: /etc/profile.d/java.sh

Complete Contents:

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
export PATH=$JAVA_HOME/bin:$PATH

Line-by-Line Explanation:

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
  • Sets the root directory of the Java installation
  • Required by Maven, Gradle, and many Java tools
  • Used to locate the JDK
export JRE_HOME=$JAVA_HOME/jre
  • Points to the Java Runtime Environment subdirectory
  • Some applications check this for the Java runtime
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
  • .: Current directory (for finding .class files)
  • $JAVA_HOME/lib: JDK libraries
  • $JRE_HOME/lib: JRE libraries
export PATH=$JAVA_HOME/bin:$PATH
  • Adds Java binaries to system PATH
  • Allows running java, javac, jar from anywhere

4.3. Maven Environment Configuration​

File: /etc/profile.d/maven.sh

Complete Contents:

export M2_HOME=/usr/local/maven
export MAVEN_HOME=/usr/local/maven
export PATH=$M2_HOME/bin:$PATH

Variable Explanation:

  • M2_HOME: Maven 2/3 home directory (legacy convention)
  • MAVEN_HOME: Modern Maven home variable
  • Both set for maximum compatibility

Maven uses a symbolic link for easy upgrades:

/usr/local/maven -> /usr/local/apache-maven-3.6.3

Why This Matters:

When upgrading Maven:

  1. Extract new version to /usr/local/apache-maven-3.9.0/
  2. Update symlink: sudo ln -sf /usr/local/apache-maven-3.9.0 /usr/local/maven
  3. No need to change /etc/profile.d/maven.sh
  4. All users immediately use new version

4.5. Maven Repository Structure​

After first Maven build, ~/.m2/ will contain:

~/.m2/
├── repository/        # Downloaded JAR files
│   ├── org/
│   ├── com/
│   └── ...
└── settings.xml       # User-specific Maven configuration (optional)

Space Considerations:

  • Small projects: ~50 MB
  • Medium projects: ~200 MB
  • Large projects: 500 MB+

The repository is shared across all projects, so dependencies are downloaded once.

5. How-To-Create: Building This AMI from Scratch​

This section explains exactly how this AMI was created, allowing you to:

  • Understand the configuration
  • Reproduce the setup on other systems
  • Customize the installation

Step 1: Install Java 8 OpenJDK​

Install both the runtime and development kit:

sudo dnf install -y java-1.8.0-openjdk java-1.8.0-openjdk-devel

Package Breakdown:

  • java-1.8.0-openjdk: Java Runtime Environment (JRE)

    • Allows running Java applications
    • Size: ~200 MB

  • java-1.8.0-openjdk-devel: Java Development Kit (JDK)

    • Adds javac compiler
    • Adds development tools (jdb, javadoc, jar)
    • Adds JDK headers
    • Size: ~100 MB additional

Why Both Packages:

Many developers install only the JRE and then can't compile. This AMI includes both to avoid confusion.

Verify installation:

java -version
javac -version

Expected Output:

openjdk version "1.8.0_472"
...
javac 1.8.0_472

Step 2: Download Maven 3.6.3​

Download from Apache Maven archive:

wget https://archive.apache.org/dist/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz

Why Maven 3.6.3:

  • Last stable release of Maven 3.x series
  • Widely tested in production environments
  • Compatible with Java 8 through Java 17
  • Maven 3.9+ requires Java 8 minimum, but 3.6.3 is more conservative

Download Details:

  • URL: Apache Archive (official mirror)
  • Size: ~9 MB
  • Format: tar.gz (compressed tarball)

Step 3: Extract Maven​

Extract to /usr/local/:

sudo tar -xzf apache-maven-3.6.3-bin.tar.gz -C /usr/local/

Extraction Options:

  • -x: Extract files
  • -z: Decompress gzip
  • -f: File to extract
  • -C /usr/local/: Change to this directory before extracting

Result: Creates /usr/local/apache-maven-3.6.3/ with Maven installation.

Directory Structure:

/usr/local/apache-maven-3.6.3/
├── bin/           # mvn, mvnDebug executables
├── boot/          # Plexus classworlds
├── conf/          # settings.xml template
├── lib/           # Maven core libraries
└── LICENSE        # Apache License 2.0

Create a symlink for easy version management:

sudo ln -sf /usr/local/apache-maven-3.6.3 /usr/local/maven

Symlink Benefits:

  1. Environment Variable Stability: /etc/profile.d/maven.sh always points to /usr/local/maven
  2. Easy Upgrades: Change symlink, don't edit config files
  3. Rollback Capability: Keep old versions, switch back if needed
  4. Standard Pattern: Matches Tomcat, JBoss, other Java tools

Step 5: Configure Java Environment​

Create system-wide Java configuration:

sudo tee /etc/profile.d/java.sh << 'EOF'
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
export PATH=$JAVA_HOME/bin:$PATH
EOF

Why /etc/profile.d/:

  • System-wide: Applies to all users
  • Login Shells: Sourced automatically when users log in
  • Survives Updates: Won't be overwritten by system updates
  • Standard Location: Used by Red Hat/CentOS/Fedora

Activation:

For current session:

source /etc/profile.d/java.sh

For future sessions: Automatic (sourced at login)

Step 6: Configure Maven Environment​

Create system-wide Maven configuration:

sudo tee /etc/profile.d/maven.sh << 'EOF'
export M2_HOME=/usr/local/maven
export MAVEN_HOME=/usr/local/maven
export PATH=$M2_HOME/bin:$PATH
EOF

Variable Naming:

  • M2_HOME: Historical name from Maven 2 days
  • MAVEN_HOME: Modern convention
  • Both set for maximum tool compatibility

Activate for current session:

source /etc/profile.d/maven.sh

Step 7: Verify Installation​

Check Java:

java -version
javac -version

Check Maven:

mvn -version

Critical Verification:

Maven's output should show:

Java version: 1.8.0_472, vendor: Red Hat, Inc.

If it shows a different Java version, Maven is using the wrong JDK.

Step 8: Test Maven​

Run Maven's system test:

mvn help:system

What This Downloads:

On first run, Maven downloads:

  • maven-help-plugin (~65 KB)
  • Plugin dependencies (~2 MB total)

Expected Result:

[INFO] BUILD SUCCESS

This confirms:

  • Maven can reach Maven Central
  • Maven can download plugins
  • Maven can execute goals
  • Java and Maven are properly integrated

Step 9: Cleanup (Optional)​

Remove the downloaded Maven archive:

rm -f apache-maven-3.6.3-bin.tar.gz

Space Saved: ~9 MB

This is optional because the file is small. However, it's good practice before creating AMI snapshots.

6. Using the Development Environment​

6.1. Creating a Maven Project​

Create a new Maven project using archetype:

mvn archetype:generate \
  -DgroupId=com.example \
  -DartifactId=my-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DarchetypeVersion=1.4 \
  -DinteractiveMode=false

Parameters Explained:

  • groupId: Usually your company's reverse domain (com.example)
  • artifactId: Project name (my-app)
  • maven-archetype-quickstart: Simple Java project template
  • interactiveMode=false: Use defaults, no prompts

Navigate to project:

cd my-app

Project Structure:

my-app/
├── pom.xml                    # Project Object Model
└── src/
    ├── main/
    │   └── java/
    │       └── com/example/
    │           └── App.java    # Main class
    └── test/
        └── java/
            └── com/example/
                └── AppTest.java # Unit test

6.2. Understanding the POM File​

View the pom.xml:

cat pom.xml

Key Sections:

<project>
  <!-- Project coordinates -->
  <groupId>com.example</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>

  <!-- Dependencies -->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

6.3. Building the Project​

Compile the code:

mvn compile

What Happens:

  1. Downloads dependencies (JUnit, etc.)
  2. Compiles src/main/java/**/*.java
  3. Places .class files in target/classes/

Run tests:

mvn test

What Happens:

  1. Compiles test code
  2. Runs JUnit tests
  3. Generates test reports in target/surefire-reports/

Package into JAR:

mvn package

What Happens:

  1. Runs compile and test
  2. Creates target/my-app-1.0-SNAPSHOT.jar

Run the application:

java -cp target/my-app-1.0-SNAPSHOT.jar com.example.App

Expected Output:

Hello World!

6.4. Common Maven Goals​

# Clean build artifacts
mvn clean

# Compile without running tests
mvn compile -DskipTests

# Install JAR to local repository
mvn install

# Run without rebuilding
mvn exec:java -Dexec.mainClass="com.example.App"

# Generate project site documentation
mvn site

# Show dependency tree
mvn dependency:tree

# Check for dependency updates
mvn versions:display-dependency-updates

6.5. Adding Dependencies​

Edit pom.xml to add a dependency (example: Apache Commons Lang):

<dependencies>
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
  </dependency>
</dependencies>

Download new dependencies:

mvn dependency:resolve

Or just run:

mvn compile

Maven automatically downloads missing dependencies.

6.6. Creating a Spring Boot Project​

Use Spring Initializr archetype:

mvn archetype:generate \
  -DarchetypeGroupId=org.springframework.boot \
  -DarchetypeArtifactId=spring-boot-sample-tomcat-archetype \
  -DarchetypeVersion=2.7.0 \
  -DgroupId=com.example \
  -DartifactId=my-spring-app

Or manually create pom.xml:

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

  <groupId>com.example</groupId>
  <artifactId>my-spring-app</artifactId>
  <version>1.0-SNAPSHOT</version>

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

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

Note: Spring Boot 2.7.x is the last version supporting Java 8. Spring Boot 3.x requires Java 17+.

7. Important File Locations​

PathPurposeNotes
/usr/lib/jvm/java-1.8.0-openjdk/Java installationJDK root directory
/usr/lib/jvm/java-1.8.0-openjdk/bin/Java binariesjava, javac, jar, javadoc
/usr/lib/jvm/java-1.8.0-openjdk/jre/Java Runtime EnvironmentJRE subdirectory
/usr/local/apache-maven-3.6.3/Maven installationActual Maven directory
/usr/local/mavenMaven symlinkPoints to Maven installation
/usr/local/maven/bin/Maven binariesmvn, mvnDebug
/usr/local/maven/conf/settings.xmlGlobal Maven settingsDefault configuration template
/etc/profile.d/java.shJava environmentSystem-wide Java configuration
/etc/profile.d/maven.shMaven environmentSystem-wide Maven configuration
~/.m2/User Maven directoryCreated on first use
~/.m2/repository/Local Maven repositoryDownloaded dependencies
~/.m2/settings.xmlUser Maven settingsOptional user-specific config
target/Maven build outputIn each project directory

8. Troubleshooting​

Problem: JAVA_HOME not set​

Cause: Environment not loaded or user logged in before Java was configured.

Solution:

# Source the environment file
source /etc/profile.d/java.sh

# Or log out and back in
exit
ssh -i your-key.pem ec2-user@YOUR_IP

# Verify
echo $JAVA_HOME

Problem: mvn: command not found​

Cause: Maven not in PATH or environment not loaded.

Solution:

# Source Maven environment
source /etc/profile.d/maven.sh

# Check if Maven binary exists
ls -la /usr/local/maven/bin/mvn

# If missing, symlink might be broken
ls -la /usr/local/maven
sudo ln -sf /usr/local/apache-maven-3.6.3 /usr/local/maven

Problem: Maven uses wrong Java version​

Cause: Multiple Java versions installed, Maven picking the wrong one.

Solution:

# Check what Maven sees
mvn -version

# Check JAVA_HOME
echo $JAVA_HOME

# If wrong, fix in /etc/profile.d/java.sh
sudo nano /etc/profile.d/java.sh

# Set correct path
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk

# Source and verify
source /etc/profile.d/java.sh
mvn -version

Problem: Maven build fails with "OutOfMemoryError"​

Cause: Maven default memory too small for large projects.

Solution:

# Set Maven options
export MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=256m"

# Or create ~/.mavenrc
echo 'MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=256m"' > ~/.mavenrc

# Retry build
mvn clean install

Problem: Dependencies won't download​

Cause: Maven Central unreachable, firewall blocking, or network issue.

Solution:

# Test network connectivity
ping repo.maven.apache.org

# Try using HTTP instead of HTTPS (if corporate proxy)
# Edit ~/.m2/settings.xml or /usr/local/maven/conf/settings.xml

# Clear corrupted cache
rm -rf ~/.m2/repository/

# Force re-download
mvn dependency:purge-local-repository

Problem: "javac: command not found"​

Cause: Only JRE installed, not JDK.

Solution:

# Install JDK
sudo dnf install -y java-1.8.0-openjdk-devel

# Verify
javac -version

Problem: SSL handshake failures with Maven Central​

Cause: Java 8 has older SSL/TLS protocols disabled by default.

Solution:

# Add to Maven options
export MAVEN_OPTS="-Dhttps.protocols=TLSv1.2"

# Or upgrade CA certificates
sudo dnf update -y ca-certificates

9. Advanced Topics​

9.1. Configuring Maven Settings​

Create ~/.m2/settings.xml for user-specific configuration:

<settings>
  <!-- Use a mirror for faster downloads -->
  <mirrors>
    <mirror>
      <id>central-mirror</id>
      <mirrorOf>central</mirrorOf>
      <url>https://repo1.maven.org/maven2</url>
    </mirror>
  </mirrors>

  <!-- Configure proxy if needed -->
  <proxies>
    <proxy>
      <id>myproxy</id>
      <active>true</active>
      <protocol>http</protocol>
      <host>proxy.example.com</host>
      <port>8080</port>
    </proxy>
  </proxies>

  <!-- Set default JDK profile -->
  <profiles>
    <profile>
      <id>jdk-1.8</id>
      <activation>
        <jdk>1.8</jdk>
      </activation>
      <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
      </properties>
    </profile>
  </profiles>
</settings>

9.2. Multi-Module Projects​

Create a parent POM:

<project>
  <groupId>com.example</groupId>
  <artifactId>parent-project</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <modules>
    <module>module-a</module>
    <module>module-b</module>
  </modules>
</project>

Build all modules:

mvn clean install

9.3. Building Executable JARs​

Add to pom.xml:

<build>
  <plugins>
    <plugin>
      <artifactId>maven-assembly-plugin</artifactId>
      <configuration>
        <archive>
          <manifest>
            <mainClass>com.example.App</mainClass>
          </manifest>
        </archive>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
      </configuration>
    </plugin>
  </plugins>
</build>

Build:

mvn assembly:assembly

Run:

java -jar target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar

9.4. Integrating with CI/CD​

Jenkins Pipeline Example:

pipeline {
    agent any
    tools {
        maven 'Maven 3.6.3'
        jdk 'JDK 8'
    }
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
    }
}

9.5. Performance Tuning​

Parallel Builds:

# Use 4 threads
mvn -T 4 clean install

# Use 1 thread per CPU core
mvn -T 1C clean install

Offline Mode:

# Don't check for updates
mvn -o clean install

Skip Tests:

# Compile but don't run tests
mvn install -DskipTests

# Don't even compile tests
mvn install -Dmaven.test.skip=true

10. Security Considerations​

10.1. Dependency Security​

Check for vulnerable dependencies:

# Add dependency-check plugin to pom.xml
mvn org.owasp:dependency-check-maven:check

Update dependencies:

# Check for updates
mvn versions:display-dependency-updates

# Update to latest versions
mvn versions:use-latest-versions

10.2. Maven Repository Security​

Use HTTPS for repositories:

<repositories>
  <repository>
    <id>central</id>
    <url>https://repo.maven.apache.org/maven2</url>
  </repository>
</repositories>

Verify checksums:

Maven automatically verifies SHA-1 checksums for downloaded artifacts.

10.3. Firewall Best Practices​

Only expose necessary ports:

# SSH (restrict to your IP)
Source: YOUR_IP/32, Port: 22

# Application port (if running web app)
Source: 0.0.0.0/0, Port: 8080 (HTTP) or 443 (HTTPS)

# Do NOT expose:
# - Maven repository ports
# - JMX monitoring ports

11. Final Notes​

What You've Got​

This AMI provides a complete, production-ready Java 8 development environment:

  • ✅ Java 8 OpenJDK 1.8.0_472 (latest patch)
  • ✅ Maven 3.6.3 stable build tool
  • ✅ System-wide environment configuration
  • ✅ Symbolic link strategy for easy upgrades
  • ✅ Complete JDK (compiler + runtime)

  1. Learn Java Basics (if new to Java):

  2. Learn Maven:

  3. Explore Spring Framework:

  4. Join the Community:

Java 8 vs Newer Versions​

When to Use Java 8:

  • Legacy applications requiring Java 8
  • Organizations with Java 8 standard
  • Maximum library compatibility
  • Long-term support until 2030 (some vendors)

Consider Upgrading If:

  • Starting a new project (use Java 17 or 21 LTS)
  • Need modern language features (records, pattern matching, etc.)
  • Want better performance (newer GC algorithms)
  • Require longer support (Java 17 supported until 2029)

Performance Expectations​

Java 8 excels at:

  • Enterprise Applications: Proven stability
  • Microservices: Lightweight with proper tuning
  • Batch Processing: Excellent multi-threading
  • Spring Framework: Optimal compatibility

Cost Optimization​

For development:

  • t3.micro (1 vCPU, 1GB RAM): Learning and small apps
  • t3.small (2 vCPU, 2GB RAM): Medium Spring Boot apps

For production:

  • t3.medium+ (2+ vCPU, 4GB+ RAM): Recommended minimum
  • m5.large+: For memory-intensive apps (large heap)
  • c5.large+: For CPU-intensive processing

Java 8 is more memory-efficient than newer versions for many workloads.

Happy coding with Java 8! ☕