So greifen Sie von Ihren Pods aus auf die API Ihres Kubernetes-Clusters zu

0
54

Die Kubernetes-API ist Ihr Weg zur Überprüfung und Verwaltung der Vorgänge Ihres Clusters. Sie können die API mit der Kubectl-CLI, Tools wie curl oder den offiziellen Integrationsbibliotheken für gängige Programmiersprachen nutzen.

Die API steht auch Anwendungen innerhalb Ihres Clusters zur Verfügung. Kubernetes-Pods erhalten automatisch Zugriff auf die API und können sich über ein bereitgestelltes Dienstkonto authentifizieren. Sie führen Interaktionen durch, indem Sie die eingefügten Umgebungsvariablen und Zertifikatsdateien verwenden, um Verbindungen vom Client Ihrer Wahl herzustellen.

Warum auf die Kubernetes-API innerhalb zugreifen Kapseln?

Es gibt mehrere Anwendungsfälle für den In-Pod-API-Zugriff. Mit dieser Technik können Anwendungen ihre Umgebung dynamisch untersuchen, Kubernetes-Änderungen anwenden und Metriken der Steuerungsebene erfassen, die Einblicke in die Leistung liefern.

Einige Organisationen entwickeln ihre eigenen Tools rund um Kubernetes. Sie stellen möglicherweise eine spezielle Cluster-interne Anwendung bereit, die die API verwendet, um zusätzliche Funktionen bereitzustellen. Der Betrieb innerhalb des Clusters kann sicherer sein als API-Aufrufe von einem externen Skript aus, da Sie Ihre Umgebung nicht öffnen oder Dienstkonten und Authentifizierungstoken gemeinsam nutzen müssen.

Verwenden der API-Clientbibliotheken

Die einfachste und empfohlene Methode für den Zugriff auf die Kubernetes-API von einem Pod aus ist die Verwendung einer Clientbibliothek. Vollständig unterstützte Optionen sind für C, .NET, Go, Haskell, Java, JavaScript, Perl, Python und Ruby verfügbar. Für die meisten anderen gängigen Programmiersprachen gibt es gleichwertige, von der Community gepflegte Lösungen.

Die Clientbibliotheken verfügen über eine integrierte Unterstützung zum Erkennen der Clusterumgebung, in der sie ausgeführt werden. Jede Implementierung bietet eine Funktion, die Sie aufrufen können, um die Bibliothek so zu konfigurieren, dass sie eine Verbindung zum richtigen API-Server herstellt.

Hier& #8217;s ein Beispiel dafür, wie Sie die Pods in Ihrem Cluster in einer Python-Anwendung auflisten:

aus kubernetes import Client, Konfiguration   config.load_incluster_config()   api = client.CoreV1Api()   # Notwendige API-Interaktionen durchführen # pods = api.list_pod_for_all_namespaces()

Dieser Ansatz ist einfach zu handhaben und erfordert keine manuelle Konfiguration. Manchmal können Sie jedoch keine Clientbibliothek verwenden. In diesen Fällen ist es immer noch möglich, mithilfe des von Kubernetes bereitgestellten Dienstkontos manuell auf die API zuzugreifen.

Performing Manual API Interactions

< p>Um die API aufzurufen, müssen Sie zwei Dinge wissen: den In-Cluster-Hostnamen, auf dem sie angezeigt wird, und das Dienstkonto-Token, das Ihren Pod authentifiziert.

Der API-Hostname ist immer kubernetes.default.svc. Der Kubernetes-DNS-Anbieter löst diesen Namen zum API-Server der Steuerungsebene auf. Alternativ können Sie die Umgebungsvariable $KUBERNETES_SERVICE_HOST verwenden, um die IP-Adresse des API-Servers zu ermitteln:

$ echo $KUBERNETES_SERVICE_HOST 10.96.0.1

Die API ist nur über HTTPS verfügbar. Sie finden die Zertifizierungsstellendatei für Ihren Cluster unter /var/run/secrets/kubernetes.io/serviceaccount/ca.crt in Ihrem Pod. Kubernetes legt dies jedes Mal im Dateisystem ab, wenn ein neuer Container erstellt wird.

