Wir haben die Möglichkeit hinzugefügt, Kubernetes im Virtual Private Cloud-Dienst im frühen Beta-Testmodus bequem zu starten.
Diese Funktionalität ist nützlich für Benutzer, die eine bequeme Verwaltung einer großen Anzahl von Anwendungen benötigen, die als Container ausgeführt werden. Kubernetes bietet Tools zur Skalierung, Selbstheilung und zum Lastausgleich für Container, die in einem Cluster ausgeführt werden.
Da der Virtual Private Cloud-Dienst auf OpenStack basiert, verwenden wir eine seiner Komponenten - OpenStack Magnum . Sie können damit schnell private Kubernetes-Cluster mit der gewünschten Anzahl von Knoten erstellen.
Derzeit kann jeder Benutzer unseres Dienstes mehrere unabhängige Cluster in seinem Projekt erstellen. Als Clusterknoten werden virtuelle Maschinen verwendet, deren Konfiguration ausgewählt und geändert werden kann.
In diesem Artikel werden wir uns mit den Hauptobjekten des Kubernetes-Clusters befassen und anhand der Beispiele den Prozess zum Erstellen eines Clusters mit OpenStack Magnum untersuchen.
Erstellen und verwalten Sie einen Kubernetes-Cluster
Derzeit ist die Erstellung eines Kubernetes-Clusters nur über Konsolendienstprogramme oder die OpenStack-API in den Verfügbarkeitszonen ru-1a und ru-1b (St. Petersburg) möglich.
Um loszulegen, benötigen Sie:
- Erstellen Sie ein neues oder verwenden Sie ein vorhandenes VPC- Projekt.
- Erstellen Sie einen Benutzer mit einem SSH-Schlüssel .
- Fügen Sie dem erstellten Projekt auf der Projektverwaltungsseite einen Benutzer hinzu.
- Gehen Sie zum Projekt und rufen Sie die Zugriffsdatei auf der Registerkarte Zugriff ab .
- Installieren Sie den Openstack- Konsolenclient mit der Python-Magnumclient-Bibliothek .
- Installieren Sie den kubectl- Konsolenclient.
Um den Openstack- Konsolen-Client zu installieren, können Sie die Anweisungen auf dem Link verwenden. Beachten Sie jedoch, dass Sie für diesen Client auch die Python-Magnumclient- Bibliothek installieren müssen , um die Erstellung von Kubernetes-Clustern zu unterstützen.
Der vollständige Befehlssatz zum Installieren eines Openstack-Clients mit dem erforderlichen Plug-In für Betriebssysteme der Ubuntu / Debian-Familie:
$ sudo apt update $ sudo apt -y install curl python-pip python-dev python3-dev git libxml2-dev libxslt1-dev python-openssl python3-openssl python-pyasn1 libffi-dev libssl-dev build-essential $ sudo pip install -UI pbr setuptools pytz $ sudo pip install -UI git+https://github.com/openstack/python-openstackclient $ sudo pip install -UI git+https://github.com/openstack/python-magnumclient
Vollständiger Befehlssatz für die Installation des Openstack-Clients mit dem erforderlichen Plug-In für Betriebssysteme der Fedora / CentOS-Familie:
$ sudo yum -y install python-pip gcc libffi-devel python-devel libxslt-devel openssl-devel git libffi-devel $ sudo pip install -UI pbr setuptools pytz $ sudo pip install -UI git+https://github.com/openstack/python-openstackclient $ sudo pip install -UI git+https://github.com/openstack/python-magnumclient
Zum Verwalten von Kubernetes-Objekten benötigen Sie den kubectl- Konsolenclient. Installationsmethoden für verschiedene Betriebssysteme sind in der offiziellen Dokumentation beschrieben .
Um einen Cluster zu erstellen, müssen Sie vorhandene erstellen oder verwenden:
- Cluster- Vorlage ;
- Eine Reihe von Parametern für die CPU und den RAM virtueller Maschinen ( Variante ).
Sie können Cluster-Vorlagen erstellen und selbst eine Version erstellen oder öffentliche vorab erstellte Vorlagen verwenden.
Sie müssen auch die Verfügbarkeitszone, den Festplattentyp für Ihren Cluster und die Anzahl der Knoten ermitteln. Es ist zu bedenken, dass wir die Möglichkeit, einen Cluster in mehreren Zonen zu erstellen, noch nicht unterstützen. Sie können einen beliebigen Netzwerktyp auswählen (schnell, universell oder einfach).
Weitere Informationen zu Laufwerkstypen finden Sie in unserer Wissensdatenbank .
Die Anzahl der Knoten kann für Master- und Minion- Rollen unterschiedlich sein. Auf den Knoten, die die Hauptrolle ausführen, werden die Cluster-Steuerelemente gestartet - Controller-Manager , Scheduler , API . Auf den anderen Knoten werden Kubelet- , Kube-Proxy- Dienste und alle Anwendungscontainer gestartet. Weitere Informationen zu den Komponenten, die auf Clusterknoten ausgeführt werden, finden Sie in der offiziellen Dokumentation .
Um über SSH auf Knoten zuzugreifen, müssen Sie den zuvor erstellten SSH-Schlüssel verwenden. Die Beispielbefehle verwenden einen Schlüssel namens ssh-test .
Wir werden die Vorlage und Variante des öffentlichen Clusters, den schnellen Festplattentyp und die Verfügbarkeitszone ru-1b verwenden .
In unserem Cluster werden zunächst 2 Masterknoten und 3 Minionknoten gestartet.
Um diese Parameter zu überprüfen, verwenden wir die openstackclient-Befehle und die heruntergeladene Zugriffsdatei ( rc.sh ):
Als Beispiel wählen wir die zweite Cluster-Vorlage aus, aus der nicht öffentlich zugängliche Floating-Adressen für jeden der Knoten erstellt werden. Wir werden sie nicht brauchen.
# Kubernetes test-cluster # keypair , $ openstack coe cluster create \ --cluster-template kubernetes-nofloatingips-ru-1b-v1.9.9 \ --master-count 2 \ --node-count 3 \ --keypair ssh-test \ --master-flavor BL1.2-4096 \ --flavor BL1.2-4096 \ test-cluster
Bitte beachten Sie, dass wir dieselbe Konfiguration für verschiedene Knoten ausgewählt haben (Master-Flavour- und Flavour-Parameter). Sie können je nach den Anforderungen des Clusters unterschiedliche Konfigurationssätze auswählen. Ihre Änderung ist nach ihrer Schaffung möglich.
Beachten Sie auch, dass beim Erstellen eines Clusters mit mehreren Masterknoten automatisch ein Load Balancer erstellt wird, um auf die Kubernetes-API zuzugreifen.
Nach einigen Minuten wird in Ihrem Projekt ein Kubernetes-Cluster angezeigt. In der Projektsteuerung sehen Sie neue virtuelle Maschinen, Festplatten und Netzwerkobjekte.
Sie können den Status Ihres Clusters über openstackclient überprüfen:
openstack coe cluster list -c name -c status +--------------+--------------------+ | name | status | +--------------+--------------------+ | test-cluster | CREATE_IN_PROGRESS | +--------------+--------------------+
Nachdem der Cluster in den Status CREATE_COMPLETE eingetreten ist, können Sie seine Objekte über das Dienstprogramm kubectl verwalten, indem Sie die Konfigurationsdatei mit den folgenden Befehlen herunterladen:
$ mkdir -p ~/test-cluster $ openstack coe cluster config test-cluster --dir ~/test-cluster
Danach können Sie mit dem Dienstprogramm kubectl mit dem Cluster arbeiten:
$ export KUBECONFIG=~/test-cluster/config $ kubectl get pods --all-namespaces -o=custom-columns=NAME:.metadata.name,STATUS:.status.phase NAME STATUS coredns-785dcf9c58-6gnfp Running heapster-6846cdc674-rm4k6 Running kube-dns-autoscaler-6b94f7bbf8-x5clt Running kubernetes-dashboard-747575c864-wlg6p Running monitoring-grafana-84b4596dd7-zf5rx Running monitoring-influxdb-c8486fc95-bqqb6 Running node-exporter-test-cluster-robvp4cvwpt7-minion-0 Running
Bei Bedarf können Sie die Anzahl der Minion-Knoten im Cluster über openstackclient erhöhen oder verringern, indem Sie den neuen Wert für node_count übergeben:
$ openstack coe cluster update test-cluster replace node_count=4
Wichtige Kubernetes-Clusterobjekte
Pods
Obwohl Kubernetes eine Reihe von Containern verwaltet, ist die zugrunde liegende Entität, die Kubernetes verwaltet, kein Container, sondern ein Pod .
Pod ist eine Reihe von Linux-Kernel-Namespaces und Netzwerkstapel-Einstellungen, mit denen Sie eine Reihe von Containern zu einer einzigen Entität zusammenstellen können.
Meistens wird ein Container mit der Anwendung in einem separaten Pod gestartet.
Bei Bedarf können Sie mehrere Container in einem Pod ausführen. Dies kann hilfreich sein, wenn Sie über die localhost-Netzwerkschnittstelle Zugriff von einem Container auf einen anderen gewähren müssen oder aus einem anderen Grund mehrere Container auf demselben Host ausführen müssen.
Alle Container, die im selben Pod ausgeführt werden, haben einen Hostnamen, eine IP-Adresse, eine Routing-Tabelle und Festplatten.
Beachten Sie, dass beim Skalieren der Anzahl der Instanzen Ihrer Anwendung in Kubernetes die Anzahl der Pods und nicht die Anzahl der Container in einem bestimmten Pod erhöht werden muss.
Weitere Details in der offiziellen Pods- Dokumentation.
Erstellen Sie beispielsweise den einfachsten Pod mit Nginx anhand der Beschreibung im Yaml-Format:
Um einen Pod zu erstellen, können wir das Dienstprogramm kubectl verwenden .
Wir haben alle im Artikel vorgestellten Beispiele zu unserer Github-Gruppe hinzugefügt, sodass Sie keine Dateien auf Ihrem Computer erstellen können, sondern die Datei-URL aus dem öffentlichen Repository verwenden :
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/pods/nginx-basic.yaml
Nach der Erstellung können wir mit dem Befehl kubectl description vollständige Informationen zum Status des Pods anfordern:
$ kubectl describe pod nginx Name: nginx Namespace: default Node: test-cluster-nd5c5y6lsfxb-minion-0/10.0.0.5 Start Time: Sun, 17 Jun 2018 12:29:03 +0000 Labels: <none> Annotations: <none> Status: Running IP: 10.100.88.9 Containers: nginx: Container ID: docker://6ca6383b66686c05c61c1f690737110e0f8994eda393f44a7ebfbbf2b2026267 Image: library/nginx:1.14-alpine Image ID: docker-pullable://docker.io/nginx@sha256:944b79ca7dbe456ce72e73e70816c1990e39967c8f010349a388c00b77ec519c Port: 80/TCP Host Port: 0/TCP State: Running Started: Sun, 17 Jun 2018 12:29:16 +0000 Ready: True Restart Count: 0 Environment: <none> Mounts: /var/run/secrets/kubernetes.io/serviceaccount from default-token-rp5ls (ro) Conditions: Type Status Initialized True Ready True PodScheduled True Volumes: default-token-rp5ls: Type: Secret (a volume populated by a Secret) SecretName: default-token-rp5ls Optional: false QoS Class: BestEffort Node-Selectors: <none> Tolerations: <none> Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Scheduled 52s default-scheduler Successfully assigned nginx to test-cluster-nd5c5y6lsfxb-minion-0 Normal SuccessfulMountVolume 51s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 MountVolume.SetUp succeeded for volume "default-token-rp5ls" Normal Pulling 50s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 pulling image "library/nginx:1.14-alpine" Normal Pulled 39s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 Successfully pulled image "library/nginx:1.14-alpine" Normal Created 39s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 Created container Normal Started 39s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 Started container
Wie Sie sehen können, wurde Pod auf einem Knoten mit dem Namen test-cluster-nd5c5y6lsfxb-minion-0 gestartet und erhielt eine interne IP-Adresse von 10.100.88.9.
Im Abschnitt "Ereignisse" können Sie die wichtigsten Startereignisse anzeigen. Wählen Sie einen Knoten zum Starten aus und laden Sie das Image herunter.
Wir können in den Pod gelangen und den Status der Prozesse im Container überprüfen:
$ kubectl exec -it nginx sh ps aux PID USER TIME COMMAND 1 root 0:00 nginx: master process nginx -g daemon off; 7 nginx 0:00 nginx: worker process 20 root 0:00 sh 24 root 0:00 ps aux exit
Es ist zu beachten, dass die IP-Adresse 10.100.88.9 nicht für andere Anwendungen innerhalb und außerhalb des Kubernetes-Clusters verfügbar ist. Der Zugriff auf das laufende Nginx ist nur über den Pod selbst möglich:
$ ping -c 1 10.100.88.9 PING 10.100.88.9 (10.100.88.9): 56 data bytes --- 10.100.88.9 ping statistics --- 1 packets transmitted, 0 packets received, 100% packet loss $ kubectl exec nginx -- ping -c1 10.100.88.9 PING 10.100.88.9 (10.100.88.9): 56 data bytes 64 bytes from 10.100.88.9: seq=0 ttl=64 time=0.075 ms --- 10.100.88.9 ping statistics --- 1 packets transmitted, 1 packets received, 0% packet loss round-trip min/avg/max = 0.075/0.075/0.075 ms
Neben der Tatsache, dass auf die angegebene IP-Adresse nur vom Container aus zugegriffen werden kann, ist sie auch nicht permanent. Dies bedeutet, dass dieser Pod bei einer Neuerstellung eine andere IP-Adresse erhalten kann.
Um diese Probleme zu lösen, können Sie ein Objekt namens Service verwenden.
Dienstleistungen
Mit dem Dienst können Sie Pods permanente IP-Adressen zuweisen, ihnen Zugriff von externen Netzwerken gewähren und Anforderungen zwischen Pods ausgleichen.
Weitere Informationen zum Service finden Sie in der offiziellen Dokumentation .
Zum Beispiel müssen wir den laufenden Pod entfernen:
$ kubectl delete pod nginx
Fügen Sie der Beschreibung des Pods ein Etikett (Label) hinzu, das für den Service erforderlich ist:
Wir benötigen auch eine Beschreibung des Service:
Pod und Service erstellen:
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/pods/nginx-labeled.yaml \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/services/nginx-nodeport.yaml
Da der erstellte Dienst vom Typ NodePort ist, wird der von uns auf allen Netzwerkschnittstellen angegebene Port 30001 auf allen Knoten des Clusters geöffnet.
Dies bedeutet, dass wir, wenn wir einem Knoten eine externe IP-Adresse hinzufügen, über ein externes Netzwerk mit Nginx auf den laufenden Pod zugreifen können.
Um die externen Adressen der Clusterknoten nicht für den Zugriff auf den Service zu verwenden, können Sie anstelle von NodePort den Typ LoadBalancer verwenden.
Wir benötigen eine neue Beschreibung des Dienstes:
Löschen Sie den aktuellen Dienst und wenden Sie die neue Beschreibung an:
$ kubectl delete service nginx-service $ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/services/nginx-loadbalancer.yaml
Nach dem Starten des Dienstes ist Nginx auf TCP-Port 80 über ein externes Netzwerk verfügbar, und es ist nicht erforderlich, externe Adressen für Clusterknoten zuzuweisen und zu verwenden. Der Dienst vom Typ LoadBalancer weist Ihrem VPC-Projekt automatisch eine neue externe Adresse zu und beginnt mit deren Verwendung.
Informationen zur hervorgehobenen externen Adresse erhalten Sie mit kubectl:
$ kubectl get service nginx-service -o=custom-columns=IP:status.loadBalancer.ingress[0].ip IP xxx.xxx.xxx.xxx
In unseren Beispielen wurde nur ein Pod mit Nginx gestartet. Um die Anwendung auf mehrere Pods zu skalieren, können wir die Bereitstellung verwenden.
Bereitstellungen
Die Bereitstellung ist die Essenz des Kubernetes-Clusters, mit dem Sie Pods skalieren und Versionen für eine große Anzahl von Pods bequem aktualisieren oder zurücksetzen können.
Anstelle der Bereitstellung können Sie auch das ReplicaSet-Objekt verwenden. In unseren Beispielen wird darauf jedoch nicht eingegangen.
Weitere Informationen zur Bereitstellung finden Sie in der offiziellen Dokumentation .
Wir müssen den Pod erneut entfernen (wir müssen den Service nicht entfernen):
$ kubectl delete pod nginx
Fügen Sie die folgende Bereitstellungsbeschreibung hinzu:
Erstellen Sie die angegebene Bereitstellung:
$ kubectl create -f \ https://raw.githubusercontent.com/selectel/kubernetes-examples/master/deployments/nginx-1.14.yaml
Wir haben 10 als Replikat-Parameter ausgewählt, sodass 10 Pods mit der Nginx-Anwendung in unserem Cluster erstellt werden:
$ kubectl get pods --selector app=webservice NAME READY STATUS RESTARTS AGE nginx-deployment-54bfdc4489-42rrb 1/1 Running 0 4m nginx-deployment-54bfdc4489-5lvtc 1/1 Running 0 4m nginx-deployment-54bfdc4489-g7rk2 1/1 Running 0 4m nginx-deployment-54bfdc4489-h5rxp 1/1 Running 0 4m nginx-deployment-54bfdc4489-l9l2d 1/1 Running 0 4m nginx-deployment-54bfdc4489-pjpvg 1/1 Running 0 4m nginx-deployment-54bfdc4489-q8dnp 1/1 Running 0 4m nginx-deployment-54bfdc4489-s4wzf 1/1 Running 0 4m nginx-deployment-54bfdc4489-tfxf9 1/1 Running 0 4m nginx-deployment-54bfdc4489-xjzb5 1/1 Running 0 4m
Sie können über das externe Netzwerk mit dem im vorherigen Abschnitt erstellten Dienst auf die ausgeführte Anwendung zugreifen. Der Dienst gleicht automatisch Anforderungen aus dem externen Netzwerk zwischen 10 Nginx-Instanzen aus.
Bei Bedarf können wir die Version von Nginx aktualisieren. Aktualisieren Sie die Bereitstellungsbeschreibung, indem Sie die Version des Bildes von 1.14-alpine auf 1.15-alpine ändern:
Um den Prozess der Aktualisierung von Pods zu starten, verwenden wir den Befehl kubectl. Achten Sie auf das Argument --record, es ist nützlich für das spätere bequeme Rollback der Nginx-Version:
$ kubectl apply -f \ https://raw.githubusercontent.com/selectel/kubernetes-examples/master/deployments/nginx-1.15.yaml \ --record
Sie können den Fortschritt der Aktualisierung mit dem folgenden Befehl überwachen:
$ kubectl rollout status deployment nginx-deployment Waiting for rollout to finish: 4 out of 10 new replicas have been updated...
Kubernetes wartet 10 Sekunden nach einer erfolgreichen Aktualisierung eines Pods, da wir in der Deployment-Beschreibung den Wert 10 für den Parameter minReadySeconds angegeben haben.
Nach Abschluss des Updates werden alle Pods für die Bereitstellung in einen aktiven Zustand versetzt:
$ kubectl get deployment --selector app=webservice NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE nginx-deployment 10 10 10 10 23m
Wir können die Version der Anwendung zurücksetzen, wenn ein Fehler aufgetreten ist. Dazu müssen wir die gewünschte Bereitstellungsversion auswählen:
$ kubectl rollout history deployment nginx-deployment deployments "nginx-deployment" REVISION CHANGE-CAUSE 1 <none> 2 kubectl apply --filename=https://raw.githubusercontent.com/selectel/kubernetes-examples/master/deployments/nginx-1.15.yaml --record=true
Die Befehlsausgabe enthält zwei Revisionen: Die erste ist die ursprüngliche Erstellung der Bereitstellung, die zweite ist das Update. Da wir beim Aktualisieren das Argument --record verwendet haben, wird der Befehl angezeigt, mit dem die zweite Revision von Deployment erstellt wurde.
Verwenden Sie den folgenden Befehl, um die Version zurückzusetzen:
$ kubectl rollout undo deployment nginx-deployment --to-revision=1
Ebenso können wir mit dem Update das Rollback der Version mit dem folgenden Befehl überwachen:
$ kubectl rollout status deployment nginx-deployment Waiting for rollout to finish: 6 out of 10 new replicas have been updated…
In all unseren Beispielen haben wir Container ohne persistenten Datenspeicher verwendet. Im nächsten Abschnitt werden wir das Problem beheben.
Datenspeicherung
Standardmäßig sind alle Daten von Containern, die in Pods ausgeführt werden, kurzlebig und gehen verloren, wenn Pods abstürzen.
Mit dem PersistentVolumeClaim-Objekt können Sie Pods mit einem persistenten Data Warehouse ausführen.
Das Erstellen eines solchen Objekts in einem Cluster ist sehr einfach. Fügen Sie einfach seine Beschreibung hinzu, ähnlich wie wir in den vorherigen Abschnitten Pod, Service oder Bereitstellung erstellt haben.
Weitere Informationen finden Sie in der offiziellen Dokumentation .
Beispielbeschreibung von PersistentVolumeClaim beim Erstellen einer 10-GB-Festplatte:
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: my-pv-claim spec: accessModes: - ReadWriteOnce resources: requests: storage: 10Gi
Wir können es als Datenträger mit unserem Pod verbinden, indem wir die Beschreibung des Pods mit Nginx aktualisieren, das zuvor erstellt wurde:
Damit der Datenträger erstellt werden kann, müssen Sie jedoch die Eigenschaften des erstellten Datenträgers in Form von StorageClass angeben. Im Dienst "Virtual Private Cloud" können Sie Netzlaufwerke schneller, universeller und grundlegender Typen als permanente Speicherung von Kubernetes Pod-Daten verwenden.
Um beispielsweise eine StorageClass zu erstellen, mit der Sie schnelle Festplatten in der Verfügbarkeitszone ru-1b verwenden können, benötigen Sie die folgende Beschreibung:
Löschen Sie vor dem Erstellen der angegebenen Objekte die zuvor erstellte Bereitstellung:
$ kubectl delete deployment nginx-deployment
Lassen Sie uns zunächst eine StorageClass erstellen, damit sie zur Standardklasse wird, und später erstellte PersistentVolumeClaim verwendet sie:
$ kubectl create -f \ https://raw.githubusercontent.com/selectel/kubernetes-examples/master/storageclasses/fast.ru-1b.yaml
Erstellen Sie PersistentVolumeClaim und Pod:
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/persistentvolumeclaims/my-pv-claim.yaml \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/pods/nginx-with-volume.yaml
Danach wird in Ihrem Projekt automatisch eine Festplatte erstellt, die mit einem der Minion-Knoten des Clusters verbunden wird. Wenn es herunterfällt, wechselt die Festplatte automatisch zu einem anderen Knoten.
Wir können die Festplatte im Container mit Nginx sehen:
$ kubectl exec -it nginx sh mount | grep "/var/www/html" /dev/sdc on /var/www/html type ext4 (rw,seclabel,relatime,data=ordered) exit
Sie können das Laufwerk mit Deployment verbinden. Ein entsprechendes Beispiel finden Sie in der offiziellen Dokumentation .
Kubernetes-Systemsteuerung
Sie können das integrierte Dashboard von Kubernetes selbst verwenden, um den Status von Clusterobjekten und deren Verwaltung anzuzeigen.
Um auf alle Funktionen des Panels zugreifen zu können, müssen Sie ein Konto mit der Administratorrolle in Ihrem Cluster erstellen.
Dazu benötigen wir eine Kontobeschreibung:
Und Rollenbeschreibung:
Erstellen Sie die angegebenen Objekte:
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/accounts/admin-user.yaml \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/clusterrolebindings/cluster-admin.yaml
Als Nächstes müssen Sie den Wert des generierten Tokens für dieses Konto ermitteln.
Suchen Sie dazu das entsprechende Secret-Objekt im Cluster:
$ kubectl get secret --namespace=kube-system | grep "admin-user-token" admin-user-token-bkfhb kubernetes.io/service-account-token 3 22m
Und schauen Sie sich den Token-Wert des gefundenen Geheimnisses mit dem Namen admin-user-token-bkfhb an:
$ kubectl describe secret admin-user-token-bkfhb --namespace=kube-system | grep "token:" token: XXXXXX...
Als Antwort erhalten Sie den Wert des Tokens, speichern ihn, er wird uns in Zukunft nützlich sein.
Einzelheiten zur Zugriffskontrolle für Kubernetes-Objekte finden Sie in der offiziellen Dokumentation .
Für den Fall, dass Sie einen Cluster aus einer öffentlichen Vorlage erstellt haben, sind Pod und Service bereits vorhanden, um den Betrieb des Panels sicherzustellen:
$ kubectl get svc kubernetes-dashboard --namespace=kube-system 206ms Tue Jun 19 14:35:19 2018 NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes-dashboard ClusterIP 10.254.122.245 <none> 443/TCP 2d $ kubectl get pod --namespace=kube-system --selector k8s-app=kubernetes-dashboard 119ms Tue Jun 19 14:36:48 2018 NAME READY STATUS RESTARTS AGE kubernetes-dashboard-747575c864-jpxvt 1/1 Running 0 2d
Da der Dienst vom Typ ClusterIP ist, ist er nur innerhalb des Clusters selbst verfügbar.
Sie können mit der Cluster-Konfigurationsdatei von Ihrem Arbeitscomputer aus mit dem Befehl kubectl auf das Panel zugreifen:
$ kubectl proxy Starting to serve on 127.0.0.1:8001
Testen Sie den Proxy, indem Sie die angegebene Adresse im Browser öffnen:
Wenn Sie eine Antwort ähnlich dem Screenshot sehen, können Sie unter der folgenden Adresse zum Bedienfeldbildschirm wechseln:
http://127.0.0.1:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/
Wenn Sie es durchgehen, sollte der Anmeldebildschirm im Bedienfeld angezeigt werden:
Sie müssen das zuvor empfangene Token angeben. Nach dem Anmelden können Sie das Bedienfeld verwenden:
Informationen zu allen Funktionen des Bedienfelds finden Sie in der offiziellen Dokumentation .
Überwachen von Kubernetes-Objekten
Wenn Sie die Vorlage für öffentliche Cluster verwenden, führen Sie automatisch die Komponenten zum Sammeln und Anzeigen von Metriken aus - Prometheus und Grafana.
Ähnlich wie in der Systemsteuerung wird ClusterIP als Diensttyp installiert. Der Zugriff darauf ist nur innerhalb des Clusters oder über den kubectl-Proxy möglich. Sie können von Ihrem Arbeitscomputer aus unter der folgenden Adresse auf Grafana zugreifen:
http://127.0.0.1:8001/api/v1/proxy/namespaces/kube-system/services/monitoring-grafana:80
Fazit
In diesem Artikel haben wir die am häufigsten verwendeten Kubernetes-Objekte untersucht und Beispiele zum Starten und Verwalten eines Clusters mit OpenStack Magnum untersucht.
In naher Zukunft wird es möglich sein, die neuesten Kubernetes-Versionen zu verwenden, und die Clusterverwaltung wird über das Control Panel verfügbar sein.
Wir freuen uns, wenn Sie unseren Service im Testmodus nutzen und Feedback geben.