Archive

Wie installiere ich ein Tech4Hosting Theme für WordPress?

Hinweis: Um ein Tech4Hosting Theme zu installeren, benötigen Sie das Tech4Hosting Parent Plugin. Folgen Sie der Anleitung, wenn Sie das Plugin noch nicht installiert haben.

Wie installiere ich das Tech4Hosting Plugin?

Wir haben unsere beliebtesten Homepage-Baukasten Templates zu WordPress Themes konvertiert. Die Themes erleichtern es Ihnen, direkt mit Ihrer WordPress Seite zu starten.

  1. Loggen Sie sich in Ihre WordPress Administration ein.
  2. Klicken Sie auf den Tech4Hosting Plugin Bereich.
  3. Bewegen Sie die Maus über das Theme, welches Sie wünschen und klicken Sie auf Installieren.
  4. Bewegen Sie die Maus erneut über das Theme und klicken Sie auf Aktivieren.

Hinweis: Sobald ein Tech4Hosting Theme installiert ist, können Sie es auch unter Design > Themes in der WordPress Administration finden.

The Tech4Hosting plugin allows you to choose from our custom made WordPress themes


Demo Daten Importieren

Sie können Demo Daten in Ihr Theme importieren und es noch leichter machen, mit Ihrer Seite zu starten. Demo Daten bestehen aus Seiten mit Beispiel Inhalten wie Text und Bildern.

Wenn Sie Ihre Seite bearbeiten, ersetzen Sie einfach die Demo Daten mit Ihrem eigenen Text und Bildern.

  1. In Ihrer WordPress Administration, klicken Sie auf den Titel Ihres Themes, in diesem Beispiel „Heisengard“.
  2. Klicken Sie auf Demo Daten Importieren
  3. Sobald der Import abgeschlossen ist, klicken Sie auf Änderungen Speichern.

Import demo data to your theme to make it easier to get started

Hinweis: Wenn Sie zuvor bereits andere Demo Daten für ein anderes Theme importiert haben, müssen Sie diese zunächst manuell entfernen. Dies können Sie unter Seiten in der WordPress Administration tun.


Verwandte Artikel:

1-click WordPress mit Tech4Hosting verwenden
Ändern Sie Ihr WordPress Theme in der Datenbank

Wie installiere ich das Tech4Hosting Plugin?

Schritt 1 – Tech4Hosting Plugin herunterladen
Schritt 2 – Loggen Sie sich in Ihren WordPress Adminbereich ein
Schritt 3 – Gehen Sie zu Plugins
Schritt 4- Klicken Sie auf Installieren
Schritt 5 – Klicken Sie auf Plugin hochladen
Schritt 6 – Installieren Sie das Tech4Hosting Plugin
Schritt 7 – Aktivieren Sie das Plugin
Schritt 8- Fertig!

Das Tech4Hosting Plugin gibt Ihnen die Möglichkeit, Tech4Hosting Themes und Plugins in Ihrer WordPress Seite zu installieren.

Falls Sie eine neue 1-Click Installation machen, ist dieses Plugin automatisch installiert. Diese Anleitung zeigt Ihnen, wie man das Plugin zu Ihrer bestehenden WordPress Installation hinzufügt.


Schritt 1 – Tech4Hosting Plugin herunterladen

Laden Sie das Tech4Hosting Plugin auf Ihren Computer herunter. Es heißt Tech4Hosting Themes and Plugins.


Schritt 2 – Loggen Sie sich in Ihren WordPress Adminbereich ein

Loggen Sie sich in Ihren WordPress Adminbereich ein.

Enter your username and password to log in


Schritt 3 – Gehen Sie zu Plugins

Gehen Sie zu Plugins, im Menü auf der linken Seite.

Once you are logged in click plugins in the menu to the left


Schritt 4- Klicken Sie auf Installieren

Klicken Sie auf Installieren, oben auf dem Bildschirm.

Click Add New in the top left corner


Schritt 5 – Klicken Sie auf Plugin hochladen

Klicken Sie auf Plugin hochladen, oben auf dem Bildschirm.

Click Upload Plugin in the top left corner


Schritt 6 – Installieren Sie das Tech4Hosting Plugin

  1. Klicken Sie auf Browse und finden Sie die Datei, die Sie gerade heruntergeladen haben. Diese heißt „onecom-themes-plugins.zip“.
  2. Klicken Sie auf Jetzt installieren, um das Tech4Hosting Plugin zu installieren.

Select the file on your computer and click Install Now


Schritt 7 – Aktivieren Sie das Plugin

Nachdem das Plugin erfolgreich installiert wurde, klicken Sie auf Aktiviere dieses Plugin, um es zu aktivieren.

Your plugin is installed


Schritt 8- Fertig!

Fertig! Tech4Hosting Themes und Plugins wurde nun installiert und aktiviert. Klicken Sie auf Tech4Hosting im Menü auf der linken Seite, um Tech4Hosting Themes oder das Webshop Plugin zu installieren.

The Tech4Hosting themes and plugins plugin has now been activated


Verwandte Artikel:

Was ist das Tech4Hosting Plugin?
1-click WordPress mit Tech4Hosting verwenden

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

Wie lösche ich eine 1-click WordPress Installation?

Schritt 1 – Gehen Sie zu WordPress in Ihrem Kontrollpanel
Schritt 2 – Löschen Sie WordPress von Ihrem Webspace
Schritt 3 – Löschen Sie die Tabellen in Ihrer Datenbank

Wir empfehlen, WordPress Installationen, die Sie nicht mehr benötigen, zu löschen. Alte WordPress Installationen werden oftmals vergessen und nicht mehr aktualisiert. Dies macht sie zu einem leichten Opfer für Hacker.


Schritt 1 – Gehen Sie zu WordPress im Kontrollpanel auf Tech4Hosting

Loggen Sie sich ins Tech4Hosting-Kontrollpanel ein und klicken sie auf die Kachel WordPress.

wordpress-tile.png


Schritt 2 – Löschen Sie WordPress von Ihrem Webspace

  1. Klicken Sie auf Blog löschen.
  2. Geben Sie Ihr Kontrollpanel Passwort ein.
  3. Klicken Sie auf Löschen.

delete-wordpress.png


Schritt 3 – Löschen Sie die WordPress-Tabellen in Ihrer Datenbank

Nachdem Sie WordPress von Ihrem Webspace entfernt haben, müssen Sie es auch aus Ihrer Datenbank löschen. Hierfür haben wir eine separate Anleitung.

Wie lösche ich Tabellen aus meiner Datenbank?

Verwandte Artikel:

1-click WordPress mit Tech4Hosting verwenden
Was ist das Tech4Hosting Plugin?

Deaktivieren Sie WordPress Plugins in phpMyAdmin

Schritt 1 – Öffnen Sie Ihre Datenbank in phpMyAdmin
Schritt 2 – Klicken Sie auf wp_options
Schritt 3 – Finden Sie die Plugins
Schritt 4 – Deaktivieren Sie die Plugins

Normalerweise verwalten Sie Ihre WordPress Plugins im Adminbereich. Manchmal kann es allerdings nützlich sein die Plugins im phpMyAdmin zu deaktivieren, z.Bsp. wenn Sie Probleme mit Ihrer WordPress Seite haben und sich nicht einloggen können.

Das Deaktivieren der Plugins entfernt diese nicht von Ihrer WordPress Installation. Sie können diese wieder in Ihrem Adminberiech aktivieren.


Schritt 1 – Öffnen Sie Ihre Datenbank in phpMyAdmin

Lesen Sie unseren Guide, wie Sie auf Ihre Datenbank zugreifen können, falls Sie nicht wissen wie man dies macht.


Schritt 2 – Klicken Sie auf wp_options

In Menü auf der linken Seite, klicken Sie auf wp_options, um die „Options“- Tabelle zu öffnen.

Hinweis: Die Tabelle kann verschiedene Präfixe haben, hier ist es www_. Falls Sie die 1-Click Installation nutzen, ist der Präfix normalerweise der Speicherort Ihrer WordPress Seite.

Click wp-options in phpMyAdmin


Schritt 3 – Finden Sie die Plugins

Finden Sie die Zeile mit Namen active_plugins. Diese finden Sie normalerweise auf Seite 2 in der „Options“- Tabelle.

Disable plugins in wp-options


Schritt 4 – Deaktivieren Sie die Plugins

  1. Klicken Sie auf das Feld in der Spalte option_value neben active_plugins
  2. Entfernen Sie den gesamten Inhalt und klicken Sie auf Enter um dies zu speichern.

Ihre Plugins sind nun deaktiviert.
Falls dies das Problem nicht gelöst hat, können Sie versuchen Ihr WordPress Theme manuell zu ändern

Plugins disabled succesfully


Verwandte Artikel:

