I run in some troubles to install Node.JS on Raspbian soft-float image and also when you wanted to compile it for yourself you need some time. Luckily there is an ARM binary package for Raspberry Pi (See ‘other release files’ on Node.JS download section).

For this tutorial you need:

• Raspberry Pi
• SD card at least 4GB
• HDMI to DVI Converter – to plug the Raspberry Pi to your monitor
• micro usb charger – for the power supply
• Network cable and internet connection
• Node.JS 0.10.x ARM binary package
• Raspbian ‘wheezy’ hard-float image (2013-02-09)

Note: We will use Node.JS 0.10.2 in this tutorial because the ARM binary package for 0.10.3 was not yet available. But I think when the new ARM package is available this tutorial should also work with the new minor release.

Install Raspbian on your SD Card

Download Raspian “wheezy” (hard-float, 2013-02-09-wheezy-raspbian) and install it on your SD card. There are plenty of tutorials which shows you how to install Raspbian on your SD card. Have a look at the following tutorials how you can install Raspbian on your SD card.

• Raspberry Pi Quick start guide
• A Beginner’s Guide to DIYing with the Raspberry Pi

Note: You have to use the Raspbian hard-float image. With the soft-float image the Node.JS ARM binary will not work.

Configure your Raspberry Pi

Plug in your usb micro charger and Rasberry Pi will boot up and display the
raspi-config dialog.

These are the configuration steps you should do with ‘raspi-config’ after the first time you start your Raspberry Pi:

• expand_rootfs – select expand_rootfs to expand the root partition to fill out the whole SD card
• memory_split – we reduce the GPU to the minimum (16mb), because we will not start intensive graphical tasks.
• change_pass – change password for ‘pi’ user. The user ‘pi’ is the preconfigured user in Raspbian
• ssh – enable the ssh server, so that we can use ssh to log in from remote.
• You should also adapt the keyboard, timezone and locale to your needs. When you are finished select finish to end the configuration.

After the configuration you need to restart your system, so that the resizing of the root partition and memory split will work.

sudo reboot

You can always change your settings again with ‘raspi-config’.

sudo raspi-config

After the restart, login in with the user ‘pi’ and the new password you have choosen. Now we need to update our system with ‘apt-get’ our package manager.

sudo apt-get update
sudo apt-get upgrade

With no further network changes your Raspberry Pi will use DHCP to get a dynamic IP adress. So we are going to change this to a fixed IP adress. Because we will use our system as Node.JS server and this is quite simpler with a fixed IP adress. You can also work with a dynamic IP adress and just skip the following step.

To change the system to a fixed IP adress just open the interface configurartion file. For that we use the preinstalled editor ‘nano’.

sudo nano /etc/networks/interfaces

Replace the following lines for your network device eth0 and just adapt the settings to your network (e.g. IP, gateway, dns, etc.) configuration.

iface eth0 inet static
address 10.0.0.40
netmask 255.255.255.0
gateway 10.0.0.1
nameserver 10.0.0.1

After the changes in the network configuration file just stop and start your network device with ‘ifdown’ and ‘ifup’.

sudo ifdown eth0
sudo ifup eth0

Yo can try now from a remote system to connect with the user ‘pi’ over SSH to our Raspberry Pi.

ssh pi@10.0.0.40

Installing Node.JS

We will download the ARM binary package from Node.JS and create the directory /opt/node where we want Node.JS installed. We will not place Node.JS in ‘/usr/local’, instead we use a separate directory for Node.JS, this way it is much easier to update a manually installed package.

sudo mkdir /opt/node

The next step is to dowload the Node.JS ARM binary package, unpack it and copy the content to our node directory /opt/node.

wget http://nodejs.org/dist/v0.10.2/node-v0.10.2-linux-arm-pi.tar.gz
tar xvzf node-v0.10.2-linux-arm-pi.tar.gz
sudo cp -r node-v0.10.2-linux-arm-pi/* /opt/node

Finally we have to add Node.JS to our path variable. For that you have to edit the ‘/etc/profile’ configuration file.

nano /etc/profile

Add the following lines to the configuration file before the ‘export’ command.

...
NODE_JS_HOME="/opt/node"
PATH="$PATH:$NODE_JS_HOME/bin"
export PATH
...

Yo need now to logout and log in again, so that the changed path variable will work.

logout

Configure Node.JS

We need now a start script for Node.JS. Our script will start the Node.JS with the user ‘pi’ and look for a server.js file in the /home/app directory. The output stream from Node.JS will be stored in the file nodejs.log. Just create the file nodejs.sh in your current directory with the following content:

#!/bin/bash

NODE=/opt/node/bin/node
SERVER_JS_FILE=/home/pi/app/server.js
USER=pi
OUT=/home/pi/nodejs.log

case "$1" in

start)
	echo "starting node: $NODE $SERVER_JS_FILE"
	sudo -u $USER $NODE $SERVER_JS_FILE > $OUT 2>$OUT &
	;;

stop)
	killall $NODE
	;;

*)
	echo "usage: $0 (start|stop)"
esac

exit 0

Note: When yo want to use a privileged port (TCP/IP port numbers below 1024) you have to start the script as root.

Make the script executable with ‘chmod’ and copy it to ‘/etc.init.d’. The last step is to register the script as service with ‘update-rc.d’. Then our Node.JS server will automatically start up when the Raspberry Pi is powered on.

chmod 755 nodejs.sh
sudo cp nodejs.sh /etc/init.d
sudo update-rc.d nodejs.sh defaults

The last step is to create a Node.JS server.js file in our /home/pi/app directory. The directory ‘/home/pi/app’ will be our Node.JS project directory.

mkdir /home/pi/app

The ‘server.js’ file is just a simple Node.JS server which will listen on port 8080 and display ‘Hello World’ and write some output to the console. Just place the following content as ‘server.js’ file in directory ‘/home/pi/app’.

var http = require('http');

http.createServer(function(req,resp) {
	resp.writeHead(200, {"Content-Type": "text/plain"});
	resp.write("Hello World");
	resp.end();
	
	console.log("sample output to console");

}).listen(8080);

Start Node.JS

It’s time to start Node.JS with our start script and see if it all fits together.

sudo /etc/init.d/nodejs.sh start

Open a browser with the url http://10.0.0.40:8080. You should now see a page which displays ‘Hello World’ and the output from the console.log() statement in the /home/pi/node.log file.

To stop Node.JS just enter

sudo /etc/init.d/nodejs.sh stop

When you want to use ‘npm’ or ‘node’ as root with sudo you have to add the ‘-i’ option, so that the root user’s environment is acquired. For example when you want to install the package ‘forever’ globally with ‘npm’.

sudo -i npm install forever -g

Update Node.JS to a new version

To update Node.JS to a new version just follow the next steps. Also check first if there is an ARM package available.

delete the old version

# sudo rm /opt/node -r

create new directory

# sudo mkdir /opt/node

unpack the new version and copy the content to our node.js directory. Replace ‘x’ with the new minor version.

# tar xvzf node-v0.10.x-linux-arm-pi.tar.gz
# sudo cp -r node-v0.10.x-linux-arm-pi/* /opt/node

Check current version

# node -v
v0.10.2

I hope this tutorial was useful for you and will give you some quick start to play around with Node.JS and Raspberry Pi.

Download Twitter Bootstrap and place the bootstrap.min.css and bootstrap-responsive.min.css in the css directory. Create an empty file with the name test.html. The content of your directory should look like this.

test.html
css --- bootstrap.min.css
     |- bootstrap-responsive.min.css   

To use RWD the following meta tag and the bootstrap-responsive.min.css css file are needed.

<meta name="viewport" content="width=device-width, 
       initial-scale=1.0">
<link href="css/bootstrap-responsive.min.css" 
       rel="stylesheet">

In the test.html page are three buttons. One button is shown only for mobile, one for tablets and the last one only for desktops environments. The following example shows the test.html file with responsive web design enabled and the three buttons.

<!DOCTYPE html>
<html>
  <head>
    <title>Bootstrap 101 Template</title>
    <!-- Bootstrap -->
    
    <meta name="viewport" content="width=device-width, 
       initial-scale=1.0">
    <link href="css/bootstrap-responsive.min.css" 
       rel="stylesheet">
    <link href="css/bootstrap.min.css" 
       rel="stylesheet" media="screen">
    
  </head>
  <body>
    <h1>Hello, world!</h1>
	
    <button class="btn btn-large btn-primary visible-desktop" 
       type="button">Desktop</button>
    <button class="btn btn-large btn-danger visible-tablet" 
       type="button">Tablet</button>
    <button class="btn btn-large btn-success visible-phone" 
       type="button">Mobile</button>
	
  </body>
</html>

There are css classes for showing an element for a specific environment (e.g. visible-phone) and to hide it (e.g. hidden-phone). There are three environments phone, tablet and desktop.

To show the button only for a mobile environment just place the css class visible-phone to the button element.

<button class="btn btn-large btn-success visible-phone" 
       type="button">Mobile</button>

To test the page with a mobile or tablet device we can emulate this in chrome with the chrome developer tools. Just open the settings in chrome developer tools and pick the right user agent and device metrics (e.g. Android 4.0.2 – Galaxy Nexus).

When we visit our html page with a mobile device or emulate a mobile device with the chrome developer tools, then the right button should be displayed.

As you can see working with responsive design and Twitter Bootstrap is straightforward. For more details about responsive web design (RWD) and Twitter Bootstrap have a look at http://twitter.github.com/bootstrap/scaffolding.html#responsive

For our homegrown private cloud solution we will install an Ubuntu Server which hosts our VirtualBox virtual machines and a load balancer which will distribute the work load to different virtual servers. The whole network setup should look like this:

• The VirtualBox server atlas with IP 10.0.0.50
• virtual server zeus1 with IP 10.0.0.71
• virtual server zeus2 with IP 10.0.0.72
• A load balancer which distributes our workload for port 80 (http) to zeus1 and zeus2

Install Ubuntu server as VirtualBox server

This server will be our VirtualBox server which hosts our virtual machines. Install Ubuntu Server with the following package.

• OpenSSH Server

For this example our VirtualBox server has the following IP address and hostname.

• hostname: atlas
• IP: 10.0.0.50

Change the network settings in /etc/network/interfaces. You may also adapt the gateway and dns-nameserver settings.

auto eth0
iface eth0 inet static
        address 10.0.0.50
        netmask 255.255.255.0
        network 10.0.0.0
        broadcast 10.0.0.255
        gateway 10.0.0.1
        dns-nameservers 10.0.0.1

Also change the hostname in /etc/hostname and don’t forget to update the /etc/hosts file.

After a fresh installation we need to to upgrade Ubuntu.

sudo apt-get update
sudo apt-get upgrade

sudo apt-get install linux-headers-$(uname -r)

#
# VirtualBox for Ubuntu 12.04 (Precise Pangolin)
#
deb http://download.virtualbox.org/virtualbox/debian precise contrib

wget -q http://download.virtualbox.org/virtualbox/debian/oracle_vbox.asc -O- | sudo apt-key add -

sudo apt-get update
sudo apt-get install virtualbox-4.2

sudo apt-get install dkms

sudo VBoxManage extpack install Oracle_VM_VirtualBox_Extension_Pack-4.2.12-84980.vbox-extpack

sudo adduser vbox
sudo usermod -a -G vboxusers,cdrom,sudo,dip,plugdev,dialout,lpadmin,adm vbox

sudo apt-get install openssh-server

sudo apt-get install acpid

event=button[ /]power
action=/etc/acpi/powerbtn.sh

sudo apt-get install apache2

auto eth0
iface eth0 inet static
        address 10.0.0.71
        netmask 255.255.255.0
        network 10.0.0.0
        broadcast 10.0.0.255
        gateway 10.0.0.1
        dns-nameservers 10.0.0.1

sudo poweroff

scp zeus1.ova vbox@10.0.0.50:/tmp

ssh vbox@10.0.0.50
VBoxManage import /tmp/zeus1.ova

VBoxManage clonevm zeus1 --name zeus2 --register

"zeus1" {fa974e98-6411-4768-9cd9-017176e47e81}
"zeus2" {81953acc-59d0-4fa9-87f1-42e08bbbdb78}

#!/bin/bash

# VirtualBox vm name
vm_name=zeus1

# VirtualBox username 
vbox_user=vbox

vbox_command="sudo -u $vbox_user -i VBoxManage"

case "$1" in

start)
        echo "starting vm vm_name"
        $vbox_command startvm --type headless $vm_name
        ;;

shutdown)
        echo "sending ACPI shutdown to vm $vm_name"
        $vbox_command controlvm $vm_name acpipowerbutton
        ;;
pause)
        echo "pause $vm_name"
        $vbox_command controlvm $vm_name pause
        ;;

resume)
        echo "resume $vm_name"
        $vbox_command controlvm $vm_name resume
        ;;

stop)
        echo "savestate $vm_name"
        $vbox_command controlvm $vm_name savestate
        ;;


*)
        echo "usage: $0 (start|stop|pause|resume|shutdown|help)"
        ;;
esac

exit 0

chmod a+x vm_zeus1.sh 
sudo cp vm_zeus1.sh /etc/init.d/
sudo update-rc.d vm_zeus1.sh defaults 25 10

sudo  /etc/init.d/vm_zeus2.sh start

auto eth0
iface eth0 inet static
        address 10.0.0.72
        netmask 255.255.255.0
        network 10.0.0.0
        broadcast 10.0.0.255
        gateway 10.0.0.1
        dns-nameservers 10.0.0.1

sudo poweroff

sudo apt-get install crossroads

#!/bin/sh

XR=/usr/bin/xr
SERVER="-s http:0:80"
BACKENDS="-b 10.0.0.71:80 -b 10.0.0.72:80"
ALGORITHM="-dl"
HTTP_FLAGS="-x -X"
TIMEOUTS="-t 10"
CHECK_CALLS="-c 10"
DEBUGGING="-v"


case "$1" in

start)


	$XR $SERVER $BACKENDS $ALGORITHM $HTTP_FLAGS $TIMEOUTS $CHECK_CALLS $DEBUGGING 2>&1 | logger -t crossroads &
	;;
stop)
	killall $XR
	;;
*)
    echo "usage: $0 (start|stop|help)"
esac

exit 0

chmod a+x crossroads.sh
sudo cp crossroads.sh /etc/init.d
sudo update-rc.d crossroads.sh defaults

sudo /etc/init.d/crossoads.sh start
sudo /etc/init.d/vm_zeus1.sh start
sudo /etc/init.d/vm_zeus2.sh start

sudo /etc/init.d/vm_zeus1.sh shutdown
VBoxManage modifyvm zeus1 --vrde on --vrdeport 3389 --vrdeauthtype external
sudo /etc/init.d/vm_zeus1.sh start

rdesktop 10.0.0.50:3389 -u vbox -p -

rdesktop 10.0.0.50:3389 -u vbox -p your_password

sudo /etc/init.d/vm_zeus1.sh shutdown
VBoxManage modifyvm zeus1 --vrde off

First we create a directory for our internal maven repository. Later we will push the content of this directory to github as our maven remote repository.

mkdir mvn-repo

The next step is to create our project called code-base with maven. For simplicity this is just a normal maven project which is not configured with a SCM like git.

mvn archetype:create -DgroupId=com.github.myproject
    -DartifactId=code-base -Dversion=1.0-SNAPSHOT

There should now be a directory called mvn-repo for our internal repository and the directory code-base for our maven project.

.
└──  code-base
└─── mvn-repo
 

To deploy a maven artifact in the internal repository we have to modify the pom.xml file and add the following lines to our configuration. Adopt the file path here specified as maven property internal.repo.path to the location where you created the mvn-repo directory.

<properties>
  <!--maven variable which points to your local repository -->
  <internal.repo.path>file:///home/mr/tmp/mvn-repo/</internal.repo.path>
</properties>

Also add the following distributionManagement element for deploying a maven artifact in your internal repository. The location (url) to the repository is stored as maven property ${internal.repo.path} which points to our internal repository in the file system.

<distributionManagement>
  <repository>
    <id>internal.repo</id>
    <name>Internal Repository</name>
    <url>${internal.repo.path}</url>
  </repository>
</distributionManagement>

Then we can deploy our artifact to the internal maven repository. With the maven deploy goal maven copies the maven artifacts to our internal repository.

mvn deploy

After a maven deploy the content of our internal maven repository mvn-repo should look like this.

.
└── com
    └── github
        └── myproject
            └── code-base
                ├── 1.0-SNAPSHOT
                 \......

To publish our artifacts we have to push our internal repository to github. Next thing to do is to initialize the directory as local git repository and add the remote github repository. Then pull the files which github created for us (e.g. gitignore and README file) in the local git repository. Also change {your_project} to your github username.

git init
remote add origin https://github.com/{your_project}/mvn-repo.git
git pull origin master

With git we add the new generated files from the execution of maven deploy to our git local repository. Then we push the changes to our remote git repository. The new artifacts should then be accessible to the rest of the world.

git add .
git commit -m "first release"
git push origin master

You can use your repository now in other maven projects. Change {your_project} to your github username and add the following lines to your pom.xml which want to use the code-base project.

<repository>
  <id>my.mvn.repo</id>
  <url>https://github.com/{your_project}/mvn-repo/raw/master</url>
  <!-- use snapshot version -->
  <snapshots>
     <enabled>true</enabled>
      <updatePolicy>always</updatePolicy>
   </snapshots>
</repository>

When you deploy SNAPSHOT versions be sure to enable them for your pom.xml with snapshots/enabled = true. See http://maven.apache.org/settings.html#Repositories for more details on how to configure a remote repository.

Add the following dependencies in your pom.xml to use the code-base jar in your new maven project.

<dependency>
  <groupId>com.github.myproject</groupId>
  <artifactId>code-base</artifactId>
  <version>1.0-SNAPSHOT</version>
</dependency>

When you don’t want to change the version manually in your code-base project before you deploy a new stable version. You could configure the maven release plugin. I have not yet done this with git, perhaps when I have the time I will look for a solution how to configure git with maven and a working release plugin configuration. How to configure git with maven just read the following post Maven Tips and Tricks: Using GitHub.

When you also want to deploy the source JAR and javadoc JAR to your remote repository you should have a look a the maven page How to attach source and javadoc artifacts. Just configure the maven javadoc and source plugin.