Operator SDK - Spring Boot Starter

Spring Boot starter for framework

License

License

Categories

Categories

Spring Boot Container Microservices
GroupId

GroupId

io.javaoperatorsdk
ArtifactId

ArtifactId

spring-boot-operator-framework-starter
Last Version

Last Version

1.5.0
Release Date

Release Date

Type

Type

jar
Description

Description

Operator SDK - Spring Boot Starter
Spring Boot starter for framework

Download spring-boot-operator-framework-starter

How to add to project

<!-- https://jarcasting.com/artifacts/io.javaoperatorsdk/spring-boot-operator-framework-starter/ -->
<dependency>
    <groupId>io.javaoperatorsdk</groupId>
    <artifactId>spring-boot-operator-framework-starter</artifactId>
    <version>1.5.0</version>
</dependency>
// https://jarcasting.com/artifacts/io.javaoperatorsdk/spring-boot-operator-framework-starter/
implementation 'io.javaoperatorsdk:spring-boot-operator-framework-starter:1.5.0'
// https://jarcasting.com/artifacts/io.javaoperatorsdk/spring-boot-operator-framework-starter/
implementation ("io.javaoperatorsdk:spring-boot-operator-framework-starter:1.5.0")
'io.javaoperatorsdk:spring-boot-operator-framework-starter:jar:1.5.0'
<dependency org="io.javaoperatorsdk" name="spring-boot-operator-framework-starter" rev="1.5.0">
  <artifact name="spring-boot-operator-framework-starter" type="jar" />
</dependency>
@Grapes(
@Grab(group='io.javaoperatorsdk', module='spring-boot-operator-framework-starter', version='1.5.0')
)
libraryDependencies += "io.javaoperatorsdk" % "spring-boot-operator-framework-starter" % "1.5.0"
[io.javaoperatorsdk/spring-boot-operator-framework-starter "1.5.0"]

Dependencies

compile (3)

Group / Artifact Type Version
org.springframework.boot : spring-boot-autoconfigure-processor Optional jar
org.springframework.boot : spring-boot-autoconfigure jar
io.javaoperatorsdk : operator-framework jar 1.5.0

test (5)

Group / Artifact Type Version
org.springframework.boot : spring-boot-starter-test jar
org.junit.jupiter : junit-jupiter-api jar 5.7.0
org.junit.jupiter : junit-jupiter-engine jar 5.7.0
org.junit.platform : junit-platform-commons jar 1.7.0
org.mockito : mockito-core jar 3.6.0

Project Modules

There are no modules declared in this project.

java-operator-sdk

Java CI with Maven

Build Kubernetes Operators in Java without hassle. Inspired by operator-sdk.

S.No. Contents
1. Features
2. Why build your own Operator?
3. Roadmap
4. Join us on Discord!
5. User Guide
6. Usage
7. Spring Boot

Features

  • Framework for handling Kubernetes API events
  • Registering Custom Resource watches
  • Retry action on failure
  • Smart event scheduling (only handle latest event for the same resource)

Check out this blog post about the non-trivial yet common problems needed to be solved for every operator.

Why build your own Operator?

  • Infrastructure automation using the power and flexibility of Java. See blog post.
  • Provisioning of complex applications - avoiding Helm chart hell
  • Integration with Cloud services - e.g. Secret stores
  • Safer deployment of applications - only expose cluster to users by Custom Resources

Roadmap

  • Testing of the framework and all samples while running on a real cluster.
  • Generate a project skeleton
  • Generate Java classes from CRD defintion (and/or the other way around)
  • Integrate with Quarkus (including native image build)
  • Integrate with OLM (Operator Lifecycle Manager)

Join us on Discord!

Discord Invite Link

User Guide

You can (will) find detailed documentation here. Note that these docs are currently in progress.

Usage

We have several sample Operators under the samples directory:

  • basic: Minimal Operator implementation which only parses the Custom Resource and prints to stdout. Implemented with and without Spring Boot support. The two samples share the common module.
  • webserver: More realistic example creating an nginx webserver from a Custom Resource containing html code.
  • mysql-schema: Operator managing schemas in a MySQL database
  • spring-boot-plain/auto-config: Samples showing integration with Spring Boot.

Add dependency to your project with Maven:

<dependency>
  <groupId>io.javaoperatorsdk</groupId>
  <artifactId>operator-framework</artifactId>
  <version>{see https://search.maven.org/search?q=a:operator-framework for latest version}</version>
</dependency>

Or alternatively with Gradle, which also requires declaring the SDK as an annotation processor to generate the mappings between controllers and custom resource classes:

dependencies {
    implementation "io.javaoperatorsdk:operator-framework:${javaOperatorVersion}"
    annotationProcessor "io.javaoperatorsdk:operator-framework:${javaOperatorVersion}"
}

Once you've added the dependency, define a main method initializing the Operator and registering a controller.

public class Runner {

   public static void main(String[] args) {
       Operator operator = new Operator(new DefaultKubernetesClient(),
           DefaultConfigurationService.instance());
       operator.register(new WebServerController());
   }
}

The Controller implements the business logic and describes all the classes needed to handle the CRD.

@Controller(crdName = "webservers.sample.javaoperatorsdk")
public class WebServerController implements ResourceController<WebServer> {

    @Override
    public DeleteControl deleteResource(CustomService resource, Context<WebServer> context) {
        // ... your logic ...
        return DeleteControl.DEFAULT_DELETE;
    }
    
    // Return the changed resource, so it gets updated. See javadoc for details.
    @Override
    public UpdateControl<CustomService> createOrUpdateResource(CustomService resource, Context<WebServer> context) {
        // ... your logic ...
        return UpdateControl.updateStatusSubResource(resource);
    }
}

A sample custom resource POJO representation

public class WebServer extends CustomResource {

    private WebServerSpec spec;

    private WebServerStatus status;

    public WebServerSpec getSpec() {
        return spec;
    }

    public void setSpec(WebServerSpec spec) {
        this.spec = spec;
    }

    public WebServerStatus getStatus() {
        return status;
    }

    public void setStatus(WebServerStatus status) {
        this.status = status;
    }
}

public class WebServerSpec {

    private String html;

    public String getHtml() {
        return html;
    }

    public void setHtml(String html) {
        this.html = html;
    }
}

Quarkus

A Quarkus extension is also provided to ease the development of Quarkus-based operators.

Add this dependency to your project:

<dependency>
 <groupId>io.javaoperatorsdk</groupId>
 <artifactId>operator-framework-quarkus-extension</artifactId>
 <version>{see https://search.maven.org/search?q=a:operator-framework-quarkus-extension for latest version}</version>
</dependency>

Create an Application, Quarkus will automatically create and inject a KubernetesClient, Operator and ConfigurationService instances that your application can use, as shown below:

@QuarkusMain
public class QuarkusOperator implements QuarkusApplication {

  @Inject KubernetesClient client;

  @Inject Operator operator;

  @Inject ConfigurationService configuration;

  public static void main(String... args) {
    Quarkus.run(QuarkusOperator.class, args);
  }

  @Override
  public int run(String... args) throws Exception {
    final var config = configuration.getConfigurationFor(new CustomServiceController(client));
    System.out.println("CR class: " + config.getCustomResourceClass());
    System.out.println("Doneable class = " + config.getDoneableClass());

    Quarkus.waitForExit();
    return 0;
  }
}

Spring Boot

You can also let Spring Boot wire your application together and automatically register the controllers.

Add this dependency to your project:

<dependency>
 <groupId>io.javaoperatorsdk</groupId>
 <artifactId>operator-framework-spring-boot-starter</artifactId>
 <version>{see https://search.maven.org/search?q=a:operator-framework-spring-boot-starter for latest version}</version>
</dependency>

Create an Application

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Spring Boot test support

Adding the following dependency would let you mock the operator for the tests where loading the spring container is necessary, but it doesn't need real access to a Kubernetes cluster.

<dependency>
 <groupId>io.javaoperatorsdk</groupId>
 <artifactId>operator-framework-spring-boot-starter-test</artifactId>
 <version>{see https://search.maven.org/search?q=a:operator-framework-spring-boot-starter for latest version}</version>
</dependency>

Mock the operator:

@SpringBootTest
@EnableMockOperator
public class SpringBootStarterSampleApplicationTest {

  @Test
  void contextLoads() {}
}

Versions

Version
1.5.0
1.4.0
1.3.0