In diesem Beitrag wollen wir uns mit der Bereitstellung von SQL Server in Kombination mit Kubernetes auf einem Ubuntu Server auseinandersetzen. Hierfür wollen wir anhand eines praktischen Beispiels zwei Kubernetes Objekte, einen Pod und einen SQL Server Service erstellen. Haben wir das alles auf einem Cluster zum Laufen gebracht, werden wir uns mittels des Azure Data Studios mit diesem verbinden. Als Umgebung werden wir einen Ubuntu 18.04 Server mit MicroK8s
verwenden.
Bevor wir mit der Bereitstellung unseres Kubernetes Clusters beginnen können, müssen wir zunächst MicroK8s
installieren und konfigurieren. Bei MicroK8s handelt es sich um eine zertifizierte Kubernetes Distribution von Canonical
, den Schöpfern von Ubuntu. MicroK8s stellt ein einziges Paket bereit, mit dem sich eine komplette Kubernetes Umgebung installieren lässt.
MicroK8s ist kompatibel mit Linux, Windows und macOS. In unserem Beispiel nutzen wir einen Ubuntu 18.04 Server.
Um MicroK8s zu installieren, loggen wir uns zunächst auf unserer Ubuntu Maschine ein und führen anschließend folgendes Kommando aus:
sudo snap install microk8s --classic
Nach erfolgreicher Installation kann mit dem folgenden Kommando überprüft werden, ob MicroK8s auch tatsächlich fehlerfrei auf der Maschine läuft:
microk8s.status
Weiterhin kann mit diesem Kommando geprüft werden, welche Addons für MicroK8s aktiviert sind:
Es ist im Allgemeinen darauf zu achten, dass der Computername der Ubuntu Maschine, auf der MicroK8s ausgeführt werden soll, weder Großbuchstaben noch Unterstriche enthält. Andernfalls kann kubernetes die Maschine nicht als Node registrieren.
Nun haben wir erfolgreich ein Single-Node Kubernetes Cluster erzeugt. Jetzt können wir einfache kubectl Kommandos ausführen und uns beispielsweise einer Liste aller Nodes innerhalb unseres Clusters anzeigen lassen oder uns einen Überblick über die ausgeführten Services verschaffen.
microk8s.kubectl get nodes
microk8s.kubectl get services
Es besteht nun die Möglichkeit, gewisse Dienste wie ein Dashboard, DNS oder Prometheus für unser Cluster zu aktivieren.
Wir führen hierfür folgendes Kommando aus:
sudo microk8s.enable dns dashboard registry prometheus metrics-server
Damit wir unser Dashboard ansehen können, müssen wir uns mit einem sogenannten Token
authentifizieren. Diesen erhalten wir mit folgenden Kommandos:
token=$(microk8s.kubectl -n kube-system get secret | grep default-token | cut -d " " -f1)
microk8s.kubectl -n kube-system describe secret $token
Die Ausgabe des letzten Kommandos entspricht dem Token. Diesen kopieren wir. Nun benötigen wir noch die Adresse für unser Dashboard. Hierfür führen wir dieses Kommando aus:
microk8s.kubectl get services -n kube-system -l k8s-app=kubernetes-dashboard
Hieraus können wir nun entnehmen, welche IP Adresse wir zum Verbinden mit unserem Dashboard benötigen. In unserem Fall müssen wir https://10.152.183.77:443 in der Internet Suchleiste eingeben und anschließend die aufkommende Warnung akzeptieren. Mit dem vorher kopierten Token können wir uns nun über die Login Seite mit dem Dashboard verbinden.
Nachdem wir nun erfolgreich unsere Ubuntu Maschine erstellt und MicroK8s als Kubernetes Cluster konfiguriert haben, können wir mit dem Erstellen eines Kubernetes Manifestes beginnen.
Um Objekte zu definieren, verwendet Kubernetes, wie Docker, YAML. Die einzelnen Objekte werden dann in einem Ordner, dem Manifest, gespeichert. In unserem Beispiel werden wir mehrere Objekte in einem Manifest speichern, das die Objekte, den Pod und den Service erstellt.
Wir beginnen also mit dem Erstellen unseres Manifests, das wir sql-server.yaml
nennen. Das erfolgt mit diesem Kommando:
touch sql-server.yaml
Um unsere YAML File nun zu bearbeiten, führen wir diesen Befehl aus:
vi sql-server.yaml
Um nach dem Bearbeiten die File zu speichern und den Editor zu verlassen, klicken wir einmal ESCAPE
und anschließend zweimal SHIFT + Z
.
Als Erstes erstellen wir unseren Pod:
apiVersion: v1
kind: Pod
metadata:
labels:
run: mydb
name: mydb
spec:
containers:
- image: mcr.microsoft.com/mssql/server
name: mydb
Wir geben ihm den Namen mydb
und verwenden den von Microsoft bereitgestellten SQL Server Container. Für den Container ist es notwendig Umgebungsvariablen für das Passwort, das Akzeptieren der EULA
und das Definieren einer SQL Server Produktversion zu setzen. Mit den gesetzten Variablen sieht unsere YAML File so aus:
apiVersion: v1
kind: Pod
metadata:
labels:
run: mydb
name: mydb
spec: containers:
- image: mcr.microsoft.com/mssql/server
name: mydb
env:
- name: ACCEPT_EULA
value: "Y"
- name: SA_PASSWORD
value: TestingPassword1
- name: MSSQL_PID
value: Developer
ports:
- containerPort: 1433
name: mydb
Nachdem wir nun einen Pod erstellt haben, müssen wir einen Service erstellen, der unsere Datenbank auf unserem Cluster verfügbar macht. Wir konfigurieren ihn wie folgt:
apiVersion: v1
kind: Service
metadata:
name: mydb
spec:
type: NodePort
ports:
- port: 1433
nodePort: 31433
selector:
run: mydb
Unseren Service nennen wir ebenfalls mydb und definieren seinen Typ als NodePort
. Den internen Port
spezifizieren wir mit 1433
und unseren NodePort
mit 31433
. Anschließend müssen wir einen Selektor definieren, um unserem Service mitzuteilen, welchem Port er zugeordnet werden muss. Dies können wir zu unserer Pod-Definition hinzufügen und diese beiden Objekte durch drei Bindestriche trennen.
Komplett sieht unser YAML File so aus:
apiVersion: v1
kind: Pod
metadata:
labels:
run: mydb
name: mydb
spec: containers:
- image: mcr.microsoft.com/mssql/server name: mydb
env:
- name: ACCEPT_EULA
value: "Y"
- name: SA_PASSWORD
value: passwort123
- name: MSSQL_PID
value:
Developer ports:
- containerPort: 1433
name: mydb
---
apiVersion: v1
kind: Service
metadata:
name: mydb
spec:
type: NodePort
ports:
- port: 1433
nodePort: 31433
selector:
run: mydb
Jetzt wurden alle wichtigen Ressourcen in unserem YAML File definiert, also können wir unseren SQL Server und unseren Service erstellen. Hierfür prüfen wir zunächst, welche Pods auf unserem Cluster definiert sind. Hierfür führen wir das Kommando aus:
microk8s.kubectl get pods
Als Ausgabe erhalten wir die Nachricht, dass im Standard Namespace unseres MicroK8s Clusters keine Pods definiert sind. Da das Kommando aber erfolgreich ausgeführt wurde, zeigt uns, dass unser Cluster läuft.
Als Nächstes überprüfen wir die Services mit:
microk8s.kubectl get svc
Wie zu erwarten läuft unser Kubernetes Service. Nun erstellen wir mithilfe unseres YAML Files unseren SQL Server und den Service. Hierfür führen wir dieses Kommando aus:
microk8s.kubectl apply -f sql-server.yaml
Überprüfen wir nun erneut unsere Pods und Services, erhalten wir:
Wir können sehen, dass sowohl unser SQL Server Pod als auch unser Service innerhalb unseres Clusters laufen.
Als letzten Schritt wollen wir uns mithilfe von Azure Data Studio mit unserem SQL Server verbinden. Hierfür müssen wir Azure Studio zunächst auf unserer Ubuntu Maschine installieren. Dies tun wir mit dem Kommando:
wget https://github.com/microsoft/azuredatastudio/releases/download/1.14.1/azuredatastudio-linux-1.14.1.deb
sudo dpkg -i azuredatastudio-linux-1.14.1.deb
Kontaktieren Sie uns gerne über das
Kontaktformular und vereinbaren ein unverbindliches
Beratungsgespräch mit unseren Berater:innen zur
Bedarfsevaluierung. Gemeinsam optimieren wir Ihre
Umgebung und steigern Ihre Performance!
Wir freuen uns auf Ihre Kontaktaufnahme!