githubixx.kubernetes_controller

ansible-role-kubernetes-controller

Diese Rolle wird in Kubernetes the not so hard way with Ansible - Control plane verwendet. Sie installiert den Kubernetes API-Server, Scheduler und Controller-Manager. Für mehr Informationen zu dieser Rolle werfen Sie bitte einen Blick auf Kubernetes the not so hard way with Ansible - Control plane.

Versionen

Ich versiegle jede Veröffentlichung und versuche, bei semantischer Versionierung zu bleiben. Wenn Sie die Rolle verwenden möchten, empfehle ich, den neuesten Tag zu verwenden. Der Master-Zweig ist im Grunde genommen Entwicklung, während die Tags stabile Versionen kennzeichnen. Ein Tag 23.0.0+1.28.5 bedeutet, dass dies die Veröffentlichung 23.0.0 dieser Rolle ist und sie für die Kubernetes-Version 1.28.5 gedacht ist (aber natürlich auch mit jeder K8s 1.27.x-Version funktionieren sollte). Wenn sich die Rolle selbst ändert, wird X.Y.Z vor + erhöht. Wenn sich die Kubernetes-Version ändert, wird X.Y.Z nach + ebenfalls erhöht. Dies ermöglicht es, Bugfixes und neue Hauptversionen der Rolle zu kennzeichnen, während sie weiterhin für eine spezifische Kubernetes-Version entwickelt wird. Das ist besonders nützlich für Hauptversionen von Kubernetes mit brechenden Änderungen.

Voraussetzungen

Diese Rolle erfordert, dass Sie bereits einige Zertifikate für den Kubernetes API-Server erstellt haben (siehe Kubernetes the not so hard way with Ansible - Zertifizierungsstelle (CA)). Die Rolle kopiert die Zertifikate aus dem k8s_ctl_ca_conf_directory (das standardmäßig dasselbe wie das k8s_ca_conf_directory ist, das von der Rolle githubixx.kubernetes_ca verwendet wird) auf den Zielhost. Sie sollten auch ein vollständig gemaschtes VPN, z.B. WireGuard, einrichten (siehe Kubernetes the not so hard way with Ansible - WireGuard) und natürlich ein etcd-Cluster (siehe Kubernetes the not so hard way with Ansible - etcd-Cluster). Das WireGuard VPN-Mesh ist keine Voraussetzung, erhöht jedoch die Sicherheit, da der gesamte Datenverkehr zwischen den K8s-Hosts standardmäßig verschlüsselt wird. Solange alle beteiligten Hosts eine Schnittstelle haben, über die sie miteinander kommunizieren können, ist das in Ordnung.

Unterstützte Betriebssysteme

Ubuntu 20.04 (Focal Fossa)
Ubuntu 22.04 (Jammy Jellyfish)

Änderungsprotokoll

Änderungshistorie:

Siehe vollständiges CHANGELOG.md

WICHTIG: Wenn Sie von einer Version < 22.0.0+1.27.8 aktualisieren, lesen Sie das CHANGELOG.md sorgfältig! Die Version 22.0.0+1.27.8 hatte einige brechende Änderungen!

Aktuelle Änderungen:

24.0.0+1.29.4

AKTUALISIERUNG
- k8s_release auf 1.29.4 aktualisieren

24.0.0+1.29.3

AKTUALISIERUNG
- k8s_release auf 1.29.3 aktualisieren
- Molecule: alvistack statt generic Vagrant-Boxen verwenden

23.1.2+1.28.8

AKTUALISIERUNG
- k8s_release auf 1.28.8 aktualisieren

23.1.1+1.28.5

BUGFIX
- ClusterRoleBinding system:kube-apiserver muss den Wert k8s_apiserver_csr_cn für den Benutzernamen berücksichtigen
- Aufgrund der vorherigen Änderung die Dateien files/kube-apiserver-to-kubelet_cluster_role.yaml -> templates/rbac/kube-apiserver-to-kubelet_cluster_role.yaml.j2 und files/kube-apiserver-to-kubelet_cluster_role_binding.yaml -> templates/rbac/kube-apiserver-to-kubelet_cluster_role_binding.yaml.j2 verschieben, da beide Dateien eine Jinja2-Vorlage geworden sind.

23.1.0+1.28.5

MOLECULE
- Wechsel zu Ubuntu 22.04 für Test-Assets-VM
- Allgemeine Namen für Zertifikate anpassen / Algorithmus auf ecdsa und Algorithmusgröße ändern
SONSTIGE ÄNDERUNGEN
- Berechtigungen für das temporäre Verzeichnis fixen
- Github-Aktion anpassen wegen Ansible Galaxy Änderungen

23.0.0+1.28.5

AKTUALISIERUNG
- k8s_release auf 1.28.5 aktualisieren
BRECHENDE ÄNDERUNG
- enable-admission-plugins in k8s_apiserver_settings um: PodSecurity,Priority,StorageObjectInUseProtection,RuntimeClass,CertificateApproval,CertificateSigning,ClusterTrustBundleAttest,CertificateSubjectRestriction,DefaultIngressClass erweitern. Diese sind standardmäßig aktiviert, wenn dieses Flag nicht angegeben ist (siehe Referenz der Zulassungscontroller für weitere Informationen).
MOLECULE
- IP-Adressen ändern

Installation

Direkt von Github herunterladen (wechseln Sie in das Verzeichnis der Ansible-Rollen, bevor Sie klonen. Sie können den Rollenpfad mit dem Befehl ansible-config dump | grep DEFAULT_ROLES_PATH ermitteln): git clone https://github.com/githubixx/ansible-role-kubernetes-controller.git githubixx.kubernetes_controller
Über den Befehl ansible-galaxy und direkt von Ansible Galaxy herunterladen: ansible-galaxy install role githubixx.kubernetes_controller
Eine Datei requirements.yml mit folgendem Inhalt erstellen (dadurch wird die Rolle von Github heruntergeladen) und mit ansible-galaxy role install -r requirements.yml installieren (Ändern Sie die version, falls erforderlich):

---
roles:
  - name: githubixx.kubernetes_controller
    src: https://github.com/githubixx/ansible-role-kubernetes-controller.git
    version: 24.0.1+1.29.4

Standardvariablen der Rolle

# Das Basisverzeichnis für Kubernetes-Konfigurations- und Zertifikatsdateien für
# alles, was den Steuerungsbereich betrifft. Nach Abschluss des Playbooks
# enthält dieses Verzeichnis verschiedene Unterordner.
k8s_ctl_conf_dir: "/etc/kubernetes/controller"

# Alle Zertifikatdateien (Privat Key Infrastruktur bezogen), die in
# "k8s_ctl_certificates" und "k8s_ctl_etcd_certificates" angegeben sind (siehe "vars/main.yml")
# werden hier gespeichert. Der Besitzer dieses neuen Verzeichnisses wird "root" sein. Die Gruppe wird
# die Gruppe sein, die in "k8s_run_as_group" angegeben ist. Die Dateien in diesem Verzeichnis
# werden von "root" und der Gruppe wie in "k8s_run_as_group" angegeben, besessen. Die
# Dateiberechtigungen werden "0640" sein.
k8s_ctl_pki_dir: "{{ k8s_ctl_conf_dir }}/pki"

# Das Verzeichnis zum Speichern der Kubernetes-Binärdateien (siehe die Variable "k8s_ctl_binaries"
# in "vars/main.yml"). Besitzer und Gruppe dieses neuen Verzeichnisses
# werden in beiden Fällen "root" sein. Die Berechtigungen für dieses Verzeichnis werden "0755" sein.
#
# HINWEIS: Das Standardverzeichnis "/usr/local/bin" existiert normalerweise bereits auf jeder
# Linux-Installation mit dem genannten Besitzer, Gruppe und Berechtigungen. Wenn Ihre aktuellen
# Einstellungen anders sind, ziehen Sie ein anderes Verzeichnis in Betracht. Stellen Sie jedoch sicher,
# dass das neue Verzeichnis in den Wert Ihrer "$PATH"-Variable einbezogen wird.
k8s_ctl_bin_dir: "/usr/local/bin"

