phpundmysql.de

31. Januar 2016
von (sr)
Kommentare deaktiviert für In der OneBitAhead GmbH findet PHP&MySQL ein neues Zuhause

In der OneBitAhead GmbH findet PHP&MySQL ein neues Zuhause

Software Entwicklung mit Web-Technologien war und ist unsere Leidenschaft. Deshalb haben wir unsere bestehenden Arbeitsverhältnisse beendet. Als OneBitAhead GmbH werden wir fortan Anwendungen entwickeln, uns frühzeitig neuen Entwicklungen widmen, und uns im Bereich Weiterbildung/Schulungen engagieren.

Besuchen Sie uns unter:

OneBitAhead GmbHOneBitAhead GmbH
https://www.onebitahead.com
Königsstr. 32-33,
48143 Münster

Oder in soziales Netzwerken:
https://twitter.com/OneBitAhead
http://www.facebook.com/OneBitAhead

24. April 2015
von (sr)
Kommentare deaktiviert für Use FTP To Transfer Files To A Google Cloud Platform Web Server

Use FTP To Transfer Files To A Google Cloud Platform Web Server

German version available here / Deutsche Version hier: Mit FTP Dateien auf einen Google Cloud Platform Server übertragen

This is the second part of a Google Cloud Platform series. With a preconfigured web server up and running our last task is to access the server with a SSH client like WinSCP. Until now the deployment of the server didn’t require any more IT knowledge than the average user should bring. To spoil the show: this will change now. If you are new to SSH: our goal today is to access the server and copy custom content to the server. By custom we mean any software, or website content (scripts, stylesheets, images) that is not available via Googles Click-to-Deploy mechanism.

To achieve this we need to configure a SSH connection in WinSCP and therefore generate a public/private key pair for authentification.

Our Goal

For a SFTP connection we do not only have to configure our tool – we choose WinSCP for now – but also the web server at Google Cloud Platform (GCP). Instead of using user names and passwords we will generate a public/private key pair. The public key has to be registered in Googles developer console, the private key is used in the WinSCP connection. Let’s begin!

In case you do not have a SSH tool by hand, download WinSCP here. There also is a portable version available if you want to store it on a USB stick.

Generating the key pair

Key pairs are used to encrypt and decrypt data, email or other messages and so on. A private key is always bundled with a corresponding public key. As the names suggest: While you should keep your private key secret and only use it to configure software (like WinSCP or your mailing software), feel free to let your friends and business partners know you have a public key.
The keys only work together. When you loose your private key then your public key is useless. The other way around you can always recover the public from the private key.

A tool named PUTTYgen comes bundled with WinSCP and it’s used to generate key pairs. Just hit the „Generate“ button to start the process. You will have to actively particpiate in the key generation: To gather random salt PUTTYgen is monitoring your mouse movement. So send your mouse pointer on a weird journey all over the screen. It all should take less than 10 seconds.
After that save both keys to separate files (using the „Save public key“ / „Save private key“ buttons).

Now that have your pubnlic/private keys, why not start encrypting your mails?

Configure Google Cloud Platform

GCP makes it easy to store your public key using the Developer Console. The correct byte-by-byte value can be obtained from PUTTYgen. With your key information still open in the program, just change the „Key comment“ field and enter the same email address that you used for GCP registration. Google expects a form only containing letters and underscores, so every special character including @ has to be replaced. For example your.email@gmail.com gets your_email_gmail_com.
In case you have already closed PUTTYgen, reopen it and load your private key file to get all information back.

Open the Google Developer Console and navigate to Compute > Compute Engine > Metadata and choose the „SSH Keys“ tab. You will find 2-3 keys preconfigured Just add another one and use as key the content of PUTTYgens field named „Public key for pasting into OpenSSH authorized_keys file“; the value should begin with „ssh-rsa“ and end with your email address in the format mentioned above.

Add a new site in WinSCP

Open WinSCP and hit the „New site“ button. Choose SFTP as protocol on port 22. Host name resolves to the public IP of your server. In case you do not remember the IP, find it under Compute > Compute Engine > VM Instances in the Developer Console. Once again take the letter/underscore version of your mail address as user name. No password needed.
You can not enter your private key in this form. Instead go to the advanced settings and find SSH > Authentification. Upload your private key file and keep hitting enter/save until everything is set.

Connecting for th first time

When you establish a connection for the first time, WinSCP tells you it can not find the server fingerprint in its cache. Verify the fingerprint by comparing it to the one your see on the online SSH interface in the Google Developer Console.

TO open the SSH interface one last time open the developer console, navigate to Compute > Compute Engine > VM Instances, and hit the SSH button to the right of your server name. The fingerprint to compare is written in the very first line:

Connected, host fingerprint: ssh rsa 2048 ...

When both fingerprints match, everything is fine. Don’t be surprised to never ever be asked for a password. This is exactly what we wanted to achieve with the keys.

Handling Linux permissions

Actually everything is set up and a connection is established. However file transfer is not yet possible. Your user does not have the write permission for the /lamp directory where all your web content is stored. The reason is the configuratoin of the servers Linux OS. It is not specific to GCP. It only takes a single line of code in the online SSH console to fix that:

sudo chown ihre_email_gmail_com /lamp

This command makes your user the owner of the /lamp directory. It’s the easiest way to solve the problem withour further notice of Linux commands. The command takes effect immediately so you should be able to transfer files with WinSCP right away.

23. April 2015
von (sr)
Kommentare deaktiviert für Mit FTP Dateien auf einen Google Cloud Platform Server übertragen

Mit FTP Dateien auf einen Google Cloud Platform Server übertragen

Dies ist der zweite Teil der Google Cloud Platform Serie. Im ersten Teil haben wir einen Webserver per Click-to-Deploy erfolgreich installiert und öffentlich zugänglich gemacht. Um Inhalte wie HTML, CSS, JavaScript oder andere Dateien auf den Server zu kopieren, bedarf es nun noch einer SSH Verbindung mit einem beliebigen Werkzeug wie WinSCP. Bisher war für die Installation und Konfiguration nicht mehr IT Wissen vonnöten als ein durchschnittlicher Computernutzer vorzuweisen hat. Um es vorweg zu nehmen: Das ändert sich von nun an.

Ziel

Für eine SFTP-Verbindung muss nicht nur das Werkzeug – wir verwenden WinSCP – sondern auch der Webserver bei Google Cloud Platform (GCP) konfiguriert werden. Statt Benutzernamen und Passwort zum Einloggen zu verwenden, generieren wir ein Schlüsselpaar aus öffentlichem und privatem Schlüssel. Den öffentlichen Schlüssel hinterlegen wir bei GCP, den privaten Schlüssel verwenden wir bei der Konfiguration von WinSCP.
Sofern Sie kein WinSCP auf Ihrem Rechner haben, laden Sie es sich vorab herunter. Zusätzlich zum Installer ist auch eine portable Version verfügbar, die Sie vom USB Stick laufen lassen können.

 

Erstellung von Public/Private Keys

Schlüsselpaare zum Ver- bzw. Entschlüsseln von Daten, Email, Nachrichten, etc. bestehen immer aus einem privaten und einem öffentlichen Schlüssel. Aus dem Namen wird klar: den privaten Schlüssel sollten Sie tunlichst für sich behalten und nur zur Konfiguration von Software (wie WinSCP oder Ihrem E-Mail-Programm) verwenden. Den öffentlichen Schlüssel können Sie an Freunde oder Geschäftspartner verteilen.
Die Schlüssel funktionieren nur zusammen, d.h. wenn Sie Ihren privaten Schlüssel verlieren, nützt Ihnen der öffentliche Schlüssel auch nichts mehr. Anders herum lässt sich ein öffentlicher Schlüssel aus dem privaten wieder herstellen.

Im Gepäck von WinSCP befindet sich das Tool PUTTYgen, das zur Erstellung von Schlüsselpaaren geeignet ist. Mit einem einfachen Klick auf Generate beginnt die Berechnung der Schlüssel. Sie müssen dabei allerdings buchstäblich aktiv mitarbeiten: Um zufällige Informationen als Basis der Berechnung zu bekommen, liest PUTTYgen Ihre Mausbewegungen mit. Also schicken Sie den Mauszeiger auf eine intensive Reise über Ihren Bildschirm. Innerhalb von 10 Sekunden sollte die Kalkulation fertig sein.
Speichern Sie die beiden Schlüssel in separaten Dateien an sicheren Orten ab (mittels „Save public key“ / „Save private key„).

Bei der Gelegenheit können Sie auch gleich Ihre Email-Kommunikation verschlüsseln.

 

Konfiguration von Google Cloud Platform

GCP bietet Ihnen die Möglichkeit, Schlüsselinformationen über die Developer Console zu hinterlegen. Um das korrekte Format der Schlüssel zu bekommen, müssen Sie in PUTTYgen aber noch einmal Hand anlegen. Ändern Sie den Wert des Textfeldes „Key comment“ auf diejenige E-Mail-Adresse, die Sie bei der Anmeldung bei GCP verwendet haben. Alle Sonderzeichen, auch das @, sind dabei mit einem Unterstrich zu ersetzen. Aus ihre.email@gmail.com wird so ihre_email_gmail_com.

Wechseln Sie in der Developer Console zum Menüpunkt Compute > Compute Engine > Metadata und dort auf den Reiter SSH Keys. Standardmäßig sind bereits 2-3 Keys angelegt. Fügen Sie einfach einen neuen hinzu. Verwenden Sie dazu den gesamten Inhalt des Feldes „Public key for pasting into OpenSSH authorized_keys file“; der Text sollte mit ssh-rsa beginnen und mit Ihrer E-Mail-Adresse – analog zu dem Feld „Key comment“ – enden.

 

Eine Verbindung in WinSCP einrichten

Starten Sie in WinSCP mit „Neues Verbindungsziel“ und wählen Sie als Protokoll SFTP auf Port 22. Als Rechnername reicht die statische IP Adresse Ihres Webservers. Diese können Sie notfalls in der Developer Console im Menüpunkt Compute > Compute Engine > VM Instances nachschlagen. Der Benutzername ist Ihre E-Mail-Adresse, in dem gleichen Format, das Sie in PUTTYgen als „Key comment“ verwendet haben.

Ihren Schlüssel können Sie in diesem Formular nicht hinterlegen. Stattdessen müssen Sie in die erweiterten Einstellungen wechseln. Dort können im letzten Schritt der Konfiguration Sie unter SSH > Authentifizierung die vorher gespeicherte Datei mit den privaten Schlüssel hinterlegen. Danach können Sie die Verbindung speichern.

 

Die erste Verbindung

Wenn Sie sich das erste Mal über WinSCP mit dem Server verbinden, sollten Sie zur Sicherheit den Serverschlüssel überprüfen. Der Host sendet dazu einen Fingerabdruck. Dieser muss mit demjenigen übereinstimmen, den Sie über die SSH Oberfläche der Developer Console zu sehen bekommen.

Um die online SSH Oberfläche zu öffnen, wechseln Sie ein weiteres Mal in der Developer Console zu dem Menüpunkt Compute > Compute Engine > VM Instances. Rechts neben Ihrem Servernamen finden Sie die Schaltfläche mit der Aufschrift SSH. Wenn Sie diese betätigen, öffnet sich ein Fenster, in dessen ersten Zeile bereits der Fingerabdruck zu sehen ist:

Connected, host fingerprint: ssh rsa 2048 ...

Wenn die folgende Zeichenkette mit derjenigen übereinstimmt, die von WinSCP bei der ersten Verbindung akzeptiert werden muss, hat alles seine Richtigkeit. Wundern Sie sich nicht, dass Sie beim Verbindungsaufbau nie nach einem Passwort gefragt werden. Genau dafür haben wir ja die Schlüssel auf beiden Seiten hinterlegt.

 

Die Sache mit den Linux-Zugriffsrechten

Eigentlich ist nun alles eingerichtet und die Verbindung steht. Dennoch werden Sie noch keine Dateien übertragen können, weil Sie noch keine Schreibrechte für das Verzeichnis /lamp besitzen, in dem Ihre Web-Dateien liegen. Das liegt an der Einrichtung der Linux-Maschine und ist nicht spezifisch für GCP. Dieses Hindernis ist über die online SSH Console allerdings mit einem Einzeile behoben.

sudo chown ihre_email_gmail_com /lamp

Dies ist der einfachste Weg, wenn man keine grundlegenden Linux-Kenntnisse vorzuweisen hat. Damit wird Ihr persönlicher Benutzer zum Besitzer des /lamp Verzeichnisses. Mit den voreingestellten Lese- und Schreibrechten können Sie nach Belieben Dateien verändern.

10. April 2015
von (sr)
Kommentare deaktiviert für Wie man sich einen Webserver bei Google Cloud Platform zulegt

Wie man sich einen Webserver bei Google Cloud Platform zulegt

English version available here / Englische Version hier: How to Setup a Web Server on Google Cloud Platform

Das Ziel

Dies ist der Beginn einer 2-teiligen Reihe zu Googles Cloud Plattform (GCP). Das Ziel in diesem Abschnitt ist es, einen Apache mit möglichst wenig Konfiguration zum Laufen zu bringen. Im Ergebnis bekommen wir Zugriff auf einen virtuellen Linux-Server unter statischer IP-Adresse, dazu PHP und eine MySQL Datenbank und eine Willkommens-Webseite. Ein voll-funktionstüchtiger LAMP Stack frei Haus quasi.
Der zweite Teil richtet sich an kundige Anwender, denen SSH und Public/Private Schlüssel ein Begriff sind. Die Einrichtung einer Verbinung eines SSH-Tools wie WinSCP wird vorgestellt, um beliebige Dateien auf den Server zu übertragen.

 

Registierung bei GCP

Um unser 600-Sekunden-Versprechen zu halten, kommen wir gleich zur Sache! Aber zu erst einmal bedarf es natürlich eines Accounts bei dem Cloud-Dienst. Navigieren Sie mit Ihrem Browser zu https://cloud.google.com/, klicken Sie auf einen der „Kostenlose Testversion“ und füllen Sie das Formular aus. Die Registrierung ist einer der komplexeren Aufgaben dieses Tutorials, versprochen! Google fragt die üblichen Privat- und Unternehmensdaten ab, Google beteuert Ihre Kreditkarten nur zur Validierung des Benutzerkontos zu nutzen. Darüber hinaus wird betont, dass nach Ablauf der Testphase nicht automatisch Kosten verursacht werden. Die geschieht erst nach expliziter Einwilligung.

Nach der Registrierung können Sie sich direkt in die Google Developer Console einloggen. Als erstes werden ein Projekt und eine Abrechnungskonto angelegt. Dem Projekt werden später virtuelle Maschinen zugeordnet. Wenn Sie diesen Schritt überspringen, dann können Sie diesen zu einem späteren Zeitpunkt, spätestens aber bei Starten eines Servers, nachholen.

 

Softwareauswahl

Der einfachste Weg fortzufahren ist der so genannte Google Cloud Launcher. Hier können Sie Softwarekomponenten auswählen und direkt installieren. Alle 120+ Komponenten werden auch in vorsortierten Tabs noch einmal aufgeführt. Auf dem „Infrastruktur“ Tab finden Sie, neben anderen Einträgen, auch zweimal den LAMP Stack. Neben einer Version von Bitnami Solutions gibt es eine zweite, die unter „Google Click to Deploy Solution“ geführt wird.
Die Google Version enthält weitere Informationen zum den verwendeten Softwareständen. Während dieser Artikel entsteht, entsprechen diese dem Apache 2.2, PHP 5.4 und MySQL 5.5. Ein wenig angestaubt – besonders wo PHP 7 und MySQL 7 dieses Jahr in den Startlöchern stehen. Aber immer noch aktuell genug für unsere konstenlose Testphase.

 

Konfiguration and Start

Klicken Sie zum Beginn des Installationsprozesses auf „Getting started“ in der Google Version. Ordnen Sie Ihren Server Ihrem Projekt und dem Abrechnungskonto zu und fahren Sie fort. Wenn Sie bislang kein Projekt angelegt haben, holen Sie es jetzt nach. Die Initialisierung startet danach sofort und braucht einige Momente.
Ordnen Sie den Server danach einer Zone in Ihrer Nähe zu. Google stellt mehrere großräumige Zonen zur Auswahl, darunter US und Europa. Die physische Distanz zwischen dem Server und dem Browser Ihrer Webseitenbesucher hat Einfluss auf die Geschwindigkeit, mit der die Seiteninhalte abgerufen werden. Wählen Sie also keine geografische Zone am anderen Ende der Welt aus.
Als nächstes bekommen Sie die Gelegenheit, die Pferdestärken Ihrer virtuellen Maschine festzulegen. Wir wählen in diesem Beispiel eine virtuelle CPU mit 1.7GB of RAM für den Screenshot. Aber lassen Sie sich ruhig oberhalb ider unterhalb dieser Maschinengröße aus, solange Sie in der Testphase sind. Legen Sie noch die Festplattengröße bzw -typ fest, setzen Sie der Einfachheit halber den Haken, damit phpMyAdmin installiert wird und schließen Sie die Konfiguration ab. Wenn Sie sich mit den Einstellungen nicht sicher sind, behalten Sie die Standardwerte bei – Sie machen damit nichts verkehrt. Das Starten der Maschine dauert wenige Minuten.

Die nächsten Schritte

Erst einmal Glückwunsch, Sie haben es geschafft! Abschließend bekommen Sie eine Übersicht angezeigt. Bevor Sie gleich zu der Willkommensseite Ihres Webservers wechseln, nehmen Sie sich ein wenig Zeit für die Punkte unter „What to do next“. Ihr Webserver ist von Ihrem Browser noch nicht zu erreichen. Folgen Sie also den Anweisungen und öffnen Sie einen HTTP Port. Notieren Sie sich besser auch noch den MySQL/PHPMyAdmin Benutzernamen und das dazugehörigen Passwort (ändern Sie dies besser später noch, sofern Sie Daten in der Datenbank speichern) sowie die statische IP-Adresse Ihres Servers.
Der Lohn Ihrer Arbeit ist eine Willkommensseite, die sagt „It works!“ sobald Sie in Ihrem Browser die IP-Adresse angeben.

Der virtuelle Server wird solange laufen, bis Ihre kostenlose Testphase endet oder Sie ihn manuell über die Google Developer Console herunter fahren. Die Console dient darüber hinaus auch zur Verwaltung aller Ressourcen. Ihre virtuellen Maschinen finden Sie unter dem Menüpunkt Compute > Compute Engine > VM Instances.

10. April 2015
von (sr)
Kommentare deaktiviert für How to Setup a Web Server on Google Cloud Platform

How to Setup a Web Server on Google Cloud Platform

German version available here / Deutsche Version hier: Wie man sich einen Webserver bei Google Cloud Platform zulegt

What’s our goal

This is a two part series on using Google Cloud Platform (GCP). The goal of the first part is to get a web server started with least possible configuration effort. The result will be a configured server accessible at a static IP, working PHP and MySQL, and a static welcome page. As you can see, you will get a full-fledged LAMP stack out of the box. The second part is for all tech-savvy users not strangers to SSH and public/private key generation: We will configure a SSH connection to transfer all kinds of files to the server.

 

Register at GCP

To keep our 600-seconds-promise, let’s get going! But first things first: To get started, go to https://cloud.google.com/, click on one of the many „Free Trial“ buttons and fill out the registration form. This is one of the most complex tasks of this tutorial. Promised! The fields to enter consist of the usual personal and business data, your credit card number is for account validation only. Google emphasizes that billing will not start automatically, but you will explicitly be asked to continue when your free trial ends.

After registration you will be able to log into Google Developer Console immediately. There you will be asked to start a project and a billing account. The project is basically a name to assign your virtual machines to. If you skip the project setup, you can do so when you setup the web server.

 

Choose server software

The easiest way to continue is to go to the so called Google Cloud Launcher where you can choose the software components to deploy. All available 120+ components are listed but also subsetted in tabs. Click the Infrastructure tab to see, among other compnents, two different versions of the LAMP stack. The first is provided by Bitnami Solutions, the second one originates by „Google Click to Deploy Solution“. The latter contains information on the available components. As of time of writing, this is Apache 2.2, PHP 5.4 and MySQL 5.5. This is a bit outdated – especially with PHP 7 and MySQL 7 on their way to be released this year. But still not bad for a free trial period.

Configuration and Deployment

Start your setup by clicking the „Getting started“ button on the latter version. Assign your resource to your project and your billing account and hit „Continue“. If no project has been created so far, you have to do so right now. Initialization starts immidiately and takes some time.
Next, you get the chance to resize your virtual machine if necessary. Start by selecting a geographic zone nearby. The physical distance between your users browser and the server still effects the speed of web content delivery. So make sure you do not choose a zone at the other end of the world. Next choose how much power your VM should have. We chose a small instance with 1CPU and 1.7GB of RAM in the screenshot. But be free to upsize or downsize as needed. Furthermore configure disk type, space and whether to install phpmyadmin (advised) and continue. Deploying takes some time.

What to do next

Congratulations, that’s it! You are presented a resulting summary. Easy, wasn’t it? Before freaking out and advancing to your welcome page, take some time to take a look at the „What to do next“ section. Your web server is not publicly accessible yet. So follow at least the first advised step to some of open the HTTP port to the server. Furthermore note the MySQL/PHPMyAdmin user name and password (change this later), and the External IP.

Todays reward will be a welcome page saying „It works!“ as soon as you open a new browser tab and enter to external IP address of your virtual machine. Well done!

Your web server will keep running until your free trial ends or you manually shut it down using the Google Developer Console. You can also use the console to manage your server, simple choose Compute > Compute Engine > VM Instances from the left side menu.

300px-PHP-logo.svg

6. Juni 2014
von (sr)
Kommentare deaktiviert für First steps with PHP 5.6 on Windows

First steps with PHP 5.6 on Windows

It’s almost a tradition for us to publish a How-To-Install for upcoming PHP versions with some example code of new or extended features. With the forth beta being online we take a closer look at PHP 5.6. This time – on special request – we start to do so in English. The German version can be found here.

1. Install Apache

Our first steps include installing an Apache webserver. This is done the same way as with prior versions which we described here: „PHP 5.5 und Apache unter Windows installieren“ (German only). Take a look at http://www.apachelounge.com/download/ to find the latest version of Apache (Version 2.4.9 as of time of writing). There are distributions for 32 and 64 Bit, compiled with Visual Studio 2012 (VC11). Download a suitable version and extract the folder named Apache24 to a new folder on your drive. We will use  c:\wap for this example (The name wap of our folder corresponds to the well known WAMP for Windows-Apache-PHP, without MySQL of course). Up to now we created a structure like this:

C:
+- wap
  +- apache
    +- all the apache stuff like bin, conf, etc...

Note: „Visual C++ Redistributable für Visual Studio 2012“ is required as runtime for the apache to work. If you do not have this installed go check  http://www.microsoft.com/en-US/download/details.aspx?id=30679.

We postpone the configuration of Apache until we integrated PHP. Let’s do the latter first.

2. Install PHP

Even prior to its official release you can get a sneak preview of development process of PHP: either with a beta version or in form of a snapshot. These differ in frequency of releases and stability. While there are commonly 3-4 betas at intervals of some weeks there are more than one snapshots per day. Betas are stable enough to be tested by the community, snapshots may not. Last but not least: only beta versions are anounced at php.net. You can find a history of betas for Windows OS at http://windows.php.net/qa/. Snapshots on the other hand are listed at http://windows.php.net/downloads/snaps/php-5.6/.

For our first steps we will use a snapshot. To work along with the Apache web server it has to be a “Thread Safe VC11 x64″ version, named php-5.6-ts-windows-vc11-x64-rfb991bd.zip. Do not forget to have a look at its parent directory (see link above) as there is most probably a newer versions at the time you look at it. Download the snapshot and extract it to a new subdirectory of c:\wap which is named php for obvious reasons. And while you are creating new folders: add two more. One named htdocs where our test scripts will be stored and tmp for temporary files like sessions and stuff. Your resulting structure should look like that:

C:
+- wap
  +- apache
    +- alle the apache stuff like bin, conf, etc...
  +- htdocs (empty)
  +- php
    +- all the php stuff like ext, extras and logs
  +- tmp (empty)

3. Configure both Apache and PHP

With Apache and PHP on our PC we are good to go and only the configuration is left. Like always we are going to create a portable installation which will continue working even when we copy it to a different location on our hard drive or a USB stick. Therefore we change all paths to relative ones.

Let’s begin with the PHP config file named c:\wap\php\php.ini. It does not exist right now but instead we create it as a copy of php.ini-development in the same folder. Open the file in a text editor of your choice and search for „extension_dir„. Do not get confused when you see multiple results. They all are comments by default – as you can see the semicolon (;) at the beginning of the line. Find the occurence which follows the comment „; On Windows:“ in the line above. Change
; extension_dir = "ext"
to
extension_dir = "..\..\php\ext"
Please note: remove the semicolon so the line is parsed and not dismissed as a comment anymore! The base of the relative path is the Apache config file httpd.conf. Now that the server knows where to find extensions you need to activate some necessary extensions by removing the leading semicolons. Search for ;extension= and find a block of about 20 lines in the middle of the ini file. Uncomment  curl, gd2, mbstring, mysqli, sockets and xmlrpc for starters.
Our last task of the PHP configuration is to define a path for temporary files. Remember we have created the tmp folder for this. So assign this folder to upload_tmp_dir as well as  session.save_path relatively with "..\tmp". Uncomment both places as well.

Next, open C:\wap\apache\conf\httpd.conf to configure the Apache web server. See the list of necassary changes below. Use your text editor to search for the unterlined parts and change to or add the italic parts:

  • ServerRoot „c:/Apache24“ –> ServerRoot „..“
  • Listen 80 –> Listen 82
  • LoadModule php5_module „../php/php5apache2_4.dll“ (add at the end of the block consisting of LoadModule directives)
  • #ServerName www.example.com:80 –> ServerName localhost:82
  • Require all denied (within <Directory />) –> Require all granted
  • DocumentRoot „c:/Apache24/htdocs“ –> DocumentRoot „../htdocs“
  • <Directory „c:/Apache24/htdocs“> –> <Directory „../htdocs“>
  • DirectoryIndex index.html –> DirectoryIndex index.php index.html
  • AddType application/x-httpd-php .php (add at the end of the <IfModule mime_module> directive, e.g. after AddType application/x-gzip .gz .tgz)
  • PHPIniDir ../php (add this as last line of the file)

To avoid conflicts with either other web servers (like running WAMP installations) or other software (like Skype) we changed the server port from 80 to 82. The most obvious consequence is the necessary addition of the port number to any URL in the following examples: always use  http://localhost:82/ instead of http://localhost/. If you are sure that port 80 is free, you can omit this particular change.

Let us stress the fact that this current installation is for testing purposes only! Unlike the snapshot PHP version the Apache may be used in production. But the configuration – mostly granting all access – made it too unsecure.

4. Running some tests

To start the server open a command prompt (Win+R) and switch to our directory

cd c:\wap\apache\bin

Call

httpd

and hope for the best. The server should start without warning. If this is not the case ask Google for help with the particular error message. Otherwise create your first PHP script in the htdocs folder named phpinfo.php and the following one-liner:

<?php phpinfo(); ?>

Run it in your browser with http://localhost:82/phpinfo.php:

Ready-to-go-examples für new PHP 5.6 features can be found in the PHP documentation. Don’t be disappointed: when you expect some killer features you have to wait for another release. PHP 5.6 brings some extended language constructs that should ease the developers life. Not more, not less:

Variadic Functions & Argument Unpacking

Functions with variable number of arguments could be used indirectly by using func_get_args() so far. PHP 5.6 brings explicit support by adding the  ... operator. Parameters supplied with … are available within the functions body as an array, so the workaround with func_get_args() is not necessary any more:

<?php
function v( $required, $optional = 0, ...$variable){
  printf('Variadic params are of type %s with length %d',
    gettype($variable), count($variable));
}

v('a');
v('b', 1);
v('c', 2, 9);
v('c', 2, 9, 8);
v('c', 2, 9, 8, 7);
v('c', 2, 9, 8, 7, 6);
?>

In case the variable parameter is an array or traversible object the … operator is used to unpack the elements in it. The following function is used to add all values and returns the integer value of 15:

<?php
function sumOf($a, $b, $c, $d, $e) {
  return $a + $b + $c + $d + $e;
}

$input = [2, 3, 4, 5];
echo sumOf(1, ...$input);
?>

Logic injection with use function & use const

The use construct injects classes into namespaces so far. This injection construct is extended to be used with functions and constants:

<?php
namespace Name\Space {
  const FOO = 42;
  function f() { echo __FUNCTION__."\n"; }
}

namespace {
  use const Name\Space\FOO;
  use function Name\Space\f;

  echo FOO."\n";
  f();
}
?>
300px-PHP-logo.svg

6. Juni 2014
von (sr)
Kommentare deaktiviert für PHP 5.6 unter Windows: Erste Schritte

PHP 5.6 unter Windows: Erste Schritte

Es hat fast schon Tradition, dass wir zu anstehenden PHP Versionen eine Installationsanleitung mit Beispielen zu den neuen oder veränderten Features schreiben. Mit der Veröffentlichung der letzten Beta werfen wir einen ersten Blick auf PHP 5.6.

1. Apache installieren

Für den Test setzen wir einen neuen Apache Webserver mit einem Snapshot von PHP 5.6 auf. Die Installation läuft nicht anders als bei den Vorgängerversionen, beschrieben haben wir das bereits in „PHP 5.5 und Apache unter Windows installieren„. Die letzte Apache Version findet sich unter http://www.apachelounge.com/download/ (Version 2.4.9 zur Erstellung dieses Beitrags). Zur Auswahl stehen je eine Version für 32 und 64 Bit, alle mit Visual Studio 2012 (VC11) kompiliert. Nach dem Download der passenden Version findet sich in dem Archiv ein Ordner namens Apache24, dessen Inhalt wir nach c:\wap extrahieren (Der Name wap unseres Ordners steht in Analogie zum bekannten WAMP für Windows-Apache-PHP, da wir MySQL auslassen). Unsere Ordnerstruktur sieht bisher wie folgt aus:

C:
+- wap
  +- apache
    +- der ganze apache kram wie bin, conf, etc...

Voraussetzung für einen laufenden Webserver ist in diesem Fall, dass „Visual C++ Redistributable für Visual Studio 2012“ als Laufzeitumgebung installiert ist. Sofern die fehlt, bekommt ihr sie unter http://www.microsoft.com/de-de/download/details.aspx?id=30679.

Die Konfiguration des Webservers heben wir uns noch für einen Moment auf: sobald wir PHP heruntergeladen und integriert haben, müssen wir die Config-Dateien eh noch einmal anfassen.

2. PHP installieren

Bei noch nicht veröffentlichten PHP Versionen stehen uns mehrere Alternativen zur Installation zur Verfügung: Zum einen können wir auf die Betaversionen zurückgreifen. Oder aber wir verwenden einen Snapshot. Der Unterschied besteht in der Häufigkeit und der Stabilität der Versionen: Betaversionen gibt es in der Regel 3-4. Sie kommen im Abstand von ein paar Wochen während der Entwicklung, sind stabil genug, um sie der PHP Community zum Probieren hinzuwerfen, und werden auf php.net angekündigt. Archive für Windows werden unter http://windows.php.net/qa/ bereitgestellt. Snapshots finden sich unter http://windows.php.net/downloads/snaps/php-5.6/. Täglich kommen mehrere hinzu. Bei deren Verwendung kann es zu Instabilitäten kommen. Dafür hat man den tagesaktuellen Entwicklungsstand.

Wir verwenden einen Snapshot. Passend zu unserem vorher installierten Apache Webserver brauchen wir die “Thread Safe VC11 x64″ , die den Dateiname php-5.6-ts-windows-vc11-x64-rfb991bd.zip trägt. Ein Blick in das Oberverzeichnis lohnt sich, um die aktuellste Version zu finden. Wir erzeugen unter c:\wap einen neuen Ordner namens php und extrahieren den gesamten Inhalt des eben herunter geladenen Archivs dorthin. Bei der Gelegenheit erzeugen wir noch zwei weitere Verzeichnisse: htdocs für unsere Testskripte und tmp für temporäre Dateien wie Sessions etc unter c:\wap. Alles in allem haben wir folgende Verzeichnisstuktur erzeugt:

C:
+- wap
  +- apache
    +- der ganze apache kram wie bin, conf, etc...
  +- htdocs (noch leer)
  +- php
    +- der ganze php kram wie ext, extras und logs
  +- tmp (noch leer)

3. Die Konfiguration von Apache und PHP

So weit so gut. Wir haben alle Dateien, die wir benötigen und müssen uns nun noch durch die Konfigurationsdateien wühlen. Wie bei den vorigen Anleitungen auch, achten wir darauf, eine portable Installation zu erzeugen, die auch noch lauffähig ist, wenn wir sie an einen anderen Ort auf der Festplatte kopieren oder auf dem USB-Stick mitnehmen. Dazu müssen wir die Pfade in den Konfigurationsdateien relativ angeben.

Beginnen wir mit der Datei c:\wap\php\php.ini. Wir erzeugen die Datei als Kopie von der php.ini-development im selben Verzeichnis. Zur Konfiguration der Extensions suchen wir zuerst nach „extension_dir„. Nicht wundern, es wird mehrere Vorkommen des Suchstrings in der Datei geben. Alle Vorkommen sind im Initialzustand auskommentiert, zu erkennen an dem Semikolon (;) am Zeilenanfang. Wir brauchen nur einen Eintrag, der mit dem Kommentar „; On Windows:“ in der Zeile darüber. Aus
; extension_dir = "ext"
machen wir
extension_dir = "..\..\php\ext"
Nicht übersehen: wir haben das Semikolon am Anfang entfernt, damit die Zeile auch geparst und nicht als Kommentar verworfen wird! Das Verzeichnis ist relativ zu der Apache-Konfigurationsdatei httpd.conf angegeben. Danach aktivieren wir einige grundlegende Extensions, indem wir auch dort das Semikolon am Zeilenanfang entfernen. Dazu suchen wir einen Block von etwa 20 Zeilen, die alle mit ;extension= beginnen. Für einen minimalen Start empfehlen wir curl, gd2, mbstring, mysqli, sockets und xmlrpc.
Abschließend definieren wir das Verzeichnis für temporäre Dateien sowohl für upload_tmp_dir als auch session.save_path und geben das bisher leere tmp-Verzeichnis mit "..\tmp" an. Auch hier sind an beiden Stellen eventuell vorhandene Semikola zu entfernen.

Die Konfiguration des Apache Webservers wird in der Datei C:\wap\apache\conf\httpd.conf vorgenommen. Die unterschiedlichen anzupassenden Stellen sucht ihr am besten in eurem Texteditor (suchen nach den unterstrichenden Begriffen) und weist die neuen Werte entsprechend der folgenden Liste zu (kursiv markiert):

  • ServerRoot „c:/Apache24“ –> ServerRoot „..“
  • Listen 80 –> Listen 82
  • LoadModule php5_module „../php/php5apache2_4.dll“ (an Ende des Blocks der LoadModule Anweisungen etwa in der Mitte der Datei)
  • #ServerName www.example.com:80 –> ServerName localhost:82
  • Require all denied (im Block unter <Directory />) –> Require all granted
  • DocumentRoot „c:/Apache24/htdocs“ –> DocumentRoot „../htdocs“
  • <Directory „c:/Apache24/htdocs“> –> <Directory „../htdocs“>
  • DirectoryIndex index.html –> DirectoryIndex index.php index.html
  • AddType application/x-httpd-php .php (an das Ende der Direktive <IfModule mime_module>, also z.B. hinter AddType application/x-gzip .gz .tgz)
  • PHPIniDir ../php (als letzte Zeile der Datei hinzufügen)

Um Konfigurations-Konflikten mit ggf. weiteren installierten Webservern (wie z.B. WAMP) oder anderer Software (z.B. Skype) aus dem Weg zu gehen, haben wir den Port von 80 auf 82 geändert. Wichig ist das, wenn man die Beispiel afruft: dann muss man nämlich http://localhost:82/ aufrufen anstatt http://localhost/. Wenn ihr sicher seid, dass der urspüngliche Port 80 auf eurem Rechner frei ist, könnt ihr diese Änderung übergehen.

Es muss noch einmal betont werden, dass die Installation nur für Testzwecke gedacht ist. Der Webserver ist zwar anders als der PHP Snapshot auch für den produktiven Einsatz zu gebrauchen, allerdings haben wir mit der obigen Konfiguration alle Tore aufgerissen ("Require all granted") und damit nicht zwingend zur Absicherung der Installation beigetragen.

4. Erste Tests laufen lassen

Um den Server zu starten, öffnen wir eine Kommandozeile (Win+R) und wechseln in unser Testverzeichnis mit

cd c:\wap\apache\bin

Mit dem Aufruf von einem

httpd

startet unser Webserver. Tauchen Fehlermeldungen auf, ist was schief gegangen. Bei der Fehlerbehebung steht Google mit Rat und Tat zur Seite. Bei einer lauffähigen Installation legen wir als erstes unter htdocs eine Datei mit dem Namen phpinfo.php und folgendem Inhalt an:

<?php phpinfo(); ?>

Als Ausgabe erwarten wir:

Testbare Beispiele zu den neuen Features finden sich in der PHP Dokumentation. Wer die Liste studiert, wird zwar auf eine Reihe neuer Operatoren und erweiterte Sprachkonstrukte treffen, bahnbrecende Killerfeatures jedoch vergeblich suchen. Werfen wir einen Blick auf Features, die dem Entwickler das Leben einfacher machen sollen:

Variadic Funktions & Argument Unpacking

Die variadischen Funktionen ließen sich bisher indirekt unter Rückgriff auf die Funktion func_get_args() nutzen. Eine variable Anzahl an Parametern für eine Funktion ist ab PHP 5.6 mit dem Operator ... möglich. Innerhalb der Funktion sind die Parameter als Array verfügbar, der Umweg über func_get_args() entfällt:

<?php
function v( $required, $optional = 0, ...$variable){
  printf('Variadic params are of type %s with length %d',
    gettype($variable), count($variable));
}

v('a');
v('b', 1);
v('c', 2, 9);
v('c', 2, 9, 8);
v('c', 2, 9, 8, 7);
v('c', 2, 9, 8, 7, 6);
?>

Ist der Parameter ein Array oder traversierbares Objekt, kann der Operator … zum Entpacken der Elemente verwendet werden. Die folgende Funktion zum Addieren gibt als Ergebnis 15 zurück:

<?php
function summe($a, $b, $c, $d, $e) {
  return $a + $b + $c + $d + $e;
}

$summanden = [2, 3, 4, 5];
echo summe(1, ...$summanden);
?>

Übernahme mittels use function & use const

Was bisher mit dem use Konstrukt zum Übernehmen von Klassen in einen Namensraum möglich war, wird in PHP 5.6 für Funktionen und Kontanten erweitert:

<?php
namespace Name\Space {
  const FOO = 42;
  function f() { echo __FUNCTION__."\n"; }
}

namespace {
  use const Name\Space\FOO;
  use function Name\Space\f;

  echo FOO."\n";
  f();
}
?>

26. Januar 2014
von (sr)
Kommentare deaktiviert für Apache Logs direkt in MySQL einlesen

Apache Logs direkt in MySQL einlesen

Jeder Apache protokolliert standardmäßig Aufrufe der Webseite im so genannten Common Log Format (CLF). Die Logdaten finden sich zeilenweise in der Datei access.log. Gesteuert wird dies über einen Eintrag in der httpd.conf, der in etwa so aussieht:

LogFormat „%h %l %u %t \“%r\“ %>s %b \“%{Referer}i\“ \“%{User-Agent}i\““ combined

Jeder Teil der Zeichenkette – beginnend mit einem % und begrenzt durch ein Leerzeichen respektive das Zeichenkettenende – steht für eine geloggte Information. Das obige Standardformat enthält beispielsweise folgendes:

Abkürzung Bedeutung
%h Host, IP-Adresse des Aufrufs
%l Logname, Ergebnis von identd
%u User, Benutzername wenn eingeloggten
%t Time, Zeitpunkt der Anfrage
%r Request, gewünschte Anfrage-URL und HTTP-Methode (GET, POST…)
%>s Status, numerischer Antwortstatus, eigentlich %s, bei der Verwendung von %>s wird der finale Status zurück gegeben
%b Antwortlänge in Bytes ohne Header
%{header}i Ein beliebiger Header, z.B. User-Agent

Eine vollständige Auflistung der möglichen Bestandteile findet sich in der Apache Dokumentation.

Eine passende MySQL Tabelle gibt es natürlich nicht adhoc. Sie muss erst angelegt werden. Dies sieht dann in etwa so aus:

CREATE TABLE IF NOT EXISTS 'ACCESSLOG' (
'ip' varchar(50) NOT NULL,
'ident' varchar(250) NOT NULL,
'userid' varchar(100) NOT NULL,
'momentum' varchar(50) NOT NULL,
'request' varchar(2048) NOT NULL,
'statuscode' mediumint(4) NOT NULL,
'size' int(11) NOT NULL,
'referer' varchar(2048) NOT NULL,
'useragent' varchar(2048) NOT NULL
) ENGINE=InnoDB;

Zum Laden der Datei in die MySQL Tabelle bemühen wir die Kommandozeilentools des Datenbankclients. Nach dem Verbinden mit dem Datenbankserver reicht ein LOAD DATA INFILE aus. Allerdings sind ein paar Kniffe notwendig:

LOAD DATA LOCAL INFILE 'C:\\Software\\access_20130514.log'
INTO TABLE apache.accesslog
FIELDS TERMINATED BY ' '
OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY '\r\n'
(ip, ident, userid, @t1, @t2, request, statuscode, size, referer,
useragent)
SET momentum = CONCAT(@t1, ' ', @t2);

Die Logdatei wird dabei wie ein CSV behandelt, nur dass die einzelnen Felder nicht per Semikolon voneinander getrennt sind, sondern durch ein Sonderzeichen. Um Zeichenkette mit potentiellen Spaces korrekt zu behandeln, wird definiert, dass einzelne Felder im Zweifel durch doppelte Leerzeichen eingefasst sind, so beispielsweise der User Agent. Der letzte Stolperstein ist das Datum, das aus der Tages- und Zeitangabe besteht. Da diese durch ein Leerzeichen getrennt sind, würde das LOAD DATA diese eigentlich getrennt voneinander einlesen. Hier im Beispiel werden diese beiden Werte allerdings per CONCAT wieder aneinander gesetzt und gemeinsam eingelesen.

Mehr Arbeit bedarf es nicht. Es mag sein, dass der LOAD DATA INFILE Befehl einige Warnungen erzeugt, wenn in der Datei fehlende Werte auftreten. Dies zu beheben ist allerdings nicht schwer.

30. Oktober 2013
von (sr)
Keine Kommentare

Noch schneller zu PHP&MySQL auf Google+

Google verteilt derzeit in seinem sozialen Netzwerk neue, sprechende URLs. Auch Webseiten kommen in den Genuß, sofern Sie sich verifiziert haben. Auf diese Weise sind wir auch zu einem sprechenden Namen gekommen und heißen nun +phpundmysqlde hinter dem google.com/. Alternativ funktioniert auch noch der alte Weg über 111078111579125891417, wer mag.

7. April 2013
von (sr)
Keine Kommentare

PHP 5.5 und Apache unter Windows installieren

Die Installation von PHP5.5 mit Apache Webserver unterscheidet sich nur geringfügig von der Vorgängerversion, die wir in unserem Buch „PHP 5.4 und MySQL 5.5“ beschrieben haben. Um ein lauffähiges Testsystem zu erstellen, setzen wir zuerst einen eigenen Apache Webserver auf, laden uns danach einen aktuellen Snapshot von PHP herunter, konfigurieren beides und lassen danach eine Handvoll Testskripte laufen.

Die Anleitung bezieht sich auf unser lokales Testsystem mit einem 64-Bit Windows. Beim Download der Komponenten werden wir uns also immer dazu passenden Versionen besorgen. Bei denselben Quellen sind aber immer auch die 32-Bit Versionen zu bekommen.

1. Den Apache Webserver herunterladen

Die PHP5.5 Snapshots für Windows sind mit Visual Studio 2012 kompiliert. Aus diesem Grund müssen wir darauf achten, einen kompatiblen Webserver zu verwenden. Diesen bekommen wir auf der Webseite http://www.apachelounge.com/download/additional/. Beachtet den Hinweis, dass diese Version nicht mit Windows XP funktioniert! Folgt dem Link „httpd-2.4.4-win64-VC11 & modules“ (ggf. hat sich seit dem Schreiben dieser Anleitung die Versionsnummer auf 2.4.x geändert) und ladet euch die Datei „httpd-2.4.4-win64-VC11-upd2.zip“ herunter (der Versionshinweis von eben gilt natürlich auch hier). In diesem Archiv befindet sich ein Ordner namens Apache24, entpackt diesen in ein neues Verzeichnis (z.B. C:\wap, steht für Windows-Apache-PHP). Der Einfachheit halber benennt den Ordner „Apache24“ in „apache“ um; am Ende sollte die Ordnerstruktur bislang wie folgt aussehen:

C:
+- wap
  +- apache
    +- der ganze apache kram wie bin, conf, etc...

Wie bereits erwähnt verwenden wir Komponenten, die mit Visual Studio 2012 kompiliert worden ist. Um das zum Laufen zu kriegen, muss auf eurem Rechner „Visual C++ Redistributable für Visual Studio 2012“ installiert sein. Ob diese Bibliotheken bereits installiert sind, erfahrt ihr in eurer Systemsteuerung unter dem Punkt „Programme und Features“ (siehe folgende Abbildung). Ansonsten bekommt ihr diese auf der Microsoft Webseite mit dem wenig sprechenden Linktitel http://www.microsoft.com/de-de/download/details.aspx?id=30679. Achtet auch hier auf die korrekte Version, im Zweifel könnt ihr euch auch beide installieren – d.h. die 32-Bit und die 64-Bit Version.

2. Den PHP 5.5 Snapshot herunterladen

Nachdem wir den Apache soweit entpackt haben, besorgen wir uns eine aktuelle Version von PHP. Im Releaseprozess gibt es mehrere Alpha- und Beta-Versionen. Allerdings werden so genannte Snapshots auf mehr als täglicher Basis ins Netz gestellt. Die Snapshots für Windows finden sich unter http://windows.php.net/downloads/snaps/php-5.5/. Unter dieser Adresse findet ihr eine lange, zeitlich sortierte Liste von Verzeichnissen. Ganz unten sind die neuesten Versionen (während der Erstellung dieser Anleitung ist beispielsweise das Verzeichnis http://windows.php.net/downloads/snaps/php-5.5/re769025/ das neueste). Jedes dieser Verzeichnisse enthält mehrere PHP Versionen, die entweder zum Debuggen, zum Testen etc gedacht sind.

Passend zu unserem vormals installierten Apache Webserver wählen wir die „Thread Safe VC11 x64“ (nicht wundern, dass Visual C++ für Visual Studio 2012 mit VC11 abgekürzt ist (!) ), die den Dateiname php-5.5-ts-windows-vc11-x64-re769025.zip trägt. Den Inhalt dieses Archivs entpacken wir in einen Ordner namens „php“ unter C:\wap. Und wenn wir schon einmal dabei sind, Verzeichnisse anzulegen, erstellen wir unter C:\wap auch gleich noch htdocs (für unsere PHP Skripte) und tmp (für temporöre Dateien und Sessions). Danach sieht unser Verzeichnisbaum so aus:

C:
+- wap
  +- apache
    +- der ganze apache kram wie bin, conf, etc...
  +- htdocs (noch leer)
  +- php
    +- der ganze php kram wie ext, extras und logs
  +- tmp (noch leer)

3. Die Konfiguration von Apache und PHP

Nach den vorigen beiden Schritten haben wir alles auf der Festplatte, was wir bis hierher benötigen. Allerdings müssen wir die beiden Komponenten noch einrichten, damit diese auch nahtlos miteinander funktionieren. Im Folgenden werden wir bei Pfadangaben in den Konfigurationsdateien immer darauf achten, dass wir diese relativ angeben. Ziel ist es, dass wir im Nachhinein den Ordner C:\wap auch umbenennen oder an eine andere Stelle kopieren/verschieben können, ohne die Konfiguration anpassen zu müssen (im Fachjargon: wir machen uns eine portable Version daraus).

Ein gut gemeinter Tipp zur Konfiguration: Anstatt die Dateien durchzuscrollen, lohnt sich der Einsatz der Suchfunktion eures Texteditors. Die Kür ist ein „Alle Vorkommen suchen“, wie es beispielsweise Notepad++ bietet. Verwendet kein Suchen/Ersetzen, weil die gefundenen Stellen nicht eindeutig sein müssen! Beachtet dazu in den folgenden Auflistungen die Kommentare in Klammern.

Nehmen wir uns zuerst die Datei C:\wap\php\php.ini vor: Diese existiert im Initialzustand noch gar nicht. Im selben Verzeichnis befindet sich aber eine Datei namens php-ini-development, von der wir uns eine Kopie mit dem Namen php.ini machen und mit einem Texteditor öffnen.

Zuerst geben wir an, wo die Extensions/Module (wie z.B. die MySQLi-Schnittstelle) liegen. Dazu geben wir der Definition von extension_dir den Wert "..\..\php\ext". Das Verzeichnis ist relativ zu der Apache-Konfigurationsdatei httpd.conf angegeben. Danach aktivieren wir einige grundlegende Extensions, indem wir das Semikolon am Zeilenanfang entfernen. Eine gute Wahl ist immer curl, gd2, mbstring, mysqli, sockets und xmlrpc. Bei Bedarf (de-)aktiviert andere oder weitere. Welche ihr später braucht, erfahrt ihr im Zweifel dann, wenn bei der Ausführung eines PHP Skripts entsprechende Fehlermeldungen zu fehlenden Extensions auftreten.

Zu guter letzt legen wir noch bei upload_tmp_dir und session.save_path das bisher leeres tmp-Verzeichnis mit "..\tmp" fest.

Das wars soweit mit der PHP Konfiguration, als nächstes öffnen wir die bereits vorhandene Datei C:\wap\apache\conf\httpd.conf. Hierin müssen wir eine ganze Reihe von Anpassungen machen. Der Einfachheit halber listen wir sie nur auf. Dabei gilt: Sucht in eurem Texteditor nach dem unterstrichenden Begriff und ändert ihn in den kursiven Begriff. Steht dort nur ein kursiver Begriff, fügt die Zeile an der genannten Stelle (in Klammern) hinzu:

  • ServerRoot „c:/Apache24“ –> ServerRoot „..“
  • Listen 80 –> Listen 82
  • LoadModule php5_module „../php/php5apache2_4.dll“ (an Ende des Blocks der LoadModule Anweisungen etwa in der Mitte der Datei)
  • #ServerName www.example.com:80 –> ServerName localhost:82
  • Require all denied (im Block unter <Directory />) –> Require all granted
  • DocumentRoot „c:/Apache24/htdocs“ –> DocumentRoot „../htdocs“
  • <Directory „c:/Apache24/htdocs“> –> <Directory „../htdocs“>
  • DirectoryIndex index.html –> DirectoryIndex index.php index.html
  • AddType application/x-httpd-php .php (an das Ende der Direktive <IfModule mime_module>, also z.B. hinter AddType application/x-gzip .gz .tgz)
  • PHPIniDir ../php (als letzte Zeile der Datei hinzufügen)

Was haben wir hier getan? Im Einzelnen wollen wir nicht drauf eingehen, sondern auf die Dokumentation verweisen. Nur grob: Wir haben den Apache so eingerichtet, dass er nach notwendigen Pfaden relativ schaut, anstatt diese absolut zu verwenden. Darüber hinaus haben wir den Server auf Port 82 eingerichtet und nicht wie standardmäßig auf Port 80. Das haben wir aus dem Grund gemacht, falls zufällig schon eine Anwendung wie etwa Skype oder ein anderer Apache den Port 80 belegt. Außerdem haben wir PHP als Modul eingebunden, einen Verweis auf die php.ini gelegt und die index.php als Standarddatei für URL ohne Dateiangabe festgelegt. So wird der Apache also zukünftig die Datei c:\wap\htdocs\index.php verarbeiten, wenn wir im Browser die URL http://localhost:82 eingeben. Zu guter Letzt haben wir durch „Require all granted“ Tür und Tor geöffnet, so dass wir keine Forbidden-Fehlermeldungen bekommen werden; Dies ist nur für lokale Testserver ratsam!

4. Erste Tests

Den Server starten wir erst einmal über die Kommandozeile (Win+R). Dort wechseln wir mit dem Kommando

cd c:\wap\apache\bin

in das richtige Verzeichnis und starten den Server mit httpd.exe. Wenn an dieser Stelle keine Fehlermeldungen kommen, ist bei der Konfiguration alles glatt gegangen. Als nächstes legen wir drei Testskripte im Ordner c:\wap\htdocs an: Zuerst prüfen wir, ob wir es wirklich mit PHP5.5 zu tun haben (wir nennen die Datei phpinfo.php)

<?php phpinfo(); ?>

Das Ergebnis dürfte wir folgt aussehen:

Von nun an können wir mit dem neuen System arbeiten und uns etwa Standardbespiele aus der PHP 5.5 Featureliste vornehmen, nämlich Generatoren und die Password-API.

Viel Spaß dabei!