Zunächst habe ich ein Maven-Projekt erstellt und den MySQL-Treiber sowie Liquibase eingebunden:

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.17</version>
</dependency>
<dependency>
	<groupId>org.liquibase</groupId>
	<artifactId>liquibase-core</artifactId>
	<version>2.0.1</version>
</dependency>

Danach habe ich zu Testzwecken ein sehr einfach gestricktes Changeset unter src/main/resources/changelog.xml angelegt:

<?xml version="1.0" encoding="UTF-8"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
	http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
	<changeSet id="1" author="patrick">
		<createTable tableName="kontakt">
			<column name="id" type="int">
				<constraints primaryKey="true" nullable="false" />
			</column>
			<column name="vorname" type="varchar(32)">
				<constraints nullable="false" />
			</column>
			<column name="nachname" type="varchar(32)">
				<constraints nullable="false" />
			</column>
		</createTable>
	</changeSet>
</databaseChangeLog>

Zum Ausführen des Changesets habe ich dann folgende Klasse implementiert:

package de.techspread.liquibase;

import java.sql.Connection;
import java.sql.DriverManager;

import liquibase.Liquibase;
import liquibase.database.core.MySQLDatabase;
import liquibase.database.jvm.JdbcConnection;
import liquibase.resource.ClassLoaderResourceAccessor;

public final class Main {

	private String driver    = "com.mysql.jdbc.Driver";
	private String url       = "jdbc:mysql://localhost/liquibase";
	private String username  = "benutzername";
	private String password  = "passwort";
	private String changelog = "changelog.xml";			

	public static void main(String[] args) throws Exception {
		new Main();
	}

	public Main() throws Exception {
		Class.forName(driver);
		Connection connection = DriverManager.getConnection(url, username, password);
		JdbcConnection jdbcConnection = new JdbcConnection(connection);
		MySQLDatabase databaseConnection = new MySQLDatabase();
		databaseConnection.setConnection(jdbcConnection);
		Liquibase liquibase = new Liquibase(changelog, new ClassLoaderResourceAccessor(), databaseConnection);
		liquibase.update(null);
	}

}

Bevor man das Changeset ausführen kann, muss natürlich die Datenbank und ggf. einen entsprechender Benutzer eingerichtet werden.

Beim Start der Anwendung führt Liquibase nun die gewünschten Änderungen an der Datenbank durch (in diesem Fall wird eine Tabelle angelegt). Zusätzlich legt Liquibase eine eigene Tabelle an, in der sich Liquibase das aktuelle Changeset merkt.

Konfiguriert man nun weitere Changesets, bringt Liquibase die Datenbank beim nächsten Start der Anwendung auf den aktuellsten Stand. Damit gehören unnachvollziehbare Änderungen an der Datenbank der Vergangenheit an.

Sollte ein Datenbank-Update fehlschlagen, können zudem auch Rollback-Einträge definiert werden. Weiteres erfahrt ihr natürlich auf der Projektwebseite, ich möchte hier keine vollständige Dokumentation hinlegen

MySQL-Datenbank sichern

MySQL-Datenbanken sichert man am Besten mit dem Kommandozeilen-Tool mysqldump, welches standardmäßig mit dem MySQL-Server mitinstalliert wird. Die Syntax zur Sicherung einer Datenbank lautet wie folgt:

mysqldump -u<Benutzername> -p<Passwort> <Datenbank> > <SQL-Datei>

Beispiel:

mysqldump –uroot –pgeheim techspread > /backup/techspread.sql

Natürlich bietet der mysqldump Befehl noch etliche weitere Parameter, in den meisten Fällen ist diese Variante jedoch vollkommen ausreichend.

MySQL-Datenbank wiederherstellen

Die Syntax zum Wiederherstellen der Datenbank lautet wie folgt:

mysql -u<Benutzername> –p<Passwort> <Datenbank> < <SQL-Datei>

Beispiel:

mysql –uroot –pgeheim techspread < /backup/techspread.sql

MySQL-Datenbank via Netzwerk sichern

Wer noch einen Schritt weiter gehen möchte, kann auch MySQL-Server per Netzwerk/Internet sichern. Dazu muss dem mysqldump-Befehl lediglich ein weiterer Parameter mit auf den Weg gegeben werden. Der angegebene Benutzer muss natürlich auch Zugriff via Netzwerk erhalten (was in der Standardeinstellung nicht der Fall ist):

mysqldump -h <Server> -u<Benutzername> -p<Passwort> <Datenbank> > <SQL-Datei>

Beispiel:

mysqldump -h techspread.de -uroot -pgeheim techspread > /backup/techspread.sql

MySQL-Backup-Script

Damit man sich nicht manuell um die Sicherung jeder einzelnen Datenbank kümmern muss, habe ich folgendes Script geschrieben:

#! /bin/bash

BACKUPDIR=<Sicherungsordner>
USERNAME=<Benutzername>
PASSWORD=<Passwort>

if [ -d $BACKUPDIR ];
then
	rm -r $BACKUPDIR
fi

mkdir $BACKUPDIR
cd $BACKUPDIR

DATABASES=`mysql -u$USERNAME -p$PASSWORD -Bse 'show databases'`
for DATABASE in $DATABASES;
do
	if [ "$DATABASE" != "information_schema" ];
	then
		mysqldump -u$USERNAME -p$PASSWORD $DATABASE > ${DATABASE}.sql
	fi
done

Schlussbemerkung

Auf Basis der vorgestellten Befehle und dem Script kann man sich noch weitaus mächtigere Scripte schreiben. So habe ich das Script auf Arbeit so eingerichtet, dass man über Parameter an das Script das Sicherungsverzeichnis, den Server, den Benutzernamen und das Passwort übergibt. Dadurch kann man komfortabel eine zentrale Sicherung für mehrere MySQL-Server einrichten.

root-Rechte verschaffen

Also setzen wir uns nun einen eigenen lokalen Webserver mit Mac OS Bordmitteln auf. Verschaffe dir zunächst einmal root-Rechte im Terminal:

sudo -i

Webserver konfigurieren

Danach wechselst du in den Konfigurationsordner des Apache-Webservers…

cd /etc/apache2

… und öffnest die Haupkonfigurationsdatei des Webservers:

nano httpd.conf

Entferne erst einmal das Rautezeichen vor der folgenden Zeile, damit das PHP-Modul mitgeladen wird:

#LoadModule php5_module        libexec/apache2/libphp5.so

Für die Entwicklung empfiehlt sich die Vergabe voller Zugriffsrechte. Ändere dazu den <Directory>-Block wie folgt ab:

<Directory />
   Options FollowSymLinks
   AllowOverride All
   Order allow,deny
   Allow from all
</Directory>

Der DirectoryIndex-Eintrag muss noch um die Datei index.php erweitert werden:

DirectoryIndex index.html index.php

Damit du virtuelle Hosts (vhosts) anlegen kannst,  entfernst du das Rautezeichen vor der Zeile

#Include /private/etc/apache2/extra/httpd-vhosts.conf

und erstellst auch gleich deinen ersten vhost-Eintrag. Öffne dazu die Konfigurationsdatei für vhosts

nano extra/httpd-vhosts.conf

und kommentiere beide voreingestellten vhosts mit Rautezeichen aus. Füge dann folgenden Eintrag an das Ende hinzu:

<VirtualHost *:80>
   ServerName <Projekt>
   DocumentRoot "/Users/<Benutzer>/Sites/<Projekt>"
</VirtualHost>

Ersetze hierbei <Projekt> durch den Namen deines Webprojektes und <Benutzer> durch deinen Benutzernamen. Jetzt fügst du noch einen Eintrag zum Ende der Datei /etc/hosts hinzu:

echo "127.0.0.1 <Projekt>" >> /etc/hosts

<Projekt> muss hierbei wieder durch den Namen deines Projektes ersetzt werden. Dieser Eintrag muss unbedingt mit dem ServerName-Eintrag in der letzten editierten Datei übereinstimmen. Für jedes weitere Projekt musst du die letzten beiden Schritte wiederholen und den Webserver neustarten:

