how-to: railo / resin installation on ubuntu minimal os

I hope this tutorial will save you a few hours of trouble, it’s a complete step-by-step tutorial of a railo/resin installation on Linux Ubuntu OS.
You’ll be able to deliver cfml via port 8600 and apache-port 80 as well.

If you prefer the german version, click here

First of all, you need some compliler-tools, wget for downloading the sources, the java enviroment and additional apache-modules (for example apxs2).

sudo apt-get install build-essential
sudo apt-get install apache2 sun-java6-jdk
sudo apt-get install wget
sudo apt-get install apache2-threaded-dev

Now go to http://www.getrailo.org/index.cfm/download/ and download the current railo server version (all os version without jre).
In my case this was today:

wget http://www.getrailo.org/down.cfm?item=/railo/remote/download/3.1.2.001/server/all/railo-3.1.2.001-resin-without-jre.tar.gz

Now move the tarball to /opt/ and extract the tarball:

mv railo-3.1.2.001-resin-without-jre.tar.gz /opt/.
tar -xvzf railo-3.1.2.001-resin-without-jre.tar.gz

Create a symlink and change the user for your convinience:

sudo ln -s railo-3.1.2.001-resin-without-jre railo
sudo chown -R username railo

Grats, Railo and Resin ist installed now. Please start the shellscript:

./opt/railo/bin/httpd.sh

Run the service in background using (currently railo/resin would stop after closing the shell)

./opt/railo/bin/httpd.sh &

Now you can browse to http://domain.com:8600 ant a test page should appear. From here you can navigate to the railo admin located under http://cfml.domain.com/railo-context/admin/web.cfm.

Now we have to explain apache that it should deliver cfml:

cd /opt/railo
sudo ./configure --with-apxs=/usr/bin/apxs2
sudo make
sudo make install

Warning: if an error occures while doing the configure or make, the makefile isn’t right. In that case please got to /opt/railo/ and rename the Makefile.in to Makefile.in.bak. Then rename the Makefile.am to Makefile.in:

root@blabla:/opt/railo# mv Makefile.in Makefile.in.bak
root@blabla:/opt/railo# mv Makefile.am Makefile.in

Then execute an „make clean“ in the directory /opt/railo/ and do the configure,make an make install again, it will run correctly now.
Remember to restart apache:

sudo /etc/init.d/apache2 restart

Now you can access the railo admin via apache, too: http://domain.com/railo-context/admin/web.cfm
Browse to http://domain.de/caucho-status to see the status of mod-caucho.

At least you have to configure the apache vhost and the resin.conf to provide multiple hosts. Here’s an example:

less /etc/apache2/sites-available/default

Define one more virtual host:

<VirtualHost *:80>
ServerName playgroundcfml.domain.com
ServerAdmin webmaster@localhost
DocumentRoot /var/www/playground/
<Directory /var/www/playground/>
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
</Directory>
ErrorLog /var/log/apache2/error.log
LogLevel warn
CustomLog /var/log/apache2/access.log combined
ServerSignature On
</VirtualHost>

Restart apache again and create the host entry on your local machine. The last point is to tell resin.conf the host:

less /opt/railo/conf/resin.conf

search for the host definition beginning:

<!-- configures the default host, matching any host name -->
<host id="" root-directory=".">

after the closing </host> you should add:

<host id="playgroundcfml.domain.com">
<root-directory>/var/www/playground</root-directory>
<web-app id="/">
<document-directory></document-directory>
</web-app>
</host>

Furthermore it is important to define the right port in the following tag – here’s the setting how apache webserver will talk to resin server:

<!-- define the servers in the cluster -->
<server id="" address="127.0.0.1" port="6800">
</code>

Resin will discover the changes automatically and restart the service, you'll not to do that on your own.
That's all, enjoy!

CFML ausliefern mit Railo / Resin Installation auf Ubuntu Server

Dieses How-To könnte Euch einiges an Arbeit sparen, ich zeige Schritt für Schritt auf, wie man einen Railo-Server mit Resin unter Ubuntu aufsetzt, cfm kann dann über Port 8600 ausgeliefert werden, außerdem konfigurieren wir den Apachen für die CFML-Auslieferung.

Please note: version in english is here

Ich gehe von einem minimal installiertem Ubuntu-System aus. Als erstes benötigt man das Paket build-essential, das uns die grundlegenden Tools für das Kompilieren zur Verfügung stellt, außerdem brauchen wir noch wget, Java und einige Komponenten (zum Beispiel apxs2), die beim normalen Apache nicht beiliegen, deswegen würde ich zu Beginn empfehlen:

sudo apt-get install build-essential
sudo apt-get install apache2 sun-java6-jdk
sudo apt-get install wget
sudo apt-get install apache2-threaded-dev

Geht nun auf http://www.getrailo.org/index.cfm/download/ und holt Euch die aktuelle Version vom Railo Server (all OS Version ohne JRE).

In meinem Fall war das heute:

wget http://www.getrailo.org/down.cfm?item=/railo/remote/download/3.1.2.001/server/all/railo-3.1.2.001-resin-without-jre.tar.gz

Verschiebt den Downlaod nach /opt/ und entpackt den Tarball dort:

mv railo-3.1.2.001-resin-without-jre.tar.gz /opt/.
tar -xvzf railo-3.1.2.001-resin-without-jre.tar.gz

Nun könnt Ihr einen Symlink einrichten und den User anpassen, um das Handling zu erleichtern:

sudo ln -s railo-3.1.2.001-resin-without-jre railo
sudo chown -R username railo

So, nun sollte Railo und Resin bereits fertig installiert sein, startet das Shellscript

./opt/railo/bin/httpd.sh

Dann solltet Ihr in der Konsole bereits die Ausgaben sehen. Als Hintergrundprozess laufen lassen könnt Ihr Railo/Resin mit

./opt/railo/bin/httpd.sh &

Damit läuft der Dienst auch weiter, wenn die Konsole wieder geschlossen wird. Wenn Ihr nun im Browser die URL http://domain.de:8600 aufruft, dann sollte bereits die Testseite mit Link zum Railo-Admin erscheinen.

Nun lassen wir den Apache noch cfml ausliefern, macht bitte als root Folgendes:

cd /opt/railo
sudo ./configure --with-apxs=/usr/bin/apxs2
sudo make
sudo make install

Achtung: sollte das so nicht fuktionieren und Fehler beim configure oder make auftauchen, dann ist das Makefile.in aus der Distribution nicht korrekt. In diesem fall geht Ihr nach /opt/railo/ und sichert Euch die Makefile.in weg, umbenennen in Makefile.in.bak und benennt Euch die Makefile.am um in Makefile.in

root@blabla:/opt/railo# mv Makefile.in Makefile.in.bak
root@blabla:/opt/railo# mv Makefile.am Makefile.in

Danach in /opt/railo/ ein make clean in der Konsole ausführen und das configure, make und make install von oben nochmals durchführen, es wird nun problemlos durchlaufen.

Nun muss der Apache neu gestartet werden:

sudo /etc/init.d/apache2 restart

Nun solltet Ihr den Railo-Administrator auch unter http://domain.de/railo-context/admin/web.cfm aufrufen können, CFML wird also auch vom Apachen ausgeliefert. Unter der URL http://domain.de/caucho-status seht Ihr die Informationen zum Mod Caucho.

Jetzt werden wir die Apache-Config und die Resin-Config anpassen, um multiple Hosts definieren zu können, anhand des nachstehenden Beispiels könnt Ihr vorgehen:

less /etc/apache2/sites-available/default

Hier definiert Ihr nun einen weiteren Virtual Host:

<VirtualHost *:80>
ServerName playgroundcfml.hetzner.de
ServerAdmin webmaster@localhost
DocumentRoot /var/www/playground/
<Directory /var/www/playground/>
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
</Directory>
ErrorLog /var/log/apache2/error.log
LogLevel warn
CustomLog /var/log/apache2/access.log combined
ServerSignature On
</VirtualHost>

Apache wiederum restarten nach dieser Änderung ( /etc/init.d/apache2 restart), wenn Ihr Euch dann einen entsprechenden Eintrag in Eure lokale Hosts gmacht habt, sollte das mit HTML-Files bereits klappen. Nun gleichen wir die Resin-Konfiguration noch an:

less /opt/railo/conf/resin.conf

Hier sucht Ihr am besten nach dem bereits definierten host, der so beginnt:

<!-- configures the default host, matching any host name -->
<host id="" root-directory=".">

Nach dem schließendem </host> dieser Definition fügt Ihr Euren neuen Eintrag hinzu:

<host id="playgroundcfml.hetzner.de">
<root-directory>/var/www/playground</root-directory>
<web-app id="/">
<document-directory></document-directory>
</web-app>
</host>

Wichtig ist desweiteren, dass der Port im nachstehenden Tag passt, denn dort wird festgelegt, wie der Apache Webserver mit dem Resin-Server spricht:

<!-- define the servers in the cluster -->
   <server id="" address="127.0.0.1" port="6800">
</code>

Resin sollte die Änderung der Config automatisch bemerken und sich selber restarten, danach seid Ihr auch in der Lage, CFML direkt für diese Vhost-Definition auszuführen. Viel Spass damit, ich hoffe, diese Anleitung hat Euch etwas Zeit gespart.

Installation von Railo mit Tomcat und Apache unter Debian Linux (Teil 1)

Folgende Anleitung soll Euch helfen, Websites mit der kostenlosen Alernative zu Adobe Coldfusion Railo unter Debian zusammen mit Tomcat und Apache zu servieren. 

Als erstes wird ein Java benötigt, falls das noch nicht zur Verfügung steht. Dies sollte problemlos mittels folgendem Befehle machbar sein:

sudo apt-get install sun-java6-jdk

Als nächstes holen wir den Tomcat und entpacken ihn, bei mir aktuell war die Version 6.0.20 (die neueste Version solltet Ihr jeweils unter http://tomcat.apache.org/download-60.cgi finden)

wget http://apache.mirror.digionline.de/tomcat/tomcat-6/v6.0.20/bin/
apache-tomcat-6.0.20.tar.gz
tar zfvx apache-tomcat-6.0.20.tar.gz

Nach dem Download per wget wird der Tomcat in ein permanentes Verzeichnis verschoben, zum Beispiel so:

mv apache-tomcat-6.0.20 /usr/local/tomcat

Dann dafür sorgen, dass sich der Tomcat automatisch mitstartet bei Server-Start, dazu wird die Datei /etc/init.d/tomcat editiert, hier kommen folgenden Zeilen rein:

# Tomcat auto-start
#
# description: Auto-starts tomcat
# processname: tomcat
# pidfile: /var/run/tomcat.pid

export JAVA_HOME=/usr/lib/jvm/java-6-sun

case $1 in
start)
sh /usr/local/tomcat/bin/startup.sh
;;
stop)
sh /usr/local/tomcat/bin/shutdown.sh
;;
restart)
sh /usr/local/tomcat/bin/shutdown.sh
sh /usr/local/tomcat/bin/startup.sh
;;
esac
exit 0

Das Script muss ausführbar sein und beim Serverstart ausgeführt werden. Deswegen noch diese Anpassungen:

chmod 755 /etc/init.d/tomcat
vi /etc/init.d/tomcat
ln -s /etc/init.d/tomcat /etc/rc1.d/K99tomcat
ln -s /etc/init.d/tomcat /etc/rc2.d/S99tomcat

Gut, soweit fertig, der Tomcat sollte nun laufen. Gestoppt/Gestartet wird mit

/etc/init.d/tomcat start

Nun das Railo holen, entpacken und ins lib-Verzeichnis vom Tomcat legen:

wget http://www.getrailo.org/down.cfm?item=/railo/remote/download/
3.1.2.001/custom/all/railo-3.1.2.001-jars.tar.gz

tar zxvf railo-3.1.2.001-jars.tar.gz
mv railo-3.0.1.000-jars/ /usr/local/tomcat/lib

Nun muss die Konfigurationsdatei /usr/local/tomcat/conf/web.xml bearbeitet werden, da muss noch zusätzlich rein:

<servlet>
<servlet-name>CFMLServlet</servlet-name>
<servlet-class>railo.loader.servlet.CFMLServlet</servlet-class>
   <init-param>
      <param-name>configuration</param-name>

      <param-value>{web-root-directory}/WEB-INF/railo/</param-value>
      <description>Configuraton directory</description>
   </init-param>
   <load-on-startup>1</load-on-startup>

</servlet>
<servlet-mapping>
   <servlet-name>CFMLServlet</servlet-name>
   <url-pattern>*.cfm</url-pattern>
</servlet-mapping>
<servlet-mapping>

   <servlet-name>CFMLServlet</servlet-name>
   <url-pattern>*.cfml</url-pattern>
</servlet-mapping>
<servlet-mapping>
   <servlet-name>CFMLServlet</servlet-name>

   <url-pattern>*.cfc</url-pattern>
</servlet-mapping>

Im Element <welcome-file-list> muss noch folgende Ergänzung gemacht werden:

<welcome-file>index.cfm</welcome-file>
<welcome-file>index.cfml</welcome-file>

Unter Port 8080 sollte nun bereits das Railo mit dem Tomcat zusammenarbeiten, wir können cfml ausliefern.

Wie cfml auch über Port 80 mittels mod_proxy und mod_ajp ausgeliefert werden kann, werde ich einem seperaten Teil beschrieben

symbolischen Link zu Datei oder Ordner setzen

Unter Linux lann man symbolische Links zu einer Datei oder einem Ordner setzen,  so kann man bequem übers Dateisystem Verknüpfungen anlegen.
Ein Symlink ist lediglich eine Referenz und kein richtiges Element.

Hier eine beispielhafte Verwendung von ln:

ln -s /directory_1/file_1 /directory_2/file_2

Mit diesem Befehl wird also von /directory_1/file_1 ein Link zu /directory_2/file_2 gesetzt.

Mehr Informationen zu symbolischen Links gibt’s bei Wikipedia

Ubuntu: Passwort vergessen, was nun?

Vielleicht ist’s Euch ja auch schonmal passiert: am alten Ersatz-Rechner mit Ubuntu-Installation, den man nur alle paar Monate benutzt, habt Ihr das Passwort vergessen..nun gut, halb so wild: falls das Ubuntu das einzige installierte Betriebssystem ist (sind mehrere Betriebssysteme installiert, erscheint der Bootloader sowieso), kann man durch Drücken der ESC-Taste den Bootloader GRUB aufrufen und hier als Option das Starten von Ubuntu im Recovery Mode auswählen. Danach hat man im Terminal-Fenster Root-Rechte und kann mit dem Befehl

passwd <username>

das Passwort von jedem User leicht ändern. Nun nochmal das Passwort bestätigen und speichern, beim nächsten Anmelden ist es dann aktiv.

OS X ist ein zuverlässiges Betriebs-System

OS X ist ein ausgereiftes und sicheres Betriebssystem. Wenn Sie Vista für toll halten, gehen Sie doch mal in den nächsten Apple-Store und probieren Sie OS X einfach mal aus. In der Tat besteht die größte Schwierigkeit darin, die von Windows konditionierte komplizierte Denkweise aus dem Kopf zu kriegen – oft ist ein Task unter OS X so schnell und einfach zu erledigen, dass man als Windows-gewohnter Nutzer einfach nicht drauf kommt!

OS X ist ein leicht zu bedienendes Betriebssystem, das auch gut mit Windows, UNIX und LINUX Computern zusammenspielt, außerdem setzt es prinzipiell keine besonderen Computer-Kenntnisse beim Benutzer voraus.

Die technische Basis unter dem wirklich schön gestalteten User-Interface von OS X ist BSD UNIX, das bereits über 30 Jahre Entwicklungszeit hinter sich hat (also fast doppelt so viel wie Windows). Während heutzutage jeder 12-jährige einen Virus für Windows schreiben (oder zusammenklicken) kann, ist das Entwickeln eines Schädlings für OS X wesentlich anspruchsvoller und ein viel größerer Aufwand, den die allermeisten Viren-Programmierer doch scheuen.

Zippen aller Dateien in einem Verzeichnis

Auf der Shell kann man diese oft wiederkehrende Aufgabe bequem erledigen:

for f in `find . -name '*'`; do zip -j ${f%.*}.zip $f; done

Zur Erklärung:
mit einer Schleife durchläuft der Find-Befehl alle Dateien (hier könnte zwischen den einfachen Anführungszeichen auch ein beliebiger String stehen). Innerhalb der Schleife wird dann aus jeder Datei ein Zip-File mit dem entsprechenden Namen angelegt.

weiteres Beispiel:

for f in `find . -name '*.pdf'`; do zip -j ${f%.*}.zip $f; done

hier werden alle PDF-Files in einem Verzeichnis gezippt, die anderen Dateitypen in dem Verzeichnis bleiben unberührt

Passend dazu gibt’s hier den Aufruf von Shellscripten mit Coldfusion.