[DOCKER] Installieren Sie Ubuntu20.04 auf RaspberryPi 4 und erstellen Sie Kubernetes, um den Container auszuführen

Einführung

Ich wollte eine Testumgebung für Kubernetes und habe sie erstellt. Es ist eine Menge, die herauskommt, wenn Sie googeln. 3 Tage kochen [Kubernetes 'Himbeerkuchenverpackung "Cyber Agent Style"] fand ich köstlich.

Umgebung

Es ist der zusammengebaute Raspberry Pi 4. Der Switching Hub und das USB-Ladegerät sind mit Klebeband befestigt. (Ich habe es für 100 Yen gekauft.)

Dies sind die Teile, die ich dieses Mal vorbereitet habe.

Teilname	Adresse
Raspberry Pi	Raspberry Pi 4 Model B/4GBx 3 Einheiten
SD-Karte	Samsung micro SDXC 128GB MB-MC128GAx 3 Blatt
Schaltnabe	エレコムSchaltnabeギガビット 5ポート AC電源小型 EHC-G05PA-SBx 1 Einheit
USB-Ladegerät	Anker PowerPort I PD - 1 PD & 4 PowerIQx 1 Einheit ※type-c:1 Mund, type-A:4 Münder
Fall	Pi Rack Case für GeeekPi Raspberry Pi 4 Modell B mit Lüfter und Kühlkörperx 1 Einheit
USB-Kabel	Mauknci type-c & type-c 30cmx 1
USB-Kabel	SUNGUY type-A & type-c 30cm 2 Stk. Setx2Sätze(4) * Einer bleibt übrig. Ich benutze es für etwas anderes.
LAN-Kabel	Miyoshi MCO Kategorie-6 Schlankes LAN-Stier 15cmx 3

Der Switching Hub ist über ein LAN-Kabel mit dem Router verbunden. Ich benutze kein WLAN.
Verwenden Sie einen SDXC-kompatiblen Writer, um auf die SD-Karte zu schreiben.
Die Netzteilspezifikation des Raspberry Pi 4 ist 3A, und der Ausgang des USB-Ladegeräts ist 2,4A, aber es funktioniert.

Dies ist die zu installierende Software.

Ubuntu 20.04.1 LTS 64bit
Kubernetes v1.19.3
Docker 19.03.13

Ich habe Folgendes für meine Arbeit verwendet.

Windows 10 PC (zum Schreiben von SD-Karte und SSH-Verbindung)
15-Zoll-Mobilmonitor (für die anfängliche Einstellung von Raspeye)
USB-Tastatur (für die Raspeye-Grundeinstellung)

Netzwerkumgebung zu erstellen

Die IP-Adresse ist fest.

Verwenden	Hostname	IP Adresse
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

Andere notwendige IP-Adressinformationen.

Verwenden	IP Adresse
gateway	192.168.100.254
DNS	192.168.100.254
IP-Pool für LoadBalancer	192.168.100.211-192.168.100.215

Versammlung

Da das USB-Ladegerät schwer ist, habe ich es unten zusammengebaut. Für den Master-Knoten wird nur ein "Typ-C-Typ-C-Kabel" verwendet, was wichtig sein kann. (Vielleicht macht es keinen Sinn) Es gibt nichts Besonderes zu erwähnen. Nach dem Zusammenbau kann es gestartet werden.

Installieren Sie Ubuntu 20.04 auf Raspberry Pi 4

Erstellen Sie eine SD-Karte, um Raspeye zu starten. Der Arbeits-PC ist Windows 10.

Verwenden Sie "Raspberry Pi Imager", um auf die SD-Karte zu schreiben. Wenn Sie es mit "Raspberry Pi Imager" formatieren, können Sie eine SD-Karte mit 64 GB oder mehr verwenden. Download von Raspberry Pi Imager.

Legen Sie die SD-Karte in den Brenner ein und starten Sie "Raspberry Pi Imager".

Bitte verwenden Sie einen Writer, der SDXC-Karten unterstützt.

Formatieren Sie die SD-Karte.

Klicken Sie auf Betriebssystem auswählen und wählen Sie Löschen.

Klicken Sie auf "SD-Karte auswählen" und wählen Sie die eingelegte SD-Karte aus.

Klicken Sie auf SCHREIBEN, um die Formatierung zu starten.

Die Formatierung ist abgeschlossen. Klicken Sie auf "WEITER", um den Dialog zu schließen.

Dann schreiben Sie das Betriebssystem. Klicken Sie auf Betriebssystem auswählen und wählen Sie Ubuntu.

Wählen Sie Ubuntu Server 20.04.1 LTS (RPi 3/4). Wählen Sie 64-Bit. Das obige 32-Bit ist anders.

Klicken Sie auf "SD-Karte auswählen" und wählen Sie die eingelegte SD-Karte aus.

Klicken Sie zum Schreiben auf "SCHREIBEN".

Das Schreiben des Betriebssystems ist abgeschlossen.

Schreiben Sie auf die gleichen zwei SD-Karten auf die gleiche Weise.

Ubuntu 20.04 Einstellungen

Richten Sie das Netzwerk ein und stellen Sie dann eine Verbindung mit SSH her, um zu arbeiten.

Legen Sie die SD-Karte mit dem darin geschriebenen Betriebssystem in den Raspelkuchen ein und starten Sie sie. Die Einstellung erfolgt über einen 15-Zoll-Mobilmonitor und eine USB-Tastatur.

Melden Sie sich bei Ubuntu an

Nutzername	Erstes Passwort
ubuntu	ubuntu

Wenn Sie sich zum ersten Mal anmelden, werden Sie aufgefordert, Ihr Passwort zu ändern.

Da die englische Tastatur eingestellt ist, sollten Sie beim Einfügen von Symbolen vorsichtig sein.

Überprüfen Sie die Betriebssystemversion.

$ 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

Deaktivieren Sie das Standard-Ubuntu-Konto und erstellen Sie ein Arbeitskonto (Arbeit, die allen drei Einheiten gemeinsam ist).

Erstellen Sie anstelle des Standard-Ubuntu-Kontos ein k8suser-Konto für Ihre Arbeit.

Wenn Sie kein Arbeitskonto benötigen, überspringen Sie es bitte.

$ sudo useradd -m -s /usr/bin/bash k8suser
$ sudo passwd k8suser          #Änder das Passwort
New password:
Retype new password:
passwd: password updated successfully

$ sudo adduser k8suser sudo     #Fügen Sie k8suser zur sudo-Gruppe hinzu
Adding user `k8suser' to group `sudo' ...
Adding user k8suser to group sudo
Done.
$ cat /etc/group | grep sudo   #Bestätigen
#Umschalttaste für englische Tastatureinstellungen+ }Aber"|"werden
sudo:x:27:ubuntu,k8user

Verbietet die Anmeldung für das Standardkonto (Ubuntu).

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

Master Node OS-Einstellungen

Nehmen Sie Einstellungen rund um das Master-Node-Netzwerk vor.

Hostnamen ändern (auf Masterknoten ausführen)

$ sudo hostnamectl set-hostname master01.example.jp
$ hostname    #Bestätigen
master01.example.jp

IP-Adresse ändern (auf Master-Knoten ausführen)

#Für englische Tastatureinstellungen ist dies wie folgt
# Shift + ;Aber":」
# @Aber"[」
# [Aber"]」
$ 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    #Bestätigung:「eth0:Bestätigen Sie, dass die IP-Adresse in "inet" von angezeigt wird

Melden Sie sich mit SSH bei master01.example.jp an.

Zugangspunkt	Nutzername	Passwort
192.168.100.101	k8suser	Passwort festlegen

Betriebssystemeinstellungen für Worker Node 1

Konfigurieren Sie die Einstellungen im Worker Node 1-Netzwerk.

Hostnamen ändern (auf Worker Node 1 ausführen)

$ sudo hostnamectl set-hostname worker01.example.jp
$ hostname    #Bestätigung
worker01.example.jp

IP-Adresse ändern (auf Worker Node 1 ausführen)

#Für englische Tastatureinstellungen ist dies wie folgt
# Shift + ;Aber":」
# @Aber"[」
# [Aber"]」
$ 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    #Bestätigung:「eth0:Bestätigen Sie, dass die IP-Adresse in "inet" von angezeigt wird

Melden Sie sich mit SSH bei worker01.example.jp an.

Zugangspunkt	Nutzername	Passwort
192.168.100.102	k8suser	Passwort festlegen

Betriebssystemeinstellungen für Worker Node 2

Konfigurieren Sie die Einstellungen im Worker Node 2-Netzwerk.

Hostnamen ändern (auf Worker Node 2 ausführen)

$ sudo hostnamectl set-hostname worker02.example.jp
$ hostname    #Bestätigen
worker02.example.jp

IP-Adresse ändern (auf Worker Node 2 ausführen)

#Für englische Tastatureinstellungen ist dies wie folgt
# Shift + ;Aber":」
# @Aber"[」
# [Aber"]」
$ 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    #Bestätigung:「eth0:Bestätigen Sie, dass die IP-Adresse in "inet" von angezeigt wird

Melden Sie sich mit SSH bei worker02.example.jp an.

Zugangspunkt	Nutzername	Passwort
192.168.100.103	k8suser	Passwort festlegen

Allen drei gemeinsame Betriebssystemeinstellungen

Stellen Sie für den Rest der Arbeit eine Verbindung zu SSH her und fahren Sie mit dem Einstellen des Betriebssystems fort. Wenn ich Kubernetes starte, muss der Austausch gestoppt werden, aber der Austausch hat nicht funktioniert. Ist es, weil es für Raspeltorte ist?

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

Aktualisierung des vorhandenen Pakets (gemeinsam mit 3 Einheiten)

$ sudo apt update
$ sudo apt -y upgrade

Hosts-Datei bearbeiten (allen 3 gemeinsam)

$ sudo vi /etc/hosts
#Anhängen
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    #Bestätigen

Zeitzone ändern (allen 3 Einheiten gemeinsam)

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

Keymap ändern (gemeinsam mit 3 Einheiten)

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

Stoppen Sie IPv6 (allen 3 Einheiten gemeinsam)

$ sudo vi /etc/sysctl.conf
#Anhängen
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    #Bestätigen. inet6 wird nicht angezeigt.

Verhindern Sie, dass iptables das nftables-Backend verwenden (allen drei gemeinsam)

[Verhindern, dass iptables das nftables-Backend verwenden](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 ) Siehe Einstellung.

$ 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 von Docker (allen 3 Einheiten gemeinsam)

Installieren Sie unter Docker Engine unter Ubuntu installieren.

$ 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.

Das Zuweisen von Benutzern zur Docker-Gruppe dient nicht der Sicherheit, sondern dem Testen.

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

Melden Sie sich für die Gruppenzuweisung ab und wieder an. Überprüfen Sie die Docker-Version.

$ 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

Überprüfen Sie die Funktion von Docker. Starten Sie den Hallo-Welt-Container.

$ 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 von kubeadm, kubectl, kubelet (allen 3 Einheiten gemeinsam)

[Installieren Sie kubeadm, kubelet, kubectl](https://kubernetes.io/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#kubeadm-kubelet-kubectl%E3%81%AE%E3 Installieren Sie unter Bezugnahme auf% 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.

Überprüfen Sie die Version jedes Moduls.

$ 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 jsonNur Nachricht zur Laufzeit(die Verbindung zum Server ・・・)Wird angezeigt, aber wir werden uns später darum kümmern.

Speicher mit cgruop aktivieren (allen 3 Einheiten gemeinsam)

enable ist 0. (Die letzte 0 ist die aktivierte Spalte)

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

Dies wird unter [Installieren von Kubernetes auf Raspeye Cluster (Erfolg)] festgelegt (https://kuromt.hatenablog.com/entry/2019/01/03/233347).

Fügen Sie zu /boot/firmware/cmdline.txt hinzu. Hinzufügung am Ende der Zeile. Es ist eine einzeilige Datei.

$ sudo vi /boot/firmware/cmdline.txt
cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory    #Anhängen
$ cat /boot/firmware/cmdline.txt    #Bestätigen
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

Neustart.

$ sudo reboot

Überprüfen Sie, wann das Betriebssystem gestartet wird.

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

enable ist 1, was bedeutet, dass es aktiviert ist.

Erstellen eines Kubernetes-Clusters

Es ist endlich die Einstellung von Kubernetes. Initialisieren Sie zunächst den Master-Knoten.

Einrichtung unter Bezugnahme auf Kubernetes-Dokumentation.

Initialisierung des Masterknotens (auf dem Masterknoten ausführen)

Informationen zu Optionen

apiserver-advertise-address=192.168.100.101
IP-Adresse des API-Servers. In diesem Fall die IP-Adresse des Master-Knotens.
Muss angegeben werden, wenn mehrere Netzwerkkarten vorhanden sind.
Es gibt nicht mehr als eine, aber sie ist der Klarheit halber angegeben.
pod-network-cidr=10.244.0.0/16
Spezifikation für Flanell.

Initialisierung durchführen.

$ 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

Der letzte `kubeadm-Join ・・・` ist erforderlich, wenn Sie einen Worker-Knoten hinzufügen. Notieren Sie ihn also irgendwo. Nach 24 Stunden ist der Token nicht mehr verfügbar.

Es ist eine Methode, um die verbleibende Zeit des Tokens zu überprüfen und erneut auszugeben. Wenn Sie den Befehl jedoch an dieser Stelle ausführen, tritt ein Fehler auf, der später beschrieben wird.

Festlegen von Umgebungsvariablen und Abschluss der Eingabe (auf dem Hauptknoten ausgeführt)

Umgebungsvariablen festlegen. kubectl version -o jsonLaufzeitnachricht(die Verbindung zum Server ・・・)Wird nicht angezeigt, wenn Folgendes eingestellt wird.

$ 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
#Stellen Sie sicher, dass "Die Verbindung zum Server ..." nicht angezeigt wird.

Legt die Befehlsvervollständigung fest.

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

Über das Token des Kubeadm-Joins (auf dem Master-Knoten ausgeführt)

Über das Token, das ich später erwähnte. Wenn Sie die verbleibende Zeit überprüfen möchten, führen Sie den Befehl `` `kubeadm token list``` aus. Wenn nichts angezeigt wird, gibt es kein gültiges Token.

$ 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'.

Wenn Sie das Token erneut ausgeben möchten, führen Sie den Befehl `` `kubeadm token create``` aus.

$ 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  #Das ist ein Token

Wenn Sie den Hash des CA-Zertifikats überprüfen möchten, führen Sie den Befehl `` `openssl``` aus. Es ist geschrieben in Erstellen eines einzelnen Steuerebenenclusters mit kubeadm. Ich werde.

$ openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | \
   openssl dgst -sha256 -hex | sed 's/^.* //'
3646aa901c623280b56d8ec33873263a5e3452a979f594c0f628724ed9fe9cce  #Dies ist der Hash des CA-Zertifikats

Installieren Sie das Pod Network Add-on (auf dem Hauptknoten ausführen)

Stellen Sie Flanell als Add-On ein, damit Pods miteinander kommunizieren können. Ich habe mich für Flanell entschieden, das eine gute Erfolgsbilanz hat. Installieren Sie anhand der folgenden Anweisungen.

$ 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

Bestätigen Sie den Start. Sie können kube-flannel-ds-XXXXX sehen.

$ 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

Installieren Sie LoadBalancer (Auf Masterknoten ausführen)

Verwenden Sie MetalLB. Ich habe mich aus folgenden Features entschieden.

Sie können den Service vom Typ LoadBalancer in einer lokalen Umgebung verwenden --Externe IP kann zugewiesen werden

Es besteht aus zwei Arten von Pods, Controller und Lautsprecher.

Installieren Sie dies unter Bezugnahme auf MetalLB, Bare-Metal-Load-Balancer für 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

Bestätigen Sie den Start. Sie können Controller-XXXXXXXXX-XXXXX und Lautsprecher-XXXXX sehen.

$ 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

Controller läuft nicht in Pending. Wie in MetalLB, Bare-Metal-Load-Balancer für Kubernetes angegeben, ist Controller Deployment. Da ich noch keinen Worker Node registriert habe, habe ich keinen Worker Node, der den Pod ausführen kann. Da der Sprecher ein DaemonSet ist, wird er von allen Knoten (Master, Worker) gestartet. Jetzt läuft es auf dem Master-Knoten. (Starten Sie nach dem Hinzufügen des Arbeiterknotens insgesamt 3)

Verbinden Sie Worker Node mit Cluster (Ausführen auf Worker Node1, Worker Node2)

Führen Sie den Befehl aus, der bei der Initialisierung des Master-Knotens aufgezeichnet wurde. Wenn Sie es vergessen, wird es neu ausgestellt.

Wenn Sie die Nachricht kopieren und einfügen, beachten Sie bitte, dass `` `sudo``` nicht angehängt ist.

$ 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.

Bestätigung des zusätzlichen Arbeiterknotens (auf dem Hauptknoten ausgeführt)

Die Bestätigung erfolgt auf dem Master-Knoten. Es dauerte weniger als 5 Minuten, bis der Worker Node ausgeführt wurde.

$ 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

Der ausstehende Controller wird jetzt ausgeführt. kube-flannel-ds-XXXXX, kube-proxy-XXXXX, lautsprecher-XXXXX werden um die Anzahl der Arbeiterknoten erhöht.

Label auf Worker Node festlegen (Run on Master Node)

$ 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  #Bestätigen
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

Führen Sie einen Container mit Kubernetes aus

Verwenden Sie zum Überprüfen des Vorgangs das Image von Nginx-Container, der den Hostnamen des Hosts zurückgibt, auf dem Docker ausgeführt wird.

`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  #Name des Metallb-IP-Pools
      protocol: layer2
      addresses:
      - 192.168.100.211-192.168.100.215
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service-lb # Service(LoadBalancer)s Name
  namespace: nginx-prod
  annotations:
    metallb.universe.tf/address-pool: pool-ips #Name des Metallb-IP-Pools
spec:
  type: LoadBalancer
  ports:
    - name: nginx-service-lb
      protocol: TCP
      port: 8080 #Port zum Abhören der Service-IP
      nodePort: 30080 #Port zum Abhören der Knoten-IP (30000)-32767）
      targetPort: 80 #Weiterleitungsziel(Container)Der Port der abhörenden Portnummer
  selector: #Service Selector wird als matchLabels behandelt
    app: nginx-pod #Beschriftung des Ziel-Pods
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment #Bereitstellungsname(Dies ist auch der Name des ReplicaSet)
  namespace: nginx-prod
spec:
  selector:
    matchLabels: #Erstellen eines ReplicaSet für Pods mit übereinstimmenden Beschriftungen
      app: nginx-pod
  replicas: 2
  template: #Pod-Vorlage
    metadata:
      name: nginx-pod #Pod Name
      namespace: nginx-prod
      labels: #Pod-Etikett
        app: nginx-pod
    spec:
      containers: #Containereinstellungen
        - name: nginx-container #Der Name des Containers
          image: yasthon/nginx-display-hostname #Bildname
          env:
            - name: nginx-container
          ports:
            - containerPort: 80 #Containerhafen
          volumeMounts:
            - name: file-hostname
              mountPath: /usr/share/nginx/html/hostname
      volumes:
        - name: file-hostname
          hostPath:
            path: /etc/hostname

Erstellen Sie eine 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  #Bestätigen
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  #Bestätigen
NAME     DATA   AGE
config   1      3m57s

Pod, Service, Bereitstellung, ReplicaSet, ConfigMap wurden erstellt. Der Dienst EXTERNAL-IP wurde aus dem IP-Pool zugewiesen.

Überprüfen Sie die LoadBalancer Ingress- und Port-Werte in den Servicedetails.

$ 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"

Die IP-Adresse von LoadBalancer Ingress ist dieselbe wie bei EXTERNAL-IP. (x2 over 59s)Was bedeutet die Anzeige von?Zweimal zugewiesen?Das erste Mal hat Zeit gekostet?? Es scheint den Betrieb nicht zu stören. Es wird möglicherweise nicht angezeigt.

Verbindungsbestätigung

Stellen Sie eine Verbindung zur IP-Adresse von LoadBalancer Ingress und zur Portnummer von Port her.

$ 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>

Wenn Sie den Befehl curl mehrmals wiederholen, ändert sich das Verbindungsziel in worker02.example.jp. Es wird lastausgeglichen. Es scheint kein einfaches Round Robin zu sein.

Versuchen Sie, Worker Node 2 zu stoppen

Ich habe das Ether-Kabel für Worker Node2 abgezogen und den Befehl curl ausgeführt. Der Befehl wurde auf dem Master-Knoten ausgeführt.

$ 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>

Natürlich greife ich nur auf worker01.example.jp zu.

Versuchen Sie, Worker Node1 zu stoppen

Schließen Sie das Etherkabel für Worker Node2 wieder an. Ich habe das Ether-Kabel für Worker Node1 abgezogen und den Curl-Befehl ausgeführt.

$ 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>

Ich kann nur eine Verbindung zu Worker Node2 herstellen. Wenn Sie das Ether-Kabel von Worker Node1 wieder anschließen, wird es mit beiden Worker Nodes verbunden.

Der Zugriff funktioniert, mit Ausnahme von Arbeitnehmern, auf die nicht mehr zugegriffen werden kann.

Auch vom Browser

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


 Sie können mit darauf zugreifen.
 Beim Zugriff über einen Browser ist dies fest behoben.
 Selbst wenn Sie wiederholt Strg + F5 drücken, ändert sich das Verbindungsziel nicht ...
 Wenn ich das Kabel abziehe, wird eine Verbindung zu einem anderen Worker-Knoten hergestellt, sodass Load Balancer anscheinend funktioniert.

## Clusterbereinigung

 Wenn Sie den Cluster aus irgendeinem Grund neu erstellen möchten, führen Sie eine Bereinigung durch.
 Ich beziehe mich auf Folgendes.

 - [Erstellen eines einzelnen Steuerebenenclusters mit kubeadm](https://kubernetes.io/en/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/#tear-down),
 - [Fehlerbehebung bei kubeadm-kubeadm hängt beim Löschen des verwalteten Containers](https://kubernetes.io/ja/docs/setup/production-environment/tools/kubeadm/troubleshooter-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)



### Knoten löschen (auf Masterknoten ausführen)

```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    #Bestätigen
NAME                  STATUS   ROLES    AGE   VERSION
master01.example.jp   Ready    master   8d    v1.19.3

Worker-Knoten zurücksetzen (Auf Worker-Knoten1, Worker-Knoten2 ausführen)

$ 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    #Geben Sie y ein
[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.

Führt die in der Nachricht beschriebene Verarbeitung durch.

Löschen Sie die CNI-Konfiguration.

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

Kubernetes-bezogene Regeln verbleiben in iptables. Löschen Sie sie daher.

$ sudo iptables -L -n
#Sie werden eine Menge Regeln sehen, die sich auf Kubernetes beziehen.
$ sudo iptables -F && sudo iptables -t nat -F && sudo iptables -t mangle -F && sudo iptables -X
$ sudo iptables -L -n    #Bestätigen
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

Master-Knoten zurücksetzen (Auf Master-Knoten ausführen)

$ 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    #Bestätigen

Führen Sie nach der Bereinigung den Befehl `` `sudo kubeadm init``` aus, um den Cluster zu erstellen.

Pod auf Masterknoten ausführen (Auf Masterknoten ausführen)

Sie können Pods auf dem Master-Knoten ausführen. Die Standardeinstellungen sind auf dem Masterknoten nicht geplant.

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

Deaktivieren Sie die NoSchedule-Einstellung, damit der Pod auch auf dem Master-Knoten funktioniert. Fügen Sie nach dem Master "-" (Bindestrich) hinzu: NoSchedule.

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

`kind:Bereitstellungsreplikate:Ändern Sie 2 zu 3`

$ vi display-hostname.yaml replicas: 3 #Ändern Sie 2 zu 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 #Bestätigen 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


 Der mittlere Pod, den Sie starten möchten, ist der Pod, der auf dem Master-Knoten ausgeführt wird.
 Selbst in den detaillierten Informationen können Sie bestätigen, dass es mit master01.example.jp gestartet wurde.

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


 Wenn Sie verhindern möchten, dass die Pods am Master-Knoten arbeiten, ändern Sie zunächst die Anzahl der Pods wieder auf zwei.
``display-hostname.yaml```von```replicas:```Wird auf 2 zurückgesetzt.

```bash
$ vi display-hostname.yaml
 Repliken: Ändern Sie 2 # 3 in 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 # Überprüfen
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

Der zuvor gestartete mittlere Pod steht kurz vor dem Verlassen.

Stellen Sie NoSchedule ein.

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

NoSchedule ist eingestellt und Pod funktioniert nicht mehr auf dem Master-Knoten.

##Schließlich

Ich konnte mit Raspeye eine Kubernetes-Clusterumgebung erstellen. Es ist eine gute Zeit. Im Vergleich zum Kauf von mehr Servern und PCs ist dies sehr viel. Alles was Sie tun müssen, ist zu spielen.

##Referenz-URL

Dies ist ein Artikel, den ich als Referenz verwendet habe.

Ich habe versucht, einen Kubernetes-Cluster mit Himbeerkuchen ~ zusammen mit einem eleganten Stoffkabel ~ zu machen
Machen wir ein Haus Kubernetes mit Raspberry Pi 4 (Raspbian Buster Lite kompatible Version)
Kubernetes Dojo Tag 1-Übersicht über Kubernetes- Toku's Blog* Der Link befindet sich am 1. Tag, ist jedoch bis zum 25. Tag verfügbar.

Dies ist ein Referenzartikel mit einem Link im Text.