Despliegue de un nodo satélite Cyberwatch en un cluster Kubernetes existente

Esta pagina describe los pasos a seguir para desplegar un nodo satélite Cyberwatch en un cluster Kubernetes existente. Este procedimiento supone que el usuario dispone de conocimientos básicos del orquestador Kubernetes y de Helm.

Procedimiento de despliegue

Disponer de un nodo maestro Cyberwatch configurado para permitir la conexión de un nodo satélite y tener acceso SSH a ese nodo maestro
En caso de que el nodo maestro use bases de datos externas, estas bases de datos deben ser accesibles para el cluster Kubernetes.
Tener un cluster que cumpla con los requisitos técnicos del software.
Conectarse al repositorio Helm:
```
helm registry login harbor.cyberwatch.fr
```
Complete el nombre de usuario prefijandolo con cbw$, luego proporcione la contraseña.

Crear y luego editar el archivo de configuración values.yml

Es necesario conservar el archivo values.yml de forma segura. El archivo es necesario para actualizar las imágenes Docker o actualizar el chart Helm.

Los pasos presentados a continuación apuntan a crear un archivo de configuración mínimo que permita el despliegue del satélite Cyberwatch.

A continuación, un ejemplo de archivo values.yml en su configuración mínima:

global:
  pki:
    root_ca: cbw-root-ca-cert
  image:
    registryCredentials:
      - name: cyberwatch-credentials
        registry: harbor.cyberwatch.fr/cbw-on-premise
        username: "changeme"
        password: "changeme"

node:
  name: cyberwatch-node-name
  type: satellite

nginx:
  resolver: "changeme"

ingress:
  enabled: true
  hosts:
    - hostname: cyberwatch.example.com
      ingressClassName: nginx
      tls:
        enabled: true

thirdParties:
  enabled: false

database:
  external: true
  host: "changeme"
  password: "changeme"
  root_password: "changeme"

redis:
  external: true
  host: "changeme"
  password: "changeme"

key:
  base: "changeme"
  credential: "changeme"

Configurar el acceso al registro de contenedores. El par usuario/contraseña es similar al usado para conectarse al repositorio Helm

global:
  image:
    registryCredentials:
      - name: cyberwatch-credentials
        registry: harbor.cyberwatch.fr/cbw-on-premise
        username: "changeme"
        password: "changeme"

Configurar el nombre que tomara el nodo satélite Cyberwatch en la aplicación con el parámetro node.name:
```
node:
  name: cyberwatch-node-name
  type: satellite
```
Configurar el campo nginx.resolver
1. Obtener la IP del resolvedor DNS kube-dns:
```
kubectl -n kube-system get svc kube-dns
```
2. Asignar la dirección IP del resolvedor DNS del cluster Kubernetes al campo nginx.resolver
  Ejemplo:
```
nginx:
  resolver: 10.3.0.10
```
Configurar el ingress
1. Se pueden configurar uno o varios ingress en el campo ingress.hosts. Cada ingress debe tener un hostname único y un ingressClassName. Las IngressClass disponibles en el cluster pueden listarse usando el comando siguiente:
```
kubectl get ingressclasses
```
2. Asignar el valor seleccionado al campo ingressClassName y el nombre de dominio que aceptara las solicitudes al campo hostname.
  Ejemplo:
```
ingress:
  enabled: true
  hosts:
    - hostname: cyberwatch.example.com
      ingressClassName: nginx
      tls:
      enabled: true
```
  La dirección IP que corresponde al nombre de dominio debe ser la del balanceador de carga del cluster.
Si es necesario, hay mas información disponible en los comentarios del archivo de configuración por defecto del chart Helm.

Configurar los accesos a las bases de datos y a la aplicación Cyberwatch

Introducir las direcciones IP de conexión a las bases de datos en los campos database.host y redis.host:

database:
  external: true
  host: "changeme"

redis:
  external: true
  host: "changeme"

