Wie man

Authentifizieren von Kubernetes-Dashboard-Benutzern mit Active Directory

Authentifizieren von Kubernetes-Dashboard-Benutzern mit Active Directory

Das Kubernetes-Dashboard ist eine webbasierte Benutzeroberfläche, die es Benutzern ermöglicht, einfach mit dem Kubernetes-Cluster zu interagieren. Es ermöglicht Benutzern, Anwendungen sowie den Cluster zu verwalten, zu überwachen und Fehler zu beheben. Wir haben uns in diesem Tutorial bereits angesehen, wie das Dashboard bereitgestellt wird. In diesem Handbuch werden wir die Integration des Kubernetes-Dashboards in Active Directory untersuchen, um die Benutzer- und Passwortverwaltung zu vereinfachen.

Kubernetes unterstützt zwei Benutzerkategorien:

Dazu verwenden wir ein Projekt namens Dex. Dex ist ein OpenID Connect-Anbieter von CoreOS. Es kümmert sich um die Übersetzung zwischen Kubernetes-Token und Active Directory-Benutzern.

Einrichtungsanforderungen:

Schritt 1: Dex auf Kubernetes-Cluster bereitstellen

Wir müssen zuerst einen Namespace erstellen, ein Dienstkonto für dex erstellen create. Dann konfigurieren wir RBAC-Regeln für das Dex-Dienstkonto, bevor wir es bereitstellen. Dies soll sicherstellen, dass die Anwendung über die richtigen Berechtigungen verfügt.

  1. Erstellen Sie einen Dex-Namespace.yaml-Datei.
$ vim dex-namespace.yaml apiVersion: v1 Art: Namespace-Metadaten: Name: Auth-System 

2. Erstellen Sie den Namensraum für Dex.

$ kubectl apply -f dex-namespace.jaml

3. Erstellen Sie einen Dex-rbac.yaml-Datei.

$ vim dex-rbac.yaml apiVersion: v1 Art: ServiceAccount Metadaten: Name: Dex Namespace: Auth-System --- apiVersion: rbac.Genehmigung.k8s.io/v1beta1 Art: ClusterRole-Metadaten: Name: dex Namespace: Authentifizierungssystemregeln: - apiGroups: ["dex.Kernos.com"] Ressourcen: ["*"] Verben: ["*"] - apiGroups: ["apiextensions.k8s.io"] resources: ["customresourcedefinitions"] Verben: ["create"] --- apiVersion: rbac.Genehmigung.k8s.io/v1beta1 Art: ClusterRoleBinding Metadaten: Name: Dex Namespace: Auth-System RoleRef: apiGroup: rbac.Genehmigung.k8s.io Art: ClusterRole-Name: Dex-Subjekte: - Art: ServiceAccount-Name: Dex-Namespace: Auth-System

4. Erstellen Sie die Berechtigungen für Dex.

$ kubectl apply -f dex-rbac.jaml

5. Erstellen Sie eine dex-configmap.yaml-Datei. Stellen Sie sicher, dass Sie die Aussteller-URL, die Umleitungs-URIs, das Client-Geheimnis und die Active Directory-Konfiguration entsprechend ändern.

$ vim dex-configmap.yaml-Art: ConfigMap apiVersion: v1 Metadaten: Name: Dex Namespace: Authentifizierungssystem Daten: config.jaml: | Herausgeber: https://auth.Kubernetes.meinedomain.com/web: http: 0.0.0.0:5556 Frontend: Thema: benutzerdefinierte Telemetrie: http: 0.0.0.0:5558 staticClients: - ID: oidc-auth-client redirectURIs: - https://kubectl.Kubernetes.meinedomain.com/callback - http://dashtest.Kubernetes.meinedomain.com/oauth2/callback name: oidc-auth-client geheim: geheime Konnektoren: - type: ldap id: ldap name: LDAP config: host: 172.16.16.16:389 insecureNoSSL: true insecureSkipVerify: true bindDN: ldapadmin bindPW: 'KJZOBwS9DtB' userSearch: baseDN: OU=computingforgeeksabteilungen,DC=computingforgeeks ,DC=net username: sAMAccountName idAttr: mail groupsName =groups,OU=computingforgeeks,DC=computingforgeeks,DC=net userMatchers: - userAttr: sAMAccountName groupAttr: memberOf nameAttr: GivenName oauth2: skipApprovalScreen: true storage: type: kubernetes config: inCluster: true

6. Dex konfigurieren.

$ kubectl apply -f dex-configmap.jaml

7. Erstellen Sie die Dex-Bereitstellung.yaml-Datei.

$ vim dex-Bereitstellung.yaml apiVersion: extensions/v1beta1 Art: Bereitstellungsmetadaten: Labels: App: Dex-Name: Dex-Namespace: Authentifizierungssystem-Spezifikation: Replikate: 1 Selektor: matchLabels: App: Dex-Strategie: RollingUpdate: maxSurge: 1 maxUnavailable: 1 Typ: RollingUpdate-Vorlage : Metadaten: Labels: App: Dex Revision: "1" Spezifikation: Container: - Befehl: - /usr/local/bin/dex - Serve - /etc/dex/cfg/config.Yaml-Bild: Kai.io/dexidp/dex:v2.17.0 imagePullPolicy: IfNotPresent Name: Dex Ports: - ContainerPort: 5556 Name: http-Protokoll: TCP-Ressourcen:  TerminationMessagePath: /dev/termination-log TerminationMessagePolicy: File volumeMounts: - mountPath: /etc/dex/cfg Name: config - mountPath : /web/themes/custom/ name: theme dnsPolicy: ClusterFirst serviceAccountName: dex restartPolicy: Always schedulerName: default-scheduler securityContext:  TerminationGracePeriodSeconds: 30 Volumes: - configMap: defaultMode: 420 Elemente: - Schlüssel: config.yaml-Pfad: config.Yaml-Name: Dex-Name: config - Name: Thema emptyDir:  

8. Dex bereitstellen.

$ kubectl apply -f dex-deployment.jaml

9. Erstellen Sie einen Dex-Dienst.yaml-Datei.

$ vim dex-service.yaml apiVersion: v1 Art: Dienstmetadaten: Name: Dex-Namespace: Authentifizierungssystem-Spezifikation: Selektor: App: Dex-Ports: - Name: Dex-Port: 5556 Protokoll: TCP targetPort: 5556

10. Erstellen Sie einen Dienst für die Dex-Bereitstellung.

$ kubectl apply -f dex-service.jaml

11. Erstellen Sie ein Dex-Ingress-Secret. Stellen Sie sicher, dass sich die Zertifikatsdaten für den Cluster am angegebenen Speicherort befinden oder ändern Sie diesen Pfad so, dass er darauf verweist. Wenn in Ihrem Cluster ein Certificate Manager installiert ist, können Sie diesen Schritt überspringen.

$ kubectl create secret tls dex --key /data/Certs/kubernetes.meinedomain.com.Schlüssel --cert /data/Certs/ kubernetes.meinedomain.com.crt -n Authentifizierungssystem

12. Erstellen Sie einen Dex-Ingress.yaml-Datei. Ändern Sie die Hostparameter und den Namen Ihres Zertifikatsausstellers entsprechend.

$ vim dex-ingress.yaml apiVersion: extensions/v1beta1 Art: Ingress-Metadaten: Name: Dex Namespace: Authentifizierungssystem Anmerkungen: Kubernetes.io/tls-acme: "echter" Ingress.Kubernetes.io/force-ssl-redirect: "true" spec: tls: - secretName: dex hosts: - auth.Kubernetesuat.meinedomain.com-Regeln: - Host: auth.Kubernetes.meinedomain.com http: Pfade: - Backend: serviceName: dex servicePort: 5556

13. Erstellen Sie den Ingress für den Dex-Dienst.

$ kubectl apply -f dex-ingress.jaml

Warten Sie einige Minuten, bis der Zertifikatsmanager ein Zertifikat für Dex generiert. Sie können überprüfen, ob Dex ordnungsgemäß bereitgestellt wird, indem Sie zu https://auth . navigieren.Kubernetesuat.meinedomain.com/.bekannte/openid-Konfiguration

Schritt 2: Kubernetes-API für den Zugriff auf Dex als OpenID-Connect-Anbieter konfigurieren

Als Nächstes sehen wir uns an, wie der API-Server sowohl für einen RKE- als auch für einen Kubeadm-Cluster konfiguriert wird. Um das OIDC-Plugin zu aktivieren, müssen wir die verschiedenen Flags auf dem API-Server wie hier gezeigt konfigurieren:

EIN. RKE-CLUSTER

1. SSH zu Ihrem rke-Knoten.

$ ssh [email protected]

2. Bearbeiten Sie die Kubernetes-API-Konfiguration. Fügen Sie die OIDC-Parameter hinzu und ändern Sie die Aussteller-URL entsprechend.

