Skip to content

Novelty Helm Chart Quickstart

Follow this link for the Full Helm chart.

Prerequisites

Kubernetes

A Kubernetes cluster is required to install Novelty with Helm.

Helm

Helm must be installed to use the charts. Please refer to Helm's documentation to get started.

Once Helm has been set up correctly, add the repo as follows:
helm repo add thatdot https://helm.thatdot.com

If you have previously added this repo, run helm repo update to retrieve the latest versions of the packages. You can then run helm search repo thatdot to see the charts.

Cassandra Compatible Database

Apache Cassandra or a Cassandra-compatible database such as ScyllaDB is required to use Novelty.

The database used with Novelty may be installed in the same Kubernetes cluster as Novelty, but this is not required. However, it is recommended that it be physically located as close to the Novelty installation as possible to reduce network latency, such as ensuring they are both located in the same AWS region or availability zone.

There are a variety of ways to install Apache Cassandra or ScyllaDB into Kubernetes. For production, use an operator, which manages scaling and upgrades:

Set the persistor's local datacenter to the name of your Cassandra datacenter by adding -Dthatdot.novelty.store.local-datacenter=<DATACENTER_NAME> to extraJdkArgs in your Helm values. A plain Cassandra install uses datacenter1, which is also the default for this setting. With an operator, use the name you gave the datacenter.

License

Novelty is proprietary software and a license is required to use it.

To request an evaluation, schedule a demo, or purchase a license, contact thatDot or email sales@thatdot.com.

Once you receive your license key, you must store it in a Kubernetes secret and reference that secret in the Helm values using the licenseKeySecret field.

The same key is also your credential for the private image registry that distributes the Novelty image, registry.license.thatdot.com: the registry username is your client id, and the password is the license key itself. You can verify your credentials from a workstation with docker:

echo <LICENSE_KEY> | \
    docker login registry.license.thatdot.com \
    -u <CLIENT_ID> \
    --password-stdin

docker pull \
    registry.license.thatdot.com/thatdot/novelty:1.2.0

Installation

Helm Values

First create a values file called novelty-values.yaml with required helm configuration values (see values.yaml for a reference of available configuration and defaults):

# Settings for using Cassandra cluster as the persistor. REQUIRED.
extraJdkArgs: >-
  -Dthatdot.novelty.store.type=cassandra
  -Dthatdot.novelty.store.endpoints.0=<CASSANDRA_ADDRESS_1>
  -Dthatdot.novelty.store.endpoints.1=<CASSANDRA_ADDRESS_2>
  -Dthatdot.novelty.store.should-create-keyspace=true
  -Dthatdot.novelty.store.should-create-tables=true

The Novelty chart has no Cassandra values, so the persistor settings are Java system properties in extraJdkArgs, which the chart adds to the JVM options. See Cassandra Setup for the other settings. The chart cannot read a Cassandra password from a Kubernetes secret, and extraJdkArgs is stored in plain text in the Deployment and printed by the JVM when it starts, so do not put credentials in it.

Create a Kubernetes secret containing your license key:

kubectl create secret generic novelty-license \
  --from-literal=license-key="YOUR_LICENSE_KEY"

Then reference this secret in your Helm values:

licenseKeySecret:
  name: novelty-license
  key: license-key

The Novelty image is pulled from thatDot's private registry, authenticated with the same license key. Create a kubernetes.io/dockerconfigjson secret holding that credential:

kubectl create secret docker-registry thatdot-registry \
  --docker-server=registry.license.thatdot.com \
  --docker-username=<CLIENT_ID> \
  --docker-password=<LICENSE_KEY>

The resulting secret is a docker login stored as data. If you manage manifests directly or use a secrets operator, the equivalent shape is:

apiVersion: v1
kind: Secret
metadata:
  name: thatdot-registry
type: kubernetes.io/dockerconfigjson
stringData:
  .dockerconfigjson: |
    {"auths": {"registry.license.thatdot.com": {
      "username": "<CLIENT_ID>",
      "password": "<LICENSE_KEY>",
      "auth": "<base64 of CLIENT_ID:LICENSE_KEY>"}}}

Reference the image in your Helm values:

image:
  repository: registry.license.thatdot.com/thatdot/novelty
  pullPolicy: IfNotPresent
  tag: "1.2.0"

The Novelty chart does not add imagePullSecrets to its pods. They run as the namespace's default service account, so attach the secret to that service account before you install the chart, and Kubernetes adds it to each new pod that uses it:

kubectl patch serviceaccount default \
  -p '{"imagePullSecrets": [{"name": "thatdot-registry"}]}'

If you deploy without Helm, the same wiring in a Deployment manifest looks like:

apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      imagePullSecrets:
        - name: thatdot-registry
      containers:
        - name: novelty
          image: registry.license.thatdot.com/thatdot/novelty:1.2.0

Install the cluster with Helm using the command (Don't forget to first helm repo add the thatdot Helm repo in the prerequisites section):

helm install --values=novelty-values.yaml \
    my-novelty thatdot/novelty

To inspect a Novelty pod after the install, open a shell with kubectl exec or attach a debug container. The Novelty container image has bash, the Java runtime and basic tools such as ls, cat and grep, but not curl, ps or a package manager. Work in a running container lists what is there and what to do about the rest.

Uninstall the cluster:
helm uninstall my-novelty

Metrics and Monitoring

Novelty exposes a large number of JVM and application metrics via the Dropwizard Metrics Library.

The recommended monitoring stack consists of influxDBv1 to record metrics and grafana to graph and visualize them.

See helm-charts/extras/monitoring-stack for an example to quickly bootstrap a thatDot environment with an InfluxDb and a Grafana instance.

# Metrics Configuration:
metrics:
  influx:
    enabled: true
    database: metrics
    scheme: http
    # Set "host" and "port" to the reachable address of the influx server
    host: "<INFLUXDB_HOST_ADDRESS>"
    port: 8086

Note

Novelty also supports emitting metrics to Prometheus. A guide on how to set this up with Helm is here.