Observability

The Container Storage Modules (CSM) for Observability Helm chart bootstraps an Observability deployment on a Kubernetes cluster using the Helm package manager.

Prerequisites

• Helm 3.x
• The deployment of one or more supported Dell CSI drivers

Install the CSM for Observability Helm Chart

Steps

1. Create a namespace where you want to install the module

   kubectl create namespace karavi
   

2. Install cert-manager CRDs

   kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v1.10.0/cert-manager.crds.yaml
   

3. Add the Dell Helm Charts repo

     helm repo add dell https://dell.github.io/helm-charts
   

4. Copy only the deployed CSI driver entities to the Observability namespace

   PowerFlex

   1. Copy the config Secret from the CSI PowerFlex namespace into the Container Storage Module Observability namespace:

      kubectl get secret vxflexos-config -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
      

      If the CSI driver secret name is not the default vxflexos-config, please use the following command to copy secret:

      kubectl get secret [VXFLEXOS-CONFIG] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [VXFLEXOS-CONFIG]/name: vxflexos-config/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
      

   If Container Storage Module for Authorization is enabled for CSI PowerFlex, perform the following steps:

   2. Copy the driver configuration parameters ConfigMap from the CSI PowerFlex namespace into the Container Storage Module Observability namespace:

      kubectl get configmap vxflexos-config-params -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
      

      If the CSI driver configmap name is not the default vxflexos-config-params, please use the following command to copy configmap:

      kubectl get configmap [VXFLEXOS-CONFIG-PARAMS] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [VXFLEXOS-CONFIG-PARAMS]/name: vxflexos-config-params/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
      

   3. Copy the karavi-authorization-config, proxy-server-root-certificate, proxy-authz-tokens Secret from the CSI PowerFlex namespace into the Container Storage Module Observability namespace:

      
      kubectl get secret karavi-authorization-config proxy-server-root-certificate proxy-authz-tokens -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
      

5. Configure the parameters and install the CSM for Observability Helm Chart

   A default values.yaml file is located here that can be used for installation. This can be copied into a file named myvalues.yaml and either used as is or modified accordingly.

   Note:

   • The default values.yaml deploys the CSM for Observability Topology service.
   • For CSI PowerFlex with Authorization, configure karaviMetricsPowerflex.authorization in myvalues.yaml.
   • For CSI PowerScale with Authorization, configure karaviMetricsPowerscale.authorization in myvalues.yaml.
   • For CSI PowerMax with Authorization, configure karaviMetricsPowerMax.authorization in myvalues.yaml

   
   helm install karavi-observability dell/karavi-observability -n [CSM_NAMESPACE] -f myvalues.yaml
   

   Alternatively, you can specify each parameter using the ‘–set key=value[,key=value]’ and/or ‘–set-file key=value[,key=value] arguments to ‘helm install’. For example:

   
   helm install karavi-observability dell/karavi-observability -n [CSM_NAMESPACE] \
   --set-file karaviTopology.certificateFile=<location-of-karavi-topology-certificate-file> \
   --set-file karaviTopology.privateKeyFile=<location-of-karavi-topology-private-key-file> \
   --set-file otelCollector.certificateFile=<location-of-otel-collector-certificate-file> \
   --set-file otelCollector.privateKeyFile=<location-of-otel-collector-private-key-file>
   

Configuration

The following table lists the configurable parameters of the Container Storage Module for Observability Helm chart and their default values.

Topology:

Otel:

CSM for Observability Installer

The installer bootstraps Helm for a simplified and robust deployment by:

• Checking if Container Storage Modules for Observability is installed
• Verifying Kubernetes/OpenShift and Helm versions
• Adding and refreshing the Dell Helm chart repository
• Creating the CSM namespace and copying secrets
• Installing CertManager CRDs and the Container Storage Modules Helm chart
• Waiting for CSM pods to be ready

If Authorization is enabled for CSI drivers in the same Kubernetes cluster:

• Verifies the karavictl binary is available.
• Verifies the appropriate Secrets and ConfigMap exist in the CSI driver namespace.
• Updates the CSM Observability deployment to use the existing Authorization instance if not already enabled.