apachectl restart

Bei mir kommt immer eine Warnung, der Webserver startet trotzdem neu.

PHP einrichten

Jetzt richtest du erst einmal PHP ein. Kopiere dazu die Vorlage für die PHP-Konfigurationsvorlage und öffne diese in einem Editor:

cp /etc/php.ini.default /etc/php.ini
nano /etc/php.ini

Zum Entwickeln lohnt es sich, alle Fehler auszugeben. Passe also die Einstellung für error_reporting wie folgt an:

error_reporting = E_ALL

Schalte dann die Fehlerausgabe an:

display_errors = On

Danach aktivierst du noch ein paar gängige PHP-Module (entferne das Semikolon am Anfang der Zeile):

extension=php_curl.dll
extension=php_gd2.dll
extension=php_mbstring.dll
extension=php_mysql.dll
extension=php_mysqli.dll
extension=php_pdo_mysql.dll
extension=php_xmlrpc.dll

Gleich unter dem Extension-Block stellst du die richtige Zeitzone ein:

date.timezone = Europe/Berlin

Jetzt müssen noch die Angaben für den MySQL-Socket angepasst werden, da diese auf einen falschen Pfad verweisen:

pdo_mysql.default_socket = /tmp/mysql.sock
mysql.default_socket = /tmp/mysql.sock
mysqli.default_socket = /tmp/mysql.sock

Jetzt ist ein Neustart des Webservers fällig:

apachectl restart

MySQL-Server installieren

Lade dir nun den MySQL-Server als 32-Bit dmg-Datei herunter und installiere alle drei Dateien aus dem Paket. Starte den Server dann über den Eintrag in den Systemeinstellungen. Der Server wird ohne root-Passwort installiert, sodass du nun erst einmal ein Passwort vergeben solltest:

/usr/local/mysql/bin/mysql -uroot
UPDATE mysql.user SET Password=PASSWORD('<Passwort>') WHERE User='root';
FLUSH PRIVILEGES;
quit;

Statt <Passwort> setzt du natürlich dein Passwort ein. Noch einmal den MySQL-Server über die Systemeinstellungen neustarten und dein lokaler Webserver ist fertig gestellt.

Vorteile

Viele Vorteile ergeben sich aus dem Fakt, dass Informationen (Artikel, Texte etc) zusammen in einer Datenbank abgespeichert werden. Dadurch können Bilder nicht ohne weiteres einfach verwaisen und es wird die Integrität der Daten vereinfacht. Metadaten können ebenfalls problemlos mit den Bildern verknüpft werden.

Die Speicherung in einer Datenbanken bringt aber auch noch andere Vorteile mit sich. So können sehr schnell und einfach Load-Balancing-Systeme auf Datenbank-Ebene eingeführt werden. Eine Portierung von einem System auf ein anderes ist ebenfalls sehr einfach, da einfach ein Backup der Datenbank erstellt und auf einen anderen Server übertragen werden kann – die Anwendung ist dann sofort wieder einsatzbereit.

Auch ist die Rechteverwaltung innerhalb einer Datenbank leichter umzusetzen, als auf Dateisystem-Ebene.

Es ergeben sich sicherlich noch weitere Vorteile, die mir auf die schnelle nicht eingefallen sind

Nachteile

Das Auslesen von Bildern aus einer Datenbank ist im Gegensatz zu einem direkten Zugriff auf das Dateisystem deutlich langsamer, da zunächst immer die Datenbankabfrage abgefragt werden muss. Zudem kann ein Browser die Bilder nicht ohne weiteres zwischenspeichern, da der Webserver nicht erkennen kann, ob das Bild seit dem letzten Besuch verändert wurde. Die Backup-Strategie muss auch angepasst werden, da Bilder in Datenbanken als BLOBs (Binary Large Objects) abgelegt werden. Dadurch ist es nicht mehr so einfach möglich, textbasierte, inkrementelle Sicherungen zu erstellen.

