2. Installing Robin Cloud Native Storage (CNS)¶

In this section, we will cover the pre-requisites, getting Robin CNS Software and installing Robin CNS on various Kubernetes distributions/versions.

2.1. Prerequisites¶

2.1.1. Minimum Resource Requirements¶

The minimum compute requirements in order to install Robin CNS on a Kubernetes cluster are listed below:

Each node must have at least 4 CPUs
Each node must have at least 4GB of memory

In order to determine the resource capacity on an existing Kubernetes cluster the following command can be used:

$ kubectl  get nodes -o custom-columns=Name:.metadata.name,OSImage:.status.nodeInfo.osImage,KubeVersion:.status.nodeInfo.kubeProxyVersion,CPU:.status.capacity.cpu,Memory:.status.capacity.memory,providerID:.spec.providerID

2.1.2. Supported Kubernetes versions¶

Robin CNS can be installed on the following Kubernetes Distributions/versions.

Kubernetes	Version Supported
OpenShift	4.5, 4.4
Google Anthos	1.6, 1.7, 1.8
GKE	1.16 through to 1.20
AKS	1.16 through to 1.20
EKS	1.16 through to 1.20
IKS	1.16 through to 1.20

2.1.3. Supported OS for worker nodes¶

CentOS 7/8
Redhat 7/8
Ubuntu
Red Hat Enterprise Linux CoreOS
Container optimized OS (For GKE)

Note

Windows based OS are not supported by Robin CNS

2.1.4. Kernel dependency¶

Minimum supported kernel version for Redhat/CentOS based OS is 3.10.0-1062.xx.el7.x86_64. Run the command below to confirm that you are running the minimum supported kernel version:
```
$ uname -r
```
or run yum update to upgrade to the latest available kernel.
Ensure the tcm_loop kernel modules are loaded on all nodes within the cluster before starting the installation process.

$ lsmod | egrep '^target_core_user|^tcm_loop'
target_core_user       35043  0
tcm_loop               21028  3
In order to load the modules on an Ubuntu based machine, run the following commands:
$ sudo apt-get update

$ sudo apt-get install linux-modules-extra-<kernel-version>

$ sudo depmod -a

$ sudo modprobe tcm_loop

$ lsmod | grep tcm
tcm_loop 28672 3
target_core_mod 360448 5 tcm_loop,target_core_user
Note

The kernel version can be determined from the output of the uname -r command.

2.1.5. User permissions¶

Ensure the user installing Robin CNS is the Cluster Administrator within the Kubernetes cluster.

2.1.6. Port and access requirements¶

If you are installing Robin CNS on any platform, the following ports need to be accessible for the installation to succeed and for Robin to operate correctly:

Ports	Description
29442 - 29470	Robin services
30000 - 32767	IKS Access Ports

Note

The above list of ports also apply to on-premises clusters. For the cloud platforms, when creating each rule to make the port accessible ensure that the protocol is TCP. In addition the cloud nodes should be able to communicate with one another on all ports via the IPv4 protocol.

Detailed below are the resources to manage ports and access requirements on various cloud platforms.

AWS

Ports can be made accessible via security groups on AWS. Details on how to create security groups can be found here.
Robin requires both the access key and secret key of a user to be assed during installation. Details on how to create/manage AWS credentials can be found here.

GCP

Ports can be made accessible via firewall rules on GCP. Details on how to create appropriate firewall rules can be found here.
Instances on which Robin will be installed need to have full access to cloud APIs. This can be set during instance creation.

Azure

Ports can be made accessible via network security groups on Azure. Details on how to create network groups can be found here.

IKS

Ports can be made accessible via network Network interfaces section on IKS. Details on how to create configure network interfaces can be found here.
Robin requires API key of a user to access during installation. Details on how to create/manage here.

2.1.7. Supported Volumes Types¶

The following are the supported volume types:

GCP: pd-ssd, pd-standard
AWS: gp2, io1, st1
Google Anthos : independent-persistent
IBM cloud Platform : IBM include general-purpose (3iops-tier), 5iops-tier, 10iops-tier, custom

2.1.8. Storage requirements¶

The disks available for use by Robin CNS should meeting the following requirements:

Should not have any filesystem
Should not have any partitions created on the disk. If the partitions should be used for robin storage, there are manual steps involved to make this work.
Robin recommends having direct access to the storage disks without RAID controller in between. If RAID is to be used and caching is enabled at RAID controller level, then cache should be battery backed. This is to guarantee data consistency when power goes off. Overall, Robin does not recommend using RAID configuration and is discussed in more detail here.

Note

Within the cluster, there needs to be at least one disk available for use by Robin CNS.

2.1.9. Downloading Robin CNS Software¶

Depending on the Kubernetes distribution there could be more than one way to install Robin. Please visit the following link to see all the install options available to your specific setup. In addition if the Robin installer is used, it will automatically determine the Kubernetes distribution available on the target cluster.

Note

You have to first register an account before you can access the download link for your environment.

2.2. Install on OpenShift¶

Robin CNS can be deployed on OpenShift using any of the methods below:

Using the Robin installer to deploy all necessary objects.
Using the Operator Lifecycle Manager to deploy the operator.
Installing Robin CNS via OperatorHub from the Openshift console.

Note

Throughout this documentation the oc command is equivalent to the kubectl command.
The commands starting with oc are applicable for the OpenShift environment.

2.2.1. Prerequisites¶

Kubernetes user(s) who are running either the kubectl or oc commands shown below must have the cluster-admin role currently assigned to them.
The ports detailed here need to be accessible for the installation to succeed and for Robin to operate correctly.

In addition to the above requirements, one needs to create the appropriate Security Context Constraints. These can be created via the CLI. Define the SCC in a JSON or YAML file as shown below:

   kind: SecurityContextConstraints
   apiVersion: security.openshift.io/v1
   metadata:
     name: robin-scc
   allowPrivilegedContainer: true
   runAsUser:
     type: RunAsAny
   seLinuxContext:
     type: RunAsAny
   fsGroup:
     type: RunAsAny
   supplementalGroups:
     type: RunAsAny
   users:
   - my-admin-user
   groups:
   - my-admin-group


.. code-block:: text

        $ oc apply -f robin-scc.yaml

2.2.2. Install using the Robin Installer¶

Follow the steps below to download and install Robin CNS for Openshift on AWS. Please proceed to Step 4 if you have already downloaded the installer.

