“tar zxvf squid-3.0.STABLE24.tar.gz”

entpackt und wir wechseln durch Eingabe von

“cd /usr/local/squid-3.0.STABLE24″

in das soeben frisch entpackte Verzeichnis. Wie gewohnt, müssen wir nun den Squid-Server auf die Bedürfnisse unseres Systems zuschneiden und das geht über das bekannte “configure”-Skript, wobei wir dieser Installationsroutine den ein oder anderen individuellen Parameter übergeben. Wer eine genauere Übersicht der Befehle sucht, kann die wie üblich über Eingabe des Befehls

“./configure –help”

im Quellverzeichnis finden und – die wie üblich erschlagende Anzahl von Optionen – genauer nachlesen. Erstellen wir also gemäss dem folgenden Beispiel (die Bedeutungen der einzelnen Schalter sind grösstenteils selbsterklärend bzw. können in der Hilfe des Konfigurationsskriptes nachgelesen werden) unser Makefile:

“./configure –prefix=/usr/local/squid –enable-icmp –enable-useragent-log –enable-referer-log –enable-ssl –enable-default-err-language=German –enable-linux-netfilter”

Wie bereits gewohnt sollten diverse Abhängigkeiten (openSSL) im System bereits erfüllt werden, da es sonst zum Abbruch des Skriptes samt passender Fehlermeldung kommt. Nun wenden wir uns per Eingabe von

“make all”

dem eigentlichen Kompilierungsvorgang zu, der ebenfalls problemlos durchlaufen sollte und uns im Falle eines Fehlers wieder entsprechend informiert. Installiert werden dann die neuen Binärdateien durch Eingabe von

“make install”

an ihren Zielort im System kopiert. Der eigentliche Installationsvorgang ist nun abgeschlossen. Vor dem erstmaligen Starten des Proxy-Servers sollte sich aber ein jeder noch der Konfigurationsdatei “squid.conf” im Verzeichnis /usr/local/squid/etc widmen, in dem unter anderem der Benutzer und die Gruppe, unter denen der Cache-Dämon laufen soll, anzupassen sind. In meinem Fall habe ich durch Eingabe der Befehle

“groupadd squid” und
“useradd squid -g squid”

den Benutzer “squid” und die Gruppe “squid” angelegt, wobei der User logischerweise auch Mitglied dieser Gruppe ist. Diese Benutzer- und Gruppenkonfiguration ist in der mir vorliegenden Datei in Zeile 2935 (“cache_effective_user”) und 2955 (“cache_effective_group”) zu finden. Sobald dies geändert wurde, müssen wir noch die Benutzerrechte auf das Cache- und Logverzeichnis durch Eingabe von

“chown squid.squid /usr/local/squid/var -R”

ändern, da diese Verzeichnisse ja noch vom aktuellen Root-Benutzer erstellt wurden und der Squid-Dämon ja nicht als Root läuft bzw. laufen sollte! Auch das PID-File, das ja den Status darüber liefert, ob der Cache läuft oder nicht, kann in Zeile 2006 (“pid_filename”) der squid.conf noch vom störenden “Lattenkreuz” befreit und somit aktiviert werden.

Schlussendlich erfolgt nun noch das Initialisieren des eigentlichen Cacheverzeichnisses, welches noch durch Eingabe von

“/usr/local/squid/sbin/squid -z”

einmalig geschieht. Dies sollte nach den vorherigen Anpassungen ohne Probleme erfolgen und uns somit einen funktionsfähigen und grundeingerichteten Proxyserver bescheren, welcher durch Eingabe von

“/usr/local/squid/sbin/squid”

zu starten ist. Trägt man dann im Browser die IP des Linux-Servers samt Proxy-Port (in meinem Falle die 192.168.15.5, Port 3128) ein und surft auf die ein oder andere Seite, sollte der Squid bereits diese Inhalte cachen. Final können wir dies verfolgen, indem wir einfach ein Echzeitmonitoring auf die Logdatei “access.log” durch Eingabe des Befehls

“tail -f /usr/local/squid/var/logs/access.log”

durchführen – voila, unsere gecachten Dokumente sind in diesem Logfile schon zu finden, was letztendlich heisst: Der Proxyserver funktioniert – ein Beispielscreenshot ist hier zu sehen:

