Archive

Tech4Hosting Kubernetes Cluster in 5 Minuten einrichten

Du möchtest deine Applikation auf Kubernetes betreiben? Dir und deinen Teammitgliedern fehlt allerdings die Erfahrung damit? Kein Problem, Kubernetes ist relativ neu auf dem Markt und zudem noch sehr komplex. Hinzu kommt, dass das Betreiben eines Kubernetes Clusters eine andere Herausforderung ist, als Kubernetes als Plattform zu nutzen.

Mit Tech4Hosting Kubernetes (GSK) bieten wir dir einen Managed Kubernetes Service an, sodass du dich um den Betrieb deiner Applikation kümmern kannst und nicht um das Cluster selbst.

In diesem Tutorial erstellen wir einen GSK Cluster, konfigurieren die Kommandozeilen-Tools und installieren ein WordPress auf dem GSK. Viel Spaß!

Einen GSK Cluster erstellen

Wie immer legen wir viel Wert auf eine möglichst einfache und effiziente Bedienbarkeit, daher ist auch das Erstellen eines GSK gewohnt einfach. Als erstes musst du dich natürlich in unser Tech4Hosting Panel einloggen. In der linken Navigationsleiste wählst du dann das schon bekannte Kubernetes-Icon aus.

Jetzt erstellst du den Service und bekommst ein Dialogfenster angezeigt, in dem du ein paar einfache Konfigurationen vornehmen kannst.

Gib deinem Cluster einen Namen und passe die Konfiguration an. Für das Beispiel reichen die oben abgebildeten Einstellungen völlig aus. Diese kannst du auch nachher anpassen.

Nun erstelle das GSK Cluster. Das dauert ungefähr 5-7 Minuten. Die Zeit nutzen wir und richten derweil die Kommandozeilen-Tools ein.

Zugriff aufs GSK Cluster einrichten

Um mit dem GSK Cluster bequem und einfach interagieren zu können installieren wir jetzt kubectl, helm und gscloud.

kubectl – Kubernetes CLI

Da ich auf einem Linux System unterwegs bin, sind folgende Schritte darauf ausgelegt.

curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.18.0/bin/linux/amd64/kubectl

chmod +x ./kubectl

sudo mv ./kubectl /usr/local/bin/kubectl

Für andere Systeme verweise ich auf die offizielle Dokumentation von Kubernetes selbst:

Helm – der Kubernetes Packet Manager

Da wir wahrscheinlich noch auf das Cluster warten, installieren wir schnell noch Helm. Helm ist eine Art Paketmanager, mit dem wir nachher WordPress installieren werden. Wenn man gerade mit Helm startet, sollte man auf jeden Fall Helm 3 benutzen.

Hier wieder mein Installationsverlauf mit Verweis auf die offizielle Dokumentation:

Geh auf GitHub Releases für die letzte stable Helm 3 Version. Download Helm 3 für die jeweilige Architektur, entpacken und dann noch in meinen Pfad verschieben:

wget https://get.helm.sh/helm-v3.2.4-linux-amd64.tar.gz
tar -xzf helm-v3.2.4-linux-amd64.tar.gz
mv linux-amd64/helm /usr/local/bin/helm

gscloud – Tech4Hosting CLI

Wir von Tech4Hosting entwickeln mit gscloud ein Kommandozeilen-Tool, mit dem du mit Tech4Hosting interagieren kann. Warum brauchen wir jetzt ein weiteres Tool, um mit Kubernetes zu agieren? Würde nicht die kubeconfig ausreichen? Ja, du kannst jetzt ins Panel gehen und dir die kubeconfig für deinen GSK Cluster herunterladen und schon loslegen.

Allerdings ist das Clientzertifikat in der kubeconfig nur 3 Tage gültig, da dies nicht widerrufen werden kann. Damit wir nicht alle 3 Tage ins Panel müssen und eine neue kubeconfig herunterladen müssen, können wir gscloud so einrichten, dass es beim Ablauf automatisch das Zertifikat erneuert, wenn wir kubectl nutzen.

Holt euch dafür den Downloadlink für eure Architektur hier.

gscloud installieren

wget https://github.com/Tech4Hosting/gscloud/releases/download/v0.3.0-beta/gscloud_0.3.0-beta_linux_amd64.zip
unzip gscloud_0.3.0-beta_linux_amd64.zip
sudo mv gscloud_0.3.0-beta_linux_amd64 /usr/local/bin/gscloud

gscloud konfigurieren

Wir richten gscloud nun ein, da wir damit die kubeconfig sehr einfach generieren können.

Hiermit erstellen wir eine config für gscloud:
gscloud make-config

Das sieht dann so aus:

cat /home/andrej/.config/gscloud/config.yaml

Im Panel unter API-Keys kannst du dir die User-UUID kopieren und einen API-Token erstellen. Diese beiden kopierst du in die gscloud config. Die kubeconfig kannst du dir nun mit folgendem Befehl generieren:

gscloud kubernetes cluster save-kubeconfig --credential-plugin --cluster CLUSTER-UUID

Die Cluster-UUID bekommst du im Panel angezeigt, wenn du auf dein GSK Cluster auswählst.

Mit dem GSK Cluster arbeiten

Das GSK Cluster ist provisioniert, alle Kommandozeilen-Tools sind eingerichtet. Jetzt kannst du anfangen mit dem Cluster zu interagieren. Zuerst schauen wir uns alle Nodes an:

kubectl get nodes

Dann schauen wir, welche Pods auf dem GSK Cluster laufen:

kubectl get pods --all-namespaces

WordPress mit Helm installieren

Helm ist der Paketmanager für Kubernetes. Viele bekannte Anbieter bieten ihre Kubernetes YAML Dateien als Helm Chart an. Es gibt momentan 2 Hubs auf denen man Helm Charts finden kann.

Jetzt suchst du nach “Wordpress” und siehst mehrere Anbieter.

Wir nehmen das Helm Chart “bitnami/wordpress”.

Mit “helm repo list” kann man prüfen, ob man das Repository schon konfiguriert hat. Bei einer frischen Installation von Helm 3 sollte kein Repository vorhanden sein. Mit folgendem Befehl fügen wir das Repository von bitnami hinzu:

helm repo add bitnami https://charts.bitnami.com/bitnami

Kurze Kontrolle mit helm repo list

Nun ist das Repository für Helm verfügbar. Als nächstes wird ein namespace erstellt in dem wir unsere WordPress Ressourcen deployen wollen.

kubectl create namespace wordpress

Im letzten Schritt deployen wir mit Helm das WordPress Chart. Hierfür belassen wir es bei den Standardwerten, da diese für unser Beispiel ausreichen.

helm install test-wordpress bitnami/wordpress --version 9.4.2 --namespace wordpress

Die Standardwerte eines Helm Charts werden für gewöhnlich im README.md gepflegt und sind auch im Hub einsehbar: https://hub.kubeapps.com/charts/bitnami/wordpress

Im Code des Helm Charts selbst sind die Standardwerte in der values.yaml des Helm Charts zu finden: https://github.com/bitnami/charts/blob/master/bitnami/wordpress/values.yaml

Für uns sind folgende Parameter wichtig:

service.type Kubernetes Service type LoadBalancer

Damit wird in dem GSK Cluster ein LoadBalancer erstellt, der die WordPress Installation direkt von außen erreichbar macht.

kubectl get svc --namespace wordpress
original


Wir sehen in unserem Beispiel, dass der WordPress Service mit der externen IP http://45.12.48.144/ erreichbar ist.

Im WordPress Helm Chart sind folgende Werte für persistente Datenhaltung wichtig:
mariadb.master.persistence.enabled true
mariadb.master.persistence.size 8Gi

persistence.enabled true
persistence.size 10Gi

In dem GSK Cluster werden dadurch automatisch Persistent Volumes und Persistent Volume Claims angelegt:

kubectl get pvc -n wordpress

kubectl get pv

Mit GSK einen Kubernetes Cluster erstellen

Mit einem Tech4Hosting Kubernetes Cluster haben wir in Windeseile ein gemanagtes Kubernetes Cluster erstellt. Funktionen wie ein LoadBalancer und Storage Volumes sind direkt integriert und machen den Einstieg in die komplexe Kubernetes Welt sehr einfach.

Zurück zur Tutorial Übersicht Back to Tutorial Overview

How To: Marketplace 2.0 – Anwendungen erstellen und veröffentlichen

Click-Click-Fertig! Du willst auch so einfach neue Anwendungen auf unserem neuen Marketplace erstellen, freischalten und nutzen? Kein Problem! Dann folge einfach diesem Tutorial.

Auf unserem Marketplace konntest du bisher verschiedene, von uns zur Verfügung gestellte, Anwendungen nutzen. Um dir mehr Freiraum zu geben, haben wir den Marketplace um neue Funktionen ergänzt. Bei dem Marketplace 2.0 gibt es nun die Möglichkeit neue Anwendungen deiner Wahl zu erstellen und zu hinterlegen. Somit bieten wir dir mehr Flexibilität und die Freiheit eigene Software in deine Cloud-Lösung zu integrieren. Aber damit nicht genug! Du kannst deine Anwendungen jetzt auch für andere Tech4Hosting Kunden zur Verfügung stellen. Wie das Ganze funktioniert, erfährst du im Folgenden.

Voraussetzung

Um eine Anwendung deiner Wahl im Tech4Hosting Panel hinterlegen zu können, musst du diese erst einmal bei uns auf dem Object Storage als Bucket hochladen. Dafür sollte deine Software bereits auf einem Server laufen. Dann kannst du vom Storage des Servers einen Snapshots erstellen und diesen dann im Object Storage als Bucket exportieren.

Schritt 1

Navigiere zuerst zu Object Storage und erstelle einen leeren Bucket. In meinem Beispiel heißt der Bucket “Tech4HostingUser”.

Objekt Storage erstellen

Schritt 2

Als Nächstes navigierst du über Menüleiste zum Storage. Danach erstellst du einen Snapshot und exportierst diesen in den vorher erstellten Object Storage als Bucket.

Export von Storage zu Object Storage

Jetzt bist du startklar, um deine Anwendung im Marketplace zu erstellen.

Anwendung bereitstellen

Um deine Anwendung zu erstellen, musst du im Expert Panel über die Menüleiste in den Marketplace navigieren und dort auf “Anwendung erstellen” klicken.

Tech4Hosting Marketplace

Als Nächstes musst du die Pflichtfelder ausfüllen: Wichtig ist, dass du ein Bild oder Logo für deine Anwendung hast, um es hochzuladen.

Marketplace 2.0: Anwendung erstellen

Tipp: Eine Veröffentlichung der Anwendung auf Tech4Hosting Panel bedarf eine Kontaktaufnahme via Email an [email protected], um die Veröffentlichung auf dem Marketplace genehmigen zu lassen. Dann erscheint auch den Bereich “Bereit für Marketplace” und dem Button “VERÖFFENTLICHUNG ANFRAGEN”, wie es im obigen Screenshot der Fall ist.

Marketplace 2.0: Anwendung erstellen

Wenn du die Pflichtfelder ausgefüllt hast, kannst du deine Anwendung endlich starten.
Wie bereits angedeutet, gibt es die Möglichkeit deine Applikation für alle Kunden zu veröffentlichen. Hierfür gibt es ein paar wichtige Informationen, die du noch ausfüllen musst: eine Lizenz, Nutzerbedingungen, Informationen zur Inbetriebnahme, und in der Software enthaltene Komponente.

Marketplace 2.0: Veröffentlichung der Anwendung

Marketplace 2.0: Anwendung veröffentlichen

Zur Sicherheit prüft Tech4Hosting deine Software auf deren Funktionstüchtigkeit bevor sie auf unserem Marketplace für alle freigegeben wird.

Probiere es selbst aus

Ein Vorteil des neuen Marketplace ist, dass du als Tech4Hosting Kunde auch als Softwareanbieter (ISV) agieren kannst. Zudem können unsere Partner ihren Mandanten die Anwendungen ihrer Wahl freigeben. Dabei handelt es sich um die Anwendungen, die sowohl von Tech4Hosting als auch von anderen Partner veröffentlicht worden sind. Weiterhin hast du als unser Kunde alle deine Anwendungen gebündelt in deiner Cloud. Das vereinfacht die Arbeit, da die Anwendungen bereits vorhanden sind, wodurch du deutlich effektiver bist und Zeit sparst. Viel Spaß dabei.

Zurück zur Tutorial Übersicht Back to Tutorial Overview

Node.js richtig installieren

Nodejs_richtig_installieren_DE

Ein Node Installations-Guide

Die offiziellen Installationspakete von Node.js stehen inzwischen für viele Systeme zur Verfügung und funktionieren auch gut, so lange man mit einer Version von Node zurechtkommt. Wenn du jedoch im Laufe der Zeit an mehreren Node.js Projekten arbeitest, fährst du mit einer Methode auf lange Zeit gesehen am besten. Zudem verlanden einige Tools bestimmte Versionen von Node, das pusht die Installationsmethode mit dem Node.js Versionsmanager nvm an die Spitze der Liste. Das Tolle an nvm ist, dass du damit parallel verschiedene Versionen von Node.js auf deinem Setup nutzen kannst. Du kannst also bspw. die latest LTS, die neuste Version und beliebig viele andere Node.js Versionen, die am besten kompatibel mit deinen Tools sind betreiben. Mit nvm bleibst du flexibel beim Entwickeln und sparst eine Menge Zeit.

Die Installationsmethode über nvm ist besonders für diejenigen unter euch zu empfehlen, die ihre Setups mit verschiedenen Node Releases testen wollen, die an Node selbst hacken, oder die in allen anderen Situationen mehrere Node-Installationen benötigen. Wenn du gerade erst mit Node.js startest, kannst du gelassen den normalen Installationsweg wählen.

In diesem Artikel zeigen wir dir, wie du Node.js mit nvm auf Linux Ubuntu und Mac installierst. Darüber Hinaus gehen wir auch kurz auf die alternativen Installationswege ein. Eine nvm Version für Windows steht derzeit leider nicht bereit.

Node.js auf Ubuntu installieren

Von einer Node.js Installation über die offiziellen Paketquellen mit apt-get sollte abgesehen werden. Node.js ist hierüber zwar Verfügbar, jedoch nicht immer in der aktuellsten Version. Stattdessen kannst du Node mittels Fremdquelle installieren (s. u.).

Wenn du Node.js bereits über den built in Paketmanager installiert hast, kannst du Node mit folgendem Befehl von deinem System entfernen:

sudo apt-get purge nodejs && sudo apt-get autoremove && sudo apt-get autoclean

 

Node.js via package-manager auf Ubuntu installieren

Node.js kann über eine Fremdquelle installiert werden, welche in den eigenen Paketquellen eingebunden wird. Bei diesem Weg ist kein switchen zwischen Node Versionen möglich.

curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
sudo apt-get install -y nodejs

Der curl-Befehl lädt ein Bash Skript was dafür sorgt, dass automatisch das passende deb-Paket zu deiner Ubuntu-Version heruntergeladen wird.

Node.js mit nvm auf Linux/Ubuntu installieren

1. Im ersten Schritt lädst du das Installations Skript für nvm.

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash

Das heruntergeladene Skript cloned dir ein nvm Repository in dein Root-Verzeichnis ~/.nvm und fügt eine Quellenangabe zu deinem Bash-Profil hinzu (entweder unter ~/.bash_profile, ~/.zshrc, ~/.profile, oder ~/.bashrc).

2. Reloade deine aktuelle Shell oder öffne eine neue Session in einem zweiten Fenster/Tab.

source ~/.bashrc

3. Überprüfe, ob nvm korrekt installiert wurde:

command -v nvm

4. Lass dir anzeigen, welche Node.js Versionen derzeit installiert sind (da wir bisher nur nvm installiert haben sollten keine vorhanden sein) .

Führe dazu folgenden Befehl aus:

nvm ls

5. Im nächsten Schritt kannst du die letzte LTS Version von Node.js über nvm installieren (empfohlen für production). Derzeit ist das Version 8.9.4.

nvm install v8.9.4

6. Weitere Node.js Version installieren.
Installiere nun die aktuellste Version von Node mit den neusten Features.

nvm install v9.5.0

Falls du für eines deiner Tools eine bestimmte Node.js Version benötigst oder die Features der neuesten Node Version ausprobieren willst, kannst du auf diesem Wege ganz einfach weitere Versionen hinzufügen.

7. Deine default Node Version in nvm aktivieren.
Du kannst jetzt einfach zwischen deinen installierten Node Versionen switchen und diese dann in einer neuen Terminal Session benutzen. Deine Default Version wählst du mit folgenden Befehl und der gewünschten Versionsnummer aus:

nvm alias default v8.9.4

 

Noch mehr Flexibilität gibt dir das Kommando nvm use [versionsnummer]. Mit dem Kommando kannst du festlegen, welche Node Version du für jedes Projekt verwenden möchtest. Das Kommando muss innerhalb deines Projekt-Ordners ausgeführt werden. Falls du später an vielen Projekten gleichzeitig arbeitest und diese auf unterschiedlichen Node Versionen basieren, kannst du dir einfach ein kleines Bash-Skript pro Projekt anlegen. So musst du dir nicht extra merken, welche Node Version du für ein Projekt verwendet hast. Wenn du dich in einer anderen Session befindest, wird dort weiterhin deine Default nvm Node Version verwendet.

Checke deine Node Version mit dem Befehl:

node -v

 

Das nvm Node.js Paket beinhaltet bereits npm, den Node Package Manager. Du brauchst diesen also nicht noch separat zu installieren. Einige npm Pakete benötigen jedoch zusätzlich das build-essential package, damit sie richtig installiert werden können.

Auf Ubuntu installierst du das Paket mit dem Befehl:

apt-get -y install build-essential

(Unter Mac musst du XCode oder die Command Line Tools installiert haben.)

Via package-manager auf anderen Linux-Distros

Folge den Installationsanweisungen auf dieser Seite um Node.js auf anderen Linux-Distributionen wie bspw. CentOS oder Fedora über einen package-manager zu installieren.


Node.js auf Mac installieren

Über den offiziellen Installer:
https://nodejs.org/en/download/

oder z.B. mit Homebrew oder MacPorts:
https://nodejs.org/en/download/package-manager/#osx

Node.js mit nvm auf Mac installieren

Auch auf dem Mac bietet dir nvm die meiste Flexibilität. Als Voraussetzung dafür benötigst du Apple’s XCode oder du kannst einfach die kleineren Command Line Tools über dein Terminal installieren.

xcode-select --install

(Falls frisch installiert, musst du XCode zunächst starten und den Richtlinien zustimmen.)

Anschließend kannst du mit der Installation in einem neuen Terminal Fenster beginnen.

1. nvm Installer starten

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash

Hinweis: Vergewissere dich, vor dem Ausführen des Befehls, ob sich ein Bash-Profil innerhalb deines Root-Verzeichnis befindet (entweder ~/.bash_profile, ~/.zshrc, ~/.profile, oder ~/.bashrc).

Sollte keines vorhanden sein, leg ein neues an mit:

touch ~/.bash_profile

Sollte es bei deiner Installation zu Problemen kommen, kannst du nvm auch manuell installieren. Folge dazu den Anweisungen in der nvm README.

2. Reloade deine aktuelle Shell oder öffne eine neue Session in einem zweiten Fenster/Tab.

source ~/.bash_profile

 

Die weiteren Installationsschritte unter OSX gleichen denen der Installation unter Linux/Ubuntu. Folge dafür einfach den Schritten 3 – 7 weiter oben.

Node.js auf Windows installieren

Unter Windows kannst du den offiziellen Installer benutzen, nvm ist leider nicht für Windows verfügbar.

Fazit

Dank Ryan Dahl’s Idee hat JavaScript ein Leben außerhalb des Browsers ermöglicht. Innerhalb von nur wenigen Jahren ist Node zu einer wichtigen Größe im Server-side Development geworden. Node ist bekannt dafür extrem skalierbar zu sein und kann ohne Probleme tausende von I/O Bound Operations ausführen. Viele große und kleine Firmen haben Node in ihre Services integriert und konnten durch Node ihre Serverkapazitäten wesentlich effizienter betreiben.

Du hast Lust die Power von Node auf einem echten Cloud-Server zu testen? Dank der simplicity unseres Tech4Hosting Panel kannst du dir blitzschnell deinen eigenen Cloud-Server aufbauen und deine Node-Anwendungen testen.

Zurück zur Tutorial Übersicht Back to Tutorial Overview

Node.js Beginner Guide

Node.js für Anfänger

Dieser Artikel richtet sich an alle, die mit Node beginnen möchten, aber noch nicht wirklich viel über Node wissen. Du hast Node bestimmt schon gegoogelt und vielleicht festgestellt, dass viele Tutorials oder Artikel zu advanced sind oder die wirklichen Basics auslassen. Das liegt auch daran, dass Node sich seit seinem Erscheinen rapide entwickelt hat. Gerade für Beginner ist es deswegen schwer, die guten und aktuellen Informationen für den Start mit Node zu finden. Vielleicht hast du Node auch gerade erst heruntergeladen und fragst dich: was stelle ich jetzt damit an? Dann ist das hier dein Artikel. Was der Artikel nicht ist, ist eine komplette Einführung in Node, er soll mehr ein Startpunkt für deine ersten Schritte mit Node sein und dir aufzeigen was Node auszeichnet.

Du hast Fragen oder Anregungen? Du wünschst dir ein Tutorial zu einem bestimmten Thema? Schreib uns eine Mail an [email protected]

Was ist Node.js?

Node.js ist eine noch relative junge und spannende JavaScript Runtime für die Entwicklung von Webanwendungen und Anwendungsservern. Darüber hinaus kann Node.js auch für generelle Programmierungs Zwecke eingesetzt werden. Du kannst mit Node alles bauen, von einfachen Command-Line Tools bis hin zu dynamischen HTTP-Servern.

Es war für lange Zeit ein unerfüllter Traum für das Web, dieselbe Programmiersprache auf Server- und Client-Seite zu betreiben. Auch gerade deswegen hat Node in kurzer Zeit so viel an Popularität gewonnen und spielt heute eine bedeutende Rolle im Development. Viele Firmen, darunter auch große Namen wie PayPal oder ebay, haben Teile ihrer Services auf Node.js umgestellt. Die Vorzüge von Node sind unter anderem die extreme Skalierbarkeit und seine Schnelligkeit im Ausführen von I/O Bound Operations. Das Managen von Input und Output bei Systemen, die über ein Netzwerk kommunizieren, stellt ein eher schwieriges Problem dar. Dazu gehören alle Wege, die Daten im Netzwerk nehmen, read- und write-Vorgänge aus dem Netzwerk auf Festplattenspeicher und vieles mehr. Du kannst dir bestimmt vorstellen, dass so etwas clever geplant sein muss, damit es schnell geht. Node löst dieses Problem sehr gut mit einer ausgetüftelten Kombination von serverseitigem JavaScript-Code, asynchroner Programmierung, anonymen JavaScript Funktionen und einer komplett Ereignis-basierten Architektur. Das Konzept von Node baut auf der bekannten und super schnellen JavaScript Engine V8 aus Googles Chrome Browser auf. Wichtig für dein Verständnis ist, dass Node selbst keinen Webserver darstellt. Node funktioniert nicht wie ein Apache-Server auf deinem Ubuntu und es gibt auch kein Config-File, welches auf deine HTML-Files verweist. Wenn du Node als HTTP-Server einsetzen willst, musst du dir deinen Server selbst schreiben. Wie du deinen eigenen HTTP-Server schreibst, ist auch das erste, was du in der Node Documentation gezeigt bekommst. Dank der eingebauten Libraries von Node ist das Coden eines simplen Servers nicht viel Arbeit. Node ist mit vielen nützlichen Build-In Modulen ausgestattet, du musst also nicht jede Kleinigkeit “from scratch” schreiben. Der Gedanke hinter Node war, asynchrone I/O Vorgänge einfacher und bequemer zu machen. Im Prinzip ist Node also nicht nur eine Runtime Environment, sondern auch eine Library. Oder kurz und knapp gesagt: Node.js ist server-side JavaScript.

Node.js installieren

Node.js ist einfach und schnell zu installieren. Wie du Node auf Linux, Mac und Windows installierst, haben wir dir hier gezeigt: Node.js richtig installieren

Node.js installiert, und jetzt?

Nachdem du Node installiert hast, steht dir das Node Command-Line-Interface zur Verfügung. Das Node-CLI kannst du auf zwei verschiedene Arten nutzen, ich stelle dir einmal beide vor.

Der erste Weg ist über das Node REPL-Terminal (read-eval-print-loop), wo du puren Javascript-Code interaktiv ausführen kannst.

Node REPL Terminal Example

Wie du im obigen Beispiel sehen kannst, führt Node den eingegebenen JavaScript Code „console.log(“Hello from Tech4Hosting”);“ direkt aus und zeigt dir das Ergebnis an. Node liefert unsere Log-Message und einen Return-Wert vom Typ “undefined” zurück. Für jedes Kommando wird immer ein Return-Wert zurückgeliefert. In unserem Fall wird jedoch kein Wert zurückgeliefert, da console.log nichts returned. Mit dem Befehl exit verlässt du den Prozess wieder.

Der zweite Weg ist, eine JavaScript Datei im Node Terminal auszuführen.
Das ist der gewöhnliche Weg wie du Node benutzt.

Du erstellst einfach eine JavaScript Datei und schreibst deinen Code mit einem Texteditor deiner Wahl, z.B. Atom, in die Datei. Anschließend führst du die Datei mit dem Befehl

node [Dateiname].js

im Terminal aus. In diesem Beispiel habe ich die gleiche console.log Message wie oben in eine Datei mit dem Namen sample.js geschrieben und in meinem Terminal-Fenster ausgeführt:

Node CLI Example

Node führt den JavaScript Code aus und printed die Log-Message in die Shell. Node macht im Prinzip das gleiche, was dein Browser beim Ausführen von JavaScript tut, nur das der Output Stream nicht in deiner Browser-Konsole landet.

Node.js Modules

Node kommt mit vielen Built-In Modulen, von denen du nach der Installation Gebrauch machen kannst. Mit diesen Modulen kannst du dir externale Funktionalitäten in deine Node Runtime einbinden, auf die du dann zugreifen kannst. Stell sie dir so ähnlich wie JavaScript Bibliotheken vor.

Wenn ein Modul eingebunden wird, erkennst du das an dem Keyboard require. Um innerhalb deines eigenen Codes auf die functions des mit Node gelieferten HTTP-Modules zugreifen zu können, musst du bspw. folgende Zeile einfügen:

var http = require (“http”)

So würdest du das HTTP-Modul in deinen eigenen Code einfügen, den Inhalt des Moduls übergibst du einer lokalen Variablen (http). Es ist gängig, der Variablen den Namen des Moduls zu vergeben, du könntest hier aber genauso gut auch einen eigenen Namen wählen. Durch die Zuweisung des HTTP-Modules wird die lokale Variable http zu einem Objekt, das alle objektgebundenen Methoden des HTTP-Modules umfasst.

Ebenso ist es möglich, eigene Node Modules zu erstellen, das Einbinden eines eigenes Moduls funktioniert ganz ähnlich wie das oben gezeigte Einbinden eines internen Node Modules.

Hier ein Beispiel:

var http = require (“./meinmodul”)

An die Stelle des Keywords für ein internes Modul, würdest du in die runden Klammer den Pfad zu deinem eigenen Modul angeben. Auf diese Weise kannst du deine index.js übersichtlich halten und bestimmte Funktionsweisen deiner App gruppieren und in eigene Modules auslagern. Die Funktionsweisen, auf die du an anderer Stelle deiner App zurückgreifen willst, musst du innerhalb deiner ausgelagerten Modules exportieren.

So würde ein simples Modul mit einer Hello World Funktion aussehen:

exports.hello_world = function () {
console.log(“Hello World”);
}

Mit Hilfe des exports-Objekts kannst du Funktionen, Klassen und Variablen exportieren, es ist extra für diesen Zweck gedacht und ein spezielles Objekt des Node.js Modulsystems. Das oben gezeigte Modul kannst du unter meinmodul.js abspeichern und dann wie folgt einbinden und die Hello World Funktion aufrufen:

var meinmodul = require (“./meinmodul.js”);
meinmodul.hello_world();

Natürlich ist es möglich, beliebig viele Funktionen und Klassen innerhalb des Moduls für dein exports-Objekt zu exponieren.

npm – Node Package Manager

npm ist der Paketmanager für Node.js. Es gibt eine große Community, die nützliche Module veröffentlicht, jeder kann diese Module in seinen eigenen Code einbinden und auch du kannst deine eigenen Module für die npm Community bereitstellen. Npm wird bei deiner Installation von Node bereits mit installiert, tippe das Kommando npm help in dein Terminal, um zu schauen ob npm verfügbar ist.

npm Packages sind unkompliziert zu installieren, du verwendest einfach den Befehl npm install + den Namen des Module-Packages. Wie du ein npm-Paket installierst, steht auch immer auf der jeweiligen npm Seite des Paketes. Zudem ist bei vielen Packages der Sourcecode auf GitHub hinterlegt, hier findest du meistens eine README und ggf. auch Beispiele.

Ein populäres npm-Paket ist Forever, Forever sorgt dafür das dein Node Skript kontinuierlich ausgeführt wird. Auf der GitHub und npm-Site von Forever findest du Anweisungen für die Installation. Forever würdest du bspw. mit folgendem Befehl über deine Shell installieren:

npm install forever -g

(Das -g Flag steht für eine globale Installation)

Solltest du gerade nicht den genauen Namen zur Hand haben, kannst du auch einfach innerhalb deiner Shell nach einem npm-Paket suchen. Nutze dafür den Befehl:

npm search

Der Befehl liefert dir den Namen sowie eine Beschreibung zu allen Treffern zurück.

npm installiert deine Modul-Packages innerhalb deines Projekt-Ordners in das Unterverzeichnis node_modules. Sollte das Modul-Package selbst noch Dependencies besitzen, werden diese ebenfalls in einen Ordner node_modules innerhalb dieses Unterverzeichnisses installiert.

Weitere npm Befehle

Du kannst dir eine Liste aller Module innerhalb deines Projekts ausgeben lassen, nutze hierfür das Kommando:

npm ls

Ein bereits installiertes npm-Package updaten kannst du mit:

npm update [paketname]

Wenn du npm update ohne einen Paketnamen ausführst, werden alle deine Packages auf die letzte Version upgedatet.

npm EACCES-ERRORS vermeiden

Bei der Installation von globalen npm-Paketen (wie z. B. bei unserem Forever Beispiel) kann es zu Berechtigungsfehlern kommen. Diese erkennst du an einer EACCES Error-Message. Bei mir selbst traten auch schon EACCES Errors auf, deswegen möchte ich dir hierfür 2 Lösungsvorschläge an die Hand geben:

Der erste Weg, den Fehler zu vermeiden, ist npm bzw. Node über den Versions Manager nvm zu installieren. Wie das geht, zeigen wir dir in unserem Tutorial Node.js richtig installieren. Du brauchst dafür nicht deine derzeitigen Versionen von Node und npm vom System zu entfernen.

2. Der zweite Weg ist etwas aufwändiger und wird dir hierveranschaulicht.

File I/O mit Node.js

Das Node.js File System Module ist eines der wichtigsten Module in Node. JavaScript selbst bietet dir keine Funktion um Dateien ein- und auszulesen. Dieses Module bietet dir die nötigen Functions um mit Verzeichnissen und Dateien Sachen anzustellen.

Ich zeige dir jetzt mal ein kleines Beispiel, wie du eine Datei mit Node einliest. Wir nutzen dazu eine Function des File System Module welche sich readFile nennt. Ich habe im Vorfeld eine Textdatei mit dem Namen “beispiel.txt” im selben Verzeichnis angelegt.

Das erste Argument der Funktion verweist auf den Pfad, das zweite Argument gibt die Zeichenkodierung an. Wenn dir die Zeichenkodierung deiner Textdatei nicht bekannt ist, bist du auf der sicheren Seite wenn du UTF-8 angibst, die meisten modernen Systeme benutzen diese Kodierung. Lässt du das Argument Zeichenkodierung aus, wird dir kein String zurückgegeben sondern ein Buffer Objekt. Ein Buffer ist so etwas ähnliches wie ein Array, aber darum musst du dir erstmal keine Gedanken machen. Der folgende Code liest die Textdatei ein und loggt den Inhalt in deine Konsole, sobald du ihn ausführst.

// An dieser Stelle wird das File System Module geladen
var fs = require('fs');

// Den Inhalt der Textdatei in den Speicher einlesen
fs.readFile('beispiel.txt', 'utf8', function (err, content) {

// sollte ein Error auftreten 
// wird der Error ausgeworfen und die App beendet
  if (err) throw err;

console.log('Das ist der Inhalt der Textdatein', content);

});

Eine weitere Function des File System Module ist writeFile.
Mit writeFile kannst du eine Datei schreiben:

var fs = require('fs');

// Datei erstellen und Inhalt schreiben
fs.writeFile('karneval.txt', 'Kölle Alaaf', function(err) {


// Bei Fehler ERROR ausgeben, andernfalls Erstellung bestätigen
if (err)
    console.log('Error beim schreiben der Datei:', err);
  else
    console.log('Datei erstellt.');

});

 

HTTP-Server mit Node.js


var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello, World!n');
}).listen(8080, '127.0.0.1');

console.log('Server running at http://127.0.0.1:8080');

Du hast bestimmt schon eine Ahnung, was in dem Code passiert, oder?
Du siehst einen sehr einfach gestrickten HTTP-Server in Node. Lass uns das Ganze mal ein wenig genauer analysieren… Was in der ersten Zeile passiert, haben wir ja oben bereits geklärt. An dem require erkennst du, dass das HTTP Module geladen wird.
Danach rufen wir die Funktion createServer auf, eine der vielen Funktionen die das HTTP Module liefert. Anschließend übergeben wir die createServer Funktion an eine anonyme Funktion.

Wenn du den Code bei dir ausführst und http://127.0.0.1:8080 in deinem Browser aufrufst, wirst du von einer “Hello, World!” Nachricht begrüßt. Vielleicht fragst du dich, warum der Node Prozess bestehen bleibt, nachdem du die Datei ausführst? Der Grund dafür ist ein aktiver Event-Listener. Die listen Funktion erstellt einen Event-Listener der den HTTP-Server startet und auf eingehende Verbindungen lauscht. Dieser Event-Listener bleibt bestehen und wartet bis du das Programm beendest, führe dazu in deinem Terminal Control+C aus.

Fazit

Ich hoffe, dass ich dir Node.js mit diesem Artikel ein bisschen näher bringen konnte und du ermutigt wurdest, selbst mit Node zu experimentieren. Deiner Fantasie beim Erschaffen von Applications mit Node sind kaum Grenzen gesetzt. Die Core Libraries und die verfügbaren npm Module liefern dir mächtige Puzzlestücke zum Erstellen von komplexen Apps.

Melde dich gerne zu unserem Tutorial Newsletter an und verpasse keine spannenden Developer Themen mehr! Wir schicken dir 1x im Monat die Hot Topics von uns zu ?

Zurück zur Tutorial Übersicht Back to Tutorial Overview

MySQL Feinabstimmung der Benutzerrechte

MySQL Benutzerrechteverwaltung

Rechte pro Tabelle und sogar pro Spalte sinnvoll einstellen

Nachdem du in in unserem Artikel MySQL Datenbank erstellen und löschen gelernt hast, wie man in MySQL eine Datenbank erstellt und löscht und dir in unserem Artikel zum Thema Wie erstelle ich einen MySQL Benutzer und weise ihm Rechte zu? gezeigt wurde, wie man einem Nutzer Zugriff auf eine Datenbank in MySQL gewährt, wird dir in diesem Tutorial schrittweise näher gebracht, wie du Benutzerrechte nicht nur für eine Datenbank definierst, sondern pro Tabelle und sogar pro Spalte für bestimmte Nutzer festlegst. Beim Tutorial zu ‚MySQL Feinabstimmung der Benutzerrechte‘ werde ich mit dir im Sinne eines Real-Live Case eine Datenbank erstellen, diese mit Tabellen füllen und vier frei erfundenen Nutzern spezifische Rechte auf bestimmte Tabellen und/oder Tabellenspalten dieser Datenbank zuweisen. Einige in diesem Tutorial einführende Shell-Commands werden dir somit bereits aus unseren oben genannten Artikeln bekannt sein, werden jedoch trotzdem gezeigt, um den Gesamtkontext für dich greifbar zu machen. Du kannst also alle Schritte bei dir am Rechner anhand dieses Tutorials nachbilden und simulieren.

Fallbeispiel

  • Feinabstimmung der Benutzerrechte
  • Es soll möglich sein Nutzerrechte nicht lediglich auf bestimmte Datenbanken zu vergeben, sondern diese sogar zum einen zu spezifizieren und in Anwendung auf den pro Kopf Nutzer zu individualisieren. Hierbei wird davon ausgegangen, dass einem bestimmten Nutzer nur auf bestimmte Tabellen oder nur auf bestimmte Spalten einer Tabelle oder mehrerer Tabellen Zugriff erlaubt wird. Im Hinblick auf Spalten wäre ein denkbares Szenario, dass ein bestimmter Nutzer in einer bestimmten Tabelle nur die Inhalte der Spalten A und B, nicht aber die der Spalte C anschauen und/oder editieren kann und lediglich ein Nutzer mit allen Rechten vollen Zugriff auf alle Tabellen und deren Inhalte hat.

Anwendungsszenario

Es wird zur Verbildlichung im Sinne eines Real-Live Case von einer Datenbank zur Systemverwaltung von Blogeinträgen ausgegangen, die nach der Implementierung die unten aufgeführten Tabellen FAVORITENLISTE, NUTZER, REDAKTEUR, CHEFREDAKTEUR, BLOGEINTRAG und FAVORISTENLISTEenthaltenBLOGEINTRAG mit Inhalten enthalten soll.

Tabellen der Datenbank Blogeinträge

Für die Vergabe von Rechten ist hierbei wichtig, dass jeder Redakteur ein Nutzer ist, aber nicht jeder Nutzer ein Redakteur und dass jeder Chefredakteur ein Redakteur ist, aber nicht jeder Redakteur ein Chefredakteur. Chefredakteure haben kompletten Zugriff auf die Datenbank Blogeinträge, sie können unter anderem Tabellen anlegen und diese sichten, editieren und löschen. Redakteure hingegen haben eingeschränkten Zugriff auf Tabellen der Datenbank. Sie dürfen keine Tabellen anlegen und haben nur für bestimmte Tabellen und/oder Tabellenspalten Rechte. Ein Redakteur hat alle Rechte an der Tabelle REDAKTEUR. In der Tabelle NUTZER darf er lediglich die in den Spalten Benutzername, EMailAdresse und FavoritenlisteID befindlichen Inhalte einsehen. Auch die Inhalte der Tabelle BLOGEINTRAGenthaltenFAVORITENLISTE darf ein Redakteur lediglich einsehen, wobei er hier Zugriff auf alle Spalten hat. In der Tabelle BLOGEINTRAG darf ein Redakteur lediglich die Inhalte der Spalten Titel, Text und Benutzername updaten, jedoch sowohl die komplette Tabelle sichten, als auch neue Einträge hinzufügen.
Als Nutzer darf man in der Tabelle NUTZER die Spalten Benutzername, EMailAdresse und FavoritenlisteID einsehen, in den Tabellen REDAKTEUR, BLOGEINTRAG und FAVORITENLISTEenthaltenBLOGEINTRAG darf man jeweils lediglich die Inhalte sichten, das bezieht sich jedoch hierbei auf alle Spalten der jeweiligen Tabelle. Für die Tabelle FAVORITENLISTE sollen NUTZER gar keine Rechte haben.

Umsetzung

Zunächst werden unter dem root-Account die vier in der Einführung dieses Tutorials genannten Nutzer mit dem CREATE USER-Command, sowie die Datenbank
Blogeinträge mit dem CREATE DATABASE-Command angelegt.

mysql -u root -p
password: *********

mysql> CREATE USER 'jens'@'localhost' IDENTIFIED BY 'passwort1';
Query OK, 0 rows affected (0,00 sec)

mysql> CREATE USER 'katrin'@'localhost' IDENTIFIED BY 'passwort2';
Query OK, 0 rows affected (0,00 sec)

mysql> CREATE USER 'natascha'@'localhost' IDENTIFIED BY 'passwort3';
Query OK, 0 rows affected (0,00 sec)

mysql> CREATE USER 'michael'@'localhost' IDENTIFIED BY 'passwort4';
Query OK, 0 rows affected (0,00 sec)

mysql> CREATE DATABASE Blogeinträge;
Query OK, 0 rows affected (0,00 sec)

Danach werden die Rechte vergeben, die ein Chefredakteur haben soll, wie ich zu Beginn des Anwendungsszenarios geschildert habe.

mysql> GRANT ALL PRIVILEGES ON Blogeinträge.* TO 'jens'@'localhost';
Query OK, 0 rows affected (0,00 sec)

In MySQL werden Berechtigungen in bestimmten Systemtabellen gespeichert, deren Werte mittels dem SELECT-Command zur Einsicht wiedergegeben werden können.
Informationen zu Nutzerberechtigungen werden in der mysql.user-Systemtabelle gespeichert. In der mysql.db-Systemtabelle sind die Werte zu Datenbankberechtigungen zu finden. Die Daten zu Tabellenberechtigungen hingegen sind in der mysql.tables_priv-Systemtabelle gespeichert und Informationen zu Spaltenberechtigungen in der mysql.columns_priv-Systemtabelle. Die Attribute der mysql.tables_priv-Systemtabelle beziehen sich auf Rechte an Tabellen einer bestimmten Datenbank – in diesem Fall die Datenbank Blogeinträge – und die Attribute der Tabelle mysql.columns_priv-Systemtabelle nehmen Bezug auf Rechte an bestimmten Spalten dieser Tabellen. Hinter den Attributen der jeweiligen Tabelle, wie Sie in der unten stehenden Tabelle aufgelistet sind, stehen Werte. Möchte man die Werte der Attribute User, Host, Db, Select_priv und Insert_priv aus der mysql.db-Systemtabelle zur Sichtung wiedergegeben haben, würde der Command SELECT user,host,db,select_priv,insert_priv FROM db dies erfüllen. Andernfalls, wenn man z.B. alle Attributwerte angezeigt bekommen möchte, würde der Command SELECT * FROM db genügen. Eine Referenz zu den in der unten stehenden Tabelle aufgelisteten Attributen, bzw. Privilegien-Parametern ist in der MySQL-Online-Dokumentation zu finden, wo erklärt wird, welche MySQL Privilegien bereitgestellt werden.

Tab. 1: Informationsstruktur – Attribute, deren Werte unter dem Command SELECT * FROM user, SELECT * FROM db, SELECT * FROM tables_priv oder SELECT * FROM columns_priv einsehbar sind.

Tabelle user

Tabelle db

Tabelle tables_priv

Tabelle columns_priv

user

db

tables_priv

columns_priv

Host

Host

Host

Host

User

Db

Db

Db

Select_priv

User

User

User

Insert_priv

Select_priv

Table_name

Table_name

Update_priv

Insert_priv

Grantor

Column_name

Delete_priv

Update_priv

Timestamp

Column_priv

Create_priv

Delete_priv

Table_priv

Timestamp

Drop_priv

Create_priv

Column_priv

 

Reload_priv

Drop_priv

   

Shutdown_priv

Grant_priv

   

Process_priv

References_priv

   

File_priv

Index_priv

   

Grant_priv

Alter_priv

   

References_priv

Create_tmp_table_priv

   

Index_priv

Lock_tables_priv

   

Alter_priv

Create_view_priv

   

Show_db_priv

Show_view_priv

   

Super_priv

Create_routine_priv

   

Create_tmp_table_priv

Alter_routine_priv

   

Lock_tables_priv

Execute_priv

   

Execute_priv

Event_priv

   

Repl_slave_priv

Trigger_priv

   

Repl_client_priv

     

Create_view_priv

     

Show_view_priv

     

Create_routine_priv

     

Alter_routine_priv

     

Create_user_priv

     

Event_priv

     

Trigger_priv

     

Create_tablespace_priv

     

ssl_type

     

ssl_cipher

     

x509_issuer

     

x509_subject

     

max_questions

     

max_updates

     

max_connections

     

max_user_connections

     

plugin

     

authentication_string

     

password_expired

     

password_last_changed

     

password_lifetime

     

account_locked

     

Im Hinblick auf das Anwendungsszenario müsstest du unter dem root-Account in die Standard-MySQL-Datenbank wechseln, um dir die Attributwerte der
mysql.user-Systemtabelle oder der mysql.db-Systemtabelle anzeigen zu lassen. Aus dem
eingeblendeten Output entnimmst du, dass der Nutzer Jens in der Datenbank z.B. für
sämtliche SELECT- und INSERT-Operationen Rechte besitzt. Besäße er sie nicht, wäre der
Attributwert nicht ‚Y‘ für ‚Yes‘, sondern ‚N‘ für ‚No‘.

mysql> USE MYSQL;

mysql> SELECT user,db,select_priv,insert_priv FROM db;
+---------------+---------------+-------------+-------------+
| user          | db            | select_priv | insert_priv |
+---------------+---------------+-------------+-------------+
| jens          | Blogeinträge  | Y           | Y           |
+---------------+---------------+-------------+-------------+
1 row in set (0,00 sec)

Tabellen in MySQL anlegen und Attributwerte validieren

Da der Nutzer Jens als Chefredakteur alle Rechte an der Datenbank Blogeinträge hat, können unter seinem Account Tabellen angelegt werden. Hierzu loggst du dich zunächst mit seinen Benutzerdaten ein und wechselst mittels dem USE-Command in die Datenbank Blogeinträge.

mysql -u jens -p
password: *********

mysql> USE Blogeinträge;
Database changed

Im Anschluss daran kannst du als Chefredakteur mit dem CREATE TABLE-Command Tabellen zur Datenbank hinzufügen. Die Syntax des CREATE TABLE-Command sieht vor, dass in der Klammerung, die nach CREATE TABLE folgt, die jeweiligen Attribute (Spalten) der Tabelle gelistet sind. Hinter jedem Attribut steht der Datentyp. IDs z.B. lassen sich gut als ganzzahlige Werte abbilden, was einem INTEGER entspricht. Nach der Definition des Datentyps folgt die Definition, die klar stellt, ob es sich um einen Primärschlüssel oder einen Fremdschlüssel handelt oder der Wert hinter dem Datentypen einfach nicht null sein darf. Im Anschluss daran kann ein CHECK erfolgen, muss aber nicht. Mittels dem CHECK kannst du eine Bedingung definieren, die bei jedem neuen Eintrag in die betreffende Spalte prüft, ob der Eintrag valide ist. Zur Verdeutlichung dient z.B. der CHECK in der Tabelle NUTZER für die Spalte Geschlecht. Hier ist der Datentyp als Character der Länge 1 definiert und darf nicht null sein, was bedeutet, dass für jeden Eintrag in dieser Spalte ein Wert stehen muss. Letztlich folgt der CHECK, in dem geprüft wird, ob die durch INSERT– oder UPDATE-Operation hinzugefügte Zeichenkette der Länge 1 den Wert ‘w’ oder ‘m’ hat. Bei der Festlegung des Fremdschlüssels ist hingegen REFERENCES wichtig. Erneut nehme ich Bezug auf die Tabelle NUTZER. Als letztes Attribut dieser Tabelle steht die FavoritenlisteID. Zunächst wird sie, wie alle anderen Attribute, nach der vorgestellten Syntax deklariert. Im Nachgang daran wird über REFERENCES zusätzlich zur erfolgten Deklaration die Referenz des Fremdschlüssels FavoritenlisteID hergestellt, was bedeutet, dass eindeutig gemacht wird, aus welcher Tabelle der Fremdschlüssel FavoritenlisteID kommt, also in welcher Tabelle er selber Primärschlüssel ist. Und dies wiederum ist die Tabelle FAVORITENLISTE, die vor der Tabelle NUTZER via CREATE TABLE-Command erstellt wurde. In diesem Zusammenhang solltest du generell immer die Reihenfolge berücksichtigen, in der du Tabellen anlegst. Tabellen, deren Primärschlüssel in anderen Tabellen Fremdschlüssel ist, sollten immer vor diesen zweitgenannten Tabellen angelegt werden. In der MySQL-Dokumentation kannst du weiterführende Informationen zur CREATE TABLE-Syntax nachlesen.

mysql> CREATE TABLE FAVORITENLISTE(
FavoritenlisteID INT PRIMARY KEY CHECK(FavoritenlisteID > 0));
Query OK, 0 rows affected (0,04 sec)

mysql> CREATE TABLE NUTZER(
Benutzername VARCHAR(50) PRIMARY KEY CHECK(LENGTH(Benutzername) > 0), 
EMailAdresse VARCHAR(50) NOT NULL CHECK(EMailAdresse LIKE '%@%.de' OR EMailAdresse LIKE '%@%.com'), 
Geschlecht CHAR(1) NOT NULL CHECK(Geschlecht IN ('w', 'm')), 
Geburtsdatum DATE NOT NULL, 
Passwort VARCHAR(10) NOT NULL CHECK(LENGTH(Passwort) > 0), 
FavoritenlisteID INT NOT NULL CHECK(FavoritenlisteID > 0), 
FOREIGN KEY(FavoritenlisteID) REFERENCES FAVORITENLISTE(FavoritenlisteID));
Query OK, 0 rows affected (0,06 sec)

mysql> CREATE TABLE REDAKTEUR(
Benutzername VARCHAR(50) PRIMARY KEY CHECK(LENGTH(Benutzername) > 0), 
Vorname VARCHAR(50) NOT NULL CHECK(LENGTH(Vorname) > 0), 
Name VARCHAR(50) NOT NULL CHECK(LENGTH(Name) > 0), 
Vorstellungstext TEXT CHECK(LENGTH(Vorstellungstext)  CREATE TABLE CHEFREDAKTEUR(
Benutzername VARCHAR(50) PRIMARY KEY CHECK(LENGTH(Benutzername) > 0), 
Telefonnummer VARCHAR(20) NOT NULL CHECK(LENGTH(Telefonnummer) > 0), 
FOREIGN KEY(Benutzername) REFERENCES REDAKTEUR(Benutzername));
Query OK, 0 rows affected (0,06 sec)

mysql> CREATE TABLE BLOGEINTRAG(
BlogeintragID INT PRIMARY KEY CHECK(BlogeintragID > 0), 
Erstellungsdatum DATE NOT NULL, 
Änderungsdatum DATE CHECK(Änderungsdatum >= Erstellungsdatum), 
Titel VARCHAR(250) NOT NULL CHECK(LENGTH(Titel) > 0), 
Text TEXT CHECK(LENGTH(Text)  0), 
FOREIGN KEY(Benutzername) REFERENCES REDAKTEUR(Benutzername));
Query OK, 0 rows affected (0,08 sec)

mysql> CREATE TABLE FAVORITENLISTEenthaltenBLOGEINTRAG(
BlogeintragID INT NOT NULL CHECK(BlogeintragID > 0), 
FavoritenlisteID INT NOT NULL CHECK(FavoritenlisteID > 0), 
PRIMARY KEY(BlogeintragID, FavoritenlisteID), 
FOREIGN KEY(BlogeintragID) REFERENCES BLOGEINTRAG(BlogeintragID), 
FOREIGN KEY(FavoritenlisteID) REFERENCES FAVORITENLISTE(FavoritenlisteID));
Query OK, 0 rows affected (0,05 sec)

Mittels dem SHOW TABLES-Command kannst du dir im Anschluss daran, angemeldet als Nutzer Jens, nun die in der Datenbank Blogeinträge befindlichen Tabellen ansehen. Es werden alle Tabellen angezeigt, da der Nutzer Jens als Chefredakteur alle Rechte an allen Tabellen hat.

mysql> SHOW TABLES;
+------------------------------------+
| Tables_in_Blogeinträge             |
+------------------------------------+
| BLOGEINTRAG                        |
| FAVORITENLISTEenthaltenBLOGEINTRAG |
| CHEFREDAKTEUR                      |
| FAVORITENLISTE                     |
| NUTZER                             |
| REDAKTEUR                          |
+------------------------------------+
6 rows in set (0,00 sec)

Rechte in MySQL pro Tabelle und/oder Spalte definieren

Nachdem die Datenbank Tabellen enthält, kannst du die jeweiligen Nutzerrechte pro Tabelle und /oder pro Spalte definieren. Beginnen wir mit dem Nutzer Katrin, welcher die Rechte eines Redakteurs haben soll. Wenn du dich unter dem Account von Katrin einloggst und in die Datenbank Blogeinträge wechseln willst, bekommst du die im unteren Codeblock eingeblendete Fehlermeldung, die dich darauf aufmerksam macht, dass dir die Rechte auf die Datenbank Blogeinträge fehlen.

mysql -u katrin -p
password: *********

mysql> USE Blogeinträge;
ERROR 1044 (42000): Access denied for user 'katrin'@'localhost' to database 'Blogeinträge'

Um dem Nutzer Katrin spezifische Rechte an bestimmten Tabellen und/oder Spalten der Datenbank Blogeinträge zu gewähren, müssen diese zunächst – wie die allgemeinen Rechte, die Jens als Chefredakteur hat – definiert werden. Nur sind die Rechte des Redakteurs eben eingeschränkt. Zunächst musst du dich wieder unter dem Root-Account in MySQL einloggen.

mysql -u root -p
password: *********

Aus der Einleitung zum Anwendungsszenario weißt du, dass ein Redakteur alle Rechte an der Tabelle REDAKTEUR hat. Der GRANT-Command ist dir bereits aus dem in der Einleitung dieses Tutorials erwähnten Artikel Wie erstelle ich einen MySQL Benutzer und weise ihm Rechte zu? bekannt und wird bei der Spezifizierung von Tabellenrechten ebenso genutzt, wie bei der allgemeinen Rechtevergabe, wie ich sie bereits für den Chefredakteur Jens zu Beginn des Anwendungsszenarios umgesetzt habe. Jedoch wird der GRANT-Command nun detaillierter. Um festzulegen, dass Katrin alle Rechte an der Tabelle REDAKTEUR hat, wird nicht der bisher geläufige Command im Sinne von

mysql> GRANT ALL PRIVILEGES ON Blogeinträge.* TO 'katrin'@'localhost';
Query OK, 0 rows affected (0,00 sec)

genutzt, sondern er wird genauer formuliert, nämlich als

mysql> GRANT ALL PRIVILEGES ON Blogeinträge.REDAKTEUR TO 'katrin'@'localhost';
Query OK, 0 rows affected (0,00 sec)

Hierbei wird nicht nur die Datenbank angetriggert, sondern die hinter der Datenbank stehende Tabelle REDAKTEUR. Wenn du die Rechte noch weiter spezifizieren willst, also nicht lediglich auf bestimmte Tabellen einschränken willst, sondern sogar auf Spalten, sieht der GRANT-Command wieder etwas anders aus. Dann wird nämlich für jede Art von Zugriff bzw. Operation definiert, auf welche Spalten einer bestimmten Tabelle der betreffende Nutzer diese Operation ausüben darf. Hierzu wird in der Syntax der Name der betreffenden Operation, gefolgt von dem in Klammern gesetzten Bestandteil vor dem ON TABELLE.SPALTE des Commands deklariert. Wie dies in der Kommandozeile realisiert wird, siehst du in den folgenden Shell-Snippets, in denen die weiteren Rechtevergaben für den Nutzer Katrin stattfinden, wie sie in der Einleitung zum Anwendungsszenario erläutert worden sind. Dort wird für Katrin als erstes die SELECT-Operation auf die Spalten Benutzername, EMailAdresse und FavoritenlisteID der Tabelle NUTZER gewährt.

mysql> GRANT SELECT (Benutzername, EMailAdresse, FavoritenlisteID) ON Blogeinträge.NUTZER TO 'katrin'@'localhost';
Query OK, 0 rows affected (0,00 sec)

Des Weiteren wird im nächsten GRANT-Befehl Katrin das Recht an der SELECT-Operation auf die komplette Tabelle FAVORITENLISTEenthaltenBLOGEINTRAG zugewiesen.

mysql> GRANT SELECT ON Blogeinträge.FAVORITENLISTEenthaltenBLOGEINTRAG TO 'katrin'@'localhost';
Query OK, 0 rows affected (0,00 sec)

Im Anschluss daran erfolgt eine weitere GRANT-Anweisung, laut der Katrin als Redakteur sowohl die SELECT-, als auch die UPDATE– und DELETE-Operation auf die Spalten Titel, Text und Benutzername der Tabelle BLOGEINTRAG vornehmen darf.

mysql> GRANT SELECT, INSERT, UPDATE (Titel, Text, Benutzername) ON Blogeinträge.BLOGEINTRAG TO 'katrin'@'localhost';
Query OK, 0 rows affected (0,00 sec)

In den folgenden Shell-Snippets zeige ich dir noch, wie du die Rechte im Fall des Nutzers Natascha so umsetzen würdest, wie ich es zu Beginn des Anwendungsszenarios geschildert habe. Da sich Natascha und Michael jeweils in der Rolle des Nutzers rechtlich auf derselben Ebene befinden, solltest du bei der Nachbildung dieses Leitfadens die auf den Nutzer Natascha gesetzten Rechte im Nachgang ebenso auf den Nutzer Michael festlegen, um dieselben Outputs zu erzielen, wie ich sie im folgenden Teil des Tutorials präsentieren werde.

mysql> GRANT SELECT (Benutzername, EMailAdresse, FavoritenlisteID) ON Blogeinträge.NUTZER TO 'natascha'@'localhost';
Query OK, 0 rows affected (0,00 sec)

mysql> GRANT SELECT ON Blogeinträge.REDAKTEUR TO 'natascha'@'localhost';
Query OK, 0 rows affected (0,00 sec)

mysql> GRANT SELECT ON Blogeinträge.BLOGEINTRAG TO 'natascha'@'localhost';
Query OK, 0 rows affected (0,00 sec)

mysql> GRANT ALL PRIVILEGES ON Blogeinträge.FAVORITENLISTEenthaltenBLOGEINTRAG TO 'natascha'@'localhost';
Query OK, 0 rows affected (0,00 sec)

Nachdem du die Rechte pro Nutzer individuell festgelegt hast, kannst du dir den Gesamtkontext der Rechtevergabe, so wie er durch dich implementiert wurde, via SELECT-Statement ausgeben lassen. Hierzu musst du aber zunächst die Datenbank wechseln, da du dich noch in der Datenbank Blogeinträge befindest. Also wechselst du mittels dem USE-Command in die MySQL-Datenbank.

mysql> USE mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Über die Ausführung des folgenden Kommandos kannst du dir die Attributwerte der tables_priv-Systemtabelle ausgeben lassen. Hieraus lassen sich die Tabellenrechte in Relation zu den Spaltenrechten ablesen. Angewandt auf die erste Zeile würdest du daraus verstehen, dass dem Redakteur Katrin auf Tabellenebene für die Tabelle BLOGEINTRAG sowohl die SELECT– als auch die INSERT-Operation erlaubt sind. Im Hinblick auf die Spaltenebene ist hingegen lediglich die UPDATE-Operation zulässig.

mysql> SELECT * from tables_priv;
+-----------+---------------+---------------+------------------------------------+----------------------+---------------------+----------------------------------------------------------------------------------------------+-------------+
| Host      | Db            | User          | Table_name                         | Grantor              | Timestamp           | Table_priv                                                                                   | Column_priv |
+-----------+---------------+---------------+------------------------------------+----------------------+---------------------+----------------------------------------------------------------------------------------------+-------------+
| localhost | Blogeinträge  | katrin        | BLOGEINTRAG                        | [email protected]       | 0000-00-00 00:00:00 | Select,Insert                                                                                | Update      |
| localhost | Blogeinträge  | katrin        | FAVORITENLISTEenthaltenBLOGEINTRAG | [email protected]       | 0000-00-00 00:00:00 | Select                                                                                       |             |
| localhost | Blogeinträge  | michael       | NUTZER                             | [email protected]       | 0000-00-00 00:00:00 |                                                                                              | Select      |
| localhost | Blogeinträge  | natascha      | FAVORITENLISTEenthaltenBLOGEINTRAG | [email protected]       | 0000-00-00 00:00:00 | Select                                                                                       |             |
| localhost | Blogeinträge  | natascha      | BLOGEINTRAG                        | [email protected]       | 0000-00-00 00:00:00 | Select                                                                                       |             |
| localhost | Blogeinträge  | katrin        | NUTZER                             | [email protected]       | 0000-00-00 00:00:00 |                                                                                              | Select      |
| localhost | Blogeinträge  | katrin        | REDAKTEUR                          | [email protected]       | 0000-00-00 00:00:00 | Select,Insert,Update,Delete,Create,Drop,References,Index,Alter,Create View,Show view,Trigger |             |
| localhost | Blogeinträge  | natascha      | REDAKTEUR                          | [email protected]       | 0000-00-00 00:00:00 | Select                                                                                       |             |
| localhost | Blogeinträge  | natascha      | NUTZER                             | [email protected]       | 0000-00-00 00:00:00 |                                                                                              | Select      |
| localhost | Blogeinträge  | michael       | FAVORITENLISTEenthaltenBLOGEINTRAG | [email protected]       | 0000-00-00 00:00:00 | Select                                                                                       |             |
| localhost | Blogeinträge  | michael       | BLOGEINTRAG                        | [email protected]       | 0000-00-00 00:00:00 | Select                                                                                       |             |
| localhost | Blogeinträge  | michael       | REDAKTEUR                          | [email protected]       | 0000-00-00 00:00:00 | Select                                                                                       |             |
+-----------+---------------+---------------+------------------------------------+----------------------+---------------------+----------------------------------------------------------------------------------------------+-------------+
12 rows in set (0,01 sec)

Und über die Ausführung des darauffolgenden Kommandos kannst du dir die Attributwerte der columns_priv-Systemtabelle ausgeben lassen. Hierbei erkennst du dann weiter verfeinert, dass Katrin nach der Implementierung der Rechte in der Tabelle BLOGEINTRAG lediglich auf die Spalten Benutzername, Text und Titel die UPDATE-Operation ausführen darf, was letztlich das wiedergibt, was vorgesehen ist: nämlich dass die UPDATE-Operation für die restlichen Spalten der Tabelle (nämlich für die Spalten BlogeintragID, Erstellungsdatum und Änderungsdatum) für Katrin nicht erlaubt sein soll, sondern lediglich die SELECT– und die INSERT-Operation.

mysql> SELECT * from columns_priv;
+-----------+---------------+----------+-------------+------------------+---------------------+-------------+
| Host      | Db            | User     | Table_name  | Column_name      | Timestamp           | Column_priv |
+-----------+---------------+----------+-------------+------------------+---------------------+-------------+
| localhost | Blogeinträge  | katrin   | BLOGEINTRAG | Benutzername     | 0000-00-00 00:00:00 | Update      |
| localhost | Blogeinträge  | katrin   | BLOGEINTRAG | Text             | 0000-00-00 00:00:00 | Update      |
| localhost | Blogeinträge  | katrin   | BLOGEINTRAG | Titel            | 0000-00-00 00:00:00 | Update      |
| localhost | Blogeinträge  | katrin   | NUTZER      | FavoritenlisteID | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | katrin   | NUTZER      | EMailAdresse     | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | katrin   | NUTZER      | Benutzername     | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | natascha | NUTZER      | FavoritenlisteID | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | natascha | NUTZER      | EMailAdresse     | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | natascha | NUTZER      | Benutzername     | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | michael  | NUTZER      | FavoritenlisteID | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | michael  | NUTZER      | EMailAdresse     | 0000-00-00 00:00:00 | Select      |
| localhost | Blogeinträge  | michael  | NUTZER      | Benutzername     | 0000-00-00 00:00:00 | Select      |
+-----------+---------------+----------+-------------+------------------+---------------------+-------------+
12 rows in set (0,00 sec)

In den folgenden drei Shell-Snippets zeige ich dir, wie du dir ausgehend vom jeweiligen Benutzer-Account anzeigen lassen kannst, auf welche Tabellen der betreffende Nutzer Zugriff hat. Hierzu wird wieder der SHOW TABLES-Command genutzt, den ich schon unter dem Account von Jens verwendet habe, um mir seinen Zugriff auf alle Tabellen ausgeben zu lassen.

mysql -u katrin -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

mysql> SHOW TABLES;
+------------------------------------+
| Tables_in_Blogeinträge             |
+------------------------------------+
| BLOGEINTRAG                        |
| FAVORITENLISTEenthaltenBLOGEINTRAG |
| NUTZER                             |
| REDAKTEUR                          |
+------------------------------------+
4 rows in set (0,00 sec)
mysql -u natascha -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

mysql> SHOW TABLES;
+------------------------------------+
| Tables_in_Blogeinträge             |
+------------------------------------+
| BLOGEINTRAG                        |
| FAVORITENLISTEenthaltenBLOGEINTRAG |
| FAVORITENLISTE                     |
| NUTZER                             |
| REDAKTEUR                          |
+------------------------------------+
5 rows in set (0,00 sec)
mysql -u michael -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

mysql> SHOW TABLES;
+------------------------------------+
| Tables_in_Blogeinträge             |
+------------------------------------+
| BLOGEINTRAG                        |
| FAVORITENLISTEenthaltenBLOGEINTRAG |
| FAVORITENLISTE                     |
| NUTZER                             |
| REDAKTEUR                          |
+------------------------------------+
5 rows in set (0,00 sec)

Tabellen nach Inhalten durchsuchen, mit Inhalten befüllen, updaten und löschen

Als nächstes werde ich dir zeigen, wie du die bisher implementierten Tabellen mit Inhalten befüllst oder bereits bestehende Inhalte updatest oder löscht. Wie du weißt, kann lediglich der Chefredakteur Jens Inhalte in allen Tabellen via INSERT-Operation einfügen und lediglich der Redakteur Katrin kann in der Tabelle BLOGEINTRAG die INSERT-Operation durchführen. Zunächst wechselst du in den Account des Chefredakteurs Jens.

mysql -u jens -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Dann befüllst du die Tabellen FAVORITENLISTE und NUTZER mit Inhalten. Die hierzu notwendige INSERT-Operation hat die Syntax, in der der Command INSERT INTO gefolgt wird von dem Datenbanknamen getrennt durch einen Punkt vom Tabellennamen. Hier kann allerdings auch lediglich der Tabellenname stehen. Also anstatt INSERT INTO Blogeinträge.FAVORITENLISTE könnte im ersten INSERT-Beispiel unten auch einfach nur INSERT INTO FAVORITENLISTE stehen, da du dich bereits in der Datenbank Blogeinträge befindest. Darauf folgt im Command VALUES, wo die zu befüllenden Attributwerte in Klammerung gelistet eingetragen werden. Hierbei ist es wichtig, auf die Reihenfolge der einzutragenden Attributwerte zu achten: diese muss der Reihenfolge entsprechen, in der die Spalten in einer Tabelle aufeinander folgen.

mysql> INSERT INTO Blogeinträge.FAVORITENLISTE VALUES(1001);
Query OK, 1 row affected (0,03 sec)

mysql> INSERT INTO Blogeinträge.FAVORITENLISTE VALUES(1002);
Query OK, 1 row affected (0,03 sec)

mysql> INSERT INTO Blogeinträge.FAVORITENLISTE VALUES(1003);
Query OK, 1 row affected (0,00 sec)

mysql> INSERT INTO Blogeinträge.FAVORITENLISTE VALUES(1004);
Query OK, 1 row affected (0,01 sec)

mysql> INSERT INTO Blogeinträge.NUTZER VALUES('jens', '[email protected]', 'm', '1984-05-30', 'ferrari', 1001);
Query OK, 1 row affected (0,04 sec)

mysql> INSERT INTO Blogeinträge.NUTZER VALUES('katrin', 'k[email protected]', 'w', '1990-01-16', 'darkeyes', 1002);
Query OK, 1 row affected (0,03 sec)

mysql> INSERT INTO Blogeinträge.NUTZER VALUES('natascha', '[email protected]', 'w', '1987-08-22', 'starwish', 1003);
Query OK, 1 row affected (0,01 sec)

mysql> INSERT INTO Blogeinträge.NUTZER VALUES('michael', '[email protected]', 'm', '1989-03-14', 'infotech', 1004);
Query OK, 1 row affected (0,00 sec)

Um dir zu zeigen, dass Katrin fähig ist, die Tabelle BLOGEINTRAG mit Inhalten zu füllen, werde ich die hierzu notwendige Operation von ihrem Account aus ausführen, jedoch wäre Jens als Chefredakteur hierzu natürlich auch in der Lage.

mysql -u katrin -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

mysql> INSERT INTO Blogeinträge.REDAKTEUR VALUES('katrin', 'Katrin', 'Loos', 'Hi, mein Name ist Katrin und ich bin seit ...');
Query OK, 1 row affected (0,01 sec)

mysql> INSERT INTO Blogeinträge.REDAKTEUR VALUES('jens', 'Jens', 'Müller', 'Hey, ich freue mich auf dieser Plattform als ...');
Query OK, 1 row affected (0,03 sec)

Für die Befüllung mit Inhalten der Tabellen CHEFREDAKTEUR, BLOGEINTRAG und FAVORITENLISTEenthaltenBLOGEINTRAG wechsele ich wieder in den Account von Jens, da Katrin – wie bereits bekannt – für das Hinzufügen von Inhalten in Tabellen bis auf die Tabelle BLOGEINTRAG die Rechte fehlen.

mysql -u jens -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

mysql> INSERT INTO Blogeinträge.CHEFREDAKTEUR VALUES('jens', '+49 178 3339990');
Query OK, 1 row affected (0,01 sec)

mysql> INSERT INTO Blogeinträge.BLOGEINTRAG VALUES(2001, '2018-02-20', NULL, 'Test-Headline', 'In diesem Blogeintrag möchte ich Euch zeigen ...', 'katrin');
Query OK, 1 row affected (0,01 sec)

mysql> INSERT INTO Blogeinträge.BLOGEINTRAG VALUES(2002, '2018-02-20', '2018-02-24', 'Test-Headline', 'Heute werde ich über ...', 'jens');
Query OK, 1 row affected (0,03 sec)

mysql> INSERT INTO Blogeinträge.FAVORITENLISTEenthaltenBLOGEINTRAG VALUES(2001, 1003);
Query OK, 1 row affected (0,03 sec)

mysql> INSERT INTO Blogeinträge.FAVORITENLISTEenthaltenBLOGEINTRAG VALUES(2001, 1004);
Query OK, 1 row affected (0,01 sec)

mysql> INSERT INTO Blogeinträge.FAVORITENLISTEenthaltenBLOGEINTRAG VALUES(2002, 1002);
Query OK, 1 row affected (0,03 sec)

Nachdem du nun alle Tabellen mit Inhalten befüllt hast, sehen sie so aus, wie ich dir zu Beginn des Anwendungsszenarios gezeigt habe. Zum Ende dieses Tutorials möchte ich dir nun noch jeweils ein Beispiel für eine SELECT-, sowie eine UPDATE– und eine DELETE-Operation zeigen. Das Beispiel für die SELECT-Operation zeige ich dir ausgehend von den Benutzerrechten, die Natascha als Nutzer hat und die ebenso auf ein Beispiel von Michaels Account aus anwendbar wären. Das jeweilige Beispiel für die UPDATE– und DELETE-Operation zeige ich dir ausgehend von den Rechten, die Katrin als Redakteur besitzt. Zunächst loggst du dich unter Nataschas Account in MySQL ein und wechselst mit dem USE-Command in die Datenbank Blogeinträge.

mysql -u natascha -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Wenn du nun versuchst, die Einträge zum Benutzernamen und dem dazugehörigen Geburtsdatum aus der Tabelle NUTZER zu selektieren, wird dir eine Fehlermeldung ausgegeben, in der du darauf hingewiesen wirst, dass die Spalte Geburtsdatum nicht erkannt wird, wie du im unteren Beispiel erkennst.

SELECT Benutzername, Geburtsdatum FROM REDAKTEUR;
ERROR 1054 (42S22): Unknown column 'Geburtsdatum' in 'field list'

Selektierst du hingegen die Spalteninhalte zu den Spalten Benutzername, EMailAdresse und FavoritenlisteID aus der Tabelle NUTZER, erhältst du entsprechenden Output, wie er im Beispiel darunter zu sehen ist.

SELECT Benutzername, EMailAdresse, FavoritenlisteID FROM NUTZER;
+--------------+---------------------------------+------------------+
| Benutzername | EMailAdresse                    | FavoritenlisteID |
+--------------+---------------------------------+------------------+
| jens         | [email protected]      |             1001 |
| katrin       | [email protected]      |             1002 |
| michael      | [email protected] |             1004 |
| natascha     | [email protected]               |             1003 |
+--------------+---------------------------------+------------------+
4 rows in set (0,00 sec)

Möchtest du dir als Nutzer Natascha lediglich Informationen anzeigen lassen, die dich selber betreffen, dann schränke das SELECT-Statement mit der WHERE-Bedingung ein, indem du z.B. die Bedingung anhand des Benutzernamens setzen kannst und somit die Treffermenge einschränkst, wie ich es dir im Beispiel unten verdeutliche.

SELECT Benutzername, EMailAdresse, FavoritenlisteID FROM NUTZER;
+--------------+---------------------------------+------------------+
| Benutzername | EMailAdresse                    | FavoritenlisteID |
+--------------+---------------------------------+------------------+
| natascha     | [email protected]               |             1003 |
+--------------+---------------------------------+------------------+
4 rows in set (0,00 sec)

Um nun das jeweilige Beispiel zur UPDATE– und DELETE-Operation unter Katrins Rechten nachzuvollziehen, loggst du dich unter ihrem Account ein und wechselst wieder in die Datenbank Blogeinträge.

mysql -u katrin -p
password: *********

mysql> USE Blogeinträge;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Die Syntax der UPDATE-Operation setzt voraus, dass nach dem UPDATE der Name der Tabelle gesetzt werden muss oder der Name der Tabelle gefolgt von einem Punkt und der betreffenden Spalte. Dann wird mittels SET der neue Wert gesetzt und die bekannte WHERE-Bedingung dient auch bei dieser Operation zur Einschränkung der Treffermenge. Sollen mehr als ein Wert neu gesetzt werden, kann dies über die booleschen Operatoren AND oder OR erfolgen. Wenn du hier nun versuchst das Änderungsdatum zu ändern, wird dir die Fehlermeldung ausgegeben, die dich darüber in Kenntnis setzt, dass du keinen Zugriff auf das Ändern von Werten in der Spalte Änderungsdatum besitzt, wie du dem Beispiel unten entnimmst.

UPDATE BLOGEINTRAG SET Änderungsdatum = '2018-04-01' WHERE Titel = 'Test-Headline' AND Benutzername = 'katrin';
ERROR 1143 (42000): UPDATE command denied to user 'katrin'@'localhost' for column 'Änderungsdatum' in table 'BLOGEINTRAG'

Wenn du hingegen den Titel eines bestimmten Blogeintrags änderst, wie im Beispiel unten, wird der UPDATE-Command durchgeführt, weil der Redakteur eben UPDATE-Rechte an der Spalte Titel der Tabelle BLOGEINTRAG hat. Hättest du im Beispiel unten ohne WHERE-Bedingung gearbeitet, würde der Titel in allen Zeilen der Tabelle in ‘Hallo Welt!’ geändert werden.

UPDATE BLOGEINTRAG Titel SET Titel = 'Hallo Welt!' WHERE Titel = 'Test-Headline' AND Benutzername = 'katrin';
Query OK, 1 row affected (0,03 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Das Ergebnis deiner UPDATE-Operation kannst du dir im Nachgang via SELECT-Operation ausgeben lassen, wie ich es dir z.B. unten zeige.

SELECT Titel FROM BLOGEINTRAG WHERE Benutzername = 'katrin';
+-------------+
| Titel       |
+-------------+
| Hallo Welt! |
+-------------+
1 row in set (0,01 sec)

Im letzten Beispiel, in dem ich mit dir eine DELETE-Operation durchführe, gehen wir davon aus, dass in der Tabelle REDAKTEUR zwischenzeitlich ein neuer Redakteur hinzugefügt wurde, nämlich der Redakteur mit dem Benutzernamen Sabine, wie in der Tabelle unten aufgeführt ist. Dieser neu hinzugefügte Redakteur soll nun aber wieder aus der Tabelle REDAKTEUR entfernt werden, weil Frau Stein nunmehr doch nicht mehr in dem betreffenden Blogsystem als Redakteur tätig sein möchte. Frau Stein könnte als Redakteur die Löschung auch selber durchführen, aber in meinem Beispiel lasse ich dies Katrin tun.

Tabelle REDAKTEUR in Datenbank Blogeinträge

Die Syntax der DELETE-Operation sieht vor, dass nach dem DELETE FROM die betreffende Tabelle angetriggert wird und mit der WHERE-Bedingung hier – anders als wie im Fall der SELECT– oder UPDATE-Operation – die WHERE-Bedingung essentiell ist und nicht lediglich zur Wahl steht, um die Treffermenge einzuschränken.

mysql> DELETE FROM REDAKTEUR WHERE Benutzername = 'sabine';
Query OK, 1 row affected (0,03 sec)

Auch in diesem Beispiel lassen wir uns zur Prüfung das Ergebnis der DELETE-Operation ausgeben, indem wir uns alle Benutzernamen anzeigen lassen, die sich nun noch in der Tabelle REDAKTEUR befinden, wie du im Beispiel darunter siehst.

mysql> SELECT Benutzername FROM REDAKTEUR;
+--------------+
| Benutzername |
+--------------+
| jens         |
| katrin       |
+--------------+
2 rows in set (0,00 sec)

Wie dir aus der Beschreibung des Anwendungsszenarios bekannt ist, ist jeder Redakteur zwangsläufig auch ein Nutzer. Wenn Frau Stein also komplett aus der Datenbank entfernt werden soll, dann müsste final eine DELETE-Operation in der Tabelle NUTZER hierzu stattfinden, was du in der Rolle, bzw. unter dem Account des Chefredakteurs Jens umsetzen kannst, um die Tabelle NUTZER in dem Zustand zu haben, wie im Bild zu Beginn des Anwendungsszenarios gezeigt.

Fazit

Nachdem wir nun zusammen eine Datenbank erstellt, aufgebaut und Rechte pro Nutzer individuell zugeteilt haben, hast du ein Gefühl dafür bekommen, wie flexibel und steuerbar die Vergabe von Rechten in MySQL ist und bist in der Lage, die Rechte pro Nutzer in bestimmten Datenbanken fein abzustimmen und somit einen gewissen Grad an Datenkontrolle zu gewährleisten. Mir hat es Freude gemacht, dich durch das Anwendungsszenario zu führen und ich wünsche dir viel Spaß bei der Umsetzung der gelernten Inhalte.

Zurück zur Tutorial Übersicht Back to Tutorial Overview

rsync Tutorial

rsync Tutorial

Wie synchronisiere ich meinen Server mit rsync?

Rsync ist ein super praktisches kleines Tool für die Datensynchronisation unter Linux. Wenn du rsync noch nicht kennst, solltest du dir dieses vielseitige Tool definitiv einmal anschauen, es ist nämlich schon ein richtiger Klassiker in der Linux-Welt.

Mit rsync kannst du Daten via SSH Protocol zwischen zwei Servern über das Netzwerk synchronisieren. Es eignet sich perfekt als Tool für geplante Backups, Mirroring oder einfach um Daten zwischen zwei Servern zu übertragen. Wir zeigen dir in diesem Tutorial die Basics im Umgang mit rsync. Du lernst unter anderem, wie man sicher Daten via SSH zwischen zwei Servern mit rsync kopiert und synchronisiert. Zudem zeigen wir dir später im Artikel, wie du einen rsync-Deamon einrichtest – der Deamon benutzt ein eigenes Protokoll und läuft auf einem spezifischen Port. Mithilfe des Deamon kannst du Verzeichnisse auf deinem Server für andere oder dich selbst zum Download und Upload verfügbar machen.

Vorbereitungen

Als Voraussetzung, um dem kompletten Tutorial folgen zu können, benötigst du zwei Linux Server, auf denen rsync installiert ist. Ich habe für das Tutorial in wenigen Klicks zwei Ubuntu Server in meinem Tech4Hosting-Panel erstellt. Zudem musst du für einen sicheren Datentransport sicherstellen, dass deine zwei Hosts sich via SSH Key-Based Authentication verbinden können.

Den lokalen Beispielen in diesem Tutorial kannst du auch mit nur einem Linux Host folgen (s. rsync als cp Alternative).

Installation

Unter Ubuntu ist rsync standardmäßig installiert. Sollte es bei dir aus irgendeinem Grund fehlen, kannst du es mit folgendem Befehl installieren:

apt-get install rsync

Auf RHEL / CentOS / Fedora:

yum install rsync


rsync als cp Alternative

Obwohl rsync eigentlich dafür gedacht ist, Dateien zwischen zwei Hosts zu übertragen, kannst du es auch lokal als erweiterte Alternative des cp Kommandos einsetzen. Hier eignet es sich besonders für das Kopieren von größeren Dateien.

Die Syntax zum kopieren von Dateien auf lokaler Ebene mit rsync sieht folgendermaßen aus:

rsync -P [quelle] [Zielpfad]

Bspw. um eine Bilddatei in ein anderes Verzeichnis zu kopieren:

rsync -P /opt/flowy/new.jpg /home/data/

Mit dem Flag -P oder wahlweise –progress werden die Details zu deinem Kopiervorgang angezeigt. Das kann sinnvoll sein, wenn du besonders große Dateien kopierst und du den Vorgang generell überwachen möchtest.

Ganze Verzeichnisse kopieren

Mit der –recursive oder kurz -r Option kannst du ein ganzes Verzeichnis inklusive Dateien und Unterverzeichnissen kopieren.

rsync --recursive [quelle] [Zielpfad]


Weitere rsync Beispiele

Du kannst deine Copy Optionen auch weiter spezifizieren. Hier ein Beispiel, wie du ausschließlich Dateien aus einem Ordner kopierst, die maximal 2 Kilobytes groß sind:

rsync -r --max-size=2k [quelle] [Zielpfad]

Ein weiteres Beispiel mit einer min Angabe der Dateigröße:

rsync -r --min-size=100mb [quelle] [Zielpfad]

Mit diesem Befehl kopierst du nur Dateien, die mindestens 100MB groß sind in dein Zielverzeichnis.

Du kannst auch Dateien mit einer bestimmten Endung von deinem Kopiervorgang ausschließen, bspw. alle Dateien, die mit .jpg enden.

Mit diesem Befehl kopierst du den kompletten Inhalt des Quellverzeichnisses in dein Zielverzeichnis, jedoch werden alle jpg-Files im Quellverzeichnis von diesem Vorgang ausgeschlossen.

rsync -r --exclude="*.jpg" [quelle] [Zielpfad]


Dateien zwischen zwei Servern übertragen

Mit rsync kannst du auf zwei verschiedene Arten Daten zwischen zwei Hosts übertragen bzw. synchronisieren. Zum einen via Pull und zum anderen via Push. Die Syntax der beiden Befehle ist leicht unterschiedlich – welchen Befehl du anwenden musst, um deine Daten zu transportieren, entscheidet sich je nachdem, auf welchem der beiden Hosts du dich befindest.

Wenn du deine Quelle zuerst definierst, wird ein Push initiiert.

rsync [optionen] [Quelle] [email protected]:[Zielpfad]

Definierst du deinen Remote-Host zuerst, also “[email protected]” gefolgt von der Quelle auf dem Remote-Host und dem Zielpfad des anderen Hosts, imitierst du einen Pull.

rsync [optionen] [email protected]:[Quelle] [Zielpfad]

Bei [email protected] gibst du den User an, mit dem sich rsync auf deinem Remote-Host anmeldet, angeführt von einem @-Zeichen spezifizierst du danach die IP-Adresse des Remote-Hosts.

Hier siehst du, wie das ganze bei mir als vollständiger Befehl aussieht.

Beispiel für einen Push zwischen zwei Hosts:

rsync -r /home/data/ [email protected]:/home/data-backup

Beispiel für einen Pull zwischen zwei Hosts:

rsync -r [email protected]:/home/data-backup/extras /home/data

rsync Tutorial Example

Weitere nützliche Optionen innerhalb von rsync:

-d kopiert nur den Ordner aber nicht den Inhalt

-t Mit der -t Option wird die Zeit und das Datum, an dem die Datei zuletzt geändert wurde, mit kopiert. Die Option -t funktioniert bei Pull und Push und ist eine gute Methode z.B. bei kritischen Backups oder immer dann, wenn du präzise Angaben darüber benötigst, wann deine Dateien zuletzt geändert wurden.

Aber rsync kann noch viel mehr, ich will dir an dieser Stelle nur die vielseitigen Möglichkeiten dieses kleinen Programms aufzeigen. Für eine ausführliche Beschreibung aller Funktionen lohnt sich ein Blick in die man-Page von rsync

man rsync


Dateien mit rsync synchronisieren

Einen regelmäßigen Sync-Job kannst du mit den richtigen Optionen genauso einfach mittels eines einzigen rsync-Befehls durchführen. Dafür musst du den Befehl nur noch in Skript bzw. Crontab packen.

rsync -rtul --delete [QUELLE] [email protected]:/[ZIELPFAD]

In dem obigen Beispiel mit den Optionen -rtu und –delete wird ein rekursives Backup -r mit Timestamp -t angelegt. Die Option -u bezweckt, dass rsync mittels seines Algorithmus nur Differenzen synchronisiert, also nur hinzugefügte oder veränderte Dateien. –delete löscht alle Dateien aus dem Zielpfad, die in der Quelle möglicherweise nicht mehr vorhanden sind und -l kopiert alle Symlinks. Mit den zahlreichen rsync-Options kannst du dir also ein Backup Kommando ganz nach deinen Ansprüchen zusammenstellen.

rsync-Deamon

Du kannst rsync auch als Server-Instanz auf einem bestimmten Port laufen lassen. Dazu muss der rsync-Deamon konfiguriert und gestartet werden, standardmäßig lauscht der Deamon auf Port 873. Diese Methode ist nicht empfehlenswert für Datentransfers über ungesicherte Netzwerke wie das Internet, da das rsyncd-Protokoll keine Verschlüsselung bietet. Stattdessen bietet sich die Methode für die Synchronisation von Daten und Backups in nicht öffentlichen Netzwerken an. Darüber hinaus kannst du mit dem rsync-Deamon ganze Shared-Verzeichnisse für andere oder auch nur für dich selbst zum Download und Upload einrichten.

rsyncd.conf

Um den rsync-Deamon zu starten, sind einige Konfigurationen notwendig. Es existiert eine eigene man-Page für das rsync-Deamon Config-File, da dieses umfangreiche Konfigurationsmöglichkeiten bietet. Obwohl ich dir nachfolgend einen Überblick geben werde, rate ich dir in jedem Fall die man-Page genau durchzulesen!!

man rsyncd.conf

Hier findest du Beispiele und Anweisungen zu allen globalen und lokalen Parametern.

rsyncd.conf

Damit du den Deamon überhaupt starten kannst, muss zunächst das Config-File unter /etc/rsyncd.conf angelegt werden.

Nachfolgend siehst du eine Basic rsyncd.conf Einstellung:


motd file = /etc/rsyncd.motd
log file = /var/log/rsyncd.log
pid file = /var/run/rsyncd.pid
lock file = /var/run/rsync.lock

[my_path]
   path = /opt/flowy
   comment = My Rsync Server
   read only = no
   list = yes
   secrets file = /etc/rsyncd.secret

Die rsyncd-Konfigurationsdatei besteht aus zwei Blöcken für die Einstellungen mit unterschiedlichen Scopes. Im ersten Block werden die globalen Parameter festgelegt und im zweiten die Modul-Parameter.

Globale Parameter

modt file: Die erste Zeile definiert eine Message of the Day Datei, wie du es vielleicht bei einem FTP-Server kennst. Der Inhalt der Datei wird jedesmal dann angezeigt, wenn ein Client sich zu der rsync-Deamon Maschine verbindet. Du kannst deine Message individuell für dich anpassen und als Welcome-, Warning- oder Identifikations-Message nutzen.

log file: Die Datei in der zweiten Zeile spezifiziert eine simples log-File, zu welcher normale rum-time Messages und Diagnostics gesendet werden.

pid file: Das pid file beinhaltet die “process ID” also PID Nummer des aktiven rsync-Deamon.

lock file: Mit dem Deamon Lock File werden Mehrfachbearbeitungen von Dateien verhindert, die Datei sorgt dafür, dass alles glatt läuft beim Syncen.

Module Parameter

Bei dem Block der darauf folgt, handelt es sich um die lokalen Optionen deines rsync Deamons. In der ersten Zeile des zweiten Blocks in den eckigen Klammern trägst du den “Path Name” ein. Die rsync Syntax ist an dieser Stelle leicht verwirrend, da du hier nicht den direkten Pfad zu deinem Verzeichnis einträgst, sondern lediglich eine art Nickname bzw. den Modulnamen für dieses Verzeichnis. Du kannst hier einen kurzen Namen einfachen Typs angeben, der dein Verzeichnis beschreibt. Den eigentlichen Pfadnamen für dein rsync Verzeichnis gibst du unter dem path Parameter an.

Hier eine kleine Übersicht zu den grundlegendsten Optionen für einen rsync-Deamon, diese würdest du an erster Stelle festlegen. Die Optionen werden pro Zeile spezifiziert und als “Name = Value” Paar eingetragen.

path: Hier gibst du deinen eigentlichen Pfadnamen an, der zu syncen ist.

comment: Ein kurze knappe Beschreibung, auf was und wohin dein Pfadname verweist.

auth user: In der default Einstellung befindet sich der rsync-Deamon in dem Zustand “anonymous rsync”, was bedeutet, das sich alle User ohne ein Passwort connecten können. Du solltest hier auf jeden Fall den Zugang beschränken und Usernamen angeben, welchen gestattet ist, sich mit dem jeweiligen Modul verbinden zu können. Die Usernamen werden getrennt von Komma oder Leerzeichen angeben und müssen keine validen Systembenutzer sein. An dieser Stelle sind auch komplexere Authentifikationen möglich, wie bspw. Gruppenzuordnungen. Die Username/Passwort Kombinationen werden in der Datei gespeichert, die unter dem Parameter “secret file” angegeben ist.
secret file – Hier wird der Pfad zu der Datei angegeben, in der du die Username:Passwort oder @Groupname:Passwort Kombinationen hinterlegst (wie z.B. /etc/rsyncd.secrets). Die Datei ist zeilenbasiert, das heißt du gibst eine Kombination pro Zeile an.

Dateien über den rsync-Deamon übertragen

Starte deinen rsync-Deamon mit:

rsync --daemon

Wenn du dich vergewissern willst, ob dein rsync-Deamon gerade aktiv ist, dann nutze folgenden Befehl:

 ps x | grep rsync

rsync-Deamon Connection testen

Anschließend testen wir unsere neue Connection, indem wir uns vom Client-Host mit dem Server verbinden, auf dem wir den Deamon aktiviert haben.

Die Syntax dafür sieht wie folgt aus:

rsync Deamon Connection

Wie du sehen kannst, wird dir nach dem Connecten dein Modulname (Der “Path Name”, der in den eckigen Klammern im config-File definiert wurde) für das Verzeichnis und das comment Parameter zurückgegeben.

Um dir den Inhalt des Verzeichnisses anzeigen zu lassen, hängst du den Modulnamen an den vorherigen Befehl:

rsync Deamon Connection Sample 2

Auf die Angabe des Ports könnte in unserem Fall genauso gut verzichtet werden, da wir für unser Beispiel nicht vom Default rsyncd-Port abgewichen sind.

Die Basic Syntax für Pull und Push über den Deamon sieht wie folgt aus:

Pull:

rsync [optionen] rsync://[email protected][:PORT][QUELLE] [ZIELPFAD]

Push:

rsync [optionen] [QUELLE] rsync://[email protected][:PORT][ZIELPFAD]


Fazit

Du hast gelernt, was in diesem “kleinen” vielseitigen Tool rsync steckt und kannst es nun für einfache Copy-Jobs, aufwändigere Backups zwischen zwei Servern und Mirroring Tasks einsetzen. In vielerlei Hinsicht wird rsync auf diesen Gebieten deine beste Wahl sein, einmal aufgesetzt arbeitet rsync sehr zuverlässig.

Zurück zur Tutorial Übersicht Back to Tutorial Overview

GoAccess – Echtzeit Webserver Log Analyse

GoAccess_LogAnalyzer_auf_Linux_installieren_DE

GoAccess Log Analyzer auf Linux installieren

GoAccess ist ein cooles Open-Source Webserver Analyse Tool, mit dem du deine Webserver-Logs in Echtzeit analysieren kannst. Wenn du auf deinem Cloud-Server eine Webapplikation wie z.B. WordPress oder Ghost laufen hast, bietet dir GoAccess eine praktische und vor allem easy-to-use Dashboard-Übersicht. Für dich als Systemadministrator ist es wichtig alle HTTP Statistiken im Blick zu haben, dein GoAccess Dashboard kannst du wahlweise über das Terminal per SSH oder deinen Browser aufrufen. Es werden nahezu alle gängigen Web-Log-Formate wie Apache, Nginx, Elastic Load und viele weitere unterstützt. Dazu ist die Installation von GoAccess schnell und einfach durchgeführt, es werden alle gängigen Linux-Distributionen, FreeBSD und OpenBSD unterstützt.

Einige der Key-Features von GoAccess:

– Superschnelle real-time Analyse (GoAccess wurde in C geschrieben)
– Tracken der Response-Time
– Custom Log-Format String
– Nützliche Statistiken (Bandbreite, Besucher, Anzahl der Hits etc.)
– Metriken für all deine Virtual-Hosts
– Wenig Konfiguration notwendig
– Customizable View

In diesem Tutorial zeige ich dir die Installation von GoAccess unter Ubuntu 16.04 und anderen Linux-Distros.

Vorbereitungen

Wenn noch keine Webapplikation mit Webserver wie Apache oder Nginx auf deinem Server aktiv ist, wird noch ein Webserver benötigt. Für eine einfache Demonstration installieren wir einen Apache.

apt-get install apache2 -y

Nach der Installation kannst du den Apache Service starten und auf enable stellen, so bleibt dein Webserver auch nach einem Neustart aktiv.

systemctl start apache2
systemctl enable apache2

Noch mehr Informationen dazu, wie du einen Apache Server oder Nginx installierst und einrichtest, findest auch in diesen Tutorials:

Apache2 auf Ubuntu 16.04 installieren

LEMP Server auf Ubuntu installieren

GoAccess unter Ubuntu 16.04 installieren

Du kannst GoAccess über verschiedene Wege installieren, am schnellsten unter Ubuntu geht es über den eingebauten Paketmanager.

apt-get install goaccess

Hinweis: Mittels Paketmanager ist nicht gewährleistet, dass du die aktuellste LTS-Version bekommst, deswegen kann es sinnvoll sein, GoAccess über eine Paket-Fremdquelle oder alternativ über den Source-Code zu installieren.

Auch das geht mit nur ein paar Befehlen, folge dazu einfach meinen untenstehenden Anweisungen.

GoAccess von Source-Code installieren

Um GoAccess unter Ubuntu/Debian von Source-Code zu installieren, müssen vorab ein paar Dependencies installiert werden. Diese werden zur richtigen Kompilierung gebraucht, da GoAccess in C geschrieben ist.

Solltest du nicht mit Root-Rechten eingeloggt sein, ist eine Ausführung der Befehle mit sudo erforderlich!

Schritt 1 – Paketmanager upgraden und Dependencies installieren:

apt-get upgrade -y
apt-get -y install libncursesw5-dev gcc make libgeoip-dev libtokyocabinet-dev build-essential -y

Schritt 2 – GoAccess installieren und kompilieren

Lade zuerst die aktuellste GoAccess Version von der offiziellen Website.

wget http://tar.goaccess.io/goaccess-1.2.tar.gz

Als nächstes entpackst du die tar-Datei nach /opt/:

tar -xzvf goaccess-1.2.tar.gz

und wechselst in das neue Verzeichnis

cd /opt/goaccess-1.2/

Im letzten Schritt kannst du nun den Source-Code compilen:

./configure --enable-utf8 --enable-geoip=legacy
make
make install

 

GoAccess über eine Fremdquelle installieren

An dieser Stelle zeige ich dir, wie du GoAccess über eine Fremdquelle auf Debian/Ubuntu installierst.

echo "deb http://deb.goaccess.io/ $(lsb_release -cs) main" | sudo tee -a /etc/apt/sources.list.d/goaccess.list+
wget -O - https://deb.goaccess.io/gnugpg.key | sudo apt-key add -
sudo apt-get update
sudo apt-get install goaccess

 

Andere Linux-Distros/BSD/Windows

Wie du GoAccess unter anderen Linux Distributionen, BSD und Windows installierst erfährst du auf der offiziellen Seite:

https://goaccess.io/download#distro

GoAccess aufrufen

Schon gespannt auf dein neues Analyzer-Dashboard?

Nach der erfolgreichen Installation, sind wir bereit GoAccess mit dem Apache Webserver zu testen. Hierzu brauchen wir aber erstmal einen Log-Eintrag in dem default access_log File.

Rufe dafür deinen Webserver über die IP-Adress in deinem Browser auf. Der Apache wird einige Log-Einträge in die Datei schreiben, ansonsten wäre auf deinem Dashboard natürlich nichts zu sehen.

GoAccess im Terminal aufrufen

goaccess /var/log/apache2/access.log --log-format=COMBINED

Und so sollte dein CLI Dashboard aussehen:

GoAccess CLI View Example

GoAccess HTML View aufrufen

Mit folgendem Befehl kannst du ein HTML-Dashboard generieren:

goaccess /var/log/apache2/access.log --log-format=COMBINED -a -o /var/www/html/report.html

Anschließend kannst du GoAccess über http://deine-ip-adresse/report.html in deinem Browser aufrufen. Hier solltest du nun dein neues Dashboard in aller Schönheit betrachten können:

GoAccess HTML View Example 2

GoAccess CLI View Example

Fazit

Ging doch RatzFatz oder?
Jetzt kannst du ganz easy deine Apache-Logs in deinem neuen GoAccess Web-Interface und CLI Dashboard analysieren.

Und vielleicht findest du ja noch mehr interessante Topics für dich in unserer Developer Community ?

Machs gut!

Zurück zur Tutorial Übersicht Back to Tutorial Overview

Joomla! unter Ubuntu 16.04/18.04 installieren und einrichten

Joomla auf Ubuntu installieren und einrichten

Zu Joomla!

Informationen zu Open Source CMS und deren Installation/Einrichtung sind dir bereits aus unseren Tutorials zu Installation von WordPress Ubuntu 16.04 LTS oder Debian 8, TYPO3 7 auf Ubuntu 16.04 installieren und Drupal unter Ubuntu 16.04/18.04 installieren und einrichten bekannt, du kannst sie jederzeit dort nachlesen. In diesem Tutorial wird nun die Reihe abgeschlossen, indem ich dir Joomla! vorstelle und mit dir gemeinsam einen Installationsprozess simuliere, sodass du ihn nachbilden kannst. Das dynamische Web-CMS bietet dir flexiblen Freiraum bei der Gestaltung deiner Webpräsenz. Du hast die Möglichkeit, die zur Verfügung gestellten Designs anzupassen und auch der zu befüllende Content wird durch die zur Verfügung gestellten Module und Plugins leicht managbar. Ab der Version 3.8 tritt Joomla! an dich als potentiellen Endnutzer mit einem verbesserten Routing-System heran, unterstützt Verschlüsselungen und bietet eine robustere und schnellere Codebasis.

Voraussetzungen

Wie du aus den Tutorials zu TYPO3 7 auf Ubuntu 16.04 installieren und Drupal unter Ubuntu 16.04 installieren und einrichten weißt, kann für die Installation eines Web-CMS ein LAMP-Stack (Apache, MariaDB/MySQL und PHP) erforderlich sein, so auch im Fall der Installation von Joomla!. Wie du den LAMP-Stack herstellst, wird dir in unserem Tutorial zum Thema LAMP-Server mit PHP 7 und Apache 2.4 auf Ubuntu 16.04 installieren bzw. LAMP-Stack auf Ubuntu 18.04 LTS mit PHP 7.2 und Apache 2.4 gezeigt. Für dieses Tutorial hingegen bevorzuge ich nicht MariaDB als Datenbank, sondern MySQL. Also müsstest du zur Installation der erforderlichen Datenbank, anders als in LAMP-Server mit PHP 7 und Apache 2.4 auf Ubuntu 16.04 installieren bzw. LAMP-Stack auf Ubuntu 18.04 LTS mit PHP 7.2 und Apache 2.4 demonstriert, nicht MariaDB installieren, sondern MySQL. Dies wird dir über die drei Commands im Code-Snippet unten veranschaulicht.


apt-get update

apt-get install mysql-server

mysql_secure_installation

Des Weiteren legst du dann eine Datenbank für dein Joomla!-CMS an, wie im Code-Block unten gezeigt und befolgst im Anschluss daran die weitere Anleitung aus dem Tutorial LAMP-Server mit PHP 7 und Apache 2.4 auf Ubuntu 16.04 installieren bzw. LAMP-Stack auf Ubuntu 18.04 LTS mit PHP 7.2 und Apache 2.4.


mysql -u root -p_
password: *********

mysql> CREATE USER 'username'@'localhost' IDENTIFIED BY 'passwort';
Query OK, 0 rows affected (0,00 sec)


mysql> CREATE DATABASE Joomla;
Query OK, 1 row affected (0.00 sec)

mysql> GRANT ALL PRIVILEGES ON Joomla.* TO 'username'@'localhost' IDENTIFIED BY 'passwort';
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> EXIT;
Bye

Nach der Installation von PHP ist es noch wichtig, das PHP-Package xml zu installieren. Denn wenn du gleich Joomla! installiert hast, wirst du es zum Einrichten in deinem Browser via IP und entsprechendem Pfadnamen – getrennt durch Forward Slash – aufrufen müssen und wenn das xml-Package fehlt, kann es zu einer Error displaying the error page-Fehlermeldung kommen und der eigentlich zu erwartende Seiteninhalt wird nicht angezeigt.


apt-get install php7.0-xml

systemctl restart apache2

Download und Installation von Joomla!

Vor dem Download von Joomla! wechselst du via dem unten eingeblendeten Command in das betreffende Verzeichnis.


cd /var/www/html

Dort legst du einen neuen Ablageort für die im Nachhinein zu installierende Jooma!-Software an und wechselst in das neu angelegte Verzeichnis.


mkdir joomla

cd joomla

Darin führst du dann mit dem unten gezeigten Command den Download der gezippten Software aus. Je nach Joomla!-Version kannst du die Versionsnummer im Befehl anpassen.


wget  https://github.com/joomla/joomla-cms/releases/download/3.8.2/Joomla_3.8.2-Stable-Full_Package.tar.gz

Im Anschluss daran entpackst du das Joomla!-Package mittels folgendem Command.


tar xzf Joomla_3.8.2-Stable-Full_Package.tar.gz

Schließlich musst du dann noch die Zugehörigkeit der Joomla!-Dateien zu Apache bestimmen, was du über den 1. Command im unten eingeblendeten Command-Block tun kannst. Über den 2. Command veränderst du dann noch die Zugriffsrechte der Dateien, sodass die Dateien vom Web-Server gelesen werden können.


chown -R www-data:www-data .

chmod -R 755 .

Danach ist es dann noch notwendig die Apache2-Konfigurationsdatei zu editieren. Hierzu öffnest du diese Datei im nano-Editor mit dem folgenden Command.


nano /etc/apache2/sites-available/joomla.conf

Es öffnet sich dann im Terminal der nano-Editor mit leerem Inhalt. Hier wirst du die im Code-Block unten präsentierten Zeilen reinkopieren.



   ServerName joomla.example.com 
   ServerAdmin [email protected]
   DocumentRoot /var/www/html/joomla
   
	    Allowoverride all
   

Mit der Kombination aus der Taste Strg und der Taste O speicherst du den Inhalt, bestätigst den daraufhin im weiß hinterlegten Balken befindlichen Dateinamen unten im Menü mit der Enter-Taste und verlässt im Anschluss den Editor via Kombination aus den Taste Strg und der Taste X.

Einrichten von Joomla!

Wenn du die Installation abgeschlossen hast, ist es dir möglich Joomla! einzurichten. Hierzu rufst du entsprechend die URL im Browser via joomla/index.php, wobei “joomla” das betreffende Verzeichnis anspricht, das ich im vorherigen Kapitel via mkdir joomla-Command erstellt habe. Alternativ kannst du auch die IP deines Servers in Kombination mit /joomla/index.php in den Browser eingeben. Sobald du dies tust, erscheint – wie unten im Screenshot zu erkennen- die Einrichtungsseite für dein CMS, auf der sich drei Tabs befinden. Im ersten Tab geht es zunächst um deine EIngabe von Daten, die die Hauptkonfiguration betreffen.

Hauptkonfiguration von Joomla

Hast du die Eingabe der Daten mit Klick auf “Weiter” abgeschlossen, wird der nächste Tab freigeschaltet, in dem die Informationen zu deiner erstellten Joomla!-Datenbank abgefragt werden.

Datenbankkonfiguration von Joomla

Sobald du die erforderlichen Daten in die Felder eingetragen hast und dies mit Klick auf “Weiter” bestätigst, öffnet sich schließlich der 3. und letzte Tab, in dem dir ein Gesamtüberblick deiner Eingaben bereitgestellt wird. Zusätzlich bietet dir die Sparte “Installationsprüfung” unten links eine Übersicht darüber, ob die vor und während der Installation durchgeführten Voraussetzungen und Einstellungen stimmen.

Zusammenfassung nach Konfiguration von Joomla

In jedem der 3 Tabs hast du jederzeit die Möglichkeit über Klick auf den Button “Zurück” bereits getroffene Eingaben zu revidieren. Wenn du aber der Ansicht bist, dass die eingetragenen Informationen korrekt sind, dann klicke den Button “Installieren”, um die Einrichtung deines CMS abzuschließen und somit die Installation zu finalisieren. Letztlich wird dir dann bestätigt, dass die Installation vollständig durchgeführt worden ist, wie du dem Screenshot unten entnehmen kannst.

Installationsbestätigung von Joomla

Fazit

Meine Anleitung zur Installation und Einrichtung von Joomla! hat dir eine Basis geschaffen, um dein CMS auf deinem Ubuntu-Server startklar zu machen. Ich hoffe, dir ein guter Ratgeber gewesen zu sein, den du gerne jederzeit wieder nachschlagen kannst. Mir hat es Spaß gemacht, dir die Inhalte dieses Tutorials nahe zu bringen und ich wünsche dir viel Spaß bei der Umsetzung.

Zurück zur Tutorial Übersicht Back to Tutorial Overview

Drupal unter Ubuntu 16.04/18.04 installieren und einrichten

Drupal auf Ubuntu installieren und einrichten

Zu Drupal

In den Tutorials Installation von WordPress Ubuntu 16.04 LTS oder Debian 8 und TYPO3 7 auf Ubuntu 16.04 installieren haben wir dir bereits jeweils eine Anleitung dafür bereit gestellt, wie du die beiden Content-Management-Systeme WordPress und TYPO3 auf deinem Server korrekt installierst. Neben diesen existiert ein weiteres CMS, nämlich Drupal. Auch Drupal ist ein frei erwerbbares und sehr mächtiges Web-Content-Management-System (Web-CMS) und -Framework. Mit Drupal kannst du deine eigene Homepage, einen Blog, eine Bildergalerie, ein Forum oder Wiki umsetzen. Es ist in wenigen Schritten nutzbar, leicht auszubauen und verfügt über viele Erweiterungen und einer Menge fertiger Designs, aus denen du wählen kannst. Das Template-System von Drupal ist flexibel, es unterstützt alle modernen Techniken und ist HTML5-konform. Es ist möglich die Stylesheets der Standard-Templates nicht nur zu nutzen, sondern auch zu bearbeiten, um Designs nach eigenem Ermessen anzupassen. In diesem Tutorial werde ich dir zeigen, wie du Drupal unter Ubuntu installierst und im Anschluss einrichtest.

Voraussetzungen

Wie im Fall der Installation von TYPO3 ist es auch bei der Installation von Drupal notwendig, dass zunächst Apache, MySQL/MariaDB und PHP auf deinem Server konfiguriert worden sind. Dies erreichst du – wie bereits aus dem Tutorial TYPO3 7 auf Ubuntu 16.04 installieren bekannt – über die Installation eines LAMP-Servers. Wie du dir einen LAMP-Server einrichten kannst, wird dir in unserem Tutorial LAMP-Server mit PHP 7 und Apache 2.4 auf Ubuntu 16.04 installieren bzw. LAMP-Stack auf Ubuntu 18.04 LTS mit PHP 7.2 und Apache 2.4 erklärt.
In diesem Tutorial hier arbeite ich nicht mit MariaDB, sondern mit MySQL. Also müsstest du zur Installation der erforderlichen Datenbank, anders als in LAMP-Server mit PHP 7 und Apache 2.4 auf Ubuntu 16.04 installieren bzw. LAMP-Stack auf Ubuntu 18.04 LTS mit PHP 7.2 und Apache 2.4 demonstriert, nicht MariaDB installieren, sondern MySQL. Dies wird dir über die drei Commands im Code-Snippet unten veranschaulicht.


apt-get update

apt-get install mysql-server

mysql_secure_installation

Des Weiteren legst du dann eine Datenbank für dein Drupal-CMS an, wie im Code-Block unten gezeigt und befolgst im Anschluss daran die weitere Anleitung aus dem Tutorial LAMP-Server mit PHP 7 und Apache 2.4 auf Ubuntu 16.04 installieren bzw. LAMP-Stack auf Ubuntu 18.04 LTS mit PHP 7.2 und Apache 2.4.


mysql -u root -p
password: *********

mysql> CREATE USER 'username'@'localhost' IDENTIFIED BY 'passwort';
Query OK, 0 rows affected (0,00 sec)


mysql> CREATE DATABASE Drupal;
Query OK, 0 rows affected (0,00 sec)

mysql> GRANT ALL PRIVILEGES ON Drupal.* TO 'username'@'localhost' IDENTIFIED BY 'passwort';
Query OK, 0 rows affected (0,00 sec)

mysql> EXIT;
Bye

Download und Installation von Drupal

Bevor du Drupal von der offiziellen Website via Terminal-Command downloadest, musst du in das betreffende Verzeichnis wechseln.

cd /var/www/html

Im Anschluss daran führst du mit dem unten gezeigten Command den Download der gezippten Software aus. Hierbei kannst je nach Version die Nummer anpassen.

wget https://ftp.drupal.org/files/projects/drupal-8.5.0.tar.gz

Um die gezippte Software zu extrahieren, ist der folgende Command auszuführen.

tar xvzf drupal-8.5.0.tar.gz

Weiterführend ist es sinnvoll, das daraufhin entpackte Verzeichnis drupal-8.5.0 nach deinem eigenen Ermessen umzubenennen. Im Hinblick auf die Endnutzung und die Auffindbarkeit wäre es ratsam, die Benennung des Verzeichnisses der Sache entsprechend zu wählen, wie im Beispiel das aus dem folgenden Code-Block hervorgeht. Denn der Name des Ordners wird später auch in der URL deines persönlichen Drupal-CMS erscheinen. In diesem Fall benenne ich das Verzeichnis drupal-8.5.0 um in drupal.

mv drupal-8.5.0 drupal

Als nächstes wechselst du mittels dem 1. im Code-Block unten gezeigten Command in das Verzeichnis, in dem nun alle Dateien der gedownloadeten Software liegen.
Dort schließlich musst du dann noch die Zugehörigkeit der Drupal-Dateien zu Apache bestimmen. was du über den 2. im unten eingeblendeten Code-Block gelisteten Command tust. Mit dem 3. Command letztlich ermöglichst du es, dass die Dateien vom Web-Server gelesen werden können.


cd drupal

chown -R www-data:www-data .

chmod -R 755 .

Einrichten von Drupal

Nach der erfolgreich durchgeführten Installation kannst du nun Drupal einrichten. Hierzu rufst du entsprechend die URL im Browser auf, die sich aus deiner Server-IP und dem Suffix /drupal/core/install.php zusammensetzt, wobei “drupal” das betreffende Verzeichnis anspricht, in dem die entpackte Drupal-Software liegt. Ein User-Interface leitet dich dann Schritt für Schritt durch die Einrichtung, wie in den folgenden Screenshots verbildlicht. Hierbei kannst du nach eigenem Ermessen die Basiseinstellungen konfigurieren.

Sprache für Drupal auswählen

Installationsprofil für Drupal auswählen

Im Schritt zur Überprüfung der Systemvoraussetzungen – wie im Screenshot unten verbildlicht – wird die Korrektheit und Vollständigkeit der Basis für deine Nutzung von Drupal validiert, wie du im Screenshot unten erkennst. Soweit es sich bei dem Validierungsergebnis lediglich um (eine) Warnung(en) handelt, kannst du den im Interface unten befindlichen Link “fahre weiter fort” anklicken, ansonsten – im Fall einer Fehlermeldung – musst du dich definitiv darum kümmern, dass diese verschwindet, z.B. durch Nachinstallation eines Packages für den Fall, dass es fehlen sollte.

Systemvoraussetzungen für Drupal

An der Fehlermeldung im oben eingeblendeten Screenshot erkennst du schließlich, dass es notwendig ist, zusätzliche PHP-Packages zu installieren, nämlich die Packages dom, gd, xml und SimpleXML. Dies tust du, indem du die vier unten im Code-Snippet präsentierten Commands im Terminal ausführst. Je nach verwendeter PHP-Version müsstest du die Versionsnummer in den vier Kommandos aus dem folgenden Code-Block entsprechend anpassen.


apt-get install php7.0-dom

apt-get install php7.0-gd

apt-get install php7.0-xml

apt-get install php7.0-SimpleXML

Hiernach führst du ein Update durch und startest den WebServers neu via der beiden unten gezeigten Kommandos.


apt-get update

systemctl restart apache2

Zurück zu dem Schritt im Interface, bei dem die Systemvoraussetzungen überprüft werden: Nachdem du den Browser aktualisiert hast, siehst du, dass die Fehlermeldung nun beseitigt ist. Allerdings ist die Warnmeldung zur Lesbarkeit von URLs noch existent. Es steht dir nun frei, ob du die Installation nun weiterführst durch Klick auf den im Interface unten befindlichen Link “fahre weiter fort” und dich später darum kümmerst, dass URLs lesbar sind oder ob du das jetzt direkt machst. Ich zeige dir nun, wie du die Warnmeldung beseitigen kannst, um das Problem mit der Lesbarkeit von URLs für dein Drupal-CMS zu beseitigen. Zunächst wechselst du via cd-Command in das Home-Verzeichnis zurück und öffnest dann mit dem darauffolgend unten eingeblendeten Command die apache2.config-Datei im nano-Editor.


cd

nano /etc/apache2/apache2.conf

Darauf öffnet sich die Datei im Terminal im nano-Editor. Dort scrollst du dich bis zu der Stelle, die im Screenshot unten gelb markiert ist und änderst None ab in All, sodass der in Directory /var/www/ getaggte Code-Snippet so aussieht wie im grauen Code-Block unterhalb des Screenshots dargestellt.

apache2.conf-Datei geöffnet im nano-Editor


Options Indexes FollowSymLinks
AllowOverride All
Require all granted

Als nächstes speicherst du den editierten Inhalt via Kombination der Taste Strg mit der Taste O, bestätigst mit der Enter-Taste den daraufhin in einem weißen Balken eingeblendeten Dateinamen und verlässt im Anschluss den Editor via Kombination der Taste Strg und der Taste X.

Zudem ist es noch notwendig, dass du das rewrite-Modul installierst und Apache2 neu startest, wie in dem dem Command-Block unten verdeutlicht.


a2enmod rewrite

systemctl restart apache2

Sobald du den Browser dann aktualisiert hast, wirst du automatisch in das nächste Interface-Fenster weitergeleitet, was dir signalisiert, dass die Warnmeldung zur Lesbarkeit von URLs behoben ist. Hier geht es nun um die Datenbankkonfiguration, wobei du die dir bekannten Daten deiner zuvor in MySQL erstellten Drupal-Datenbank in die freien Felder einträgst und dies mit Klick auf den Button Speichern und Fortfahren bestätigst.

Datenbank für Drupal einrichten

Im Nachgang wird dann die Website installiert. Die Entwicklung dieses Installationsprozesses entnimmst du dem prozentualen Maß des Fortschrittsbalken im Interface.

Drupal-Website installieren

Sind die 100% der Website-Installation erreicht, erscheint ein neuer Fortschrittsbalken, der erneut die prozentuale Entwicklung wiedergibt, dieses Mal aber die der Konfiguration der Übersetzungen.

Uebersetzungen für Drupal konfigurieren

Konfiguration der Drupal-Website

Uebersetzungen für Konfiguration von Drupal aktualisieren

Wenn du im Anschluss daran die IP des Servers in Kombination mit dem Suffix /drupal im Browser aufrufst, dann siehst du – wie im Screenshot unten erkenntlich – die Oberfläche deines persönlichen Drupal CMS.

Web-Interface von Drupal

Fazit

Nachdem du nun Drupal installiert und eingerichtet hast, kannst du es nutzen, um deine Online-Präsenz eigenständig und variabel zu gestalten – sei es z.B. für deine Website, ein Wiki oder einen Blog. Es freut mich, dir die Schritte zu deinem eigenen Web-CMS näher gebracht zu haben und ich wünsche dir gutes Gelingen bei der Umsetzung deiner Ideen mit diesem.

Aus unserer Rubrik zu Open Source CMS auch noch interessant und hilfreich:

Zurück zur Tutorial Übersicht Back to Tutorial Overview

InfluxDB unter Ubuntu 16.04/18.04 installieren und einrichten

InfluxDB unter Ubuntu installieren und einrichten

Wir haben dir bereits in unserem Tutorial zu MySQL Datenbank erstellen und löschen und PostgreSQL 10 auf Ubuntu 16.04 / 14.04 installieren gezeigt, wie du objektrelationale SQL-Datenbanken auf deinem Ubuntu-Server installierst und einrichtest. Ebendies haben wir dir auch für objektrelationale NO-SQL Datenbanken wie MongoDB, Redis und RethinkDB in unseren Tutorials MongoDB auf Ubuntu installieren, Apache Cassandra auf Ubuntu installieren, Redis auf Ubuntu 16.04 LTS installieren und RethinkDB auf Ubuntu installieren nahe gebracht. In diesem Tutorial geht es nun um ein Open Source-Produkt, das an das Konzept einer Datenbank angelehnt ist, sich aber von den bisher durch uns vorgestellten Modellen der SQL- und NO-SQL-Datenbanken abhebt. Ich werde dich in den folgenden Kapiteln mit InfluxDB vertraut machen. Solltest du mit der Installation, dem Einrichten und/oder der Nutzung von InfluxDb bereits betraut sein, können für dich weiterführend die Tutorials InfluxDB – Monitoring mit dem TICK-Stack oder InfluxDB – Monitoring mit dem TIG-Stack interessant und hilfreich sein, da es auch direkt an das in diesem Tutorial beschriebene Anwendungsszenario anknüpft.

Neu! – Autoscale MySQL-as-a-Service von Tech4Hosting

Alle, die sich nicht mehr mit Datenbank-Administration auseinandersetzen wollen, können jetzt auch die neuen Platform Services von Tech4Hosting nutzen.

Der Vorteil der Platform Services bei Tech4Hosting: Wir kümmern uns um die sichere Konfiguration, den zuverlässigen Betrieb und die Installation von Sicherheitsupdates deiner PaaS-Dienste. In deinem Tech4Hosting Panel kannst du ab sofort mit den Datenbanken PostgreSQL, MySQL und redis starten.
Probiere es einfach mal aus!

Mehr Infos zu PaaS bei Tech4Hosting und wie PaaS funktioniert gibt es in unserem
Getting started mit PaaS bei Tech4Hosting
Platform Services von Tech4Hosting.

Zu InfluxDB

Mit InfluxDB wird eine komplette Open Source-Plattform angeboten, die für Metriken, Ereignisse und andere zeitbasierte Daten von Menschen, Sensoren oder Maschinen und deren Verarbeitung, bzw. Auswertung entwickelt wurde. In Echtzeit können Daten gesammelt, gespeichert, visualisiert und Erkenntnisse in Aktionen umgesetzt werden. Es handelt sich sozusagen um eine moderne Zeitreihen-Plattform. InfluxDB differenziert sich somit vom Modell einer SQL- oder NoSQL-Datenbank, da dieses Produkt als Plattform fungiert und nicht auf einen SQL- oder NoSQL-Speicher beschränkt ist. Da sich Compute-Infrastruktur und -Architekturen als Konsequenz neuer Anforderungen und Bedürfnisse weiterentwickeln, genügen bestehende Technologien meist nicht, um die damit verbundenen neuen Anforderungen zu erfüllen (Big Data und das Aufkommen von HDFS und Hadoop). Und da die bisherige Technologie der Datenspeicherung in SQL- und NoSQL-Speichern diesen nicht gerecht wurde, wurde InfluxDB entwickelt. InfluxDB bietet für die Speicherung von Zeitreihendaten in einer Zeitreihen-Datenbank eine zweckmäßige und moderne Zeitreihen-Plattform. Die Transparenz und Kontrolle von Zeit gehören zum Zeitalter der Digitalisierung und Instrumentierung, in der Echtzeitverarbeitung datengesteuerten Organisationen Einblicke und Wettbewerbsvorteile verschaffen können. Als eine End-to-End-Plattform kann InfluxDB in der Cloud oder per Download bereitgestellt werden, elegant und einfach zu bedienen, frei von externen Abhängigkeiten, aber offen und flexibel genug für komplexe Implementierungen. Die Analyse der Daten erfolgt über eine SQL-ähnliche Abfragesprache.
Man kann seine Daten sogar mit dem integrierten Open-Source-Projekt Chronograf grafisch darstellen und visualisieren und eine somit eine Untersuchung im Sinne von Daten-Plotting durchführen. Hierzu wirst du im vorletzten Kapitel dieses Tutorials mehr erfahren. Darüber hinaus unterstützt InfluxDB andere Visualisierungswerkzeuge wie Grafana.

Anwendungsszenario

Um dir ein Gefühl für die Arbeit mit der Datenbank-Plattform InfluxDB zu geben, werde ich mit dir einen Real-Live Case simulieren, bei dem wir uns im Anschluss die in eine angelegte Datenbank integrierten Datenpunkte visuell analysiert plotten lassen werden. Hierzu nehme ich mit dir die Perspektive eines Unternehmens ein, das Wert darauf legt, seine über den Online-Shop stattfindenden Verkaufsaktivitäten als Messung in Relation zur Zeit, sowie den Tatsachen, wie alt die Person ist (INTEGER) und letztlich eingekauft wurde oder nicht (Boolean TRUE/FALSE) als Messwerten und schließlich zu demographischen Daten wie dem Geschlecht und dem Standort sowohl seiner bereits existierenden Kunden als auch potentieller Kunden zu betrachten. Aus den sich aus Besucher-Tracking-Zeitreihen ergebenden Datenpunkten können möglicherweise interessante Informationen ermittelt und auf Basis dieser Informationen zukünftige Online-Marketingstrategien (z.B. Newsletter, Social-Media) und Usability-Maßnahmen entwickelt und/oder optimiert werden. Das Projekt soll sozusagen helfen, die Psychologie des Online-Shoppings zu verstehen, indem Einkaufsphasen und die dahinter stehenden Kunden in bestimmten Kontexten erkannt werden. Es ist – wie schon erwähnt – ein an die Realität angelehntes Fallbeispiel, dass dir lediglich zur Orientierung dienen soll. InfluxDB kann natürlich nicht nur für gewerbliche Zwecke sehr hilfreich sein, sondern auch für private oder auf Bildung ausgelegte Projekte jeglicher Art genutzt werden, um Zeitreihen basierte Zusammenhänge von Datenmengen wiederauffindbar, bewachbar, analysierbar, auswertbar und visualisierbar zu machen.
Zur Simulation des Szenarios werde ich die Datenpunkte mittels der aus der SQL-Datenbanksprache bekannten INSERT-Operation sozusagen als Indexer in die betreffende Messung implementieren. Mit Ausblick auf einen Real-Life Case darfst du dir vorstellen, dass die pro Datenpunkt enthaltenen Informationen direkt auf der Website getrackt und über eine im Hintergrund agierende Software automatisiert an die Datenbank kommuniziert wurden. Wobei die persönlichen Informationen zu Geschlecht und Alter über eine für den Besucher unumgängliche Interface-Abfrage auf der Website abgefangen wurden. Ich beschränke mein Zeitreihen-Szenario auf ein Zeitfenster, das Datenpunkte zum 17.04.2018 im Zeitraum 13:00 bis 13:15 enthält und diese im Epoch-Zeitformat auf Minuten bestimmt getrackt wurden.

Voraussetzungen

Die Nutzung von InfluxDB setzt das Vorhandensein der Netzwerkports 8086 und 8088 auf deinem System voraus, wobei der TCP-Port 8086 für die Client-Server-Kommunikation über die HTTP-API von InfluxDB verwendet wird und der TCP-Port 8088 für den RPC-Dienst zum Sichern und Wiederherstellen.
Neben diesen beiden Ports bietet InfluxDB mehrere Plugins, die möglicherweise benutzerdefinierte Ports erfordern. Es ist möglich alle Port-Zuordnungen über die Konfigurationsdatei zu ändern. Die Port-Zuordnungen befinden sich bei Standardinstallationen in der Datei /etc/influxdb/influxdb.conf. Informationen darüber, wie du diese Datei editieren kannst, findest du im Kapitel InfluxDB konfigurieren.
Die unten stehende Tabelle bietet dir einen guten Überblick über mögliche Ports.

Port

Bedeutung

8086

Der Standardport, auf dem der HTTP-Dienst InfluxDB ausgeführt wird. Du kannst diesen Port in der Konfigurationsdatei konfigurieren, indem du bind-address = „127.0.0.1:8086“ setzt.

Umgebungsvariable: INFLUXDB_HTTP_BIND_ADDRESS

8088

Der Standardport, auf dem der RPC-Dienst zum Sichern und Wiederherstellen ausgeführt wird. Du kannst diesen Port in der Konfigurationsdatei konfigurieren, indem du bind-address = „127.0.0.1:8088“ setzt.

Umgebungsvariable: INFLUXDB_HTTP_BIND_ADDRESS

2003

Der Standardport, auf dem der Graphite-Dienst ausgeführt wird.

Du kannst diesen Port in der Konfigurationsdatei konfigurieren, indem du bind-address = „127.0.0.1:2003“ setzt.

Umgebungsvariable: INFLUXDB_GRAPHITE_0_BIND_ADDRESS

4242

Der Standardport, auf dem der OpenTSDB-Dienst ausgeführt wird.

Du kannst diesen Port in der Konfigurationsdatei konfigurieren, indem du bind-address = „127.0.0.1:4242“ setzt.

Umgebungsvariable: INFLUXDB_OPENTSDB_BIND_ADDRESS

8089

Der Standardport, auf dem der UDP-Dienst ausgeführt wird.

Du kannst diesen Port in der Konfigurationsdatei konfigurieren, indem du bind-address = „127.0.0.1:8089“ setzt.

Umgebungsvariable: INFLUXDB_UDP_BIND_ADDRESS

25826

Der Standardport, auf dem der Collect-Dienst ausgeführt wird.

Du kannst diesen Port in der Konfigurationsdatei konfigurieren, indem du bind-address = „127.0.0.1:25826“ setzt.

Umgebungsvariable: INFLUXDB_COLLECTD_BIND_ADDRESS

 

aktivierte Ports

 

deaktivierte Ports

Bei InfluxDB dienen Zeitstempel zur Koordination und zur Zuordnung von Daten, wobei die lokale Zeit eines Hosts in UTC genutzt wird. Um eine Ungenauigkeit der Zeitstempel der in INfluxDB geschriebenen Daten zu vermeiden, ist es nötig, die Zeit zwischen Hosts mittels Verwendung des Network Time Protocol (NTP) zu synchronisieren.

InfluxDB installieren

Zunächst musst du das InfluxDB-Repository mit den folgenden drei Befehlen hinzufügen.


> curl -sL https://repos.influxdata.com/influxdb.key | apt-key add -

> source /etc/lsb-release

> echo "deb https://repos.influxdata.com/${DISTRIB_ID,,} ${DISTRIB_CODENAME} stable" | tee /etc/apt/sources.list.d/influxdb.list

Sowohl für Ubuntu-Versionen unterhalb Ubuntu 15.04+ als auch die darüber liegenden Versionen, müsstest du für die Installation von InfluxDB das unten stehende Kommando im Terminal ausführen.


> apt-get update && sudo apt-get install influxdb

Nach der Installation ist es noch notwendig, dass du InfluxDB startest. Der hierfür zu verwendende Command unterscheidet sich bei Ubuntu-Versionen unterhalb Ubuntu 15.04+ von denen, deren Version darüber liegt. Im Fall von Ubuntu-Versionen unterhalb Ubuntu 15.04+ wäre für den Start die Kommandozeile richtig, wie sie im Code-Block unten zu sehen ist.


> service influxdb start

Mit Ubuntu-Versionen ab Ubuntu 15.04+ allerdings wird das Hintergrundprogramm systemd im Kommando berücksichtigt, das den Start von InfluxDB umsetzt. Somit sollte das Kommando für den Start von InfluxDB so aussehen, wie im unten eingeblendeten Code-Snippet demonstriert.


> systemctl start influxdb

InfluxDB konfigurieren

Für die Einstellung jeder Konfigurationsdatei stellt das System interne Standardeinstellungen bereit. Via dem unten gezeigten Command kannst du dir die Einstellungen im nano-Editor ansehen und bei Bedarf editieren.


> nano /etc/influxdb/influxdb.conf

Die meisten Einstellungen in der lokalen Konfigurationsdatei /etc/influxdb/influxdb.conf sind auskommentiert. Alle auskommentierten Einstellungen werden durch die internen Standardeinstellungen bestimmt. Alle unkommentierten Einstellungen in der lokalen Konfigurationsdatei überschreiben die internen Standardeinstellungen. Beachte, dass die lokale Konfigurationsdatei nicht bereits alle Konfigurationseinstellungen enthalten muss.

Bevor du mit InfluxDB arbeiten kannst, also z.B. um (eine) Datenbank(en) anzulegen, zu löschen oder zu editieren oder Daten zu analysieren, musst du InfluxDB einmalig mit deiner Konfigurationsdatei starten.
Hierbei gibt es zwei Möglichkeiten:

1. Richte den Prozess mit der Option -config auf die richtige Konfigurationsdatei aus.


> influxd -config /etc/influxdb/influxdb.conf


 8888888           .d888 888                   8888888b.  888888b.
   888            d88P"  888                   888  "Y88b 888  "88b
   888            888    888                   888    888 888  .88P
   888   88888b.  888888 888 888  888 888  888 888    888 8888888K.
   888   888 "88b 888    888 888  888  Y8bd8P' 888    888 888  "Y88b
   888   888  888 888    888 888  888   X88K   888    888 888    888
   888   888  888 888    888 Y88b 888 .d8""8b. 888  .d88P 888   d88P
 8888888 888  888 888    888  "Y88888 888  888 8888888P"  8888888P"

2018-04-04T23:03:51.641110Z	info	InfluxDB starting	{"log_id": "07GjHMMG000", "version": "1.5.1", "branch": "1.5", "commit": "cdae4ccde4c67c3390d8ae8a1a06bd3b4cdce5c5"}
2018-04-04T23:03:51.641142Z	info	Go runtime	{"log_id": "07GjHMMG000", "version": "go1.9.2", "maxprocs": 4}
run: open server: listen: listen tcp 127.0.0.1:8088: bind: address already in use

2. Setze die Umgebungsvariable INFLUXDB_CONFIG_PATH in Relation zu dem Pfad deiner Konfigurationsdatei und starte den Prozess.


> echo $INFLUXDB_CONFIG_PATH /etc/influxdb/influxdb.conf

> influxd


 8888888           .d888 888                   8888888b.  888888b.
   888            d88P"  888                   888  "Y88b 888  "88b
   888            888    888                   888    888 888  .88P
   888   88888b.  888888 888 888  888 888  888 888    888 8888888K.
   888   888 "88b 888    888 888  888  Y8bd8P' 888    888 888  "Y88b
   888   888  888 888    888 888  888   X88K   888    888 888    888
   888   888  888 888    888 Y88b 888 .d8""8b. 888  .d88P 888   d88P
 8888888 888  888 888    888  "Y88888 888  888 8888888P"  8888888P"

2018-04-04T23:43:31.184743Z	info	InfluxDB starting	{"log_id": "07GlYaS0000", "version": "1.5.1", "branch": "1.5", "commit": "cdae4ccde4c67c3390d8ae8a1a06bd3b4cdce5c5"}
2018-04-04T23:43:31.184777Z	info	Go runtime	{"log_id": "07GlYaS0000", "version": "go1.9.2", "maxprocs": 4}
run: open server: listen: listen tcp 127.0.0.1:8088: bind: address already in use

InfluxDB funktioniert so, dass zunächst die Konfiguration über die Option -config überprüft wird und im Anschluss daran die über die Umgebungsvariable.
Des Weiteren musst du sicherstellen, dass die Verzeichnisse, in denen Daten und das Write Ahead-Protokoll (WAL) gespeichert sind, für dich schreibbar sind, bevor du den InfluxDB-Dienst ausführst. Sprich, du musst du prüfen, ob diese Verzeichnisse existieren. Für den Fall, dass die Daten- und WAL-Verzeichnisse nicht beschreibbar sind, wird der InfluxdDB-Service nämlich nicht gestartet. Beide sollten im Verzeichnis /var/lib/influxdb liegen. Im Terminal kannst du dir die darin befindlichen Verzeichnisse mit den beiden folgenden Kommandos anzeigen lassen und somit deren Beschreibbarkeit garantieren.


> cd /var/lib/influxdb

> ls

In InfluxDB eine Datenbank anlegen, nutzen oder löschen

Um mit InfluxDB zu arbeiten, kannst du die influx-Befehlszeilenschnittstelle (CLI) nutzen, die in allen InfluxDB-Paketen enthalten ist und eine leichte und einfache Möglichkeit bietet, mit der Datenbank zu interagieren. Die CLI kommuniziert direkt mit InfluxDB, indem standardmäßig Anfragen an die InfluxDB-HTTP-API über Port 8086 gestellt werden. Daher stellt Influx standardmäßig eine Verbindung zu Port 8086 und localhost her. Wenn du diese Standardwerte ändern musst, führe den Command influx –help im Terminal aus.
Schließlich kannst du die CLI über den influx-Command – wie ich es dir im Code-Block unten zeige – starten und somit eine Verbindung zur lokalen InfluxDB-Instanz herstellen. Am daraufhin generierten Output kannst du erkennen, dass der korrekte Port 8086 angetriggert worden ist und auch die Version der InfluxDB wird dir angezeigt.
In meinem Beispiel nutze ich zusätzlich zum influx-Command das Argument -precision. Dieses gibt das Format/die Genauigkeit von zurückgegebenen Zeitstempeln an. Im obigen Beispiel teilt das Attribut rfc3339 InfluxDB mit, dass Zeitstempel im RFC3339-Format zurückgegeben werden sollen, was wiederum dem Format YYYY-MM-DDTHH:MM:SS.nnnnnnnnnZ entspricht.


> influx -precision rfc3339
Connected to http://localhost:8086 version 1.5.x
InfluxDB shell version: 1.5.x

Solltest du Zeitstempel im Format Unix-Epoch bevorzugen, dann sollte hingegen nach -precision ein Element aus der Liste [h, m, s, ms, u, ns] folgen. Zum Beispiel bekommst du Epoch in Stunden, wenn den Command so angibst, wie im Code-Snippet unten veranschaulicht.


> influx -precision s
Connected to http://localhost:8086 version 1.5.x
InfluxDB shell version: 1.5.x

Mittels dem EXIT-Command kannst du die CLI wieder verlassen oder auch jede andere Datenbank, die du in InfluxDB erzeugt hast.
Um eine Datenbank anzulegen, nutzt du den CREATE DATABASE-Command, wie ich dir im Code-Snippet unten veranschauliche, in dem ich die Datenbank OnlineMarketDevelopment anlege.


> CREATE DATABASE OnlineMarketDevelopment

Mittels dem SHOW DATABASES-Command ist es dir möglich, die alle existierenden Datenbanken ausgeben zu lassen.


> SHOW DATABASES
name: databases
name
----
_internal
OnlineMarketDevelopment

Um eine Datenbank hingegen zu löschen, wird der DROP DATABASE-Command genutzt. Hätte ich in der Zwischenzeit noch zusätzlich die Datenbank HumanResources angelegt und würde diese wieder löschen wollen, würde mein Command so aussehen.


> DROP DATABASE HumanResources

Wenn du schließlich eine spezielle Datenbank mit Inhalten füllen, nach Inhalten durchsuchen oder nach Inhalten analysieren willst, dann musst du explizit mit dem USE-Command in die betreffende Datenbank wechseln. Solange du dann nicht den EXIT-Command ausführst, werden alle Operationen lediglich auf die in meinem Beispiel gezeigte Datenbank OnlineMarketDevelopment ausgeübt.


> USE OnlineMarketDevelopment
Using database OnlineMarketDevelopment

Als Hinweis ist noch wichtig, dass du InfluxDB nicht nur über die CLI nutzen kannst, sondern auch direkt über rohe HTTP-Anfragen mittels der curl-Applikation. Im Terminal würde der Befehl für eine Anfrage über einen POST-Request im Endpunkt /query resultieren und dann dem Schema folgen, wie ich es dir im Code-Block unten präsentiere, wobei nach q= jedes Datenbank-Kommando – bis auf den USE-Command ausgeführt werden kann, das ich bereits in den oben gezeigten Code-Snippets über die CLI durchgeführt habe und XXX sozusagen als Platzhalter zu interpretieren ist.


> curl -i -XPOST http://localhost:8086/query --data-urlencode "q=XXX"

Angewendet auf den DROP-Command, würde die Kommandozeile als rohe HTTP-Anfrage dann so aussehen, wie du dem Code-BLock unten entnimmst.


> curl -i -XPOST http://localhost:8086/query --data-urlencode "q=DROP DATABASE HumanResources"

HTTP/1.1 200 OK
Content-Type: application/json
Request-Id: c53a00b6-3caa-11e8-8018-000000000000
X-Influxdb-Build: OSS
X-Influxdb-Version: 1.5.1
X-Request-Id: c53a00b6-3caa-11e8-8018-000000000000
Date: Tue, 10 Apr 2018 10:34:38 GMT
Transfer-Encoding: chunked

{"results":[{"statement_id":0}]}

In InfluxDB eine Datenbank mit Inhalten füllen und nach Inhalten durchsuchen

Nachdem wir gemeinsam die Datenbank OnlineMarketDevelopment erstellt und uns mittels dem USE-Command Zugang zu dieser verschafft haben, ist InfluxDB bereit, Anfragen und Schreibvorgänge in dieser zu akzeptieren.
Den Datenspeicher in InfluxDB darfst du dir so vorstellen, dass die Daten nach Zeitreihen gegliedert sind, sodass sie eine zeitabhängige Folge von Datenpunkten bilden. Die Datenpunkte wiederum beziehen sich auf eine Messung. Im Sinne des von mir vorgestellten Anwendungsszenarios könnte das z.B. die Messung mit der Bezeichnung SalesActivity sein. Zeitreihen können null bis viele Datenpunkte haben, wobei jeder Datenpunkt für eine Stichprobe der Metrik steht. Datenpunkte bestehen aus der Zeit (ein Punkt ist zu verstehen als ein Zeitstempel), mindestens einem Feld-Schlüssel-Wert-Paar (dem hinter der Messung SalesActivity stehenden Werten selbst, z. B. age=52i und buying=FALSE) und Null oder vielen Tag-Schlüssel-Wert-Paaren, die Metadaten zum Messwert enthalten (z. B. gender=“male“ region=“EMEA“ und dc=“koeln“). EMEA als Wert des Feld-Schlüssels region stünde dann für den Wirtschaftsraum Europa, Naher Osten und Afrika.
Im Hinblick auf die Integration in der Datenbank-Plattform kann man sich eine Messung konzeptionell als eine SQL-Tabelle vorstellen, bei der der Primärindex, bzw. Primärschlüssel immer die Zeit in Form des Zeitstempels ist. Tags und Felder sind als Spalten in der Tabelle zu verstehen. Tags werden indiziert und Felder nicht. Nullwerte werden nicht gespeichert.
Punkte werden in InfluxDB unter Verwendung des Leitungsprotokolls geschrieben. Das Format gleicht dem, das du dem im Code-Block unten integrierten Muster entnimmst, wobei die in ()-Klammern stehenden Bezeichnungen als Platzhalter zu interpretieren sind und die []-Klammern lediglich zur Wahrung der Übersichtlichkeit innerhalb der Syntax dienen. Es ist aus dem Muster im Code-Snippet unten gut ersichtlich wie die Tag-Schlüssel-Wert-Paare von den Feld-Schlüssel-Wert-Paaren bei der Zuordnung zur Messung kenntlich gemacht werden. Wenn nach der Messung ein Komma folgt, dann ist mindestens ein Tag vorhanden. Solltest du allerdings kein(e) Tag-Schlüssel-Wert-Paar(e) verwenden, dann folgt nach der Messung – lediglich getrennt durch ein Leerzeichen – unmittelbar das/die Feld-Schlüssel-Wert-Paar(e). Allgemein folgt das erste Feld-Schlüssel-Wert-Paar nie auf ein Komma. Sowohl die Tag-Schlüssel-Wert-Paare als auch die Feld-Schlüssel-Wert-Paare werden – sobald es sich um mehr als eins handelt – durch Komma gelistet. Hier musst du darauf achten, dass dazwischen keine Leerzeichen stehen, da es ansonsten zu einer Fehlermeldung kommt.


*Messung*[,(Tag-Schlüssel)=(Tag-Wert),...] (Feld-Schlüssel)=(Feld-Wert)[,(Feld2-Schlüssel)=(Feld2-Wert),...][Unix-Nanosekunden-Zeitstempel]

In der Tabelle unten findest du alle Parameter dieser Syntax gelistet im Zusammenhang mit deren Bedarf, deren Bedeutung und Datentyp.

Element der Syntax

optional vs. erforderlich

Bedeutung

Datentyp

Messung

erforderlich

Name der Messung. Entspricht konzeptionell einem Namen, den man einer SQL-Tabelle geben würde.

Beim INSERT eines Datensatzes wird – gemäß der Syntax – eine Messung pro Datenpunkt akzeptiert.

String

Tag-Sammlung

optional

Alle Tag-Schlüssel-Wert-Paare des Datenpunktes.

Sowohl Schlüssel als auch Werte werden jeweils als String integriert.

Feld-Sammlung

erforderlich

> Ein Datenpunkt muss mindestens einem Feld zugeordnet werden können.

Alle Feld-Schlüssel-Wert-Paare des Datenpunktes.

Feld-Schlüssel werden jeweils als String eingebunden und Feld-Werte jeweils als String, Integer, Float oder Boolean.

Zeitstempel

optional

> Falls dieser nicht beim INSERT des Datensatzes gesetzt wird und somit nicht im Datenpunkt enthalten ist, verwendet InfluxDB den lokalen Nanosekunden-Zeitstempel des Servers in UTC.

Beim INSERT eines Datensatzes wird – gemäß der Syntax – ein Zeitstempel pro Datenpunkt akzeptiert.

Unix-Nanosekunden-Zeitstempel

Wenn du den Datentyp Boolean für bestimmte Feld-Werte nutzen möchtest, dann beachte, dass sowohl TRUE als auch FALSE in InfluxDB auf unterschiedliche Weise interpretiert werden können. Die unten stehende Tabelle gibt dir einen schnellen Überblick zu den Möglichkeiten der Boolean-Syntax. Hieraus entnimmst du, dass beim Schreiben von Datenpunkten (via INSERT-Operation) jeweils zwei Schreibweisen mehr für die beiden Boolean-Werte genutzt werden können als beim Lesen von Datenpunkten (z.B. via SELECT-Statement). Diese beiden jeweils für TRUE und FALSE zusätzlich nutzbaren Schreibweisen werden beim Lesen von Datenpunkten zwar als entsprechender Boolean-Wert interpretiert, aber sind lediglich über die in der Spalte ganz rechts aufgeführten Schreibweisen erreichbar.

Boolean

akzeptierte Schreibweisen in InfluxDB bei INSERT-Operationen

akzeptierte Schreibweisen in InfluxDB bei SELECT-Operationen

TRUE

t, T, true, True oder TRUE

true, True oder TRUE

FALSE

f, F, false, False, FALSE

false, False, FALSE

Die bereits aus SQL bekannte INSERT-Operation wird auch bei InfluxDB genutzt, um in eine Messung bzw. in eine konzeptionelle SQL-Tabelle Datenpunkte einzubinden. Dem unten eingeblendeten Code-Snippet kannst du nachempfinden, wie solch ein INSERT angewendet auf die Messung SalesActivity aussehen kann. In dem von mir über die CLI durchgeführten INSERT-BeIspiel setze ich den Zeitstempel des Datenpunktes selbst, nämlich im Epoch-Format in Sekunden. Wenn man den jeweils zu einem integrierten Datenpunkt gehörenden Zeitstempel nicht implementiert, wird er in InfluxDB automatisch auf Basis der aktuellen Zeit gesetzt. Im Hinblick auf Zahlen, also Zahlen, die dem Datentyp INTEGER angehören, solltest du berücksichtigen, dass bei ihrer Implementierung ein i suffigiert werden muss, da sie ansonsten als Gleitkommazahl interpretiert werden. Diese Konvention gilt allerdings nur für ganze Zahlen. Gleitkommazahlen, also Zahlen, die dem Datentyp FLOAT angehören, sind davon nicht betroffen und werden in der Datenbank direkt als solche erkannt. In der Datenbank sind die Werte für ganze Zahlen dann als ganze Zahlen gespeichert, ohne das nachfolgende i. Es spielt – wie gesagt – lediglich bei der Implementierung eine Rolle. Im Code-Snippet unten heißt es dann für das Feld age nicht age=52, sondern age=52i. Zudem solltest du die Konvention beibehalten, dass du in einem INSERT alle als Datentyp STRING vorgesehenen Werte in Anführungszeichen setzt, um sie explizit als solche von anderen Datentypen differenzierbar zu machen. Würdest du dies nicht tun, also wären alle Werte nicht in Anführungszeichen gesetzt, würde auch zwangsläufig der Feld-Wert in age=52i als String „52i“ erkannt werden und nicht als Zahl 52i. Folglich müsste der komplette INSERT so aussehen, wie im Code-Block unten demonstriert.


> INSERT SalesActivity,region="EMEA",dc="koeln",gender="male" age=52i,buying=FALSE 1523962800

Auch das Schreiben von Daten – also auch die INSERT-Operation ist via rohen HTTP-Anfragen möglich. Hierbei mündet der POST-Request allerdings nicht im Endpunkt /query, sondern im Endpunkt /write. Und hier wird der in der CLI anwendbare USE-Command nicht ausgeführt, sondern bereits direkt im Anschluss an den Endpunkt /write via ?db= angetriggert. In der HTTP-Anfrage unten könnte ich den Zeitstempel auch selbst setzen, aber ich tue dies nicht, sodass er automatisch in InfluxDB vergeben wird.


> curl -i -XPOST 'http://localhost:8086/write?db=OnlineMarketDevelopment' --data-binary 'SalesActivity,region="EMEA",dc="koeln",gender="male" age=52i,buying=FALSE'

HTTP/1.1 200 Ok
Content-Type: application/json
Request-Id: 3afe35d0-3c14-11e8-8048-000000000000
X-Influxdb-Build: OSS
X-Influxdb-Version: 1.5.1
X-Request-Id: 3afe35d0-3c14-11e8-8048-000000000000
Date: Mon, 09 Apr 2018 16:37:02 GMT

Über die CLI kannst du dir dann mittels dem SELECT-Statement Datensätze wiedergeben lassen. Es funktioniert genauso, wie bei einer SQL-Abfrage. Nach dem SELECT werden die Spalten gelistet, deren Inhalte gefunden werden sollen, mittels dem FROM wird die Verortung der Spalten angetriggert, was konzeptionell der betreffenden SQL-Tabelle entsprechen würde und in InfluxDB der betreffenden Messung SalesActivity. Wäre die Messung SalesActivity bereits mit vielen Datenpunkten gefüllt, könntest du zusätzlich noch die WHERE-Bedingung einsetzen, um die Treffermenge zu spezifizieren.


> SELECT "region", "gender", "age", "dc", "buying" FROM "SalesActivity"
name: SalesActivity
time       region gender age dc      buying
----       ------ ------ --- --      ------
1523962800 "EMEA" "male" 52  "koeln" false

Würdest du für das SELECT die rohe HTTP-Anfrage nutzen, sähe das Kommando so aus, wie unten im Code-Block zu entnehmen. Nun stellst du eine GET-Request an den /query-Endpunkt, legst den URL-Parameter db als Zieldatenbank fest, und bettest deine Anfrage in q= ein.


curl -GET 'http://localhost:8086/query?pretty=true' --data-urlencode 'db=OnlineMarketDevelopment' --data-urlencode 'q=SELECT "region", "gender", "age", "dc", "buying" FROM "SalesActivity"'
{
    "results": [
        {
            "statement_id": 0,
            "series": [
                {
                    "name": "SalesActivity",
                    "columns": [
                        "time",
                        "region",
                        "gender",
                        "age",
                        "dc",
                        "buying"
                    ],
                    "values": [
                        [
                            "2018-04-17T13:00:00Z",
                            ""EMEA"",
                            ""male"",
                            52,
                            ""koeln"",
                            false
                        ],
                    ]
                }
            ]
        }
    ]
}

Wie du bereits weißt, werden Zeitstempel in InfluxDB standardmäßig in RFC3339 UTC zurückgegeben und haben eine Genauigkeit im Nanosekundenbereich. Wenn du Zeitstempel im Format Unix-Epoch verwenden möchtest, dann binde zusätzlich in deine Anfrage den Parameter epoch=”x” gefolgt von –data-urlencode ein, wobei x ein Platzhalter ist, den du mit einem Element aus der Liste [h, m, s, ms, u, ns] festlegen musst. Zum Beispiel bekommst du Epoch in Sekunden, wenn dein Command so aussieht, wie im Code-Snippet unten präsentiert.


curl -GET 'http://localhost:8086/query?pretty=true' --data-urlencode 'db=OnlineMarketDevelopment' --data-urlencode 'epoch=s' --data-urlencode 'q=SELECT "region", "gender", "age", "dc", "buying" FROM "SalesActivity"'
{
    "results": [
        {
            "statement_id": 0,
            "series": [
                {
                    "name": "SalesActivity",
                    "columns": [
                        "time",
                        "region",
                        "gender",
                        "age",
                        "dc",
                        "buying"
                    ],
                    "values": [
                        [
                            1523962800,
                            ""EMEA"",
                            ""male"",
                            52,
                            ""koeln"",
                            false
                        ]
                    ]
                }
            ]
        }
    ]
}

Nachdem ich dir im Kontext des zu Beginn des Tutorials vorgestellten Anwendungsszenarios gezeigt habe, wie du eine Datenbank in InfluxDB erstellst und diese mit Messungen und dazugehörenden Datenpunkten befüllst, widme ich mich nun schließlich dem Teil des Anwendungsszenarios, in dem es um die visuelle Aufbereitung und dem Monitoring integrierter Datensätze geht. Hierzu werde ich Chronograf verwenden, das wiederum – neben InfluxDB – Bestandteil eines Stacks ist. Die beschriebene Fortsetzung des Anwendungsszenarios wird dir – wie bereits zu Beginn des Tutorials erwähnt – in unserem Tutorial zum Thema InfluxDB – Monitoring mit dem TICK-Stack bereitgestellt. Grafana ist ein weiteres Tool zum Plotten und Monitoring deiner Daten. Auch hierzu biete ich dir ein Tutorial an, in dem ich das eingeführte Anwendungsszenario umsetze, nämlich im Tutorial InfluxDB – Monitoring mit dem TIG-Stack.

Fazit

Du hast nun einen Einblick bekommen, wie sich Zeitreihen basierte Datenspeicherung und -auswertung mittels InfluxDB umsetzen und mit den damit in Verbindung stehenden Stack-Komponenten managen lässt. Dieses Tutorial hat dir sowohl eine solide Basis für das Verständnis über die Datenbank-Plattform InfluxDB sowie deren Installation und Einrichtung geschaffen, als auch einen Ausblick auf die Nutzung ihrer Features geboten. Du bist fähig, die gelernten Inhalte anzuwenden, im besten Fall für spannende Projekte – sei es für den Beruf, für die Schule, Lehre, Universität oder private Zwecke – auszuweiten und in die Möglichkeiten, die dir InfluxDB bietet, hineinzuwachsen. Ich wünsche dir gutes Gelingen und vor allem aber auch viel Spaß bei der Arbeit mit InfluxDB.

Aus unserer Rubrik zu Open Source Datenbanken und Datenbank-Plattformen auch noch interessant und hilfreich:

Zurück zur Tutorial Übersicht Back to Tutorial Overview