Kubernetes Dashboard bereitstellen und absichern

Das Kubernetes Dashboard ist eine webbasierte, quelloffene Benutzeroberfläche, mit der sich Kubernetes-Cluster visuell verwalten lassen. Es ermöglicht das Bereitstellen von Anwendungen, das Überwachen von Workloads, die Analyse der Clusterleistung sowie das Verfolgen von Echtzeitaktivitäten. Das Dashboard unterstützt die Verwaltung zahlreicher Kubernetes-Ressourcen wie CronJobs, DaemonSets, Deployments, Pods, ReplicaSets und StatefulSets und bietet damit volle Kontrolle über den Cluster.

Diese Anleitung erklärt, wie Sie das Kubernetes Dashboard bereitstellen, Ressourcen über die Benutzeroberfläche verwalten und einen sicheren externen Zugriff mithilfe eines Ingress Controllers konfigurieren.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes eingerichtet haben:

• Zugriff auf einen laufenden Kubernetes-Cluster.
• Kubectl ist installiert und für den Zugriff auf den Cluster konfiguriert.
• Helm ist auf Ihrem lokalen System installiert.

Kubernetes Dashboard installieren

Das Kubernetes Dashboard kann über das offizielle Helm-Repository installiert werden. Befolgen Sie die untenstehenden Schritte, um das Repository hinzuzufügen und das Dashboard im Cluster zu installieren.

Schritt 1: Kubernetes Dashboard Helm-Repository hinzufügen

$ helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/

Schritt 2: Helm-Repositories aktualisieren

$ helm repo update

Schritt 3: Kubernetes Dashboard installieren

$ helm install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --create-namespace --namespace kubernetes-dashboard

Schritt 4: Installation überprüfen

$ kubectl get all -n kubernetes-dashboard

Überprüfen Sie, ob alle Pods, Services und ReplicaSets im Namespace kubernetes-dashboard aktiv und fehlerfrei laufen.

Zugriff auf das Kubernetes Dashboard konfigurieren

Standardmäßig verwendet das Dashboard minimale RBAC-Berechtigungen und erfordert zur Anmeldung ein Bearer-Token. Im Folgenden wird beschrieben, wie Sie ein Service-Konto mit administrativen Rechten erstellen, um sich sicher anzumelden.

Schritt 1: Service-Account-Manifest erstellen

$ nano dashboard-admin-user.yml

Schritt 2: YAML-Konfiguration hinzufügen

apiVersion: v1
kind: ServiceAccount
metadata:
  name: dashboard-admin-user
  namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: dashboard-admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: dashboard-admin-user
  namespace: kubernetes-dashboard

Diese Konfiguration erstellt ein dashboard-admin-user Service-Konto mit vollen Administratorrechten. Für Produktionsumgebungen sollte eine restriktivere Rolle verwendet werden.

Schritt 3: Konfiguration anwenden

$ kubectl apply -f dashboard-admin-user.yml

Schritt 4: Bearer-Token generieren

$ kubectl -n kubernetes-dashboard create token dashboard-admin-user

Kopieren Sie den erzeugten Token-String, um ihn später zur Anmeldung zu verwenden.

Zugriff auf das Kubernetes Dashboard

Nach der Installation können Sie das Dashboard per Portweiterleitung oder über einen Ingress Controller erreichen. Die einfachste Methode ist die Portweiterleitung.

Schritt 1: Portweiterleitung aktivieren

$ kubectl port-forward service/kubernetes-dashboard-kong-proxy 8443:443 -n kubernetes-dashboard

Schritt 2: Zugriff über HTTPS

Öffnen Sie Ihren Browser und rufen Sie eine der folgenden URLs auf:

https://127.0.0.1:8443

oder

https://SERVER-IP:8443

Akzeptieren Sie die Sicherheitswarnung und fügen Sie anschließend das zuvor erzeugte Bearer-Token ein, um sich anzumelden.

Kubernetes Dashboard absichern

Um die Sicherheit zu erhöhen, kann das Dashboard über ein vertrauenswürdiges TLS-Zertifikat mittels eines Ingress Controllers bereitgestellt werden. Dadurch wird ein sicherer Zugriff über HTTPS ermöglicht.

