Rôle Ansible : Kubernetes

Un rôle Ansible qui installe Kubernetes sur Linux.

Exigences

Nécessite un Runtime de Conteneur compatible ; rôle recommandé pour l'installation de CRI : geerlingguy.containerd.

Variables du rôle

Les variables disponibles sont listées ci-dessous, avec des valeurs par défaut (voir defaults/main.yml) :

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

Paquets Kubernetes à installer sur le serveur. Vous pouvez fournir une liste de noms de paquets ou définir name et state pour avoir plus de contrôle sur la présence, l'absence, la dernière version, etc.

kubernetes_version: '1.25'
kubernetes_version_rhel_package: '1.25.1'

La version mineure de Kubernetes à installer. La variable kubernetes_version est utilisée pour fixer une version de paquet apt sur Debian et pour passer la version de Kubernetes à la commande kubeadm init (voir kubernetes_version_kubeadm). La variable kubernetes_version_rhel_package doit être une version spécifique de Kubernetes et est utilisée pour fixer la version sur les serveurs Red Hat / CentOS.

kubernetes_role: control_plane

Indique si ce serveur servira de control_plane Kubernetes (par défaut) ou de node. Le plan de contrôle exécutera kubeadm init pour initialiser l'ensemble du plan de contrôle K8s, tandis que les nodes exécuteront kubeadm join pour les joindre au control_plane.

Variables pour configurer kubeadm et kubelet avec kubeadm init via un fichier de configuration (recommandé)

Avec ce rôle, kubeadm init sera exécuté avec --config <FICHIER>.

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

Chemin pour <FICHIER>. Si le répertoire n'existe pas, ce rôle le créera.

Les variables suivantes sont analysées comme options pour . Pour comprendre sa syntaxe, voir kubelet-integration et kubeadm-config-file. Le squelette (apiVersion, kind) du fichier de configuration sera créé par ce rôle, il ne faut donc pas les définir dans les variables. (Voir templates/kubeadm-kubelet-config.j2).

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

Définit les options sous kind: InitConfiguration. L'inclusion de kubernetes_apiserver_advertise_address ici est pour la compatibilité avec les anciennes versions de ce rôle, où il était utilisé avec une option de ligne de commande.

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

Options sous kind: ClusterConfiguration. L'inclusion de kubernetes_pod_network.cidr et kubernetes_version_kubeadm ici est pour la compatibilité avec les anciennes versions de ce rôle, où elles étaient utilisées avec des options de ligne de commande.

kubernetes_config_kubelet_configuration:
  cgroupDriver: systemd

Options pour configurer kubelet sur n'importe quel nœud de votre cluster via le processus kubeadm init. Pour les options de syntaxe, lire la fiche de configuration kubelet et la documentation intégration kubelet.

REMARQUE : C'est la méthode recommandée pour la configuration de kubelet. La plupart des options en ligne de commande sont obsolètes.

REMARQUE : Le cgroupDriver recommandé dépend de votre Runtime de Conteneur. Lorsque ce rôle est utilisé avec Docker au lieu de containerd, cette valeur doit être changée en cgroupfs.

kubernetes_config_kube_proxy_configuration: {}

Options pour configurer la configuration du proxy kubelet dans la section KubeProxyConfiguration de la configuration kubelet.

Variables pour configurer kubeadm et kubelet via des options de ligne de commande

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

Arguments supplémentaires à passer à kubelet lors du démarrage. Par exemple, pour permettre à kubelet de démarrer même si le swap est activé sur votre serveur, définissez ceci à : "--fail-swap-on=false". Ou pour spécifier l'IP du nœud annoncée par kubelet, définissez ceci à "--node-ip={{ ansible_host }}". Cette option est obsolète. Veuillez utiliser kubernetes_config_kubelet_configuration à la place.

kubernetes_kubeadm_init_extra_opts: ""

Arguments supplémentaires à passer à kubeadm init lors de l'initialisation du plan de contrôle K8s. Par exemple, pour spécifier des noms alternatifs supplémentaires pour le certificat du serveur API, définissez ceci à : "--apiserver-cert-extra-sans my-custom.host"

kubernetes_join_command_extra_opts: ""

Arguments supplémentaires à passer à la commande kubeadm join générée lors de l'initialisation du nœud K8s. Par exemple, pour ignorer certaines erreurs de prévol comme le swap étant activé, définissez ceci à : --ignore-preflight-errors=Swap

Variables supplémentaires

kubernetes_allow_pods_on_control_plane: true

Indique s'il faut supprimer la dénomination qui empêche les pods d'être déployés sur le plan de contrôle Kubernetes. Si vous avez un cluster à nœud unique, cela doit être True. Sinon, réglez sur False si vous souhaitez un plan de contrôle Kubernetes dédié qui n'exécute pas d'autres pods.

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'

Ce rôle prend actuellement en charge flannel (par défaut), calico ou weave pour le réseau pod du cluster. Choisissez-en un seul pour votre cluster ; la conversion entre eux n'est pas faite automatiquement et pourrait entraîner des problèmes de réseau ; si vous devez passer de l'un à l'autre, cela doit être fait en dehors de ce rôle.

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

Options passées à kubeadm init lors de l'initialisation du plan de contrôle Kubernetes. L'adresse par défaut kubernetes_apiserver_advertise_address est ansible_default_ipv4.address si elle est laissée vide.

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/ /"

Options de dépôt Apt pour l'installation de Kubernetes.

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

Options de dépôt Yum pour l'installation de Kubernetes. Vous pouvez changer kubernetes_yum_gpg_key pour une autre URL si vous êtes derrière un pare-feu ou fournir un miroir de confiance. Habituellement en combinaison avec le changement de kubernetes_yum_base_url également.

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

Fichier manifeste Flannel à appliquer au cluster Kubernetes pour activer le réseau. Vous pouvez copier vos propres fichiers sur votre serveur et les appliquer à la place, si vous devez personnaliser la configuration du réseau Flannel.

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

Fichier manifeste Calico à appliquer au cluster Kubernetes (en utilisant Calico au lieu de Flannel).

Dépendances

Aucune.

Exemples de Playbooks

Cluster à un seul nœud (contrôle uniquement)

- hosts: all

  vars:
    kubernetes_allow_pods_on_control_plane: true

  roles:
    - geerlingguy.docker
    - geerlingguy.kubernetes

Cluster à deux nœuds ou plus (un seul plan de contrôle)

Variables d'inventaire du plan de contrôle :

kubernetes_role: "control_plane"

Variables d'inventaire des nœuds :

kubernetes_role: "node"

Playbook :

- hosts: all

  vars:
    kubernetes_allow_pods_on_control_plane: true

  roles:
    - geerlingguy.docker
    - geerlingguy.kubernetes

Ensuite, connectez-vous au plan de contrôle Kubernetes et exécutez kubectl get nodes en tant que root, et vous devriez voir une liste de tous les serveurs.

Licence

MIT / BSD

Informations sur l'auteur

Ce rôle a été créé en 2018 par Jeff Geerling, auteur d'Ansible for DevOps.