How I Got Node.js Running On A Linux Micro Instance Using Amazon EC2

In the past, I've dabbled with Node.js (a server-side JavaScript runtime environment) on my local MacBook Pro. If you know JavaScript, it's not too hard to get something up and running on your local machine. Putting Node.js out into the wild, however, is whole other beast. Not only am I mediocre at managing web servers in general, I happen to know almost nothing about Amazon EC2 (Elastic Compute Cloud), Linux / Unix, Git, SSH, ports, routing, processes, and just about everything else that goes into managing a Node.js deployment. After a couple of hours, some online tutorials, and a bit of trial and error, I finally got something working! I managed to keep a Node.js process running on a Linux Micro instance on Amazon EC2! For those who are interested, I thought I would share my experience.

DISCLAIMER: I could not do any of this without the knowledgable guidance of many other blogs. Please take whatever I say in this post with a grain of salt. I am likely going to mangle terminology and provide misinformation (accidentally, of course).

I wanted to see if I could get Node.js up and running using manual labor. If you are interested in a managed Node.js platform as a service (PaaS), you might want to check out Nodejitsu. They provide a command-line tool that makes hosting and deploying Node.js application much more of a black-box experience.

For the following screenshots, please click on the smaller versions to view larger (1024 x 768) versions.

In order to deploy Node.js on an Amazon EC2 instance, the first thing you need to do is get yourself an EC2 (Elastic Compute Cloud) instance. Log into Amazon Web Services (AWS) and select the EC2 tab. On the EC2 landing page, you'll want to select "Key Pairs". Theoretically, you can do this as part of the Launch workflow; however, I found that I could not get past Step 1 without doing this beforehand.

I don't fully understand what a Key Pair is; but, from what I can gather, it's a way to establish a trusted, authenticated connection between your computer (the client) and the server during an SSH operation. From the Key Pairs screen, create a new key pair:

Enter the name of your key pair.

Once you've created the Key Pair, Amazon should prompt you to save the private key. Make sure you know where the file gets saved on your local machine as you'll need to use it in subsequent step.

Once you've downloaded the PEM file (private key), return to the EC2 landing page and click the Launch Instance button.

This should take you into the launch wizard. Here, you can name your instance and select the Key Pair that we just created. I picked the Amazon Linux Quicklaunch option because that's what Kostas Mavropalias recommended on this blog. Apparently, the 64-bit version works well with Node.js.

Once you've named and selected your instance, click Continue. This will take you to a confirmation page. On this page, take note of which security group is assigned to this instance. We will need to make some edits to this group to allow HTTP and TCP access.

Now click Launch. This will immediately create and launch your new Linux micro instance. Once the instance starts, you will begin using billable processing time. But, don't worry! It's mad cheap - a free period followed by $.02 / hour! Booya, grandma!

Click Close to return to the EC2 landing page.

Now, we need to go into the Security Groups to edit the public access permissions for this machine.

Once on the Security Groups page, select the security group associated with our instance and then select the Inbound tab to see which ports are open.

You should see that the SSH port (22) is open by default. That will allow us to remotely connect to the EC2 instance; however, in order to allow access from the web, we want to enable HTTP port 80 and a high-numbered TPC port for Node.js testing (before we pipe it into port 80).

Once the rules have been defined, the changes need to be applied.

After the Security Groups have been updated, select Instances from the left-hand navigation. This should bring you to the list of running instances, where you'll want to select the newly created instance. This will bring up the details for the instance that includes the public DNS.

Copy the public DNS value as we'll need it to SSH into the machine.

Our Amazon EC2 Linux micro instance is now up and running. It's time to install and configure Node.js! Go to the directory where you saved your PEM (key pair) private key. Create a text file called, "connect." This will be a Bash script that makes opening the SSH connection easier.

In the new "connect" file, define the SSH command using our PEM file and the public DNS value:

connect - Our SSH Connect Bash Script

Notice that we are using "ec2-user" as the SSH user and our EC2 instance public DNS as the domain.

Save and close this file. Then, update the permissions so that it can be executed:

Once you've done this, you need to tighten the permissions on the PEM file. If too many people can access the PEM file, the SSH connection will be denied. Let's remove Read, Write, and Execute permissions for everyone but the current user (you):