Wie bereits von meinen Tutorials gewohnt, ist auch dies nur ein kleiner Einstieg in die Funktionsweise einer selbstkompilierten Linux-Software, denn ob nun selbstkompiliert oder direkt via “apt-get” oder “rpm” installiert, es gilt immer: Die letztendliche Konfiguration übernimmt immer noch der Benutzer bzw. der Administrator – und wie immer gibt es auch viele unzählige Optionen, die dem einen wichtig, dem anderen eher unwichtig erscheinen, daher rate ich an dieser Stelle auch: Zieht die Dokumentation der Software zu Rate und passt Euch das Produkt gezielt auf Eure Bedürfnisse an, es lohnt sich!

Bei Fragen, Anmerkungen oder Ergänzungen nutzt bitte die Kommentarfunktion oder das Kontaktformular auf dieser Webseite!

Grundlegend hat GreenSQL vier Betriebsmodi, die sich wie folgt aufschlüsseln und bereits viel über die Einsatzzwecke- und Möglichkieten der Software offenbaren:

• Simulations-Modus (Intrusion Detection System)
• Sperre verdächtiger Abfragen (Intrusion Prevention System)
• Lern-Modus
• Datenbank-Firewall

Auf die einzelnen Funktionen gehe ich an dieser Stelle nur stichpunktartig ein, da das Kompilieren und die damit verbundene grundsätzliche Funktion von GreenSQL im Vordergrund stehen, die Anwendungsebene bleibt dann dem Benutzer selbst überlassen, nachdem er dieses Tutorial durchgearbeitet hat.

Wie bei bisherigen Tutorials dieser Art haben wir grundsätzlich die Auswahl zwischen vorkompilierten und distributionsspezifischen RPM-Dateien oder aber dem Quellcode, den ich aus Gründen der eigenen Systemanpassung – sofern möglich – stets vorziehe. Die einzelnen Pakete können vorab unter http://www.greensql.net/download heruntergeladen werden, eine Registrierung ist nicht erforderlich (hilft den Autoren aber sicherlich!) und kann auf Wunsch durch Klicken auf die Option “Skip Registration” übersprungen werden.

Gehen wir also vom aktuellen Quellcode aus, so führt dieser Link zum Ziel. Wie üblich speichern wir das Archiv unter /usr/local und entpacken dies durch Eingabe von

“tar zxvf greensql-fw-1.2.2.tar.gz”.

Anschliessend wechseln wir durch Eingabe von

“cd /usr/local/greensql-fw-1.2.2″

in das just entpackte Verzeichnis  und werfen den Kompilierungsvorgang durch schlichte Eingabe des Befehls

“./build.sh”

an.

Werden jetzt diverse Fehler ausgegeben, so fehlen der Applikation diverse Bibliotheken – in meinem Fall (Testsystem: openSUSE 11.2) waren das die Komponenten “flex”, “bison”, “postgresql-develop”, “pcre-devel”, “libmysqlclient-devel” und “libevent-devel”. Diese schlüsselt die Installationsroutine wunderbar auf und nachdem diese nachinstalliert wurden, sollte auch der “make”-Befehl – sprich: Der eigentliche Kompilierungsvorgang – problemlos durchlaufen. Nun haben wir auf unserem Zielsystem ein neues RPM, wie zum Beispiel unter /usr/src/packages/RPMS/i586/greensql-fw-1.2.2-1.i586.rpm.

Dieses Paket lässt sich nun durch Eingabe von

“rpm -i /usr/src/packages/RPMS/i586/greensql-fw-1.2.2-1.i586.rpm”

installieren – nun teilt uns das frisch installierte Paket mit, das wir die Konfigurationsroutine unter

“/usr/sbin/greensql-config”

ausführen müssen, um die finale Anpassung des Programms an die eigene Betriebsumgebung zu beenden. Das ist ganz einfach, da die Routine alle benötigten Informationen in einem gewohnten Dialog abfragt, die benötige MySQL-Datenbank samt Benutzer anlegt und die GreenSQL-Konfigurationsdatei “greensql.conf” im Verzeichnis /etc/greensql erstellt.

