Helm Install

$ helm repo add blackduck https://repo.blackduck.com/artifactory/cloudnative/
                

### Create the Namespace

```bash
$ kubectl create ns <namespace>

Modify the values.yaml file or pass in values to helm install with --set.

$ helm install blackduck/blackduck-alert --name <name> --namespace <namespace>

 $ helm repo add blackduck https://repo.blackduck.com/artifactory/cloudnative/

$ kubectl create ns <namespace>

Modify the values.yaml file or pass in values to helm install with --set. Please see the Configuration section for more details.

$ helm install <name> blackduck/blackduck-alert --namespace <namespace>

Navigate to the alert-helm chart repository in your terminal.

$ cd <path>/alert-helm

$ kubectl create ns myalert

Deploy Alert

$ helm install myalert blackduck/blackduck-alert --namespace myalert

A brief description of each parameter in the values.yaml file.

Specify each parameter using the --set key=value[,key=value] argument to helm install.

Alternatively, a YAML file that specifies the values for the above parameters can be provided while installing the chart. For example,

$ helm install blackduck/blackduck-alert --name <name> --namespace <namespace> --set enableStandalone=true

Execute the command as shown, replacing the relevant variables:

 $ kubectl create secret generic <SECRET_NAME> -n <ALERT_NAMESPACE> \
 --from-literal=<USERNAME_KEY>=<USER_USERNAME> \
 --from-literal=<PASSWORD_KEY>=<USER_PASSWORD>

• Replace <SECRET_NAME> with the desired name for the secret.
• Replace <ALERT_NAMESPACE> with the namespace used for Alert.
• Replace <USERNAME_KEY> with the key mapped to the user's username. By default, this is set to ALERT_DB_USERNAME in values.yaml.
• Replace <USER_USERNAME> with the database user's username.
• Replace <PASSWORD_KEY> with the key mapped to the user's password. By default, this is set to ALERT_DB_PASSWORD in values.yaml.
• Replace <USER_PASSWORD> with the database user's password.

Example of creating a secret with the name 'alert-db-user-secret' in the 'example' namespace:

 $ kubectl create secret generic alert-db-user-secret -n example \
 --from-literal=ALERT_DB_USERNAME=sa \
 --from-literal=ALERT_DB_PASSWORD=blackduck

Execute the command:

 $ kubectl create secret generic <SECRET_NAME> -n <ALERT_NAMESPACE> \
 --from-literal=<ADMIN_USERNAME_KEY>=<ADMIN_USERNAME> \
 --from-literal=<ADMIN_PASSWORD_KEY>=<ADMIN_PASSWORD>

• Replace <SECRET_NAME> with the desired name for the secret.
• Replace <ALERT_NAMESPACE> with the namespace used for Alert.
• Replace <ADMIN_USERNAME_KEY> with the key mapped to the admin's username. By default, this is set to ALERT_DB_ADMIN_USERNAME in values.yaml.
• Replace <ADMIN_USERNAME> with the database admin's username.
• Replace <ADMIN_PASSWORD_KEY> with the key mapped to the admin's password. By default, this is set to ALERT_DB_ADMIN_PASSWORD in values.yaml.
• Replace <ADMIN_PASSWORD> with the database admin's password.

Example of creating a secret with the name 'alert-db-admin-secret' in the 'example' namespace:

 $ kubectl create secret generic alert-db-admin-secret -n example \
 --from-literal=ALERT_DB_ADMIN_USERNAME=postgres \
 --from-literal=ALERT_DB_ADMIN_PASSWORD=adminPassword

Once you create the secrets with the correct credentials, you must then tell Alert the name of the secret the credentials correspond to. In the values.yaml file, for the database user, set:

postgres.dbCredential.secretName: "<SECRET_NAME>"
postgres.dbCredential.usernameKey: "<USERNAME_KEY>"
postgres.dbCredential.passwordKey: "<PASSWORD_KEY>"

• Replace <SECRET_NAME> with the name of the secret created in the step Create the Database User Credentials Secret.

• Replace <USERNAME_KEY> with the username key used in the same step.

• Replace <PASSWORD_KEY with the password key used in the same step.

• In the values.yaml file, for the database admin, set

  postgres.dbAdminCredential.secretName: "<SECRET_NAME>"
  postgres.dbAdminCredential.usernameKey: "<ADMIN_USERNAME_KEY>"
  postgres.dbAdminCredential.passwordKey: "<ADMIN_PASSWORD_KEY>"

• Replace <SECRET_NAME> with the name of the secret created in the step Create the Database Admin Credentials Secret.

• Replace <ADMIN_USERNAME_KEY> with the username key used in the same step.

• Replace <ADMIN_PASSWORD_KEY> with the password key used in the same step.

Execute the command as shown, replacing the relevant variables:

 $ kubectl create secret generic <SECRET_NAME> -n <ALERT_NAMESPACE> \
 --from-literal=<USERNAME_KEY>=<USER_USERNAME> \
 --from-literal=<PASSWORD_KEY>=<USER_PASSWORD>

• Replace <SECRET_NAME> with the desired name for the secret.
• Replace <ALERT_NAMESPACE> with the namespace used for Alert.
• Replace <USERNAME_KEY> with the key mapped to the RabbitMQ user's username. By default, this is set to ALERT_RABBITMQ_USER in values.yaml.
• Replace <USER_USERNAME> with the database RabbitMQ user's username.
• Replace <PASSWORD_KEY> with the key mapped to the RabbitMQ user's password. By default, this is set to ALERT_RABBITMQ_PASSWORD in values.yaml.
• Replace <USER_PASSWORD> with the RabbitMQ user's password.

Example:

$ kubectl create secret generic alert-rabbitmq-secret -n example \
   --from-literal=ALERT_RABBITMQ_USER=rabbitUser \
   --from-literal=ALERT_RABBITMQ_PASSWORD=rabbitPassword

This creates a secret with the name 'alert-rabbitmq-secret' in the 'example' namespace.

Once you create the secrets with the correct credentials, you must then tell Alert the name of the secret the credentials correspond to. In the values.yaml file, for the RabbitMQ user, set:

rabbitmq.credential.secretName: "<SECRET_NAME>"
rabbitmq.credential.usernameKey: "<USERNAME_KEY>"
rabbitmq.credential.passwordKey: "<PASSWORD_KEY>"

• Replace <SECRET_NAME> with the name of the secret created in the step Create the RabbitMQ Credentials Secret.
• Replace <USERNAME_KEY> with the username key used in the same step.
• Replace <PASSWORD_KEY with the password key used in the same step.

Execute the command as shown, replacing the relevant variables:

 $ kubectl create secret generic <SECRET_NAME> -n <ALERT_NAMESPACE> \
 --from-file=WEBSERVER_CUSTOM_CERT_FILE=<PATH_TO_CERTIFICATE_FILE> \
 --from-file=WEBSERVER_CUSTOM_KEY_FILE=<PATH_TO_CERTIFICATE_KEY_FILE>

• Replace <SECRET_NAME> with the desired name for the secret.
• Replace <ALERT_NAMESPACE> with the namespace used for Alert.
• Replace <PATH_TO_CERTIFICATE_FILE> to the path on the current file system to your .crt file.
• Replace <PATH_TO_CERTIFICATE_KEY_FILE> to the path on the current file system to the .key file corresponding to your .crt file.

For more information about managing secrets, please see: managing secrets using kubectl.

Once you have created the certificate secret with the correct keys, you must then tell Alert the name of the secret the certificate corresponds to. Replace <SECRET_NAME> with the name of the secret created in the step Create Certificate Secret.

In the values.yaml file, set:

webserverCustomCertificatesSecretName: "<SECRET_NAME>"

In the values.yaml file, set the value to true to instruct Alert to use the secret specified by the webserverCustomCertificatesSecretName configuration parameter as the custom certificate.

enableCertificateSecret: true

In the values.yaml file ensure that the setting is true which is the default. If this is false when the deployment is uninstalled all data will be lost.

enablePersistentStorage: true 

A persistent volume must be created first if a dynamic provisioner is not being used. It must be created in the same namespace as the Alert deployment and bound to the persistent volume for Alert.

Configure Alert to use the volume claim by replacing <ALERT_CLAIM_NAME> with the name of the persistent volume claim for Alert data.

alert:
  persistentVolumeClaimName: "<ALERT_CLAIM_NAME>"

An optional storage class with the persistent volume claim requires the addition of the storage class name. Replace <STORAGE_CLASS_NAME> with the name of the storage class in the persistent volume claim.

    alert:
      persistentVolumeClaimName: "<ALERT_CLAIM_NAME>"
      storageClassName: "<STORAGE_CLASS_NAME>"

Example:

  alert:
    persistentVolumeClaimName: "alert-pvc"
    storageClassName: "myStorageClass"

A persistent volume must be created first for the Postgres database if a dynamic provisioner not being used. It must be created in the same namespace as the Alert deployment for Postgres and bound to the persistent volume for Postgres.

Configure Postgres to use the volume claim by replacing <POSTGRES_CLAIM_NAME> with the name of the persistent volume claim for Postgres data.

  postgres:
    persistentVolumeClaimName: "<POSTGRES_CLAIM_NAME>"

An optional storage class with the persistent volume claim requires the addition of the storage class name. Replace <STORAGE_CLASS_NAME> with the name of the storage class in the persistent volume claim.

    postgres:
      persistentVolumeClaimName: "<POSTGRES_CLAIM_NAME>"
      storageClassName: "<STORAGE_CLASS_NAME>"

Example:

    postgres:
      persistentVolumeClaimName: "postgres-pvc"
      storageClassName: "myStorageClass"

Configure Postgres admin username and password following the instructions outlined here: Using On-Premise Database Configuration

A persistent volume must be created first if a dynamic provisioner not being used. Configure Alert to use the volume name by replacing <ALERT_VOLUME_NAME> with the name of the persistent volume for Alert data.

  alert:
    volumeName: "<ALERT_VOLUME_NAME>"

An optional storage class with the persistent volume requires the addition of the storage class name. Replace <STORAGE_CLASS_NAME> with the name of the storage class in the persistent volume claim.

    alert:
      volumeName: "<ALERT_VOLUME_NAME>"
      storageClassName: "<STORAGE_CLASS_NAME>"

Define the claim size which by default is 5GB.

    alert:
      claimSize: "5Gi"

Example:

  alert:
    claimSize: "5Gi"
    storageClassName: "myStorageClass"
    volumeName: "alert-volume"

A claim will be created with the release name for example 'myalert-pvc' please verify the claim bound to the volume.

$ kubectl -n <ALERT_NAMESPACE> get pvc

A persistent volume must be created first for the Postgres database if a dynamic provisioner is not being used. Configure Alert to use the volume name by replacing <POSTGRES_VOLUME_NAME> with the name of the persistent volume for Postgres data.

  postgres:
    volumeName: "<POSTGRES_VOLUME_NAME>"

An optional storage class with the persistent volume requires the addition of the storage class name. Replace <STORAGE_CLASS_NAME> with the name of the storage class in the persistent volume claim.

    postgres:
      volumeName: "<POSTGRES_VOLUME_NAME>"
      storageClassName: "<STORAGE_CLASS_NAME>"

Define the claim size which by default is 5GB.

    postgres:
      claimSize: "5Gi"

Example:

    postgres:
      claimSize: "5Gi"
      storageClassName: "myStorageClass"
      volumeName: "postgres-volume"

A claim will be created with the release name for example 'myalert-postgres' please verify the claim bound to the volume.

    $ kubectl -n <ALERT_NAMESPACE> get pvc

Configure Postgres admin username and password following the instructions outlined here: Using On-Premise Database Configuration.

When deploying with an external database follow the information provided for installing with an external database.

On the external database create a database owned by the Alert Admin user by replacing <DATABASE_NAME> with the name of the database for Alert and <ROLE_NAME> with the Alert database user created in the previous step.

CREATE DATABASE <DATABASE_NAME> WITH OWNER <ROLE_NAME>

Disable on premise database container creation.

postgres:
  isExternal: true

Configure Alert Postgres user by replacing <ROLE_NAME> with the database user name.

postgres:
  userUserName: <ROLE_NAME>

postgres:
  userPassword: <PASSWORD>

postgres:
  host: <DATABASE_HOST>

Configure Alert Postgres port by replacing <DATABASE_PORT> with the port the database server is running on.

postgres:
  port: <DATABASE_PORT>

Configure Alert Postgres database name by replacing <DATABASE_NAME> with the name of the database created in previous steps.

postgres:
  databaseName: <DATABASE_NAME>

Configure Postgres admin username and password following the instructions outlined here: Using External Database Configuration.

Alert requires administrator access to configure the database correctly. The following section describes how to configure the administrator credentials for both on-premise and external database configurations.