Blog de dada

DevOps, bidouilleur et routard plein de logiciels libres

DHCP

Welcome to Nginx, puis Wordpress

Rédigé par dada / 09 novembre 2018 / Aucun commentaire

Perdu ?

On y arrive. Après des heures d'attente, de commandes bizarres, de pods dans tous les sens, je vais enfin vous montrer comment mettre en place un Wordpress, sa base de données et y accéder depuis le navigateur !

Wordpress

Il existe une configuration simple pour avoir un Wordpress fonctionnel : ne nous privons pas !

La partie MySQL

Son fichier de configuration :
apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  ports:
    - port: 3306
  selector:
    app: wordpress
    tier: mysql
  clusterIP: None
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim2
  labels:
    app: wordpress
spec:
  storageClassName: rook-ceph-block
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: mysql
    spec:
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: changeme
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim2
Vous y trouverez les volumes persistant pour Rook, le point de montage, la configuration du port MySQL, le mot de passe, etc. Vous avez le temps de lire tout ça.

On lance la création du conteneur :
dada@k8smaster:~$ kubectl create -f mysql.yaml
Et le résultat :
default            wordpress-mysql-75477bf794-89mzw                          1/1     Running     1          5h38m   10.244.2.50    k8snode2    <none>

On peut enchaîner avec la suite. C'est vrai qu'une BDD de Wordpress sans le CMS pour l'utiliser, c'est moyen.

La partie PHP

Notez que je parle de la partie "PHP", mais il n'y a pas que PHP. Il me fallait un titre, alors voilà.

Cette partie, je l'ai modifié par rapport à ce que vous trouverez dans les documentations officielles.
apiVersion: v1
kind: Service
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  ports:
  - port: 80
  selector:
    app: wordpress
    tier: frontend
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wp-pv-claim
  labels:
    app: wordpress
spec:
  storageClassName: rook-ceph-block
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: frontend
    spec:
      containers:
      - image: wordpress:4.6.1-apache
        name: wordpress
        env:
        - name: WORDPRESS_DB_HOST
          value: wordpress-mysql
        - name: WORDPRESS_DB_PASSWORD
          value: changeme
        ports:
        - containerPort: 80
          name: wordpress
        volumeMounts:
        - name: wordpress-persistent-storage
          mountPath: /var/www/html
      volumes:
      - name: wordpress-persistent-storage
        persistentVolumeClaim:
          claimName: wp-pv-claim
Vous pouvez lancer tout ça :
 kubectl create -f wordpress.yaml
Le pod wordpress devrait apparaître:
default            wordpress-796698694f-sxbhb                                1/1     Running     1          3h35m   10.244.2.51    k8snode2    <none>

Ce qu'il faut saisir

La présence des services de Wordpress :
dada@k8smaster:~/$ kubectl get services 
NAME                                     TYPE           CLUSTER-IP       EXTERNAL-IP    PORT(S)                      AGE
kubernetes                               ClusterIP      10.96.0.1        <none>         443/TCP                      4d8h
my-nginx-nginx-ingress-controller        LoadBalancer   10.100.45.147    192.168.0.50   80:32462/TCP,443:30337/TCP   3d5h
my-nginx-nginx-ingress-default-backend   ClusterIP      10.109.228.138   <none>         80/TCP                       3d5h
wordpress                                ClusterIP      10.102.55.203    <none>         80/TCP                       6m3s
wordpress-mysql                          ClusterIP      None             <none>         3306/TCP                     6h33m
La configuration du service wordpress-mysql, on ne va pas s'y attarder. Ça marche tout seul.
Le truc chouette, c'est la configuration du service wordpress.
dada@k8smaster:~/$ kubectl describe service wordpress
Name:              wordpress
Namespace:         default
Labels:            app=wordpress
Annotations:       <none>
Selector:          app=wordpress,tier=frontend
Type:              ClusterIP
IP:                10.102.55.203
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         10.244.2.61:80
Session Affinity:  None
Events:            <none>
On y retrouve les informations qu'il nous faut et surtout, surtout, le Endpoint ! C'est là qu'on peut savoir où vont se retrouver les requêtes ! Ici, on lit 10.244.2.61:80 : il s'agit de l'IP du pod qui fait tourner Wordpress et le port sur lequel l'attaquer.

On va pouvoir s'attaquer à la dernière configuration : le service Ingress

Le service Ingress

Ici, on va expliquer au videur du cluster qu'il peut laisser passer les requêtes vers Wordpress.
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  annotations:
    kubernetes.io/ingress.class: nginx
  name: nginx-ingress
spec:
 backend:
   serviceName: wordpress
   servicePort: 80