Diese Nachteile können jedoch durch intelligente Lösungen drastisch reduziert werden. So kann man z.B. per PHP-Script überprüfen, ob sich das Bild in der Datenbank verändert hat und entsprechende Header zurückgeben. Für die Datenbank-Sicherung kann z.B. ein Point-in-Time Recovery verwendet werden.

PHP-Beispiel

Nachdem ich nun die Vor- und Nachteile erläutert habe, stelle ich ein simple Lösung vor, um Bilder per PHP in eine Datenbank zu bringen und wieder auszulesen. Diese Lösung ist wirklich minimalistisch und kann sollte um Überprüfungen und weitere Funktionalitäten erweitert werden.

Zunächst einmal muss eine entsprechende Datenbank angelegt werden:

CREATE DATABASE imagedb;
CREATE TABLE imagedb.images (
	id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
	image BLOB NOT NULL,
	mimetype VARCHAR(32) NOT NULL
);

Nachdem die Datenbank angelegt wurde, erstellst du eine Datei namens connect.php, in der die MySQL-Verbindungsdaten hinterlegt werden und auch gleich die Verbindung zur Datenbank aufgebaut wird:

<?php
	// MySQL-Verbindungsdaten
	$hostname = 'localhost';
	$database = 'imagedb';
	$username = 'Dein DB-Benutzer';
	$password = 'Dein DB-Password';

	// MYSQL-Verbindung herstellen
	mysql_connect($hostname, $username, $password) or die(mysql_error());
	mysql_select_db($database) or die(mysql_error());
?>

Danach legst du die Datei index.php an, die für das Hochladen und Anzeigen der Bilder verantwortlich ist:

<?php
	// MySQL-Verbindung herstellen
	require 'connect.php';

	// Formular abgeschickt
	if(isset($_FILES['image'])) {

		// Datei hochgeladen
		if(is_uploaded_file($_FILES['image']['tmp_name'])) {

			// Verweis auf Bild
			$image = $_FILES['image']['tmp_name'];

			// Vorbereiten für den Upload in DB
			$data = addslashes(file_get_contents($image));

			// Metadaten auslesen
			$meta = getimagesize($image);
			$mime = $meta['mime'];

			// Bild in DB speichern
			mysql_query("INSERT INTO images VALUES('', '$data', '$mime')");
		}
	}
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="de" lang="de">
	<head>
		<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
		<title>MySQL-Bilder-Datenbank</title>
	</head>
	<body>
		<h1>Bild hochladen</h1>
		<form action="" method="post" enctype="multipart/form-data">
			<input name="image" type="file" />
			<input type="submit" value="hochladen" />
		</form>
		<h1>Bilderliste</h1>
		<?php
			$result = mysql_query("SELECT id FROM images");
			while($row = mysql_fetch_object($result)) {
				echo '<img alt="" src="image.php?id='.$row->id.'" /><br />';
			}
		?>
	</body>
</html>

Zuletzt wird die Datei image.php benötigt, die sich um das Auslesen der Bilder aus der Datenbank kümmert:

<?php
	// MySQL-Verbindung herstellen
	require 'connect.php';

	// Bild ausgeben
	$id = addslashed($_GET['id']);
	$result = mysql_query("SELECT image, mimetype FROM images WHERE id='$id'");
	$row = mysql_fetch_object($result);
	header("Content-type: $row->mimetype");
	echo $row->image;
?>

Um die Datenbank zu testen, musste ich zunächst bc auf meinem System nachinstallieren:

aptitude install bc

Danach habe ich das Script heruntergeladen, ausführbar gemacht und dann natürlich ausgeführt:

wget http://www.day32.com/MySQL/tuning-primer.sh
chmod +x tuning-primer.sh
./tuning-primer.sh