Ändern Sie Ihr WordPress Passwort in der Datenbank
Ändern Sie Ihr WordPress Theme in der Datenbank

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', '[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

Ändern Sie Ihr WordPress Theme in der Datenbank

Schritt 1 – Öffnen Sie Ihre Datenbank in phpMyAdmin
Schritt 2 – Klicken Sie auf wp_options
Schritt 3 – Finden Sie das Theme in der Tabelle
Schritt 4 – Ersetzen Sie das Theme
Schritt 5 – Sie sind fertig!

Normalerweise verwalten Sie Ihre WordPress Themes im Adminbereich. Manchmal ist dies allerdings nicht möglich, z.Bsp. wenn Sie einen weißen Bildschirm nach einem Update bekommen und sich nicht einloggen können.

Sie können dies lösen, indem Sie statt Ihres aktuellen Themes ein Standard-Theme aus der Datenbank benutzen. Danach können Sie sich wieder in Ihren Adminbereich einloggen und Ihre Seite von dort aus verwalten.

Ein Standard-Theme ist das Theme, das aktiv war, als Sie WordPress erstmalig installiert hatten, z.Bsp. Twentysixteen.


Schritt 1 – Öffnen Sie Ihre Datenbank in phpMyAdmin

Lesen Sie unseren Guide, wie Sie auf Ihre Datenbank zugreifen können, falls Sie nicht wissen wie man dies macht.


Schritt 2 – Klicken Sie auf wp_options

Im Menü auf der linken Seite, klicken Sie auf wp_options, um die „Options“- Tabelle zu öffnen.

Hinweis: Die Tabelle kann verschiedene Präfixe haben, hier ist es www_. Falls Sie die 1-Click Installation nutzen, ist der Präfix normalerweise der Speicherort Ihrer WordPress Seite.

Click wp-options in phpMyAdmin


Schritt 3 – Finden Sie das Theme in der Tabelle

Finden Sie die Zeilen mit Namen template und stylesheet. Diese finden Sie normalerweise auf Seite 2 in der „Options“- Tabelle.

Change template and stylesheet


Schritt 4 – Ersetzen Sie das Theme

  1. Klicken Sie auf das Feld in der Spalte option_value neben template
  2. Ersetzen Sie das jetzige Theme mit einem Standard-Theme, wie twentysixteen.
  3. Klicken Sie Enter um dies zu speichern.
  4. Wiederholen Sie diesen Vorgang für stylesheet.

Changed template WordPress


Schritt 5 – Sie sind fertig!

Das Theme wurde nun geändert und Ihre Webseite ist wieder zugänglich und Sie können sich in Ihren WordPress Adminbereich einloggen.

Falls dies das Problem nicht gelöst hat, können Sie versuchen Ihre WordPress Plugins manuell zu deaktivieren.


Verwandte Artikel:

Ändern Sie Ihr WordPress Passwort in der Datenbank
Deaktivieren Sie WordPress Plugins in phpMyAdmin

Webshop in WordPress benutzen

Schritt 1 – Loggen Sie sich bei WordPress ein
Schritt 2 – Installieren Sie das Tech4Hosting Webshop Plugin
Schritt 3 – Finden Sie die Einstellungen des Webshop Plugins
Schritt 4 – Generieren Sie einen Shortcode
Schritt 5 – Fügen Sie den Shortcode auf ihrer Seite ein
Schritt 6 – Seite ansehen

Sie können Ihren Webshop in Ihre WordPress Seite mit dem Tech4Hosting Webshop Plugin integrieren. Mit dieser Anleitung zeigen wir Ihnen, wo Sie das Plugin finden und wie Sie es auf einer Ihrer Seiten integrieren können.

Note: Before you can install the „Tech4Hosting Webshop“ plugin, you need to install the Tech4Hosting parent plugin called „Tech4Hosting themes and plugins“.

If you don’t have this plugin installed and activated, please do this first. You can follow the guide below.

Wie installiere ich das Tech4Hosting Plugin?

Schritt 1 – Loggen Sie sich bei WordPress ein

Loggen Sie sich bei WordPress ein. Sie haben WordPress noch nicht installiert? Folgen Sie unserer Installationsanleitung.

1-click WordPress mit Tech4Hosting verwenden

Enter your username and password to log in


Schritt 2 – Installieren Sie das Tech4Hosting Webshop Plugin

  1. Klicken Sie in Ihrer WordPress Administration auf Tech4Hosting in der oberen linken Ecke.
  2. Gehen Sie in den Bereich Tech4Hosting plugins.
  3. Klicken Sie im Webshop Plugin auf Installieren (Install now).
  4. Als nächstes klicken Sie auf Aktivieren (Activate) um das Plugin zu aktivieren.

Click the the Webshop plugin to install and then Activate.


Schritt 3 – Finden Sie die Einstellungen des Webshop Plugins

  1. In Ihrer WordPress Administration klicken Sie auf Webshop in dem Menü auf der linken Seite.
  2. Klicken Sie Shortcode erhalten.

Hinweis: Sie verwalten Ihre Produkte und Bestellungen des Webshops in Ihrem Tech4Hosting Kontrollpanel. Klicken Sie auf Zu Produkten & Bestellungen zu dieser Seite zu gelangen.

Go to settings in the Webshop plugin and click get the shortcode


Schritt 4 – Generieren Sie einen Shortcode

  1. Gleichen Sie ihre Einstellungen nach eigenem Belieben an. Der Shortcode gibt alle Änderungen wieder, die Sie durchführen.
  2. Wenn Sie fertig sind, klicken Sie auf Code kopieren(Copy code).

Adjust the settings to your liking and click Copy code


Schritt 5 – Fügen Sie den Shortcode auf ihrer Seite ein

  1. Klicken Sie auf (Seiten) Pages im linken Menü.
  2. Bearbeiten Sie die Seite, auf der der Webshop erscheinen soll, und klicken Sie Hinzufügen (Add new) um einen neue Seite zu erstellen.
  3. Fügen Sie den Shortcode in den Editor ein.
  4. Klicken Sie auf Aktualisieren (Update), um Ihre Änderungen zu speichern.

Paste the shortcode in the editor for the page you want the webshop to appear


Schritt 6 – Seite ansehen

Klicken Sie auf Seite ansehen (View page) um Ihren Shop online auf ihrer Webseite zu sehen.

You can now see your webshop in your WordPress site


Verwandte Artikel:

CSS Parameter für den Webshop
HTML Parameter zum Einbetten des Webshops