Déploiement d’un nœud satellite Cyberwatch sur un cluster Kubernetes existant

Cette page décrit les étapes à suivre pour déployer un nœud satellite Cyberwatch sur un cluster Kubernetes existant. Cette procédure suppose que l’utilisateur dispose d’une connaissance basique de l’orchestrateur Kubernetes et de Helm.

Prérequis techniques

Disposer d’un nœud maitre Cyberwatch configuré pour permettre la connexion d’un nœud satellite et avoir un accès SSH à ce nœud maitre
Dans le cas où le nœud maitre utilise des bases de données externes. Ces bases de données doivent être accessibles au cluster Kubernetes.
Disposer d’un environnement sur lequel sont installés les programmes Helm (version > 3.8.0) et Kubectl, configuré pour accéder au cluster Kubernetes
Le cluster Kubernetes doit disposer :
- d’un résolveur DNS comme core-dns
- d’un ingress-controller fonctionnel, la documentation OVH indique par exemple comment en mettre un en place
Pour vérifier que le cluster dispose d’un resolver DNS :
```
kubectl cluster-info
```

Procédure de déploiement

Se connecter au dépôt Helm :
```
helm registry login harbor.cyberwatch.fr
```
Compléter le nom de l’utilisateur en le préfixant par cbw$, puis fournir le mot de passe.

Créer puis éditer le fichier de configuration values.yml

Il est nécessaire de conserver le fichier values.yml de manière sécurisée. Le fichier est requis pour la mise à jour des images Docker ou encore pour mettre à jour le chart Helm.

Les étapes présentées ci-dessous visent à mettre en place un fichier de configuration minimal permettant le déploiement du satellite Cyberwatch.

Voici un exemple de fichier values.yml dans sa configuration minimale :

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
  ingressClassName: "changeme"
  host: "changeme"
  tls:
    selfSigned: 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"

Configurer l’accès au registre des conteneurs. Le couple identifiant/mot de passe est similaire à celui utilisé pour se connecter au dépôt Helm

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

Configurer le nom que prendra le nœud satellite Cyberwatch dans l’application à l’aide du paramètre node.name :
```
node:
  name: cyberwatch-node-name
  type: satellite
```
Configurer le champ nginx.resolver
1. Récupérer l’IP du DNS resolver kube-dns :
```
kubectl -n kube-system get svc kube-dns
```
2. Assigner l’adresse IP du résolveur DNS du cluster Kubernetes au champ nginx.resolver
  Exemple :
```
nginx:
  resolver: 10.3.0.10
```
Configurer l’ingress
1. Le champ ingress.ingressClassName permet de définir quelle IngressClass va être utilisée pour implémenter l’Ingress. Cette valeur doit être définie afin de pointer sur le nom d’une IngressClass valide. Les IngressClass disponibles sur le cluster peuvent être listées à l’aide de la commande ci-dessous :
```
kubectl get ingressclasses
```
2. Assigner la valeur sélectionnée au champ ingress.ingressClassName et le nom de domaine qui acceptera les requêtes au champ ingress.host
  Exemple :
```
ingress:
  enabled: true
  ingressClassName: nginx
  host: cyberwatch.example.com
  tls:
    selfSigned: true
```
  L’adresse IP qui correspond au nom de domaine doit être celle du répartiteur de charge du cluster.

Configurer les accès aux bases de données et à l’application cyberwatch

Renseigner les adresses IP de connections aux bases de données dans les champs database.host et redis.host :

database:
  external: true
  host: "changeme"

redis:
  external: true
  host: "changeme"

Se connecter en SSH au nœud maitre et afficher les mots de passes :

sudo cyberwatch show-secrets

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

Renseigner les mots de passes de bases de données obtenues dans les champs correspondant :

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

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

Renseigner les identifiants de connexions à l’application cyberwatch :

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

Désactiver l’utilisation du conteneur thirdParties en définissant les paramètres suivants :
```
thirdParties:
  enabled: false
```
Créer le namespace cyberwatch sur le cluster :
```
kubectl create namespace cyberwatch
```
Configurer le certificat racine permettant de se connecter à l’application cyberwatch
1. Se connecter en SSH sur le nœud maitre et afficher le certificat racine :
```
sudo cyberwatch show-root-cert
```
2. Stocker le certificat racine dans un fichier nommé ./cbw-root-ca-cert.pem :
```
cat <<EOF > ./cbw-root-ca-cert.pem
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
EOF
```
3. Importer le certificat en tant que secret sur le cluster Kubernetes :
```
kubectl -n cyberwatch create secret generic cbw-root-ca-cert --from-file=./cbw-root-ca-cert.pem
```

Générer un couple de clef SSH et l’enregistrer en tant que secret :

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"

Déployer le chart Helm :
```
helm -n cyberwatch install cyberwatch oci://harbor.cyberwatch.fr/cbw-on-premise/cyberwatch-chart -f values.yml
```
Le déploiement du chart Helm va prendre en compte les configurations du fichier values.yml afin de configurer l’application.
Vérifier l’état des pods :
```
kubectl -n cyberwatch get pods
```
Quand tous les pods sont en cours d’exécution, se connecter à l’interface web du nœud maitre afin de constater le lien avec le nœud satellite. Il est possible également de vérifier que sidekiq communique bien avec le nœud maitre :
```
kubectl -n cyberwatch logs $(kubectl -n cyberwatch get pods -l app=sidekiq  -o jsonpath='{.items[*].metadata.name}')
```