DEV Community

Cover image for Setting Up Nexus Repository on AWS EC2 with Terraform and Publishing a Custom Gradle Plugin
Himanshu Singh Tomar
Himanshu Singh Tomar

Posted on

Setting Up Nexus Repository on AWS EC2 with Terraform and Publishing a Custom Gradle Plugin

#nexus #programming #awschallenge #vim

1. Introduction to Sonatype Nexus

What is Sonatype Nexus?

Sonatype Nexus is a powerful, open-source repository manager that allows organizations to store and manage software artifacts. It supports both internal and external repositories for various package formats such as Maven, npm, NuGet, Docker, and more. Nexus helps in managing and distributing binary artifacts, ensuring efficient version control and secure access to packages within an organization.

Image nexus-repo

Why Use Nexus?

Nexus Repository provides several benefits:

  • Centralized Artifact Management: Nexus stores artifacts like libraries, dependencies, and Docker images, making them easy to share and reuse across different projects.
  • Secure Artifact Distribution: It allows for secure access to artifacts through permissions and policies, preventing unauthorized access and ensuring the integrity of software artifacts.
  • Supports Multiple Formats: Nexus supports different repository formats such as Maven, npm, Docker, etc., making it flexible and adaptable for various development environments.
  • Integration with Build Systems: Nexus can be integrated into CI/CD pipelines for automated artifact management and deployment.

2. Project Overview

In this project, we automated the installation of Sonatype Nexus on an AWS EC2 instance using Terraform and demonstrated the publishing and usage of a custom Gradle plugin through Nexus.

The project is divided into three major parts:

  1. Deploy Nexus via Terraform
  2. Create and Publish a Custom Gradle Plugin to Nexus
  3. Use the Published Plugin in a Spring Boot Backend Project

3. Deploying Nexus Using Terraform

We created a Terraform configuration to:

Key Terraform Files:

main.tf 