# Die Kubernetes-Veröffentlichung.
k8s_ctl_release: "1.29.4"

# Die Schnittstelle, auf der die Kubernetes-Dienste hören sollen. Da die gesamte Cluster-
# Kommunikation eine VPN-Schnittstelle verwenden sollte, ist der Schnittstellenname
# normalerweise "wg0" (WireGuard), "peervpn0" (PeerVPN) oder "tap0".
#
# Die Netzwerkschnittstelle, auf der die Kubernetes-Control-Plane-Dienste hören sollen. Das sind:
#
# - kube-apiserver
# - kube-scheduler
# - kube-controller-manager
#
k8s_interface: "eth0"

# Führen Sie den Kubernetes Control-Plane-Service (kube-apiserver, kube-scheduler,
# kube-controller-manager) als diesen Benutzer aus.
#
# Wenn Sie für "kube-apiserver" einen "secure-port" < 1024 verwenden möchten, müssen Sie "kube-apiserver"
# wahrscheinlich als Benutzer "root" (nicht empfohlen) ausführen.
#
# Wenn der in "k8s_run_as_user" angegebene Benutzer nicht existiert, erstellt die Rolle ihn. Nur
# wenn der Benutzer bereits existiert, wird er nicht erstellt, sondern UID/GID und Shell
# angepasst, wenn dies angegeben wird (siehe Einstellungen unten). Stellen Sie sicher, dass UID,
# GID und Shell mit dem vorhandenen Benutzer übereinstimmen, wenn Sie nicht möchten, dass dieser 
# Benutzer geändert wird.
#
# Wenn "k8s_run_as_user" "root" ist, berührt diese Rolle den Benutzer überhaupt nicht.
k8s_run_as_user: "k8s"

# UID des Benutzers, der in "k8s_run_as_user" angegeben ist. Wenn nicht angegeben, wird
# die nächst verfügbare UID aus "/etc/login.defs" verwendet (siehe die Einstellung "SYS_UID_MAX" in dieser Datei).
# k8s_run_as_user_uid: "999"

# Shell für den in "k8s_run_as_user" angegebenen Benutzer. Halten Sie den Standardwert sicher
# für erhöhte Sicherheit.
k8s_run_as_user_shell: "/bin/false"

# Gibt an, ob der in "k8s_run_as_user" angegebene Benutzer Systembenutzer (Standard)
# oder nicht sein wird. Wenn "true", wird die Einstellung "k8s_run_as_user_home" ignoriert. Im Allgemeinen
# macht es Sinn, den Standardwert beizubehalten, da es normalerweise nicht notwendig ist, sich als
# den Benutzer anzumelden, der kube-apiserver, kube-scheduler oder kube-controller-manager ausführt.
k8s_run_as_user_system: true

# Das Home-Verzeichnis des Benutzers, der in "k8s_run_as_user" angegeben ist. Wird ignoriert, wenn
# "k8s_run_as_user_system" auf "true" gesetzt ist. In diesem Fall wird kein Home-Verzeichnis erstellt.
# Normalerweise nicht notwendig.
# k8s_run_as_user_home: "/home/k8s"

# Führen Sie die Kubernetes-Daemons (kube-apiserver, kube-scheduler, kube-controller-manager)
# als diese Gruppe aus.
#
# Hinweis: Wenn die Gruppe, die in "k8s_run_as_group" angegeben ist, nicht existiert,
# wird die Rolle sie erstellen. Nur wenn die Gruppe bereits existiert, wird die Rolle
# sie nicht erstellen, sondern nur GID anpassen, wenn in "k8s_run_as_group_gid" angegeben (siehe
# Einstellung unten).
k8s_run_as_group: "k8s"

# GID der Gruppe, die in "k8s_run_as_group" angegeben ist. Wenn nicht angegeben, wird
# die nächst verfügbare GID aus "/etc/login.defs" verwendet (siehe die Einstellung "SYS_GID_MAX" in dieser Datei).
# k8s_run_as_group_gid: "999"

