# Instalando un clúster OKD en un solo nodo.
La fuente la he obtenido de [aquí](https://andrearaponi.it/devops/deploy-okd-on-proxmox/).

## Contenido
- [Prerequisitos](#prerequisitos)
- [Fase 1: Preparativos en la máquina de administración](#fase-1-preparativos-en-la-máquina-de-administración)
    - [Variables de entorno](#variables-de-entorno)
    - [Descargar el cliente de OpenShift (```oc```)](#descargar-el-cliente-de-openshift-oc)
    - [ Descargar el instalador de OpenShift (```openshift-install```)](#descargar-el-cliente-de-openshift-oc)
    - [Obtener la Live ISO de Fedora CoreOS (FCOS)](#obtener-la-live-iso-de-fedora-coreos-fcos)
    - [Preparar el fichero ```install-config.yaml```](#preparar-el-fichero-install-configyaml)
    - [Generar la configuración de ignición del nodo único](#generar-la-configuración-de-ignición-del-nodo-único)
    - [Incrustar la ignición dentro del Live ISO de FCOS](#incrustar-la-ignición-dentro-del-live-iso-de-fcos)
- [Fase 2: Instalación de Fedora CoreOS](#fase-2-instalación-de-fedora-coreos)
    - [Instalar Fedora CoreOS](#instalar-fedora-coreos)
- [Fase 3. DNS y acceso al clúster](#fase-3-dns-y-acceso-al-clúster)
  - [Configuración DNS](#configuración-dns)
  - [Monitorizar la instalación desde la máquina de administración](#monitorizar-la-instalación-desde-la-máquina-de-administración)
  - [Acceso a través de la consola web](#acceso-a-través-de-la-consola-web)
- [Fase 4: Post-instalación - Configurar almacenamiento](#fase-4-post-instalación---configurar-almacenamiento)


---


## Prerequisitos.
Necesitamos una máquina donde instalar el clúster. Puede ser una máquina virtual en Proxmox VE o bien un servidor físico.

Además, hay que obtener un ```pull secret``` desde la página de [Redhat](https://console.redhat.com/openshift/install/pull-secret
)

## Fase 1: Preparativos en la máquina de administración
En esta fase, todos los comando son ejecutados en la **máquina cliente de administración**
### Variables de entorno
Hay que definir la versión y la arquitectura de nuestro clúster.
La versión de OKD la obtuve de [la página del proyecto en Github](https://github.com/okd-project/okd/releases?page=1). Descarté las versiones de *pre-release*. En el momento de escribir esto, la versión estable era la que pongo más abajo en la definición de las variables.

    export OKD_VERSION=4.19.0-okd-scos.9
    export ARCH=x86_64



### Descargar el cliente de OpenShift (```oc```)

    curl -L "https://github.com/okd-project/okd/releases/download/${OKD_VERSION}/openshift-client-linux-${OKD_VERSION}.tar.gz" -o oc.tar.gz
    tar zxf oc.tar.gz
    chmod +x oc kubectl # kubectl is also included
    sudo mv oc kubectl /usr/local/bin/ # Optional: Move to PATH for global access
    oc version

### Descargar el instalador de OpenShift (```openshift-install```)
    curl -L "https://github.com/okd-project/okd/releases/download/${OKD_VERSION}/openshift-install-linux-${OKD_VERSION}.tar.gz" -o openshift-install-linux.tar.gz
    tar zxvf openshift-install-linux.tar.gz
    chmod +x openshift-install
    sudo mv openshift-install /usr/local/bin/ # Optional: Move to PATH
    openshift-install version

### Obtener la Live ISO de Fedora CoreOS (FCOS)
El instalador determinará la url correcta de la ISO de FCOS que concuerde con la versión de OKD.

    export ISO_URL=$(openshift-install coreos print-stream-json | grep location | grep "${ARCH}" | grep iso | cut -d\" -f4)
    echo "Downloading FCOS ISO from: ${ISO_URL}"
    curl -L "${ISO_URL}" -o fcos-live.iso

> Nota: Esta imagen es la que más tarde tendríamos que subir a Proxmox (en caso de VM) o grabar en un USB (para arranchar un ordenador físico)

### Preparar el fichero ```install-config.yaml```
Hay que crear un directorio para guardar los ficheros de instalación y el fichero ```install-config.yaml```.

    mkdir okd-sno-install
    cd okd-sno-install

Crear el fichero ```install-config.yaml``` con el siguiente contenido:

    apiVersion: v1
    baseDomain: reymota.lab # Your local base domain
    metadata:
      name: ocp-cluster    # Your cluster name
    compute:
    - name: worker
      replicas: 0     # Essential for SNO
    controlPlane:
      name: master
      replicas: 1     # Essential for SNO
    networking:
      networkType: OVNKubernetes
      clusterNetwork:
      - cidr: 10.128.0.0/14
        hostPrefix: 23
      machineNetwork:
      - cidr: 192.168.1.0/24 # Your Proxmox VM/máquina física network subnet
      serviceNetwork:
      - 172.30.0.0/16
    platform:
      none: {} # For bare-metal/VM installations not managed by a cloud provider
    bootstrapInPlace:
      # IMPORTANT: Identify your Proxmox VM's target disk for installation.
      # This can be /dev/vda, /dev/sda, or a more stable WWN path.
      # Example for a VirtIO disk, often /dev/vda:
      installationDisk: /dev/vda
      # Example using WWN (more robust, get this from Proxmox VM's disk details or from FCOS live env):
      # installationDisk: /dev/disk/by-id/wwn-0x64cd98f04fde100024684cf3034da5c2
    pullSecret: '<PASTE_YOUR_PULL_SECRET_JSON_HERE>' # Replace with your actual pull secret
    sshKey: |
    ssh-rsa AAAA...your_public_ssh_key_here # Replace with your public SSH key  

Notas importantes para el fichero ```install-config.yaml```:

- ```baseDomain``` y ```metadata.name```: Estos dos formarán en nombre del cluster (FQDN). Por ejemplo, ```api.ocp-cluster.reymotal.lab```.
- ```machineNetwork.cidr```: Tiene que coincidir con la subred donde está instala la máquina (VM o física)
- ```installationDisk```:
    - Para discos VirtIO de Proxmox, esto es normalmente ```/dev/vda```.
    - En el caso de mi ordenador, el disco es: ```/dev/nvme0n1```.
- ```pullSecret```: Pega la cadena completa JSON obtenida desde  [Redhat](https://console.redhat.com/openshift/install/pull-secret
).
- ```sshKey```: La clave pública para acceder al usuario ```core``` en el nodo FCOS.
### Generar la configuración de ignición del nodo único.
El comando siguiente usará el fichero ```install-config.yaml``` en el directorio actual (¡ojo! creo que luego lo borra por lo que conviene tener una copia)

    # Still in okd-sno-install directory
    openshift-install create single-node-ignition-config

Esto creará un fichero llamado ```bootstrap-in-place-for-live-iso.ign``` en el directorio actual.

### Incrustar la ignición dentro del Live ISO de FCOS.
Para esto, necesitamos ```coreos-installer```que se puede ejecutar con Podman.

    # Ensure you are in the directory containing fcos-live.iso and the bootstrap ignition file
    # (which should be okd-sno-install if you followed above)

    # If fcos-live.iso is in parent dir:
    # coreos-installer iso ignition embed -fi bootstrap-in-place-for-live-iso.ign ../fcos-live.iso
    # If fcos-live.iso is in current dir (okd-sno-install):
    # First, move fcos-live.iso into okd-sno-install or adjust paths. Let's assume it's in the parent.
    # Ensure fcos-live.iso is in the directory where you run this command or provide full path.
    # Let's assume fcos-live.iso is in the parent directory of okd-sno-install for this example.

    # If you downloaded fcos-live.iso to the okd-sno-install directory:
    podman run --privileged --pull always --rm \
    -v /dev:/dev -v /run/udev:/run/udev -v "$PWD":"$PWD" -w "$PWD" \
    quay.io/coreos/coreos-installer:release \
    iso ignition embed -fi bootstrap-in-place-for-live-iso.ign fcos-live.iso

Esto modifica ```fcos-live.iso``` en su sitio para incluir la configuración de ignición.
## Fase 2: Instalación de Fedora CoreOS
Si vamos ha instalar en una VM en Proxmox, esta tendrá que estar creada y el Live ISO tendrá que estar subido para poder arrancar la VM desde ahí.
Si hemos elegido una máquina física, hay que crear un usb de arranque con el contenido del Live ISO de FCOS. En el Mac, he usado [BalenaEtcher](https://etcher.balena.io).
### Instalar Fedora CoreOS.
Una vez creado el usb (o creada la VM con el live ISO de FCOS como cd-rom) hay que arrancar la máquina.
Dado que la configuración de ignición está incrustrada y ```bootstrapInPlace.installationDisk``` está activado, FCOS debería **automáticamente instalarse en el disco especificado** y luego rearrancar el equipo.
## Fase 3. DNS y acceso al clúster.
### Configuración DNS.
La máquina OKD necesita una dirección IP fija. Esto hay que hacerlo desde el servidor DHCP, reservando una IP para esta máquina usando la dirección MAC. No se incluyen aquí instrucciones de cómo hacerlo.

Respecto al servidor DNS, hay que añadir las siguientes entradas apuntando a la dirección física de la máquina.

- ```api.okd4sno.okd.lan```
- ```console-openshift-console.apps.okd4sno.okd.lan```
- ```oauth-openshift.apps.okd4sno.okd.lan```
- ```*.apps.okd4sno.okd.lan``` (If your DNS supports wildcard A records. If not, like OpenWRT UI, you’ll need to add entries for specific app routes as you create them, or use dnsmasq custom configs for wildcards).

>Alternativa en la máquina de administración si no tenemos un DNS centralizado: Añade los nombres de host anteriores al fichero ```/etc/hosts```
### Monitorizar la instalación desde la máquina de administración.
Una vez que la máquina OKD ha rearrancado y la ignición se ha completado, el proceso de arranque de OKD comenzará.
Se puede monitorizar con los siguientes comandos:

    # On your Admin Client Machine, in the okd-sno-install directory
    openshift-install wait-for bootstrap-complete --log-level=info
    # This can take 20-40 minutes.
    # Once bootstrap is complete:
    openshift-install wait-for install-complete --log-level=info
    # This can take another 30-60+ minutes.
### Acceso a través de la consola web.
Después de que ```install-complete``` termine:

- Navega a: ```https://console-openshift-console.apps.ocp-cluster.reymota.lab```
- Entra en sesión usando:
  - Nombre de usuario: ```kubeadmin```
  - Contraseña: La puedes encontrar en el fichero ```okd-sno-install//kubeadmin-password``` en la máquina de administración.

## Fase 4: Post-instalación - Configurar almacenamiento.
Yo he usado ```Longhorn```. He seguido las instrucciones de este [post](https://h00pz.co/2024/01/13/longhorn-storage-on-openshift/)

Para instalar Longhorn hay que seguir estas [instrucciones](https://longhorn.io/docs/archives/1.4.2/deploy/install/install-with-kubectl/)

Básicamente, se trata de ejecutar el siguiente comando:

    kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.4.2/deploy/longhorn.yaml


y monitorizar el proceso con:

    kubectl get pods --namespace longhorn-system --watch

Hay que fijar ciertos permisos:

    oc adm policy add-scc-to-user anyuid -z default -n longhorn-system
    oc adm policy add-scc-to-user privileged -z longhorn-service-account -n longhorn-system
    oc adm policy add-scc-to-user anyuid -z longhorn-ui-service-account -n longhorn-system

En el UI de OKD hay que ir a User Management->Roles y buscar el rol "longhorn-role". Hay que editarlo y buscar al ```apiGroup "longhorn.io"``` y añadir los recursos que se muestran:

    apiGroups:
      - longhorn.io
    resources:
      - engineimages/finalizers
      - instancemanagers/finalizers
      - sharemanagers/finalizers
      - backingimagemanagers/finalizer
      - nodes/finalizers

Por último, lo siguiente es crear una ruta para poder acceder a la consola de gestión:

    kind: Route
    apiVersion: route.openshift.io/v1
    metadata:
      name: longhorn
      namespace: longhorn-system
      labels:
        app: longhorn-ui
        app.kubernetes.io/instance: longhorn
        app.kubernetes.io/name: longhorn
        app.kubernetes.io/version: v1.4.2
    spec:
      host: longhorn.apps.loki.h00pz.co
      to:
        kind: Service
        name: longhorn-frontend
        weight: 100
      port:
        targetPort: http
      wildcardPolicy: None

Con esto ya tendríamos Longhorn funcionado. Se debería haber creado una StorageClass y se habrá marcado como la usar por defecto.