Once you've done this, you can connect to the EC2 instance by invoking the connect executable:

Once you do this, the SSH connection will be opened. At this point, you'll probably be prompted to allow the untrusted connection:

The authenticity of host 'ec2-174-129-82-198.compute-1.amazonaws.com (x.x.x.x)' can't be established. RSA key fingerprint is x:x:x:x:x:x:x:x:x:x:x:x:x:.
Are you sure you want to continue connecting (yes/no)?

To be honest, I have no idea what this actually means. Just type "yes" and continue.

At this point, you'll be connected to the ec2-user's home directory. Now, we can update the machine software and install Node.js.

--------------------------
--------------------------

THANKS TO: Instructions for updating the computer and installing Node.js, Git, and NPM (Node Package Manager) were all taken from this post by Kostas Mavropalias. I'm simply re-creating part of it here. This part of the demo should probably take like 20 minutes to download and compile everything.

Update Your EC2 Linux Box

Install The GCC Compiler And Git

Add User's Directory To BIN Paths

Once inside the Nano editor, scroll to where you see the line:

Defaults secure_path = /sbin:/bin:/usr/sbin:/usr/bin

Append the following value, ":/usr/local/bin", to the end of that line. Save the file and exit the Nano editor.

Install NPM - The Node Package Manager

--------------------------
--------------------------

Now that we have all of our core components installed, go back to the home directory of the machine and create a directory for our Node.js site:

I'm putting it in the home directory; but, from the feedback I got on Twitter, a lot of people would put this in the "/var/" directory somewhere.

Once you're in the "site" directory, create the hello world file for our Node.js application. This will listen for requests coming in on port 8080 and return a static response:

server.js - Our Node.js Server File

You'll notice that our Node.js server is set to listen to port 8080. For security reasons, we're not supposed to allow non-core services to listen to port numbers below 1024. In order to allow requests on the standard HTTP port, 80, to be handled by our Node.js server on port 8080, we need to add some port forwarding.

Thanks to this blog post by Steve Kemp, setting up port forward is rather trivial with the use of the machine's IP Tables. Simply type this in the console:

This seamlessly redirects port 80 to port 8080.

Ok, so now we have Node.js installed and able to listen to the standard HTTP port. Now, we need a way to keep our Node.js application running even after we logout of our EC2 instance. For this, we'll use the Forever module by Nodejitsu. Let's install Forever using our Node Package Manager (NPM):

This should download a whole bunch of stuff into our "site" directory. Once it's done, we can use Forever to launch our Node.js server. However, since the command for Forever is somewhat complex, I am going to turn it into a Bash command file:

start - The Bash Script To Invoke Forever (And Start Node.js)

This command defines a number of log files that can be used to log the output and errors of our Node.js site as it runs. I'd like to put those log files in a sub-directory; however, I could not figure out how to define the file paths in such a way that actually worked.

As before, we need to add execute permissions to this file in order to be able to run it:

Before we actually invoke Forever, however, let's create a Bash script that allows us to stop our script, should we need to:

stop - The Bash Script To Invoke Forever (And Stop Node.js)

And apply the right permissions:

And now, we're ready to rock!!! Let's kick the tires and light the fires. Execute our Start Bash script:

This will invoke the Forever module and start our Node.js server (server.js). It should output something like:

info: Forever processing file: server.js

You'll notice that calling Forever puts you back into the command-line. At any time, you can invoke the Stop command to end the Node.js server:

Or, you can simply logout of your EC2 server and let the Node.js server run.

But, does it actually work? Try testing your public DNS in your web browser to see if it works. In this demo, that would be:

http://ec2-174-129-82-198.compute-1.amazonaws.com

Hopefully, if everything went smoothly, you should get the following page output:

Hellow world from AWS!

NOTE: Yes, I see the extra "w"... I'm way too tired to fix it at this point.

Well, that's about all that I understand at this point. You can try to ask me questions; but, it is unlikely that I'll really be able to answer them. Like I said, I just got this to work for the first time. I definitely need to learn more about Unix servers and commands - I'm mostly feeling around in the dark.

You Might Also Be Interested In: