Von 0 auf Kubernetes - Aufbau einer Kubernetes-CI/CD-Infrastruktur per GitLab-Pipeline - Teil 5 - Vorbereitungen für Kubernetes

Titelbild-rancher-kubernetes

Ansible, Terraform, GitLab und etwas Magie: Wie ich eine ganze Infrastruktur auf Knopfdruck erstelle.

In dieser Serie möchte ich Euch zeigen, wie Ihr automatisiert ein Kubernetes-Cluster aufbaut, ein GitLab mit GitLab-Runner installiert und eine eigene Docker-Registry zur Verfügung stellt. Das Ziel wird es sein, dass Ihr Eure Anwendungen direkt aus dem GitLab heraus in eurem Cluster bauen und starten könnt.

Im fünften Teil dieser Serie müssen wir einige Vorbereitungen für die Installation des RKE-Clusters treffen.

Rückblick 

Im vierten Teil haben wir uns ein Ansible-Inventory und unser erstes Ansible-Playbook erstellt. Mithilfe des Inventory können wir unsere Zielsysteme einfach und zentral verwalten. Das Ansible-Playbook vereint alle bisher beschrieben Schritte und ermöglicht uns das Installieren und Starten unserer Services mit nur einem Befehl. 

Unser Ziel für diesen Teil 

In diesem Teil legen wir eine Konfigurationsdatei für Traefik an, damit wir das Cluster per rancher.example.com und api.example.com erreichen können. Wir schreiben eine kleine Ansible-Rolle zur Konfiguration von SSHD auf den Knoten des Clusters, erstellen bereits das zugehörige Ansible-Playbook und abschließend eine cluster.yml mit verschiedenen Konfigurationsoptionen für RKE (siehe sechster Teil).

Traefiks Konfigurationsdatei 

Bisher haben wir Traefik per Docker-Labels konfiguriert (ich möchte hier nochmal an TEIL 2 - DOCKER SERVICES erinnern). Dies war möglich, da die entsprechenden Anwendungen alle innerhalb von Docker-Containern gekapselt sind, die nicht nur auf demselben System laufen, sondern sogar im gleichen Docker-Netzwerk. Das Rancher-Cluster stellt aber keinen einfachen Docker-Container dar und befindet sich zudem auf ganz anderen Systemen. Daher müssen wir Traefik auf eine andere Weise konfigurieren. Dies geschieht über den File-Provider.

Wir erstellen uns nun eine traefik.yml unter dem Pfad ansible-setup/roles/gitlab/traefik.yml (falls nicht bereits beim Testen geschehen). Das Kopieren dieser Datei auf die VM1 hatten wir im dritten Teil bereits in die Ansible-Rolle mit aufgenommen. Die Datei sollte folgenden Inhalt haben:
---
http:
  routers:
    https-rancher:
      rule: "Host(`rancher.example.com`)"
      service: rancher
      entryPoints:
        - websecure
      tls: {}
    http-rancher:
      rule: "Host(`rancher.example.com`)"
      service: rancher
      entryPoints:
        - web
    https-api:
      rule: "Host(`api.example.com`)"
      service: rancher
      entryPoints:
        - websecure
      tls: {}
    http-api:
      rule: "Host(`api.example.com`)"
      service: rancher
      entryPoints:
        - web

  services:
    rancher:
      loadBalancer:
        servers:
          - url: https://vm2.example.com
          - url: https://vm3.example.com
          - url: https://vm4.example.com 
Der Aufbau der Datei ähnelt sehr den verwendeten Labels des Docker-Providers von Traefik. Es gibt hier zwei nennenswerte Unterschiede. Erstens wird TLS hier per tls: {} aktiviert. Zweitens legen wir für jeden Router einen Service fest, welchen wir am Ende der Datei definieren. Dieser Service namens rancher besteht aus einem Load-Balancer, der seine Anfragen auf drei URLs aufteilt. Diese URLs geben wir mit den entsprechenden Hostnames für VM2, VM3 und VM4 an (beachtet das https der URL). Nun kann Traefik alle Anfragen an rancher.example.com und api.example.com an unser späteres Cluster weiterleiten.

RKE und SSHD 

Bei dem von mir auf den VMs verwendeten Ubuntu verbietet SSHD, also der SSH-Daemon, das TCP-Forwarding. Dies müssen wir für das später verwendete Tool zum Installieren des Kubernetes-Clusters aktivieren. Dafür erstellen wir eine neue Ansible-Rolle namens sshd mit analoger Ordnerstruktur zu den anderen beiden Rollen. Per Modul lineinfile ersetzen wir das AllowTcpForwarding no innerhalb der SSHD-Konfiguration mit einem AllowTcpForwarding yes und starten den SSHD anschließend neu. Die main.yml dieser Rolle sieht dann wie folgt aus:

---
- name: Configure sshd for rke
  lineinfile:
    path: /etc/ssh/sshd_config
    regexp: '^AllowTcpForwarding'
    line: AllowTcpForwarding yes

- name: Restart sshd service to apply config
  systemd:
    name: sshd.service
    state: restarted 

Ansible-Playbook für das RKE-Cluster 

Nun bereiten wir das Ansible-Playbook zur Installation des RKE-Clusters vor. Da es dem Ansible-Playbook aus dem vierten Teil ähnelt, werde ich nur auf die Unterschiede eingehen. Statt der Ansible-Rolle gitlab verwenden wir hier die gerade erstellte Rolle sshd und wählen als Hosts die Gruppe rancher des Inventorys. Neu ist der zweite Schritt des Playbooks. An dieser Stelle wird die Rolle rke_setup benutzt, welche wir im sechsten Teil erstellen werden. Eine große Besonderheit ist der verwendete Host: localhost. Die Tasks der Rolle rke_setup werden also von Ansible auf demselben System ausgeführt, auf dem dieses gestartet wird, und nicht, wie man es vielleicht erwartet hätte, auf den VMs 2 bis 4. In Euren Tests wäre dies also Euer eigenes System. In unserer späteren GitLab-Pipeline wird dies ein flüchtiger Docker-Container sein. Dies hat eine einfache Begründung: Die von uns verwendeten Tools wie RKE und kubectl bauen ihre eigene Verbindung zu den Zielsystemen auf. Wir nutzen Ansible also nur zum Starten dieser Tools mit entsprechenden Optionen.

Wir erstellen also eine rancher.yml in demselben Verzeichnis wie unser anderes Ansible-Playbook namens gitlab.yml mit folgendem Inhalt:
---
- name: setup for rancher nodes
  hosts: rancher
  become: true
  roles:
    - common
    - sshd
  vars:
    proxy: http://proxy-ip:proxy-port
  environment:
    http_proxy: "{{ proxy }}"
    https_proxy: "{{ proxy }}"

- name: setup cluster with rke
  hosts: localhost
  become: true
  vars:
    proxy: http://proxy-ip:proxy-port
  roles:
    - rke_setup 

Die RKE-Konfiguration

Das Tool RKE zum Erstellen eines RKE-Clusters bietet eine große Auswahl an Einstellungsmöglichkeiten. Diese werden innerhalb einer rancher-cluster.yml festgehalten, welche wir unter dem Pfad ansible-setup/roles/rke_setup/rancher-cluster.yml erstellen. Eine Übersicht über alle Einstellungsmöglichkeiten findet Ihr hier. Wir werden für dieses Beispiel nur eine Mindestkonfiguration vornehmen. Gleichzeitig werden in dieser Datei die Knoten des Clusters, die verwendeten Benutzer innerhalb der Systeme und die Rollen der Knoten angegeben. Als Nutzer verwende ich hier wieder den ubuntu-Benutzer. Als Rollen haben wir controlplane, worker und etcd zur Verfügung. Der Einfachheit halber weisen wir über role: [controlplane, worker, etcd] allen drei Konten alle drei Rollen zu. Knoten mit nur einzelnen Rollen begenet man meist erst in größeren Clustern. Als Adressen müssen wir hier leider die IP-Adressen der Knoten angeben. Die zu den VMs zugehörigen URLs haben in meinen Tests leider nicht funktioniert. Vielleicht wird dies in einer späteren Version von RKE behoben.

Die rancher-cluster.yml sieht dann wie folgt aus (analog zur hier verwendeten Konfiguration):
---
nodes:
  - address: IP_Fuer_VM_2
    user: ubuntu
    role: [controlplane, worker, etcd]
  - address: IP_Fuer_VM_3
    user: ubuntu
    role: [controlplane, worker, etcd]
  - address: IP_Fuer_VM_4
    user: ubuntu
    role: [controlplane, worker, etcd]

services:
  etcd:
    backup_config:
      interval_hours: 12
      retention: 6 

Zusammenfassung 

In diesem Teil haben wir eine Konfigurationsdatei für Traefik, eine Ansible-Rolle zum Aktivieren des TCP-Forwarding im SSHD, ein Ansible-Playbook und die Konfigurationsdatei für RKE erstellt. Bis auf die Rolle rke_setup haben wir nun alles um unser Cluster per Ansible erstellen zu lassen.

Im sechsten Teil dieser Anleitung werden wir die Rolle rke_setup erstellen und somit unsere Cluster-Installation vervollständigen.

By accepting you will be accessing a service provided by a third-party external to https://blog.ordix.de/