Sie müssen sich authentifizieren, um etwas Nützliches mit der API zu erreichen. Kubernetes erstellt für jeden Pod ein neues Dienstkonto und stellt sein Token unter /var/run/secrets/kubernetes.io/serviceaccount/token bereit. Dies sollte bei jeder HTTP-Anfrage als Bearer-Token im Authorization-Header enthalten sein.

Alles zusammenfassend ist hier ein Beispiel für eine grundlegende In-Pod-Kubernetes-API-Anfrage mit curl:

$ curl –cacert /var/run/secrets/kubernetes.io/serviceaccount/ca.crt -H “Autorisierung: Träger $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)” https: //kubernetes.default.svc/api { “kind”: “APIVersions”, “versions”: [ “v1” ], “serverAddressByClientCIDRs”: [ { “clientCIDR”: “0.0.0.0/0”, “serverAddress”: “192.168.49.2:8443” } ]

Der Kubernetes-Server hat mit den verfügbaren API-Versionen geantwortet. Dies bestätigt, dass eine erfolgreiche Verbindung unter Verwendung des Hostnamens kubernetes.default.svc und des bereitgestellten Dienstkontos hergestellt wurde.

Verarbeitung von RBAC

Obwohl eine API-Anfrage erfolgreich gestellt wurde, sind die meisten anderen gesperrt, wenn RBAC für Ihren Cluster aktiviert ist. Neu erstellte Dienstkonten erhalten nicht automatisch Rollen, sodass Ihr Pod keine geschützten API-Endpunkte anfordern kann.

Sie können dieses Problem lösen, indem Sie Ihre eigenen Rollenobjekte erstellen und sie an die binden Dienstkonto, das Ihren Pods bereitgestellt wird. Erstellen Sie zuerst eine neue Rolle:

apiVersion: rbac.authorization.k8s.io/v1art: RolleMetadaten: Namespace: Standardname: < /strong>demo-roleRegeln: – apiGroups: [""]Ressourcen: ["Pods" ] Verben: ["erhalten", "auflisten"& #93;

Wenden Sie es mit Kubectl auf Ihren Cluster an:

$ kubectl apply -f role.yaml

Binden Sie als Nächstes die Rolle an das Dienstkonto:

apiVersion: rbac.authorization.k8s.io/v1 Art: RoleBindingMetadaten:Namespace strong>: default name: demo-role-binding Themen: – Art: ServiceAccount name: default apiGroup: "" roleRef:art: Rollenname: demo-role apiGroup< /strong>: ""

Das Standarddienstkonto wird als Betreff der Rollenbindung ausgewählt. Pods werden immer mit diesem Dienstkonto bereitgestellt, das auf den Namespace beschränkt ist, in dem sie erstellt wurden. In diesem Beispiel wird der Standard-Namespace verwendet, aber dies sollte für die Role- und RoleBinding-Objekte geändert werden, wenn Ihr Pod in einem anderen Namespace vorhanden ist.

Fügen Sie die Rollenbindung zu Ihrem Cluster hinzu:

$ kubectl apply -f role-binding.yaml

Jetzt dürfen Ihre Pods andere Pod-Objekte im Standard-Namespace abrufen und auflisten. Sie können dies überprüfen, indem Sie eine API-Anfrage an den Pods-Endpunkt mit Namespace stellen:

$ curl –cacert /var/run/secrets/kubernetes.io/serviceaccount/ca.crt -H “Authorization: Bearer $( cat /var/run/secrets/kubernetes.io/serviceaccount/token)” https://kubernetes.default.svc/api/v1/namespaces/default/pods { “kind”: “PodList”, “apiVersion”: ” v1″ … }

Pods können ihren eigenen Namespace identifizieren, indem sie die Datei /var/run/secrets/kubernetes.io/serviceaccount/namespace lesen:

$ cat /var/run/secrets/kubernetes.io/serviceaccount/namespace default

Dies bietet eine praktische Methode zum Interpolieren des aktiven Namespace in Endpunkt-URLs:

$ curl –cacert /var/run/secrets /kubernetes.io/serviceaccount/ca.crt -H “Autorisierung: Bearer $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)” https://kubernetes.default.svc/api/v1/namespaces/$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace)/pods { “kind”: “PodList”, “apiVersion”: “v1” … }

