Ansible Rolle: Kubernetes

Eine Ansible Rolle, die Kubernetes auf Linux installiert.

Anforderungen

Benötigt eine kompatible Container-Laufzeit; empfohlene Rolle für die CRI-Installation: geerlingguy.containerd.

Rollenvariablen

Verfügbare Variablen sind unten aufgeführt, zusammen mit Standardwerten (siehe defaults/main.yml):

kubernetes_packages:
  - name: kubelet
    state: present
  - name: kubectl
    state: present
  - name: kubeadm
    state: present
  - name: kubernetes-cni
    state: present

Kubernetes-Pakete, die auf dem Server installiert werden sollen. Du kannst entweder eine Liste von Paketnamen angeben oder name und state setzen, um mehr Kontrolle darüber zu haben, ob das Paket present, absent, latest usw. ist.

kubernetes_version: '1.25'
kubernetes_version_rhel_package: '1.25.1'

Die Minor-Version von Kubernetes, die installiert werden soll. Das einfache kubernetes_version wird verwendet, um eine apt-Paketversion auf Debian festzulegen, und als die Kubernetes-Version, die in den Befehl kubeadm init übergeben wird (siehe kubernetes_version_kubeadm). Die Variable kubernetes_version_rhel_package muss eine spezifische Kubernetes-Version sein und wird verwendet, um die Version auf Red Hat / CentOS-Servern festzulegen.

kubernetes_role: control_plane

Ob der spezifische Server als Kubernetes control_plane (Standard) oder node fungieren wird. Der Control-Plane wird kubeadm init ausgeführt, um die gesamte K8s-Control-Plane zu initialisieren, während nodes kubeadm join ausgeführt haben, um sie mit der control_plane zu verbinden.

Variablen zur Konfiguration von kubeadm und kubelet mit kubeadm init über eine Konfigurationsdatei (empfohlen)

Mit dieser Rolle wird kubeadm init mit --config <FILE> ausgeführt.

kubernetes_kubeadm_kubelet_config_file_path: '/etc/kubernetes/kubeadm-kubelet-config.yaml'

Pfad für <FILE>. Wenn das Verzeichnis nicht existiert, wird es von dieser Rolle erstellt.

Die folgenden Variablen werden als Optionen für geparst. Um die Syntax zu verstehen, siehe kubelet-integration und kubeadm-config-file. Das Grundgerüst (apiVersion, kind) der Konfigurationsdatei wird von dieser Rolle erstellt, also definiere sie nicht innerhalb der Variablen. (Siehe templates/kubeadm-kubelet-config.j2).

kubernetes_config_init_configuration:
  localAPIEndpoint:
    advertiseAddress: "{{ kubernetes_apiserver_advertise_address | default(ansible_default_ipv4.address, true) }}"

Definiert die Optionen unter kind: InitConfiguration. Das Einschließen von kubernetes_apiserver_advertise_address hier dient der rückwärtskompatibilität zu älteren Versionen dieser Rolle, in denen kubernetes_apiserver_advertise_address mit einer Befehlszeilenoption verwendet wurde.

kubernetes_config_cluster_configuration:
  networking:
    podSubnet: "{{ kubernetes_pod_network.cidr }}"
  kubernetesVersion: "{{ kubernetes_version_kubeadm }}"

Optionen unter kind: ClusterConfiguration. Das Einschließen von kubernetes_pod_network.cidr und kubernetes_version_kubeadm hier dient der Rückwärtskompatibilität zu älteren Versionen dieser Rolle, in denen sie mit Befehlszeilenoptionen verwendet wurden.

kubernetes_config_kubelet_configuration:
  cgroupDriver: systemd

Optionen zur Konfiguration von kubelet auf jedem Knoten in deinem Cluster durch den kubeadm init-Prozess. Für Syntaxoptionen lies die kubelet-Konfigurationsdatei und die kubelet-Integration Dokumentation.

HINWEIS: Dies ist die empfohlene Methode zur Konfiguration von kubelet. Die meisten Befehlszeilenoptionen sind veraltet.

HINWEIS: Der empfohlene cgroupDriver hängt von deiner Container-Laufzeit ab. Wenn du diese Rolle mit Docker anstelle von containerd verwendest, sollte dieser Wert auf cgroupfs geändert werden.

kubernetes_config_kube_proxy_configuration: {}

Optionen zur Konfiguration der Proxy-Konfiguration von kubelet im Abschnitt KubeProxyConfiguration der kubelet-Konfiguration.

Variablen zur Konfiguration von kubeadm und kubelet über Befehlszeilenoptionen

kubernetes_kubelet_extra_args: ""
kubernetes_kubelet_extra_args_config_file: /etc/default/kubelet

Zusätzliche Argumente, die beim Start von kubelet übergeben werden. Z.B. um zu erlauben, dass kubelet startet, selbst wenn Swap auf deinem Server aktiviert ist, setze dies auf: "--fail-swap-on=false". Oder um die von kubelet beworbene Node-IP anzugeben, setze dies auf "--node-ip={{ ansible_host }}". Diese Option ist veraltet. Bitte verwende stattdessen kubernetes_config_kubelet_configuration.

