Kubernetes Cluster mit Rancher RKE provisionieren

Kubernetes setzt sich als Container Orchestration-Werkzeug durch. Die regelmässigen Releases mit neuen Features, machen die Installation und Wartungen zu einer aufwendigen Prozedure. So existieren am Markt zahlreiche Cloud- und OnPremise-Lösungen zum Erzeugen eines Kubernetes Clusters. Im Oktober 2017 hatte Docker Inc. angekündigt nun auch Kubernetes in ihre Docker Desktop Edition und Docker EE aufzunehmen. Im September 2017 hat Rancher ihr neues Management-UI für Container-Orchestration im Release 2.0 komplett auf Kubernetes umgestellt. Seit November 2017 exitiert das Werkzeug Rancher Kubernetes Engine (RKE), das die einfache Installation eines Kubernetes Clusters auf verschiedenen Plattformen unterstützt.

Die Voraussetzungen für eine Kubernetes-Installation mit RKE sind, das auf den Systemen ein SSH-Zugang und eine Docker-CE (1.12-17.03) Installation existieren. Mithilfe des Werkzeugs terraform ist die Installation von Linux Systemen mit Docker CE schnell erledigt. In diesem Artikel wird die Terraform Installation eines DigitalOcean Clusters mit anschliessender Provisionierung des Kubernetes-Cluster mit RKE vorgestellt.

Vorraussetzung der Installation eines Kubernetes Clusters

Damit die Maschinen auf dem Cloud Provider-DigitalOcean erzeugt werden können, muss ein DigitalOcean-Konto vorhanden sein. Wenn noch kein Konto vorhanden ist, kann man mit diesem DigitalOcean Verweis ein Konto mit 10€ Guthaben erzeugen. In dem Setting des Kontos muss dann der Zugriffs-Token des DigitalOcean-API erzeugt werden.

Nun müssen die entsprechend Werkzeuge terraform, kubectl und rke installiert werden. Auf einem MACOS ist dies Mithilfe des Packagemanager Homebrew elegant möglich. Das Projekt RKE wird gerade heftig entwickelt und unsere Artikel bezieht sich auf die Version 0.0.9-dev.

🐳 brew install terraform
🐳 brew install kubernetes-cli
🐳 sudo curl -sL https://github.com/rancher/rke/releases/download/v0.0.9-dev/rke_darwin-amd64 > /usr/local/bin/rke
🐳 sudo chmod +x /usr/local/bin/rke

Die Konfiguration und entsprechenden Skripten stehen in unserem Projekt rancher-ondemand zur Verfügung.

🐳 git clone https://github.com/bee42/rancher-ondemand
🐳 cd rancher-ondemand/rke-demo

RKE

Das Ziel der Rancher Kubernetes Engine ist es eine sichere, wiederholbare und homogenen Kubernetes Cluster Installation zu erzeugen. Auf dieser Basis lassen sich zuverlässig und schnell Test und Produktionssysteme erzeugen. Durch die häufigen Release-Wechsel lassen sich Neuerungen von Kubernetes vor dem Einsatz einfacher testen. Seit dem Release 1.8 wird an einem Update-Verfahren für bestehende Kubernetes gearbeitet, aber jedes Veränderungen sollte vor dem Einsatz durchgespielt werden. Einige Updates erzeugen noch heftige Probleme bei Installationen. Mit der RKE werden bestehende Maschinen mit dem erforderlichen Kubernetes Komponenten provisioniert. Die Maschinen können die Rollen ControlPlane, ETCD und Worker annehmen. Damit lassen sich sehr einfach verschiedene Setups von Kubernetes-Cluster erzeugen.

Für einen ersten Tests kann mit nur einer Maschine einen Kubernetes-Setup ausprobieren. Für ein grösseres Setup können die Rollen auf verschiedene Maschine installiert werden. Die Besonderheit von RKE ist das alle Komponenten in einer Konfigurationsdatei für die Installation eines Cluster zusammengefasst sind. Es werden flannel, canel, calcio und weave als Netzwerk-Plugins unterstützt. Der Kubernetes-Cluster wird mit TLS abgesichert und läuft mit RBAC als Zugriffsschutz.

Installation der Maschinen auf DigitalOcean

Als Voraussetzung für die Erzeugung von DigitalOcean-Maschinen mit RKE braucht es den erwähnten DigitalOcean Access Key und einen SSH-Key. Der SSH-Key muss ohne Password-Validierung bereitgestellt werden und kann mit dem Werkzeug ssh-keygen erzeugt werden. Der öffentliche Teil des Schlüssel muss dann im eigenen Konto von DigitalOcean eingetragen werden.

$ ssh-keygen -t ed25519 -f $HOME/.ssh/digitalocean-key -q -N "" -C "xxx@example.com"
$ cat $HOME/.ssh/digitalocean-key | pbcopy

Im nächsten Schritt werden die notwendigen Parameter für die Terraform Installation gesetzt. Zur Überprüfung des SSH-Keys muss noch der SSH-Fingerprint ermittelt werden.

$ export TF_VAR_do_token=REPLACE_ME_WITH_YOUR_DIGITALOCEAN_TOKEN
$ export TF_VAR_pvt_key=$HOME/.ssh/digitalocean-key
$ export TF_VAR_pub_key=${TF_VAR_pvt_key}.pub
$ export TF_VAR_ssh_fingerprint=`ssh-keygen -E md5 -lf ${TF_VAR_pub_key} | awk '{print $2}' | sed 's/^MD5://g'`

Mit den Umgebungsvariablen mit dem Prefix TF_VAR_ existiert eine einfache Möglichkeit der Übertragung der spezifischen Parameter an das Werkzeug Terraform. In unserem Projekt befindet sich die Definition der Variablen in der Datei provider.tf.

