Two new Maven Central releases package RagLeap's existing infrastructure files for Java applications.

RagLeap has published two new Java artifacts:

  • ragleap-ansible 0.1.2
  • ragleap-terraform 0.1.1

Both are available through Maven Central.

These releases are designed for Java developers who want to read RagLeap's existing infrastructure resources from a Java application.

One important clarification:

These are resource-packaging releases, not Java ports of Ansible or Terraform.

The JARs contain the same six files distributed through the corresponding PyPI wheels. They provide small Java classes for reading those resources from the classpath.

Ansible and Terraform are not included or executed by the JARs.

Why package these resources for Java?

RagLeap is an open-source, self-hosted AI infrastructure ecosystem.

Its infrastructure packages include Ansible resources and Terraform modules. These are useful beyond the Python application itself, so I wanted to make the existing files accessible from Java projects too.

Rather than rewriting the resources in Java, the releases package the original files.

This gives Java applications a simple way to access them while keeping the Python distributions as the matching resource source.

1. RagLeap Ansible Java 0.1.2

Maven coordinates:

<dependency> <groupId>io.github.antonyrag</groupId> <artifactId>ragleap-ansible</artifactId> <version>0.1.2</version> </dependency>

Release:

https://github.com/ragleap/ragleap-core/releases/tag/ragleap-ansible-java-v0.1.2

Maven Central:

https://central.sonatype.com/artifact/io.github.antonyrag/ragleap-ansible/0.1.2

PyPI:

https://pypi.org/project/ragleap-ansible/0.1.2/

Included resources

The JAR contains the six files from the PyPI wheel, including:

playbooks/bootstrap.yml

The Java resource reader is:

com.ragleap.ansible.RagleapAnsible

It provides:

openPlaybook(path)

and:

readPlaybookString(path)

Example:

import com.ragleap.ansible.RagleapAnsible; public class Example { public static void main(String[] args) throws Exception { String playbook = RagleapAnsible.readPlaybookString("bootstrap.yml"); System.out.println(playbook); } }

The path is resolved under the packaged playbooks/ tree.

Paths must be relative. Backslashes and parent-directory traversal are rejected.

Ansible execution is not included

This Java artifact only reads the packaged playbook resources.

It does not:

  • Include Ansible.
  • Run playbooks.
  • Start processes.
  • Connect to remote hosts.
  • Change infrastructure.

You still need Ansible separately if you want to execute the playbooks.

2. RagLeap Terraform Java 0.1.1

Maven coordinates:

<dependency> <groupId>io.github.antonyrag</groupId> <artifactId>ragleap-terraform</artifactId> <version>0.1.1</version> </dependency>

Release:

https://github.com/ragleap/ragleap-core/releases/tag/ragleap-terraform-java-v0.1.1

Maven Central:

https://central.sonatype.com/artifact/io.github.antonyrag/ragleap-terraform/0.1.1

PyPI:

https://pypi.org/project/ragleap-terraform/0.1.1/

Included resources

The JAR contains the six Terraform files from the corresponding PyPI wheel:

modules/kind-cluster/main.tf modules/kind-cluster/variables.tf modules/kind-cluster/outputs.tf modules/kind-cluster/versions.tf examples/kind/main.tf examples/kind/.terraform.lock.hcl

The resource reader is:

com.ragleap.terraform.RagleapTerraform

It provides:

open(...)

and:

readString(...)

Example:

import com.ragleap.terraform.RagleapTerraform; public class Example { public static void main(String[] args) throws Exception { String module = RagleapTerraform.readString( "modules/kind-cluster/main.tf" ); System.out.println(module); } }

The resource is read from the JAR's classpath.

Terraform execution is not included

The Java artifact does not include Terraform or execute Terraform commands.

The current packaged module creates a local kind cluster. Cloud modules are not included yet.

The module's actual application remains a Terraform responsibility.

3. Resource parity: the important part

Both Java releases package the same files as their corresponding Python distributions.

That was verified through file-list and file-content comparisons.

The six files in each published JAR were compared byte for byte against the matching PyPI wheel.

The result:

  • Ansible Java 0.1.2: six matching resource files.
  • Terraform Java 0.1.1: six matching resource files.

This is the main design goal.

The Java artifacts should not become a separate version of the infrastructure resources.

Keeping the packaged files identical reduces the chance of Java and Python distributions drifting apart.

4. Published artifact verification

Both releases were built from:

e5e4328837758a03cb21e1207c8aec90a88b5c87

Build environment:

OpenJDK 21.0.12 Maven 3.6.3

Build command:

mvn -Prelease clean deploy

The JAR, sources JAR, Javadoc JAR, and POM were signed.

All four signatures were verified before upload.

After publication, the JARs served by Maven Central were checked against the locally built artifacts.

Ansible 0.1.2

Published JAR SHA-256:

1e33f98f9f4bea29763686fec4de97aad6bbc14e1447d1a4a958917062319cf4

The published JAR matched the locally built JAR.

Its signature verified with the same key.

Central listed 24 files for the release.

Terraform 0.1.1

Published JAR SHA-256:

a73b1030f79c6827a7afc8689b986e2ca929cdc7097e6f2e1b4f6557f127a354

The published JAR matched the locally built JAR.

Its signature verified with the same key.

Central listed 24 files for the release.

These checks cover the published artifact, checksum, signature, and resource parity.

5. CI checks

The Ansible resource-parity workflow passed on main and on the pull request.

The Terraform resource-parity check passed on main.

The workflows compare the packaged file list and contents against the corresponding Python wheel.

The infrastructure execution tests remain in the Python package test suites:

  • Ansible: container idempotence and real-host tests on GitHub-hosted Ubuntu 22.04 and 24.04.
  • Terraform: live apply and destroy testing on a real kind cluster.

Those tests were not repeated by the Java JAR releases.

6. What is not tested yet?

The published JARs were not built into a separate consuming Java project.

Other JDK and Maven versions were not tested.

The JARs only package resources. They do not provide an execution environment for Ansible or Terraform.

So the current verification should not be interpreted as a claim that Java applications can execute infrastructure automation directly through these artifacts.

The releases are intentionally limited to resource access.

7. Try the releases

Ansible Java 

<dependency> <groupId>io.github.antonyrag</groupId> <artifactId>ragleap-ansible</artifactId> <version>0.1.2</version> </dependency>

Terraform Java 

<dependency> <groupId>io.github.antonyrag</groupId> <artifactId>ragleap-terraform</artifactId> <version>0.1.1</version> </dependency>

RagLeap Core

https://github.com/ragleap/ragleap-core

Final note

These releases are a small but practical step toward making RagLeap's infrastructure resources easier to use across language ecosystems.

The goal is not to replace Ansible or Terraform with Java.

The goal is to let Java applications access the same infrastructure resources that RagLeap already distributes through Python—while keeping the package boundaries clear and the verification claims honest.

More open-source infrastructure work is ongoing.