Créez tout ça :
kubectl create -f ingress.yaml
Une fois créé, vérifiez qu'il est bien là :
dada@k8smaster:~/$ kubectl get ingresses
NAME            HOSTS   ADDRESS   PORTS   AGE
nginx-ingress   *                 80      6s
Et vérifiez sa configuration :
dada@k8smaster:~/$ kubectl describe ingress nginx-ingress
Name:             nginx-ingress
Namespace:        default
Address:         
Default backend:  wordpress:80 (10.244.2.61:80)
Rules:
  Host  Path  Backends
  ----  ----  --------
  *     *     wordpress:80 (10.244.2.61:80)
Annotations:
  kubernetes.io/ingress.class:  nginx
Events:
  Type    Reason  Age   From                      Message
  ----    ------  ----  ----                      -------
  Normal  CREATE  65s   nginx-ingress-controller  Ingress default/nginx-ingress
Normal  UPDATE  30s   nginx-ingress-controller  Ingress default/nginx-ingress

Dans les Rules, remarquez que le backend est bien présent. Ici, le backend est le service wordpress que nous avons mis en place un peu plus tôt. Tout va bien !

Maintenant ? Souvenez-vous de l'IP externe que vous avez réussi à récupérer dans mon précédent billet et allez voir !



Il existe des moyens bien plus simples pour arriver à ce résultat. Passer par un Ingress Controller n'est pas la plus rapide mais elle permet de mettre le nez dans cet outil qui, plus tard, vous permettra de rediriger le flux en fonction du host. Bref. C'est un choix qui invite à aller plus loin !

La suite ?

À voir...

Accéder au cluster k8s depuis l'extérieur

Rédigé par dada / 09 novembre 2018 / Aucun commentaire



Perdu ?

On vient de se battre pour mettre en place un cluster Ceph opérationnel, histoire de stocker ses données dans le cluster k8s et de les répliquer un peu. Maintenant que c'est bon, si on s'attaquait à des choses un peu plus visible, hors dashboard ?
Au programme de ce billet : Ingress, Service, Wordpress, des nouveaux pods.

Ingress Nginx

Cette chose-là va être le point d'entrée de notre cluster. Il va permettre à l'extérieur d'aller regarder à l'intérieur. Son rôle va être de comprendre la requête d'entrée et de l'orienter vers le pod qui y répondra. Dans le cas qui va suivre, aller sur l'IP du cluster pour y retrouver un Wordpress.

Installation via Helm

Comme on s'en sert déjà, on va continuer :
helm install stable/nginx-ingress --name my-nginx
Cette installation va faire apparaître les pods suivants :
dada@k8smaster:~$ kubectget pods -n default
NAME                                                      READY   STATUS    RESTARTS   AGE
my-nginx-nginx-ingress-controller-565bc9555b-pcqjz        1/1     Running   2          8h
my-nginx-nginx-ingress-default-backend-5bcb65f5f4-728tx   1/1     Running   2          8h
Et un service. On n'a pas encore parlé de services : je vous redirige vers la documentation officielle si vous voulez en savoir bien plus.
dada@k8smaster:~$ kubectl --namespace default get services -o wide -w my-nginx-nginx-ingress-controller
NAME                                TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE   SELECTOR
my-nginx-nginx-ingress-controller   LoadBalancer   10.100.45.147   <pending>     80:32462/TCP,443:30337/TCP   8s    app=nginx-ingress,component=controller,release=my-nginx
Ça veut dire que l'Ingress Controller est bien installé. Notez le <pending> : ça veut dire que notre controller n'a pas d'IP externe. En gros : il ne sert à rien. Il lui faut une IP pour que nous puissions l'attaquer.
Dans une installation chez des gros fournisseurs d'informatique dans les nuages, nous aurions une sorte de plugin nous fournissant déjà l'IP tant désirée. Avec notre infrastructure sous Virtualbox, il va falloir faire autrement. Et autrement, ça veut dire avec MetalLB.

MetalLB

MetalLB, ce sont des pods que nous allons installer dans notre cluster et qui nous serviront à palier le problème cité juste au dessus. Il ira interroger notre DHCP, la Freebox dans mon cas, pour récupérer une IP publique.

Installer MetalLB

Toujours avec Helm :
helm install --name metallb stable/metallb
Un peu d'attente et vous devriez voir de nouveaux pods :
dada@k8smaster:~$ kubectl get pods -n metallb-system
NAME                         READY   STATUS    RESTARTS   AGE
controller-765899887-ck6bv   1/1     Running   2          8h
speaker-jdqg9                1/1     Running   2          8h
speaker-t4vtk                1/1     Running   2          8h
Il lui manque un fichier de configuration pour nous offrir une adresse IP externe :
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: default
  name: config
data:
  config: |
    address-pools:
    - name: default
      protocol: layer2
      addresses:
      - 192.168.0.50-192.168.0.60
Les adresses IP en bas de ce fichier de conf vont permettre à MetalLB d'aller titiller notre DHCP (Freebox pour moi) pour obtenir une adresse. Quelque chose entre 192.168.0.50 et 192.168.0.60 dans mon cas. Vérifiez bien la configuration de votre Freebox avant de choisir une plage d'IP.

