Ubuntu – Path of the saint coder…

Setup Domain Name for Raspberry Pis, wired to Local Network

In my previous article, I have shared my experience about sharing internet connection received by my Desktop PC, to the RPis. While this setup is okay to me, there is a small matter that bugged me. Whenever I need to reach other RPi from another RPi or from my connected desktop PC (e.g. doing SSH), It requires me to remember & type in the target machine’s IP Address. I want to improve this experience further by just typing the hostname of the target machine such as ssh pi@rylai instead of ssh [email protected]

I understand that in order to achieve this, I would need to setup & run Domain Name System (DNS) servers in my RPis LAN. But, it’s another “I know ( what I should do), but I don’t know (the technical detail of how to do it)” problem to me. After I spent a couple of days searching references which fit to my case, I then bumped with this article. Someone has done it, but I’d like to prove it and see if it fits & works on my RPis LAN.

In this article, I am going to share my experience of how I setup the primary & secondary servers on my Desktop PC and my old Raspbery Pi 2 Model B, I connected to the RPis Private Local Network.

Updated the IP Addresses

I did not change any physical parts that are involved in the private network. However, in order to get this done by following the article, I changed each RPis and my desktop PC’s IP Addresses as in the following list:

Linux, Raspberry Pi, Ubuntu

Sharing internet connection to Raspberry PIs, wired to Local Network

Sometime before I write this article, I bought 5 units of Raspberry Pi 3 Model B, along with : 6 pieces of UTP Cat 6 RJ-45 cables, 5 Sandisk 16GB Micro SD cards, an 8 ports TP-Link TL-SF1008D LAN Switch, and an Anker 6 ports USB Power Adapter with 6 USB OTG cables as well. I ordered those parts, to be used for building an ARM based Computers Cluster, wired altogether forming a Local Area Network.

Once I have setup Raspbian Jessie OS on each of these RPis, I then booted them, (by using my Desktop PC’s Keyboard , Mouse & HDMI monitor) and began on assigning host name & static IP on each of the RPis (through editing their /etc/hostname & /etc/hosts files). I did this because I want to remote the RPis from my own desktop PC using SSH or Remote Desktop, by specifying their static IP Address.

I wired the Rpis using the UTP Cat6 cables to the LAN Switch, and also connected my Ubuntu Desktop PC into the Switch as well. I planned the topology of the wired Network as shown in this following picture:

I did ping test from an RPi to other connected RPis, from my Desktop PC to RPis, run ssh command from my desktop PC to the RPis, and the outcome were all went well.

A problem arise when I connected my Desktop PC to internet. Either through tethering my iPhone to my PC or connecting the PC to my Wireless MiFi modem, I could get access to internet from my Desktop PC, BUT not from the RPis in the wired LAN. It seemed that my Desktop PC did not share the Internet connection it receives to my RPis.

It took me few hours to understand, how sharing internet connection from my Ubuntu PC to my RPis can be done. Through google-ing efforts and trial-error attempts, I bumped into this article & followed partial steps in the article to get this done.

In this article, I am going to share my experience about how to share the internet connection received by my Ubuntu Desktop PC to the wired Raspberry Pis via Local Area Network.

Configure DHCP Client service on each of RPis