Auswählen eines anderen Dienstkontos

Kubernetes stellt Pods automatisch das Standarddienstkonto in ihrem Namespace bereit. Sie können stattdessen optional ein anderes Dienstkonto einfügen, indem Sie das Feld spec.serviceAccountName auf Ihren Pods festlegen:

apiVersion: v1Art: PodMetadaten: Name: demo spec: serviceAccountName: demo-sa < p>In diesem Beispiel authentifiziert sich der Pod als demo-sa-Token. Sie können dieses Dienstkonto manuell erstellen und ihm die erforderlichen Rollen zuweisen.

$ kubernetes create serviceaccount demo-sa

Das Dienstkonto sollte im selben Namespace wie der Pod vorhanden sein.

Opting-out-of-service-account-mounting

Die automatische Einfügung von Dienstkonten ist nicht immer wünschenswert. Dies kann ein Sicherheitsrisiko darstellen, da eine erfolgreiche Pod-Kompromittierung sofortigen Zugriff auf die API Ihres Kubernetes-Clusters bietet. Sie können Dienstkonto-Token-Mounts mit dem Pod-Manifestfeld spec.automountServiceAccountToken deaktivieren:

apiVersion: v1 Art: PodMetadaten:name: demo spec:automountServiceAccountToken: falsch

Kubernetes fügt die Datei /var/run/secrets/kubernetes.io/serviceaccount/token nicht ein. Dadurch wird verhindert, dass sich der Pod bei der Kubernetes-API authentifiziert, es sei denn, Sie geben Anmeldeinformationen manuell mit einer anderen Methode ein. Dieses Feld wird auch für Dienstkontoobjekte unterstützt, sodass sie nicht automatisch in einem Pod gemountet werden können.

Wenn Sie das Dienstkontomounten verwenden, legen Sie geeignete RBAC-Richtlinien fest, um das Token auf Ihre beabsichtigten Anwendungsfälle zu beschränken . Das Vermeiden von hochprivilegiertem Zugriff verringert das Schadensrisiko, falls ein Angreifer Zugriff auf Ihren Pod erhält.

Zusammenfassung

Der Zugriff auf den Kubernetes-API-Server von Ihrem Cluster aus lässt die Ausführung zu Anwendungen prüfen und ändern benachbarte Workloads. Sie können zusätzliche Funktionen hinzufügen, ohne Ihren Cluster für den externen API-Zugriff zu öffnen.

Die offiziellen Client-Bibliotheken erleichtern die Inbetriebnahme, wenn sie für Ihren Anwendungsfall geeignet sind. In anderen Situationen müssen Sie manuell Anfragen an https://kubernetes.default.svc stellen und die Zertifizierungsstellendatei und das Dienstkonto-Token bereitstellen, die Kubernetes in Ihre Pod-Container einfügt. Unabhängig von dem von Ihnen verwendeten Ansatz muss das Dienstkonto korrekt mit RBAC-Rollenbindungen konfiguriert sein, damit der Pod die Berechtigung hat, seine beabsichtigten Aktionen auszuführen.

WEITER LESEN

  • › Was ist DLSS 3 und kann es auf vorhandener Hardware verwendet werden?
  • › Unser Lieblings-Controller für PC-Gaming kostet heute nur 45 $
  • › NASA und SpaceX wollen dem Hubble-Teleskop einen Schub geben
  • › Was ist der “Klick des Todes” in einer HDD, und was sollten Sie tun?
  • › Intels RTX 3060-Konkurrent kostet weniger als 300 $
  • › Spotify vs. Audible: Was ist besser für Hörbücher?