On l'applique :
kubectl create -f config.yaml 

Retour à l'Ingress Nginx

Une fois après avoir configuré MetalLB, vous allez vérifier l'état du service :
dada@k8smaster:~/$ kubectl --namespace default get services -o wide -w my-nginx-nginx-ingress-controller
NAME                                TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)                      AGE    SELECTOR
my-nginx-nginx-ingress-controller   LoadBalancer   10.100.45.147   192.168.0.50   80:32462/TCP,443:30337/TCP   3d3h   app=nginx-ingress,component=controller,release=my-nginx
Vous avez vu ? Une EXTERNAL-IP ! On va pouvoir taper dessus !

La suite ?


Bloquer les pubs : j'ai installé Pi-Hole derrière une Freebox

Rédigé par dada / 05 juin 2018 / 17 commentaires




Étant coincé pendant encore quelques temps dans la maison familiale, j'ai du trouver des occupations. Première idée : installer un Pi-Hole.

L'idée derrière tout ça ? Trouver une utilité à l'une de mes 3 Raspberry Pi.
L'utilité derrière tout ça ? Mettre en place un système simple permettant aux membres de ma famille, qui passent souvent par cette baraque, de ne plus être emmerdés par les pubs et autres.

Je suis le "toi qui t'y connais en informatique" local. Ça m'ouvre des droits et des devoirs. Avec des géniteurs frôlant les 70 ans, je me dois de prendre en main certaines choses. J'ai déjà réussi à passer un ordinateur portable sous Debian pour l'une mais l'autre doit continuer à se servir d'un Windows. Ils sont bien au courant des histoires de pubs, de flicages et de contenus sponsorisés, mais bon, autant prendre le temps de mettre en place une petite bête qui va s'occuper de tout ça pour eux. Et je ne parle pas d'une branche qui ne jure que par Apple et dont certaines notions citées juste avant n'allument aucune lanterne.

Installer Pi-Hole

Si vous passez par Raspbian, prenez le temps de flasher sa carte SD avec la version Stretch de l'OS sans quoi vous ne pourrez pas vous servir de l'outil. Une sombre configuration de dnsmask plante la chose si vous n'êtes pas à jour.
Pensez aussi à faire un "apt update" avant de lancer l'installeur : j'avais des soucis avec les dépôts et Pi-Hole, sans rien m'expliquer, refusait de s'installer.

Pas de blabla autour de l'installation. Si vous avez une Raspberry et que vous passez par ce blog, vous devriez réussir à faire un curl et appuyer 6 fois sur la touche entrée.

Ajouter la blacklist manquante

J'ai ajouté une blacklist orientée francophones en plus de celles activées par défaut : Liste_fr + Easylist

Ça ne fait pas de mal.

Configuration de la Freebox

Pour que la Freebox utilise Pi-Hole, il faut aller faire un tour dans l'interface de gestion de la bestiole de Free. La capture d'écran qui va bien :



Voyez l'adresse sur serveur DNS 1 : il s'agit de l'IP de la Rasbperry.

Éviter les emmerdes

Alors, quand on commence à faire ce genre de bêtise, il faut garder à l'esprit qu'une coupure de courant, ça arrive. Que ce passera-t-il si la Raspberry ne redémarre pas ? Plus "d'internet" pour les utilisateurs, le téléphone qui sonne, les "tu es responsable !".

- Configurer la réservation de l'adresse IP de la Raspberry pour ne pas perdre le Pi-Hole

Pour que l'IP de la Rasbperry ne change pas, vous devez impérativement la réserver. Ça se fait dans l'interface de la Freebox, dans la gestion de baux statiques.

- Activer la connexion SSH vers la Raspberry en cas de besoin

Cette configuration ne se fait pas depuis l'interface de la Freebox mais depuis le site Free.fr. Dans la rubrique de configuration du routeur, redirigez l'accès SSH depuis l'extérieur vers l'IP de la Rasbperry Pi et le port SSH que vous utilisez (22 par défaut).

- Préparer un mail avec des captures d'écran en cas de crash du Pi-Hole alors que vous faites le tour de la Jamaïque

Pour ce dernier point, je vous laisse aller à vote imagination pour trouver la solution la plus simple pour expliquer à des proches en colères comment corriger la situation en votre absence. C'est sportif, j'en suis conscient.

Notes étonnantes

  • L'utilisation d'une Raspberry Pi de vieille génération ne ralentie pas la navigation des 10 appareils branchés sur le réseau.
  • Si vous êtes utilisateurs de uBlock, sachez que ce dernier bloque directement depuis le navigateur les requêtes qui devraient être élimées par le Pi-Hole (cf ici).

Et voilà, fin du billet. Vous pouvez vous lancer dans l'aventure si ça vous chante et que vous êtes prêt à prendre des responsabilités dans le digital familiale. Moi, je vais jouer avec Funkwhale maintenant.

Des bisous