[DOCKER] Créer un environnement Kubernetes avec Ansible 2

Introduction

J'ai pu initialiser kubernetes en utilisant ansible
Enfin, je vais ajouter un worker k8s pour créer un environnement k8s final </ p>

Environnement

MBP OS Sierra
Serveur MAAS (réseau 192.168.100.152 pour MAAS: 192.168.200.1)
serveur maître k8s (KVM: 192.168.100.191)
serveur ansible (KVM: 192.168.100.192)
k8s worker(192.168.200.151)
k8s worker(192.168.200.153)

dash-board Ver.1.8

Objectif

Ajouter une machine avec un OS déployé avec MAAS en tant que travailleur k8s dans le réseau flanelle créé avec k8s
En outre, vous pouvez voir l'état d'utilisation des k8 sur le tableau de bord.

Paramètres réseau du serveur MAAS

Cette fois, en raison du problème DHCP de MAAS, k8s-master et worker sont sur des réseaux différents, il est donc nécessaire de définir le pont sur le serveur MAAS

ubuntu18 a modifié le mode de configuration du réseau de 16 au maximum
J'aurais dû être capable d'écrire simplement /etc/netplan/50-cloud-init.yaml_bk, mais cette fois je l'ai écrit dans deux types de fichiers car le réglage du pont ne s'est pas bien passé. 

$ sudo vi /etc/netplan/50-cloud-init.yaml_bk
network:
    ethernets:
        enp0s31f6:
            addresses:
            - 192.168.100.152/24
            gateway4: 192.168.100.1
            nameservers:
                addresses:
                - 8.8.8.8
                search:
                - 8.8.4.4
        enp2s0:
            addresses:
            - 192.168.200.1/24
            gateway4: 192.168.100.1
            nameservers:
                addresses:
                - 8.8.8.8
                search:
                - 8.8.4.4
    version: 2

$ sudo vi /etc/network/interfaces
auto lo
iface lo inet loopback

auto enp0s31f6
iface enp0s31f6 inet manual

auto br0
iface br0 inet static
address 192.168.100.152
netmask 255.255.255.0
gateway 192.168.100.1
dns-nameservers 8.8.8.8
bridge_ports enp0s31f6
bridge_maxwait 0
bridge_df 0
bridge_stp off


auto enp2s0
iface enp2s0 inet static
address 192.168.200.1
netmask 255.255.255.0
gateway 192.168.100.1
dns-nameservers 8.8.8.8

