Install Symphony - Kubernetes

Adding Logi Symphony to your environment involves installing, configuring, and licensing the components you'll use as a stand alone or embedded resource. You may need to install multiple components that work together to provide your desired analytics experience, depending on your licensing arrangements.

To install Symphony in a Kubernetes environment, you'll need an intermediate level of familiarity and experience with Kubernetes. See https://kubernetes.io/docs/home/.

Download the latest installation package and read me at https://repo-logisymphony.insightsoftware.com/helm-charts/.

Prerequisites

• A Kubernetes cluster of appropriate compute availability
• The Helm CLI installed
• Your command line tool, kubectl, is installed and configured to use with your cluster

Kubernetes Cluster Requirements

There are no specific limits in the Helm chart by default, but we suggest the following compute availability on your cluster:

Recommended Compute Availability

• 10 Cores
• 24 Gi Memory

Required for Scheduling by Kubernetes

• 4 Cores
• 16 Gi Memory

These specifications are intended as an initial installation guide. Your environment's specific workloads may demand a higher number of cores and more memory available for computing.

Other Requirements

The memory requirements above do not take into account other components that are a part of Logi Symphony. These components are external to Helm chart requirements. Size your environment following the recommendations for each component. These components include:

• PostgreSQL
• RabbitMQ
• NGINX Ingress Controller

Installation Steps

• Step 1: Install a NGINX Ingress Controller
• Step 2: Determine Your URL
• Step 3: Add the Symphony Helm Repository
• Step 4: Create a Symphony values.yaml File
• Step 5: Install Logi Symphony
• Step 6: Get the Pods for Your Namespace
• Step 7: Set the Admin Password for Data Discovery
• Step 8: Apply Licenses

For information about accessing Symphony after it is installed, see Access Symphony.

Step 1: Install a NGINX Ingress Controller

If you haven't installed a NGINX ingress controller, install one using the following commands:

helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update
helm install my-ingress-controller bitnami/nginx-ingress-controller

Verify your ingress controller by running the following command to return all services in the namespace:

kubectl get services    

If the EXTERNAL-IP is set to a value and not stuck in a pending space, the ingress controller is exposed correctly. You can additionally verify this by visiting the external IP address: you should be served an NGINX 404 page.

Logi Symphony requires an NGINX Ingress controller, and an Ingress in order to properly expose Symphony. This ingress controller should be installed before the Symphony is installed, and you should validate that the ingress controller has a proper address. To install the ingress controller do the following:

helm install my-release oci://registry-1.docker.io/bitnamicharts/nginx-ingress-controller

For other install methods for the ingress controller, see https://bitnami.com/stack/nginx-ingress-controller/helm.

The NGINX proxy for the main Symphony service (logi.symphony.proxy.port) should not be routed through port 8080. Select an appropriate available alternative port to designate for the service.

Step 2: Determine Your URL

You have two options to choose from for your environment's URL:

• Use the EXTERNAL-IP returned in the previous step
• Use the URL from your cluster

Step 3: Add the Symphony Helm Repository

Install the Helm chart with the release name of logisymphony1 on your Kubernetes cluster using default configuration settings. Adjust parameters as needed. See Installation Parameters.

helm repo add insightsoftware https://repo-logisymphony.insightsoftware.com/helm-charts/
helm repo update
helm install logisymphony1 insightsoftware/logisymphony    

Uninstall the Helm Chart

If you need to uninstall the Helm chart, run this command to remove all Kubernetes components associated with the chart and delete Symphony.

helm delete logisymphony1    

Step 4: Create a Symphony values.yaml File

Use Helm to generate a values.yaml file, then edit in the Symphony Docker key, an updated Admin user password, and the ingress information.

Enable Features

Enable and disable features as needed:

global:
  postgresql:
    # Enables a shared PostgresSQL server.
    enabled: true
            
logi:
  symphony:
    managed:
# Enables Dundas BI
   enabled: true
  discovery:
    # Enables Composer.
    enabled: true

Update the Admin User Password

Set a strong password: a combination of at least nine characters that includes upper and lower case letters, numbers, and special characters.

# Default values for Symphony.
# This is a YAML-formatted file.
# Declare variables to be passed into your template
            
global:
  symphony:

  # Set the data discovery and managed dashboards supervisor/admin credentials.
    auth:

      # This will be used for the password.
      adminPassword: "<Complex-password>"

      # If the above section is not set, then the admin and supervisor password is
      # set through the .values.managed, or .values.discovery sections.

The managed service does not use a Supervisor user: all actions are handled by the Admin user role.

Managed Service Values

Set the Managed service values using the managed section of values.yaml.

managed:
# Default values for dundas-bi.
  dundas:
    bi:

For more information on defining values for the Managed service, see Orchestrating Dundas BI with Kubernetes and Helm charts.

 Data DiscoveryDiscovery Service Values

