[DOCKER] Installez Ubuntu20.04 sur RaspberryPi 4 et compilez Kubernetes pour exécuter le conteneur

introduction

Je voulais un environnement de test pour Kubernetes et je l'ai construit. C'est beaucoup de choses qui ressortent lorsque vous recherchez sur Google. Cuisiner pendant 3 jours [emballage de tarte aux framboises de Kubernetes "style cyber agent"], j'ai pensé que c'était délicieux.

environnement

Il s'agit du Raspberry Pi 4 assemblé. Le hub de commutation et le chargeur USB sont fixés avec du ruban magique. (Je l'ai acheté pour 100 yens.)

Ce sont les parties que j'ai préparées cette fois.

Nom de la pièce	adresse
Raspberry Pi	Raspberry Pi 4 Model B/4GBx 3 unités
carte SD	Samsung micro SDXC 128GB MB-MC128GAx 3 feuilles
Hub de commutation	エレコムHub de commutationギガビット 5ポート AC電源小型 EHC-G05PA-SBx 1 unité
chargeur USB	Anker PowerPort I PD - 1 PD & 4 PowerIQx 1 unité ※type-c:1 bouche, type-A:4 bouches
Cas	Boîtier rack Pi pour GeeekPi Raspberry Pi 4 modèle B avec ventilateur de refroidissement et dissipateur de chaleurx 1 unité
cable USB	Mauknci type-c & type-c 30cmx 1
cable USB	SUNGUY type-A & type-c 30cm ensemble de 2 piècesx2ensembles(4) * Il en reste un. Je l'utilise pour autre chose.
câble LAN	Catégorie Miyoshi MCO-6 Slim LAN-Taureau 15cmx 3

Le concentrateur de commutation est connecté au routeur avec un câble LAN. Je n'utilise pas de LAN sans fil. --Utilisez un graveur compatible SDXC pour écrire sur la carte SD.
La spécification d'alimentation du Raspberry Pi 4 est de 3A et la sortie du chargeur USB est de 2,4A, mais cela fonctionne.

Il s'agit du logiciel à installer.

Ubuntu 20.04.1 LTS 64bit
Kubernetes v1.19.3
Docker 19.03.13

J'ai utilisé ce qui suit pour mon travail.

--Windows 10 PC (pour l'écriture sur carte SD et connexion SSH)

Moniteur mobile 15 pouces (pour le réglage initial de Raspeye) --Clavier USB (pour le réglage initial de Raspeye)

Environnement réseau à construire

L'adresse IP est fixe.

Utilisation	nom d'hôte	adresse IP
Master Node	master01.example.jp	192.168.100.101/24
Worker Node1	worker01.example.jp	192.168.100.102/24
Worker Node2	worker02.example.jp	192.168.100.103/24

Autres informations d'adresse IP nécessaires.

Utilisation	adresse IP
gateway	192.168.100.254
DNS	192.168.100.254
Pool d'adresses IP pour LoadBalancer	192.168.100.211-192.168.100.215

Assemblée

Comme le chargeur USB est lourd, je l'ai assemblé en bas. Un seul «câble de type c à type c» est utilisé pour le nœud maître, ce qui peut être important. (Peut-être que ça n'a pas de sens) Il n'y a rien de spécial à mentionner. Après l'assemblage, il est prêt à démarrer.

Installez Ubuntu 20.04 sur Raspberry Pi 4

Créez une carte SD pour démarrer Raspeye. Le PC de travail est Windows 10.

Utilisez "Raspberry Pi Imager" pour écrire sur la carte SD. Si vous le formatez avec "Raspberry Pi Imager", vous pouvez utiliser une carte SD de 64 Go ou plus. Téléchargement depuis Raspberry Pi Imager.

Insérez la carte SD dans le graveur et démarrez "Raspberry Pi Imager".

Veuillez utiliser un graveur prenant en charge les cartes SDXC.

Formatez pour utiliser la carte SD.

Cliquez sur CHOOSE OS et sélectionnez Effacer.

Cliquez sur "CHOISIR LA CARTE SD" et sélectionnez la carte SD insérée.

Cliquez sur ÉCRIRE pour commencer le formatage.

Le formatage est terminé. Cliquez sur "CONTINUER" pour fermer la boîte de dialogue.

Ensuite, écrivez le système d'exploitation. Cliquez sur CHOOSE OS et sélectionnez Ubuntu.

Sélectionnez Ubuntu Server 20.04.1 LTS (RPi 3/4). Sélectionnez 64 bits. Le 32 bits ci-dessus est différent.

Cliquez sur "CHOISIR LA CARTE SD" et sélectionnez la carte SD insérée.

Cliquez sur "WRITE" pour écrire.

L'écriture du système d'exploitation est terminée.

Écrivez sur les deux cartes SD restantes de la même manière.

Paramètres d'Ubuntu 20.04

Configurez le réseau, puis connectez-vous avec SSH pour travailler.

Insérez la carte SD avec le système d'exploitation écrit dans la tarte à la râpe et démarrez-la. Il est configuré à l'aide d'un moniteur mobile de 15 pouces et d'un clavier USB.

Connectez-vous à Ubuntu

Nom d'utilisateur	Mot de passe initial
ubuntu	ubuntu

Si vous vous connectez pour la première fois, vous serez invité à modifier votre mot de passe.

Comme il est réglé sur le clavier anglais, soyez prudent lorsque vous incluez des symboles.

Vérifiez la version du système d'exploitation.

$ cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.1 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.1 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal

Désactivez le compte ubuntu par défaut et créez un compte professionnel (travail commun aux 3 unités)

Au lieu d'utiliser le compte ubuntu par défaut, créez un compte k8suser pour votre travail.

Si vous n'avez pas besoin d'un compte opérationnel, veuillez l'ignorer.