$ sudo vim ~/Rancher/cluster.yml kube-api: service_cluster_ip_range: 10.43.0.0/16 # Offenlegen eines anderen Portbereichs für NodePort-Dienste service_node_port_range: 30000-32767 extra_args: # Audit-Log auf stdout aktivieren audit-log-path: "-" # Anzahl der Löscharbeiter erhöhen delete-collection-workers: 3 # Festlegen der Level der Log-Ausgabe auf Debug-Level v: 4 #ADD THE FOLLOWING LINES oidc-issuer-url: https://auth.Kubernetes.meinedomain.com/ oidc-client-id: oidc-auth-client oidc-ca-file: /data/Certs/kubernetes.meinedomain.com.crt oidc-username-claim: email oidc-groups-claim: groups extra_binds: - /data/Certs:/data/Certs ##SICHERSTELLEN, DASS DIE WILDCARD-ZERTIFIKATE IN DIESEM DATEIPFAD IN ALLEN MASTER-NODES VORHANDEN SIND

3. Die Kubernetes-API wird von selbst neu gestartet, sobald Sie ein RKE UP ausführen.

$ rke auf

B. KUBEADM-CLUSTER

1. SSH zu Ihrem Knoten.

$ ssh [email protected]

2. Bearbeiten Sie die Kubernetes-API-Konfiguration. Fügen Sie die OIDC-Parameter hinzu und ändern Sie die Aussteller-URL entsprechend.

$ sudo vim /etc/kubernetes/manifests/kube-apiserver.yaml… Befehl: - /hyperkube - apiserver - --advertise-address=10.10.40.30 #FOLGENDE ZEILEN HINZUFÜGEN:… - --oidc-issuer-url=https://auth.Kubernetes.meinedomain.com/ - --oidc-client-id=oidc-auth-client ##SICHERSTELLEN, DASS DIE WILDCARD-ZERTIFIKATE IN DIESEM DATEIPFAD IN ALLEN MASTER-NODES VORHANDEN SIND: - --oidc-ca-file=/etc/ssl/kubernetes/kubernetes.meinedomain.com.crt - --oidc-username-claim=email - --oidc-groups-claim=groups… 

3. Die Kubernetes API wird von selbst neu gestartet.

SCHRITT 3: Stellen Sie den Oauth2-Proxy bereit und konfigurieren Sie den Kubernetes-Dashboard-Ingress

1. Generieren Sie ein Geheimnis für den Oauth2-Proxy.

python -c 'importieren os,base64; base64 drucken.urlsafe_b64encode(os.Urand(16))'

2. Kopieren Sie das generierte Geheimnis und verwenden Sie es für die OAUTH2_PROXY_COOKIE_SECRET Wert im nächsten Schritt.

3. Erstellen Sie eine oauth2-Proxy-Bereitstellung.yaml-Datei. Ändern Sie das OIDC-Client-Geheimnis, die OIDC-Aussteller-URL und das Oauth2-Proxy-Cookie-Geheimnis entsprechend.

$ vim oauth2-proxy-deployment.yaml apiVersion: extensions/v1beta1 Art: Bereitstellungsmetadaten: Labels: k8s-app: oauth2-proxy name: oauth2-proxy namespace: auth-system spec: repliks: 1 Selektor: matchLabels: k8s-app: oauth2-proxy Vorlage: Metadaten: Labels: k8s-app: oauth2-proxy-Spezifikation: Container: - Argumente: - --cookie-secure=false - --provider=oidc - --client-id=oidc-auth-client - --client-secret=* ********** - --oidc-issuer-url=https://auth.Kubernetes.meinedomain.com/ - --http-adresse=0.0.0.0:8080 - --upstream=file:///dev/null - --email-domain=* - --set-authorization-header=true env: # docker run -ti --rm python:3-alpine python -c 'Geheimnisse importieren,base64; drucken (base64.b64encode(base64.b64encode(Geheimnisse.token_bytes(16))));' - Name: OAUTH2_PROXY_COOKIE_SECRET Wert: ********** Bild: sguyennet/oauth2-proxy:header-2.2 imagePullPolicy: Immer Name: oauth2-proxy Ports: - containerPort: 8080 Protokoll: TCP

4. Stellen Sie den Oauth2-Proxy bereit.

$ kubectl apply -f oauth2-proxy-deployment.jaml

5. Erstellen Sie einen oauth2-Proxy-Dienst.yaml-Datei.

$ vim oauth2-proxy-service.yaml apiVersion: v1 Art: Dienstmetadaten: Labels: k8s-app: oauth2-proxy name: oauth2-proxy namespace: auth-system spec: ports: - name: http port: 8080 protocol: TCP targetPort: 8080 selector: k8s-app : oauth2-proxy

6. Erstellen Sie einen Dienst für die OAuth2-Proxy-Bereitstellung.

$ kubectl apply -f oauth2-proxy-service.jaml