variable "do_token" {}
variable "pub_key" {}
variable "pvt_key" {}
variable "ssh_fingerprint" {}

provider "digitalocean" {
  token = "${var.do_token}"
}

In Terraform existiert direkt ein Ressource-Definition für DigitalOcean-Maschinen. Wir erzeugen in der Region Frankfurt entsprechend drei Ubuntu-Maschinen. Sobald die Maschinen verfügbar sind, wird die Provisionierung von Docker CE 17.03 vorgenommen. Rancher stellt hier netterweise ein Repository mit Installationsskripte für verschiedene Docker CE-Versionen bereit.

resource "digitalocean_droplet" "dockernodes" {
    count = 3
    image = "ubuntu-16-04-x64"
    name = "dockernode-${count.index}"
    region = "fra1"
    size = "1Gb"
    private_networking = true
    ssh_keys = [
      "${var.ssh_fingerprint}"
    ]

  connection {
      user = "root"
      type = "ssh"
      private_key = "${file(var.pvt_key)}"
      timeout = "2m"
  }

  provisioner "remote-exec" {
    inline = [
      # install recommended docker version
      "curl https://releases.rancher.com/install-docker/17.03.sh | sh"
    ]
  }

}

output "public_ips" {
  value = ["${digitalocean_droplet.dockernodes.*.ipv4_address}"]
}

Zuerst muss einmalig die entsprechend Terraform-Provider lokal installiert werden. Die Terraform Konfiguration wird validiert, ein Installationsplan erstellt und dieser Plan dann ausgeführt. Nach weniger als zwei Minuten stehen die drei Maschinen für die Installation von Kubernetes zur Verfügung.

$ TF_PLAN=dockernodes.tfplan
$ terraform init
$ terraform validate
$ terraform plan -out $TF_PLAN
$ terraform apply $TF_PLAN

Nun müssen noch die konkreten IP-Adressen der Maschinen in die RKE-Konfiguration übertragen werden. In diesem Beispiel befindet sich das Template in der Datei cluster.template und mit Hilfe des Python Skripts create_config.py werden die IPs aus dem Terraform Plan extrahiert und ersetzt. Mit der RKE Version 0.0.9-dev hat nur die Kubernetes Rancher Installation 1.8.5 funktioniert. Ältere Versionen scheinen die neuen Installations-Checks noch nicht zu enthalten.

cluster.template

nodes:
- address: $server0
  internal_address: ""
  role:
  - controlplane
  - etcd
  hostname_override: ""
  user: root
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ""
- address: $server1
  internal_address: ""
  role:
  - worker 
  hostname_override: ""
  user: root
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ""
- address: $server2
  internal_address: ""
  role:
  - worker
  hostname_override: ""
  user: root
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ""
services:
  etcd:
    image: quay.io/coreos/etcd:latest
    extra_args: {}
  kube-api:
    image: rancher/k8s:v1.8.5-rancher3
    extra_args: {}
    service_cluster_ip_range: 10.233.0.0/18
  kube-controller:
    image: rancher/k8s:v1.8.5-rancher3
    extra_args: {}
    cluster_cidr: 10.233.64.0/18
    service_cluster_ip_range: 10.233.0.0/18
  scheduler:
    image: rancher/k8s:v1.8.5-rancher3
    extra_args: {}
  kubelet:
    image: rancher/k8s:v1.8.5-rancher3
    extra_args: {}
    cluster_domain: cluster.local
    infra_container_image: gcr.io/google_containers/pause-amd64:3.0
    cluster_dns_server: 10.233.0.3
  kubeproxy:
    image: rancher/k8s:v1.8.5-rancher3
    extra_args: {}
network:
  plugin: flannel
  options: {}
auth:
  strategy: x509
  options: {}
addons: ""
system_images: {}
ssh_key_path: $ssh_key_path

Die Provisionierung erfolgt nun mit dem Befehl rke up. Alle Kubernetes Komponenten werden gemäss der Rollen auf die entsprechenden Maschinen installiert und miteinander verbunden. Die Konfiguration des Kubernetes Cluster wird in der Datei .kube_config_cluster.yml gespeichert. Nun kann der Cluster mit dem gewohnten Kubernetes CLI Befehl kubectl genutzt werden.

$ kubectl --kubeconfig .kube_config_cluster.yml get nodes

Zusammenfassung

Der Artikel zeigt das Infrastruktur mit Hilfe von Terraform für einen Test sich schnell und mit übersichtlichen Mitteln erzeugen lässt. Die Provisionierung von Kubernetes ist mit RKE sehr flexible und verständlich möglich. Unser Dank gilt Claus Frein der die erste Version des Projekts bereitgestellt hat und mit uns zusammen an der nächsten Version arbeitet.

Als nächsten Schritt für unser Projekt ist geplant die Werkzeug besser als eigene Container bereitzustellen und ein flexiblere Generierung verschiedener Kubernetes Cluster zu ermöglichen. Das Ziel wird es sein, ein echtes Werkzeug bereitzustellen. Dann können auch verschiedenen Typen und Grössen von Maschinen berücksichtigt werden. Die Bereistellung und Provisionierung eines Kubernetes Test-Cluster kann so hoffentlich noch mehr vereinfacht werden.

"Um unsere Webseite für Sie optimal zu gestalten und fortlaufend verbessern zu können, verwenden wir Cookies. Durch die weitere Nutzung der Webseite stimmen Sie der Verwendung von Cookies zu. Weitere Informationen zu Cookies erhalten Sie in unserer Datenschutzerklärung."