Setup Java local profile

Prerequisites

At this point it is assumed, that the initial setup and the mandatory commands of the Solution CLI have been performed and executed as described here.

Now its always helpful if you can run, test and debug your service project locally. To achieve that we need to provide some needed configuration.

Configuration approaches

  • Have a valid deployed project and use its k8s configuration maps to load bindings for your database and Kafka.

  • Provide configuration values to connect to your local database and Kafka broker.

Attention: If you choose to use deployed project k8s configuration maps, you need to log in to your OpenShift cluster via oc CLI and run proper oc proxy command to be able to connect to your OpenShift namespace Database and Kafka clusters.

Setting up local profile

Tip: Use `\src\main\resources\application-local.template.yaml` as the basis to create an `application-local.yaml` file and override properties needed for the local profile.

First add your service project acronym

solution:
    acronym : "project acronym"

Second configure needed database, kafka and manage different features auto configuration and Swagger UI, see below sections.

OpenShift k5-project namespace bindings

To load bindings from OpenShift k5-project namespace use the below configuration

de:
  knowis:
    cp:
      consumer:
        kubernetes:
          namespace: <k5-Project>

Auto configuration features

To enable / disable some auto configuration features

  feature:
    kafka-events:
      enabled: true
    mongo:
      enabled: true
    security:
      enabled: true
    openapi:
      enabled: true
    webmvc:
      enabled: true

Database configuration

Depending on your service project selected Persistence Type or , you can configure your database as below.

MongoDB persistence

Load MongoDB configuration from k8s configuration map

spring:
  data:
    mongodb:
        secretName: # read from kubernetes secret

To access local MongoDB, you can set the spring.data.mongodb.uri property to change the URL and configure additional settings, as shown in the following example:

spring:
  data:
    mongodb:
      uri: mongodb://<username>:<secret>@<host>:<port>/<database>
      database: <database>

Alternatively, you can specify connection details using discrete properties. For example, you might declare the following settings as shown below:

spring:
  data:
    mongodb:
      host: <host>
      port: <port>
      database: <database>
      username: <username>
      password: <password>

RDBMS Persistence

To access your service project RDBMS database, you need to add below configuration

spring:
  datasource:
    url: "jdbc:<subprotocol name>://<host>:<port>/<database-name>"
    username: <user name>
    password: <password>
    driver-class-name: <Your database driver class>

Kafka configurations

Load event topic binding configuration from k8s secret(s)

  1. You need to add your k5-project as described in Here

  2. You need to have proper oc proxy and oc port forwarding to be able to access your OpenShift k5 project event topic binding secret(s) and their configured Kafka cluster.

Alternatively, you can configure to use your Kafka broker and your own local topic binding secret(s).

  1. Install and configure your Kafka broker see https://kafka.apache.org/quickstart

  2. For each topic add proper event topic binding configuration like below

de.knowis.cp.binding.topic:
  topicBindings:
    <Topic-Alias-1>: 
      topicName: "<Kafka topic name>"
      kafkaBinding: "<Kafka-Secret-1>"
    <Topic-Alias-2>: 
      topicName: "<Kafka topic name>"
      kafkaBinding: "<Kafka-Secret-2>"
  kafkaBindings:
    <Kafka-Secret-1>:
      kafka_brokers_sasl: ""
      password: ""
      user: ""
    <Kafka-Secret-2>:
      kafka_brokers_sasl: ""
      password: ""
      user: ""
Note: Kafka broker user and password are optional if your Kafka broker is not secured.

Swagger UI

To configure Swagger UI for local development, use the settings below:

springdoc:
  swagger-ui:
    oauth:
      clientId: <client-id>

If you have spring-security-oauth2-client on your classpath, you can take advantage of some auto configuration to set up an OAuth2/Open ID Connect client, as shown in the following example:

spring:
  security:
    oauth2:
      client: #Spring Security OAuth2  config
        provider:
          default:
            issuer-uri: <issuer-uri>
          <client-id>: 
            jwk-set-uri: <jwk-set-uri>
            token-uri: <token-uri>
            issuer-uri: <issuer-uri>
        registration: 
          default:
            client-id: <client-id>
          <client-id>: # only required if the access type of the client is not public
            client-id: <client-id>
            client-secret: <secret>

Schema registry configurations

To configure schema registry for local development, please use the settings below:

de.knowis.schema-registry:
  schemaRegistryConfig:
    schemaRegistryUrl: <schema-registry-url>
    schemaAuthServerUrl: <schema-auth-server-url>
    authRealm: <auth-realm>
    clientSecret: <client-secret-token>
    clientId: <client-id>

Running with local profile

Create a new Run Configuration for a Java Application. Pass the configuration below as jvm arguments to use the local profile.

-Dspring.profiles.active=local

Build and run the code.

Note: Refer to Spring Boot's official documentation for more details on Database and Kafka additional configuration.