# Gibt an, ob die Gruppe, die in "k8s_run_as_group" angegeben ist, eine Systemgruppe (Standard)
# oder nicht sein wird.
k8s_run_as_group_system: true

# Standardmäßig werden alle Aufgaben, die mit dem Kubernetes-Cluster kommunizieren müssen,
# auf dem lokalen Host (127.0.0.1) ausgeführt. Wenn dieser jedoch keine direkte Verbindung zum
# K8s-Cluster hat oder andernorts ausgeführt werden soll, kann diese Variable entsprechend geändert werden.
k8s_ctl_delegate_to: "127.0.0.1"

# Die IP-Adresse oder der Hostname des Kubernetes API-Endpunkts. Diese Variable
# wird von "kube-scheduler" und "kube-controller-manager" verwendet, um sich mit dem
# "kube-apiserver" (Kubernetes API-Server) zu verbinden.
#
# Standardmäßig ist hier der erste Host in der Ansible-Gruppe "k8s_controller" angegeben.
# HINWEIS: Diese Einstellung ist nicht fehlertolerant! Das bedeutet, dass,
# wenn der erste Host in der Ansible-Gruppe "k8s_controller" nicht verfügbar ist,
# der Arbeitsknoten und seine Arbeitslast weiterlaufen, aber der Arbeitsknoten keine
# Aktualisierungen vom Kubernetes API-Server erhalten.
#
# Wenn Sie einen Lastenausgleich haben, der den Datenverkehr zwischen allen
# Kubernetes API-Servern verteilt, sollte dieser hier angegeben werden (entweder
# seine IP-Adresse oder der DNS-Name). Aber Sie müssen sicherstellen, dass die IP
# oder der DNS-Name, den Sie hier verwenden möchten, im TLS-Zertifikat des Kubernetes
# API-Servers enthalten ist (siehe die Variable "k8s_apiserver_cert_hosts"
# von https://github.com/githubixx/ansible-role-kubernetes-ca).
# Wenn es nicht angegeben ist, erhalten Sie Zertifikatsfehler in den Protokollen der
# oben genannten Dienste.
k8s_ctl_api_endpoint_host: "{% set controller_host = groups['k8s_controller'][0] %}{{ hostvars[controller_host]['ansible_' + hostvars[controller_host]['k8s_interface']].ipv4.address }}"

# Wie oben, nur für den Port. Gibt an, auf welchem Port die
# Kubernetes API-Server hören. Wenn ein Lastenausgleich vorhanden ist,
# der die Anfragen an die Kubernetes API-Server verteilt, geben Sie den Port
# des Lastenausgleichs hier an.
k8s_ctl_api_endpoint_port: "6443"

# Normalerweise protokollieren "kube-apiserver", "kube-controller-manager" und
# "kube-scheduler" in "journald". Es gibt jedoch Ausnahmen wie das Audit-Log. Für
# diese Art von Logdateien wird dieses Verzeichnis als Basisverzeichnis verwendet. Der
# Besitzer und die Gruppe dieses Verzeichnisses sind die in "k8s_run_as_user"
# und "k8s_run_as_group" angegebenen, da diese Dienste als dieser Benutzer ausgeführt werden und
# Berechtigungen benötigen, um Protokolldateien in diesem Verzeichnis zu erstellen.
k8s_ctl_log_base_dir: "/var/log/kubernetes"

# Berechtigungen für das Verzeichnis, das in "k8s_ctl_log_base_dir" angegeben ist
k8s_ctl_log_base_dir_mode: "0770"

# Der Port, zu dem die Steuerungsebenenkomponenten eine Verbindung zum etcd-Cluster
# herstellen sollten
k8s_ctl_etcd_client_port: "2379"

# Die Schnittstelle, auf der der etcd-Cluster hört
k8s_ctl_etcd_interface: "eth0"

