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. Both databases have published Helm charts to make installation and administration easier.

See helm-charts/extras/persistor for an example to quickly bootstrap a thatDot environment with an Apache Cassandra cluster.

Apache Cassandra Helm chart: https://artifacthub.io/packages/helm/bitnami/cassandra
ScyllaDB Helm chart: https://operator.docs.scylladb.com/stable/installation/helm.html

License¶

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

To request an evaluation, schedule a demo, or purchase a license, please visit https://www.thatdot.com/getting-started-with-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: 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 <DOCKER_REGISTRY_URL> \
    -u <CLIENT_ID> \
    --password-stdin

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.
cassandra:
  enabled: true
  endpoints: "<CASSANDRA_ADDRESS_1>,<CASSANDRA_ADDRESS_2>"
  plaintextAuth:
    enabled: true
    username: <CASSANDRA_USERNAME>
    password: <CASSANDRA_PASSWORD>
  shouldCreateKeyspace: true
  shouldCreateTables: true

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=<DOCKER_REGISTRY_URL> \
  --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": {"<DOCKER_REGISTRY_URL>": {
      "username": "<CLIENT_ID>",
      "password": "<LICENSE_KEY>",
      "auth": "<base64 of CLIENT_ID:LICENSE_KEY>"}}}

Reference the secret and the image in your Helm values:

image:
  repository: <DOCKER_REGISTRY_URL>/<IMAGE>
  pullPolicy: IfNotPresent
  tag: "<TAG>"

imagePullSecrets:
  - name: thatdot-registry

The chart renders these into the Deployment's pod template, where the secret is referenced by name for image pulls. 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: <DOCKER_REGISTRY_URL>/<IMAGE>:<TAG>

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

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.