### Install LVM2 and Setup Loopback Device

Source: https://context7.com/openebs/website/llms.txt

Install LVM2 utilities and prepare a loopback device for testing LVM PVs. Use a real disk for production.

```bash
# Install LVM2 on all nodes (Ubuntu/Debian)
apt-get install lvm2

# Create a loopback device for testing (production: use a real disk)
truncate -s 1024G /tmp/disk.img
sudo losetup -f /tmp/disk.img --show     # outputs /dev/loop0

# Create Physical Volume and Volume Group named "lvmvg"
sudo pvcreate /dev/loop0
sudo vgcreate lvmvg /dev/loop0

# Verify
sudo vgs
#   VG    #PV #LV #SN Attr   VSize    VFree
#   lvmvg   1   0   0 wz--n- 1024.00g 1024.00g

```

--------------------------------

### Example Application Pod Output

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/replicated-storage-user-guide/replicated-pv-mayastor/configuration/rs-deployment.md

This is an example output of the 'kubectl get pod fio' command, indicating the pod's readiness and status.

```text
NAME   READY   STATUS    RESTARTS   AGE
fio    1/1     Running   0          34s

```

--------------------------------

### Travis CI Configuration: Install Prerequisites

Source: https://github.com/openebs/website/blob/main/website/src/blogs/setup-continuous-integration-for-helm-chart.md

Configure the installation steps for Travis CI, including downloading and extracting Helm, initializing the Helm client, installing the Helm push plugin, and setting up yamllint.

```yaml
install:
   # Installing Helm
    - wget ${HELM_URL}/${HELM_TGZ}
    - tar xzfv ${HELM_TGZ}
    - PATH=`pwd`/linux-amd64/:$PATH
    - helm init --client-only
    # helm plugin to push helm chart
    - helm plugin install https://github.com/chartmuseum/helm-
push --version v0.7.1
    # Installing pip deps
    - sudo pip install yamllint=="${YAMLLINT_VERSION}"
    - helm repo update
```

--------------------------------

### Install and Enable iSCSI Service

Source: https://github.com/openebs/website/blob/main/website/src/blogs/using-openebs-as-a-kubernetes-persistent-volume.md

Execute this command on each node to install, enable, and start the iSCSI service, which is required by OpenEBS.

```bash
yum -y install iscsi-initiator-utils systemctl enable iscsid systemctl start iscsid
```

--------------------------------

### Install cqlsh and Connect to Cassandra

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-deploy-a-cassandra-cluster-ring-on-kubernetes-openebs.md

Install the `cqlsh` utility by first installing Python prerequisites and then using pip. Connect to the Cassandra cluster using the IP address of a replica and the default port 9042.

```bash
sudo apt-get install -y python-minimal python-pip
 pip install cqlsh
```

```bash
ubuntu@ip-172–23–1–236:~/openebs/k8s/demo/cassandra$ cqlsh 10.2.4.6 9042 — cqlversion=”3.4.2"
 Connected to K8Demo at 10.2.4.6:9042.
 [cqlsh 5.0.1 | Cassandra 3.9 | CQL spec 3.4.2 | Native protocol v4]
 Use HELP for help.
 cqlsh>
```

--------------------------------

### Install Rancher Server

Source: https://github.com/openebs/website/blob/main/website/src/blogs/running-openebs-on-custom-rancher-cluster.md

Use this command to install the Rancher server. Ensure Docker is installed beforehand.

```bash
sudo docker run -d --restart=unless-stopped -p 8080:8080 rancher/server:stable
```

--------------------------------

### Install Guest Agent

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/read-write-many/kubevirt.md

Install and enable the QEMU guest agent inside the VM for better integration and management.

```bash
virtctl console vm1   
yum install -y qemu-guest-agent
systemctl enable --now qemu-guest-agent
```

--------------------------------

### Install Golang and crictl on Armbian

Source: https://github.com/openebs/website/blob/main/website/src/blogs/arming-kubernetes-with-openebs-1.md

Download and install Golang 1.10, set up the PATH and GOPATH environment variables, and then install the crictl tool.

```bash
wget https://dl.google.com/go/go1.10.linux-arm64.tar.gz
sudo tar -C /usr/local -xzf go1.10.linux-arm64.tar.gz
export PATH=$PATH:/usr/local/go/bin
mkdir go
export GOPATH=”$HOME/go”
go get github.com/kubernetes-incubator/cri-tools/cmd/crictl
```

--------------------------------

### Start Minikube with None Driver

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-openebs-with-kubernetes-using-minikube.md

Starts the Minikube cluster using the 'none' driver, suitable for direct use on the host OS. Requires sudo privileges and assumes Docker is installed.

```bash
sudo -E minikube start — vm-driver=none
```

--------------------------------

### Install Docker on Ubuntu

Source: https://github.com/openebs/website/blob/main/website/src/blogs/provisioning-kubernetes-cluster-by-kubeadm.md

Installs Docker using apt-get. Ensure your system is updated before running.

```bash
sudo apt-get update
sudo apt-get install -y docker.io
```

--------------------------------

### Install PostgreSQL Client

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-deploy-a-postgresql-cluster-on-kubernetes-openebs.md

Install the PostgreSQL client utility on your system to interact with the database cluster. This is a prerequisite for testing the cluster.

```bash
sudo apt-get install postgresql-client
```

--------------------------------

### Install Jiva Helm Chart

Source: https://github.com/openebs/website/blob/main/website/src/blogs/provisioning-openebs-jiva-volumes-via-csi.md

Installs the Jiva CSI driver using the Helm chart. Add the repository, update it, and then install the chart with a release name.

```bash
helm repo add openebs-jiva https://openebs.github.io/jiva-operator
helm repo update  
helm install <release-name> openebs-jiva/jiva
```

--------------------------------

### Install Docker on Ubuntu

Source: https://github.com/openebs/website/blob/main/website/src/blogs/contributing-to-mayactl-cli-in-hacktoberfest-2018.md

Commands to install Docker on an Ubuntu system. Ensure Docker is running before proceeding.

```bash
sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"
sudo apt-get update
sudo apt-get install docker.io
```

--------------------------------

### Install Minikube on Ubuntu

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-openebs-with-kubernetes-using-minikube.md

Installs the Minikube tool on an Ubuntu host. Ensure you have curl and sudo privileges.

```bash
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
sudo mv minikube /usr/local/bin/
```

--------------------------------

### Install Kubeadm on Armbian

Source: https://github.com/openebs/website/blob/main/website/src/blogs/arming-kubernetes-with-openebs-1.md

Installs Kubeadm on all nodes by adding the Kubernetes APT repository and then installing the kubeadm package.

```bash
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add — && \
 echo “deb http://apt.kubernetes.io/ kubernetes-xenial main” | sudo tee /etc/apt/sources.list.d/ kubernetes.list && \
 sudo apt-get update -q && \
 sudo apt-get install -qy kubeadm
```

--------------------------------

### Initiate Replicated PV Mayastor Upgrade

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/replicated-storage-user-guide/replicated-pv-mayastor/additional-information/upgrade-re.md

Execute this command to start the upgrade process for your Replicated PV Mayastor deployment. Ensure you replace `<mayastor-namespace>` with the actual namespace where Mayastor is installed.

```bash
kubectl mayastor upgrade -n <mayastor-namespace>
```

--------------------------------

### Install Kubeadm, Kubelet, and Kubectl on Ubuntu

Source: https://github.com/openebs/website/blob/main/website/src/blogs/provisioning-kubernetes-cluster-by-kubeadm.md

Installs Kubernetes components by adding the Kubernetes APT repository. Requires curl and apt-transport-https.

```bash
sudo apt-get update && sudo apt-get install -y apt-transport-https curl
sudo -i
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
$ deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
exit
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
```

--------------------------------

### Install OpenEBS using Helm

Source: https://github.com/openebs/website/blob/main/website/src/blogs/git-freedom-on-kubernetes.md

Installs the OpenEBS Helm chart to provision persistent storage. Use this command for a basic installation.

```bash
helm install — name ‘openebs-gitlab-test’ stable/openebs
```

--------------------------------

### Install ZFS Utilities

Source: https://github.com/openebs/website/blob/main/website/src/blogs/openebs-dynamic-volume-provisioning-on-zfs.md

Installs the necessary ZFS utilities on Ubuntu nodes. Ensure your nodes have ZFS support.

```bash
$ apt-get install -y zfsutils-linux
```

--------------------------------

### Example StorageClass with OpenEBS Storage Pool

Source: https://github.com/openebs/website/blob/main/website/src/blogs/using-openebs-for-running-kubernetes-stateful-applications-on-aws-instance-store-disks.md

An example demonstrating how to integrate the 'jivaawspool' into a Kubernetes StorageClass definition.

```yaml
-- -
    apiVersion: storage.k8s.io/v1
    kind: StorageClass
    metadata:
    name: openebs-percona
    provisioner: openebs.io/provisioner-iscsi
    parameters:
    openebs.io.storage-pool: “default”
    openebs.io/jiva-replica-count: “3”
    openebs.io/volume-monitor: “true”
    openebs.io/capacity: 5G
    openebs.io/storage-pool: “jivaawspool”— -
    -- -
```

--------------------------------

### Install Docker on Ubuntu

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-start-contributing-to-mayactl.md

Installs Docker on an Ubuntu system. Ensure you have the necessary permissions and an active internet connection.

```bash
sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-repository \
  "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) \
  stable"
sudo apt-get update
sudo apt-get install docker.io
```

--------------------------------

### Install Velero Utility

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/backup-and-restore/kubevirt-backup.md

Install the Velero command-line utility using Homebrew for managing backups.

```bash
brew install velero
```

--------------------------------

### Example Jira Pod Status Output

Source: https://github.com/openebs/website/blob/main/website/src/blogs/atlassian-jira-deployment-on-openebs.md

Example output showing a Jira pod in a 'Running' state with its age.

```text
NAME                    READY   STATUS    RESTARTS   AGE
jira-5xxxxxxxx-2xxxx    1/1     Running   0          1d12h

```

--------------------------------

### Install Kubectl on Ubuntu

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-openebs-with-kubernetes-using-minikube.md

Installs the kubectl command-line tool to interact with Kubernetes clusters. Requires curl and sudo privileges.

```bash
curl -Lo kubectl https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

--------------------------------

### Install XFS Utilities

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/local-storage-user-guide/local-pv-hostpath/advanced-operations/xfs-quota/loop-device-xfs-quota.md

Install the necessary xfsprogs package for managing XFS filesystems. Use apt for Debian/Ubuntu and yum for RHEL/CentOS.

```bash
sudo apt update
sudo apt-get install -y xfsprogs
```

```bash
sudo yum install -y xfsprogs
```

--------------------------------

### Example Volume Populator using lib-volume-populator

Source: https://github.com/openebs/website/blob/main/website/src/blogs/life-cycle-of-pvc-with-volume-populator.md

This is an example of a data populator written using the lib-volume-populator library. It demonstrates how to implement a custom volume populator for Kubernetes.

```go
package main

import (
	"context"
	"fmt"
	"os"

	"github.com/container-storage-interface/spec/lib/go/csi"
	"github.com/kubernetes-csi/lib-volume-populator/pkg/populator"
)

func main() {
	// Example usage of lib-volume-populator
	// This is a placeholder and would typically involve more setup
	// and interaction with CSI and Kubernetes APIs.
	fmt.Println("Hello, Volume Populator!")

	// In a real scenario, you would initialize and run the populator server:
	// populator.Run(context.Background(), &myPopulator{})

	// For demonstration, we'll just exit.
	os.Exit(0)
}

// Define a struct that implements the populator.Populator interface
type myPopulator struct {
	// Add any necessary fields here
}

// Implement the required methods for the populator.Populator interface
func (p *myPopulator) Populate(ctx context.Context, req *populator.PopulateRequest, resp *populator.PopulateResponse) error {
	// Implement the logic to populate the volume based on the dataSource
	// For example, copy data from a source to the target volume path.
	fmt.Printf("Populating volume %s for PVC %s/%s\n", req.VolumeId, req.PvcNamespace, req.PvcName)

	// Simulate data population
	// In a real implementation, this would involve I/O operations.
	resp.Error = ""
	return nil
}

func (p *myPopulator) PrePopulate(ctx context.Context, req *populator.PrePopulateRequest, resp *populator.PrePopulateResponse) error {
	// Implement pre-population logic if needed
	fmt.Printf("Pre-populating volume %s for PVC %s/%s\n", req.VolumeId, req.PvcNamespace, req.PvcName)
	resp.Error = ""
	return nil
}

func (p *myPopulator) Cleanup(ctx context.Context, req *populator.CleanupRequest, resp *populator.CleanupResponse) error {
	// Implement cleanup logic if needed
	fmt.Printf("Cleaning up volume %s\n", req.VolumeId)
	resp.Error = ""
	return nil
}

// Example of how to run the populator server (simplified)
func runPopulatorServer() {
	ctx := context.Background()
	// Replace with your actual populator implementation
	myPop := &myPopulator{}

	// This is a simplified representation. The actual Run function from lib-volume-populator
	// handles gRPC server setup and registration.
	fmt.Println("Starting volume populator server...")
	// populator.Run(ctx, myPop)
}

```

--------------------------------

### Set Namespace for OpenEBS Installation

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/kubectl-openebs.md

Example of setting the current context's namespace to 'storage', assuming OpenEBS is installed in that namespace.

```bash
kubectl config set-context --namespace=storage --current
```

--------------------------------

### Example Mayastor Volume Output

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/replicated-storage-user-guide/replicated-pv-mayastor/configuration/rs-deployment.md

This is an example output of the 'kubectl mayastor get volumes' command, showing volume details and status.

```text
ID                                    REPLICAS  TARGET-NODE                ACCESSIBILITY STATUS  SIZE

18e30e83-b106-4e0d-9fb6-2b04e761e18a  3         aks-agentpool-12194210-0   nvmf           Online  1073741824 

```

--------------------------------

### Create Installation Folder and Extract Config

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-ibm-cloud-private-updated.md

Sets up the necessary directory structure and extracts the sample configuration files for ICP installation. Ensure you accept the license.

```bash
mkdir /opt/ibm-cloud-private-ce-3.1.0; \
    cd /opt/ibm-cloud-private-ce-3.1.0
    sudo docker run -e LICENSE=accept \
    -v “$(pwd)”:/data ibmcom/icp-inception:3.1.0 cp -r cluster/data
```

--------------------------------

### Supportability Tool Usage Help

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/supportability.md

This is the sample output for the `kubectl openebs dump --help` command, detailing usage, commands, and options for collecting system state and log information.

```text
Supportability - collects state & log information of services and dumps it to a tar file

Usage: kubectl-openebs dump [OPTIONS] <COMMAND>

Commands:
  system  Collects entire system information
  help    Print this message or the help of the given subcommand(s)

Options:
  -t, --timeout <TIMEOUT>
          Specifies the timeout value to interact with other modules of system [default: 10s]
  -s, --since <SINCE>
          Period states to collect all logs from last specified duration [default: 24h]
  -l, --loki-endpoint <LOKI_ENDPOINT>
          Endpoint of LOKI service, if left empty then it will try to parse endpoint from Loki service(K8s service resource), if the tool is unable to parse from service then logs will be collected using Kube-apiserver
  -e, --etcd-endpoint <ETCD_ENDPOINT>
          Endpoint of ETCD service, if left empty then will be parsed from the internal service name
  -d, --output-directory-path <OUTPUT_DIRECTORY_PATH>
          Output directory path to store archive file [default: ./]
      --tenant-id <TENANT_ID>
          The tenant id to be used to query loki logs [default: openebs]
      --logging-label-selectors <LOGGING_LABEL_SELECTORS>
          Logging label selectors [default: openebs.io/logging=true]
  -n, --namespace <NAMESPACE>
          Namespace where openebs is installed. If unset, defaults to the default namespace in the current context
  -k, --kubeconfig <KUBECONFIG>
          Path to kubeconfig file
  -h, --help
          Print help

Supportability - collects state & log information of services and dumps it to a tar file.
```

--------------------------------

### Install xfsprogs on RHEL/CentOS

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/local-storage-user-guide/local-pv-hostpath/advanced-operations/xfs-quota/xfs-quota-pre.md

Installs the `xfsprogs` package needed for XFS quota functionality on RHEL and CentOS systems. Execute this command prior to quota setup.

```bash
$ sudo yum install -y xfsprogs
```

--------------------------------

### Install ZFS Utilities and Create ZFS Pool

Source: https://context7.com/openebs/website/llms.txt

Installs ZFS utilities on nodes and creates a ZFS pool. Use a real disk for production or a loopback device for testing.

```bash
# Install ZFS utilities on all nodes
apt-get install zfsutils-linux

# Create a ZFS pool on a real disk (striped)
zpool create zfspv-pool /dev/sdb

# Create a ZFS pool on a loopback device (testing only)
truncate -s 100G /tmp/disk.img
zpool create zfspv-pool $(losetup -f /tmp/disk.img --show)

# Verify pool
zpool status
```

```bash
#   pool: zfspv-pool
#  state: ONLINE
# config:
#   NAME        STATE     READ WRITE CKSUM
#   zfspv-pool  ONLINE       0     0     0
#     sdb       ONLINE       0     0     0
```

--------------------------------

### Helm Installation Error on AKS

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/troubleshooting/troubleshooting-local-storage.md

Example of an error message encountered during OpenEBS Helm installation on AKS, indicating a failure to grant necessary privileges due to RBAC misconfiguration.

```shell
Error: release openebs failed: clusterroles.rbac.authorization.k8s.io "openebs" isforbidden: attempt to grant extra privileges:[PolicyRule{Resources:["nodes"], APIGroups:["*"],Verbs:["get"]} PolicyRule{Resources:["nodes"],APIGroups:["*"], Verbs:["list"]}PolicyRule{Resources:["nodes"], APIGroups:["*"],Verbs:["watch"]} PolicyRule{Resources:["nodes/proxy"],APIGroups:["*"], Verbs:["get"]}PolicyRule{Resources:["nodes/proxy"], APIGroups:["*"],Verbs:["list"]} PolicyRule{Resources:["nodes/proxy"],APIGroups:["*"], Verbs:["watch"]}PolicyRule{Resources:["namespaces"], APIGroups:["*"],Verbs:["*"]} PolicyRule{Resources:["services"],APIGroups:["*"], Verbs:["*"]} PolicyRule{Resources:["pods"],APIGroups:["*"], Verbs:["*"]}PolicyRule{Resources:["deployments"], APIGroups:["*"],Verbs:["*"]} PolicyRule{Resources:["events"],APIGroups:["*"], Verbs:["*"]}PolicyRule{Resources:["endpoints"], APIGroups:["*"],Verbs:["*"]} PolicyRule{Resources:["persistentvolumes"],APIGroups:["*"], Verbs:["*"]} PolicyRule{Resources:["persistentvolumeclaims"],APIGroups:["*"], Verbs:["*"]}PolicyRule{Resources:["storageclasses"], APIGroups:["storage.k8s.io"], Verbs:["*"]}PolicyRule{Resources:["storagepools"], APIGroups:["*"],Verbs:["get"]} PolicyRule{Resources:["storagepools"], APIGroups:["*"],Verbs:["list"]} PolicyRule{NonResourceURLs:["/metrics"],Verbs:["get"]}] user=&{system:serviceaccount:kube-system:tiller6f3172cc-4a08-11e8-9af5-0a58ac1f1729 [system:serviceaccounts system:serviceaccounts:kube-systemsystem:authenticated] map[]} ownerrules=[]ruleResolutionErrors=[clusterroles.rbac.authorization.k8s.io"cluster-admin" not found]
```

--------------------------------

### View Supportability Tool Help

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/supportability.md

Execute this command to see all available options and sub-commands for the dump command.

```bash
kubectl openebs dump --help
```

--------------------------------

### Get CustomResourceDefinitions (CRDs)

Source: https://github.com/openebs/website/blob/main/website/src/blogs/openebs-snapshots-using-kubectl.md

Verify that the Snapshot-controller CRDs are installed and running by listing them with kubectl.

```bash
kubectl get crd
NAME                                                         AGE
volumesnapshotdatas.volumesnapshot.external-storage.k8s.io   1m
volumesnapshots.volumesnapshot.external-storage.k8s.io       1m
```

--------------------------------

### Create and Build React App

Source: https://github.com/openebs/website/blob/main/website/src/blogs/a-hands-on-demo-of-volume-populator-using-openebs-lvm-csi-driver.md

Initializes a new React application using create-react-app and then builds the production-ready static files.

```bash
npx create-react-app my-app
cd my-app
npm build
```

--------------------------------

### Kubectl Get Pods Command

Source: https://github.com/openebs/website/blob/main/website/src/blogs/openebs-dynamic-volume-provisioning-on-zfs.md

Command to check the status of Kubernetes pods. This is useful for verifying if the Percona deployment has started successfully.

```bash
kubectl get po

```

--------------------------------

### Create Database and Insert Sample Data

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/backup-and-restore/cloudnative-pg-backups.md

SQL commands to create a new database, a sample table, and insert 100 records into it. This is useful for testing and demonstration purposes.

```sql
CREATE DATABASE demo;
\c demo;

CREATE TABLE my_table (
  id SERIAL PRIMARY KEY,
  name VARCHAR(255),
  value INTEGER,
  created_at TIMESTAMP DEFAULT NOW()
);

INSERT INTO my_table (name, value)
SELECT
  'Record ' || generate_series(1, 100),
  (random() * 1000)::INTEGER;

SELECT COUNT(*) FROM my_table;
```

--------------------------------

### Setup Chaoskube Infrastructure

Source: https://github.com/openebs/website/blob/main/website/src/blogs/using-chaoskube-with-openebs.md

Apply the Chaoskube deployment and RBAC configurations to your Kubernetes cluster. This installs Chaoskube and grants it necessary permissions.

```bash
ubuntu@kubemaster-01:~$ kubectl get nodes
NAME            STATUS    ROLES     AGE       VERSION
kubemaster-01   Ready     master    2d        v1.8.8
kubeminion-01   Ready     <none>    2d        v1.8.8
kubeminion-02   Ready     <none>    2d        v1.8.8
kubeminion-03   Ready     <none>    2d        v1.8.8
```

```bash
ubuntu@kubemaster-01:~$ kubectl apply -f https://raw.githubusercontent.com/openebs/openebs/master/e2e/ansible/playbooks/resiliency/test-ctrl-failure/chaoskube.yaml
deployment "chaoskube" created
serviceaccount "chaoskube" created
```

```bash
ubuntu@kubemaster-01:~$ kubectl apply -f https://raw.githubusercontent.com/openebs/openebs/master/e2e/ansible/playbooks/resiliency/test-ctrl-failure/rbac.yaml
clusterrole "chaoskube" created
clusterrolebinding "chaoskube" created
```

```bash
ubuntu@kubemaster-01:~$ kubectl get pods
NAME                                   READY     STATUS    RESTARTS   AGE
chaoskube-55fc8f5f6d-tb6hj             1/1       Running   0          32s
maya-apiserver-69f9db69-b9qxk          1/1       Running   0          2d
openebs-provisioner-77cb47986c-w6wbz   1/1       Running   1          2d
```

--------------------------------

### Install Velero with GCP Provider

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/data-migration/migration-using-velero/migration-for-replicated-db/replicateddb-restore.md

Install Velero on the destination cluster using the GCP provider. Ensure you use the same bucket name and secret file as the original setup. This command also specifies the use of the node agent and the restic uploader type.

```bash
velero install --use-node-agent --provider gcp --plugins velero/velero-plugin-for-gcp:v1.6.0 --bucket BUCKET-NAME --secret-file SECRET-FILENAME --uploader-type restic
```

--------------------------------

### Install ZFS Utils and Import ZFS Pool

Source: https://github.com/openebs/website/blob/main/website/src/blogs/handling-node-down-cluster-scaling-on-zfs-localpv-backed-workloads.md

Installs necessary ZFS utilities and imports an existing ZFS pool. Ensure you have root privileges.

```bash
$ sudo su -
$ sudo apt-get update
$ apt-get install zfsutils-linux -y
$ zpool import zfspv-pool
```

--------------------------------

### Insert Sample Data into VM

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/read-write-many/kubevirt.md

Use the VM console to create and populate a test file. This is a prerequisite for validating live migration.

```bash
kubevirt virtctl console vm1   
Successfully connected to vm1 console. The escape sequence is ^]

vm1 login: root
Password:
Last login: Wed May  7 09:07:08 on ttyS0
[root@vm1 ~]# 
[root@vm1 ~]# 
[root@vm1 ~]# 
[root@vm1 ~]# touch sampledata.txt
[root@vm1 ~]# echo "This is some test Data" > sampledata.txt
[root@vm1 ~]# 
[root@vm1 ~]# cat sampledata.txt
This is some test Data
[root@vm1 ~]#
```

--------------------------------

### Configure Hosts File for ICP Installation

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-ibm-cloud-private-updated.md

Defines the master, worker, and proxy nodes for your ICP cluster by listing their IP addresses in the hosts file. Adjust according to your network setup and workload requirements.

```bash
$ cat /opt/ibm-cloud-private-ce-3.1.0/cluster/hosts
[master]
10.10.0.161
[worker]
10.10.0.161
10.10.0.162
10.10.0.163
10.10.0.164
10.10.0.165
[proxy]
10.10.0.161
#[management]
#4.4.4.4
#[va]
#5.5.5.5
```

--------------------------------

### Install Velero with MinIO Backend

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/local-storage-user-guide/local-pv-zfs/advanced-operations/zfs-backup-restore.md

Install Velero CLI and configure it to use a MinIO instance for storing backups, specifying plugins and backup location details.

```bash
velero install --provider aws --bucket velero --secret-file /home/pawan/velero/credentials-minio --plugins velero/velero-plugin-for-aws:v1.0.0-beta.1 --backup-location-config region=minio,s3ForcePathStyle="true",s3Url=http://minio.velero.svc:9000 --use-volume-snapshots=true --use-node-agent --uploader-type restic
```

--------------------------------

### Install Velero

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/data-migration/migration-using-velero/migration-for-distributed-db/distributeddb-restore.md

Install Velero with necessary plugins, specifying your backup bucket, secret file, and uploader type. Replace placeholders with your specific values.

```bash
velero install --provider gcp --plugins velero/velero-plugin-for-gcp:v1.0.0 --bucket-name YOUR_BUCKET_NAME --secret-file ./credentials-velero --use-node-agent
```

--------------------------------

### Install CloudNativePG Operator

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/backup-and-restore/cloudnative-pg-backups.md

Installs the CloudNativePG operator using its official manifest. The operator is typically installed in the 'cnpg-system' namespace.

```bash
kubectl apply --server-side -f https://raw.githubusercontent.com/cloudnative-pg/cloudnative-pg/release-1.25/releases/cnpg-1.25.1.yaml
```

--------------------------------

### Install WordPress with Dynamic NFS Provisioner

Source: https://github.com/openebs/website/blob/main/website/src/blogs/install-wordpress-using-dynamic-nfs-provisioner.md

Install WordPress using Helm, configuring persistence with an NFS provisioner. This command sets up WordPress, MariaDB, and enables autoscaling.

```sh
helm install my-release -n wordpress --create-namespace \
    --set wordpressUsername=admin \
    --set wordpressPassword=password \
    --set mariadb.auth.rootPassword=secretpassword \
    --set mariadb.primary.persistence.enabled=true \
    --set mariadb.primary.persistence.storageClass=openebs-hostpath \
    --set mariadb.primary.persistence.accessModes={ReadWriteOnce} \
    --set persistence.storageClass=openebs-kernel-nfs \
    --set persistence.accessModes={ReadWriteMany} \
    --set volumePermissions.enabled=true \
    --set autoscaling.enabled=true \
    --set autoscaling.minReplicas=2 \
    --set autoscaling.maxReplicas=6 \
    --set autoscaling.targetCPU=80 \
    bitnami/wordpress
```

--------------------------------

### Configure Minikube and Kubectl Directories

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-openebs-with-kubernetes-using-minikube.md

Sets up the necessary directories for Minikube and Kubectl configuration files. The '|| true' prevents errors if the directory already exists.

```bash
mkdir $HOME/.kube || true
touch $HOME/.kube/config
```

--------------------------------

### Install Docker CE Prerequisites

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-ibm-cloud-private-updated.md

Install necessary packages for adding the Docker repository and managing HTTPS transport. These are prerequisites for Docker CE installation.

```bash
sudo apt-get install \
 apt-transport-https \
 ca-certificates \
 software-properties-common
```

--------------------------------

### Apply Virtual Machine Configuration

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/read-write-many/kubevirt.md

Apply the VirtualMachine configuration to deploy the VM.

```bash
kubectl create -f vm1_pvc.yaml
```

--------------------------------

### Install systemd-coredump and GDB

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/troubleshooting/troubleshooting-replicated-storage.md

Installs the systemd-coredump package for managing coredumps and the GDB debugger for analysis. Ensure lz4 is also installed for compressed coredump handling.

```bash
sudo apt-get install -y systemd-coredump gdb lz4
```

--------------------------------

### Install Docker CE on Ubuntu

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-openebs-with-kubernetes-using-minikube.md

Install the latest version of Docker Community Edition from the official Docker repository. This involves adding the repository and then installing the docker-ce package.

```bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get update
sudo apt-get install -y docker-ce
sudo systemctl status docker
```

--------------------------------

### Initialize Git Repository and Push to GitHub

Source: https://github.com/openebs/website/blob/main/website/src/blogs/build-a-ci-dashboard.md

Use these Git commands to initialize a local repository, add files, commit changes, set the remote origin, and push to a GitHub repository.

```bash
git init
git add .
git commit -s -m "Initial commit"
git remote add origin <origin_url>.git
git push origin master
```

--------------------------------

### Install OpenEBS Operator and Storage Classes on ARM

Source: https://github.com/openebs/website/blob/main/website/src/blogs/arming-kubernetes-with-openebs-1.md

Installs necessary packages and applies the OpenEBS operator and storage class configurations for arm64 architecture. Ensure you have curl and open-iscsi installed.

```bash
sudo apt-get install -y curl open-iscsi
kubectl apply -f https://raw.githubusercontent.com/muratkarslioglu/openebs/lepotato-arm64/k8s/openebs-operator-arm64.yaml
kubectl apply -f https://raw.githubusercontent.com/muratkarslioglu/openebs/lepotato-arm64/k8s/openebs-storageclasses.yaml
```

--------------------------------

### Install New Control-Plane Components

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/replicated-storage-user-guide/replicated-pv-mayastor/additional-information/legacy-upgrade.md

Apply the modified `helm_templates.yaml` file to install the new control-plane components. Note that High Availability (HA) for nexus is disabled by default with this installation method.

```bash
kubectl apply -f helm_templates.yaml -n mayastor
```

--------------------------------

### Install Mayastor with Custom Cluster Domain

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/faqs/faqs.md

When installing Mayastor on a Kubernetes cluster with a custom domain other than 'cluster.local', specify the custom domain using the `--set mayastor.etcd.clusterDomain` flag during Helm installation.

```bash
helm install openebs openebs/openebs -n openebs --create-namespace --set mayastor.etcd.clusterDomain="<your-custom-cluster-domain>"
```

--------------------------------

### Sample Pod Status Output

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/replicated-storage-user-guide/replicated-pv-mayastor/additional-information/legacy-upgrade.md

Example output showing Mayastor pods in a 'Running' state, indicating a successful deployment.

```text
NAME                                         READY   STATUS    RESTARTS   AGE
mayastor-65cxj                               1/1     Running   0          9m42s
mayastor-agent-core-7d7f59bbb8-nwptm         2/2     Running   0          104s
mayastor-api-rest-6d774fbdd8-hgrxj           1/1     Running   0          104s      mayastor-csi-controller-6469fdf8db-bgs2h     3/3     Running   0          104s
mayastor-csi-node-7zm2v                      2/2     Running   0          104s
mayastor-csi-node-gs76x                      2/2     Running   0          104s
mayastor-csi-node-mfqfq                      2/2     Running   0          104s
mayastor-etcd-0                              1/1     Running   0          13m
mayastor-etcd-1                              1/1     Running   0          13m
mayastor-etcd-2                              1/1     Running   0          13m
```

--------------------------------

### Install NFS CSI Driver using Helm

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/read-write-many/kubevirt.md

Installs the NFS CSI driver using Helm, specifying the namespace and a custom values file. Ensure Helm repositories are updated before installation.

```bash
helm repo add csi-driver https://raw.githubusercontent.com/kubernetes-csi/csi-driver-nfs/master/charts
helm repo update
helm install csi-nfs csi-driver/csi-driver-nfs --namespace csi-nfs -f values.yaml
```

--------------------------------

### Example MongoDB Data Insertion

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/user-guides/data-migration/migration-using-pv-migrate.md

Demonstrates inserting sample data into a MongoDB instance deployed on Local PV Device storage. This data will be migrated.

```javascript
db.admin.insertMany([{name: "Max"}, {name:"Alex"}])

[
  { _id: ObjectId('65eaafa01cd2b6de45285d86'), name: 'Max' },
  { _id: ObjectId('65eaafa01cd2b6de45285d87'), name: 'Alex' }
]
```

--------------------------------

### Install OpenEBS via Helm

Source: https://context7.com/openebs/website/llms.txt

Add the OpenEBS Helm repository and update it. Then, install the full OpenEBS stack or a local-storage-only configuration. Use custom kubelet directories if necessary.

```bash
# Add and update the Helm repository
helm repo add openebs https://openebs.github.io/openebs
helm repo update

# Full installation (Local PV Hostpath + LVM + ZFS + Replicated PV Mayastor)
helm install openebs --namespace openebs openebs/openebs --create-namespace

# Local storage only (skip Replicated PV Mayastor)
helm install openebs --namespace openebs openebs/openebs \
  --set engines.replicated.mayastor.enabled=false \
  --create-namespace

# Custom kubelet directory (MicroK8s example)
helm install openebs --namespace openebs openebs/openebs \
  --set lvm-localpv.lvmNode.kubeletDir=/var/snap/microk8s/common/var/lib/kubelet/ \
  --set zfs-localpv.zfsNode.kubeletDir=/var/snap/microk8s/common/var/lib/kubelet/ \
  --set mayastor.csi.node.kubeletDir=/var/snap/microk8s/common/var/lib/kubelet/ \
  --create-namespace
```

```bash
# Verify installation
helm ls -n openebs
# NAME     NAMESPACE   REVISION  STATUS     CHART           APP VERSION
# openebs  openebs     1         deployed   openebs-4.4.0   4.4.0

kubectl get pods -n openebs
# NAME                                              READY   STATUS    RESTARTS   AGE
# openebs-agent-core-674f784df5-7szbm               2/2     Running   0          11m
# openebs-localpv-provisioner-6ddf7c7978-4fkvs      1/1     Running   0          11m
# openebs-lvm-localpv-controller-7b6d6b4665-fk78q   5/5     Running   0          11m
# openebs-zfs-localpv-controller-f78f7467c-blr7q    5/5     Running   0          11m
# openebs-io-engine-7t6tf                           2/2     Running   0          11m
# ...

kubectl get sc
# NAME                       PROVISIONER               RECLAIMPOLICY   VOLUMEBINDINGMODE
# openebs-hostpath           openebs.io/local          Delete          WaitForFirstConsumer
# openebs-single-replica     io.openebs.csi-mayastor   Delete          Immediate
```

--------------------------------

### Install ICP with Verbose Logging

Source: https://github.com/openebs/website/blob/main/website/src/blogs/how-to-install-ibm-cloud-private-updated.md

Use this command to run the ICP installer with verbose logging enabled. This is helpful for diagnosing installation failures, especially when encountering issues like timeouts waiting for services.

```bash
docker run -e LICENSE=accept — net=host \
    -t -v “$(pwd)”:/installer/cluster \
    ibmcom/icp-inception:3.1.0 install -vvv | tee -a install_log.txt
```

--------------------------------

### Apply and Verify Hostpath Application

Source: https://context7.com/openebs/website/llms.txt

Apply the PVC and Pod definitions, then verify the PVC status and check the data written to the volume.

```bash
kubectl apply -f local-hostpath-pvc.yaml
kubectl apply -f local-hostpath-pod.yaml

kubectl get pvc local-hostpath-pvc
# NAME                 STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS       AGE
# local-hostpath-pvc   Bound    pvc-864a5ac8-dd3f-416b-9f4b-ffd7d285b425   5G         RWO            openebs-hostpath   28m

kubectl exec hello-local-hostpath-pod -- cat /mnt/store/greet.txt
# Thu Apr 16 17:56:34 UTC 2020 [hello-local-hostpath-pod] Hello from OpenEBS Local PV.

```

--------------------------------

### Verify Velero Installation

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/backup-and-restore/kubevirt-backup.md

Check the status of Velero components and backup storage location after installation.

```bash
kubectl get all -n velero
```

```bash
velero get backup-location
```

--------------------------------

### Prepare Host Disk for LVM Volume Group

Source: https://github.com/openebs/website/blob/main/website/src/blogs/a-hands-on-demo-of-volume-populator-using-openebs-lvm-csi-driver.md

Creates a 10GB disk image file, sets it up as a loop device, and then creates a physical volume and volume group on it for LVM storage.

```bash
truncate -s 10G /tmp/disk.img
sudo losetup -f /tmp/disk.img --show
#get loop device id and replace X with it
sudo pvcreate /dev/loopX
sudo vgcreate lvmvg /dev/loopX
```

--------------------------------

### Deploy Sample Application (Minio)

Source: https://github.com/openebs/website/blob/main/website/src/blogs/openebs-ndm-goto-solution-for-managing-kubernetes-local-storage.md

Apply a sample Minio application deployment to your Kubernetes cluster. Ensure the application is scheduled on a worker node with available storage.

```bash
kubectl apply -f [minio-official.yaml](https://gist.githubusercontent.com/akhilerm/194a1606c514d8930addcaef56f9f19f/raw/7d339e5042b4e5e958dde558f1f3509e26c214f3/minio-official.yaml)
```

--------------------------------

### Install KOPS CLI

Source: https://github.com/openebs/website/blob/main/website/src/blogs/provisioning-google-cloud-with-k8s-using-its-in-house-tool-kops.md

Download and install the KOPS command-line interface for Linux. Ensure the binary is executable and moved to a directory in your system's PATH.

```bash
wget -O kops
https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64

chmod +x ./kops

sudo mv ./kops /usr/local/bin/
```

--------------------------------

### Verify Velero Pods Installation

Source: https://github.com/openebs/website/blob/main/docs/versioned_docs/version-4.4.x/Solutioning/backup-and-restore/velero-br-fs.md

Check if the Velero pods are running correctly in the 'velero' namespace after installation.

```bash
kubectl get pods -n velero
```

--------------------------------

### Create Demo Disks with gcloud

Source: https://github.com/openebs/website/blob/main/website/src/blogs/cstor-pool-operations-via-cspc-in-openebs.md

Use this command to create multiple demo disks for testing purposes. Ensure you have gcloud CLI installed and configured.

```bash
for i in {1..6}; do gcloud compute disks create demo-disk-$i --zone=us-central1-a --size=100GB; done
```