# Der Speicherort des Verzeichnisses, in dem die Kubernetes-Zertifikate gespeichert sind.
# Diese Zertifikate wurden von der "kubernetes_ca" Ansible-Rolle erstellt, wenn Sie
# kein anderes Verfahren zur Erstellung dieser Zertifikate verwendet haben. Dieses
# Verzeichnis befindet sich also auf dem Ansible-Controller-Host. Das ist normalerweise
# der Host, auf dem "ansible-playbook" ausgeführt wird. "k8s_ca_conf_directory" wird von
# der "kubernetes_ca" Ansible-Rolle verwendet, um die Zertifikate zu speichern. Daher wird
# angenommen, dass diese Variable bereits gesetzt ist.
k8s_ctl_ca_conf_directory: "{{ k8s_ca_conf_directory }}"

# Verzeichnis, in dem "admin.kubeconfig" (die Anmeldeinformationsdatei) für den
# "admin"-Benutzer gespeichert ist. Standardmäßig wird dieses Verzeichnis (und die
# "kubeconfig"-Datei) auf dem Host gespeichert, der in "k8s_ctl_delegate_to" angegeben ist.
# Standardmäßig ist dies "127.0.0.1". Wenn Sie z.B. "ansible-playbook" lokal ausführen,
# wird das Verzeichnis und die Datei dort erstellt.
#
# Der Standardwert dieser Variable entspricht dem lokalen $HOME des Benutzers
# plus "/k8s/certs". Das bedeutet, wenn das $HOME-Verzeichnis des Benutzers
# z.B. "/home/da_user" ist, wird "k8s_admin_conf_dir" den Wert von
# "/home/da_user/k8s/certs" haben.
k8s_admin_conf_dir: "{{ '~/k8s/configs' | expanduser }}"

# Berechtigungen für das Verzeichnis, das in "k8s_admin_conf_dir" angegeben ist
k8s_admin_conf_dir_perm: "0700"

# Eigentümer des Verzeichnisses, das in "k8s_admin_conf_dir" angegeben ist und für
# "admin.kubeconfig", die in diesem Verzeichnis gespeichert ist.
k8s_admin_conf_owner: "root"

# Gruppe des Verzeichnisses, das in "k8s_admin_conf_dir" angegeben ist und für
# "admin.kubeconfig", die in diesem Verzeichnis gespeichert ist.
k8s_admin_conf_group: "root"

# Host, zu dem der "admin"-Benutzer sich verbindet, um den K8s-Cluster zu verwalten. 
# Diese Einstellung wird in "admin.kubeconfig" geschrieben. Dies ermöglicht die
# Verwendung eines anderen Hosts/Lastenausgleichs als die K8s-Dienste, die möglicherweise
# einen internen Lastenausgleich verwenden, während sich der "admin"-Benutzer mit
# einem anderen Host/Lastenausgleich verbindet, der den Datenverkehr an den
# "kube-apiserver" verteilt, z.B.
#
# Abgesehen davon gelten im Grunde dieselben Kommentare wie für die Variable
# "k8s_ctl_api_endpoint_host".
k8s_admin_api_endpoint_host: "{% set controller_host = groups['k8s_controller'][0] %}{{ hostvars[controller_host]['ansible_' + hostvars[controller_host]['k8s_interface']].ipv4.address }}"

# Wie oben, nur für den Port.
k8s_admin_api_endpoint_port: "6443"

# Verzeichnis zur Speicherung von "kube-apiserver"-Auditprotokollen (sofern aktiviert). Der Besitzer und
# die Gruppe dieses Verzeichnisses werden die in "k8s_run_as_user"
# und "k8s_run_as_group" angegebenen sein.
k8s_apiserver_audit_log_dir: "{{ k8s_ctl_log_base_dir }}/kube-apiserver"

# Das Verzeichnis zur Speicherung der "kube-apiserver"-Konfiguration.
k8s_apiserver_conf_dir: "{{ k8s_ctl_conf_dir }}/kube-apiserver"