Conectarse por SSH al nodo maestro y mostrar las contraseñas:

sudo cyberwatch show-secrets

MYSQL_ROOT_PASSWORD=...
MYSQL_PASSWORD=...
REDIS_PASSWORD=...
SECRET_KEY_BASE=...
SECRET_KEY_CREDENTIAL=...

Introducir las contraseñas de base de datos obtenidas en los campos correspondientes:

database:
  external: true
  host: "changeme"
  password: "MYSQL_PASSWORD"
  root_password: "MYSQL_ROOT_PASSWORD"

redis:
  external: true
  host: "changeme"
  password: "REDIS_PASSWORD"

Introducir las credenciales de conexión a la aplicación Cyberwatch:

key:
  base: "SECRET_KEY_BASE"
  credential: "SECRET_KEY_CREDENTIAL"

Desactivar el uso del contenedor thirdParties configurando los parámetros siguientes:
```
thirdParties:
  enabled: false
```

Generar credenciales para los pods container-scanner y web-scanner:

cat <<-EOF
containerScanner:
  container_scanner_api_key: "$(openssl rand -hex 16):$(openssl rand -hex 16)"

webScanner:
  web_scanner_api_key: "$(openssl rand -hex 16):$(openssl rand -hex 16)"
EOF

Crear el namespace cyberwatch en el cluster:
```
kubectl create namespace cyberwatch
```
Configurar el certificado raiz que permite conectarse a la aplicación Cyberwatch
1. Conectarse por SSH al nodo maestro y mostrar el certificado raiz:
```
sudo cyberwatch show-root-cert
```
2. Almacenar el certificado raiz en un archivo llamado ./cbw-root-ca-cert.pem:
```
cat <<EOF > ./cbw-root-ca-cert.pem
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
EOF
```
3. Importar el certificado como secreto en el cluster Kubernetes:
```
kubectl -n cyberwatch create secret generic cbw-root-ca-cert --from-file=./cbw-root-ca-cert.pem
```

Generar un par de claves SSH y registrarlas como un secreto:

ssh-keygen -q -N '' -f ./id_ed25519 -t ed25519
kubectl -n cyberwatch create secret generic web-scanner-ssh-authorized-keys --from-file=authorized_keys="./id_ed25519.pub"
kubectl -n cyberwatch create secret generic ssh-private-key --from-file="./id_ed25519"

Desplegar el chart Helm:
```
helm -n cyberwatch install cyberwatch oci://harbor.cyberwatch.fr/cbw-on-premise/cyberwatch-chart -f values.yml
```
El despliegue del chart Helm tomara en cuenta las configuraciones del archivo values.yml para configurar la aplicación.
Verificar el estado de los pods:
```
kubectl -n cyberwatch get pods
```
Cuando todos los pods estén en ejecución, conectarse a la interfaz web del nodo maestro para constatar el enlace con el nodo satélite. También es posible verificar que sidekiq se comunica correctamente con el nodo maestro:
```
kubectl -n cyberwatch logs $(kubectl -n cyberwatch get pods -l app=sidekiq  -o jsonpath='{.items[*].metadata.name}')
```

(Opcional) Recuperar el archivo de configuración por defecto del chart Helm

La documentación anterior indica los pasos a seguir para configurar una version mínima de Cyberwatch.

Es posible recuperar el archivo de configuración por defecto del chart Helm de Cyberwatch, para disponer de un archivo completo que indica que valores por defecto son modificables.

El uso de este archivo se recomienda si desea desviarse de la configuración mínima propuesta en esta documentación, por ejemplo para configurar un certificado TLS.

Para recuperar el archivo de configuración por defecto del chart Helm:

helm show values oci://harbor.cyberwatch.fr/cbw-on-premise/cyberwatch-chart > values.yml

Este archivo puede modificarse según sus necesidades y el chart Helm redeplegarse a partir de esta nueva configuración.