Set the Data Discovery service values using the discovery section of values.yaml.

discovery:
  zoomdataClient:

Data Discovery Database

If global.postgresql.enabled is true, set the Postgres authentication details in the global.postgresql.auth section.

If global.postgresql.enabled is false, set the database information in the managed and discovery sections of the values.yaml. See the Managed Dashboards and Managed Reports helm readme and the Visual Data Discovery helm readme embedded in their respective helm charts.

The other postgres details are set in the postgresql section of the values.yaml as seen in the following example:

postgresql:
  # Is PostgreSQL database enabled
  enabled: true
  image:
    # Image tag
    tag: 12
  primary:
    initdb:
      # Username to execute the initdb scripts
      user: "postgres"
      # Password to execute the initdb scripts
      password: "LogiSymphony!123456"
      # Scripts to be run at first boot
        scripts:
          "initdbScript.sql": |
            CREATE DATABASE "zoomdata" WITH OWNER logisymphonyuser;
            CREATE DATABASE "zoomdata-upload" WITH OWNER logisymphonyuser;
            CREATE DATABASE "zoomdata-keyset" WITH OWNER logisymphonyuser;
            CREATE DATABASE "zoomdata-user-auditing" WITH OWNER logisymphonyuser;
            CREATE DATABASE "zoomdata-qe" WITH OWNER logisymphonyuser;

To add more databases for the Visual Data Discovery service , create them in this section along with the postgres database.

 Data Discovery CORS Whitelisting

If you're embedding your Visual Data Discovery content, you must add the appropriate domain names to whitelisting for CORS.

   properties:
     access.control.allow.origin: "example1.com,example2.com"

RabbitMQ Deployment

By default this helm chart will deploy a RabbitMQ helm chart. The RabbitMQ configuration is passed down to sub charts  Visual Data Discovery, and Managed Dashboards and Managed Reports via Environment variables set directly in the values.yaml:

discovery:
  zoomdataWeb:
    extraEnvs:
      # RabbitMQ configuration belongs here.
managed:
  dundas:
    bi:
      setup:
        extraEnvs:
        # RabbitMQ configuration belongs here.

RabbitMQ is required. If you prefer to use it outside of the Symphony helm chart, set global.logi.symphony.rabbitmq.enabled to false and define the environment variables above to point to your accessible RabbitMQ instance.

Currently only the values set by default in values.yaml are supported.

Configure RabbitMQ

You can initialize RabbitMQ with Exchanges, Bindings, and Queues in two different ways.

Method one (default): Pass the following Environment variable. With this set, RabbitMQ populates with the required exchanges, bindings, and queues during the handledatabase container as part of the Managed Dashboards and Managed Reports start up.

managed:
  dundas:
    bi:
      setup:
        - name: INIT_RABBITMQ_FOR_SYMPHONY
          value: "true"

Method two: Pass the configuration information as part of configuration.

rabbitmq:
  extraSecrets:
    load-definition:
      load_definition.json: |
        {
          "vhosts": [
          {
            "name": "symphony"
          }
          ],
          "users": [
          {
            "name": "{{ .Values.auth.username }}",
            "password": "{{ .Values.auth.password }}",
            "tags": ["administrator"]
          }
          ],
          "permissions": [
          {
              "user": "{{ .Values.auth.username }}",
              "vhost": "symphony",
              "configure": ".*",
              "write": ".*",
              "read": ".*"
            }
          ],
          "exchanges": [
            {
              "name": "composer.source",
              "vhost": "symphony",
              "type": "topic",
              "durable": true,
              "auto_delete": false,
              "internal": false,
              "arguments": {}
            },
            {
              "name": "dundas.broadcast",
              "vhost": "symphony",
              "type": "fanout",
              "durable": true,
              "auto_delete": false,
              "internal": false,
              "arguments": {}
            }
          ],
          "queues": [
            {
              "name": "create-native-structure",
              "vhost": "symphony",
              "durable": true,
              "auto_delete": false,
              "arguments": {}
            },
            {
              "name": "update-native-structure",
              "vhost": "symphony",
              "durable": true,
              "auto_delete": false,
              "arguments": {}
            },
            {
              "name": "delete-native-structure",
              "vhost": "symphony",
              "durable": true,
              "auto_delete": false,
              "arguments": {}
            },
            {
              "name": "create-native-structure-column",
              "vhost": "symphony",
              "durable": true,
              "auto_delete": false,
              "arguments": {}
            },
            {
              "name": "update-native-structure-column",
              "vhost": "symphony",
              "durable": true,
              "auto_delete": false,
              "arguments": {}
            },
            {
              "name": "delete-native-structure-column",
              "vhost": "symphony",
              "durable": true,
              "auto_delete": false,
              "arguments": {}
            }
          ],
          "bindings": [
            {
              "source": "composer.source",
              "vhost": "symphony",
              "destination": "create-native-structure",
              "destination_type": "queue",
              "routing_key": "source.created",
              "arguments": {}
            },
            {
              "source": "composer.source",
              "vhost": "symphony",
              "destination": "update-native-structure",
              "destination_type": "queue",
              "routing_key": "source.updated",
              "arguments": {}
            },
            {
              "source": "composer.source",
              "vhost": "symphony",
              "destination": "delete-native-structure",
              "destination_type": "queue",
              "routing_key": "source.deleted",
              "arguments": {}
            },
            {
              "source": "composer.source",
              "vhost": "symphony",
              "destination": "create-native-structure-column",
              "destination_type": "queue",
              "routing_key": "source.field.created",
              "arguments": {}
            },
            {
              "source": "composer.source",
              "vhost": "symphony",
              "destination": "update-native-structure-column",
              "destination_type": "queue",
              "routing_key": "source.field.updated",
              "arguments": {}
            },
            {
              "source": "composer.source",
              "vhost": "symphony",
              "destination": "delete-native-structure-column",
              "destination_type": "queue",
              "routing_key": "source.field.deleted",
              "arguments": {}
            }
          ]
        }
  loadDefinition:
    enabled: true
    existingSecret: load-definition
  extraConfiguration: |
    default_vhost = symphony
    load_definitions = /app/load_definition.json