$ sudo useradd -m -s /usr/bin/bash k8suser
$ sudo passwd k8suser          #changer le mot de passe
New password:
Retype new password:
passwd: password updated successfully

$ sudo adduser k8suser sudo     #Ajouter k8suser au groupe sudo
Adding user `k8suser' to group `sudo' ...
Adding user k8suser to group sudo
Done.
$ cat /etc/group | grep sudo   #Confirmer
#Shift pour les paramètres du clavier anglais+ }Mais"|"devenir
sudo:x:27:ubuntu,k8user

Interdit la connexion pour le compte par défaut (ubuntu).

$ sudo usermod -s /usr/sbin/nologin ubuntu
$ cat /etc/passwd | grep ubuntu   #Confirmer
ubuntu:x:1000:1000:Ubuntu:/home/ubuntu:/usr/sbin/nologin

Paramètres du système d'exploitation du nœud maître

Définissez les paramètres autour du réseau Master Node.

Changer le nom d'hôte (exécuté sur le nœud maître)

$ sudo hostnamectl set-hostname master01.example.jp
$ hostname    #Confirmer
master01.example.jp

Modifier l'adresse IP (exécuter sur le nœud maître)

#Pour les paramètres du clavier anglais, ce sera comme suit
# Shift + ;Mais":」
# @Mais"[」
# [Mais"]」
$ sudo vi /etc/netplan/99-network.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: false
      dhcp6: false
      addresses:
        - 192.168.100.101/24
      gateway4: 192.168.100.254
      nameservers:
        addresses:
          - 192.168.100.254

$ sudo netplan apply
$ ip a    #Confirmation:「eth0:Confirmez que l'adresse IP est reflétée dans "inet" de

Connectez-vous à master01.example.jp avec SSH.

point d'accès	Nom d'utilisateur	mot de passe
192.168.100.101	k8suser	Définir le mot de passe

Paramètres du système d'exploitation Worker Node 1

Configurez les paramètres autour du réseau Worker Node 1.

Modifier le nom d'hôte (exécuté sur le nœud de travail 1)

$ sudo hostnamectl set-hostname worker01.example.jp
$ hostname    #Confirmation
worker01.example.jp

Modifier l'adresse IP (exécuter sur le nœud de travail 1)

#Pour les paramètres du clavier anglais, ce sera comme suit
# Shift + ;Mais":」
# @Mais"[」
# [Mais"]」
$ sudo vi /etc/netplan/99-network.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: false
      dhcp6: false
      addresses:
        - 192.168.100.102/24
      gateway4: 192.168.100.254
      nameservers:
        addresses:
          - 192.168.100.254

$ sudo netplan apply
$ ip a    #Confirmation:「eth0:Confirmez que l'adresse IP est reflétée dans "inet" de

Connectez-vous à worker01.example.jp avec SSH.

point d'accès	Nom d'utilisateur	mot de passe
192.168.100.102	k8suser	Définir le mot de passe

Paramètres du système d'exploitation Worker Node 2

Configurez les paramètres autour du réseau Worker Node 2.

Modifier le nom d'hôte (exécuté sur le nœud de travail 2)

$ sudo hostnamectl set-hostname worker02.example.jp
$ hostname    #Confirmer
worker02.example.jp

Modifier l'adresse IP (exécuter sur le nœud de travail 2)

#Pour les paramètres du clavier anglais, ce sera comme suit
# Shift + ;Mais":」
# @Mais"[」
# [Mais"]」
$ vi /etc/netplan/99-network.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: false
      dhcp6: false
      addresses:
        - 192.168.100.103/24
      gateway4: 192.168.100.254
      nameservers:
        addresses:
          - 192.168.100.254

$ sudo netplan apply
$ ip a    #Confirmation:「eth0:Confirmez que l'adresse IP est reflétée dans "inet" de

Connectez-vous à worker02.example.jp avec SSH.

point d'accès	Nom d'utilisateur	mot de passe
192.168.100.103	k8suser	Définir le mot de passe

Paramètres du système d'exploitation communs aux trois

Pour le reste du travail, connectez-vous avec SSH et continuez à configurer le système d'exploitation. Lorsque j'exécute Kubernetes, le swap doit être arrêté, mais le swap ne fonctionnait pas. Est-ce parce que c'est pour la tarte aux râpes?

$ free
              total        used        free      shared  buff/cache   available
Mem:        3884360      961332      152584        5184     2770444     2973200
Swap:             0           0           0      #Swap est 0

Mettre à jour le package existant (commun aux 3 unités)

$ sudo apt update
$ sudo apt -y upgrade

Modifier le fichier d'hôtes (commun aux 3)

$ sudo vi /etc/hosts
#Ajouter
192.168.100.101       master01 master01.example.jp
192.168.100.102       worker01 worker01.example.jp
192.168.100.103       worker02 worker02.example.jp
$ cat /etc/hosts    #Confirmer

Changer de fuseau horaire (commun aux 3 unités)

$ sudo timedatectl set-timezone Asia/Tokyo
$ timedatectl | grep Time    #Confirmer
                Time zone: Asia/Tokyo (JST, +0900)

Changer le keymap (commun à 3 unités)

$ sudo localectl set-keymap jp106
$ localectl    #Confirmer
   System Locale: LANG=C.UTF-8
       VC Keymap: jp106
      X11 Layout: jp
       X11 Model: jp106
     X11 Options: terminate:ctrl_alt_bksp

Arrêtez IPv6 (commun aux 3 unités)

$ sudo vi /etc/sysctl.conf
#Ajouter
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.eth0.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1
$ sudo sysctl -p
$ ip a    #Confirmer. inet6 ne s'affiche pas.

Empêcher iptables d'utiliser le backend nftables (commun aux trois)