Prerequisites

• Helm 3.x
• The deployment of one or more supported Dell CSI drivers

Online Installer

Follow the instructions below to install Container Storage Module Observability in an environment that has an Internet connection and is capable of downloading the required Helm chart and Docker images. The installer expects CSI drivers are using the default secret and configmap names.

Dependencies

A Linux-based system, with Internet access, will be used to execute the script to install Container Storage Modules Observability into a Kubernetes/Openshift environment that also has Internet access.

Installer Usage

./karavi-observability-install.sh --help

Note: Container Storage Module for Authorization currently does not support the Observability module for PowerStore. Therefore setting enable-authorization is not supported in this case.

Executing the Installer

To perform an online installation of Container Storage Module Observability, the following steps should be performed:

1. Clone the GitHub repository:

   git clone https://github.com/dell/karavi-observability.git
   

2. Change to the installer directory:

   cd karavi-observability/installer
   

3. Execute the installation script. The following example will install Container Storage Module Observability into the CSM namespace.

   A sample values.yaml file is located here. This can be copied into a file named myvalues.yaml and modified accordingly for the installer command below. Configuration options are outlined in the Helm chart deployment section.

   Note:

• The default values.yaml deploys the CSM for Observability Topology service.

```bash

./karavi-observability-install.sh install --namespace [CSM_NAMESPACE] --values myvalues.yaml
```
```
---------------------------------------------------------------------------------
> Installing Karavi Observability in namespace karavi on 1.27
---------------------------------------------------------------------------------
|
|- Karavi Observability is not installed                            Success
|
|- Karavi Authorization will be enabled during installation
|
|- Verifying Kubernetes versions
  |
  |--> Verifying minimum Kubernetes version                         Success
  |
  |--> Verifying maximum Kubernetes version                         Success
|
|- Verifying helm version                                           Success
|
|- Configure helm chart repository
  |
  |--> Adding helm repository https://dell.github.io/helm-charts    Success
  |
  |--> Updating helm repositories                                   Success
|
|- Creating namespace karavi                                        Success
|
|- CSI Driver for PowerFlex is installed                            Success
|
|- Copying Secret from vxflexos to karavi                           Success
|
|- CSI Driver for PowerStore is installed                           Success
|
|- Copying Secret from powerstore to karavi                         Success
|
|- CSI Driver for PowerScale is installed                           Success
|
|- Copying Secret from isilon to karavi                             Success
|
|- CSI Driver for PowerMax is installed                             Success
|
|- Copying ConfigMap from powermax to karavi                        Success
|
|- Copying Secret from powermax to karavi                           Success
|
|- Installing CertManager CRDs                                      Success
|
|- Enabling Karavi Authorization for Karavi Observability
  |
  |--> Copying ConfigMap from vxflexos to karavi                    Success
  |
  |--> Copying Karavi Authorization Secrets from vxflexos to karavi Success
  |
  |--> Copying ConfigMap from isilon to karavi                      Success
  |
  |--> Copying Karavi Authorization Secrets from isilon to karavi   Success
  |
  |--> Copying ConfigMap from powermax to karavi                    Success
  |
  |--> Copying Karavi Authorization Secrets from powermax to karavi Success
|
|- Installing Karavi Observability helm chart                       Success
|
|- Waiting for pods in namespace karavi to be ready                 Success
```

The following instructions can be followed when a Helm chart will be installed in an environment that does not have an Internet connection and will be unable to download the Helm chart and related Docker images.

Prerequisites

• Helm 3.x
• The deployment of one or more Dell CSI drivers

Dependencies

Multiple Linux-based systems may be required to create and process an offline bundle for use.

• One Linux-based system, with Internet access, will be used to create the bundle. This involves the user invoking a script that utilizes docker to pull and save container images to file.
• One Linux-based system, with access to an image registry, to invoke a script that uses docker to restore container images from file and push them to a registry

If one Linux system has both Internet access and access to an internal registry, that system can be used for both steps.

Preparing an offline bundle requires the following utilities:

Executing the Installer

To perform an offline installation of a Helm chart, the following steps should be performed:

1. Build an offline bundle.
2. Unpack the offline bundle and prepare for installation.
3. Perform a Helm installation.

Build the Offline Bundle

1. Copy the offline-installer.sh script to a local Linux system using curl or wget:

   
   curl https://raw.githubusercontent.com/dell/karavi-observability/main/installer/offline-installer.sh --output offline-installer.sh
   

   or

   
   wget -O offline-installer.sh https://raw.githubusercontent.com/dell/karavi-observability/main/installer/offline-installer.sh
   

2. Set the file as executable.

   chmod +x offline-installer.sh
   

3. Build the bundle by providing the Helm chart name as the argument. Below is a sample output that may be different on your machine.

   ./offline-installer.sh -c dell/karavi-observability
   

   *
   * Adding Helm repository https://dell.github.io/helm-charts
   
   
   
   Downloading Helm chart dell/karavi-observability to directory /home/user/offline-karavi-observability-bundle/helm-original
   
   
   
   Downloading and saving Docker images
   quay.io/dell/container-storage-modules/csm-topology:v1.11.0
   quay.io/dell/container-storage-modules/csm-metrics-powerflex:v1.11.0
   quay.io/dell/container-storage-modules/csm-metrics-powerstore:v1.11.0
   quay.io/dell/container-storage-modules/csm-metrics-powerscale:v1.8.0
   quay.io/dell/container-storage-modules/csm-metrics-powermax:v1.6.0
   otel/opentelemetry-collector:0.42.0
   nginxinc/nginx-unprivileged:1.27
   
   
   
   Compressing offline-karavi-observability-bundle.tar.gz
   

Unpack the Offline Bundle

1. Copy the bundle file to another Linux system that has access to the internal Docker registry and that can install the Helm chart. From that Linux system, unpack the bundle.

   tar -xzf offline-karavi-observability-bundle.tar.gz
   

2. Change directory into the new directory created from unpacking the bundle:

   cd offline-karavi-observability-bundle
   

3. Prepare the bundle by providing the internal Docker registry URL. Below is a sample output that may be different on your machine.

   ./offline-installer.sh -p <my-registry>:5000
   

   *
   * Loading, tagging, and pushing Docker images to registry <my-registry>:5000/
   
     quay.io/dell/container-storage-modules/csm-topology:v1.11.0 -> <my-registry>:5000/csm-topology:v1.11.0
     quay.io/dell/container-storage-modules/csm-metrics-powerflex:v1.11.0 -> <my-registry>:5000/csm-metrics-powerflex:v1.11.0
     quay.io/dell/container-storage-modules/csm-metrics-powerstore:v1.11.0 -> <my-registry>:5000/csm-metrics-powerstore:v1.11.0
     quay.io/dell/container-storage-modules/csm-metrics-powerscale:v1.8.0 -> <my-registry>:5000/csm-metrics-powerscale:v1.8.0
     quay.io/dell/container-storage-modules/csm-metrics-powermax:v1.6.0 -> <my-registry>:5000/csm-metrics-powermax:v1.6.0
     otel/opentelemetry-collector:0.42.0 -> <my-registry>:5000/opentelemetry-collector:0.42.0
     nginxinc/nginx-unprivileged:1.27 -> <my-registry>:5000/nginx-unprivileged:1.27
   

Perform Helm installation

1. Change directory to helm which contains the updated Helm chart directory:

   cd helm
   

2. Install necessary cert-manager CustomResourceDefinitions provided:

   kubectl apply --validate=false -f cert-manager.crds.yaml
   

3. Copy the CSI Driver Secret(s)

   Copy the CSI Driver Secret from the namespace where CSI Driver is installed to the namespace where CSM for Observability is to be installed.

kubectl get secret vxflexos-config -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get secret [VXFLEXOS-CONFIG] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [VXFLEXOS-CONFIG]/name: vxflexos-config/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get configmap vxflexos-config-params -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get configmap [VXFLEXOS-CONFIG-PARAMS] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [VXFLEXOS-CONFIG-PARAMS]/name: vxflexos-config-params/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get secret karavi-authorization-config proxy-server-root-certificate proxy-authz-tokens -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get secret powerstore-config -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get secret [POWERSTORE-CONFIG] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [POWERSTORE-CONFIG]/name: powerstore-config/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

  
CSI Driver for PowerScale:

kubectl get secret isilon-creds -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
If the CSI driver secret name is not the default isilon-creds, please use the following command to copy secret:

kubectl get secret [ISILON-CREDS] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [ISILON-CREDS]/name: isilon-creds/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
If CSM for Authorization is enabled for CSI PowerScale, perform these steps:

kubectl get configmap isilon-config-params -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -
If the CSI driver configmap name is not the default isilon-config-params, please use the following command to copy configmap:

kubectl get configmap [ISILON-CONFIG-PARAMS] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [ISILON-CONFIG-PARAMS]/name: isilon-config-params/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get secret karavi-authorization-config proxy-server-root-certificate proxy-authz-tokens -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | sed 's/name: karavi-authorization-config/name: isilon-karavi-authorization-config/' | sed 's/name: proxy-server-root-certificate/name: isilon-proxy-server-root-certificate/' | sed 's/name: proxy-authz-tokens/name: isilon-proxy-authz-tokens/' | kubectl create -f -

kubectl get configmap powermax-reverseproxy-config -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get configmap [POWERMAX-REVERSEPROXY-CONFIG] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [POWERMAX-REVERSEPROXY-CONFIG]/name: powermax-reverseproxy-config/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

for secret in $(kubectl get configmap powermax-reverseproxy-config -n [CSI_DRIVER_NAMESPACE] -o jsonpath="{.data.config\.yaml}" | grep arrayCredentialSecret | awk 'BEGIN{FS=":"}{print $2}' | uniq)
do
    kubectl get secret $secret -n [CSI_DRIVER_NAMESPACE] -o yaml | sed "s/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/" | kubectl create -f -
done

for secret in $(kubectl get configmap [POWERMAX-REVERSEPROXY-CONFIG] -n [CSI_DRIVER_NAMESPACE] -o jsonpath="{.data.config\.yaml}" | grep arrayCredentialSecret | awk 'BEGIN{FS=":"}{print $2}' | uniq)
do
    kubectl get secret $secret -n [CSI_DRIVER_NAMESPACE] -o yaml | sed "s/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/" | kubectl create -f -
done

kubectl get configmap powermax-config-params -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get configmap [POWERMAX-CONFIG-PARAMS] -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/name: [POWERMAX-CONFIG-PARAMS]/name: powermax-config-params/' | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | kubectl create -f -

kubectl get secret karavi-authorization-config proxy-server-root-certificate proxy-authz-tokens -n [CSI_DRIVER_NAMESPACE] -o yaml | sed 's/namespace: [CSI_DRIVER_NAMESPACE]/namespace: [CSM_NAMESPACE]/' | sed 's/name: karavi-authorization-config/name: powermax-karavi-authorization-config/' | sed 's/name: proxy-server-root-certificate/name: powermax-proxy-server-root-certificate/' | sed 's/name: proxy-authz-tokens/name: powermax-proxy-authz-tokens/' | kubectl create -f -

4. After the images have been made available and the Helm chart configuration is updated, follow the instructions within the Helm chart’s repository to complete the installation.

   Note:

   • Optionally, you could provide your own configurations. A sample values.yaml file is located here.
     • The default values.yaml is configured to deploy the CSM for Observability Topology service on install.
     • If CSM for Authorization is enabled for CSI PowerFlex, the karaviMetricsPowerflex.authorization parameters must be properly configured.
     • If CSM for Authorization is enabled for CSI PowerScale, the karaviMetricsPowerscale.authorization parameters must be properly configured.
     • If CSM for Authorization is enabled for CSI PowerMax, the karaviMetricsPowerMax.authorization parameters must be properly configured.

   helm install -n install-namespace app-name karavi-observability
   
   NAME: app-name
   LAST DEPLOYED: Fri Nov  6 08:48:13 2020
   NAMESPACE: install-namespace
   STATUS: deployed
   REVISION: 1
   TEST SUITE: None