Ingress Updates

Modify the ingress section by defining the URL from Step 2, and uncomment any lines until your file matches the commands indicated below.

ingress:
  enabled: true

  appendToPath: ""

  annotations: 
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
    nginx.ingress.kubernetes.io/proxy-http-version: "1.1"
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/affinity: "cookie"
    nginx.ingress.kubernetes.io/session-cookie-name: "dbiroute"
    nginx.ingress.kubernetes.io/session-cookie-expires: "172800"
    nginx.ingress.kubernetes.io/session-cookie-max-age: "172800"
    nginx.ingress.kubernetes.io/session-cookie-path: /
    nginx.ingress.kubernetes.io/proxy-connect-timeout: "86400"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "86400"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "86400"
    nginx.ingress.kubernetes.io/proxy-body-size: "500m"
  hosts:
    - host: <fully-qualified-domain-name>
    paths: 
      - /
        

You must enable sticky sessions for a load balanced implementation of the managed service in Logi Symphony. This example includes annotations to add to enable sticky sessions with a NGINX ingress controller.

ingress:
  enabled: true
  annotations: 
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
    nginx.ingress.kubernetes.io/proxy-http-version: "1.1"
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/affinity: "cookie"
    nginx.ingress.kubernetes.io/session-cookie-name: "symphonyroute"
    nginx.ingress.kubernetes.io/session-cookie-expires: "172800"
    nginx.ingress.kubernetes.io/session-cookie-max-age: "172800"
    nginx.ingress.kubernetes.io/session-cookie-path: /
    nginx.ingress.kubernetes.io/proxy-connect-timeout: "86400"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "86400"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "86400"
    nginx.ingress.kubernetes.io/proxy-body-size: "500m"
    nginx.ingress.kubernetes.io/server-snippet: |
      gzip on;
      gzip_types = text/plain image/svg+xml application/xml text/css application/javascript application/json "application/json;charset=utf-8" application/font-woff;

SSL Set Up

Use an ingress to enable SSL with the Symphony Helm chart. First create a secret with your certificate information.

kubectl create secret tls exampledomain --key C:\temp\exampledomain.keyfile --cert C:\temp\exampledomain.certfile

Next, apply that secret to the ingress inside the tls.

ingress:
  ...
  hosts:
    - host: exampledomain.com
      paths: 
        - /

Step 5: Install Logi Symphony

With the previous steps completed, run the following command:

helm install logisymphony1 insightsoftware/logisymphony -f values.yaml

This installs Symphony. When it starts, proceed to the next step.

Step 6: Get the Pods for Your Namespace

Run this command to return a list of all pods running.

kubectl get pods -A        

Step 7: Set the Admin Password for Data Discovery

Visit your site at https://<your-url>/discovery to set the Admin password for the data discovery module.

We suggest you use the same password as defined above: future updates will merge workflows that use these access methods.

After you've set the admin password, log in as the admin with the password you've set at https://<your-url>/discovery to continue the install and setup process.

Step 8: Apply Licenses

Apply licenses to the Managed Dashboards, Managed Reports, and Visual Data Discovery modules.

• Evaluation licenses are included in the Helm chart.

API documentation is provided with your Symphony installation at this link: <symphony-URL>/discovery/swagger-ui.html.

Installation Parameters

The following table lists the configurable parameters of the Symphony chart and their default values.

Website