Kubernetes - Setup

Es ist wichtig, das Virtual Datacenter (vDC) einzurichten, bevor Sie Kubernetes einrichten. Dies kann als eine Reihe von Maschinen betrachtet werden, auf denen sie über das Netzwerk miteinander kommunizieren können. Für den praktischen Ansatz können Sie vDC einrichtenPROFITBRICKS Wenn Sie keine physische oder Cloud-Infrastruktur eingerichtet haben.

Sobald das IaaS-Setup in einer Cloud abgeschlossen ist, müssen Sie das konfigurieren Master und die Node.

Note- Das Setup wird für Ubuntu-Maschinen angezeigt. Das gleiche kann auch auf anderen Linux-Rechnern eingerichtet werden.

Voraussetzungen

Installing Docker- Docker ist für alle Instanzen von Kubernetes erforderlich. Im Folgenden finden Sie die Schritte zum Installieren des Dockers.

Step 1 - Melden Sie sich mit dem Root-Benutzerkonto am Computer an.

Step 2- Aktualisieren Sie die Paketinformationen. Stellen Sie sicher, dass das apt-Paket funktioniert.

Step 3 - Führen Sie die folgenden Befehle aus.

$ sudo apt-get update
$ sudo apt-get install apt-transport-https ca-certificates

Step 4 - Fügen Sie den neuen GPG-Schlüssel hinzu.

$ sudo apt-key adv \
   --keyserver hkp://ha.pool.sks-keyservers.net:80 \
   --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
$ echo "deb https://apt.dockerproject.org/repo ubuntu-trusty main" | sudo tee
/etc/apt/sources.list.d/docker.list

Step 5 - Aktualisieren Sie das API-Paket-Image.

$ sudo apt-get update

Sobald alle oben genannten Aufgaben abgeschlossen sind, können Sie mit der eigentlichen Installation der Docker-Engine beginnen. Zuvor müssen Sie jedoch überprüfen, ob die von Ihnen verwendete Kernelversion korrekt ist.

Installieren Sie Docker Engine

Führen Sie die folgenden Befehle aus, um die Docker-Engine zu installieren.

Step 1 - Melden Sie sich am Computer an.

Step 2 - Aktualisieren Sie den Paketindex.

$ sudo apt-get update

Step 3 - Installieren Sie die Docker Engine mit dem folgenden Befehl.

$ sudo apt-get install docker-engine

Step 4 - Starten Sie den Docker-Daemon.

$ sudo apt-get install docker-engine

Step 5 - Wenn der Docker installiert ist, verwenden Sie den folgenden Befehl.

$ sudo docker run hello-world

Installieren Sie etcd 2.0

Dies muss auf der Kubernetes Master Machine installiert werden. Führen Sie die folgenden Befehle aus, um es zu installieren.

$ curl -L https://github.com/coreos/etcd/releases/download/v2.0.0/etcd
-v2.0.0-linux-amd64.tar.gz -o etcd-v2.0.0-linux-amd64.tar.gz ->1
$ tar xzvf etcd-v2.0.0-linux-amd64.tar.gz ------>2
$ cd etcd-v2.0.0-linux-amd64 ------------>3
$ mkdir /opt/bin ------------->4
$ cp etcd* /opt/bin ----------->5

Im obigen Befehlssatz -

Zuerst laden wir die etcd. Speichern Sie dies unter dem angegebenen Namen.
Dann müssen wir das Teerpaket entfernen.
Wir machen ein dir. im / opt namens bin.
Kopieren Sie die extrahierte Datei an den Zielspeicherort.

Jetzt sind wir bereit, Kubernetes zu bauen. Wir müssen Kubernetes auf allen Computern im Cluster installieren.

$ git clone https://github.com/GoogleCloudPlatform/kubernetes.git
$ cd kubernetes
$ make release

Der obige Befehl erstellt eine _outputdir im Stammverzeichnis des Kubernetes-Ordners. Als nächstes können wir das Verzeichnis in ein beliebiges Verzeichnis unserer Wahl / opt / bin usw. extrahieren.

Als nächstes kommt der Netzwerkteil, in dem wir tatsächlich mit der Einrichtung von Kubernetes Master und Node beginnen müssen. Zu diesem Zweck erstellen wir einen Eintrag in der Hostdatei, der auf dem Knotencomputer ausgeführt werden kann.

$ echo "<IP address of master machine> kube-master
< IP address of Node Machine>" >> /etc/hosts

