Unter Mac OS X entwickeln macht Spaß. Und das eigenen System einzurichten geht erstaunlich schnell, da Mac OS X bereits mit einem Apache 2.2 Webserver, PHP 5 und auch mit einem SVN Server ausgeliefert wird. Wie diese unkompliziert eingerichtet werden können soll hier gezeigt werden.

Apache Webserver unter Mac OS X starten

Den Apache Webserver zu starten geht erstaunlich einfach. Dazu kann entweder unter Systemeinstellungen > Freigaben die so genannte Webfreigabe aktiviert werden. Ich empfehle, den Apache Server auf diesem Wege zu starten. Natürlich kann man im Terminal kann auch folgenden Befehl eingegeben, doch fehlt dann der entsprechende visuelle Status unter Systemeinstellungen.

sudo httpd -k start

Das so genannte htdocs Verzeichnis (das Verzeichnis, dass von außen über den Apache 2 Server angesprochen wird) findet sich standardmäßig unter /Library/Webserver/Documents.

PHP 5 unter Mac OS X einrichten

Wer mit PHP 5 entwickeln möchte, der muss das entsprechende Apache Modul zunächst aktivieren. Dazu muss die httpd.conf Datei editiert werden. Sie findet sich unter /etc/apache2. Um auf die Systemverzeichnisse wie beispielsweise etc oder usr über den Finder zuzugreifen wählt man im Menu des Finders Gehe zu > Gehe zu Ordner. Alternativ kann natürlich auch über das Terminal und cd Befehlen zu den entsprechenden Verzeichnissen navigiert werden.

In der httpd.conf Datei muss die Zeile 116

LoadModule php5_module        libexec/apache2/libphp5.so

entkommentiert werden. Wer möchte kann in Zeile 215 einstellen, dass .htaccess Dateien Parameter ändern können. Das ist für die reibungslose Funktion von mod_rewrite notwendig.

<Directory /Library/WebServer/Documents>
  AllowOverride All
</Directory>

In Zeile 230 muss hinzugefügt werden, dass auch index.php Dateien als Directory Indexes erkannt werden:

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

Zu guter letzt muss der Webserver neu gestartet werden. Dies kann über die Systemeinstellungen (siehe oben) oder mit folgendem Befehl geschehen:

sudo httpd -k restart

Um zu testen, ob PHP läuft kann eine index.php und folgendem Inhalt im htdocs Verzeichnis abgelegt werden. Mit http://localhost/index.php im Browser sollte eine Übersicht über das installierte PHP Modul erscheinen.

<?php phpinfo(); ?>

Um Default-Eigenschaften zu überschreiben (error reporting, max upload etc.) muss eine php.ini Datei unter /etc/ angelegt werden. Meine php.ini enthält das Folgende:

max_execution_time = 60
memory_limit = 256M
display_errors = On
post_max_size = 32M
upload_max_filesize = 32M
date.timezone = Europe/Berlin

MySQL unter Mac OS X einrichten

Einen MySQL-Server unter Mac OS X einzurichten geht denkbar einfach. Hierfür gibt es fertige Installer, die über http://dev.mysql.com/downloads/mysql/ bezogen werden können. Zusätzlich kommt das MySQL Package mit einem Startup-Item. Wird es installiert, so startet MySQL bei jeden Systemstart automatisch. Installiert wird mysql unter /usr/local/mysql. Um MySQL manuell zu starten genügt folgender Befehl:

sudo mysqld_safe

Um einen unkomplizierten Umgang mit MySQL zu gewährleisten empfehle ich, das /usr/local/mysql/bin Verzeichnis zur $PATH hinzuzufügen. Tut man dies nicht, wird der mysql Befehl im Terminal nicht gefunden. Diese drei Schritte helfen:

1. Eine neue Datei /etc/paths.d/mysql erzeugen:

sudo touch /etc/paths.d/mysql

2. Die Datei bearbeiten und das MySQL bin Verzeichnis erstellen:

sudo vim /etc/paths.d/mysql

3. Den  MySQL-bin Pfad einfügen und speichern.

/usr/local/mysql/bin

Wer mit vim noch nicht gearbeitet hat: i drücken um in die Datei zu schreiben, den Pfad eingeben, ESC drücken und dann :wq eingeben und mit Enter bestätigen. Nach einem Neustart sind alle im /usr/local/mysql/bin Verzeichnis befindenden Programme auffindbar.

Achtung: Anfangs besitzt der MySQL root Account kein Passwort! Zur einfachen Verwaltung empfehle ich phpmyadmin – ein WebGUI.

Einen SVN Server unter Mac OS X einrichten

SVN wird bereits mit Mac OS X ausgeliefert. Damit der SVN Server auch von außen ansprechbar ist muss in erster Linie der Apache Webserver konfiguriert werden. Ich verwalte meine SVN Repositories im Ordner /usr/local/svn/. Um die Repositories von außen ansprechbar zu machen muss eine Datei namens svn.conf im Ordner /etc/apache2/other angelegt werden. Sie besitzt folgenden Inhalt:

LoadModule dav_svn_module /usr/libexec/apache2/mod_dav_svn.so
<Location /svn>
  DAV svn
  SVNParentPath /usr/local/svn
</Location>

Nachdem Apache neu gestartet wurde sind die Repositories in /usr/local/svn/ unter http://localhost/svn ansprechbar. Beim Anlegen eines neuen Repositories namens foo mit

sudo svnadmin create /usr/local/svn/foo

Muss darauf geachtet werden, dass Apache und das SVN Modul auch darauf zugreifen können. Dazu ändern wir zuvor den Besitzer der Dateien in www um:

sudo chown -R www:www /usr/local/svn

Damit ist SVN bereits fertig eingerichtet. Ich empfehle die Absicherung des SVN Verzeichnisses. Dazu muss zunächst eine htpasswd Datei erzeugt werden:

htpasswd -cm /etc/apache2/svn.auth benutzername

Die svn.conf Datei muss um folgendes erweitert werden:

LoadModule dav_svn_module /usr/libexec/apache2/mod_dav_svn.so
<Location /svn>
  DAV svn
  SVNParentPath /usr/local/svn
  AuthType Basic
  AuthName "Subversion Login"
  AuthUserFile /etc/apache2/svn.auth
  Require valid-user
</Location>

Die Repositories sind jetzt unter http://localhost/svn erreichbar. Zur einfachen Verwaltung empfehle ich WebSVN – ein WebGUI.

Update: Sollte der Apache Server mit der obigen svn Konfiguration nicht mehr starten, muss darauf geachtet werden, dass die Apache Module mod_dav.so und mod_dav_fs.so auch geladen werden. Danke an Alexander für diesen Tip.

Bei zahlreichen Webspace-Providern ist die Funktionalität von file_get_contents für http deaktiviert. Es treten dann Fehlermeldungen wie

Warning: file_get_contents() [function.file-get-contents]: URL file-access is disabled in the server configuration in [..] und

Warning: file_get_contents([..]) [function.file-get-contents]: failed to open stream: no suitable wrapper could be found in [..]

auf. Mit folgender Funktion kann man das Verhalten von file_get_contents jedoch emulieren.

Die Funktion get_contents_by_uri benutzt fsockopen um Inhalte zu laden:

/**
 * Gets contents of any webside by an URI.
 * @author http://blog.root-of-all-evil.com
 * @param String $uri
 */
function get_contents_by_uri($uri) {
	$uriElem = parse_url ( $uri );
	$fp = @fsockopen ( $uriElem ['host'], 80, $errno, $errstr, 10 );

	if (! $fp) {
		throw new Exception ( "Could not create socket: '" . $errnstr . "' (" . $errno . ")." );
	}

	$request = "GET " . $uriElem ['path'] . (isset ( $uriElem ['query'] ) ? "?" . $uriElem ['query'] : "") . " HTTP/1.1\r\n";
	$request .= "Host: " . $uriElem ['host'] . "\r\n";
	$request .= "Connection: Close\r\n\r\n";

	fwrite ( $fp, $request );
	$response = "";
	while ( ! feof ( $fp ) ) {
		$response .= fgets ( $fp, 128 );
	}
	fclose ( $fp );

	// split headers from data
	$responseSplit = explode ( "\r\n\r\n", $response, 2 );

	return $responseSplit [1];
}

Erklärung

Socket erstellen

Die übergebene URI wird über die PHP-Funktion parse_url in ihre Teilmengen zerlegt. Anschließend wird ein Socket erstellt für den entsprechenden Host, auf Port 80 mit einem Timeout von 10 Sekunden. Fehlermeldungen unterdrücken wir durch das @, da wir explizit nach Erfolg abfragen und ggf. eine Ausnahme werfen.

Anfrage schicken, Antwort lesen

Danach wird über fwrite eine entsprechende GET-Anfrage geschickt, welche auch – falls vorhanden – die Parameter der URI und nicht nur den Pfad beachtet. Die darauffolgende Antwort wird in die Variable response gelesen.

Antwort bearbeiten und zurückgeben

Da diese neben dem eigentlichen Inhalt auch den Antwortheader enthält wird die Funktion explode benutzt um den Inhalt davon abzuschneiden. Durch den dritten Parameter bei explode mit dem Wert 2, stellen wir sicher, dass nur einmalig an Hand einer Leerzeile getrennt wird wie Sie sich zwischen Antwort-Header und HTML-Code befindet und nicht mehrmals, da natürlich auch Leerzeilen im HTML-Code selbst auftreten können.

Das zweite Element von responseSplit wird zurückgegeben, responseSplit[0] würde entsprechend den Antwort-Header liefern.