Defining a static IP address on an RPi through writing it on /etc/hosts file , helped me remoting the RPi from my Desktop PC. However, it’s not enough to help the RPis for recognising my Desktop PC as the Gateway to Internet. Also, we need to define the address of DNS servers that the RPi should lookup to, so that when they browse to a specific URL Site, they could find it by the site’s Domain name (e.g. http://www.intel.com), instead of by its IP Address (e.g. 103.56.234.57).

Through experimentation, I also found that each of RPis runs DHCPCD server. It is a daemon software which helps the RPi receiving dynamic IP assigned by DHCP server. On one of my RPi, it gave me trouble: it overridden the defined Static IP, replaced it with Dynamic IP (e.g. 169.71.55.12).

In order to prevent this and also `telling` RPis that they should lookup for valid DNS server and recognise my PC as Gateway to the internet, I modified the /etc/dhcpd.conf file in the RPi as in the following screenshot:

Additional changes in the red-squared lines are interpreted as follow:

interface eth0 — Next configuration lines are applied to the LAN interface of the RPi, the eth0 .
static ip_address — This line defines the static IP of current RPi and the subnet mask (/24)
static routers — Defines the Gateway’s IP. In this case, it points to the IP Address of my Ubuntu PC.
static domain_name_servers — Define IP addresses of valid DNS servers. In this case, I defined IP Addresses of Google’s DNS servers.

I saved the changes and then reboot the RPi. By the time my RPi was rebooted successfully, I ran ifconfig to confirm the IP address of eth0 interface has been assigned with the Static IP defined in /etc/dhcpd.conf earlier.

Then, I ping my ubuntu Desktop and I can confirm that the RPi still can reach out my PC.

I repeated these modification steps against the rest of RPis, except I gave different IP Address but still under same subnet address (e.g. RPi #2 = 192.168.8.202, RPi #3 = 192.168.8.203, etc).

Configure IP Tables on the Ubuntu Desktop PC

At this point, It was still half way to share the internet connection to the RPis. Then, I added Network Address Translation ( NAT ) configuration on my PC, through running thisiptables command in terminal window:

sudo iptables -t nat -A POSTROUTING -o wlx6466b309ab63 -j MASQUERADE

Then followed by running this command, to ensure that the IP packets routed from any wired RPis, will be forwarded to wlx6466b309ab63 wireless interface:

sudo iptables -A FORWARD -i enp6s0 -o wlx6466b309ab63 -j ACCEPT

Lastly, we run this iptables command to forward incoming packets from wlx6466b309ab63 interface to corresponding RPis, when the packets have an established initial request.

sudo iptables -A FORWARD -i wlx6466b309ab63 -o enp6s0 -m state --state RELATED,ESTABLISHED -j ACCEPT

To confirm that the changes were applied, I browsed a web page from any of the connected RPi and I confirmed that the web page is loaded on my RPi’s Chromium.

Confirming that the Internet is shared to Rpi

Persist the Changes on IP Tables, permanently

In this moment, I have configured NAT & packets forwarding rules in my Ubuntu Desktop PC for sharing the internet to my RPis. To ensure that these configuration won’t be gone at next time I restart my PC, I installed iptables-persistent tool (run sudo apt-get install iptables-persistent for installing it) and then I ran sudo netfilter-persistent save command in terminal window. This will ensure that the IP Tables Configuration that I has made will be persisted and reloaded at next time I restarted the PC.

Where to go from here

I felt excited, seeing my RPis are fully connected in Local Area Network and also able to access Internet. Next, I would like to setup DNS server(s) in the LAN, so that each of nodes in the LAN would have their own internal domain name, such as mydesktop.nextresearch.local Once I could setup this, I would like to setup DHCP server in the LAN, so that each of the connected parties will have Dynamic IPs.

Reference(s)

http://www.nairabytes.net/81-linux/418-how-to-set-up-a-nat-router-on-ubuntu-server-16-04

Linux, Ubuntu

HOW TO – Install Facebook’s Watchman on Linux Ubuntu 16.04 LTS

Facebook’s watchman. Initially, I do not have any particular needs with this software. However, I got issues when I tried to run a sample mobile app, created in Expo XDE (https://expo.io/). By looking at the error logs shown on Expo XDE, I noticed that Expo XDE runs watchman, before it builds the project and this process was ended as failing.

Armed with this error logs, I decided to install watchman and the efforts were not simply as running a sudo apt-get install command in one go. watchmancan be installed through pulling its source code, build the source code and install it. It took me some time to figure out the details of dealing with these chores and be able to install it properly.

I created this article as a reference for my future’s needs and to anyone who shared same problem as mine when running Expo XDE or React Native development tool.

Install GNU M4: sudo apt-get install m4
Install automake & autotools-dev: sudo apt-get install autotools-dev automake
Install libssl-dev: sudo apt-get update && sudo apt-get install libssl-dev
Ensure that checkinstall has been installed: sudo apt-get install checkinstall
Pull watchman’s repository and then move into watchman’s source code directory: git clone https://github.com/facebook/watchman.git && cd watchman
Run these commands to build the source code: ./autogen.sh && ./configure && make
Package the binaries as a debian package by running this command: sudo checkinstall . Follow the instructions on the screen until finished and confirm that the debian package is created ( the .deb file)
Install the .deb package using either GDebi Package installer or ubuntu’s default software installer.

By following these steps guide, the watchman should be installed in your ubuntu machine , if there were no errors displayed on any of these steps.

Amazon Web Services, Javascript, Linux, Node.js, Sails.JS, Ubuntu

Deploying Sails.js Web Application on AWS EC2 Instance

Sails.js is a Web MVC Framework, built on the top of Node.js platfom, that is interesting to me. Beside the framework leverages MVC pattern and offers blazing fast performance during runtime (thanks to Node.js), it also came in with a built in HTTP server. When i am going to run my web application, I do not need to compile, package & deploy my code into a separated web server. Instead, it just requires me to invoke a line of command to get my web application up & running:

 sails lift MyAwesomeWebApplication

Also, it just need me to press CTL+C keys in the terminal, to stop the running web application. This is a similar feature that exists in Play.

In the meantime, I was thinking about what if I deploy & run a sails web application on a cloud environment, let’s say, Amazon Web Service. So, i made the first attempt by deploying a simple sails web app on AWS through Elastic Beanstalk (EB). The result is my web app’s homepage did not show in my browser. Instead, it displays EB App’s default homepage.

Then, I took the other route. I create an EC2 Instance (It’s a virtual private server) using AMI (Amazon Machine Image) with pre-installed Ubuntu 14.04 OS. I installed required softwares in the created EC2 instance then lift my sails web app on it. Then, check it using my browser & it confirmed me that my sails web app was up & running.

In this article, I would like to share you the steps that I did to get my sails app running in a Ubuntu AWS EC2 instance. And, here they are:

Create a new AWS Instance using Ubuntu 64 AMI

Browse to AWS console at https://console.aws.amazon.com & click EC2 link.
On the EC2 Dashboard, click IMAGES->AMIs menu link.
On the Filter menu bar, modify the options to Public images | 64-bit images | Ubuntu.
On the returned filtered result, tick a desired AMI (e.g. ubuntu/images/ebs/ubuntu-trusty-14.04-amd64-server).
Click [Launch] button.
On the “Step 2: Choose an Instance Type” page, tick a desired EC2 Instance Type (e.g. Micro Instances) then click [Next: Configure Instance Details] button.
On the “Step 3: Configure Instance Details” page, leave the default settings and click [Next: Add Storage] button.
On the “Step 4: Add Storage” page, adjust the Root’s storage size or just leave the default settings then click [Next: Tag Instance] button.
On the “Step 5: Tag Instance” page, leave the default settings and click [Next: Configure Security Group] button.
On the “Step 6: Configure Security Group” page:
- Select “Create a new security group” option.
- Enter name & description for the new security group.
- Click [Add Rule] button & on the new entry, enter: Type = Custom TCP Rule, Protocol = TCP, Port Range = 1337, Source = Anywhere.
- Click [Review and Launch] button.
On the “Step 7: Review Instance Launch”, click [Launch] button.
On the displayed “Select an existing key pair of create a new key pair” dialog, select “Create a new key pair” on the combo field, enter Key pair name then click [Download Key Pair] & [Launch Instances] buttons.
Save the downloaded .pem file into somewhere within your home directory & restrict its access by running this command in terminal:
```
chmod 400 yourdownloadedkeypair.pem
```
Go back to browser, click [View Instance] button. Notice that the browser redirects to Instances dashboard page and the new AMI Instance is shown in the Instances list. Give the new Instance a name if you like ( by clicking the new instance’s empty Name cell and type the name on it). Make notes on the new Instance’s Public IP or Public DNS fields.

Connecting to the created AMI Instance using SSH

On the Instances Dashboard page, click [Connect] button. A dialog would appear, showing 2 options for connecting to the Instance. Select “A standalone SSH client”, block and copy the command written under ‘Example’ section.
Open the command line Terminal box, move to the directory that has the downloaded .pem file and run the command written in the earlier instructions dialog.
```
ssh -i downloaded_keypair.pem ubuntu@new_instance_public_ip_or_dns
```
Confirm that you have logged in successfully.
Set the root’s password by running these commands:
```
sudo su
passwd
```

Setup required softwares on the created AMI Instance (as root)

In the SSH terminal connected to the new Instance, run these following commands to update the new Instance’s software repositories:
```
apt-get upgrade && apt-get dist-upgrade && apt-get update && apt-get autoclean
```
Run these commands to set up the git client:
```
apt-get install build-essential git
```
Create a new directory & pull the latest Node.js source code in this directory by running this command ( using git client ):
```
git clone https://github.com/joyent/node.git
```
Change directory to the cloned Node.js source directory, then run these commands to compile & install the Node.js:
```
sudo ./configure && make && make install
```
Confirm that the compilation process is finished successfully.
Install sail.js web MVC framework by running this command:
```
npm -g install sails
```
Confirm that the installation is finished successfully

Deploy a sails.js app into the created Instance

Ensure that you have put the sails.js app source code in your git account (e.g. github, bitbucket, etc ).
On the created Instance, create a new directory and do git clone the sails.js app source code into this directory.
Change directory to the cloned source code’s directory and run this command to install node module dependencies referenced by your sails.js app
```
npm install
```
Run this command to lift the sails.js app online on the created instance:
```
sails lift
```
Confirm that the sails.js app is lifted successfully
Go back to your internet browser and browse to your instance’s public IP address , port 1337.
Confirm that the lifted sails.js app’s home page is displayed

It’s alive now ! But, wait..

When I close my current SSH session that was connected to the EC2 instance & refreshed the sails app’s page in my browser, I noticed that it returns 404 error. My sails web app was offline. Apparently, each processes that have been started during SSH session within the EC2 instance, would be shutdown when the SSH connection is closed. Somehow, I need to prevent the running sails app from being closed even when the SSH session is ended.

Fortunately, the solution for this is already suggested in the documentation of sails.js. The document suggests us to install & start a sails.js app by using forever. Forever prevents any running scripts from being closed during SSH session by running them as a Daemon (*nix service). Then, I tried the solution and it worked well. I would explain the steps of how to forever my sails app in EC2, in the next section,

Run the deployed app as a running daemon in the EC 2 Instance

Install forever globally:
```
npm -g install forever
```
In the terminal connected to the EC2 Instance, change directory to the sails.js app’s root folder then run this command:
```
forever start -ae errors.log app.js --dev --port 1337
```
OR, run this command if you wish to run the production version:
```
forever start -ae errors.log app.js --prod --port 80
```
If you write your controllers as coffee script files, open the errors.log file. Notice that there is error message written in it (http://tinyurl.com/p8y4ovl). This means the sails.js app is failing to be lifted by running prior command. This is a known issue in Sails.js version 0.9.16. This issue has been raised to balderdashy and it can be seen in this link, along with the temporary workaround as well : http://tinyurl.com/m2jyx24).
Logout or disconnect from the EC2 instance’s SSH session and then browse to your lifted sails.js app’s url. Confirm that your lifted app is still up & running now.

The previous section marks the end of this article. I hope this ‘how-to’ guide would help you deploying your sails.js web app on your AWS account. Happy sailing in your AWS cloud.

Java, Java SE, Linux, Ubuntu

Setup Latest Oracle JDK on Ubuntu Linux

Most of people understand that installing Oracle JDK & JRE on their Windows machine is mostly easy like eating peanuts ( Well, they might still need to setup JAVA_HOME variable & update their PATH variable though). It can be turned out to be a problem when due to some case they need to move from Windows to Linux development environment, such as Ubuntu Linux. In this HOW TO article, i’ll cover the steps for setting up the JDK on Ubuntu Linux. I hope it would be useful for anyone whom are still having problem with it.

Open a terminal window (press CTL+T) and run these commands in order (we’ll assume that we are going to install JDK version 7 ):
```
1. sudo add-apt-repository ppa:webupd8team/java
2. sudo apt-get update
3. sudo apt-get install oracle-java7-installer
```
If you wish to remove the JDK from your machine, run this command in the terminal box:
```
sudo apt-get remove oracle-java7-installer
```
Should you need to upgrade your current JDK version to the latest one, you could try running this command and see if it would work:
```
sudo update-java-alternatives -s java-7-oracle
```
If the prior command does not work then you could remove your current JDK and re-install the latest one using prior steps as the last resort.

Those are the steps that I always follow when setting up JDK on my Ubuntu machine. Until the time I written this post, i still found no problem when using it on my Intellij IDEA 12.1, working for either Android application development or Play 2 based web application development.