Es folgt die Ausgabe des obigen Befehls.

Nun beginnen wir mit der eigentlichen Konfiguration auf Kubernetes Master.

Zuerst kopieren wir alle Konfigurationsdateien an den richtigen Speicherort.

$ cp <Current dir. location>/kube-apiserver /opt/bin/
$ cp <Current dir. location>/kube-controller-manager /opt/bin/
$ cp <Current dir. location>/kube-kube-scheduler /opt/bin/
$ cp <Current dir. location>/kubecfg /opt/bin/
$ cp <Current dir. location>/kubectl /opt/bin/
$ cp <Current dir. location>/kubernetes /opt/bin/

Mit dem obigen Befehl werden alle Konfigurationsdateien an den gewünschten Speicherort kopiert. Jetzt kehren wir zu demselben Verzeichnis zurück, in dem wir den Kubernetes-Ordner erstellt haben.

$ cp kubernetes/cluster/ubuntu/init_conf/kube-apiserver.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-controller-manager.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-kube-scheduler.conf /etc/init/

$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-apiserver /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-controller-manager /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-kube-scheduler /etc/init.d/

$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/

Der nächste Schritt ist das Aktualisieren der kopierten Konfigurationsdatei unter / etc. dir.

Konfigurieren Sie etcd auf dem Master mit dem folgenden Befehl.

$ ETCD_OPTS = "-listen-client-urls = http://kube-master:4001"

Konfigurieren Sie kube-apiserver

Dazu müssen wir auf dem Master die bearbeiten /etc/default/kube-apiserver Datei, die wir zuvor kopiert haben.

$ KUBE_APISERVER_OPTS = "--address = 0.0.0.0 \
--port = 8080 \
--etcd_servers = <The path that is configured in ETCD_OPTS> \
--portal_net = 11.1.1.0/24 \
--allow_privileged = false \
--kubelet_port = < Port you want to configure> \
--v = 0"

Konfigurieren Sie den kube Controller Manager

Wir müssen den folgenden Inhalt hinzufügen /etc/default/kube-controller-manager.

$ KUBE_CONTROLLER_MANAGER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--machines = kube-minion \ -----> #this is the kubernatics node
--v = 0

Konfigurieren Sie als Nächstes den Kube-Scheduler in der entsprechenden Datei.

$ KUBE_SCHEDULER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--v = 0"

Sobald alle oben genannten Aufgaben erledigt sind, können Sie den Kubernetes Master aufrufen. Dazu starten wir den Docker neu.

$ service docker restart

Kubernetes-Knotenkonfiguration

Der Kubernetes-Knoten führt zwei Dienste aus kubelet and the kube-proxy. Bevor wir fortfahren, müssen wir die heruntergeladenen Binärdateien in die erforderlichen Ordner kopieren, in denen wir den Kubernetes-Knoten konfigurieren möchten.

Verwenden Sie zum Kopieren der Dateien dieselbe Methode wie für kubernetes master. Da nur das Kubelet und der Kube-Proxy ausgeführt werden, werden sie konfiguriert.

$ cp <Path of the extracted file>/kubelet /opt/bin/
$ cp <Path of the extracted file>/kube-proxy /opt/bin/
$ cp <Path of the extracted file>/kubecfg /opt/bin/
$ cp <Path of the extracted file>/kubectl /opt/bin/
$ cp <Path of the extracted file>/kubernetes /opt/bin/

Jetzt kopieren wir den Inhalt in das entsprechende Verzeichnis.

$ cp kubernetes/cluster/ubuntu/init_conf/kubelet.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-proxy.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kubelet /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-proxy /etc/init.d/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/

Wir werden das konfigurieren kubelet und kube-proxy conf Dateien.

Wir werden das konfigurieren /etc/init/kubelet.conf.

$ KUBELET_OPTS = "--address = 0.0.0.0 \
--port = 10250 \
--hostname_override = kube-minion \
--etcd_servers = http://kube-master:4001 \
--enable_server = true
--v = 0"
/

Für kube-proxy konfigurieren wir mit dem folgenden Befehl.

$ KUBE_PROXY_OPTS = "--etcd_servers = http://kube-master:4001 \
--v = 0"
/etc/init/kube-proxy.conf

Schließlich werden wir den Docker-Dienst neu starten.

$ service docker restart

Jetzt sind wir mit der Konfiguration fertig. Sie können dies überprüfen, indem Sie die folgenden Befehle ausführen.

$ /opt/bin/kubectl get minions