provider "aws" { region = "us-east-1" # Adjust region if necessary } resource "aws_instance" "nexus" { ami = "ami-0c55b159cbfafe1f0" # Amazon Linux 2 AMI (adjust for your region) instance_type = "t3.medium" # Adjust instance type as per your requirements key_name = "your-ssh-key" # Replace with your SSH key name # Security Group to allow access to port 8081 (Nexus) security_group = aws_security_group.nexus_sg.name # Instance metadata and user data to run the Nexus installation script user_data = <<-EOF #!/bin/bash set -e # Update system and install Java sudo apt update && sudo apt upgrade -y sudo apt install openjdk-8-jdk -y # Create nexus user sudo adduser --disabled-password --gecos "" nexus sudo usermod -aG sudo nexus # Download and install Nexus cd /opt sudo wget https://download.sonatype.com/nexus/3/nexus-3.70.4-02-java8-unix.tar.gz sudo tar -xvzf nexus-3.70.4-02-java8-unix.tar.gz sudo mv nexus-3.70.4-02 nexus sudo chown -R nexus:nexus /opt/nexus # Configure Nexus to run as nexus user echo 'run_as_user="nexus"' | sudo tee /opt/nexus/bin/nexus.rc # Create systemd service for Nexus cat <<EOF2 | sudo tee /etc/systemd/system/nexus.service [Unit] Description=Nexus Repository Manager After=network.target [Service] Type=forking LimitNOFILE=65536 ExecStart=/opt/nexus/bin/nexus start ExecStop=/opt/nexus/bin/nexus stop User=nexus Restart=on-abort [Install] WantedBy=multi-user.target EOF2 # Reload systemd and enable Nexus service sudo systemctl daemon-reexec sudo systemctl daemon-reload sudo systemctl enable nexus sudo systemctl start nexus # Print default admin password and Nexus URL echo -e "\n✅ Nexus is installed and running on port 8081." sudo cat /opt/sonatype-work/nexus3/admin.password echo -e "\n💡 Access Nexus at: http://$(curl -s http://169.254.169.254/latest/meta-data/public-ipv4):8081"  EOF  # Tags for the instance tags = { Name = "Nexus Server" } } # Security group to allow HTTP and HTTPS access resource "aws_security_group" "nexus_sg" { name = "nexus_sg" description = "Allow HTTP, HTTPS, and SSH access" ingress { from_port = 8081 to_port = 8081 protocol = "tcp" cidr_blocks = ["0.0.0.0/0"] } ingress { from_port = 22 to_port = 22 protocol = "tcp" cidr_blocks = ["0.0.0.0/0"] } egress { from_port = 0 to_port = 0 protocol = "-1" cidr_blocks = ["0.0.0.0/0"] } } output "nexus_public_ip" { value = aws_instance.nexus.public_ip description = "The public IP address of the Nexus server" }
Enter fullscreen mode Exit fullscreen mode

Image AWS

Nexus Status

Image AWS Status

4. Creating a Custom Gradle Plugin

We created a Gradle plugin project to define reusable logic. Here’s how:

build.gradle 

plugins { id 'java-gradle-plugin' id 'maven-publish' } group = 'com.dependencie' version = '1.0.0-SNAPSHOT' repositories { mavenCentral() } dependencies { implementation gradleApi() implementation localGroovy() } gradlePlugin { plugins { backendPublisher { id = 'com.dependencie.nexusplugin' implementationClass = 'com.dependencie.nexusplugin.BackendPublisherPlugin' } } } publishing { repositories { maven { name = "nexusSnapshots" url = uri("http://<your-ec2-ip>:8081/repository/maven-snapshots/") allowInsecureProtocol = true credentials { username = "admin" password = "12345" } } } }
Enter fullscreen mode Exit fullscreen mode

Image nexus-plugin

Plugin Implementation (BackendPublisherPlugin.java) 

package com.dependencie.nexusplugin; import org.gradle.api.Plugin; import org.gradle.api.Project; public class BackendPublisherPlugin implements Plugin<Project> { @Override public void apply(Project project) { project.getPluginManager().apply("java"); project.getPluginManager().apply("org.springframework.boot"); project.getPluginManager().apply("io.spring.dependency-management"); project.setGroup("com.example"); project.setVersion("0.0.1-SNAPSHOT"); project.getExtensions().getExtraProperties().set("springBootVersion", "3.4.4"); project.getRepositories().mavenCentral(); project.getDependencies().add("implementation", "org.springframework.boot:spring-boot-starter-data-jpa"); project.getDependencies().add("implementation", "org.springframework.boot:spring-boot-starter-web"); project.getDependencies().add("implementation", "org.springframework.boot"); project.getDependencies().add("compileOnly", "org.projectlombok:lombok"); project.getDependencies().add("runtimeOnly", "com.h2database:h2"); project.getDependencies().add("annotationProcessor", "org.projectlombok:lombok"); project.getDependencies().add("testImplementation", "org.springframework.boot:spring-boot-starter-test"); project.getDependencies().add("testRuntimeOnly", "org.junit.platform:junit-platform-launcher"); } }
Enter fullscreen mode Exit fullscreen mode

Publishing the Plugin

Run this in the plugin project root:

./gradlew publish
Enter fullscreen mode Exit fullscreen mode

The plugin will be published to your Nexus snapshot repository.

5. Using the Custom Plugin in a Backend Project

Once published, we integrated the custom plugin into a Spring Boot project.

Image setting.gradle

Backend Project Structure

settings.gradle

pluginManagement { repositories { maven { url = uri("http://<your-ec2-ip>:8081/repository/maven-snapshots/") allowInsecureProtocol = true credentials { username = "admin" password = "12345" } } gradlePluginPortal() mavenCentral() } } rootProject.name = 'employee-management'
Enter fullscreen mode Exit fullscreen mode

Image backend
build.gradle

plugins { id 'com.dependencie.nexusplugin' version '1.0.0-SNAPSHOT' id 'java' id 'org.springframework.boot' version '3.4.4' id 'io.spring.dependency-management' version '1.1.7' } group = 'com.example' version = '0.0.1-SNAPSHOT' java { toolchain { languageVersion = JavaLanguageVersion.of(17) } } repositories { mavenCentral() maven { url = uri("http://<your-ec2-ip>:8081/repository/maven-snapshots/") allowInsecureProtocol = true credentials { username = "admin" password = "12345" } } } dependencies { implementation 'org.springframework.boot:spring-boot-starter-data-jpa' implementation 'org.springframework.boot:spring-boot-starter-web' compileOnly 'org.projectlombok:lombok' annotationProcessor 'org.projectlombok:lombok' runtimeOnly 'com.h2database:h2' testImplementation 'org.springframework.boot:spring-boot-starter-test' } tasks.named('test') { useJUnitPlatform() }
Enter fullscreen mode Exit fullscreen mode

Verify Plugin Integration

Run:

./gradlew helloPlugin
Enter fullscreen mode Exit fullscreen mode

Output:

✅ Custom Nexus Plugin Applied Successfully!
Enter fullscreen mode Exit fullscreen mode

6. Conclusion

In this end-to-end setup, we:

  • Deployed Sonatype Nexus on AWS EC2 using Terraform
  • Created and published a custom Gradle plugin to Nexus
  • Integrated that plugin into a Spring Boot backend project

This setup can be expanded further to publish internal libraries, enforce quality gates, or share reusable Gradle logic across teams.

Top comments (0)