7. Erstellen Sie einen Dashboard-Ingress.yaml-Datei. Ändern Sie die Dashboard-URLs und den Host-Parameter entsprechend.

$ vim Dashboard-Ingress.yaml apiVersion: extensions/v1beta1 Art: Ingress-Metadaten: Name: Kubernetes-Dashboard Namespace: Kube-System Anmerkungen: nginx.eindringen.Kubernetes.io/auth-url: "https://dashboard.Kubernetes.meinedomain.com/oauth2/auth" nginx.eindringen.Kubernetes.io/auth-signin: "https://dashboard.Kubernetes.meinedomain.com/oauth2/start?rd=https://$host$request_uri$is_args$args" nginx.eindringen.Kubernetes.io/secure-backends: "echtes" nginx.eindringen.Kubernetes.io/Konfigurations-Schnipsel: | auth_request_set $token $upstream_http_authorization; proxy_set_header Autorisierung $token; Spezifikation: Regeln: - Host: Dashboard.Kubernetes.meinedomain.com http: Pfade: - Backend: serviceName: kubernetes-dashboard servicePort: 443 Pfad: /

8. Erstellen Sie den Ingress für den Dashboard-Dienst.

$ kubectl apply -f Dashboard-ingress.jaml

9. Erstellen Sie ein kubernetes-dashboard-external-tls-Ingress-Secret. Stellen Sie sicher, dass sich die Zertifikatsdaten für den Cluster am angegebenen Speicherort befinden oder ändern Sie diesen Pfad so, dass er darauf verweist. Überspringen Sie diesen Schritt, wenn Sie einen Zertifikatsmanager verwenden.

$ kubectl create secret tls kubernetes-dashboard-external-tls --key /data/Certs/ kubernetes.meinedomain.com.Schlüssel --cert /data/Certs/ kubernetes.meinedomain.com.crt -n Authentifizierungssystem

10. oauth2-proxy-ingress erstellenin.yaml-Datei. Ändern Sie den Aussteller des Zertifikatsmanagers und die Hostparameter entsprechend.

$ vim oauth2-proxy-ingress.yaml apiVersion: extensions/v1beta1 Art: Ingress-Metadaten: Anmerkungen: Kubernetes.io/tls-acme: "echter" Ingress.Kubernetes.io/force-ssl-redirect: "wahrer" Name: oauth-proxy-Namespace: Auth-Systemspezifikation: Regeln: - Host: Dashboard.Kubernetes.meinedomain.com http: Pfade: - Backend: serviceName: oauth2-proxy servicePort: 8080 Pfad: /oauth2 tls: - Hosts: - Dashboard.Kubernetes.meinedomain.com secretName: kubernetes-dashboard-external-tls

10. Erstellen Sie den Ingress für den Oauth2-Proxy-Dienst.

$ kubectl apply -f oauth2-proxy-ingress.jaml

11. Erstellen Sie die Rollenbindung.

$ kubectl Rollenbindung erstellen -Rollenbindung- --clusterrole=admin --user= -nein  e.g kubectl create rolebinding mkemei-rolebinding-default --clusterrole=admin [email protected] -n default // Beachten Sie, dass bei Benutzernamen die Groß-/Kleinschreibung beachtet wird und wir das richtige Format bestätigen müssen, bevor Sie die Rollenbindung anwenden.

12. Warten Sie ein paar Minuten und navigieren Sie zu https://dashboard.Kubernetes.meinedomain.com.

13. Melden Sie sich mit Ihrem Active Directory-Benutzer an.

Wie Sie unten sehen können: [email protected] sollte den Standard-Namespace sehen und ändern können.

Weitere Artikel zu Kubernetes ansehen:

Überwachen von Kubernetes-Bereitstellungen mit Kubernetes Operational View

So senden Sie Kubernetes-Protokolle an externe Elasticsearch

So führen Sie einen Git-Klon in der Kubernetes-Pod-Bereitstellung durch

Der Unterschied zwischen Bitcoin und Ethereum prüft, welches besser ist!
Nach Bitcoin (BTC) ist das Ethereum (ETH)-Netzwerk wohl die zweitbeliebteste digitale Währung der Welt. Tatsächlich kann man sagen, dass es die zweitg...
Können Sie Bitcoin als Zahlungsmethode verwenden??
2021 hätte kein besseres Jahr für Bitcoin werden können. Diese Kryptowährung hat es geschafft, Höhen zu erreichen, die noch nie da waren und die niema...
Virtuelle Realität iGaming Extraktnotizen
Bis vor 10-15 Jahren wurden hauptsächlich Mobiltelefone zum Telefonieren verwendet. Die Bildschirme waren klein, das Internet langsam und teuer und di...