[Empêcher iptables d'utiliser le backend nftables](https://kubernetes.io/en/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#iptables%E3%81%8Cnftables%E3 % 83% 90% E3% 83% 83% E3% 82% AF% E3% 82% A8% E3% 83% B3% E3% 83% 89% E3% 82% 92% E4% BD% BF% E7% 94 % A8% E3% 81% 97% E3% 81% AA% E3% 81% 84% E3% 82% 88% E3% 81% 86% E3% 81% AB% E3% 81% 99% E3% 82% 8B ) Reportez-vous au réglage.

$ sudo apt-get -y install iptables arptables ebtables
$ sudo update-alternatives --set iptables /usr/sbin/iptables-legacy
$ sudo update-alternatives --set ip6tables /usr/sbin/ip6tables-legacy
$ sudo update-alternatives --set arptables /usr/sbin/arptables-legacy
update-alternatives: using /usr/sbin/arptables-legacy to provide /usr/sbin/arptables (arptables) in manual mode
$ sudo update-alternatives --set ebtables /usr/sbin/ebtables-legacy
update-alternatives: using /usr/sbin/ebtables-legacy to provide /usr/sbin/ebtables (ebtables) in manual mode

Installation de Docker (commun aux 3 unités)

Installez en vous référant à Installer Docker Engine sur Ubuntu.

$ sudo apt-get -y install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
$ sudo add-apt-repository "deb [arch=arm64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
$ sudo apt-get update
$ sudo apt-get -y install docker-ce docker-ce-cli containerd.io
$ sudo apt-mark hold docker-ce docker-ce-cli containerd.io
docker-ce set on hold.
docker-ce-cli set on hold.
containerd.io set on hold.

L'affectation d'utilisateurs au groupe docker n'est pas bonne pour la sécurité, mais c'est pour les tests.

$ sudo adduser k8suser docker
Adding user `k8suser' to group `docker' ...
Adding user k8suser to group docker
Done.
$ cat /etc/group | grep docker    #Confirmation
docker:x:998:k8suser

Déconnectez-vous et connectez-vous pour l'affectation de groupe. Vérifiez la version de Docker.

$ docker version
Client: Docker Engine - Community
 Version:           19.03.13
 API version:       1.40
 Go version:        go1.13.15
 Git commit:        4484c46
 Built:             Wed Sep 16 17:03:40 2020
 OS/Arch:           linux/arm64
 Experimental:      false

Server: Docker Engine - Community
 Engine:
  Version:          19.03.13
  API version:      1.40 (minimum version 1.12)
  Go version:       go1.13.15
  Git commit:       4484c46
  Built:            Wed Sep 16 17:02:11 2020
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.3.7
  GitCommit:        8fba4e9a7d01810a393d5d25a3621dc101981175
 runc:
  Version:          1.0.0-rc10
  GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
 docker-init:
  Version:          0.18.0
  GitCommit:        fec3683

Vérifiez le fonctionnement de Docker. Démarrez le conteneur hello-world.

$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
256ab8fe8778: Pull complete
Digest: sha256:8c5aeeb6a5f3ba4883347d3747a7249f491766ca1caa47e5da5dfcf6b9b717c0
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Installation de kubeadm, kubectl, kubelet (commun aux 3 unités)

[Installez kubeadm, kubelet, kubectl](https://kubernetes.io/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#kubeadm-kubelet-kubectl%E3%81%AE%E3 Installer en se référant à% 82% A4% E3% 83% B3% E3% 82% B9% E3% 83% 88% E3% 83% BC% E3% 83% AB).

$ sudo apt-get update && sudo apt-get -y install apt-transport-https curl
$ curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
$ cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://apt.kubernetes.io/ kubernetes-xenial main
EOF
$ sudo apt-get update
$ sudo apt-get -y install kubelet kubeadm kubectl
$ sudo apt-mark hold kubelet kubeadm kubectl
kubelet set on hold.
kubeadm set on hold.
kubectl set on hold.

Vérifiez la version de chaque module.

$ kubeadm version -o json
{
  "clientVersion": {
    "major": "1",
    "minor": "19",
    "gitVersion": "v1.19.3",
    "gitCommit": "1e11e4a2108024935ecfcb2912226cedeafd99df",
    "gitTreeState": "clean",
    "buildDate": "2020-10-14T12:47:53Z",
    "goVersion": "go1.15.2",
    "compiler": "gc",
    "platform": "linux/arm64"
  }
}

$ kubectl version -o json
{
  "clientVersion": {
    "major": "1",
    "minor": "19",
    "gitVersion": "v1.19.3",
    "gitCommit": "1e11e4a2108024935ecfcb2912226cedeafd99df",
    "gitTreeState": "clean",
    "buildDate": "2020-10-14T12:50:19Z",
    "goVersion": "go1.15.2",
    "compiler": "gc",
    "platform": "linux/arm64"
  }
}
The connection to the server localhost:8080 was refused - did you specify the right host or port?

$ kubelet --version
Kubernetes v1.19.3

kubectl version -o jsonUniquement message lors de l'exécution(la connexion au serveur ・・・)Est affiché, mais nous y reviendrons plus tard.

Activer la mémoire avec cgruop (commun aux 3 unités)

enable est égal à 0. (Le dernier 0 est la colonne activée)

$ cat /proc/cgroups | grep memory
memory  0       105     0

Défini en vous référant à Installation de Kubernetes sur un cluster Raspeye (succès).

Ajoutez à /boot/firmware/cmdline.txt. Ajout en fin de ligne. C'est un fichier d'une seule ligne.

$ sudo vi /boot/firmware/cmdline.txt
cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory    #Ajouter
$ cat /boot/firmware/cmdline.txt    #Confirmer
net.ifnames=0 dwc_otg.lpm_enable=0 console=serial0,115200 console=tty1 root=LABEL=writable rootfstype=ext4 elevator=deadline rootwait fixrtc cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory

Redémarrer.

$ sudo reboot

Vérifiez quand le système d'exploitation démarre.

$ cat /proc/cgroups | grep memory
memory  10      97      1

enable est 1, ce qui signifie qu'il est activé.

Créer un cluster Kubernetes

C'est enfin le décor de Kubernetes. Tout d'abord, initialisez le nœud maître.

Configurez en vous référant à la documentation Kubernetes.

Initialisation du nœud maître (exécuté sur le nœud maître)

À propos des options

apiserver-advertise-address=192.168.100.101
Adresse IP du serveur API. Dans ce cas, l'adresse IP du nœud maître. --Doit être spécifié s'il y a plusieurs cartes réseau.
Il n'y en a pas plus d'un, mais il est précisé par souci de clarté.
pod-network-cidr=10.244.0.0/16 --Spécification pour la flanelle.

Effectuez l'initialisation.

$ sudo kubeadm init --apiserver-advertise-address=192.168.100.101 --pod-network-cidr=10.244.0.0/16
W1107 17:43:47.125493    2544 configset.go:348] WARNING: kubeadm cannot validate component configs for API groups [kubelet.config.k8s.io kubeproxy.config.k8s.io]
[init] Using Kubernetes version: v1.19.3
[preflight] Running pre-flight checks
        [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/
        [WARNING SystemVerification]: missing optional cgroups: hugetlb
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local master01.example.jp] and IPs [10.96.0.1 192.168.100.101]
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "front-proxy-ca" certificate and key
[certs] Generating "front-proxy-client" certificate and key
[certs] Generating "etcd/ca" certificate and key
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [localhost master01.example.jp] and IPs [192.168.100.101 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [localhost master01.example.jp] and IPs [192.168.100.101 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "sa" key and public key
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "kubelet.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Starting the kubelet
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
[control-plane] Creating static Pod manifest for "kube-scheduler"
[etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
[wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s
[apiclient] All control plane components are healthy after 35.510569 seconds
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.19" in namespace kube-system with the configuration for the kubelets in the cluster
[upload-certs] Skipping phase. Please see --upload-certs
[mark-control-plane] Marking the node master01.example.jp as control-plane by adding the label "node-role.kubernetes.io/master=''"
[mark-control-plane] Marking the node master01.example.jp as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[bootstrap-token] Using token: vpkasj.i7pe42jx57scb3bi
[bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to get nodes
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstrap-token] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstrap-token] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace
[kubelet-finalize] Updating "/etc/kubernetes/kubelet.conf" to point to a rotatable kubelet client certificate and key
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.100.101:6443 --token vpkasj.i7pe42jx57scb3bi \
    --discovery-token-ca-cert-hash sha256:3646aa901c623280b56d8ec33873263a5e3452a979f594c0f628724ed9fe9cce

Le dernier `` kubeadm join ・・・ '' est requis lors de l'ajout d'un nœud de travail, alors enregistrez-le quelque part. De plus, après 24 heures, le jeton ne sera pas disponible.

Il s'agit d'une méthode pour vérifier le temps restant du jeton et le réémettre, mais si vous exécutez la commande à ce stade, une erreur se produira, elle sera donc décrite plus tard.

Définition des variables d'environnement et saisie complète (exécutée sur le nœud maître)

Définissez les variables d'environnement. kubectl version -o jsonMessage d'exécution(la connexion au serveur ・・・)Ne sera pas affiché en réglant les éléments suivants.

$ mkdir -p $HOME/.kube
$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
$ sudo chown $(id -u):$(id -g) $HOME/.kube/config
$ echo 'KUBECONFIG=$HOME/.kube/config' >> $HOME/.bashrc
$ source $HOME/.bashrc
$ kubectl version -o json
#Vérifiez que "La connexion au serveur ..." ne s'affiche pas.

Définit l'achèvement de la commande.

$ source <(kubectl completion bash)
$ echo "source <(kubectl completion bash)" >> $HOME/.bashrc

À propos du jeton de jointure kubeadm (exécuté sur le nœud maître)

À propos du jeton que j'ai mentionné plus tard. Si vous souhaitez vérifier le temps restant, exécutez la commande `` kubeadm token list ''. Si rien ne s'affiche, il n'y a pas de jeton valide.

$ kubeadm token list
TOKEN                     TTL         EXPIRES                     USAGES                   DESCRIPTION                                                EXTRA GROUPS
2jdf77.0ww7uv0w2hodm99i   23h         2020-10-31T22:09:03+09:00   authentication,signing   The default bootstrap token generated by 'kubeadm init'.

Si vous souhaitez réémettre le jeton, exécutez la commande `` kubeadm token create ''.

$ sudo kubeadm token create
W1101 14:37:16.210067  508855 configset.go:348] WARNING: kubeadm cannot validate component configs for API groups [kubelet.config.k8s.io kubeproxy.config.k8s.io]
2jdf77.0ww7uv0w2hodm99i  #C'est un jeton

Si vous souhaitez vérifier le hachage du certificat CA, exécutez la commande `` openssl```. Il est écrit dans Création d'un cluster de plan de contrôle unique à l'aide de kubeadm. Je vais.

$ openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | \
   openssl dgst -sha256 -hex | sed 's/^.* //'
3646aa901c623280b56d8ec33873263a5e3452a979f594c0f628724ed9fe9cce  #Ceci est le hachage du certificat CA

Installer le module complémentaire de réseau de pod (exécuter sur le nœud maître)

Définissez la flanelle comme module complémentaire pour permettre aux pods de communiquer entre eux. J'ai choisi la flanelle, qui a un bon bilan. Installez en vous référant à ce qui suit.

$ curl https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml -O
$ kubectl apply -f kube-flannel.yml
podsecuritypolicy.policy/psp.flannel.unprivileged created
clusterrole.rbac.authorization.k8s.io/flannel created
clusterrolebinding.rbac.authorization.k8s.io/flannel created
serviceaccount/flannel created
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds created

Confirmez le démarrage. Vous pouvez voir kube-flannel-ds-XXXXX.

$ kubectl get pods -n kube-system
NAME                                          READY   STATUS    RESTARTS   AGE
coredns-f9fd979d6-trgnz                       1/1     Running   0          5m54s
coredns-f9fd979d6-w7zvv                       1/1     Running   0          5m54s
etcd-master01.example.jp                      1/1     Running   0          5m58s
kube-apiserver-master01.example.jp            1/1     Running   0          5m59s
kube-controller-manager-master01.example.jp   1/1     Running   0          5m59s
kube-flannel-ds-bmvz4                         1/1     Running   0          61s
kube-proxy-6rhgr                              1/1     Running   0          5m54s
kube-scheduler-master01.example.jp            1/1     Running   0          5m58s

Installer LoadBalancer (exécuter sur le nœud maître)

Utilisez MetalLB. J'ai choisi les fonctionnalités suivantes.

Vous pouvez utiliser le service de type LoadBalancer dans un environnement sur site
Une adresse IP externe peut être attribuée

Il se compose de deux types de pods, contrôleur et haut-parleur.

Installez en vous référant à MetalLB, équilibreur de charge bare metal pour Kubernetes.

$ curl https://raw.githubusercontent.com/metallb/metallb/v0.9.4/manifests/namespace.yaml -o namespace.yaml
$ curl https://raw.githubusercontent.com/metallb/metallb/v0.9.4/manifests/metallb.yaml -o metallb.yaml
$ kubectl apply -f namespace.yaml
namespace/metallb-system created
$ kubectl apply -f metallb.yaml
podsecuritypolicy.policy/controller created
podsecuritypolicy.policy/speaker created
serviceaccount/controller created
serviceaccount/speaker created
clusterrole.rbac.authorization.k8s.io/metallb-system:controller created
clusterrole.rbac.authorization.k8s.io/metallb-system:speaker created
role.rbac.authorization.k8s.io/config-watcher created
role.rbac.authorization.k8s.io/pod-lister created
clusterrolebinding.rbac.authorization.k8s.io/metallb-system:controller created
clusterrolebinding.rbac.authorization.k8s.io/metallb-system:speaker created
rolebinding.rbac.authorization.k8s.io/config-watcher created
rolebinding.rbac.authorization.k8s.io/pod-lister created
daemonset.apps/speaker created
deployment.apps/controller created
$ kubectl create secret generic -n metallb-system memberlist --from-literal=secretkey="$(openssl rand -base64 128)"
secret/memberlist created

Confirmez le démarrage. Vous pouvez voir controller-XXXXXXXXX-XXXXX et speaker-XXXXX.

$ kubectl get pod -n metallb-system
NAME                         READY   STATUS    RESTARTS   AGE
controller-8687cdc65-jgf2g   0/1     Pending   0          54s
speaker-q9ksw                1/1     Running   0          54s

le contrôleur ne fonctionne pas en attente. Comme indiqué dans MetalLB, équilibreur de charge bare metal pour Kubernetes, le contrôleur est Deployment. Comme je n'ai pas encore enregistré de nœud de travail, je n'ai pas de nœud de travail capable d'exécuter le pod. Puisque le locuteur est un DaemonSet, il sera démarré par tous les nœuds (maître, travailleur). Maintenant, il fonctionne sur Master Node. (Après avoir ajouté le nœud de travail, commencez 3 au total)

Joindre le nœud de travail au cluster (Exécuter sur le nœud de travail1, nœud de travail2)

Exécutez la commande enregistrée lors de l'initialisation du nœud maître. Si vous l'oubliez, il sera réédité.

Si vous copiez et collez le message, veuillez noter que `` sudo '' n'est pas joint.

$ sudo kubeadm join 192.168.100.101:6443 --token vpkasj.i7pe42jx57scb3bi \
    --discovery-token-ca-cert-hash sha256:3646aa901c623280b56d8ec33873263a5e3452a979f594c0f628724ed9fe9cce
[sudo] password for user01:
[preflight] Running pre-flight checks
        [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/
        [WARNING SystemVerification]: missing optional cgroups: hugetlb
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml'
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Starting the kubelet
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

Confirmation d'un nœud de travail supplémentaire (exécuté sur le nœud maître)

La confirmation est effectuée sur le nœud maître. L'exécution du nœud de travail a pris moins de 5 minutes.

$ kubectl get nodes
NAME                  STATUS   ROLES    AGE     VERSION
master01.example.jp   Ready    master   14m     v1.19.3
worker01.example.jp   Ready    <none>   4m59s   v1.19.3
worker02.example.jp   Ready    <none>   4m33s   v1.19.3
$ kubectl get pods -A
NAMESPACE        NAME                                          READY   STATUS    RESTARTS   AGE
kube-system      coredns-f9fd979d6-trgnz                       1/1     Running   0          14m
kube-system      coredns-f9fd979d6-w7zvv                       1/1     Running   0          14m
kube-system      etcd-master01.example.jp                      1/1     Running   0          15m
kube-system      kube-apiserver-master01.example.jp            1/1     Running   0          15m
kube-system      kube-controller-manager-master01.example.jp   1/1     Running   0          15m
kube-system      kube-flannel-ds-bmvz4                         1/1     Running   0          10m
kube-system      kube-flannel-ds-mwmt6                         1/1     Running   0          6m9s
kube-system      kube-flannel-ds-zm2fk                         1/1     Running   0          5m43s
kube-system      kube-proxy-6rhgr                              1/1     Running   0          14m
kube-system      kube-proxy-b8fjn                              1/1     Running   0          6m9s
kube-system      kube-proxy-htndc                              1/1     Running   0          5m43s
kube-system      kube-scheduler-master01.example.jp            1/1     Running   0          15m
metallb-system   controller-8687cdc65-jgf2g                    1/1     Running   0          8m7s
metallb-system   speaker-q9ksw                                 1/1     Running   0          8m7s
metallb-system   speaker-vmt52                                 1/1     Running   0          79s
metallb-system   speaker-wkcz4                                 1/1     Running   0          2m16s

Le contrôleur qui était en attente est maintenant en cours d'exécution. kube-flannel-ds-XXXXX, kube-proxy-XXXXX, speaker-XXXXX sont augmentés du nombre de nœuds de travail.

Définir le libellé sur le nœud de travail (exécuter sur le nœud maître)

$ kubectl label node worker01.example.jp node-role.kubernetes.io/worker=worker
node/worker01.example.jp labeled
$ kubectl label node worker02.example.jp node-role.kubernetes.io/worker=worker
node/worker02.example.jp labeled
$ kubectl get nodes  #Confirmer
NAME                  STATUS   ROLES    AGE     VERSION
master01.example.jp   Ready    master   16m     v1.19.3
worker01.example.jp   Ready    worker   7m22s   v1.19.3
worker02.example.jp   Ready    worker   6m56s   v1.19.3

Exécuter un conteneur avec Kubernetes

Pour vérifier l'opération, utilisez l'image du conteneur Nginx qui renvoie le nom d'hôte de l'hôte sur lequel Docker est en cours d'exécution.

`display-hostname.yaml`


apiVersion: v1
kind: Namespace
metadata:
  name: nginx-prod
---
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: pool-ips  #Nom du pool IP Metallb
      protocol: layer2
      addresses:
      - 192.168.100.211-192.168.100.215
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service-lb # Service(LoadBalancer)Le nom de
  namespace: nginx-prod
  annotations:
    metallb.universe.tf/address-pool: pool-ips #Nom du pool IP Metallb
spec:
  type: LoadBalancer
  ports:
    - name: nginx-service-lb
      protocol: TCP
      port: 8080 #Port pour écouter sur l'IP de service
      nodePort: 30080 #Port pour écouter sur l'IP du nœud (30000)-32767）
      targetPort: 80 #Destination de transfert(récipient)Le port du numéro de port écoutant
  selector: #le sélecteur de service est traité comme matchLabels
    app: nginx-pod #Libellé du pod de destination
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment #Nom du déploiement(C'est aussi le nom du ReplicaSet)
  namespace: nginx-prod
spec:
  selector:
    matchLabels: #Création d'un ReplicaSet pour les pods avec des étiquettes correspondantes
      app: nginx-pod
  replicas: 2
  template: #Modèle de pod
    metadata:
      name: nginx-pod #Nom du pod
      namespace: nginx-prod
      labels: #Étiquette du pod
        app: nginx-pod
    spec:
      containers: #Paramètres du conteneur
        - name: nginx-container #Le nom du conteneur
          image: yasthon/nginx-display-hostname #Nom de l'image
          env:
            - name: nginx-container
          ports:
            - containerPort: 80 #Port à conteneurs
          volumeMounts:
            - name: file-hostname
              mountPath: /usr/share/nginx/html/hostname
      volumes:
        - name: file-hostname
          hostPath:
            path: /etc/hostname

Créez une ressource.

$ kubectl apply -f display-hostname.yaml
namespace/nginx-prod created
configmap/config created
service/nginx-service-lb created
deployment.apps/nginx-deployment created
$ kubectl get all -n nginx-prod  #Confirmer
NAME                                    READY   STATUS    RESTARTS   AGE
pod/nginx-deployment-7ff4cc65cd-5bkv5   1/1     Running   0          3m33s
pod/nginx-deployment-7ff4cc65cd-xsp76   1/1     Running   0          3m33s

NAME                       TYPE           CLUSTER-IP    EXTERNAL-IP       PORT(S)          AGE
service/nginx-service-lb   LoadBalancer   10.97.27.72   192.168.100.211   8080:30080/TCP   3m33s

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx-deployment   2/2     2            2           3m33s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx-deployment-7ff4cc65cd   2         2         2       3m33s

$ kubectl get configmap -n metallb-system  #Confirmer
NAME     DATA   AGE
config   1      3m57s

Pod, Service, Deployment, ReplicaSet, ConfigMap ont été créés. Le service EXTERNAL-IP a été attribué à partir du pool IP.

Vérifiez les valeurs LoadBalancer Ingress et Port dans les détails du service.

$ kubectl describe svc nginx-service-lb -n nginx-prod
Name:                     nginx-service-lb
Namespace:                nginx-prod
Labels:                   <none>
Annotations:              metallb.universe.tf/address-pool: pool-ips
Selector:                 app=nginx-pod
Type:                     LoadBalancer
IP:                       10.97.27.72
LoadBalancer Ingress:     192.168.100.211
Port:                     nginx-service-lb  8080/TCP
TargetPort:               80/TCP
NodePort:                 nginx-service-lb  30080/TCP
Endpoints:                10.244.1.4:80,10.244.2.3:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
  Type    Reason        Age                    From                Message
  ----    ------        ----                   ----                -------
  Normal  IPAllocated   6m43s                  metallb-controller  Assigned IP "192.168.100.211"
  Normal  nodeAssigned  6m29s                  metallb-speaker     announcing from node "worker01.example.jp"
  Normal  nodeAssigned  6m15s (x2 over 6m36s)  metallb-speaker     announcing from node "worker02.example.jp"

L'adresse IP de LoadBalancer Ingress est la même que EXTERNAL-IP. (x2 over 59s)Qu'est-ce que l'affichage de?Attribué deux fois?La première fois a pris du temps?? Cela ne semble pas interférer avec l'opération. Il peut ne pas s'afficher.

Confirmation de connexion

Connectez-vous à l'adresse IP de LoadBalancer Ingress et au numéro de port du port.

$ curl 192.168.100.211:8080/index.sh
<html><head>
<title>worker01.example.jp</title>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
</head><body>
HOSTNAME : worker01.example.jp
</body></html>

Si vous répétez la commande curl plusieurs fois, la destination de la connexion deviendra worker02.example.jp. Il sera équilibré en charge. Cela ne semble pas être un simple tournoi à la ronde.

Essayez d'arrêter Worker Node 2

J'ai débranché le câble Ether pour Worker Node2 et ai exécuté la commande curl. La commande a été exécutée sur le nœud maître.

$ curl 192.168.100.211:8080/index.sh
<html><head>
<title>worker01.example.jp</title>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
</head><body>
HOSTNAME : worker01.example.jp
</body></html>

$ curl 192.168.100.211:8080/index.sh
<html><head>
<title>worker01.example.jp</title>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
</head><body>
HOSTNAME : worker01.example.jp
</body></html>

Bien sûr, j'accède uniquement à worker01.example.jp.

Essayez d'arrêter Worker Node1

Rebranchez le câble Ether pour Worker Node2. J'ai débranché le câble Ether pour Worker Node1 et ai exécuté la commande curl.

$ curl 192.168.100.211:8080/index.sh
<html><head>
<title>worker02.example.jp</title>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
</head><body>
HOSTNAME : worker02.example.jp
</body></html>

$ curl 192.168.100.211:8080/index.sh
<html><head>
<title>worker02.example.jp</title>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
</head><body>
HOSTNAME : worker02.example.jp
</body></html>

Je ne peux me connecter qu'à Worker Node2. Si vous reconnectez le câble Ether du Worker Node1, il sera connecté aux deux Worker Nodes.

Il travaille pour y accéder, sauf pour les travailleurs devenus inaccessibles.

Aussi depuis le navigateur

`http://192.168.100.211:8080/index.sh`


 Vous pouvez y accéder avec.
 Lorsqu'il est accessible à partir d'un navigateur, il est fermement fixé.
 Même si vous appuyez sur Ctrl + f5 à plusieurs reprises, la destination de la connexion ne change pas ...
 Lorsque je débranche le câble, il se connecte à un autre nœud de travail, donc Load Balancer semble fonctionner.

## Nettoyage de cluster

 Si, pour une raison quelconque, vous souhaitez recréer le cluster, effectuez un nettoyage.
 Je fais référence à ce qui suit.

 - [Création d'un cluster de plan de contrôle unique à l'aide de kubeadm](https://kubernetes.io/en/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/#tear-down),
 - [Dépannage de kubeadm-kubeadm se bloque lors de la suppression du conteneur géré](https://kubernetes.io/ja/docs/setup/production-environment/tools/kubeadm/troubleshooting-kubeadm/#%E7%AE% A1% E7% 90% 86% E3% 82% B3% E3% 83% B3% E3% 83% 86% E3% 83% 8A% E3% 82% 92% E5% 89% 8A% E9% 99% A4% E3% 81% 99% E3% 82% 8B% E6% 99% 82% E3% 81% ABkubeadm% E3% 81% 8C% E6% AD% A2% E3% 81% BE% E3% 82% 8B)



### Supprimer le nœud (exécuté sur le nœud maître)

```bash
$ kubectl get nodes
NAME                  STATUS   ROLES    AGE    VERSION
master01.example.jp   Ready    master   8d     v1.19.3
worker01.example.jp   Ready    worker   2d8h   v1.19.3
worker02.example.jp   Ready    worker   2d8h   v1.19.3

$ kubectl drain worker01.example.jp --delete-local-data --force --ignore-daemonsets
node/worker01.example.jp cordoned
WARNING: ignoring DaemonSet-managed Pods: kube-system/kube-flannel-ds-brt9l, kube-system/kube-proxy-5pch5, metallb-system/speaker-4n2xx
evicting pod metallb-system/controller-8687cdc65-cn48m
pod/controller-8687cdc65-cn48m evicted
node/worker01.example.jp evicted

$ kubectl drain worker02.example.jp --delete-local-data --force --ignore-daemonsets
node/worker02.example.jp cordoned
WARNING: ignoring DaemonSet-managed Pods: kube-system/kube-flannel-ds-tdg4l, kube-system/kube-proxy-k56gw, metallb-system/speaker-qdv85
evicting pod metallb-system/controller-8687cdc65-nkvvn
pod/controller-8687cdc65-nkvvn evicted
node/worker02.example.jp evicted

$ kubectl delete node worker01.example.jp
node "worker01.example.jp" deleted

$ kubectl delete node worker02.example.jp
ode "worker02.example.jp" deleted

$ kubectl get nodes    #Confirmer
NAME                  STATUS   ROLES    AGE   VERSION
master01.example.jp   Ready    master   8d    v1.19.3

Réinitialiser le nœud de travail (exécuter sur le nœud de travail1, nœud de travail2)

$ sudo kubeadm reset
[reset] WARNING: Changes made to this host by 'kubeadm init' or 'kubeadm join' will be reverted.
[reset] Are you sure you want to proceed? [y/N]: y    #Entrez y
[preflight] Running pre-flight checks
W1104 20:37:31.440013 1890335 removeetcdmember.go:79] [reset] No kubeadm config, using etcd pod spec to get data directory
[reset] No etcd config found. Assuming external etcd
[reset] Please, manually reset etcd to prevent further issues
[reset] Stopping the kubelet service
[reset] Unmounting mounted directories in "/var/lib/kubelet"
[reset] Deleting contents of config directories: [/etc/kubernetes/manifests /etc/kubernetes/pki]
[reset] Deleting files: [/etc/kubernetes/admin.conf /etc/kubernetes/kubelet.conf /etc/kubernetes/bootstrap-kubelet.conf /etc/kubernetes/controller-manager.conf /etc/kubernetes/scheduler.conf]
[reset] Deleting contents of stateful directories: [/var/lib/kubelet /var/lib/dockershim /var/run/kubernetes /var/lib/cni]

The reset process does not clean CNI configuration. To do so, you must remove /etc/cni/net.d

The reset process does not reset or clean up iptables rules or IPVS tables.
If you wish to reset iptables, you must do so manually by using the "iptables" command.

If your cluster was setup to utilize IPVS, run ipvsadm --clear (or similar)
to reset your system's IPVS tables.

The reset process does not clean your kubeconfig files and you must remove them manually.
Please, check the contents of the $HOME/.kube/config file.

Effectue le traitement décrit dans le message.

Supprimez la configuration CNI.

$ sudo rm -rf /etc/cni/net.d

Les règles liées à Kubernetes restent dans iptables, supprimez-les.

$ sudo iptables -L -n
#Vous verrez de nombreuses règles liées à Kubernetes.
$ sudo iptables -F && sudo iptables -t nat -F && sudo iptables -t mangle -F && sudo iptables -X
$ sudo iptables -L -n    #Confirmer
Chain INPUT (policy ACCEPT)
target     prot opt source               destination

Chain FORWARD (policy DROP)
target     prot opt source               destination

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination

Réinitialiser le nœud maître (exécuter sur le nœud maître)

$ sudo systemctl restart docker.service
$ sudo kubeadm reset
$ sudo rm -rf /etc/cni/net.d
$ sudo iptables -L -n
$ sudo iptables -F && sudo iptables -t nat -F && sudo iptables -t mangle -F && sudo iptables -X
$ sudo iptables -L -n    #Confirmer

Après le nettoyage, exécutez la commande `` sudo kubeadm init '' pour créer le cluster.

Exécuter le pod sur le nœud maître (exécuter sur le nœud maître)

Vous pouvez exécuter des pods sur le nœud maître. Les paramètres par défaut ne sont pas planifiés sur le nœud maître.

$ kubectl describe node master01 | grep Taints
Taints:             node-role.kubernetes.io/master:NoSchedule

Désactivez le paramètre NoSchedule pour que le pod fonctionne également sur le nœud maître. Ajouter "-" (trait d'union) après le maître: NoSchedule.

$ kubectl taint nodes master01.example.jp node-role.kubernetes.io/master:NoSchedule-
node/master01.example.jp untainted
$ kubectl describe node master01 | grep Taints    #Confirmer
Taints:             <none>

`kind:Répliques de déploiement:Changer 2 en 3`

$ vi display-hostname.yaml replicas: 3 #Changer 2 en 3

$ kubectl apply -f display-hostname.yaml namespace/nginx-prod unchanged configmap/config unchanged service/nginx-service-lb unchanged deployment.apps/nginx-deployment configured $ kubectl get pod -n nginx-prod #Confirmer NAME READY STATUS RESTARTS AGE nginx-deployment-7ff4cc65cd-5f85p 1/1 Running 0 39m nginx-deployment-7ff4cc65cd-lm782 0/1 ContainerCreating 0 38s nginx-deployment-7ff4cc65cd-nrhl7 1/1 Running 0 39m


 Le pod du milieu que vous essayez de démarrer est le pod qui s'exécute sur le nœud maître.
 Même dans les informations détaillées, vous pouvez confirmer qu'il est démarré avec master01.example.jp.

$ kubectl describe pod/nginx-deployment-7ff4cc65cd-lm782 -n nginx-prod | grep ^Node: Node: master01.example.jp/192.168.128.193


 Si vous souhaitez empêcher les pods de fonctionner sur le nœud maître, redéfinissez le nombre de pods sur deux.
``display-hostname.yaml```de```replicas:```Est remis à 2.

```bash
$ vi display-hostname.yaml
 répliques: remplacez 2 # 3 par 2

$ kubectl apply -f display-hostname.yaml
namespace/nginx-prod unchanged
configmap/config unchanged
service/nginx-service-lb unchanged
deployment.apps/nginx-deployment configured
 $ kubectl get pod -n nginx-prod # Vérifier
NAME                                READY   STATUS        RESTARTS   AGE
nginx-deployment-7ff4cc65cd-5f85p   1/1     Running       0          47m
nginx-deployment-7ff4cc65cd-lm782   1/1     Terminating   0          8m32s
nginx-deployment-7ff4cc65cd-nrhl7   1/1     Running       0          47m

Le pod du milieu qui a été lancé plus tôt est sur le point de sortir.

Définissez NoSchedule.

$ kubectl taint nodes master01.example.jp node-role.kubernetes.io/master:NoSchedule
node/master01.example.jp tainted
 $ kubectl describe node master01 | grep Taints # Check
Taints:             node-role.kubernetes.io/master:NoSchedule

NoSchedule est défini et le pod ne fonctionne plus sur le nœud maître.

##finalement

J'ai pu créer un environnement de cluster Kubernetes avec Raspeye. C'est un bon moment. Par rapport à l'achat de plus de serveurs et de PC, c'est une bonne affaire. Tout ce que vous avez à faire est de jouer.

##URL de référence

C'est un article que j'ai utilisé comme référence.

J'ai essayé de créer un cluster Kubernetes avec une tarte aux framboises ~ avec un élégant câble en tissu ~
Faisons une maison Kubernetes avec Raspberry Pi 4 (version compatible Raspbian Buster Lite)
Kubernetes Dojo Jour 1-Présentation de Kubernetes- Toku's Blog* Le lien est le 1er jour, mais il est disponible jusqu'au 25ème jour.

Ceci est un article de référence avec un lien dans le texte.