$ ifconfig
br0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.100.152  netmask 255.255.255.0  broadcast 192.168.100.255
        inet6 fe80::329c:23ff:feac:5570  prefixlen 64  scopeid 0x20<link>
        ether 30:9c:23:ac:55:70  txqueuelen 1000  (Ethernet)
        RX packets 9579059  bytes 16579553543 (16.5 GB)
        RX errors 0  dropped 657286  overruns 0  frame 0
        TX packets 6047022  bytes 936298283 (936.2 MB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

enp0s31f6: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet6 fe80::329c:23ff:feac:5570  prefixlen 64  scopeid 0x20<link>
        ether 30:9c:23:ac:55:70  txqueuelen 1000  (Ethernet)
        RX packets 21689196  bytes 26237413396 (26.2 GB)
        RX errors 0  dropped 475  overruns 0  frame 0
        TX packets 6555651  bytes 4057603928 (4.0 GB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device interrupt 16  memory 0xdf100000-df120000

enp2s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.200.1  netmask 255.255.255.0  broadcast 192.168.200.255
        inet6 fe80::6a05:caff:fe66:a834  prefixlen 64  scopeid 0x20<link>
        ether 68:05:ca:66:a8:34  txqueuelen 1000  (Ethernet)
        RX packets 6867754  bytes 970026556 (970.0 MB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 13304857  bytes 15246678579 (15.2 GB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device interrupt 17  memory 0xdf0c0000-df0e0000

De plus, définissez NAT pour pouvoir communiquer avec deux réseaux 

sudo iptables -t nat -A POSTROUTING -s 192.168.200.0/24 -j SNAT --to 192.168.100.152

Ajouter un travailleur

Ajouter un worker k8s est presque le même que le master, mais vous avez besoin d'une commande pour le démarrer à la fin pour rejoindre le réseau flannel

La commande est affichée dans le contenu de sortie lorsque kubeadm init est exécuté, mais vous pouvez également la vérifier avec la commande suivante 

(k8s-master)$ kubeadm token create --print-join-command

Créez un playbook pour la participation des collaborateurs à l'aide des commandes qui s'affichent 

(ansible)$ sudo vi mlp.yml

  • hosts: mlp01 remote_user: ubuntu become: yes tasks:
    • name: Install prerequisites and Docker.io , nfs-common apt: name={{item}} update_cache=yes with_items:
      • nfs-common
      • apt-transport-https
      • ca-certificates
      • curl
      • software-properties-common
      • docker.io
    • name: user add to docker group user: name=ubuntu group=docker append=yes
    • name: Add K8S GPG key apt_key: url: https://packages.cloud.google.com/apt/doc/apt-key.gpg
    • name: Add K8S APT repository apt_repository: repo: deb http://apt.kubernetes.io/ kubernetes-xenial main
    • name: Install K8S apt: name={{item}} update_cache=yes with_items:
      • kubelet
      • kubeadm
      • kubectl
    • name: Remove swapfile from /etc/fstab mount: name: swap fstype: swap state: absent
    • name: Disable swap command: swapoff -a when: ansible_swaptotal_mb > 0
    • name: Set docker service to start on boot. service: name=docker enabled=yes
    • name: Set kubelet service to start on boot. service: name=kubelet enabled=yes
    • name: Join k8s-master become: yes shell: kubeadm join 192.168.100.191:6443 ~~ # Décrivez ce qui a été produit par la commande ci-dessus </ code> </ pre>

Modifiez les hôtes comme vous l'avez fait lors du mastering 

$ sudo vi /etc/ansible/hosts
[master]
k8s-master

[mlp]
mlp01 

$ sudo vi /etc/hosts 
192.168.100.191 k8s-master 192.168.200.151 mlp01

Exécution du playbook Ansible
Si vous souhaitez utiliser python3, vous avez besoin de l'option après "-e" 

~/ansible$ sudo ansible-playbook --private-key=id_rsa_common mlp.yml -e 'ansible_python_interpreter=/usr/bin/python3'

Si le playbook réussit, il sera dans l'état suivant 

(k8s-master)$ kubectl get node
NAME         STATUS    ROLES     AGE       VERSION
k8s-master   Ready     master    3d        v1.10.3
mlp01        Ready     <none>    3d        v1.10.2

Lancer l'image nginx

Une fois le nœud ajouté, exécutez l'image docker nginx pour le moment
La raison sera décrite plus tard 

$ sudo vi nginx-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
    - name: nginx-container
      image: nginx
      ports:
      - containerPort: 80

$ kubectl apply -f nginx-pod.yaml
create
$ kubectl get pod
NAME           READY     STATUS    RESTARTS   AGE
nginx-pod      1/1       Running   0          3d

Aucun problème si nginx devient Running

Installation du tableau de bord

Même si vous n'avez pas de tableau de bord, vous pouvez utiliser Kubernetes, mais je veux l'utiliser
C'est pourquoi je vais l'installer 

$ kubectl create -f https://raw.githubusercontent.com/kubernetes/dashboard/master/src/deploy/recommended/kubernetes-dashboard.yaml

Si aucune erreur n'apparaît et que "created" est affiché, c'est OK
Vérifiez si cela fonctionne 

kubectl get pods --all-namespaces
NAMESPACE     NAME                                    READY     STATUS    RESTARTS   AGE
default       nginx-pod                               1/1       Running   0          3d
kube-system   kubernetes-dashboard-7d5dcdb6d9-7hptz   1/1       Running   0          3d

Démarrer le proxy kube 

$ kubectl proxy --address 0.0.0.0 --accept-hosts '.*'
Starting to serve on [::]:8001

Si cela se produit, accédez-y avec un navigateur pour le voir.
L'écran de connexion apparaîtra 

http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/#!/login
Capture d'écran 2018-05-29 14.24.06.png

Émettez un jeton pour vous connecter 

$ kubectl -n kube-system get secret

Entrez en utilisant le jeton émis

Les paramètres suivants sont destinés aux personnes qui ont du mal à émettre des jetons à chaque fois.
Après cela, vous pourrez entrer avec SKIP sur l'écran de connexion
Cependant, comme il est lâche en termes de sécurité, il est recommandé de l'utiliser dans des conditions où il n'y a pas d'étrangers tels que l'environnement interne uniquement. 

$ cat <<EOF | kubectl create -f -
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: kubernetes-dashboard
  labels:
    k8s-app: kubernetes-dashboard
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: kubernetes-dashboard
  namespace: kube-system
EOF

Ceci termine la construction de l'environnement de kubernetes

Conclusion

Une fois que vous avez créé cet environnement, vous pouvez le distribuer automatiquement au nœud en démarrant l'image docker à partir de k8s-master.
C'est très pratique car vous pouvez ajouter un nouveau nœud dès que vous avez une commande pour l'ajouter au réseau flanelle.

J'ai trébuché

Communication réseau

Les paramètres réseau sont répertoriés au début de cet article, mais tant que cela n'a pas été décidé, la communication n'a pas abouti et les erreurs se sont poursuivies.
Impression que j'ai été influencé par le changement de méthode de réglage en raison du changement de version d'ubuntu18

kubeadm init échoue

La cause est que j'ai juste oublié de supprimer le swap, mais j'ai tendance à oublier son existence

le tableau de bord n'est pas affiché

Un nœud a été ajouté au maître, et juste en installant le tableau de bord → proxy de démarrage, le tableau de bord n'a pas été affiché dans le navigateur, et seule l'arborescence des répertoires du fichier est apparue sur la page du navigateur.
J'ai essayé de démarrer le proxy-pod comme indiqué au milieu de la page, et après cela, si je procédais selon la procédure, le tableau de bord s'affichait
Il semble qu'il n'y ait pas eu de symptôme similaire sur d'autres pages référencées, et on ne sait pas s'il s'agit de la spécification de la version du tableau de bord ou s'il existe un paramètre que je n'ai pas fait seul.

Page de référence

J'ai essayé de créer un environnement NAT avec iptables
page officielle de kubernetes
access control
Ajout de Kubernetes / Web UI (tableau de bord)
Installez Dashboard sur Kubernetes et accédez sans authentification

Recommended Posts