# Einstellungen für den "kube-apiserver"-Daemon (kann mit "k8s_apiserver_settings_user"
# überschrieben oder zusätzliche hinzugefügt werden)
k8s_apiserver_settings:
  "advertise-address": "{{ hostvars[inventory_hostname]['ansible_' + k8s_interface].ipv4.address }}"
  "bind-address": "{{ hostvars[inventory_hostname]['ansible_' + k8s_interface].ipv4.address }}"
  "secure-port": "6443"
  "enable-admission-plugins": "NodeRestriction,NamespaceLifecycle,LimitRanger,ServiceAccount,TaintNodesByCondition,Priority,DefaultTolerationSeconds,DefaultStorageClass,PersistentVolumeClaimResize,MutatingAdmissionWebhook,ValidatingAdmissionWebhook,ResourceQuota,PodSecurity,Priority,StorageObjectInUseProtection,RuntimeClass,CertificateApproval,CertificateSigning,ClusterTrustBundleAttest,CertificateSubjectRestriction,DefaultIngressClass"
  "allow-privileged": "true"
  "authorization-mode": "Node,RBAC"
  "audit-log-maxage": "30"
  "audit-log-maxbackup": "3"
  "audit-log-maxsize": "100"
  "audit-log-path": "{{ k8s_apiserver_audit_log_dir }}/audit.log"
  "event-ttl": "1h"
  "kubelet-preferred-address-types": "InternalIP,Hostname,ExternalIP"  # "--kubelet-preferred-address-types" hat standardmäßig:
                                                                       # "Hostname,InternalDNS,InternalIP,ExternalDNS,ExternalIP"
                                                                       # Muss geändert werden, um "kubectl logs" und "kubectl exec" funktionsfähig zu machen.
  "runtime-config": "api/all=true"
  "service-cluster-ip-range": "10.32.0.0/16"
  "service-node-port-range": "30000-32767"
  "client-ca-file": "{{ k8s_ctl_pki_dir }}/ca-k8s-apiserver.pem"
  "etcd-cafile": "{{ k8s_ctl_pki_dir }}/ca-etcd.pem"
  "etcd-certfile": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver-etcd.pem"
  "etcd-keyfile": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver-etcd-key.pem"
  "encryption-provider-config": "{{ k8s_apiserver_conf_dir }}/encryption-config.yaml"
  "encryption-provider-config-automatic-reload": "true"
  "kubelet-certificate-authority": "{{ k8s_ctl_pki_dir }}/ca-k8s-apiserver.pem"
  "kubelet-client-certificate": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver.pem"
  "kubelet-client-key": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver-key.pem"
  "service-account-key-file": "{{ k8s_ctl_pki_dir }}/cert-k8s-controller-manager-sa.pem"
  "service-account-signing-key-file": "{{ k8s_ctl_pki_dir }}/cert-k8s-controller-manager-sa-key.pem"
  "service-account-issuer": "https://{{ groups.k8s_controller | first }}:6443"
  "tls-cert-file": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver.pem"
  "tls-private-key-file": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver-key.pem"