Visit the following link and register an account.
From the Downloads page click Download and Install on AWS on the Deploy on Red Hat OpenShift tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=openshift-aws" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh --access-key=<AWS-ACCESS-KEY> --secret-key=<AWS-SECRET-KEY> -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

This concludes the install. Continue here to verify the installation and set up the product.

Follow the steps below to download and install Robin CNS for Openshift on AZURE. Please proceed to Step 4 if you have already downloaded the installer.

Visit the following link and register an account.
From the Downloads page click Download and Install on Azure on the Deploy on RedHat Openshift tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=openshift-azure" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh --app-id=XXXXXXXXXXXXXXXXXXXXXXX --tenant-id=XXXXXXXXXXXXXXXXXXXXX --secret-key=XXXXXXXXXXXXXXX  -y

Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin

This concludes the install. Continue here to verify the installation and set up the product.

Follow the steps below to download and install Robin CNS for Openshift on GCP. Please proceed to Step 4 if you have already downloaded the installer.

Visit the following link and register an account.
From the Downloads page click Download and Install on GCP on the Deploy on RedHat Openshift tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=openshift-gcp" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin

This concludes the install. Continue here to verify the installation and set up the product.

Follow the steps below to download and install Robin CNS for Openshift OnPrem. Please proceed to Step 4 if you have already downloaded the installer.

Visit the following link and register an account.
From the Downloads page click Download and Install on-prem on the Deploy on Red Hat OpenShift tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=openshift-onprem" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin

This concludes the install. Continue here to verify the installation and set up the product.

2.2.3. Verify installation on Openshift¶

Once the installation is complete, you can get details about robin cluster by running the command:

$ oc get pods -n robinio -o wide
NAME                                     READY   STATUS    RESTARTS   AGE     IP             NODE                                         NOMINATED NODE   READINESS GATES
csi-attacher-robin-64d68c57c4-k6pmv      3/3     Running   0          3d23h   10.131.0.6     ip-10-0-167-211.us-west-1.compute.internal   <none>           <none>
csi-nodeplugin-robin-ftn4n               3/3     Running   0          3d23h   10.0.220.43    ip-10-0-220-43.us-west-1.compute.internal    <none>           <none>
csi-nodeplugin-robin-sf4s6               3/3     Running   0          3d23h   10.0.167.211   ip-10-0-167-211.us-west-1.compute.internal   <none>           <none>
csi-nodeplugin-robin-zz77z               3/3     Running   0          3d23h   10.0.128.218   ip-10-0-128-218.us-west-1.compute.internal   <none>           <none>
csi-provisioner-robin-7847568d5d-qbjqx   3/3     Running   0          3d23h   10.128.2.4     ip-10-0-128-218.us-west-1.compute.internal   <none>           <none>
csi-resizer-robin-7f65965b9-wwg6j        3/3     Running   0          3d23h   10.131.0.10    ip-10-0-167-211.us-west-1.compute.internal   <none>           <none>
csi-snapshotter-robin-0                  3/3     Running   0          3d23h   10.128.2.3     ip-10-0-128-218.us-west-1.compute.internal   <none>           <none>
robin-9hzmp                              1/1     Running   0          3d23h   10.0.220.43    ip-10-0-220-43.us-west-1.compute.internal    <none>           <none>
robin-operator-6944cb8c5-g8q7d           1/1     Running   0          3d23h   10.128.2.10    ip-10-0-128-218.us-west-1.compute.internal   <none>           <none>
robin-vwf96                              1/1     Running   0          3d23h   10.0.167.211   ip-10-0-167-211.us-west-1.compute.internal   <none>           <none>
robin-xx7rz                              1/1     Running   0          3d23h   10.0.128.218   ip-10-0-128-218.us-west-1.compute.internal   <none>           <none>

Run the below command to verify if Robin is successfully installed. For successful installs, the value of the Phase field within the status section of the output should be Ready.

$ oc describe robincluster -n robinio

Status:
  connect_command:   kubectl exec -it robin-vwf96 -n robinio -- bash
  get_robin_client:  curl -k 'https://10.0.167.211:29442/api/v3/robin_server/download?file=robincli&os=linux' > robin
  master_ip:         10.0.167.211
  Phase:             Ready
  pod_status:
    robin-9hzmp  ip-10-0-220-43.us-west-1.compute.internal  Running 10.0.220.43 false
    robin-vwf96  ip-10-0-167-211.us-west-1.compute.internal  Running 10.0.167.211 false
    robin-xx7rz  ip-10-0-128-218.us-west-1.compute.internal  Running 10.0.128.218 false
  robin_node_status:
    host_name:      ip-10-0-167-211.us-west-1.compute.internal
    join_time:      1600973314
    k8s_node_name:  ip-10-0-167-211.us-west-1.compute.internal
    Roles:          M*,S
    Rpool:          default
    State:          ONLINE
    Status:         Ready
    host_name:      ip-10-0-220-43.us-west-1.compute.internal
    join_time:      1600973337
    k8s_node_name:  ip-10-0-220-43.us-west-1.compute.internal
    Roles:          S,M
    Rpool:          default
    State:          ONLINE
    Status:         Ready
    host_name:      ip-10-0-128-218.us-west-1.compute.internal
    join_time:      1600973339
    k8s_node_name:  ip-10-0-128-218.us-west-1.compute.internal
    Roles:          M,S
    Rpool:          default
    State:          ONLINE
    Status:         Ready
Events:             <none>

You can then use the connect_command from the status section to connect to the Robin master pod.
```
$ kubectl exec -it robin-vwf96 -n robinio -- bash
```

Once you are inside the Robin Pod, run the below command to login to Robin CLI.

$ robin login admin
Password:
User admin is logged into Administrators tenant

*****
***** Your ROBIN License is NOT ACTIVATED...
***** Please register at https://get.robin.io/activate
***** to activate your license and access all ROBIN features.
*****

In order to activate your license via the CLI, first register by visiting https://get.robin.io/activate and retrieve your User ID. Next run the following command to activate your licese.
```
$ robin license activate XXXXXXXX
```

Run the below command to see all the nodes on which Robin CNS has been installed. Each node should be marked as ONLINE and Ready.

$ robin host list
Id           | Hostname                                   | Version   | Status | RPool   | LastOpr | Roles | Isol Cores(SHR/DED/Total) | Non-Isol Cores | GPUs | Mem(Free/Alloc/Total) | HDD(#/Alloc/Total) | SSD(#/Alloc/Total) | Pod Usage | Joined Time
-------------+--------------------------------------------+-----------+--------+---------+---------+-------+---------------------------+----------------+------+-----------------------+--------------------+--------------------+-----------+----------------------
1600973281:1 | ip-10-0-167-211.us-west-1.compute.internal | 5.3.2-483 | Ready  | default | ONLINE  | M*,S  | 0/0/0                     | 2/20           | 0/0  | 2G/5G/7G              | -/-/-              | 2/-/400G           | 18/250    | 24 Sep 2020 18:48:34
1600973281:2 | ip-10-0-220-43.us-west-1.compute.internal  | 5.3.2-483 | Ready  | default | ONLINE  | S,M   | 0/0/0                     | 2/20           | 0/0  | 0.22G/7G/7G           | -/-/-              | 2/-/400G           | 28/250    | 24 Sep 2020 18:48:57
1600973281:3 | ip-10-0-128-218.us-west-1.compute.internal | 5.3.2-483 | Ready  | default | ONLINE  | M,S   | 0/0/0                     | 3/20           | 0/0  | 1G/6G/7G              | -/-/-              | 2/-/400G           | 19/250    | 24 Sep 2020 18:48:59

That’s it! This concludes the Robin install on Openshift.

Note

Please see the install options detailed below and edit the custom resource section of yaml file appropriately to adjust your deployment.

2.3. Install on Openshift for IBM Cloud Pak for Data¶

Robin supports integrating IBM Cloud Pak for Data for storage provision. You can use Robin CNS with IBM Cloud Pak for Data version 4.0.

When installing IBM Cloud Pak for Data, you need to install Robin CNS on the Red Hat Openshift platform.

After you install Red Hat Openshift on any supported cloud platform or on-premises, you need to install and configure Robin CNS on it for IBM Cloud Pak for Data to use Robin CNS for storage.

When installing IBM Cloud Pak for Data, you must select custom storage and notify Coloud Pak for Data to use Robin StorageClass. Similarly, when you want to install any application on IBM Cloud Pak for Data and use Robin CNS for storage, you must select custom storage and use the Robin StorageClass.

Procedure

The following are the high-level tasks you should perform for integrating Robin CNS with IBM Cloud Pak for Data.

Note

These high-level tasks include links to the IBM Cloud Pak for Data and Robin CNS documentation.

Install Red Hat Openshift on any supported cloud platform or on-premises. For more information, see Pre-installation tasks - IBM Documentation.
Install Robin CNS on Red Hat Openshift. For more information, see Install on OpenShift.
Verify Robin CNS installation. For more information, see Verify Robin CNS installation on Openshift.
Complete the IBM Cloud Pak for Data pre-installation procedures from Step 3 of IBM Cloud Pak for Data documentation. For more information about pre-installation procedures, see Pre-installation tasks - IBM Documentation.
Create Robin StorageClass. For more information, see Create Robin StorageClass.
As part of IBM Cloud Pak for Data installation, you need to provide storage as a custom StorageClass resource and provide robin-storage-class for the storageClass attribute in the Ibmcpd config file. An example can be found below. For more information and detailed installation steps, see Installing Cloud Pak for Data - IBM Documentation.

Example

apiVersion: cpd.ibm.com/v1
kind: Ibmcpd
metadata:
   name: ibmcpd-cr                                  # This is the recommended name, but you can change it
   namespace: cpd-instance                          # Replace with the project where you will install Cloud Pak for Data
spec:
license:
   accept: true
   license: Enterprise | Standard                   # Specify the Cloud Pak for Data license you purchased
storageClass: robin-storage-class                   # Replace with the Robin RWX
zenCoreMetadbStorageClass: RWO-storage-class        # Replace with the name of a RWO storage class that points to block storage

2.3.1. Create Robin StorageClass¶

To use Robin CNS for storage for your IBM Cloud Pak for Data, you must create a Robin StorageClass on your Openshift Cluster. Detailed below is a sample definition file for a StorageClass with Robin as the provisioner.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
   name: robin-storage-class
   labels:
      app.kubernetes.io/instance: robin
      app.kubernetes.io/managed-by: robin.io
      app.kubernetes.io/name: robin
provisioner: robin
reclaimPolicy: Delete
allowVolumeExpansion: true
volumeBindingMode: Immediate
parameters:
   runAsAny: "true"

Note

The StorageClass above can be further customized by specifiying any of the parameters described here.

2.3.2. Use Robin StorageClass for Applications on IBM Cloud Pak for Data¶

Robin CNS can be used as the storage provider for applications on IBM Cloud Pak for Data. In order to do so, you must select custom storage and use the Robin StorageClass when installing any application on IBM Cloud Pak for Data.

For example, in order to install the Watson Studio application on IBM Cloud Pak and use Robin CNS as custom storage, the previously created Robin StorageClass must be specified using the storageClass attribute in the WS custom resource configuration file as shown below.

Example:

apiVersion: ws.cpd.ibm.com/v1beta1
kind: WS
metadata:
   name: ws-cr                        # This is the recommended name, but you can change it
   namespace: project-name            # Replace with the project where you will install Watson Studio
spec:
license:
   accept: true
   license: Enterprise | Standard     # Specify the license you purchased
version: 4.0.4
storageClass: robin-storage-class     # Use a Robin storageClass

Note

For more information and detailed instructions on how to install Watson Studio, see Installing the Watson Studio service - IBM Documentation.

2.4. Install on Google GKE¶

GKE is a managed Kubernetes offering from Google that runs in the Google Cloud Platform. Robin Cloud Native Storage is available as a marketplace offering to bring enterprise grade Storage and Data Management capabilities to run Stateful applications on GKE. You can also download Robin CNS software and install using the shipped installation script or manually via the CLI. In this section we will cover all these options.

2.4.1. Prerequisites¶

The ports detailed here need to be accessible for the installation to succeed and for Robin to operate correctly.
Ensure the user installing Robin CNS is the Cluster Administrator within the Kubernetes cluster. For GKE installations, run following commands to add a user as a Cluster Administrator:
```
$ account=$(gcloud info | grep Account  | awk -F'[\\[\\]]' '{print $2}')

$ kubectl create clusterrolebinding robin-cluster-admin-binding --clusterrole=cluster-admin --user=$account
```
Note

For GKE installations, Robin needs nodes with Ubuntu image and cluster with Compute Engine: Read Write and Storage: Full API being enabled. Compute Engine API access is required to make sure disks are always accessible and easy way to provision disks within ROBIN. Storage API access is required for backing up applications in GCS. You can select the Access scope as one of the following while creating GKE cluster.
- Set access for each API and select individual permissions
- Allow full access to all Cloud APIs

2.4.2. Install via Google Marketplace¶

Visit the marketplace
Search for robin cloud native storage as shown below
Select Robin Cloud Native Storage
Click on Configure
In the configuration page, select an existing GKE cluster or create a new cluster to deploy Robin CNS, Fill out each option appropriately and type ‘YES’ for Cluster requirements and click Deploy
You will then be taken to the Application details page. You should see a similar output. Wait until all the components turn to OK or Running status.
This concludes the install. Continue to the installation verification section and set up the product

2.4.3. Install using Robin Installer¶

Follow the steps below to download and install Robin CNS for GKE. Please proceed to Step 4 if you already have the installer downloaded.

Visit the following link and register an account.
From the Downloads page click Download and Install on the Deploy on Google GKE/Anthos tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=gke" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh --cluster-name=mg-cluster --zone-name=us-central1 -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

This concludes the install. Continue here to verify the installation and set up the product.

2.4.4. Install via CLI¶

Follow the steps below to manually install Robin CNS for GKE using CLI commands.

Clone the robin-storage repository using the command shown below:

$  git clone https://github.com/RobinSystems/robin-storage-gke-marketplace.git
Cloning into 'robin-storage-gke-marketplace'...
remote: Enumerating objects: 142, done.
remote: Counting objects: 100% (12/12), done.
remote: Compressing objects: 100% (11/11), done.
remote: Total 142 (delta 2), reused 9 (delta 1), pack-reused 130
Receiving objects: 100% (142/142), 84.59 KiB | 0 bytes/s, done.
Resolving deltas: 100% (64/64), done.

Move into the newly created directory, such that it is now your current working directory, and create the application CRD within the Anthos cluster if it is not already available with the following command:
```
$ cd robin-storage-gke-marketplace/
$ kubectl apply -f app-crd.yaml
customresourcedefinition.apiextensions.k8s.io/applications.app.k8s.io configured
```

Create the robinio namespace if it is not present using the below command:

$ export NAMESPACE=robinio

$ kubectl create ns ${NAMESPACE}
namespace/robinio created

Visit the following link and download a license key from the Deploy via Command Line tab.
Once the license key is downloaded, run the below command to apply it.
```
$  kubectl apply -f license.yaml -n robinio
secret/robin-cns-license-335206 created

$ export REPORTING_SECRET="robin-cns-license-335206"
```
Note

The value for the REPORTING_SECRET environment variable should be the name of the Kubernetes secret created after the license YAML is applied.

Run the following commands in order to setup the appropriate variables, apply the necessary YAML files and install Robin:

$ export APP_INSTANCE_NAME=robin
$ export HOST_TYPE=gcp
$ export TAG=5.3.10
$ export IMAGE_ROBIN_OPERATOR="gcr.io/robinio-public/robin-storage/robin-operator:${TAG}"
$ export IMAGE_ROBIN="gcr.io/robinio-public/robin-storage:${TAG}"
$ export IMAGE_UBBAGENT="gcr.io/robinio-public/robin-storage/ubbagent:${TAG}"
$ export IMAGE_ROBIN_DEPLOYER="gcr.io/robinio-public/robin-storage/deployer:${TAG}"
$ export IMAGE_CRJOB="gcr.io/robinio-public/robin-storage/crjob:${TAG}"
$ export CLUSTER_REQUIREMENTS="yes"
$ export STORAGE_DISKS=""
$ export ROBINDS_DIR="/home/robinds"
$ export ROBINLOG_DIR="/home/robinds"
$ export ROBINCRASH_DIR="/home/robinds"
$ export UPDATE_COREDNS="0"
$ export DNS_SERVICE="kube-system/kube-dns"

$ awk 'FNR==1 {print "---"}{print}' sa.yaml.template | envsubst '$APP_INSTANCE_NAME $NAMESPACE $IMAGE_ROBIN_OPERATOR $IMAGE_ROBIN $SERVICE_ACCOUNT $IMAGE_PROVISIONER_V04 $IMAGE_PROVISIONER_V10 $REPORTING_SECRET $IMAGE_UBBAGENT $IMAGE_ROBIN_DEPLOYER $CLUSTER_REQUIREMENTS $STORAGE_DISKS $HOST_TYPE $IMAGE_CRJOB $UPDATE_COREDNS $DNS_SERVICE' > "sa_manifest.yaml"

$ kubectl apply -f "sa_manifest.yaml" --namespace "${NAMESPACE}"
serviceaccount/robin-deployer-sa created
clusterrole.rbac.authorization.k8s.io/robin:robinio:deployer-cr0 created
clusterrolebinding.rbac.authorization.k8s.io/robin:robinio:deployer-crb0 created

$ export SERVICE_ACCOUNT="${APP_INSTANCE_NAME}-deployer-sa"

$ awk 'FNR==1 {print "---"}{print}' manifest/*   | envsubst '$APP_INSTANCE_NAME $NAMESPACE $IMAGE_ROBIN_OPERATOR $IMAGE_ROBIN $SERVICE_ACCOUNT $IMAGE_PROVISIONER_V04 $IMAGE_PROVISIONER_V10 $REPORTING_SECRET $IMAGE_UBBAGENT $IMAGE_ROBIN_DEPLOYER $CLUSTER_REQUIREMENTS $STORAGE_DISKS $HOST_TYPE $ROBINDS_DIR $ROBINLOG_DIR $ROBINCRASH_DIR $IMAGE_CRJOB $UPDATE_COREDNS $DNS_SERVICE' > "${APP_INSTANCE_NAME}_manifest.yaml"

$ kubectl apply -f "${APP_INSTANCE_NAME}_manifest.yaml" --namespace "${NAMESPACE}"
application.app.k8s.io/robin created
customresourcedefinition.apiextensions.k8s.io/robinclusters.manage.robin.io created
configmap/robin-cr created
deployment.apps/robin-operator created
job.batch/robin-cr created
deployment.apps/robin-monitor created

This concludes the install. Continue here to verify the installation and set up the product.

2.5. Install on Google Anthos¶

Anthos is a managed platform from Google that allows for the unification of multiple environments across on-premises, edge, and in multiple public clouds with a Google Cloud-backed control plane. Robin Cloud Native Storage is available as an offering to bring enterprise grade Storage and Data Management capabilities to run Stateful applications on Anthos. You can download Robin CNS software and install using a shipped installation script or install it manually via the CLI. In this section we will cover both.

2.5.1. Prerequisites¶

The ports detailed here need to be accessible for the installation to succeed and for Robin to operate correctly.
Ensure the user installing Robin CNS is the Cluster Administrator within the Kubernetes cluster. For Anthos installations, run following commands to add a user as a Cluster Administrator:
```
$ account=$(gcloud info | grep Account  | awk -F'[\\[\\]]' '{print $2}')

$ kubectl create clusterrolebinding robin-cluster-admin-binding --clusterrole=cluster-admin --user=$account
```

2.5.2. Install using Robin Installer¶

Follow the steps below to download and install Robin CNS for Google Anthos. Please proceed to Step 4 if you already have the installer downloaded.

Visit the following link and register an account.
From the Downloads page click Download and Install on the Deploy on Google GKE/Anthos tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=gke" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

This concludes the install. Continue here to verify the installation and set up the product.

2.5.3. Install via CLI¶

Follow the steps below to manually install Robin CNS for Google Anthos using CLI commands.

Clone the robin-storage repository using the command shown below:

$  git clone https://github.com/RobinSystems/robin-storage-gke-marketplace.git
Cloning into 'robin-storage-gke-marketplace'...
remote: Enumerating objects: 142, done.
remote: Counting objects: 100% (12/12), done.
remote: Compressing objects: 100% (11/11), done.
remote: Total 142 (delta 2), reused 9 (delta 1), pack-reused 130
Receiving objects: 100% (142/142), 84.59 KiB | 0 bytes/s, done.
Resolving deltas: 100% (64/64), done.

Move into the newly created directory, such that it is now your current working directory, and create the application CRD within the Anthos cluster if it is not already available with the following command:
```
$ cd robin-storage-gke-marketplace/
$ kubectl apply -f app-crd.yaml
customresourcedefinition.apiextensions.k8s.io/applications.app.k8s.io configured
```

Create the robinio namespace if it is not present using the below command:

$ export NAMESPACE=robinio

$ kubectl create ns ${NAMESPACE}
namespace/robinio created

Visit the following link and download a license key from the Deploy via Command Line tab.
Once the license key is downloaded, run the below command to apply it.
```
$  kubectl apply -f license.yaml -n robinio
secret/robin-cns-license-335206 created

$ export REPORTING_SECRET="robin-cns-license-335206"
```
Note

The value for the REPORTING_SECRET environment variable should be the name of the Kubernetes secret created after the license YAML is applied.

Run the following commands in order to setup the appropriate variables, apply the necessary YAML files and install Robin:

$ export APP_INSTANCE_NAME=robin
$ export HOST_TYPE=physical
$ export TAG=5.3.10
$ export IMAGE_ROBIN_OPERATOR="gcr.io/robinio-public/robin-storage/robin-operator:${TAG}"
$ export IMAGE_ROBIN="gcr.io/robinio-public/robin-storage:${TAG}"
$ export IMAGE_UBBAGENT="gcr.io/robinio-public/robin-storage/ubbagent:${TAG}"
$ export IMAGE_ROBIN_DEPLOYER="gcr.io/robinio-public/robin-storage/deployer:${TAG}"
$ export IMAGE_CRJOB="gcr.io/robinio-public/robin-storage/crjob:${TAG}"
$ export CLUSTER_REQUIREMENTS="yes"
$ export STORAGE_DISKS=""
$ export ROBINDS_DIR="/home/robinds"
$ export ROBINLOG_DIR="/home/robinds"
$ export ROBINCRASH_DIR="/home/robinds"
$ export UPDATE_COREDNS="0"
$ export DNS_SERVICE="kube-system/kube-dns"

$ awk 'FNR==1 {print "---"}{print}' sa.yaml.template | envsubst '$APP_INSTANCE_NAME $NAMESPACE $IMAGE_ROBIN_OPERATOR $IMAGE_ROBIN $SERVICE_ACCOUNT $IMAGE_PROVISIONER_V04 $IMAGE_PROVISIONER_V10 $REPORTING_SECRET $IMAGE_UBBAGENT $IMAGE_ROBIN_DEPLOYER $CLUSTER_REQUIREMENTS $STORAGE_DISKS $HOST_TYPE $IMAGE_CRJOB $UPDATE_COREDNS $DNS_SERVICE' > "sa_manifest.yaml"

$ kubectl apply -f "sa_manifest.yaml" --namespace "${NAMESPACE}"
serviceaccount/robin-deployer-sa created
clusterrole.rbac.authorization.k8s.io/robin:robinio:deployer-cr0 created
clusterrolebinding.rbac.authorization.k8s.io/robin:robinio:deployer-crb0 created

$ export SERVICE_ACCOUNT="${APP_INSTANCE_NAME}-deployer-sa"

$ awk 'FNR==1 {print "---"}{print}' manifest/*   | envsubst '$APP_INSTANCE_NAME $NAMESPACE $IMAGE_ROBIN_OPERATOR $IMAGE_ROBIN $SERVICE_ACCOUNT $IMAGE_PROVISIONER_V04 $IMAGE_PROVISIONER_V10 $REPORTING_SECRET $IMAGE_UBBAGENT $IMAGE_ROBIN_DEPLOYER $CLUSTER_REQUIREMENTS $STORAGE_DISKS $HOST_TYPE $ROBINDS_DIR $ROBINLOG_DIR $ROBINCRASH_DIR $IMAGE_CRJOB $UPDATE_COREDNS $DNS_SERVICE' > "${APP_INSTANCE_NAME}_manifest.yaml"

$ kubectl apply -f "${APP_INSTANCE_NAME}_manifest.yaml" --namespace "${NAMESPACE}"
application.app.k8s.io/robin created
customresourcedefinition.apiextensions.k8s.io/robinclusters.manage.robin.io created
configmap/robin-cr created
deployment.apps/robin-operator created
job.batch/robin-cr created
deployment.apps/robin-monitor created

This concludes the install. Continue here to verify the installation and set up the product.

2.6. Install on AKS¶

2.6.1. Prerequisites¶

The following pre-requisites must be met to install Robin CNS on AKS.

The ports detailed here need to be accessible for the installation to succeed and for Robin to operate correctly.
VM scale sets should be disabled on cluster.
Node should have the following operating system installed: Ubuntu (Kernel Version: 4.15.0-1096-azure).

2.6.2. Install using Robin Installer¶

Follow the steps below to download and install Robin CNS for AKS. Please proceed to Step 4 if you already have the installer downloaded.

Visit the following link and register an account.
From the Downloads page click Download and Install on the AKS tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=aks" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh --app-id=XXXXXXXXXXXXXXXXXX --tenant-id=XXXXXXXXXXXXXXXXXXXX --secret-key=XXXXXXXXXXXXXXX -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

This concludes the install. Continue here to verify the installation and set up the product.

2.7. Install on EKS¶

2.7.1. Prerequisites¶

The following pre-requisites must be met to install Robin CNS on EKS.

The ports detailed here need to be accessible for the installation to succeed and for Robin to operate correctly.
Nodes should have the following operating systems installed: Ubuntu (Kernel Version: 5.4.0-1024-aws or 5.4.0-1028-aws). The AMI Family to use for this OS is Ubuntu1804.

2.7.2. Install using Robin Installer¶

Follow the steps below to download and install Robin CNS for EKS. Please proceed to Step 4 if you already have the installer downloaded.

Visit the following link and register an account.
From the Downloads page click Download and Install on the EKS tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=eks" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh --secret-key=XXXXXXXXXXXXXXXXXXXXXXXXXXXX  --access-key=XXXXXXXXXXXXXXXXXXXXXXX -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

This concludes the install. Continue here to verify the installation and set up the product.

2.8. Install on RKE¶

2.8.1. Prerequisites¶

The following pre-requisites must be met to install Robin CNS on RKE.

The ports detailed here need to be accessible for the installation to succeed and for Robin to operate correctly.

The kube-controller pod must be present in order to sign certificates. To achieve this add a kube-controller entry within the services section of the Rancher configuration file as shown below.

   services:
     etcd:
       backup_config:
         enabled: true
         interval_hours: 12
         retention: 6
       creation: "12h"
       extra_args:
         election-timeout: "5000"
         heartbeat-interval: "500"
       retention: "72h"
       snapshot: false
     kube-api:
       always_pull_images: false
       pod_security_policy: false
       service_node_port_range: "30000-32767"
     kube-controller:
       extra_args:
         cluster-signing-cert-file: "/etc/kubernetes/ssl/kube-ca.pem"
         cluster-signing-key-file: "/etc/kubernetes/ssl/kube-ca-key.pem"

2.8.2. Install using Robin Installer¶

Follow the steps below to download and install Robin CNS for EKS. Please proceed to Step 4 if you already have the installer downloaded.

Visit the following link and register an account.
From the Downloads page click Download and Install on the RKE tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=rke" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh -y
Validating Kubernetes cluster......Done

Confirm that ports 29442-29470 are open between kubernetes nodes
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites:
yes
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............secret/cloud-cred-secret created
Done
Setting up robin client............Done

Activate robin license............Required

       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

This concludes the install. Continue here to verify the installation and set up the product.

2.9. Install on IKS¶

2.9.1. Prerequisites¶

The following pre-requisites must be met to install Robin CNS on IKS.

The ports detailed here need to be accessible for the installation to succeed and for Robin to operate correctly.
Currently only the VPC-Gen2 infrastructure type is supported.

2.9.2. Install using Robin Installer¶

Follow the steps below to download and install Robin CNS for IKS. Please proceed to Step 4 if you already have the installer downloaded.

Visit the following link and register an account.
From the Downloads page click Download and Install on the IKS tab.
Copy either the wget or curl command and run it on your command line to download the installation tarfile. An example is shown below:
```
$ wget "http://get.robin.io/download/storage?id=<USERID>&type=iks" -O robin-install.tar
```
Once the file is downloaded, run the below command to untar the contents into a new directory.
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd robin
$ ./install-robin.sh --version=5.3.4-75
Validating Kubernetes cluster......Done
Make sure the cluster meets prerequisites mentioned at https://docs.robin.io/storage/latest/install.html#prerequisites
Type yes to confirm that cluster meets the prerequisites: yes
Enter IBM api key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............Done
Setting up robin client............Done

Activate robin license............Required

./install-robin.sh: line 458: ./robin: No such file or directory
       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

This concludes the install. Continue here to verify the installation and set up the product.

2.10. Install on an Air-Gapped Cluster¶

An air-gapped Kubernetes cluster is a cluster that is behind a firewall without access to the Internet. You can install Robin in an air-gapped cluster by following the instructions provided in this topic.

2.10.1. Prerequisites¶

A driver node with Docker and the kubectl client installed.
The aforementioned driver node should also have access to the Internet for downloading the following: container images required to install Robin, Robin installation script, and Robin deployment YAML files.
A Kubernetes or OpenShift cluster already deployed on your choice of infrastructure.
A container registry with sufficient space for the Robin image and other images.

Note

Other prerequisites that are applicable for non-air-gapped installation apply to the air-gapped installation as well. For details, see: Prerequisites.

2.10.2. Installation Steps¶

From your driver, access Docker Hub and download the following:
- Robin Image
- Robin Operator
Run this command to download the Robin image:
$ docker pull robinsys/robinimg:<version number>
Example:
$ docker pull robinsys/robinimg:5.3.4-75
Run this command to download the Robin Operator:
$ docker pull robinsys/robin-operator<version number>
Example:
$ docker pull robinsys/robin-operator:5.3.4-310
Access quay and download the following CSI files:
- quay.io/k8scsi/snapshot-controller:v3.0.2
- quay.io/k8scsi/csi-resizer:v1.0.1
- quay.io/k8scsi/csi-snapshotter:v2.1.0
- quay.io/k8scsi/csi-provisioner:v1.6.0
- quay.io/k8scsi/csi-attacher:v2.1.0
- quay.io/k8scsi/csi-node-driver-registrar:v1.2.0
- quay.io/k8scsi/livenessprobe:v2.2.0

Run the following command to pull each of the CSI files.

$ docker pull <container image path>
Example:
$ docker pull quay.io/k8scsi/snapshot-controller:v3.0.2
Note

You must pull all the CSI files listed.

From the driver node with Docker and kubectl installed, push the Robin image and all CSI files into your container registry as shown below:

In order to push the relevant images run the following command:
```
$ docker push <path>
```
Example:
```
$ docker push artifactory.robinsystems.com/docker/robinsys/robinimg:5.3.4-75
$ docker push artifactory.robinsystems.com/docker/quay.io/k8scsi/csi-attacher:v2.1.0
```
Note

The Kubernetes cluster you plan to deploy on must have access to your cloud container registry to which you push the Robin images and CSI files.

After the images are pushed to the image registry, it will look like the following:
```
$ artifactory.robinsystems.com/robin-5-3-4/robinsys/robinimg:5.3.4-75
$ artifactory.robinsystems.com/robin-5-3-4/robinsys/robin-operator:5.3.4-75
$ artifactory.robinsystems.com/robin-5-3-4/quay.io/k8scsi/snapshot-controller:v3.0.2
```
Note

In the example above the registry is at artifactory.robinsystems.com
Access one of your generic Kubernetes nodes that has access to your Container Registry and create the robinio namespace as shown below:

In order to create the aforementioned namespace, run the following command:
```
$ kubectl create ns robinio
```
Note

A namespace with the name robinio exactly must be created
(Optional) If your cloud registry needs login credentials to access, then a secret needs to be created in the robinio namespace as shown below:

Run the following command to create a secret:
```
$ kubectl create secret docker-registry regcred --docker-server=artifactory.robinsystems.com --docker-username=<username> --docker-password=<password> -n robinio --docker-email=a@a.com
```
Note

The steps to create secret might differ depending on the cloud platform that is being utilized
(Optional) If you have a secret that needs to be used to access the cloud registry in which all the necessary images are stored, copy it to the robinio namespace as shown below:

Run the following commands to copy and pull the secret into the namespace:
```
$ kubectl get secret <secret_name_of_the_registry>  --export -o yaml > <filename>

$ kubectl create -f <filename> -n robinio
```
Example:
```
$ kubectl get secret all-icr-io --export -o yaml >all-icr-io.yaml

$ kubectl create -f all-icr-io.yaml -n robinio
```
From the driver node with kubectl installed, access get.robin.io and follow the on-screen instructions to download the robin-install.tar file for the desired Robin version. Ensure the tar file is downloaded onto your driver node.
Make a new directory on a node within your Kubernetes cluster and extract the contents of the tar into via the following command:
```
$ mkdir -p ./robin && tar -xf robin-install.tar -C ./robin
```

Move into the newly created directory, such that it is now your current working directory, and install Robin via the following commands:

$ cd <directory>
$ ./install-robin.sh --image-registry-path=us.icr.io/robin-5-3-4 -y --version=5.3.4-75 --image-pull-secret=<secret name>

Example:

$ cd robin
$ ./install-robin.sh --version=5.3.4-75
Validating Kubernetes cluster......Done
Validating kubernetes cluster permissions......Done
Validating robin cluster yaml......Done
Installing Robin operator...........Done
Installing Robin cluster............Done
Setting up robin client............Done

Activate robin license............Required

./install-robin.sh: line 458: ./robin: No such file or directory
       $ robin license activate <USERID>

       Note: You can get your User ID after registering on https://get.robin.io. Above command will only work if the host on which the
             ROBIN client is running on has an internet connection. If this is not the case please retrieve the license key by using the
             below link and apply it using the command 'robin license apply <key>'.

             https://get.robin.io/activate?clusterid=

      For logging into robin cluster,
      Default username: admin
      Default password: Robin123

2.10.3. Verify Robin Installation on an air-gapped cluster¶

Check if the pods created in the robinio namespace are in a running state by issuing the following command:

2.10.4. Verify Robin Cluster Status and State¶

You can verify the Robin cluster state and status by referring to the robincluster CRD. After a successful installation, the state and status of each node within the cluster should be ONLINE and Ready respectively.

Run the following command to verify Robin cluster status:

$ root@vpc-secure-bastion-vsi:~# kubectl describe robincluster -n robinio

Name:         robin
Namespace:    robinio
Labels:       app.kubernetes.io/instance=robin
              app.kubernetes.io/managed-by=robin.io
              app.kubernetes.io/name=robin
Annotations:  API Version:  manage.robin.io/v1
Kind:         RobinCluster
Metadata:
   Creation Timestamp:  2021-02-04T09:41:06Z
   Generation:          1
Resource Version:  378697
Self Link:         /apis/manage.robin.io/v1/namespaces/robinio/robinclusters/robin
UID:               7533d2da-8521-47e2-bb52-426df5a07a2b
Spec:
 host_type:            ibm
 image_pull_secret:    all-icr-io
 image_registry_path:  uk.icr.io/docker_registry/docker
 image_robin:          robinsys/robinimg:5.3.4-75
 k8s_provider:         iks
Options:
 cloud_cred_secret:  cloud-cred-secret
 update_coredns:     1
Status:
 connect_command:   kubectl exec -it robin-nfbxx -n robinio -- bash
 get_robin_client:  curl -k https://10.242.64.22:29442/api/v3/robin_server/download?file=robincli&os=linux > robin
 master_ip:         10.242.64.22
 Phase:             Ready
 pod_status:
  robin-nfbxx  10.242.64.22  Running  10.242.64.22
  robin-drdzx  10.242.64.21  Running  10.242.64.21
  robin-57w8h  10.242.64.20  Running  10.242.64.20
robin_node_status:
 host_name:      kube-c0d69ael0c0ce2a8b6b0-asitclus-default-00000b25
  join_time:      1612431722
  k8s_node_name:  10.242.64.22
  Roles:          M*,S
  Rpool:          default
  State:          ONLINE
  Status:         Ready
 host_name:      kube-c0d69ael0c0ce2a8b6b0-asitclus-default-00000a68
  join_time:      1612431745
  k8s_node_name:  10.242.64.20
  Roles:          S,M
  Rpool:          default
  State:          ONLINE
  Status:         Ready
 host_name:      kube-c0d69ael0c0ce2a8b6b0-asitclus-default-00000c21
  join_time:      1612431760
  k8s_node_name:  10.242.64.21
  Roles:          S,M
  Rpool:          default
  State:          ONLINE
  Status:         Ready
  Events:         <none>

2.11. Install Options¶

Shown below is a Robin CNS deployment YAML file wherein which all the configurable options are present.

apiVersion: manage.robin.io/v1
kind: RobinCluster
metadata:
  name: robin
  namespace: robinio
spec:
  image_version: <docker-image-name-version>
  k8s_provider: gke|openshift|eks|aks|pks|rke|robin|opensource
  host_type: gcp|physical|aws|azure
  node_selector: <node selector>
  source: <operatorhub|gcpmarketplace>
  # kms: robin/google
  # kms_keyring: <keyring_name>
  # options:
  #   cloud_cred_secret: aws-secret
  #   requests:
  #     cpu: "2"
  #     memory: "2Gi"
  #   limits:
  #     cpu: "2"
  #     memory: "2Gi"

Each option shown above is described below alongside whether or not they must to be present in the YAML file.

`image_version`	Required	Image name/version in your docker registry
`k8s_provider`	Required	Kubernetes Distribution name. The following values are supported: `gke` (Google Kubernetes Engine), `openshift` (Redhat Openshift), `eks` (Amazon Elastic Kubernetes Engine), `aks` (Azure Kubernetes Service), `pks` (Pivotal Container Service), `rke` (Rancher Kubernetes Engine)
`host_type`	Required	The type of host on which the Kubernetes distribution is running. The following values are supported: `gcp` (Google Compute Engine instances), `physical` (Private on-prem datacenter), `aws` (EC2 instances), `azure` (Azure Virtual Machines)
`node_selector`	Optional	Specify a selector to pick the nodes on which Robin CNS should be installed. For OpenShift v3 specify “node-role.kubernetes.io/compute=true” or for OpenShift v4 specify “node-role.kubernetes.io/master=’’”
`kms`	Optional	If external key management needs to be provided. Valid values include: `robin`, `google`
`kms_keyring`	Optional	Keyring name if google KMS is selected
`source`	Optional	Source of deployment yaml. Only specify this value if Robin CNS is deployed through one of the following portals: `operatorhub` or `gcpmarketplace`
`cloud_cred_secret`	Required	Name of secret containing cloud specific credentials. This is required for Azure, optional for AWS if EC2 instances are configured with the necessary IAM roles and optional for GCP deployments.
`requests`	Optional	Request resource for robin pods
`limits`	Optional	Set resource limits for robin pods

2.12. Verify Installation¶

Once the installation is complete, you can get details about robin cluster by running

$ kubectl describe robinclusters -n robinio

You should see the status of all the ROBIN Nodes as “Ready”.

Note

If you have deployed Robin in a different namespace, then specify it instead of robinio in the above command.

You can also see ROBIN storage class is added.

$ kubectl get sc

Use the “Connect Command” value from the above output to connect to ROBIN pod. For example,

$ kubectl exec -it robin-rnnnd -n robinio bash

After logging into ROBIN container you can login as “admin” user. Default password is ‘Robin123’

$ robin login admin

You can verify the installation by running

$ robin host list

2.13. ROBIN License Activation¶

After installing ROBIN software on any platform, a notice will appear stating that the ROBIN license will expire in approximately two days whenever a command is run. This is an indication that the license is yet to be activated. In order to avoid a cluster lockdown you can activate your ROBIN cluster via one of the following methods.

If the license is not activated your ROBIN cluster will be locked after the allocated time.

2.13.1. Web License Activation¶

Activate your ROBIN license by clicking here. After following the instructions detailed on the website your ROBIN license should be activated and your cluster ready to use.

Note

You will be asked to provide the Robin CNS cluster id when activating your license. This can be discovered by running the robin license id command via the client or when you are connected to the Robin pod. In addition you can apply the generated key via the command robin license apply <key>

2.13.2. CLI License Activation¶

In order to activate your license via the CLI, first register here and retrieve your User ID. Next run the following command:

$ robin license activate <USERID>

This will activate your ROBIN license and ensure your cluster is ready to use.

2.14. High Availability of ROBIN Services¶

Robin CNS manages High Availability of all management services that are deployed as part of Robin CNS installation. Robin CNS pods are deployed as part of a daemonset. Some pods are designated to run master services. Robin CNS configures 3 of these pods as manager pods which can host these master services.

If one of the kubernetes node goes down, ROBIN seamlessly starts master services on other manager pods.
If pod hosting ROBIN master services is removed from kuberenetes cluster, ROBIN will automatically designate another pod as manager pod so that it always has 3 master pods.

2.15. Uninstalling ROBIN¶

2.15.1. Deleting objects created via Kubernetes¶

2.15.1.1. Cleanup for automated installations¶

For uninstalling Robin CNS from Kubernetes cluster via kubectl, run the following commands:

$ kubectl delete -f robin.yaml
$ kubectl delete clusterrolebinding -l robin.io/domain=ROBIN
$ kubectl delete rolebinding -l robin.io/domain=ROBIN -A

Run the below command to get a list of namespaces created with Robin and delete the namespaces one by one. Please make sure you are not accidentally deleting namespaces that contain non-robin applications.

$ kubectl get ns -l robin.io/domain=ROBIN

After reviewing the list, if you want to delete all the namespaces at once, you can run

$ kubectl delete ns -l robin.io/domain=ROBIN

2.15.1.2. Cleanup for manual installations¶

Note

The below instructions for cleanup only apply to clusters where Robin was setup using the commands detailed here and NOT via the Robin installer.

In order to uninstall Robin CNS from a GKE Kubernetes cluster via kubectl, run the following commands:

$ export APP_INSTANCE_NAME=robin
$ export NAMESPACE=robinio

$ kubectl delete -f ${APP_INSTANCE_NAME}_manifest.yaml --namespace "${NAMESPACE}"
$ kubectl delete serviceaccount "${APP_INSTANCE_NAME}-deployer-sa" -n "${NAMESPACE}"
$ kubectl delete clusterrolebinding "$APP_INSTANCE_NAME:$NAMESPACE:deployer-crb0"
$ kubectl delete clusterrole "$APP_INSTANCE_NAME:$NAMESPACE:deployer-cr0"
$ kubectl delete application,deployment --namespace ${NAMESPACE} --selector app.kubernetes.io/name=$APP_INSTANCE_NAME
$ kubectl delete -f license.yaml -n ${NAMESPACE}
$ kubectl delete ns robinio

2.15.2. Deleting objects created by OLM¶

If the ROBIN operator was deployed on an OpenShift cluster via the OLM method described above, run the following command to delete all the objects created within the robinio namespace:

$ oc delete namespace robinio

Note

The commands starting with oc are applicable for the OpenShift environment.

2.15.3. Deleting objects created via the Robin installer¶

If the Robin CNS operator was deployed on an existing Kubernetes cluster via the Robin installer in the steps described previously, one can run the following command to uninstall:

$ ./install-robin.sh --uninstall
Uninstalling Robin cluster......Done
Some Robin managed namespaces (t001-u000001 t001-u000002 t001-u000003 ) are not deleted, please run following command to delete those after
making sure there are no required kubernetes objects present in these namespaces
"kubectl delete ns -l robin.io/domain=ROBIN"

Note

The install-robin.sh script is shipped within the downloadable tarfile.