k8s – 2 – ceph helm on minikube

Pour installer ceph sur minikube il faut faire quelques modification sur la vm. D’abord l’éteindre :

minikube stop

Avec virt-manager ajouter autant de disk que d’osd voulu. Moi je suis parti sur 6 disk de 5G en qcow2. Obligé de les mettre en SATA pour que ca fonctionne. Dommage.

Pour fabriquer les disques :

for i in 1 2 3 4 5 6; do qemu-img create -f qcow2 osd$i.qcow2 5G; done

Ensuite on relance minikube, et le dashboard

minikube start --memory 4096 --disk-size 40g --cpus 4 --vm-driver kvm2
minikube dashboard

Pour ceph.

#install helm
curl https://raw.githubusercontent.com/helm/helm/master/scripts/get | bash
helm init

Installation de ceph et astuce pour faire fonctionner avec minikube

#install ceph
helm serve &
helm repo add local http://localhost:8879/charts
git clone https://github.com/ceph/ceph-helm
cd ceph-helm/ceph

Editer le fichier ceph-helm/ceph/ceph/values.yaml et remplacer:

diff --git a/ceph/ceph/values.yaml b/ceph/ceph/values.yaml
index 5831c53..72a74b7 100644
--- a/ceph/ceph/values.yaml
+++ b/ceph/ceph/values.yaml
@@ -254,8 +254,8 @@ ceph:
     mgr: true
   storage:
     # will have $NAMESPACE/{osd,mon} appended
-    osd_directory: /var/lib/ceph-helm
-    mon_directory: /var/lib/ceph-helm
+    osd_directory: /data/ceph-helm
+    mon_directory: /data/lib/ceph-helm
     # use /var/log for fluentd to collect ceph log
     # mon_log: /var/log/ceph/mon
     # osd_log: /var/log/ceph/osd

make
cd -

Créer un fichier ./ceph/ceph-overrides.yaml avec :

network:
  public:  192.168.122.0/24
  cluster: 192.168.122.0/24

osd_devices:
  - name: sda
    device: /dev/sda
    zap: "1"
  - name: sdb
    device: /dev/sdb
    zap: "1"
  - name: sdc
    device: /dev/sdc
    zap: "1"
  - name: sdd
    device: /dev/sdd
    zap: "1"
  - name: sde
    device: /dev/sde
    zap: "1"
  - name: sdf
    device: /dev/sdf
    zap: "1"

storageclass:
  name: ceph-rbd
  pool: rbd
  user_id: k8s

Et lancer l’installation :

kubectl create namespace ceph
kubectl create -f ceph-helm/ceph/rbac.yaml
kubectl label --overwrite node minikube ceph-mon=enabled ceph-mgr=enabled ceph-rgw=enabled ceph-mds=enabled
kubectl label --overwrite node minikube ceph-osd=enabled ceph-osd-device-sda=enabled ceph-osd-device-sdb=enabled ceph-osd-device-sdc=enabled ceph-osd-device-sdd=enabled ceph-osd-device-sde=enabled ceph-osd-device-sdf=enabled
helm install --name=ceph local/ceph --namespace=ceph -f ceph/ceph-overrides.yaml

On attend que tout les pods soient running :

watch -n1 "kubectl -n ceph get pods"

On vérifie que tout est ok coté ceph :

kubectl -n ceph exec -ti ceph-mon-cppdk -c ceph-mon -- ceph -s

k8s – 1 – Installation de minikube

Minikube permet de tester en local un cluster k8s dans une vm. L’installation se fera sur une debian buster avec un user dans le group sudo.

sudo apt-get update && sudo apt-get install -y apt-transport-https curl vim qemu-kvm libvirt-clients libvirt-daemon-system
sudo adduser $USER libvirt
sudo adduser $USER libvirt-qemu
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 && chmod +x minikube && sudo cp minikube /usr/local/bin/ && rm minikube
curl -LO https://storage.googleapis.com/minikube/releases/latest/docker-machine-driver-kvm2 && chmod +x docker-machine-driver-kvm2 && sudo mv docker-machine-driver-kvm2 /usr/bin/
minikube start --memory 4096 --cpus 4 --vm-driver kvm2

 

Passage à kubernetes

J’ai un peu lâché l’affaire avec les vm. Kubernetes à l’air sec. Je vais tester ça en local. Le but est d’avoir un cluster k8s fonctionnel avec ceph, un ingress et le monitoring de tout ça.

16 – Installation de la vm ceph mon