kubernetes_kubeadm_init_extra_opts: ""

Zusätzliche Argumente, die beim K8s-Control-Plane-Initialisierungsbefehl kubeadm init übergeben werden. Z.B. um zusätzliche Subject Alternative Names für das API-Server-Zertifikat anzugeben, setze dies auf: "--apiserver-cert-extra-sans my-custom.host"

kubernetes_join_command_extra_opts: ""

Zusätzliche Argumente, die dem generierten kubeadm join-Befehl beim K8s-Knoteninitialisierung übergeben werden. Z.B. um bestimmte Preflight-Fehler wie aktivierten Swap zu ignorieren, setze dies auf: --ignore-preflight-errors=Swap

Zusätzliche Variablen

kubernetes_allow_pods_on_control_plane: true

Ob der Taint entfernt werden soll, der Pods vom Deployen auf der Kubernetes-Control-Plane abhält. Wenn du einen Cluster mit nur einem Knoten hast, sollte dies definitiv True sein. Andernfalls setze es auf False, wenn du eine dedizierte Kubernetes-Control-Plane haben möchtest, die keine anderen Pods ausführt.

kubernetes_pod_network:
  # Flannel CNI.
  cni: 'flannel'
  cidr: '10.244.0.0/16'
  #
  # Calico CNI.
  # cni: 'calico'
  # cidr: '192.168.0.0/16'
  #
  # Weave CNI.
  # cni: 'weave'
  # cidr: '192.168.0.0/16'

Diese Rolle unterstützt derzeit flannel (Standard), calico oder weave für die Cluster-Pod-Netzwerkkonfiguration. Wähle nur eine für deinen Cluster; die Umstellung zwischen ihnen erfolgt nicht automatisch und könnte zu einer fehlerhaften Netzwerkkonfiguration führen. Wenn du von einer zur anderen wechseln musst, sollte dies außerhalb dieser Rolle erfolgen.

kubernetes_apiserver_advertise_address: ''
kubernetes_version_kubeadm: 'stable-{{ kubernetes_version }}'
kubernetes_ignore_preflight_errors: 'all'

Optionen, die beim Initialisieren der Kubernetes-Control-Plane an kubeadm init übergeben werden. Die kubernetes_apiserver_advertise_address standardmäßig auf ansible_default_ipv4.address, wenn sie leer gelassen wird.

kubernetes_apt_release_channel: "stable"
kubernetes_apt_keyring_file: "/etc/apt/keyrings/kubernetes-apt-keyring.asc"
kubernetes_apt_repository: "deb [signed-by={{ kubernetes_apt_keyring_file }}] https://pkgs.k8s.io/core:/{{ kubernetes_apt_release_channel }}:/v{{ kubernetes_version }}/deb/ /"

Apt-Repository-Optionen für die Kubernetes-Installation.

kubernetes_yum_base_url: "https://pkgs.k8s.io/core:/stable:/v{{ kubernetes_version }}/rpm/"
kubernetes_yum_gpg_key: "https://pkgs.k8s.io/core:/stable:/v{{ kubernetes_version }}/rpm/repodata/repomd.xml.key"
kubernetes_yum_gpg_check: true
kubernetes_yum_repo_gpg_check: true

Yum-Repository-Optionen für die Kubernetes-Installation. Du kannst kubernete_yum_gpg_key auf eine andere URL ändern, wenn du hinter einer Firewall bist oder einen vertrauenswürdigen Mirror bereitstellen möchtest. Normalerweise in Kombination mit der Änderung von kubernetes_yum_base_url.

kubernetes_flannel_manifest_file: https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Flannel-Manifestdatei, die auf das Kubernetes-Cluster angewendet wird, um das Networking zu ermöglichen. Du kannst auch deine eigenen Dateien auf den Server kopieren und diese stattdessen anwenden, wenn du die Flannel-Netwerkkonfiguration anpassen musst.

kubernetes_calico_manifest_file: https://projectcalico.docs.tigera.io/manifests/calico.yaml

Calico-Manifestdatei, die auf das Kubernetes-Cluster angewendet wird (wenn Calico anstelle von Flannel verwendet wird).

Abhängigkeiten

Keine.

Beispiel-Playbooks

Ein-Knoten-Cluster (nur Control-Plane)

- hosts: all

  vars:
    kubernetes_allow_pods_on_control_plane: true

  roles:
    - geerlingguy.docker
    - geerlingguy.kubernetes

Zwei oder mehr Knoten (einzelne Control-Plane)

Variablen für die Control-Plane im Inventar:

kubernetes_role: "control_plane"

Variablen für die Node(s) im Inventar:

kubernetes_role: "node"

Playbook:

- hosts: all

  vars:
    kubernetes_allow_pods_on_control_plane: true

  roles:
    - geerlingguy.docker
    - geerlingguy.kubernetes

Dann logge dich in die Kubernetes-Control-Plane ein und führe als Root kubectl get nodes aus, und du solltest eine Liste aller Server sehen.

Lizenz

MIT / BSD

Autoreninformation

Diese Rolle wurde 2018 von Jeff Geerling erstellt, dem Autor von Ansible for DevOps.