Beispielaufrufe

Der einfachste Aufruf:

echo get_contents_by_uri ( 'http://www.google.de/' );

Aufruf mit Parametern:

echo get_contents_by_uri ( 'http://www.google.de/search?hl=de&site=&q=test' );

Aufruf mit Ausnahmebehandlung:

try{
    echo get_contents_by_uri ( 'http://does_not_exist_.com/bogus.html' );
}
catch(Exception $e)
{
    echo "get_contents_by_uri: ".$e->getMessage();
}

Weitere Links:

• PHP – Funktion parse_url
• PHP – Funktion file_get_contens
• PHP – Funktion fsockopen
• PHP – Funktion explode

Man stelle sich folgendes Szenario vor: Es existiert eine Webseite, die eine Vielzahl von Grafiken, die auf dem gleichem Server hinterlegt sind, einbindet. Diese Webseite wird erfahrungsgemäß eine überdurchschnittlich lange Ladezeit haben. Aber nicht nur aufgrund der zu übertragenen Datenmengen, sondern auch aufgrund der maximalen Anzahl von Verbindungen, die ein Browser auf ein und denselben Server erlaubt. Hier werde ich etwas über die Beschleunigung vom Aufbau von Webseiten schreiben. Dabei verwende ich gewisse DNS Einstellungen, so genannte CNAME-Records mit denen ich serverseitig mehrere parallele HTTP-Verbindungen erlauben kann und so das Laden der Webseite durch den Browser des Nutzers beschleunige.

Standardmäßig sind moderne Browser mit maximalen Anzahl von sechs Verbindungen (IE 6 und IE 7 maximal zwei Verbindungen) zu ein und demselben Host begrenzt. Das führt dazu, dass das Laden von Dateien (Bilder, HTML-Seiten, JavaScripts oder Stylesheets) von einer Webseite in Blöcken unterteilt wird. Dabei würde es um einiges schneller gehen können, wenn ich die zu ladenden Dateien auf verschiedene Hostnamen verteile. So können für jeden Hostnamen mehr Verbindungen gleichzeitig ermöglicht werden.

Man betrachte zum Beispiel Google Maps. Die angezeigte Karte besteht aus einer vielzahl von so genannten Tiles. Tiles sind einfach Kacheln. Jede Kachel stellt einen Kartenausschnitt dar:

Damit die Karte schnellstmöglich trotz der Browserbegrenzung von sechs Verbindungen geladen werden kann, verteilt Google Maps die zu ladenden Kacheln auf verschiedene Hostnamen (Subdomains). Google verwendet vier Subdomains: mt0, mt1, mt2 und mt3.google.de:

Grundsätzlich ist es kein großes Problem verschiedene Subdomains anzulegen und die Dateien einer Webseite auf diese Subdomains zu verteilen. Allerdings besteht so recht schnell die Gefahr, dass man als Administrator den Überblick verliert, wo welche Dateien abgespeichert sind. Einfacher wäre es, zB. alle Mediendateien (zB. Bilder, Videos) unter einer Subdomain abzuspeichern. Um das Laden der Startseite erheblich zu beschleunigen, aber ohne zahlreiche Subdomains zu arbeiten kann man wie folgt vorgehen:

1. Ich lege unter der Hauptdomain eine einzige subdomain namens media.domain an. Hier speichere ich alle Bilder ab.
2. Ich lege so genannte CNAMES Einträge in meinen DNS Einstellungen an. Ein CNAME ist – einfach erklärt – ein Domain-Alias. In meinem Fall wähle ich zwei CNAME-Einträge namens “media0.domain.de” und “media1.domain.de” an. Am einfachsten geht es über die Adminoberfläche Plesk und sieht folgendermaße aus:
3. Diese beiden Einträge bewirken, dass media0.domain.de und media1.domain.de auf die gleiche subdomain media.domain.de umleiten. Ich habe jetzt also eine Subdomain, die auf drei unterschiedliche Weisen erreicht werden kann. Der Browser des Nutzers interpretiert die drei Domains als drei unterschiedliche Adressen, die aber auf den gleichen Speicherort verweisen. So sind drei mal so viele Verbindungen zum eigentlich gleichen Host möglich. Der Browser wird einfach ausgetrickst.
4. Bei der Einbindung der Bilder in die Webseite muss ich jetzt nur die zwei verschiedenen “subdomains” media0 und media1 verteilen. Ich löse das über einen Zufallsgenerator in meinem PHP Script, dass den HTML-Code generiert. Dieser könnte zB. so aussehen:

$media_domains = array('media0', 'media1');
foreach($bilder as $bild) {
  shuffle($media_domains);
  echo('<img src="' . $media_domains[0] . '.domain.tld/img/'. $bild . '" />');
}

Und fertig. Kommentare, Verbesserungsvorschlage? Dazu sind die Kommentare da.