La première étape pour installer un serveur ceph est de créer une machine virtuelle sur laquelle tournera le monitor. Le monitor permet de surveiller le cluster ceph et donne accès aux clients du cluster.

Pour installer une machine virtuelle :

virt-install --connect qemu+ssh://root@hv010/system --name cephA-mon001 --memory 512 -lhttp://ftp.fr.debian.org/debian/dists/stretch/main/installer-amd64/ --disk size=2,bus=virtio --network network=admin,model=virtio --accelerate --nographics -v --extra-args "console=ttyS0 hostname=cephA-mon001 domain=hv.internal" --os-type=linux --virt-type=kvm --os-variant=debian9

Les plus attentifs auront remarqués qu’on se connecte à l’hyperviseur avec la commande

--connect qemu+ssh://root@hv010/system

car on exécute cette commande depuis notre machine d’admin.

On met notre vm au carré avec notre playbook base :

ansible-playbook -u root base.yml -l smobe-cephA-mon001

On ajoute nos deux interfaces cephA-front et cephA-back

virsh --connect qemu+ssh://root@hv010/system attach-interface smobe-cephA-mon001 network cephA-front --model virtio --persistent
virsh --connect qemu+ssh://root@hv010/system attach-interface smobe-cephA-mon001 network cephA-back --model virtio --persistent

15 – préparation du réseau pour ceph

Pour installer le cluster ceph nous avons besoin de deux réseaux. Un réseau par lequel le cluster pourra discuter avec ses membres et un réseau sur par lequel passeront les clients.

– vlan 111 pour le réseau cephA-front

– vlan 112 pour le réseau cephA-back

Nous avons déjà vu une configuration similaire précédemment. Je ne la détaille pas. Vous retrouverez les playbook ici : https://github.com/oaudry/cloud/tree/master/ansible/stretch/hyperviseur/004-ceph

14 – Testons l’installation d’une première machine virtuelle

J’aime bien avoir une vm que j’appelle admin. Elle est mon point d’entré sur l’architecture et ma base arrière.

Elle aura une interface sur le réseau d’admin pour discuter avec toute les vm., et une interface publique par laquelle se connecter. Cette machine aura aussi comme particularité d’être la seule à pouvoir se connecter en ssh aux vm. Les autres vm ne pourront pas passer par le réseau d’admin pour discuter entre elle.  Mais nous verrons ça par la suite.

Pour le moment créons notre machine d’admin sur le réseau d’admin pour valider que tout fonctionne comme attendu.

Que nous réussissons à avoir une ip sur le réseau d’admin servi par notre dhcp et que depuis cette ip nous pouvons accéder au web pour faire l’installation.

Ensuite nous ajouterons une interface wan et nous couperons l’accès ssh sur l’ip wan du firewall.

Nous avons fait déjà toute ces étapes. Je vous laisse les retrouver et configurer tout ça correctement.

13 – régles de pare feu nftables

nftables remplace iptables dans la debian stretch.  Voici quelques règles toutes simples mais avant il faut installer nftables :

apt install nftables

Les règles :
On fait propre avant toutes choses

flush ruleset

On défini quelques variables

define trusted_source_ip = { 192.168.0.45 }
define admin_network = 192.168.110.0/24
define admin_iface = ens7
define wan_iface = ens2

La configuration du nat et du maquerade pour donner accès à internet à nos machines virtuelles. Du moins dans un premier temps pour leur installation.

table ip nat {
	chain prerouting {
		type nat hook prerouting priority 0;
	}
	chain postrouting {
		type nat hook postrouting priority 100;
		oifname $wan_iface masquerade
	}
}

Et notre filtrage

table ip filter {
	chain input {
		type filter hook input priority 0; policy drop;
		jump base_checks
		iif lo accept
		iifname $admin_iface jump input_admin
		iifname $wan_iface goto input_wan
		log drop
	}
	chain base_checks {
		ct state established,related accept
		ct state invalid drop	
		ip saddr $trusted_source_ip ip protocol icmp icmp type { destination-unreachable, router-advertisement, time-exceeded, parameter-problem } accept
		ip saddr $admin_network ip protocol icmp icmp type { echo-request, destination-unreachable, router-advertisement, time-exceeded, parameter-problem } accept
	}
	chain input_admin {
		udp sport bootps udp dport bootpc ip saddr $admin_network
	}
	chain input_wan {
		ip saddr $trusted_source_ip tcp dport ssh log accept
	}
	chain forward { 
		type filter hook forward priority 0; policy drop;
		jump base_checks
		ip saddr $admin_network iifname $admin_iface accept	
		log drop
	}
	chain output { 
		type filter hook output priority 0; policy drop;
		ct state established,related accept
		tcp dport {https, http} accept
		udp dport domain accept
		udp sport bootps udp dport bootpc ip saddr $admin_network
		log drop
	}
}

Toute cette configuration doit être faite dans le fichier /etc/nftables.conf qui sera ensuite chargé avec la commande :

systemctl restart nftables.service

Vous trouverez le fichier entier ici : ici

N’oublions pas d’activer l’ip_forward dans le fichier /etc/sysctl.conf

net.ipv4.ip_forward = 1

et on recharge la configuration

sysctl -p

Nous avons donc un minimum de sécurité et nous pouvons installer nos machines virtuelles. Dans la prochaine étape nous testerons tout ça en démarrant l’installation de notre premier serveur du cluster ceph.

12 – Installation d’un serveur dhcp

On installe le serveur dhcp :

apt install isc-dhcp-server

Une fois le serveur installé il ne démarre pas. Il lui manque sa configuration.

La première chose à faire est de lui dire sur quelles interfaces il devra écouter et donc répondre aux requêtes.

Cette configuration se trouve dans le fichier /etc/default/isc-dhcp-server qui doit contenir chez moi

INTERFACESv4="ens7"

ou ens7 est mon interface réseau sur le réseau d’admin.

Ensuite il faut lui dire quoi proposer comme ip.

On trouve cette configuration dans le fichier /etc/dhcp/dhcpd.conf.

Voici une configuration minimale.

option domain-name "hv.internal";
option domain-name-servers 192.168.0.254;
default-lease-time 600;
max-lease-time 7200;
ddns-update-style none;
subnet 192.168.110.0 netmask 255.255.255.0 {
    range 192.168.110.50 192.168.110.200;
    option routers 192.168.110.254;
}

Nous allons distribuer des ip depuis 192.168.110.50 jusqu’à 192.168.110.200 avec comme serveur dns 192.168.0.254 (ma freebox) et comme route par défaut l’interface admin du firewall 192.168.110.254.

Maintenant le serveur dhcp démarre.

Dans la prochaine étape nous verrons comment configurer avec nftables le maquerading et nous ajouterons quelques rêgles de firewall pour un minimum de sécurité.

11 – Configuration réseau du routeur firewall

Notre nouvelle machine virtuelle fw001 est en ligne. Nous pouvons y accéder en console depuis l’hyperviseur avec la commande

virsh console fw001

Nous pouvons quitter la console avec ctrl + ] et si jamais vous avez un message qui vous dit que la console est déjà utilisée il suffit de relancer libvirtd et de vous reconnecter.

systemctl restart libvirtd.service

Mais il est quand même plus simple de se connecter en ssh.

Notre objectif est de faire de cette machine virtuelle un routeur pare feu qui sera capable de donner accès à internet aux machines virtuelles connectées au réseau d’admin et de distribuer des ips sur ce même réseau d’admin.

Pour le moment nous n’avons qu’une seule interface. L’interface wan. Il va falloir ajouter une interface réseau sur le réseau d’admin.

Depuis l’hyperviseur on attache une interface à la machine virtuelle fw001 qui sera connectée au réseau admin et qui sera du type virtio. On veut que cette configuration soit persistante.

virsh attach-interface fw001 network admin --model virtio --persistent

Avant :

# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
3: ens2: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 52:54:00:c6:cf:d0 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.16/24 brd 192.168.0.255 scope global ens2
       valid_lft forever preferred_lft forever
    inet6 fe80::5054:ff:fec6:cfd0/64 scope link 
       valid_lft forever preferred_lft forever

après

# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
3: ens2: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 52:54:00:c6:cf:d0 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.16/24 brd 192.168.0.255 scope global ens2
       valid_lft forever preferred_lft forever
    inet6 fe80::5054:ff:fec6:cfd0/64 scope link 
       valid_lft forever preferred_lft forever
4: ens7: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default qlen 1000
    link/ether 52:54:00:2c:9a:2d brd ff:ff:ff:ff:ff:ff

Nous avons donc une nouvelle interface ens7 à qui nous allons donner une adresse ip : 192.168.110.254 que nous devrions pouvoir atteindre depuis notre hyperviseur. Et vice versa.

Dans le répertoire /etc/network/interfaces.d créez un fichier admin dans lequel vous mettrez la configuration suivante :

auto ens7
iface ens7 inet static
	address 192.168.110.254
	netmask 255.255.255.0

Vérifiez bien que le réseau (192.168.110.0) est bien celui que vous avez configuré sur votre hyperviseur et que l’interface est bien la bonne.

Maintenant nous devrions pouvoir pinger l’ip de l’hyperviseur. Pour moi c’est 192.168.110.10.

root@fw001:/etc/network# ip addr show ens7
3: ens7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 52:54:00:5f:db:54 brd ff:ff:ff:ff:ff:ff
    inet 192.168.110.254/24 brd 192.168.110.255 scope global ens7
       valid_lft forever preferred_lft forever
root@hv010:~# ip addr show admin 
5: admin: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
    link/ether e0:d5:5e:14:d5:f1 brd ff:ff:ff:ff:ff:ff
    inet 192.168.110.10/24 brd 192.168.110.255 scope global admin
       valid_lft forever preferred_lft forever

Depuis le firewall :

root@fw001:/etc/network# ping -c 1 192.168.110.10
PING 192.168.110.10 (192.168.110.10) 56(84) bytes of data.
64 bytes from 192.168.110.10: icmp_seq=1 ttl=64 time=0.248 ms

--- 192.168.110.10 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.248/0.248/0.248/0.000 ms

depuis l’hyperviseur

root@hv010:~# ping -c 1 192.168.110.254
PING 192.168.110.254 (192.168.110.254) 56(84) bytes of data.
64 bytes from 192.168.110.254: icmp_seq=1 ttl=64 time=0.266 ms

--- 192.168.110.254 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.266/0.266/0.266/0.000 ms

On est donc tout bon. On peut passer à la suite.

Installation d’un dhcp et de quelques règles de firewall avec nftables.

10 – Première machine virtuelle

Maintenant nous avons tout ce qui est nécessaire à la création de notre première machine virtuelle. Elle sera connecté au réseau wan pour avoir accès à internet lors de l’installation. A condition bien sur qu’un dhcp écoute sur cette interface wan. Dans mon cas c’est ma freebox

Ensuite nous lui ajouterons une interface sur le réseau d’admin, un dhcp sur ce réseau et cette interface et enfin quelques règles de firewall avec nftables.

Pour le moment nous allons utiliser virt-install qui est un script qui permet de créer et d’installer des machines virtuelles en ligne de commande.

# virt-install
--name fw001
--memory 512
-lhttp://ftp.fr.debian.org/debian/dists/stretch/main/installer-amd64/
--disk size=2,bus=virtio
--network network=wan,model=virtio
--accelerate
--nographics
-v
--extra-args "console=ttyS0 hostname=fw001 domain=hv.internal"
--os-type=linux
--virt-type=kvm
--os-variant=debian9

C’est une installation complètement en console, il n’y a donc pas besoin de client particulier (vnc, spice) pour faire l’installation.

Faites une installation simple. Vu le peu de place que j’ai sur mon disque système je n’ai mis pour la vm firewall que 2G de disque.

Par contre 512Mo de ram est un minimum. Du moins à l’installation. Avec moins le programme d’installation plante. Vous pourrez ensuite baisser à 128Mo de ram sans soucis.

Une fois l’installation faites. La machine virtuelle reboot. Dans le menu grub appuyez sur la touche e sur la première entrée du menu. Descendez avec la flèche du bas jusqu’à la ligne qui commence par linux. Ce devrait être la troisième ligne en partant du bas. Ajoutez à la fin de cette ligne console=ttyS0 et ensuite appuyez sur f10 pour lancer la procédure de boot.

Vous devriez voir votre debian démarrer jusqu’au login. Loggez vous et éditer le fichier /etc/default/grub pour changer la ligne :

GRUB_CMDLINE_LINUX_DEFAULT="quiet"

en

GRUB_CMDLINE_LINUX_DEFAULT="quiet console=ttyS0"

et enfin mettre à jour grub

# update-grub

Astuce : pour sortir de la console ctrl + alt gr + ) ou crtl + ] et la commande reset pour retrouver votre terminal propre

Comme exercice :

  1. faites en sorte de pouvoir vous connecter en root sur cette nouvelle machine sans mots de passe
  2. executez le playbook ansible de base sur cette nouvelle machine virtuelle. Et uniquement sur cette nouvelle machine virtuelle

Ces deux étapes seront des pré requis pour la suite