Nachdem auch dieser Schritt abgeschlossen ist, können wir GreenSQL per Eingabe von

“/etc/init.d/greensql-fw start”

starten – der Startvorgang sollte problemlos vonstatten gehen – überprüfen lässt sich dies freilich in der Logdatei /var/log/greensql.log.

Um nun das Webinterface für die Verwaltung von GreenSQL in Eurer Apache-Webserverkonfiguration zu aktivieren, müsst Ihr am Ende der httpd.conf den folgenden Eintrag einfügen

“Include /etc/greensql/greensql-apache.conf”

sowie in besagter Datei die Einträge

<IfModule mod_alias.c>
Alias /greensql “/usr/share/greensql-fw”
</IfModule>

aktivieren – sprich: Die Raute (“Lattenkreuz”) vor diesen drei Zeilen löschen. Dann gilt es noch, der Anwendung volle Schreibrechte in das Cacheverzeichnis zu geben – dies geschieht durch Eingabe von

“chmod 0777 /usr/share/greensql-fw/templates_c”.

Voila, nun könnt Ihr Euch über Euren Browser (http://<IPEuresSystems>/greensql) auf der Konfigurationsoberfläche von GreenSQL einloggen und anfangen, mit dieser Lösung zu arbeiten. Die Standardlogindaten (soweit nicht von Euch während des Konfigurationsvorganges geändert) sind “admin” mit dem Kennwort “pwd” – nach dem ersten erfolgreichen Einloggen finde ich es – sofern noch nicht geschehen – obligatorisch, diese Daten dringendst zu ändern – aber das versteht sich ja von selbst, oder?

Letztendlich gilt es dann nur noch, anstatt Eures normalen Datenbankservers mit Port 3306 (Standard) die IP und den Port (3305) des Rechners, auf dem GreenSQL läuft, anzugeben und schon ist Eure SQL-Firewallapplikation (Stichwort: “Proxying”) aktiv. Die weitere Konfiguration der Anwendung überlasse ich nun – wo das Programm an sich problemlos funktioniert – einmal Euch, denn hier würde ich in diesem installationsfokussierten Tutorial ein, zwei Schritte zu tief in den anwenderspezifischen Bereich eindringen – wer mehr dazu wissen möchte, möge mir entweder per Kommentarfunktion oder Kontaktformular ein Feedback geben oder aber die Ressourcen auf der Herstellerhomepage zu Rate ziehen!

“tar zxvf webmin-1.500.tar.gz”

entpackt.

Wechselt nun in das Verzeichnis “/usr/local/webmin-1.500″ und startet das Setup-Skript durch Eingabe von

“./setup.sh”.

Das Skript leitet Euch nun Schritt für Schritt durch die Installation – Pfadangaben (Webmin-Verzeichnis und Verzeoichnis für die Logdateien) können bei Bedarf angepasst werden, ein Druck auf die <ENTER>-Taste übernimmt die jeweilige Voreinstellung und springt zum nächsten Punkt. Wichtig ist, das der Perl-Interpreter installiert ist – ist er das nicht, zeigt Euch das Installationskript dies entsprechend an und Perl muss vor einem erneuten Aufruf des Setup-Skripts erst einmal installiert werden.

Interessant sind speziell die Fragen nach dem Webserver-Port, auf dem der Webmin läuft ((Standard: 10000) als auch der gewünschte Benutzername (Standard: “admin”) und das Kennwort, welches Ihr selbstverständlich eingeben und einmal bestätigen müsst. Auch die Frage, ob Webmin beim Booten des Systems dauerhaft gestartet werden soll (und das macht Sinn, wie ich finde!) sollte mit “y” (“yes”) beantwortet werden.

Dann installiert das Installationskript die Webmin-Umgebung in die von Euch ausgewählten Pfadnamen und nach dem (hoffentlich) erfolgreichen Installationsvorgang ist durch Eingabe von

http://<EuerHost.tld>:10000

der Webmin zu erreichen. Nutzt die eben festgelegten Anmeldedaten und schon könnt Ihr eine der besten und mächtigsten GUI-Oberflächen zur Verwaltung eines Linux-Betriebssystems nutzen!

Die aktuelle Versionen von Apache (2.2.14) und PHP (5.3.1) können müssen zuerst einmal als Source-Paket von den Herstellerseiten (http://httpd.apache.org) bzw. http://www.php.net) heruntergeladen werden, idealerweise ins Verzeichnis “/usr/local” (wobei sich Eure Pfadangaben natürlich entsprechend unterscheiden können, dieses Verzeichnis ist für mich nur schon seit Urzeiten mein Installationsverzeichnis – daher dient es hier als Muster!).

Anschliessend entpacken wir erst einmal den Apache-Quellcode durch Eingabe von

“tar zxvf httpd-2.2.14.tar.gz “.

Anschliessend wechseln wir in das “httpd-2.2.14″-Verzeichnis und generieren wieder das Makefile, sprich: Durch den “./configure”-Befehl passen wir das zu erstellende Apache-Paket an unsere Systemumgebung- und Bedürfnisse an und geben direkt das ein oder andere nützliche Modul mit an – der Beispiel-Befehl würde also in etwa so lauten:

“./configure \
–prefix=/usr/local/apache2 \
–enable-cgi \
–enable-ssl \
–enable-so \
–enable-rewrite \
–enable-mime-magic \
–enable-suexec \
–enable-static-rotatelogs \
–enable-speling”

Der Befehl kann in einer Reihe eingegeben werden, dann fallen natürlich die Backslashes weg, wenn Ihr die Zeilen oben 1:1 in Eure Shell kopiert, sollte das Erstellen des Makefiles auch kein Problem darstellen. Wenn eine Fehlermeldung erscheint (bei mir waren es beispielsweise für die Entwicklung benötigte openSSL-Bibliotheken, die fehlten), sorgt bitte für eine Nachinstallation der gewünschten Pakete und startet den Konfigurationsvorgang erneut. Ist der ohne Fehler durchgelaufen, kann man durch Eingabe von

“make”

wie gewohnt den eigentlichen Kompilierungsvorgang starten. Läuft auch dieser ohne Fehler durch, ist der finale Befehl zum Kopieren und Installieren der Binaries der Befehl

“make install”.

Damit ist der eigentliche Apache-Kompilierungsvorgang abgeschlossen und man kann durch Eingabe von

“/usr/local/apache2/bin/apachectl start”

den Apache-Dämon starten. Ob der funktioniert, lässt sich durch das Ansurfen der IP Eures – nun – Webservers über den Browser Eurer Wahl oder direkt am Server über Eingabe von

“telnet localhost 80″

feststellen – auf jeden Fall sollte eine entsprechende Apache-Startseite (“It works!”) erscheinen und damit liegt die erste Hälfte dieses Tutorials bereits erfolgreich hinter uns – parallel kann man durch Eingabe von

“cp /usr/local/apache2/bin/apachectl /etc/init.d/apache”

das Apache-Startskript schon mal in den Startordner des Systems kopieren, damit beim nächsten Neustart der Apache-Server direkt mitgestartet wird. Diesen Zustand erreicht man durch Eingabe von

“/sbin/chkconfig –add apache”.

Nun geht es weiter mit der PHP-Umgebung, die ebenfalls noch gepackt im Verzeichnis “/usr/local” liegt und durch Eingabe von

“tar zxvf php-5.3.1.tar.gz”

entpackt wird.

Nun gilt es, auch hier das Makefile zu erzeugen, welches durch Eingabe von

“./configure –with-apxs2=/usr/local/apache2/bin/apxs –with-mysql=/usr/local/mysql –prefix=/usr/local/php –with-config-file-path=/usr/local/php –disable-cgi –with-mcrypt”

geschieht. Die einzelnen Optionen für die grundsätzliche Installation sind natürlich optional und stellen folgendes dar:

• “with-apxs2″ :
• “with-mysql” : Angabe des Verzeichnisses, in dem eine ggf. vorhandene MySQL-Installation liegt, damit die Verbindung mit MySQL direkt miteinkompiliert werden kann. Ist noch kein MySQL installiert, diesen Schalter entweder weglassen oder aber MySQL nachinstallieren
• “prefix”: Installationspfad der eigentlichen PHP-Umgebung
• “with-config-file-path”: Dateipfad der PHP-Konfigurationsdatei php.ini
• “disable-cgi”: Stellt sicher, das PHP nicht in einer CGI-Umgebung bzw. in einem CGI-Modus läuft
• “with-mcrypt”: Integration der MCrypt-Bibliothek aus Gründen der Datenverschlüsselung

Auch hier sollte das Makefile dann “vernünftig” erstellt werden, etwaige fehlende Programmbibliotheken (bei mir war es beispielsweise die libxml2-Bibliothek) müssen dann vorab wieder nachinstalliert werden. Läuft das Skript problemlos durch, kann der eigentliche Kompilierungsvorgang auch hier angeworfen werden – wie immer über den Befehl

“make”.

Nach einer Weile (und hoffentlich keinen Fehlern) können die Binärdateien nun via

“make install”

an ihre endgültige Position kopiert werden.

Während dieses Prozesses wird auch das eigentliche PHP5-Modul kopiert und in der Apache-Konfigurationsdatei httpd.conf aktiviert, der Eintrag sollte dort wie folgt aussehen:

“LoadModule php5_module        modules/libphp5.so”

Sollte dies wider Erwarten nicht in der httpd.conf stehen, so muss dieser Eintrag manuell nachgepflegt werden. Diverse PHP-Bibliotheken sollten dann noch (wie es am Ende der Ausgabe des Makefiles steht) durch Eingabe von

“./libtool –finish /usr/local/php-5.3.1/libs”

im Source-Verzeichnis (hier: /usr/local/php-5.3.1) dem System bekannt gemacht werden, bevor wir uns an die letzte Änderung der Apache-Konfigurationsdatei httpd.conf wagen – denn nachdem das PHP5-Modul bereits geladen ist, müssen wir unserem Webserver noch mitteilen, welche Dateiendungen überhaupt mit PHP geparst werden sollen. In meinem Beispiel sind das alle Dateien mit der Endung .php und .html:

“AddType application/x-httpd-php .php .html
AddType application/x-httpd-php-source .phps”

Anschliessend teilen wir der httpd.conf noch mit, das Dateien, die auch “index.php” heissen, als Startseite des Webservers anerkannt werden – der Eintrag für die index.html steht bereits dort drin und muss nur noch wie folgt abgeändert werden:

“<IfModule dir_module>
DirectoryIndex index.html index.php
</IfModule>”

Nun fehlt zum “finalen Glück” noch eine “php.ini”-Datei, die wir durch Eingabe von

“cp /usr/local/php-5.3.1/php.ini-production /usr/local/php/php.ini”

in das beim Kompilierungsvorgang angegebene Zielverzeichnis kopieren.

Nach einem Neustart des Apache-Webservers ist dann die grundlegende Implementation von PHP 5 in Apache abgeschlossen und wir können uns dem finalen Test widmen: Im Dokumentenroot (hier: /usr/local/apache2/htdocs) muss nun eine Datei mit dem Beispielnamen “phpinfo.php” angelegt werden, die nur den folgenden Inhalt enthält:

“<?php phpinfo(); ?>”

Wird nun Euer Webserver via http://linux-vm.pifferi.local/phpinfo.php (dies ist beispielsweise die URL meines Testsystems), müsste eine ausführliche PHP-Infoseite auf dem Bildschirm erscheinen, die besagt, das alles richtig gemacht wurde!

Damit ist auch dieses Tutorial beendet und zusammen mit dem vorherigen MySQL-Tutorial solltet Ihr nun eine ideale Entwicklungs- oder (je nach Anpassung) Produktivumgebung für Euer System besitzen. Wie immer gilt auch hier: Die einzelnen Schalter & Optionen des “configure”-Befehls sind sowohl bei Apache als auch bei PHP nahezu unendlich und für jeden Bedarf zugeschnitten – man muss nur lesen. Diese Anleitung soll nur der erste Schritt sein, um mit diesen wundervollen Softwarekomponenten arbeiten zu können und ich würde mich wie immer über Feedback jeglicher Art freuen!

Es ist also an der Zeit, sich einmal intensiver mit dem Thema “MySQL” beschäftigten und nachdem ich im Laufe der letzten Jahre verschiedene Distributionen mit vorkompilierten Binaries getestet habe, kam irgendwann der Zeitpunkt, wo ich MySQL speziell an mein System anpassen und auch nicht mehr mit der mitgelieferten Version Vorlieb nehmen wollte.

Fazit : Der Quellcode musste her, ein wenig Wissen musste angelesen werden und als Resultat erhielt ich letztendlich dann die speziell auf mein jeweiliges System angepasste Version von MySQL.

Als erstes sollte sich der geneigte Linux-User daher das Source-Package von http://www.mysql.com besorgen, im Falle dieses Workshops hieß die aktuelle Version “mysql-5.1.42.tar.gz” und stellte den blanken Sourcecode dar. Dieser ist mit dem Kommando

“tar zxvf mysql-5.1.42.tar.gz”

zu entpacken.

Wechselt nun in das neu enstandene Verzeichnis “mysql-5.1.42.tar.gz”. Nun muß erstmal der Standard-MySQL-User und die Standardgruppe angelegt werden. Dies geschieht durch Eingabe der folgenden Kommandos :

“groupadd mysql” und
“useradd -g mysql mysql”

Anschließend müsst Ihr erst einmal das “Configure”-Skript ablaufen lassen, das Eure Systemumgebung prüft und aus dem Ergebnis das Makefile generiert. Werden hier Fehler ausgegeben, müssen über die jeweiligen Paketmanager oder manuell die fehlenden Module- bzw. Bibliotheken nachinstalliert werden. Wollt Ihr Eure MySQL-Version also beispielsweise unter “/usr/local/mysql” installieren, so gilt folgende Eingabe :

“./configure –prefix=/usr/local/mysql”

Dies sollte im Normalfall (von dem ich jetzt hier einfach einmal ausgehe) problemlos vonstatten gehen (meine Tests fanden bei älteren MySQL-Distributionen unter anderem auf Debian 2.1, Red Hat 6.2 & 7.0 sowie SuSE 7.2, alle Versuche, den aktuellen 5′er Stamm der Open Source-Datenbank zu erstellen unter SuSE  11.2 statt), weswegen ihr anschließend das eigentliche Kompilieren in Angriff nehmen könnt. Tippt also

“make” und
“make install”

und fertig sind eure eigenen, selbstkompilierten MySQL-Binaries – vorausgesetzt, Compiler und die notwendigen Bibliotheken sind installiert. Falls nicht, gilt auch hier: Nachinstallieren!

Ihr könnt nun die MySQL-Standarddatenbank, in der unter anderem die Benutzer verwaltet werden, durch die Eingabe von

“scripts/mysql_install_db”

erstellen.

Nun müssen noch die jeweiligen Benutzerrechte auf das “mysql”-Verzeichnis und die darunterliegenden Pfade gesetzt werden. Dies geschieht durch die folgenden Befehle :

“chown -R root /usr/local/mysql”,
“chown -R mysql /usr/local/mysql/var” und
“chgrp -R mysql /usr/local/mysql”.

Nun sind wir fast am Ende – als vorletzten Punkt müssen wir nur noch ein Standard-Konfigurationsfile in das “/etc”-Verzeichnis unseres Linux-Systems kopieren. Als Standard nimmt man die vordefinierte Konfigurationsdatei “my-medium.cnf”, die für ziemlich alle Plattformen den besten Kompromiss bietet. Natürlich stehen für langsamere oder auch High-End-Rechner ebenfalls Musterkonfiguration zur Verfügung, aber wir wählen auf unserem Testsystem (Core2Duo-CPU 2,53 GHz, 4 GB RAM) einfach mal die Medium-Datei. Gebt also folgendes Kommando ein, während ihr euch noch im Sourcepfad befindet :

“cp support-files/my-medium.cnf /etc/my.cnf”

Damit habt ihr die Hürde der ersten eigenen MySQL-Installation bereits genommen. Startet nun “euer” Werk durch Eingabe von

“/usr/local/mysql/bin/mysqld_safe –user=mysql &”

und die Datenbank läuft. Wollt ihr es euch dann noch ganz einfach machen, kopiert die die Datei “mysql.server.sh” in euer “/etc/init.d”-Verzeichnis

(“cp support-files/mysql.server.sh /etc/init.d/mysql”),

paßt sie gegebenenfalls an Euer System an und macht das Skript durch die Eingabe von

“chmod +x /etc/init.d/mysql”

ausführbar.

Anschliessend teilen wir dem System mit, das in den Standardrunleveln 2, 3, 4 und 5 das MySQL-Startskript abgearbeitet werden soll. Das geschieht einmalig durch Eingabe des Befehls

“/sbin/chkconfig -add mysql”.

Nun wird euer MySQL-Dämon bei jedem Neustart des Systems automatisch mitgestartet, sofern Ihr die oben genannte Datei noch per Editor (vi etc.) in den Variablen “basedir” und “datadir” wie folgt anpasst (angelehnt an unsere Standardinstallationspfade):

“basedir=/usr/local/mysql
datadir=/usr/local/mysql/var”

Was nun noch geändert werden sollte, nachdem der Dämon läuft ist – selbstverständlich – das leere Standardkennwort für den MySQL-Root-Benutzer. Dies geschieht durch Eingabe von

“/usr/local/mysql/bin/mysql -u root -p”

Nach Drücken der “Enter”-Taste (schliesslich ist das aktuelle Kennwort eigentlich noch gar keins) befindet Ihr Euch dann auf der MySQL-Konsole. Nun kann durch Eingabe des Befehls

“set password=password(“neues passwort”);”

das neue Kennwort (bitte entsprechend und selbstverständlich den Tag “neues passwort” ersetzen!) gesetzt werden. Durch die Eingabe des Befehls “exit” gelangt Ihr dann wieder auf die Linux-Shell.

So, ich denke mal, das sollte für den ersten Einstieg in die Installation einer MySQL-Datenbank gereicht haben und ich hoffe, das dieser Workshop auch einigermaßen verständlich aufgebaut ist – falls nicht, bin ich immer für irgendwelche Verbesserungsvorschläge, Fragen, Anregungen aber auch Kritik immer empfänglich ! Denkt immer dran, das dies ein kleiner Schritt in das Kompilieren von MySQL-Binaries ist und erst einmal eine funktionsfähige Datenbankstruktur liefert. Wer mehr benötigt, kann den anfänglichen “configure”-Befehl entsprechend anpassen und so all die Module einkompilieren, die in diesem Standard-Tutorial aus Zeit- und Platzgründen unerwähnt blieben.

Die hier angegeben Pfade müssen sich natürlich nicht mit euren Einstellungen decken und wenn ihr zum Beispiel alle Binärdateien oder Datenbanken in andere Verzeichnisse installieren wollt, empfehle ich die Option

“./configure -help” ,

wo wirklich jede kleinste Option für eure persönliche Installation genauestens dokumentiert ist. Als kleine Notiz am Rande sei angemerkt, das dieses Tutorial in dieser Form bereits seit MySQL 3.23.42 besteht, sich über all die Monate und Jahre in der eigentlichen Grundinstallationsroutine keine nennenswerten Änderungen ergeben haben – zumindest nicht für die blanke Grundinstallation!

Zuguterletzt hier noch die URL’s zu zwei Tools, mit denen sich die Verwaltung eurer MySQL-Datenbank zu einem Kinderspiel entwickelt :

Webmin : http://www.webmin.com

phpMyAdmin : http://www.phpmyadmin.net

Wie so oft stand vor dem glücklichen Ergebnis eine Menge Arbeit und Schweiß, die sich hier durch das Wälzen diverser Dokumentationen und Fallbeispiele ausdrückten – mit einem am Ende mehr als zufriedenstellenden Ergebnis!

Getestet wurden diese Dokumentation auf SuSE-Linux-Systemen der Versionen 9.0 und 9.1, im Großen und Ganzen ist dieses Tutorial aber auch portierbar auf alle anderen Distributionen und Plattformen, auch wenn unter Umständen Pfadangaben etc. ein wenig abweichen können! Selbstverständlich wird auch der Mailserver, über den relayed wird, von User zu User verschieden sein, in dem hier vorliegenden Fall gehen wir immer vom Mailserver Eurer Domain (smtp.<euredomain.tld>) aus!

Um zum Punkt (und dem Grund dieses Tutorials zu kommen), fangen wir an dieser Stelle einfach mal mit der Konfigurationsarbeit an sich an – editiert also mit dem Editor Eurer Wahl die Datei “/etc/postfix/main.cf” und fügt der eigentlichen Konfigurationsdatei die folgenden Zeilen zu :

# SMTP-Authentifikation
# Nutzung von SMTP mit SASL-Authentifikation
smtp_sasl_auth_enable = yes

# Notwendige Paßwörter stehen im unten angegebenen Paßwortfile smtp_auth
smtp_sasl_password_maps = hash:/etc/postfix/smtp_auth

# Option : Verweigerung anonymer Anmeldungen
smtp_sasl_security_options = noanonymous

# E-Mail-Host, der als Relay dienen soll
relayhost = smtp.<euredomain.tld>

Speichert die veränderte Datei ab und prüft durch Eingabe der Befehle “postfix check” und “postconf” Eure nun veränderte Konfiguration. Ersterer Befehl sollte keine Fehler melden, dann sind wir an dieser Stelle mit der Hauptkonfigurationsdatei fertig. Nun ist es an der Zeit, das Paßwortfile “smtp_auth” im Verzeichnis “/etc/postfix” zu erstellen. Der Inhalt sollte vom Muster her wie folgt aussehen :

“smtp.<euredomain.tld> username:password”

Relayserver ist hier “smtp.<euredomain.tld>”, “username” der Benutzername eines beliebigen POP3-/IMAP-Benutzers bei Eurem Provider und “password” logischerweise das dazugehörige Kennwort. Speichert nun die Datei und erzeugt die “gehashte” Datei (sprich : Diese Textdatei im oben angegebenen Hash-Format) durch Eingabe von

“postmap smtp_auth”

im Verzeichnis “/etc/postfix”.

Im eigentlichen Sinne haben wir hiermit unser Ziel erreicht. Durch Eingeben des Befehls

“/etc/init.d/postfix restart”

wird der Postfix-Dienst neu gestartet und Ihr könnt von Eurem bevorzugten E-Mail-Programm einmal eine Testmail an eine beliebige Adresse versenden. Um zu überprüfen, ob dies auch brav so geschieht, wie wir das eigentlich erreichen wollten, gibt es in der Datei “/etc/postfix/master.cf” eine Zeile, die wie folgt lautet :

“smtp unix – - – - – smtp”

Setzt bitte hinter das letzte “smtp” einmal den Parameter “-v”, so das die Zeile wie folgt aussieht :

“smtp unix – - – - – smtp -v”

Wird Postfix dann noch neu gestartet und schaut man sich parallel das Logfile an, sollte die E-Mail, die wir eben verschickt haben, hoffentlich mit dem Status “sent” verschickt worden sein. Ist dies nicht der Fall, hat es auf dem Weg hierhin noch irgendein Problem gegeben bzw. ist bis hierhin ein Problem aufgetaucht, was aber – sind keine Tippfehler etc. vorhanden – relativ unwahrscheinlich sein dürfte. Stellt abschließend bitte in der Datei “/etc/postfix/master.cf” in der Zeile

“smtp unix – - – - – smtp -v”

wieder den Ursprungszustand durch das Entfernen des “-v”-Parameters her, bevor das Mail-Logfile ins Unüberschaubare wächst und Ihr Euch irgendwann wundert, warum Eure Festplatte plötzlich voll ist (ja, auch das kann passieren!)!

Unter dem Strich – und um dieses Tutorial an dieser Stelle einmal abzuschließen – sollte sich nun die Möglichkeit des Relayens über den eigenen Internetprovider bieten, allerdings – und das betone ich an dieser Stelle extra noch einmal – über einen unverschlüsselten Mailserver via Port 25 – wer es also verschlüsselt mag, sollte sich einen SSL-Server suchen und parallel noch die Postfix-Dokumentation zu Rate ziehen! Bei Fragen, Anregungen, Erfahrungsberichten oder auch Kritik bezüglich dieser Anleitung bitte ich um eine E-Mail über das entsprechende Mailformular auf dieser Webseite!

Weitere Informationen und allerlei Wissenswertes über Postfix findet Ihr auf der offiziellen Projekthomepage :

http://www.postfix.org !