# Dies ist der Inhalt von "encryption-config.yaml". Wird von "kube-apiserver"
# (siehe Option "encryption-provider-config" in "k8s_apiserver_settings").
# "kube-apiserver" verwendet diese Konfiguration, um Daten vor der Speicherung
# in etcd zu verschlüsseln (Daten im Ruhezustand verschlüsseln).
#
# Die folgende Konfiguration ist ein benutzbarer Beispiel, könnte jedoch nicht Ihren Anforderungen entsprechen.
# Überprüfen Sie dies daher sorgfältig! Zum Beispiel möchten Sie möglicherweise den Anbieter "aescbc"
# durch einen anderen wie "secretbox" ersetzen. Wie Sie sehen können, verschlüsselt diese
# Konfiguration nur "Secrets" im Ruhezustand. Es ist jedoch auch möglich, andere K8s-Ressourcen zu verschlüsseln.
# HINWEIS: Der "identity"-Anbieter verschlüsselt nichts! Das bedeutet Klartext. In der Konfiguration
# unten wird er als Fallback verwendet.
#
# Wenn Sie den unten definierten Standardwert beibehalten, stellen Sie sicher, dass Sie die
# Variable "k8s_encryption_config_key" irgendwo angeben (z.B. in "group_vars/all.yml" oder
# noch besser verwenden Sie "ansible-vault", um diese Art von Geheimnissen zu speichern).
# Dies muss ein base64-codierter Wert sein. Um einen solchen Wert auf Linux zu erstellen,
# führen Sie den folgenden Befehl aus:
#
# head -c 32 /dev/urandom | base64
#
# Für eine detaillierte Beschreibung besuchen Sie bitte:
# https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/
#
# Informationen zum Rotieren des Verschlüsselungsschlüssels oder zur Implementierung von Datenverschlüsselung im Ruhezustand in
# einem bestehenden K8s-Cluster finden Sie unter:
# https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/#rotating-a-decryption-key
k8s_apiserver_encryption_provider_config: |
  ---
  kind: EncryptionConfiguration
  apiVersion: apiserver.config.k8s.io/v1
  resources:
    - resources:
        - secrets
      providers:
        - aescbc:
            keys:
              - name: key1
                secret: {{ k8s_encryption_config_key }}
        - identity: {}

# Das Verzeichnis zur Speicherung der Controller-Manager-Konfiguration.
k8s_controller_manager_conf_dir: "{{ k8s_ctl_conf_dir }}/kube-controller-manager"

# Einstellungen für den K8s-Controller-Manager (kann mit "k8s_controller_manager_settings_user"
# überschrieben oder zusätzliche hinzugefügt werden)
k8s_controller_manager_settings:
  "bind-address": "{{ hostvars[inventory_hostname]['ansible_' + k8s_interface].ipv4.address }}"
  "secure-port": "10257"
  "cluster-cidr": "10.200.0.0/16"
  "allocate-node-cidrs": "true"
  "cluster-name": "kubernetes"
  "authentication-kubeconfig": "{{ k8s_controller_manager_conf_dir }}/kubeconfig"
  "authorization-kubeconfig": "{{ k8s_controller_manager_conf_dir }}/kubeconfig"
  "kubeconfig": "{{ k8s_controller_manager_conf_dir }}/kubeconfig"
  "leader-elect": "true"
  "service-cluster-ip-range": "10.32.0.0/16"
  "cluster-signing-cert-file": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver.pem"
  "cluster-signing-key-file": "{{ k8s_ctl_pki_dir }}/cert-k8s-apiserver-key.pem"
  "root-ca-file": "{{ k8s_ctl_pki_dir }}/ca-k8s-apiserver.pem"
  "requestheader-client-ca-file": "{{ k8s_ctl_pki_dir }}/ca-k8s-apiserver.pem"
  "service-account-private-key-file": "{{ k8s_ctl_pki_dir }}/cert-k8s-controller-manager-sa-key.pem"
  "use-service-account-credentials": "true"

# Das Verzeichnis zur Speicherung der Scheduler-Konfiguration.
k8s_scheduler_conf_dir: "{{ k8s_ctl_conf_dir }}/kube-scheduler"

# kube-scheduler Einstellungen
k8s_scheduler_settings:
  "bind-address": "{{ hostvars[inventory_hostname]['ansible_' + k8s_interface].ipv4.address }}"
  "config": "{{ k8s_scheduler_conf_dir }}/kube-scheduler.yaml"
  "authentication-kubeconfig": "{{ k8s_scheduler_conf_dir }}/kubeconfig"
  "authorization-kubeconfig": "{{ k8s_scheduler_conf_dir }}/kubeconfig"
  "requestheader-client-ca-file": "{{ k8s_ctl_pki_dir }}/ca-k8s-apiserver.pem"

