My Game Jam post is waaay overdue but some stuff happened this week (impromptu upgrade, server migration) so I’ll only get around to post about it probably later today.

Anyway, this post is just about the new version up over at RailsFTW. This experimental build is based on TCS’s patched Ruby build which boasted a ~200% increase in performance.

See it for yourself:

Still hung-over from Global Game Jam 2012 (mini-write-up later) when I went to the RailsInstaller site on a whim.

Noticed that it still isn’t using Rails 3.2. So I decided to update my own to be ahead again.

Hopefully this would be the last RailsFTW version (hoping Luis would be able to convince Wayne to include MySQL to RailsInstaller so I won’t need to this anymore LOL).

These screencasts were recorded in 720p so it’s a good idea to select a higher resolution then view the videos in full screen or the large player in order for you to read the code properly.

Here I code a hexagonal “game of life”-like cellular automata. Used Ruby, Gosu, and RSpec.

Walking through coding a simple Rails app. Bunch of technologies discussed like Twitter Bootstrap, Heroku, and git.

Going through Project Euler problems via brute force using Java.

Here’s a quick update to this mini-tutorial. Previous parts can be found here and here.

Installing MySQL

Installing MySQL is so simple that I don’t need to hide it behind the cut. The one in the Ubuntu repositories work just fine:

$ sudo apt-get install mysql-server-5.1

Note that you will be asked to enter a root password somewhere in the installation.

To wrap up the installation run

$ sudo mysql_install_db

to initialize the installed server and

$ sudo mysql_secure_installation

to secure it.

In mysql_secure_installation, you’ll be asked for your root password and then you’ll asked if you want to change it. Just enter “n” since there’s no reason to change it this early. Then you’ll be asked if you want to do some things to secure the database which is, of course, what we want to do so just hit Enter for each question to choose the default answer (“Y”).

Installing WordPress

Now we go to making our Ubuntu + nginx + PHP + MySQL setup more useful by installing a web app. I choose WordPress for this tutorial because it’s both popular and easy to install.

Note that most PHP web apps out there have similar installation steps i.e. install prerequisites, setup database, download and extract files, and configure the app.

Installing prerequisites

We only need to install a few extra components for WordPress to work on our box:

$ sudo apt-get install php5-mysql php5-gd

php5-mysql is obviously required to allow PHP to connect to MySQL. php5-gd may be needed if you’re uploading images inside WordPress instead of using an external hosting.

At this point we are ready to follow the Installing WordPress guide.

Creating the database

I’ve switched around steps 1 and 2 because I prefer to do file-related tasks together instead of jumping from files to database to files again.

In setting up the database, we go with the client guide. Creating a new user isn’t part of that guide, though, so we’ll have to do that too.

Connect to the database using the root user:

$ mysql -u root -p

You will be prompted for the password before you can proceed. Once in, you can now proceed with doing what you need to do. The following lines will create a database named wp and a user named wp_user whose password is password_here.

mysql> CREATE DATABASE wp;

mysql> CREATE USER wp_user;

mysql> SET PASSWORD FOR wp_user = PASSWORD("password_here");

mysql> GRANT ALL PRIVILEGES ON wp.* TO "wp_user"@"localhost" IDENTIFIED BY "password_here";

mysql> FLUSH PRIVILEGES;

mysql> EXIT

Downloading WordPress and moving it around

Now it’s time to proceed with steps 1 and 3. Use wget to download and extract the latest version of WordPress:

$ wget http://wordpress.org/latest.tar.gz

$ tar -zxvf latest.tar.gz

We’ll then move the extracted folder wordpress/ to /var/www/ to centralize our web-app stuff.

$ sudo mv wordpress /var/www/

We also need to change the ownership for the folder:

$ sudo chown -R www-data:www-data /var/www/wordpress

Configuring it to work

First we need to add our database settings to wp-config.php:

$ cd /var/www/wordpress

/var/www/wordpress$ sudo mv wp-config-sample.php wp-config.php

/var/www/wordpress$ sudo vim wp-config.php

Change the settings as follows:

// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define('DB_NAME', 'wp');

/** MySQL database username */
define('DB_USER', 'wp_user');

/** MySQL database password */
define('DB_PASSWORD', 'password_here');

Now to edit our nginx settings.

$ sudo vim /etc/nginx/nginx.conf

We’ll be using a combination of suggested settings from both nginx and WordPress documents:

...
    server {
        listen       80;
        server_name *.mysite.dev;
        root /var/www/wordpress;

        if ($http_host != "mysite.dev") {
                rewrite ^ http://mysite.dev$request_uri permanent;
        }

        # Deny all attempts to access hidden files such as .htaccess, .htpasswd, .DS_Store (Mac).
        location ~ /\. {
                deny all;
                access_log off;
                log_not_found off;
        }

        location = /favicon.ico {
                log_not_found off;
                access_log off;
        }

        location = /robots.txt {
                allow all;
                log_not_found off;
                access_log off;
        }

        location / {
                # This is cool because no php is touched for static content
                try_files $uri $uri/ /index.php;
        }

        location ~ \.php$ {
                include fastcgi_params;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                fastcgi_pass php;
        }

        location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
                expires max;
                log_not_found off;
        }
    }
}

The main changes here are the update to the root (pointing it now to /var/www/wordpress) and the try_files approach of URL rewriting (which allows nginx to act like mod_rewrite without the use of .htaccess).

Wrapping up

Restart both PHP-FPM and nginx to apply the changes we made to both.

$ sudo /etc/init.d/php5-fpm restart

$ sudo /etc/init.d/nginx restart

Then go to http://mysite.dev to proceed with the “famous 5-minute install”.

You have now successfully installed WordPress.

Here’s the next part of my basic web server administration tutorial.

At the first part, we set up the virtual machine. Now we’ll be setting up the web server itself.

Set Static IP Address and fake Domain Name

Before we could proceed with installing our web server, let’s do a couple of things to make our server behave more like a “normal” server.

First is to set our server’s IP address to a static IP address. There are a bunch of ways to do this (e.g. change the router settings), but we’ll just go with changing our server’s settings

Running ifconfig and route will give us the current IP address and gateway.

In this case, the new IP address is 192.168.1.125 and the gateway is 192.168.1.5. We can now apply these settings to /etc/network/interfaces. Open the said file via:

$ sudo vim /etc/network/interfaces

(For this tutorial, I’ll be using vim as the default text editor. If you find vim too daunting, you can replace all instances of vim with nano)

It will look something like:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto eth0
iface eth0 inet dhcp

Now replace the last line with the following:

iface eth0 inet static
address [address here]
netmask 255.255.255.0
gateway [gateway here]

for example:

iface eth0 inet static
address 192.168.1.125
netmask 255.255.255.0
gateway 192.168.1.5

To make sure you got the static IP settings correctly, you can restart the server via

$ sudo shutdown -r now

or you could just simply restart the network interface:

$ sudo /etc/init.d/networking restart

Here we see the /etc/init.d folder where the init scripts (like networking) are placed. Aside from being executed automatically upon boot to start services, they can also be used to stop or restart the said services just like what we just did with networking. We will see more of /etc/init.d/ later in this tutorial.

Now that we’ve set the IP address as static, it’s time to set a fake domain name.

Normally, when you’ve got a server with a static IP address, you’d have to go and buy a domain name from a registrar like Namecheap and you’d go through the steps in linking that name with the IP address and waiting for the DNS propagation.

For this tutorial, we’re going to skip all that by faking it with the hosts file.

First let’s update the server’s /etc/hosts file to add our fake domain name “mysite.dev”:

sudo vim /etc/hosts

Add the line at the end:

192.168.1.125   mysite.dev

You can verify the new setting by using the ping command.

user@ubuntu:~$ ping -c 4 mysite.dev
PING mysite.dev (192.168.1.125) 56(84) bytes of data.
64 bytes from mysite.dev (192.168.1.125): icmp_seq=1 ttl=64 time=0.172 ms
64 bytes from mysite.dev (192.168.1.125): icmp_seq=2 ttl=64 time=2.38 ms
64 bytes from mysite.dev (192.168.1.125): icmp_seq=3 ttl=64 time=3.34 ms
64 bytes from mysite.dev (192.168.1.125): icmp_seq=4 ttl=64 time=1.59 ms

--- mysite.dev ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3016ms
rtt min/avg/max/mdev = 0.172/1.874/3.342/1.161 ms
user@ubuntu:~$

Now let’s apply the fake domain name mapping to the host Windows computer. Like in Linux, the hosts file in Windows requires admin privileges so we first need to run the text editor as Administrator in order to allow us to modify it.

Right-click Notepad and select “Run as administrator”. Once open, you can now add the “192.168.1.125 mysite.dev” to the end of the C:\Windows\System32\drivers\etc\hosts file.

Now you could change the PuTTy settings to use “mysite.dev” instead of the actual IP address.

The actual installation of the web server below the cut.

Installing Nginx

It’s finally time to install the web server.

We won’t be using Apache, though. Instead, we’re going to go with its leaner and faster Russian counterpart nginx. We’re also going to build it from scratch (as opposed to getting it from a repository) to show you how its done in Linux machines.

Installing dependencies

We’ll need to install a few things before we could proceed with building nginx.

$ sudo apt-get install build-essential libssl-dev libpcre3-dev

build-essential contains the essential tools for compiling programs from source while the other two are libraries that nginx needs during compilation.

Building from source

~$ wget http://nginx.org/download/nginx-1.0.11.tar.gz

Using wget we download the latest stable source as of this writing. Yes, it’s a whopping 700 KB.

~$ tar zxvf nginx-1.0.11.tar.gz

We then unpack it using tar.

~$ cd nginx-1.0.11

~/nginx-1.0.11$ ./configure --sbin-path=/usr/local/sbin --with-http_ssl_module --without-mail_pop3_module --without-mail_imap_module --without-mail_smtp_module --with-http_stub_status_module

~/nginx-1.0.11$ make

~/nginx-1.0.11$ sudo make install

Now we finally perform the build/installation. This three-step configure-build-install scheme is pretty much how one builds any program in Linux from scratch.

This nginx build doesn’t come with an init script so we’ll have to download one off the net.

~/nginx-1.0.11$ cd ~

~$ wget https://raw.github.com/JasonGiedymin/nginx-init-ubuntu/master/nginx

~$ sudo mv nginx /etc/init.d/nginx

We still need to set a couple of things with the script:

$ sudo chmod +x /etc/init.d/nginx

$ sudo chown root:root /etc/init.d/nginx

The first command sets the script to executable and the other command gives the ownership of the script to root. Now we can run nginx:

$ sudo /etc/init.d/nginx start

You can now open http://mysite.dev to check if it’s installed properly.

Using Firebug or Chrome Developer tools will confirm the server’s really nginx 1.0.11.

Tweaking nginx

Before we proceed with installing PHP, let’s apply some tweaks to nginx to make it more Apache-ish (lol) and then some.

$ sudo ln -s /usr/local/nginx/conf /etc/nginx

This creates a symbolic link in the /etc folder to match with the convention for configuration files.

$ sudo vim /etc/nginx/nginx.conf

Now we edit the configuration file like so:

user  www-data;
worker_processes  1;

pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    gzip on;
    gzip_buffers 16 8k;
    gzip_disable "MSIE [1-6]\.";
    gzip_proxied any;
    gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;
    error_log  /var/log/nginx/error.log  debug;

    sendfile        on;
    keepalive_timeout  3;
    index              index.html index.htm;

    server {
        listen       80;
        server_name *.mysite.dev;
        root /var/www;

        if ($http_host != "mysite.dev") {
                rewrite ^ http://mysite.dev$request_uri permanent;
        }

        # Deny all attempts to access hidden files such as .htaccess, .htpasswd, .DS_Store (Mac).
        location ~ /\. {
                deny all;
                access_log off;
                log_not_found off;
        }

    }

}

A quick summary of the changes:

• We changed the server’s user from “nobody” to the system user “www-data”, the default user for web servers.
• We set the file where the PID for the server would be located. This will allow our init script to stop or restart the server.
• We enabled gzip for supported browsers to dramatically reduce the bandwidth usage.
• We set the log to match Apache’s format.
• We defined a handler for the *.mysite.dev domain, defining its root to be the same as Apache’s (/var/www)

Now to wrap things up:

$ sudo cp -r /usr/local/nginx/html /var/www

$ sudo chown -R www-data:www-data /var/www

We copy the html folder to /var/www and give it to www-data.

$ sudo mkdir /var/log/nginx

Just creating the log folder.

$ sudo /etc/init.d/nginx destroy

$ sudo /etc/init.d/nginx start

We force stop the server (as we haven’t defined the PID file when we started it) then start it normally.

Opening http://mysite.dev now shows us that the site is served as gzipped.

Installing PHP-FPM

Unlike nginx, we won’t be building PHP from scratch. We will, however, not go with Apache’s mod_php/extension route and instead go the PHP-FPM route which, like nginx, is much leaner than the former.

Since PHP-FPM isn’t available in the official apt repositories of Ubuntu 10.04, we will have to use another repository. Nginx’s repositories may be a bit out of date (PHP v5.3.5 vs the current v5.3.8) but it should be enough for this tutorial.

$ sudo apt-get install python-software-properties

$ sudo add-apt-repository ppa:nginx/php5

$ sudo apt-get update

$ sudo apt-get install php5-fpm

The steps above will install PHP-FPM with fairly decent defaults. If you want to change some settings, you can modify the files at /etc/php5/fpm/ and restart the server via “sudo /etc/init.d/php-fpm restart“.

Now all we need to do is to tell nginx how to use PHP-FPM. Here’s our modified /etc/nginx/nginx.conf:

user  www-data;
worker_processes  1;

pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    gzip on;
    gzip_buffers 16 8k;
    gzip_disable "MSIE [1-6]\.";
    gzip_proxied any;
    gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;
    error_log  /var/log/nginx/error.log  debug;

    sendfile        on;
    keepalive_timeout  3;
    index              index.php index.html index.htm;

    upstream php {
        server 127.0.0.1:9000;
    }

    server {
        listen       80;
        server_name *.mysite.dev;
        root /var/www;

        if ($http_host != "mysite.dev") {
                rewrite ^ http://mysite.dev$request_uri permanent;
        }

        # Deny all attempts to access hidden files such as .htaccess, .htpasswd, .DS_Store (Mac).
        location ~ /\. {
                deny all;
                access_log off;
                log_not_found off;
        }

        location ~ \.php$ {
                include fastcgi_params;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                fastcgi_pass php;
        }
    }
}

The main changes between the original are:

• Adding “index.php” before “index.html index.htm” to let the server prioritize the former over the latter.
• The addition of the upstream php block that points to PHP-FPM.
• The addition of the location handler for PHP files.

We also need to modify /etc/nginx/fastcgi_params, adding the following lines at the end of the file:

fastcgi_connect_timeout 60;
fastcgi_send_timeout 180;
fastcgi_read_timeout 180;
fastcgi_buffer_size 128k;
fastcgi_buffers 4 256k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
fastcgi_intercept_errors on;

Once done we can now restart the server via sudo /etc/init.d/nginx restart.

To test PHP, create the phpinfo() index.php file:

$ sudo sh -c 'echo "<? phpinfo();" > /var/www/index.php'

Then open http://mysite.dev again:

You have now installed nginx and PHP on your web server.

Benchmarking

You can use ApacheBench to see how well your site performs under load.

$ sudo apt-get install apache2-utils

Here’s 1000 requests with 100 concurrent users (10 requests each user) to our static HTML file:

user@ubuntu:~$ ab -n 1000 -c 100 http://mysite.dev/index.html
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking mysite.dev (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests

Server Software:        nginx/1.0.11
Server Hostname:        mysite.dev
Server Port:            80

Document Path:          /index.html
Document Length:        151 bytes

Concurrency Level:      100
Time taken for tests:   1.720 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      378290 bytes
HTML transferred:       157795 bytes
Requests per second:    581.31 [#/sec] (mean)
Time per request:       172.025 [ms] (mean)
Time per request:       1.720 [ms] (mean, across all concurrent requests)
Transfer rate:          214.75 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:       27   79  15.7     84     102
Processing:    39   83  16.5     86     131
Waiting:       10   61  17.5     65      98
Total:        129  161  16.5    172     184

Percentage of the requests served within a certain time (ms)
  50%    172
  66%    173
  75%    173
  80%    173
  90%    178
  95%    182
  98%    183
  99%    183
 100%    184 (longest request)

Here’s the same test against our phpinfo() page:

user@ubuntu:~$ ab -n 1000 -c 100 http://mysite.dev/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking mysite.dev (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests

Server Software:        nginx/1.0.11
Server Hostname:        mysite.dev
Server Port:            80

Document Path:          /
Document Length:        42481 bytes

Concurrency Level:      100
Time taken for tests:   8.582 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      42649000 bytes
HTML transferred:       42481000 bytes
Requests per second:    116.52 [#/sec] (mean)
Time per request:       858.186 [ms] (mean)
Time per request:       8.582 [ms] (mean, across all concurrent requests)
Transfer rate:          4853.19 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    6  16.6      0      63
Processing:    66  810 126.3    861     875
Waiting:       59  808 127.0    858     873
Total:        125  816 113.2    861     875

Percentage of the requests served within a certain time (ms)
  50%    861
  66%    862
  75%    863
  80%    864
  90%    869
  95%    874
  98%    874
  99%    875
 100%    875 (longest request)

581 and 116 requests per second? Not bad for a “low end” server.

Proceed to part 3: Installing MySQL and WordPress

So you want to be a bit productive this holiday/winter/end-of-year break and decide to learn how to setup your own website.

But for some odd reason you don’t want to settle with a free website service like WordPress or even a cPanel managed shared hosting site. Instead, you want to know how to setup your own web server, something like a Linode VPS or an Amazon EC2 instance.

Luckily for you, I’m having a bit of a writer’s block and I have time to write about how to learn setting up a Linux server without having to pull out your credit card.

What this post is all about

In this post, we’ll just discuss how to set up a virtual server on your computer.

Yes, that’s right. We’re not installing a server OS on a spare machine, nor are we dual-booting: we’ll be setting up a server in your desktop, running the former inside the latter. This is virtualization, dawg.

We’ll be creating a server with somewhat similar specs to what you’d get if you sign up for $8 a month at prgmr.com. This simulated environment will be enough for a newbie to learn the ropes in server management.

What you need

Any relatively modern desktop or laptop computer will do. For this series of posts, I’ll be forgoing the use of my quad-core gaming rig and instead use my laptop (dual-core @ 2.1GHz with 3GB RAM). For the sake of the majority of the readers, I’ll be using Windows 7 as the OS though the steps will almost be the same when using Windows XP and Vista, and will still be similar even when using Linux or OSX.

You also need to be connected to a network, preferably one that gives out local IP addresses via a DHCP server. In other words, a home/office router. Fast internet also helps as you need to download >700MB worth of installer data.

As for the software, you will need to download VirtualBox and a CD image (.iso) for Ubuntu Server 10.04.3 Long Term Support 32-bit. The VirtualBox download and installation is pretty straightforward, but for the Ubuntu Server 10.04.3, you may want to choose downloading via BitTorrent for faster download speed.

Unlike Linux and OSX users who already have it built in on their terminals, Windows users will also have to download an SSH client like PuTTy, the one that you’ll see in this tutorial.

Creating a Virtual Machine

Once you’ve installed VirtualBox, it’s time to create a new virtual machine. Click the New button and use the following settings:

• Name: any name, I named mine “ServerTest”
• OS Type: Linux, Version: Ubuntu
• Base Memory Size: 256MB
• Start-up Disk: Create new hard disk (VDI, Dynamically Allocated, 6GB)

Before we start installing Ubuntu Server, we’ll have to change some settings (right-click machine -> Settings, or just click the Settings button).

In the Storage settings, select the “Empty” CD/DVD drive under the IDE Controller then set the Ubuntu Server image as the current CD by clicking the CD icon in the Attributes area on the right side.

In the Network settings, change the network adapter from NAT to Bridged Adapter. This will allow your virtual machine to get a local IP address from the router, in turn allowing it to behave as though it was a real server connected to the network.

Click Ok to apply the changes.

Installing Ubuntu Server 10.04.3 LTS

Upon starting the machine (right-click machine -> Start, or just click the Start button), the system will boot the Ubuntu Server installer. The steps here are pretty straightforward:

• Arrow and Tab keys and move the cursor/selection while Enter key “clicks” the selected option. The Space Bar “ticks” the selected option in certain pages.
• There are times when VirtualBox seems to “hold” the mouse pointer. You press the Right Ctrl Key to make VirtualBox “let go” of the pointer.
• Select “English” and “Install Ubuntu Server”. This will initiate the actual installer.
• Select “English”, “Philippines”
• Say “No” to the Detect Keyboard Layout then simply choose “USA”, “USA”
• Choose a host name. The default “ubuntu” is fine.
• Choose a host name of your choice. The default “ubuntu” is fine.
• Asia/Manila is the correct time zone (“Yes”)
• Choose the default options for setting up the drive partitions (“Guided – use entire disk and set up LVM”, first drive, “Yes”, “6.2GB”). Select “Yes” when asked if you wish to continue.
• Your full name can be anything. On the other hand, your user name and password are important because it’s what you use for logging in. For this tutorial, I used the username “user” and a simple password (ignore security for now).
• Continuing our disregard for security, we skip encryption of the home folder as well as setting up automatic updates.
• Don’t tick anything for installation. We’ll do it manually later.
• Say “Yes” to installing GRUB.

Once the whole thing is finished, select “Continue”. This will restart the machine and somehow it will boot using our freshly installed OS and skip the CD for now. Now is a good time to go to the settings and change the CD drive to “Empty” again via the “Remove disk from virtual drive” option.

Enter the user name and password to login.

Congratulations, you now have a working virtual server.

Installing SSH server

When we’re managing servers, we rarely have direct physical access to the machine hardware.

For this tutorial, we’ll use SSH to manage the server pseudo-remotely. Not only will this simulate how one usually manages rented servers (as every VPS and cloud solution uses it), this will also get around the ugly and slow to respond server console that VirtualBox displays to us.

First step is to actually install the SSH server. Enter the following commands in the server console:

$ sudo apt-get update
$ sudo apt-get install openssh-server

The first command will ask for your password. This is because sudo tells Linux to run the command as the “super user”, hence allowing us to do things that are typically restricted from normal users. Later sudo prefixed commands will not require re-entering the password until the OS “forgets” you (e.g. you don’t use sudo for a certain amount of time).

The two commands above are used to install packages (e.g. programs or libraries) in Debian variants of Linux. The first command, apt-get update, updates the local database of available packages for download and installation by browsing the repositories defined in the /etc/apt/sources.list (the official repositories for your installed OS are enabled here by default).

The second command, apt-get install, installs the list of packages that you pass to it, including the packages’ dependencies. As you can see here, openssh-server requires libwrap0 and tcpd. Enter “y” to proceed with installation. (Pressing Enter without entering anything does the same thing. This is because “Y” is the default answer as denoted by its capitalization in the yes-or-no “Y/n”.)

Once installed, you can now remotely connect to the machine via SSH.

Remote management via SSH

Before you can connect to your server, you must first identify its local IP address. This should be included in the system information that you get upon logging in.

in this case the IP address is 192.168.1.116

If you didn’t take note of the IP address or if the system failed to provide it, you can still get it via the ifconfig command.

You can now connect to it via PuTTY as long as you know the IP address.

Before you connect, you may want to change some settings (e.g. changing the font to Consolas) and saving the session for future use.

Linux and OSX users can simply use the built in SSH client installed in their terminals with the following command:

$ ssh username@ip-address

Upon connecting to your server, both PuTTy and the terminal client will tell you the server fingerprint and will ask if you want to proceed. Obviously you’d want to proceed. Then you’ll be asked for your login credentials. Enter them to continue.

Now you’re connected to the server via an SSH client. Not only does your terminal look prettier than the one provided by the server, you can also copy-paste things from the clipboard now.

Learn the terminal

For terminal newbies, it’s now a good time to learn command line commands. Go to Zed Shaw’s command line crash course Controlling Your Computer From The Terminal and run through the whole thing.

And this ends this part of the tutorial. We will leave installing web server components to the later parts.

To shutdown your server, you can use the shutdown command:

$ sudo shutdown -h now

Proceed to part 2: Installing Nginx and PHP

That little app/wallpaper we made at the code retreat? I’ve published it and it’s now free for download at the Android Marketplace.

At the moment it’s not properly indexed in the Marketplace yet so searching “Game of Life Wallpaper” won’t return the link. A workaround is to search it using the search terms “code retreat“.

One day after writing the previous post, I noticed two things:

• I forgot to add the link for the term “rubber duck”, and
• I never posted about “rubber ducking” before

I’ve fixed the first so it’s time to fix the second. Still finding it weird that I haven’t done it yet in the 2+ years this blog has been up, though…

Anyway, “rubber ducking” is a simple mind hack popularized by The Pragmatic Programmer. Instead of committing copyright infringement by copy-pasting what the book says about it (all 3 paragraphs), I’ll just go with Wiki Wiki’s take on the topic.

Place a rubber duck on your monitor and describe your problems to it. There’s something magical about stating your problems aloud that makes the solution more clear.

So yeah, my MO at hackathons is to either code something totally unexpected, or just float around “magically” solving problems by being a sounding board.

This isn’t a full write-up of the event so I’ll keep this short and simple. The event was at Drei‘s place with just a bunch of Ruby, Python, and PHP guys from both Manila and Baguio hacking up random stuff instead of doing the whole Code Retreat thing.

at the after event, aka “Yo dawg, I heard you like taking pictures so here’s a picture of people taking your picture so you can have a picture of you taking pictures of people taking pictures”

Being the slacker that I am, I didn’t have anything planned out beforehand. I thought I’d just go the same route as with Startup Weekend Manila and just be a rubber duck floating around groups. Fortunately, Buddy brought along his significant other Rizza with the intention of having her learn programming from the participants of the event.

I couldn’t resist this teaching challenge. So for the entire event, I went on to give an impromptu crash course on the fundamentals of software development.

I started off with basic imperative/procedural programming via pseudocode (to drill in the idea that software development is not about computers but about solving problems). As we progressed I moved on to Ruby for the more technical side of things (basic data types) up to Object Oriented basics.

first programs – potato salad and quadratic formula

By mid-day, I had this little flash of insanity and began downloading >250MB of development stuff from a certain site.

That flash of insanity was to go back to the original Code Retreat exercise, Conway’s Game of Life, and build it in Java to teach software development: coding conventions, revision control, test automation, refactoring, etc.

Of course, I had to teach the most crucial concept in software development: how to wing it. And that was where Android came in.

So we had a base GoL class and a freshly installed Android SDK. A couple of Google searches later and a lot of guesswork, we were able to make the whole thing work as a Live Wallpaper in around 1.5 hours.

Lack of sleep and preparation can turn a Ruby guy into a Java developer. LOL

So I’m gonna be recording rants for the next few weeks to figure out and fix my vocal problems. I’m ok with topic suggestions but I’m not really expecting any.

Will be posting the recordings on this site until I get to setup another page for the recordings (probably a wiki).

Episode 0 – Intro

Episode 1 – Pizza (pt1 of 2)

Episode 2 – Pizza (pt2 of 2)

–

UPDATE

Podcasts now posted daily at http://bry-rants.tumblr.com/