Nach Auswählen des Sockets und der Eingabe der Benutzerdaten vergleicht das Script die derzeitige MySQL-Konfiguration mit Laufzeit-Daten des MySQL-Servers. Der MySQL-Server sollte also am Besten schon einige Zeit im Betrieb gewesen sein, bevor man dieses Script zur Performance-Optimierung heranzieht. Auf Basis dieses Vergleichs schlägt das Script Verbesserungen vor, welche in der MySQL-Konfigurationsdatei – für gewöhlich my.cnf – vorgenommen werden können.

Da sich die Anforderungen an die Datenbank ständig ändern können, sollte man dieses Script immer mal wieder nutzen, um eine bestmögliche Performance erzielen zu können.

Zunächst einmal musst du phpMyAdmin aufrufen. Auf der linken Seite wählst du dann die entsprechende Datenbank aus. Oben findest du dann den Menüpunkt Exportieren. Die Voreinstellungen für die Datensicherung sind eigentlich immer vollkommen in Ordnung, sodass man unten rechts einfach auf OK klicken muss, um die SQL-Datei dann abspeichern zu können.

Das Backup kann man auch ehr einfach wieder einspielen. Dazu wählst du die Datenbank aus und löschst zunächst alle Tabellen aus dieser. Danach gehst du oben auf Importieren, wählst die zuvor gespeicherte SQL-Datei aus und klickst unten rechts auf OK. Nach kurzer Zeit solltest du eine Bestätigung über den erfolgreichen Import erhalten. Das Löschen aller Tabellen ist deshalb nötig, da du sonst ggf. alle Datensätze doppelt in der Datenbank haben würdest, was ja unerwünscht ist.

Falls du noch Fragen zu der Datensicherung haben solltest, frag lieber dreimal nach, statt am Ende deine Daten in das Datennirvana zu schicken!

P.S.: Wer seine Datenbanken lieber über die Kommandozeile sichert, sollte sich meinen Artikel MySQL-Datensicherung “Best Practice” anschauen.

Pakete herunterladen

Zunächst einmal musst du folgende Pakete herunterladen:

• Apache Webserver
  Win32 Binary including OpenSSL
• MySQL-Server
  in der Essentials-Version, nach Klick auf Download unten auf » No thanks, just take me to the downloads! drücken
• PHP
  unbedingt VC6 x86 Non  Thread Safe / Installer

mysql -u<Benutzername> -p<Passwort> -e "USE wordpress; DELETE FROM wp_posts WHERE post_type = 'revision';"

Die Lösung dafür ist mehr als einfach. Sicherlich habt ihr schonmal ein LIMIT wie im folgenden Beispiel benutzt:

SELECT * FROM <Tabelle> LIMIT 10;

Dieses Statement sorgt dafür, dass euch die ersten 10 Reihen der entsprechenden Tabelle ausgegeben werden. Möchte man allerdings nur ganz bestimmte Zeilen ausgeben, verwendet man eine andere LIMIT-Syntax:

SELECT * FROM <Tabelle> LIMIT <offset>,<length>

Möchte man nun zum Beispiel nur die Reihen 13 bis 16 ausgeben, lautet das Statement wie folgt:

SELECT * FROM <Tabelle> LIMIT 12,4

Zunächst fährst du den MySQL-Server herunter. Danach startest du den MySQL-Server so neu, dass er keine Authentifizierungsdaten abfragt:

mysqld --skip-grant-tables

Danach verbindest du dich zum MySQL-Server:

mysql

Nun kannst du schnell das Passwort zurücksetzen:

UPDATE mysql.user SET Password=PASSWORD('<Dein Passwort>') WHERE User='root';
FLUSH PRIVILEGES;

Bei der ersten Zeile musst du natürlich <Dein Passwort> durch das neu zu vergebende Passwort ersetzen. Danach stoppst du den MySQL-Dienst wieder und startest ihn wie gewohnt neu. Nun kannst du dich mit dem neu vergebenen Passwort am Server anmelden.

Diese Methode ist zwar nicht die sicherste, aber bei weitem die einfachste. Im Zweifelsfall findest du auf der Seite How to Reset the Root Password aus der MySQL-Dokumentation noch andere sicherere Methoden, um das Root Password zu ändern.