# Diese sicherheitsbezogenen Einstellungen werden für
# die systemd-Einheiten "kube-apiserver", "kube-scheduler" und "kube-controller-manager"
# verwendet. Diese Optionen werden im Abschnitt "[Service]" angegeben.
# Die Standardwerte sollten zu höheren Sicherheitsanforderungen der genannten Dienste
# beitragen. Es macht also Sinn, sie wenn möglich beizubehalten.
#
# Weitere Informationen finden Sie unter:
# https://www.freedesktop.org/software/systemd/man/systemd.service.html#Options
#
# Die Optionen unter "RestartSec=5" sind hauptsächlich sicherheitsbezogene Einstellungen
# und schränken die Exposition des Systems gegenüber den Prozessen der Einheit ein. Sie können
# Optionen nach Bedarf hinzufügen oder entfernen. Für weitere Informationen siehe:
# https://www.freedesktop.org/software/systemd/man/systemd.exec.html
k8s_ctl_service_options:
  - User={{ k8s_run_as_user }}
  - Group={{ k8s_run_as_group }}
  - Restart=on-failure
  - RestartSec=5
  - NoNewPrivileges=true
  - ProtectHome=true
  - PrivateTmp=true
  - PrivateUsers=true
  - ProtectSystem=full
  - ProtectClock=true
  - ProtectKernelModules=true
  - ProtectKernelTunables=true
  - ProtectKernelLogs=true
  - ProtectControlGroups=true
  - ProtectHostname=true
  - RestrictNamespaces=true
  - RestrictRealtime=true
  - RestrictSUIDSGID=true
  - CapabilityBoundingSet=~CAP_SYS_PTRACE
  - CapabilityBoundingSet=~CAP_KILL
  - CapabilityBoundingSet=~CAP_MKNOD
  - CapabilityBoundingSet=~CAP_SYS_CHROOT
  - CapabilityBoundingSet=~CAP_SYS_ADMIN
  - CapabilityBoundingSet=~CAP_SETUID
  - CapabilityBoundingSet=~CAP_SETGID
  - CapabilityBoundingSet=~CAP_SETPCAP
  - CapabilityBoundingSet=~CAP_CHOWN
  - SystemCallFilter=@system-service
  - ReadWritePaths=-/usr/libexec/kubernetes

Die kube-apiserver-Einstellungen, die in k8s_apiserver_settings definiert sind, können durch die Definition einer Variablen namens k8s_apiserver_settings_user überschrieben werden. Sie können auch zusätzliche Einstellungen hinzufügen, indem Sie diese Variable verwenden. Zum Beispiel, um audit-log-maxage und audit-log-maxbackup Standardwerte zu überschreiben und watch-cache hinzuzufügen, fügen Sie die folgenden Einstellungen zu group_vars/k8s.yml hinzu:

k8s_apiserver_settings_user:
  "audit-log-maxage": "40"
  "audit-log-maxbackup": "4"
  "watch-cache": "false"

Das Gleiche gilt für den kube-controller-manager, indem Sie Einträge zur Variable k8s_controller_manager_settings_user hinzufügen. Für kube-scheduler fügen Sie Einträge zur Variable k8s_scheduler_settings_user hinzu, um Einstellungen im Wörterbuch k8s_scheduler_settings zu überschreiben/hinzuzufügen.

Beispiel-Playbook

- hosts: k8s_controller
  roles:
    - githubixx.kubernetes_controller

Tests

Diese Rolle verfügt über eine kleine Testkonfiguration, die mit Molecule, libvirt (vagrant-libvirt) und QEMU/KVM erstellt wurde. Bitte lesen Sie meinen Blogbeitrag Testing Ansible roles with Molecule, libvirt (vagrant-libvirt) and QEMU/KVM, um zu erfahren, wie Sie es einrichten. Die Testkonfiguration finden Sie hier.

Anschließend kann Molecule ausgeführt werden:

molecule converge

Dies richtet einige virtuelle Maschinen (VMs) mit unterstützten Ubuntu-Betriebssystemen ein und installiert einen Kubernetes-Cluster, jedoch ohne die Arbeitsknoten (es sind keine Knoten mit installiertem kube-proxy und kubelet dabei). Ein kleiner Verifizierungsschritt ist ebenfalls enthalten: