Veeam + Kasten

 kubectl get pvc,pv,sc --all-namespaces
```bash

Nos indicará las solicitudes de discos pvc (PersistentVolumeClaim) para aplicaciones, volúmenes persistentes que son provistos por el sistema o dinámicos pv (PersistenVolume), y la clase de storage o almacenamiento se ofrece al cluster sc (Storage Classes).

```bash
kubectl get pod --all-namespaces
```bash

Nos indicara todos los pods que instala por defecto Tanzu al crear un cluster y sus respectivos namespaces, que nos permite identificar el proyecto que se instale en el cluster.

```bash
kubectl get node --all-namespaces
```text

Y por ultimo ver la cantidad de nodos que están involucrados en el cluster y su respectivo rol, como se puede observar en las imagen anterior es posible ver:

```text
kube-system   vsphere-csi-controller-8c9b98f7f-tt9p6                   5/5     Running   8          3h30m
kube-system   vsphere-csi-node-5k2fp                                   3/3     Running   0          3h17m
kube-system   vsphere-csi-node-5skv2                                   3/3     Running   3          3h11m
kube-system   vsphere-csi-node-g9dpn                                   3/3     Running   0          3h17m
kube-system   vsphere-csi-node-rptch                                   3/3     Running   3          3h30m
kube-system   vsphere-csi-node-vgn7s                                   3/3     Running   3          3h17m
kube-system   vsphere-csi-node-xg6mb                                   3/3     Running   3          3h17m

```bash

Lo que nos indica que ya se encuentra instalado el driver CSI de vSphere, CSI es el acrónimo de Container Storage Interface:

[https://github.com/kubernetes-sigs/vsphere-csi-driver](https://github.com/kubernetes-sigs/vsphere-csi-driver)

Este driver es la pieza esencial para la integración de Kubernetes con vSphere ya que permite crear discos para asignarlos a los volúmenes persistentes necesarios para las aplicaciones instaladas en el cluster de Tanzu Kubernetes Grid.

## Storage Class

Ahora una de las requerimientos de Kasten son discos persistentes y como vimos anteriormente, el cluster por defecto no posee ningún Storage Class habilitado, por tanto, la aplicación que instalemos no podrá crear los volúmenes que necesite para su funcionamiento, para ello debemos ejecutar en la maquina que esta administrando TKG:

```bash
echo "
 kind: StorageClass
 apiVersion: storage.k8s.io/v1
 metadata:
   name: 24xs-vol
   annotations:
     storageclass.kubernetes.io/is-default-class: \"true\"
 provisioner: csi.vsphere.vmware.com
 parameters:
   DatastoreURL: "ds:///vmfs/volumes/5b00a1aa-6b210381-9411-54e1ad1b3bcd/"
   fstype: ext4
 " > 24xs-vol.yaml
 kubectl create -f 24xs-vol.yaml
```bash

Donde en la linea **5** podemos asignar el nombre del Storage Class, en la linea **7** asegurarnos que el valor sea " **true**" ya que con esto nos aseguramos que quede por defecto configurado y habilitado, linea **8** nos aseguramos que es el driver csi de vsphere, en la linea **10** es clave para indicarle la url del Datastore que utilizaremos como destino de los volúmenes persistentes en vSphere (en la siguiente imagen veras de donde tomar el dato) y por ultimo el nombre del archivo para guardarlo con su extensión .yaml.



        
          
          
        
  
  
  



        
          
          
        
  
  
  

Como observamos en la imagen anterior el primer comando nos muestra que no tenemos ningún Storage Class en nuestro cluster de Tanzu y luego ejecutamos el archivo para generar el Storage Class que podemos ver con el comando:

```bash
kubectl get sc
```bash



        
          
          
        
  
  
  

Ahora, si revisamos el monitoreo del DataStore que seleccionamos para ser el almacenamiento de nuestros volúmenes persistentes, veremos lo siguiente en vCenter:



        
          
          
        
  
  
  

Por tanto ya tenemos todo listo para instalar Kasten k10 en su ultima versión 2.5.22.

## Instalación de Kasten

Ahora revisaremos los prerrequisitos de Kasten que los puedes encontrar:

[https://docs.kasten.io/latest/install/requirements.html](https://docs.kasten.io/latest/install/requirements.html)

Lo primero que necesita es instalar helm, que es una administrador de paquetes para instalar fácilmente aplicaciones:

[https://helm.sh/](https://helm.sh/)

La instalación de helm es muy sencilla solo debemos descargar el archivo desde github y moverlo a la carpeta de ejecutables del servidor que estas usando para administrar Tanzu Kubernetes Grid o TKG:

```bash
wget https://get.helm.sh/helm-v3.3.4-linux-amd64.tar.gz
```json



        
          
          
        
  
  
  

```bash
tar xvzf helm-v3.3.4-linux-amd64.tar.gz
```json



        
          
          
        
  
  
  

```text
cd linux-amd64/
```bash



        
          
          
        
  
  
  

Y por ultimo lo movemos a la carpeta de ejecutables:

```bash
mv helm /usr/local/bin/
```bash



        
          
          
        
  
  
  

si ejecutamos el comando helm versión veremos la versión de helm:



        
          
          
        
  
  
  

Como indica el manual de Kasten, lo que debemos realizar ahora es agregar el repositorio de Kasten en helm, con el siguiente comando:

```bash
helm repo add kasten https://charts.kasten.io/
```bash



        
          
          
        
  
  
  

Y luego crear el nombre del proyecto o namespace con el comando:

```bash
kubectl create namespace kasten-io
```bash



        
          
          
        
  
  
  

Luego procederemos a la instalación como se indica en:

[https://docs.kasten.io/latest/install/vmware/vsphere.html](https://docs.kasten.io/latest/install/vmware/vsphere.html)

El primer comando a ejecutar es:

```bash
helm install k10 kasten/k10 --namespace=kasten-io
```bash

Los cual nos mostrará:



        
          
          
        
  
  
  

Y luego con el siguiente comando podremos ver el progreso de instalación:

```bash
kubectl get pods --namespace kasten-io --watch
```bash

Y podremos ver:



        
          
          
        
  
  
  

Debemos asegurarnos que todos los pods se encuentren en estado " **Running**" ya que con esto luego podremos acceder a la consola de Kasten.

Si revisamos nuestro Datastore que anteriormente no almacenaba volúmenes persistentes y actualizamos podremos observar:



        
          
          
        
  
  
  



        
          
          
        
  
  
  

Nos listará los volúmenes usados por Kasten para su correcto funcionamiento. Y volvemos a asegurarnos que todos los pods estén en su estado "Running":



        
          
          
        
  
  
  

Y ya tenemos instalado Kasten!

## Acceder a Kasten

Como vimos en una imagen anterior, Kasten nos indico que para acceder al Dashboard necesitamos ingresar un comando:

```bash
kubectl --namespace kasten-io port-forward service/gateway 8080:8000
```text

Y luego ingresar a la url:

```text
http://127.0.0.1:8080/k10/#/.
```bash

Y obviamente si es que tienes instalado GUI o Desktop en tu linux de administración de Tanzu Kubernetes Grid podrás acceder. Pero que pasa si no tengo instalado GUI y necesito acceder desde la red via Web?

Existen distintas formas de acceder al Dashboard de Kasten, aquí veremos la mas simple y rápida con autenticación que inclusive también lo puedes encontrar en el manual de Kasten, de hecho revisaremos los siguientes links:

[https://docs.kasten.io/latest/access/dashboard.html#dashboard](https://docs.kasten.io/latest/access/dashboard.html#dashboard)

[https://docs.kasten.io/latest/access/authentication.html#basic-auth](https://docs.kasten.io/latest/access/authentication.html#basic-auth)

```bash
https://hostingcanada.org/htpasswd-generator/
```bash

El primer link nos dice las múltiples formas de ingresar al Dashboard, en este caso utilizaremos " **Accessing via a LoadBalancer**", para ello instalaremos "metallb" que es un balanceador para k8s:

[https://metallb.universe.tf/](https://metallb.universe.tf/)

La instalación es muy sencilla, debemos ejecutar el siguiente comando:

```bash
kubectl apply -f https://raw.githubusercontent.com/google/metallb/v0.8.3/manifests/metallb.yaml
```bash



        
          
          
        
  
  
  

Y ya está instalado. Ahora lo configuraremos con el rango de direcciones IP que deseamos que trabaje:

```bash
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: default
      protocol: layer2

      # MetalLB IP Pool
      addresses:
      - 20.20.20.110-20.20.20.140
EOF
```bash

En la linea **15**, debemos ingresar un pool de direcciones IP para que las asigne a los servicios que instalemos. Y ejecutamos:



        
          
          
        
  
  
  

Luego de esto volvemos a la configuración de Kasten, debemos generar una contraseña htpasswd, en los links anteriores aparece una web que nos permite realizarlo online:



        
          
          
        
  
  
  

Copiamos el usuario y contraseña y lo agregamos en el siguiente comando (Si copian y pegan la contraseña cifrada es 24xsiempre.com):

```bash
helm upgrade k10 kasten/k10 --namespace=kasten-io \
    --set auth.basicAuth.enabled=true \
    --set auth.basicAuth.htpasswd='admin:$apr1$8zsf2361$V3BlxNRZsfbnUmDFM.XRa1'
```bash

En la linea **3**, debes copiar tu usuario y password generado en la web. Luego ejecutamos:



        
          
          
        
  
  
  

Con el comando anterior solo configuramos el mecanismo de autenticación, ahora con la siguiente instrucción le indicaremos que nos permita acceder a través del gateway de Kasten y el balanceador:

```bash
helm upgrade k10 kasten/k10 --namespace=kasten-io \
    --reuse-values \
    --set externalGateway.create=true
```bash



        
          
          
        
  
  
  

Vimos que el mensaje cambió y Kasten ahora nos indico que debemos acceder al Dashboard vía:

```bash
The K10 Dashboard is accessible via a LoadBalancer. Find the service's EXTERNAL IP using:
  `kubectl get svc gateway-ext --namespace kasten-io -o wide`
And use it in following URL
 `http://SERVICE_EXTERNAL_IP/k10/#/`
```bash

Por tanto, solo nos queda saber la dirección IP para acceder, la cual la obtendremos con el siguiente comando:

```bash
kubectl get svc gateway-ext --namespace kasten-io -o wide