Déploiement de rancher 2

Source : https://rancher.com/docs/rancher/v2.x/en/ (Leur documentation est super bien structurée, Beau travail !)

L’objectif est de déployer Rancher avec l’aide de RKE (Rancher Kubernetes Engine).

Vous devez voir idéalement 3 machines (VM ou Physique).

Personellement, j’ai une seule machine physique pour mon besoin.

Étapes requises avant de commencer le déploiment

  • Chaque machine ping entre elle.
  • elles ont tous une adresse Statique.
  • docker est installé avec la version recommandé de Rancher (Vérifier ce lien : Requis de Rancher)
  • Un Serveur DNS (J’utilise Bind9 avec mon serveur PFSense.)
  • Création des clés SSL
    • Plusieurs techniques sont possibles
      • Options SSL
      • J’ai utilisé un certificat privé, en gros il faut créer un Root Certificate.
  • Création des clés SSH sur chacune des machines. Chaque machine doit être en mesure de se connecter entre elle en SSH en utilisant la clé privée

NOTE: Je montre seulement le Noeud 1 mais c’est la même chose pour chaque noeud.

Nom d’hôte

sudo hostnamectl set-hostname node1
sudo nano /etc/hosts
# Changer le nom pour le nouveau

Adresse IP Statique

sudo nano /etc/network/interfaces
## EXAMPLE ## 
..
# The primary network interface
auto ens18
iface ens18 inet static
address 10.0.0.31/26
gateway 10.0.0.1
dns-search webux.lab
dns-nameservers 10.0.0.1
..

Désactiver le swap

sudo swapoff -a

Clés SSH

Générer la clé

studiowebux@node1:~$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/studiowebux/.ssh/id_rsa): [PRESS ENTER]
Enter passphrase (empty for no passphrase): [PRESS ENTER]
Enter same passphrase again: [PRESS ENTER]

## Resultat : 
Your identification has been saved in /home/studiowebux/.ssh/id_rsa.
Your public key has been saved in /home/studiowebux/.ssh/id_rsa.pub.

Déployer la clé sur les nodes

studiowebux@node1:~$ ssh-copy-id -i .ssh/id_rsa.pub node2

Tester la connexion

ssh node2

Installer Docker sur chacun des noeuds

En gros, mais vérifier le site de docker pour les versions dont vous avez besoin:

apt-get update
 
apt-get install -y \
    apt-transport-https \
    ca-certificates \
    curl \
    software-properties-common
 
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
 
add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"
 
apt-get update
 
apt-get install -y docker-ce=17.03.2~ce-0~ubuntu-xenial
 
groupadd docker
 
usermod -aG docker studiowebux
 
chown studiowebux:studiowebux /home/studiowebux/.docker -R
chmod g+rwx "/home/studiowebux/.docker" -R
 
systemctl enable docker

Créer le certificat pour signer tous les certificats et avoir un HTTPS “valide”

(Vous devrez installer le root certificate sur vos devices)

Générer le CA certificate

openssl genrsa -des3 -out myCA.key 2048

Dès que l’écran demande un passphrase entrez un mot de passe sécuritaire.

Générer le Root Certificate

openssl req -x509 -new -nodes -key myCA.key -sha256 -days 1825 -out myCA.pem

Le mot de passe demandé est le même que le précédent. puis remplissez l’information demandé.

 Créer d’un certificat pour le cluster

## Création de la clé privée
openssl genrsa -out server.key 2048

## Création de la requête pour signer le certificat
openssl req -new -key server.key -out server.csr

## Création du .ext
nano server.ext

# Add the following
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names
 
[alt_names]
DNS.1 = node1.webux.lab
DNS.2 = node2.webux.lab
DNS.3 = node3.webux.lab
DNS.4 = node1
DNS.5 = node2
DNS.6 = node3
DNS.7 = rancher.webux.lab
DNS.8 = rancher

## Création du certificat
openssl x509 -req -in server.csr -CA myCA.pem -CAkey myCA.key -CAcreateserial -out server.crt -days 1825 -sha256 -extfile server.ext

Les  certificats doivent être mis en mode base64:

cat ssl/server.crt | openssl base64 | awk 'BEGIN{ORS="";} {print}'
cat ssl/server.key | openssl base64 | awk 'BEGIN{ORS="";} {print}'
cat ssl/myCA.pem | openssl base64 | awk 'BEGIN{ORS="";} {print}'

Télécharger le script RKE

Télécharger la dernière version : https://github.com/rancher/rke/releases

wget https://github.com/rancher/rke/releases/download/v0.1.6/rke
chmod +x rke

Installation de kubectl sur le/les noeud(s)

Source: https://kubernetes.io/docs/tasks/tools/install-kubectl/

apt-get update && apt-get install -y apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
apt-get update
apt-get install -y kubectl

Création du fichier pour le cluster

Un fichier example est disponible ici : https://github.com/rancher/rancher/blob/master/rke-templates/3-node-certificate.yml

Sinon voici un extrait de ma configuration:

nano cluster.yml
# Add this into the file.
# default k8s version: v1.8.9-rancher1-1
# default network plugin: flannel
nodes:
  - address: 10.0.0.31 # hostname or IP to access nodes
    user: studiowebux # root user (usually 'root')
    role: [controlplane,etcd,worker] # K8s roles for node
    ssh_key_path: /home/studiowebux/.ssh/id_rsa # path to PEM file
  - address: 10.0.0.43
    user: studiowebux
    role: [controlplane,etcd,worker]
    ssh_key_path: /home/studiowebux/.ssh/id_rsa
  - address: 10.0.0.58
    user: studiowebux
    role: [controlplane,etcd,worker]
    ssh_key_path: /home/studiowebux/.ssh/id_rsa
 
addons: |-
  ---
  kind: Namespace
  apiVersion: v1
  metadata:
    name: cattle-system
  ---
  kind: ServiceAccount
  apiVersion: v1
  metadata:
    name: cattle-admin
    namespace: cattle-system
  ---
  kind: ClusterRoleBinding
  apiVersion: rbac.authorization.k8s.io/v1
  metadata:
    name: cattle-crb
    namespace: cattle-system
  subjects:
  - kind: ServiceAccount
    name: cattle-admin
    namespace: cattle-system
  roleRef:
    kind: ClusterRole
    name: cluster-admin
    apiGroup: rbac.authorization.k8s.io
  ---
  apiVersion: v1
  kind: Secret
  metadata:
    name: cattle-keys-ingress
    namespace: cattle-system
  type: Opaque
  data:
    tls.crt: <server.crt | base64>
    tls.key: <server.key | base64>
  ---
  apiVersion: v1
  kind: Secret
  metadata:
    name: cattle-keys-server
    namespace: cattle-system
  type: Opaque
  data:
    cert.pem: <cattle.crt | base64>
    key.pem: <cattle.key | base64>
    cacerts.pem: <myCA.pem | base64>
  ---
  apiVersion: v1
  kind: Service
  metadata:
    namespace: cattle-system
    name: cattle-service
    labels:
      app: cattle
  spec:
    ports:
    - port: 80
      targetPort: 80
      protocol: TCP
      name: http
    - port: 443
      targetPort: 443
      protocol: TCP
      name: https
    selector:
      app: cattle
  ---
  apiVersion: extensions/v1beta1
  kind: Ingress
  metadata:
    namespace: cattle-system
    name: cattle-ingress-http
    annotations:
      nginx.ingress.kubernetes.io/proxy-connect-timeout: "30"
      nginx.ingress.kubernetes.io/proxy-read-timeout: "1800"   # Max time in seconds for ws to remain shell window open
      nginx.ingress.kubernetes.io/proxy-send-timeout: "1800"   # Max time in seconds for ws to remain shell window open
  spec:
    rules:
    - host: rkea.webux.lab  # FQDN to access cattle server
      http:
        paths:
        - backend:
            serviceName: cattle-service
            servicePort: 80
    - host: rkeb.webux.lab  # FQDN to access cattle server
      http:
        paths:
        - backend:
            serviceName: cattle-service
            servicePort: 80
    - host: rkec.webux.lab  # FQDN to access cattle server
      http:
        paths:
        - backend:
            serviceName: cattle-service
            servicePort: 80
    - host: rancher.webux.lab  # FQDN to access cattle server
      http:
        paths:
        - backend:
            serviceName: cattle-service
            servicePort: 80
    tls:
    - secretName: cattle-keys-ingress
      hosts:
      - rancher.webux.lab
      - rkea.webux.lab
      - rkeb.webux.lab
      - rkec.webux.lab
  ---
  kind: Deployment
  apiVersion: extensions/v1beta1
  metadata:
    namespace: cattle-system
    name: cattle
  spec:
    replicas: 3
    template:
      metadata:
        labels:
          app: cattle
      spec:
        serviceAccountName: cattle-admin
        containers:
        - image: rancher/rancher:latest
          imagePullPolicy: Always
          name: cattle-server
          ports:
          - containerPort: 80
            protocol: TCP
          - containerPort: 443
            protocol: TCP
          volumeMounts:
          - mountPath: /etc/rancher/ssl
            name: cattle-keys-volume
            readOnly: true
        volumes:
        - name: cattle-keys-volume
          secret:
            defaultMode: 420
            secretName: cattle-keys-server

les sections:

  • <server.crt | base64>
  • <server.key | base64>
  • <cattle.crt | base64>
  • <cattle.key | base64>
  • <myCA.pem | base64>

doivent être remplacé par les certificats que vous avez créés.

Déployer le cluster

./rke up --config cluster.yml

Test

kubectl --kubeconfig kube_config_cluster.yml get all --all-namespaces

Avec votre navigateur favori: https://rancher.webux.lab

Laisser un commentaire