Schritt 1: Nginx Ingress Controller installieren

$ helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
$ helm repo update
$ helm install ingress-nginx ingress-nginx/ingress-nginx --namespace ingress-nginx --create-namespace

Schritt 2: LoadBalancer und DNS prüfen

$ kubectl get services -n ingress-nginx

Notieren Sie die externe IP-Adresse des LoadBalancers und passen Sie die DNS-Einträge Ihrer Domain entsprechend an.

Schritt 3: Cert-Manager installieren

$ helm repo add jetstack https://charts.jetstack.io
$ helm repo update
$ helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --set crds.enabled=true

Schritt 4: ClusterIssuer erstellen

$ nano issuer.yml

Fügen Sie die folgende Konfiguration ein und ersetzen Sie die E-Mail-Adresse durch Ihre eigene:

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: tls-certificate-issuer
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@example.com
    privateKeySecretRef:
      name: letsencrypt-private-key
    solvers:
      - http01:
          ingress:
            ingressClassName: nginx

Schritt 5: ClusterIssuer anwenden

$ kubectl apply -f issuer.yml

Schritt 6: Dashboard-Ingress konfigurieren

$ nano dashboard-ingress.yml

Ersetzen Sie dashboard.example.com durch Ihre tatsächliche Domain und fügen Sie folgendes Manifest ein:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: kubernetes-dashboard-ingress
  namespace: kubernetes-dashboard
  annotations:
    cert-manager.io/cluster-issuer: tls-certificate-issuer
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - dashboard.example.com
      secretName: kubernetes-dashboard-cert
  rules:
    - host: dashboard.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: kubernetes-dashboard-kong-proxy
                port:
                  number: 443

Schritt 7: Ingress anwenden

$ kubectl apply -f dashboard-ingress.yml

Schritt 8: TLS-Zertifikat und Zugriff prüfen

$ kubectl get certificate -n kubernetes-dashboard
$ kubectl get ingress -n kubernetes-dashboard

Sobald alles bereit ist, öffnen Sie:

https://dashboard.example.com

Anwendungen über das Kubernetes Dashboard bereitstellen

Über das Dashboard können Anwendungen entweder durch YAML-Manifeste oder über ein Formular bereitgestellt werden. Das folgende Beispiel zeigt, wie Sie eine Nginx-App deployen.

Schritt 1: Subdomain für Ihre Anwendung erstellen

Erstellen Sie einen DNS-Eintrag, z. B. sample-app.example.com, der auf die externe IP Ihres Ingress Controllers verweist.

Schritt 2: Anwendung über das Dashboard bereitstellen

Öffnen Sie https://dashboard.example.com, melden Sie sich mit Ihrem Token an und klicken Sie auf +, um eine neue Ressource zu erstellen. Wählen Sie Create from form und tragen Sie folgende Angaben ein:

• Anwendungsname: sample-app
• Container-Image: nginxdemos/hello
• Service-Typ: Internal
• Port und Zielport: 80

Wählen Sie den gewünschten Namespace und klicken Sie auf Deploy, um die Anwendung zu starten.

Schritt 3: Ingress für die Anwendung erstellen

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: sample-app-ingress
  annotations:
    cert-manager.io/cluster-issuer: tls-certificate-issuer
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - sample-app.example.com
      secretName: sample-app-cert
  rules:
    - host: sample-app.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: sample-app
                port:
                  number: 80

Diese Konfiguration leitet Anfragen von sample-app.example.com an den Service sample-app weiter und erstellt automatisch ein TLS-Zertifikat für eine sichere HTTPS-Verbindung.

Fazit

Sie haben erfolgreich das Kubernetes Dashboard installiert und abgesichert, den HTTPS-Zugriff konfiguriert und eine Beispielanwendung bereitgestellt. Das Dashboard dient nun als leistungsfähiges webbasiertes Tool zur Verwaltung von Workloads, zur Leistungsüberwachung und zur Orchestrierung Ihrer Kubernetes-Ressourcen.