Aufbau einer Docker+K8S-Clusterumgebung und verteilte Anwendungsbereitstellung

1. Docker installieren

yum installiere Docker
#Starten Sie den Dienst systemctl start docker.service
systemctl aktiviere docker.service
#Docker-Version testen

2. Installieren Sie etcd

yum installiere etcd -y
#Starten Sie etcd
systemctl start etcd
systemctl aktiviere etcd
#Geben Sie den folgenden Befehl ein, um den Gesundheitszustand von etcd zu überprüfen etcdctl -C http://localhost:2379 cluster-health
#Kubernetes installieren
yum installiere kubernetes -y

Bearbeiten Sie nach der Installation die Datei /etc/kubernetes/apiserver und entfernen Sie den ServiceAccount nach KUBE_ADMISSION_CONTROL, zum Beispiel:

KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ResourceQuota"

Starten Sie anschließend folgende Programme (Master):

systemctl starte kube-apiserver
systemctl aktiviert Kube-API-Server
systemctl start kube-controller-manager
systemctl aktiviert Kube-Controller-Manager
systemctl startet Kube-Scheduler
systemctl aktiviert Kube-Scheduler

Starten Sie als Nächstes das Node-Programm:

systemctl starte kubelet
systemctl aktiviert Kubelet
systemctl starte kube-proxy
systemctl aktiviert Kube-Proxy

Auf diese Weise wurde eine einfache K8S-Clusterumgebung erstellt. Wir können den folgenden Befehl ausführen, um den Clusterstatus anzuzeigen.

Allerdings funktioniert die Clusterumgebung derzeit nicht gut, da das Netzwerk der Pods im Cluster einheitlich verwaltet werden muss und daher ein Overlay-Netzwerk-Flanell erstellt werden muss.

1. Flanell installieren:

yum installiere flannel -y

2. Bearbeiten Sie die Datei /etc/sysconfig/flanneld und fügen Sie den folgenden Code hinzu:

--logtostderr=false --log_dir=/var/log/k8s/flannel/ --etcd-prefix=/atomic.io/network --etcd-endpoints=http://localhost:2379 --iface=enp0s3

Das -iface entspricht dem Namen der Netzwerkkarte.

3. Konfigurieren Sie den Schlüssel für flanneld in etcd

Flannel verwendet etcd zur Konfiguration, um die Konfigurationskonsistenz zwischen mehreren Flannel-Instanzen sicherzustellen. Daher muss die folgende Konfiguration auf etcd durchgeführt werden:

etcdctl mk /atomic.io/network/config '{ "Netzwerk": "10.0.0.0/16" }'

/atomic.io/network/config Dieser Schlüssel entspricht dem Konfigurationselement FLANNEL_ETCD_PREFIX in /etc/sysconfig/flannel oben. Wenn er falsch ist, schlägt der Start fehl.)

Das Netzwerk wird zum Konfigurieren des Netzwerksegments verwendet. Es darf nicht mit der IP-Adresse der physischen Maschine in Konflikt geraten. Es kann beliebig definiert werden und versucht werden, das IP-Segment der physischen Maschine zu vermeiden.

4. Starten Sie das geänderte Flanell und starten Sie Docker und Kubernetes nacheinander neu:

systemctl aktiviere flanneld 
systemctl start flanneld
Dienst Docker Neustart
systemctl startet kube-apiserver neu
systemctl startet Kube-Controller-Manager neu
systemctl Neustart Kube-Scheduler
systemctl aktiviere flanneld
systemctl start flanneld
Dienst Docker Neustart
systemctl startet kubelet neu
systemctl startet Kube-Proxy neu

Wenn wir die Anwendung auf diese Weise in einem Docker-Container bereitstellen, können wir über die physische IP auf den Container zugreifen.

Verteilte Anwendungsbereitstellung

1. Erstellen Sie ein Framework basierend auf SpringBoot, das hier nicht beschrieben wird. Standardmäßig ist es bereits erstellt.
2. Schreiben Sie ein Dockerfile. Das Inhaltsbeispiel lautet wie folgt:

#Laden Sie das Java8-Image VON java:8 herunter
#Lokale Dateien in das Verzeichnis /tmp mounten VOLUME /tmp
#Kopieren Sie die Datei in den Container ADD demo-0.0.1-SNAPSHOT.jar /demo.jar
#Port 8080 freigeben 8080 freigeben
#Konfigurieren Sie den Befehl, der nach dem Starten des Containers ENTRYPOINT ["java","-jar","/demo.jar"] ausgeführt werden soll

Erstellen Sie mit dem Befehl „Docker Build“ ein Image:

Dockerbuild -t-Demo.

An diesem Punkt führen wir Docker-Images aus und sehen das Image, das wir gerade erstellt haben, wie etwa:

Bereitstellen von SpringBoot-Anwendungen mit K8S

1. Erstellen Sie die RC-Datei demo-rc.yaml:

API-Version: v1
Art: ReplikationsController
Metadaten:
 Name: Demo
Spezifikation:
 # Anzahl der Knoten. Durch Festlegen auf mehrere kann ein Lastenausgleich erreicht werden. Replikate: 1
 Wähler:
  App: Demo
 Vorlage:
  Metadaten:
   Beschriftungen:
    App: Demo
  Spezifikation:
   Behälter:
   - Name: Demo
    #BildnameBild: Demo
    #Wenn ein lokales Bild vorhanden ist, wird das Bild nicht aus dem Lager gezogenPullPolicy: IfNotPresent
    Häfen:
    - ContainerPort: 8080

Führen Sie den folgenden Befehl aus, um einen Pod zu erstellen:

kubectl create -f demo-rc.yaml

Nach erfolgreicher Erstellung können wir uns den Pod ansehen:

ContainerCreating meldet, dass es erstellt wird. Sie können das Erstellungsprotokoll jetzt einsehen:

Es kann festgestellt werden, dass er auffordert: redhat-cat.crt existiert nicht. Lassen Sie uns zunächst die Datei mit dem Befehl ll überprüfen:

Es kann festgestellt werden, dass die Datei eine Linkdatei ist, die auf /etc/rhsm/ca/redhat-uep.pem verweist, aber diese Datei existiert nicht. Woher kommt diese Datei also? Die Antwort liegt in diesem Pfad. Wir müssen die rhsm-Software installieren. Führen Sie den Befehl aus, um sie zu installieren:

yum installiere *rhsm* -y

Nach einer kurzen Wartezeit ist die Installation abgeschlossen.

Führen Sie nach Abschluss der Installation den Befehl ll aus, um zu überprüfen, ob die Datei vorhanden ist:

[root@MiWiFi-R3-srv ~]# ll /etc/rhsm/ca/redhat-uep.pem
ls: kann nicht auf /etc/rhsm/ca/redhat-uep.pem zugreifen: Keine solche Datei oder kein solches Verzeichnis

Wir haben festgestellt, dass noch keine Datei vorhanden ist, aber wir können sie manuell erstellen:

berühren Sie /etc/rhsm/ca/redhat-uep.pem

Nachdem wir die obigen Vorgänge abgeschlossen haben, löschen wir zuerst rc und erstellen es dann:

[root@MiWiFi-R3-srv ~]# kubectl lösche rc demo
Replicationcontroller "Demo" gelöscht
[root@MiWiFi-R3-srv ~]# kubectl create -f demo-rc.yaml 
Replicationcontroller "Demo" erstellt

Nachdem wir eine Weile gewartet hatten, überprüften wir po erneut und stellten fest, dass es erfolgreich gestartet war:

[root@MiWiFi-R3-srv ~]# kubectl get po
NAME BEREIT STATUS NEUSTART ALTER
demo-hdmxs 1/1 Laufen 0 1m

An diesem Punkt können wir nicht über das LAN auf die Anwendung zugreifen und müssen einen Dienst erstellen:

1. Erstellen Sie eine Servicedatei demo-svc.yaml:

API-Version: v1
Art: Dienstleistung
Metadaten:
 Name: Demo
Spezifikation:
 Typ: NodePort
 Häfen:
 - Anschluss: 8080
  ZielPort: 8080
  # Der Port, den der Knoten der Außenwelt zugänglich macht (muss im Bereich 30000-32767 liegen)
  KnotenPort: 30001
 Wähler:
  App: Demo

2. Führen Sie den Befehl aus:

[root@MiWiFi-R3-srv ~]# kubectl create -f demo-svc.yaml 
Service "Demo" erstellt

3. Wir können den Dienst anzeigen, den wir gerade erstellt haben:

An diesem Punkt können wir über IP:30001 auf die Anwendung zugreifen, wie in der Abbildung gezeigt:

Wenn Sie nicht darauf zugreifen können, müssen Sie die Firewall ausschalten:

systemctl stoppe Firewall
iptables -P WEITERLEITEN AKZEPTIEREN

Dies ist das Ende dieses Artikels über den Aufbau einer Docker+K8S-Clusterumgebung und die verteilte Anwendungsbereitstellung. Weitere relevante Inhalte zum Aufbau einer Docker-K8S-Clusterumgebung finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!