Todd Rodzen

Agile Application Development, DevOps, Cloud Architecture Engineering

to Containerize

Containerizing an application from a monolithic application to container based microservices is a large and wide topic. I like to focus on small topics within the greater goal when looking at cloud architecture. The first is the decision to containerize and how to best achieve a manageable cloud. Of course, the desired end services and application need will drive the ultimate cloud architecture model. First, let’s look at the basic design possibilities.

The first option is a monolithic application. The problems are well known. The size of the application and complexity for the developer soon becomes overwhelming. We will take it for granted this is not desirable.

Next, is a possibility of creating a sort of hybrid cluster. This still has the problem for the developer as the application design becomes too complex. I reviewed the design of a sort “roll-your-own” cluster with a MySQL and node.js in a prior post “to Cluster or not to Cluster”. This process described using the Cluster function within node.js. This is a quick and dirty solution to programmatically rolling-your-own cluster for node.js. There is also the PM2 solution to manage a cluster application on node.js. This provides the solution of maximizing resources to utilize processing power on multiple threads but does not provide any of the solutions for a scalable containerized application.

Next, the type (or flavor) of scaleable container service is open for debate. There is docker swarm, Amazon AWS Elastic Container Service, build-your-own Kubernetes, as well as many others. One promising managed service from AWS is EKS (Elastic Kubernetes Service.) I won’t try to review these options but in a future post simply provide a step by step basic process to look at cloud architecture for a Kubernetes homogeneous solution. This provides for decisions based on cloud or service needs without fixating on AWS solutions. As with any developing, the team of developers can drive the solution to some extent, as there are many flavors of best-practices for cloud containerized services.

There are also many other cloud-based services including GCP (Google Cloud Platform), IBM, etc but Kubernetes on AWS has become a leader. In one recently published report, Kubernetes on AWS has 63% of market share of all container services used today.

My future posts focused on Kubernetes will focus on container imaging from Docker Cloud but Google Cloud container registry is also a good option. There are other options like RKT, but of course, Docker is the most widely used and supported.


AWS Architecture

A while ago I did some application design that discussed the specific need of utilizing pooled connections and clusters when using node.js and mySQL. These ideas along with many others like kubernetes containers, continuous deployment, etc are small steps to create a long-term solution of a well-architectured framework.

As a sort of exercise let’s define the terminology that is important in the planned architecture of a cloud-based system.

  • Responsiveness: reacting quickly and positively
  • Resiliency: capacity to recover quickly from demand
  • Elasticity: the ability to stretch or duplicate to adapt to high demand and return to normal when demand no longer exists.
  • Availability: the state of maintaining uptime

Some other pillars of a well-architected framework include:

  • Security: ability to protect information, systems, and assets while delivering business needs
  • Performance Efficiency: the ability to use computer resources efficiently to meet system requirements
  • Cost Optimization: the ability to avoid or eliminate unneeded cost

While these terms at times overlap and intersect to different degrees for the purpose of creating a well-designed cloud infrastructure, it is always important to consider these pillars in determining best practices. If your best-practices includes AWS it probably includes EC2, S3, and RDS. Although it also must also include budget, cost optimization and return on investment (ROI) utilizing tools to track costs, such as through tagging and IAM controls, you can innovate without overspending.

Additionally, a good architecture will utilize performance tools to track and maintain top efficiency within the cloud resources utilizing Amazon Cloud Watch or 3rd party monitors. Finally, audits and tools are also needed to maintain data integrity and security.

Regardless of the underlying technology, there are many best practices. Some might think of it as varying as individual opinions, everyone has an opinion. What is important for an organization is to select best practices that work for the entire organization from the users to the operators to the developers and designers. The success of any architecture depends on a cohesive operation and sound principles.

This AWS Architecture blog has some great insight to AWS design and architecture to achieve responsiveness, resiliency, and elasticity.

I particularly like the discussion of scaling your application one-step at a time.

LAMP, Node, and Nginx on AWS AMI Linux 2

I have in the past done install directions and details of installing LAMP on AWS Linux and another post on installing Node.js. I will now do a quick update on the basics of installing LAMP and Node.js on the newest Linux 2 AMI on Amazon.

The basic steps are the same to setup your Linux on AWS just select the Linux 2 AMI on EC2. Be sure to generate your private key and use a tool like Putty to login with the user ec2-user. Don’t forget you will need to convert your pem private key to ppk format using a tool like PuttyGen before using it in Putty.

The Lamp install is described in more detail here

Basically, do the following:

sudo yum update -y
sudo amazon-linux-extras install lamp-mariadb10.2-php7.2
sudo yum install -y httpd php mariadb-server php-mysqlnd
sudo systemctl enable httpd
sudo usermod -a -G apache ec2-user
sudo chown -R ec2-user:apache /var/www
sudo chmod 2775 /var/www && find /var/www -type d -exec sudo chmod 2775 {} \;
find /var/www -type f -exec sudo chmod 0664 {} \;
echo "<?php phpinfo(); ?>" > /var/www/html/phpinfo.php

You should now be able to view your apache default web page root and the php page

You still need to do the database install.

For the Node.js install we use nvm with the following

curl -o- | bash
. ~/.nvm/
nvm install 9.3.0

I choose to create a node directory for programming in the root and then do the same or similar group security as above for the Apache www/html directory.

Finally I will setup Nginx reverse proxy as described in a prior post but with Linux 2 Nginx is now available as an AWS “extra” use the following command.

amazon-linux-extras install nginx1.12

Follow my prior post to configure Nginx

Recruiters please note..


I am available for phone interviews for Boston based positions. I split my time between Boston and North Carolina. If I am not in Boston, I am available to return on request for onsite interviews with actual direct hiring managers. I am available for immediate hire.

{UPDATE 3/5/2018 I am in the Boston area and available for onsite interview}


my Resume:

my Coding and AWS systems design blog:

my Personal Portfolio:

moving jsfiddle Vue.js code to a single html page

If you are new to js often times simple test code is shown in an online code editor like It’s a great way to quickly get up and running on the desired task like your great Hello World example. But then how do you move that code to a served web page?

Of course there are many ways. You could use node and npm  There are better methods for the long term if you are building say a full app but if you want to dump your test code on your own server because you need access to other local resources like you images directory then this is one method to copy the Vue.js code.

When using a simple Vue.js code and using a CDN to load Vue you must do a couple things in a single HTML page.

  1. load the Vue.js CDN
  2. load the new Vue function when the page loads (window.onload is one method)
  3. It’s good practice to also hide all the elements when loading with the v-cloak directive. This way your Vue code doesn’t splash on the browser while Vue is doing its work.

Here’s that great fiddle.


Here’s the code when moved to a single HTML page run on an AWS Linux Apache server.

Gist Github code

Obviously, this is a very simple task. This shows a quick way to move a section of code to your own server for further development. The window.load function runs your Vue code. The v-cloak directives also hide your code until Vue is done loading.

The original purpose of the Hello World jsfiddle was to load “Hello World” in the data in the message variable. Vue then replaces code in the DOM inside {{ }} (“mustache”) variables with the data. But more importantly, this creates a reactive link to that Vue “message” variable so the data can be changed.

AWS create new default su

The steps to create a user with the same rights as ec2-user are:

create the account


set a password for the account


add the account to the sudo group

usermod -aG sudo NEWACCOUNT

log in with the account


create a .ssh directory

mkdir .ssh

log out of NEWACCOUNT


now you are back in root, copy the authorized_keys file, and set security on .ssh

cp /home/ec2-user/.ssh/authorized_keys /home/NEWACCOUNT/.ssh/authorized_keys

chmod 700 /home/NEWACCOUNT/.ssh

Log all the way out of the system, and try and log in with the NEWACCOUNT.

Once logged in invoke sudo su to ensure it has the correct rights. You should get an error message.

The last step is to replace ec2-user with NEWACCOUNT in the file:


The easiest way is with the nano editor, but there are many other editors in linux.

Redis on Production

Let’s do some fine tuning for Redis in production

  1. Turn on vm over commit memory. edit the /etc/sysctl.conf file

sudo chmod 664 /etc/sysctl

Then use the editor to add this to the bottom of the file.

vm overcommit_memory = 1

Without getting into the pros and cons, vm over commit is fully explained here

Next, we setup the system services to start the Redis node(s). It’s common to have at least a master and slave on one server so let’s allow multiple services to run on the same server and have them auto-start. And while we’re at it, let’s make the service start/stop commands work for Redis nodes with AUTH passwords. Oh, and let’s fix the transparent_hugepage default (set it to never, as recommended by Redis.) This is all explained in my last post Redis Linux Service

Also don’t forget to turn off the debug logging used for development.

UUID vs Auto Increment

What is the best method to create a key in today’s advanced Javascript node.js style applications? Do you rely on the old tried and true method to use auto-increment on the database primary key? or is a UUID better? One thought to help answer that; is a sequential key useful? Especially in the situation where the unique key may start out as only in the application or only on the client session store (ie. Redis key memory store.) In this situation, a sequential key is not useful and creating the auto increment key takes an additional step using INCR on Redis or INSERT on MySQL which could also create an unnecessary round trip to your database.

On the other hand, the UUID v4 implementation which creates a unique randomized UUID may appear to be a CPU time slice consuming operation, but one stackoverflow user did some testing, as posted here,:


You can see the green and yellow lines of increased connections. As connections increase AUTO INCR method creates an increased latency; while the UUID is a steady same or lower process time slice.

I didn’t come up with this one but found it may possibly be the smallest UUID v4 generator code.

exports.uuid = function b(a){return a?(a^Math.random()*16>>a/4).

There is no one answer. It’s always good to have multiple available methods but be sure to consider the uses and weigh the options.

Redis Linux Service

Redis has a service install script It takes a few prompts and adds a new Redis service on Linux. One issue I found when working with Redis passwords, the service script doesn’t handle start/stop correctly. In a prior post, I detail the installation process for Redis on Amazon Linux. Here’s a fix to the services script. The issue is with the stop. There is no password passed to the service script on shutdown. With passwords and no modification you are limited to doing the following:

service redis_6379 start
redis-cli -p 6379 -a YourPassword shutdown

The standard “service stop” command doesn’t work but here’s an update to the service script that could be implemented in the script by the Redis team.. My edits are tagged with #tlr and should be changed in the redis_6379 file in the /etc/init.d directory (or the origin script, if you want to get even more fancy. The script is used to create the redis_6379 start/stop script.)

#Configurations injected by install_server below....

NAME=`basename ${0}` #tlr


#PIDFILE=/var/run/ #tlr
#CONF="/etc/redis/6379.conf" #tlr
#REDISPORT="6379" #tlr

PIDFILE=/var/run/${NAME}.pid #tlr
CONF="/etc/redis/${NAME#*_}.conf" #tlr
REDISPORT="${NAME#*_}" #tlr

PassVar=$(grep "requirepass " $CONF | cut -d' ' -f1 | tr -d '\012\015') #tlr
# PassVar is the requirepass variable name (with or without the # comment) #tlr
if [ $PassVar = "requirepass" ] #tlr
then #tlr
 requirepass=$(grep "requirepass " $CONF | cut -d' ' -f2 | tr -d '\012\015') #tlr
else #tlr
 # password commented output #tlr
 requirepass="" #tlr
fi #tlr

# SysV Init Information
# chkconfig: - 58 74
# description: redis_6379 is the redis daemon.
# Provides: redis_6379
# Required-Start: $network $local_fs $remote_fs
# Required-Stop: $network $local_fs $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Should-Start: $syslog $named
# Should-Stop: $syslog $named
# Short-Description: start and stop redis_6379
# Description: Redis daemon

case "$1" in
 if [ -f $PIDFILE ]
 echo "$PIDFILE exists, process is already running or crashed"

echo "never" > /sys/kernel/mm/transparent_hugepage/enabled #tlr
echo "never" > /sys/kernel/mm/transparent_hugepage/defrag #tlr
# by addding hugpage here it overides other places set on reboot (ie.onAWS)

echo "Starting Redis server..."
 if [ ! -f $PIDFILE ]
 echo "$PIDFILE does not exist, process is not running"
 PID=$(cat $PIDFILE)
 echo "Stopping ..."

# $CLIEXEC -p $REDISPORT shutdown #tlr

if [ -z $requirepass ] #tlr
then #tlr
 $CLIEXEC -p $REDISPORT shutdown #tlr
else #tlr
 echo "Using .conf File Password AUTH" #tlr
 $CLIEXEC -p $REDISPORT -a $requirepass shutdown #tlr
fi #tlr

while [ -x /proc/${PID} ]
 echo "Waiting for Redis to shutdown ..."
 sleep 1
 echo "Redis stopped"
 PID=$(cat $PIDFILE)
 if [ ! -x /proc/${PID} ]
 echo 'Redis is not running'
 echo "Redis is running ($PID)"
 $0 stop
 $0 start
 echo "Please use start, stop, restart or status as first argument"

These changes simply allow for multiple services by creating symbolic links for additional nodes to the original redis_6379 service start/stop script. Additional Redis node services could be added by doing the following

ln -s /etc/init.d/redis_6379 /etc/init.d/redis_6101

This creates a start / stop script for the additional node by linking to the original 6379 service start/stop script. You will need an additional service for each node (master or slave) that you are running on the instance. Also, duplicate and modify your /etc/redis/xxxx.conf file as needed. In a prior post, I detail the configuration for a Redis Cluster with Passwords. Finally, issue a command to add the service:

service --add redis_6101

You can now reboot the Linux instance and your additional services will still be running. You can now also use the command $ service redis_6101 restart without an error due to passwords.

Redis Cluster with Passwords

Do a little work with Redis Clusters and you will see in multiple places developers trying to get Redis node instances with passwords to work in a Redis cluster environment. The fact is it’s not supported. It’s not an option for good reason. There is a second back data channel that essentially makes the password AUTH meaningless. On top of that, passwords on a memory key store is well, meaningless for a good hacker. If you can throw thousands of passwords at the instance in ONE SECOND then the brute force hack is pretty easy. Maybe future versions of Redis will start to take password retries into consideration.

On the other hand, there are good reasons for a password on any service. A couple reasons come to mind: 1. You simply want to stop inadvertent prying eyes, such as an employee within the company that has access to the machine and the redis-cli command tool. 2. Maybe you post your passwords on a sticky note next to the computer room monitor so the password itself is not a concern but the person that has access to the machine but not the computer room should be staying out of the data. 3. You have multiple people that work on the machine and you want to protect your instance so a co-developer doesn’t accidently access and delete your Redis node. The list could probably go on much longer. One thing for sure, even if you assign a password to your Redis instance if you open the port up to the public you are opening yourself up to a hack. On the other hand, if it has a password and you are only using it for testing and development, maybe it’s not a big deal.  The better option is to use SSH to tunnel to your Redis server over the internet. That has its own issues.

One reason I chose to setup a cluster with AUTH passwords is I wanted to build apps on my laptop running locally on my laptop node.js server. I want the app to connect to my remote MYSQL development/production database and the same type of situation for the memory key store. That way, in theory, you can develop and test a version on the laptop. You can push it to the development EC2 server without any code changes and it should also work because it would be using the same MYSQL database (connecting to hostname and Redis Cluster connection to a hostname (it won’t be using a local cluster or node on my laptop during development.)

With a Redis cluster environment, there is a back channel communications port for the cluster for each Redis node instance. The communications port is the node’s port with a 1 in front of the number. So if you have a node sitting on port 6101 there is also a back channel cluster communications port of 16101. We don’t use it. It’s only used by the Redis server. So In my situation above, I will not open the communications port to the public.


Furthermore, why go to all this trouble if you are just working on a development application. Well, in theory, your development application will soon be a minimum viable product (MVP) and that won’t happen, or be much more difficult later, if you develop an application with code using a single memory store environment and then have to transition to a whole new API client for production. It’s better to develop an application once the right way. If you are developing an application that will have widespread use you know the cluster environment is needed. It may be a question of your development process and some won’t want to take this approach. But if you develop with a single node you might expect a multi-stage redevelopment as clusters are needed down the road and that adds a few steps.

With my development scenario, I am using the same server for all six nodes with 3 masters and 3 slaves. Again it’s not needed unless you start moving these nodes to additional EC2 instances or your application usage grows to handle the larger demand. With this design you can always add additional nodes later without application coding changes.

So here are the steps to create the cluster:

  1. create a minimum 6 Redis node instances with different hosts or ports using the following changes to the Redis conf file. To do this I created a /redis/data directory and copied the initial install 6379.conf file to the new port name in the /etc/redis directory. Then change each with the following
    port 6101
    pidfile /redis/data/
    logfile /redis/data/redis_log_6101.log
    dbfilename dump_6101.rdb
    appendfilename "appendonly_6101.aof"
    cluster-config-file nodes_6101.conf
    requirepass myWickedLong256CharacterHashPassword
    dir /redis/data
    protected-mode no
    appendonly yes
    cluster-enabled yes
    cluster-node-timeout 15000
    cluster-slave-validity-factor 10
    cluster-migration-barrier 1
    cluster-require-full-coverage yes

    * create a .conf file for each port 6101 – 6106

  2. start each node with the redis-server command
    /usr/local/bin/redis-server /etc/redis/6101.conf

    * start each port 6101 – 6106

  3. Now we need to hack the redis-trib.rb progam with the following changes:
    This code change starts around line 57 and goes to line 125. You can cut, copy, and past as long as you get the exact same section of code (using Redis version 3.2.6) or simply scan through my code for the lines added and changed that are tagged with # tlr <start/end> comments

    class ClusterNode
     def initialize(addr)
     s = addr.split(":")
     if s.length < 2  puts "Invalid IP or Port (given as #{addr}) - use IP:Port format"  exit 1  end # tlr start pwd = nil  if s.length == 3  pwd = s.pop  end # tlr end port = s.pop # removes port from split array  ip = s.join(":") # if s.length > 1 here, it's IPv6, so restore address
     @r = nil
     @info = {}
     @info[:host] = ip
     @info[:port] = port
     @info[:slots] = {}
     @info[:migrating] = {}
     @info[:importing] = {}
     @info[:replicate] = false
    # tlr start
    @info[:password] = pwd 
    # tlr end
    @dirty = false # True if we need to flush slots info into node.
     @friends = []
    def friends
    def slots
    def has_flag?(flag)
    def to_s
    def connect(o={})
     return if @r
     print "Connecting to node #{self}: " if $verbose
    # tlr start
     if @info[:password] != nil
     @r = => @info[:host], :port => @info[:port], :timeout => 60, :password=>@info[:password])
     @r = => @info[:host], :port => @info[:port], :timeout => 60)
    # tlr end (the 2 lines in the else section are not changed from original)
     xputs "[ERR] Sorry, can't connect to node #{self}"
     exit 1 if o[:abort]
     @r = nil
     xputs "OK" if $verbose
  4. next run the redis-trib.rb program to combine your nodes into one cluster. This may be a super long command from the command line especially if you have 256 character passwords but it works. (do it all on one line)
    /redis/redis-3.2.6/src/redis-trib.rb create --replicas 1

    * I did notice this produced a few errors as shown below but they are simply the process verification errors and the nodes are working fine.

    >>> Creating cluster
    >>> Performing hash slots allocation on 6 nodes...
    Using 3 masters:
    Adding replica to
    Adding replica to
    Adding replica to
    (slot master/slave identifiers)
    Can I set the above configuration? (type 'yes' to accept): yes
    >>> Nodes configuration updated
    >>> Assign a different config epoch to each node
    >>> Sending CLUSTER MEET messages to join the cluster
    Waiting for the cluster to join.....
    [ERR] Sorry, can't connect to node
    [ERR] Sorry, can't connect to node
    [ERR] Sorry, can't connect to node
    [ERR] Sorry, can't connect to node
    [ERR] Sorry, can't connect to node
    >>> Performing Cluster Check (using node
    M: 4f531ed4bcfd058b688a8692138fbdcc01a9dc7e
     slots:0-5460 (5461 slots) master
     0 additional replica(s)
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [ERR] Not all 16384 slots are covered by nodes.

    A few more edits would fix the warning errors. 🙂 Since this is a one time command to initially setup your cluster, it’s not an issue. To add nodes to your existing cluster in the future you will user the rediscli command line tool with the CLUSTER MEET command.

  5. Confirm the cluster is working with the rediscli command setting a value.
    /usr/local/bin/redis-cli -c -p 6101 -a my256CharPassword
    SET foo bar
    GET foo

    You might notice foo gets pushed to a slot on the 2nd master. try SET a a and then try SET z z. You can also connect to any of the six nodes (6101 – 6106) to verify the sets with a GET command. (GET foo)

That’s all there is to it. You can open the 6101 – 6106 port to your local laptop and start developing on your local machine using the node.js ioredis client package on NPM at

ps. Of course that’s not all! 🙂 additional code changes would be needed for example the slave to master login with AUTH.

Redis Session and MySQL Login

The following does a Redis session store and MySQL user register and login as well as a simple message post. This is run on a node.js server


 "name": "users",
 "version": "1.0.0",
 "description": "Register User",
 "main": "app.js",
 "script": "./app.js",
 "watch": true,
 "ignore_watch": ["node_modules"],
 "keywords": [
 "author": "Todd Rodzen",
 "license": "MIT",
 "dependencies": {
 "async": "^1.2.1",
 "body-parser": "^1.13.0",
 "connect-redis": "^2.3.0",
 "cookie-parser": "^1.3.5",
 "ejs": "^2.3.1",
 "express": "^4.14.0",
 "express-session": "^1.11.3",
 "mysql": "^2.7.0",
 "redis": "^0.12.1"


 Loading all dependencies.
var express = require("express");
var redis = require("redis");
var mysql = require("mysql");
var session = require('express-session');
var redisStore = require('connect-redis')(session);
var bodyParser = require('body-parser');
var cookieParser = require('cookie-parser');
var path = require("path");
var async = require("async");
var client = redis.createClient();
var app = express();
var router = express.Router();

// Always use MySQL pooling.
// Helpful for multiple connections.

var pool = mysql.createPool({
 connectionLimit : 100,
 host : 'hmmmmm',
 user : 'you',
 password : 'ssshhhhh',
 database : 'hmmmm',
 debug : false

app.set('views', 'view');
app.engine('html', require('ejs').renderFile);

// Here we tell Express to use Redis as session store.
// We pass Redis credentials and port information.
// And express does the rest ! 

 secret: 'topics-session',
 store: new redisStore({ host: 'localhost', port: 6379, client: client,ttl : 260}),
 saveUninitialized: false,
 resave: false
app.use(bodyParser.urlencoded({extended: false}));

// This is an important function.
// This function does the database handling task.
// We also use async here for control flow.

function handle_database(req,type,callback) {
 function(callback) {
 if(err) {
 // if there is error, stop right away.
 // This will stop the async code execution and goes to last function.
 } else {
 function(connection,callback) {
 var SQLquery;
 switch(type) {
 case "login" :
 SQLquery = "SELECT * from user_login WHERE user_email='"+req.body.user_email+"' AND `user_password`='"+req.body.user_password+"'";
 case "checkEmail" :
 SQLquery = "SELECT * from user_login WHERE user_email='"+req.body.user_email+"'";
 case "register" :
 SQLquery = "INSERT into user_login(user_email,user_password,user_name) VALUES ('"+req.body.user_email+"','"+req.body.user_password+"','"+req.body.user_name+"')";
 case "addStatus" :
 SQLquery = "INSERT into msg_text(user_id,msg_text) VALUES ("+req.session.key["user_id"]+",'"+req.body.status+"')";
 case "getStatus" :
 SQLquery = "SELECT * FROM msg_text WHERE user_id="+req.session.key["user_id"];
 default :
 function(connection,SQLquery,callback) {
 if(!err) {
 if(type === "login") {
 callback(rows.length === 0 ? false : rows[0]);
 } else if(type === "getStatus") {
 callback(rows.length === 0 ? false : rows);
 } else if(type === "checkEmail") {
 callback(rows.length === 0 ? false : true);
 } else {
 } else {
 // if there is error, stop right away.
 // This will stop the async code execution and goes to last function.
 // This function gets call after every async task finished.
 if(typeof(result) === "boolean" && result === true) {
 } else {

 --- Router Code begins here.

 if(response === null) {
 res.json({"error" : "true","message" : "Database error occured"});
 } else {
 if(!response) {
 "error" : "true",
 "message" : "Login failed ! Please register"
 } else {
 req.session.key = response;
 res.json({"error" : false,"message" : "Login success."});

 if(req.session.key) {
 res.render("home.html",{ email : req.session.key["user_name"]});
 } else {

 if(req.session.key) {
 if(!response) {
 res.json({"error" : false, "message" : "There is no status to show."});
 } else {
 res.json({"error" : false, "message" : response});
 } else {
 res.json({"error" : true, "message" : "Please login first."});
 if(req.session.key) {
 if(!response) {
 res.json({"error" : false, "message" : "Status is added."});
 } else {
 res.json({"error" : false, "message" : "Error while adding Status"});
 } else {
 res.json({"error" : true, "message" : "Please login first."});
 if(response === null) {
 res.json({"error" : true, "message" : "This email is already present"});
 } else {
 if(response === null) {
 res.json({"error" : true , "message" : "Error while adding user."});
 } else {
 req.session.key = response;
 res.json({"error" : false, "message" : "Registered successfully."});

 if(req.session.key) {
 } else {


 console.log("I am running at 4201");

view/index.html (code)

view/home.html (code)

You will need a working Redis db structure and MySQL and the two files used on the select/update SQL statements.

Try it, it’s easy.
That’s All Folks!

Redis on Amazon Linux

The YUM installed Redis version on Amazon Linux is an older version so we will go through the steps to install Redis 3.2.6.


  1. sudo -i
  2. yum update
  3. yum install -y gcc*
  4. yum install -y tcl
  5. mkdir /redis
  6. sudo chmod 2775 /redis
  7. cd /redis
  8. wget
  9. tar xzf redis-3.2.6.tar.gz
  10. cd redis-3.2.6
  11. make
  12. make test
  13. make install
  14. cd utils
  15. chmod +x
  16. ./
    install with the following values:

    Welcome to the redis service installer
    This script will help you easily set up a running redis server
    Please select the redis port for this instance: [6379]
    Selecting default: 6379
    Please select the redis config file name [/etc/redis/6379.conf]
    Selected default - /etc/redis/6379.conf
    Please select the redis log file name [/var/log/redis_6379.log]
    Selected default - /var/log/redis_6379.log
    Please select the data directory for this instance [/var/lib/redis/6379]
    Selected default - /var/lib/redis/6379
    Please select the redis executable path [] /usr/local/bin/redis-server
    Selected config:
    Port : 6379
    Config file : /etc/redis/6379.conf
    Log file : /var/log/redis_6379.log
    Data dir : /var/lib/redis/6379
    Executable : /usr/local/bin/redis-server
    Cli Executable : /usr/local/bin/redis-cli
  17. chkconfig –level 2345 redis_6379 on
  18. chmod 2775 /etc/redis
  19. chmod 664 /etc/redis/6379.conf
  20. edit the /etc/redis/6379.conf file to set a password

That’s All!

ps. Want to set a password on the Redis store? It’s not recommended because a password doesn’t do much to secure a fast memory based key storage when 1000’s of password auth attempts can be thrown at it PER SECOND!  But on the other hand, if you want to add a password to prevent simply prying eyes like inhouse staff that won’t go through the trouble of building a password hacking program. Maybe you think the added password might prevent an inadvertent command to you Redis database like an accidental delete. Regardless the reason, here’s what you need to do:

edit the /etc/redis/6379.conf file
1. add your password to the password line and uncomment it. make it realy long.
2. turn protect mode off in the same file be commenting that line out.
3. (optional) comment the bind statement to allow connections from any interface. If you do this, you better control that port somewhere else, maybe with an AWS security group.

edit the  /etc/init.d/redis_6379 file and add the following command in the start and stop case procedures:

echo "Using Auth Password"
CLIEXEC="/usr/local/bin/redis-cli -a mywickedLong256character?Password"

Now you can do a sudo service redis_6379 restart command.

MongoDB on Amazon Linux

Here are the steps to install MongoDB on an Amazon Linux EC2 Server Instance. FYI The prepackaged YUM Amazon package does not work. Don’t install without a new repo file.


Do the following commands in a Putty terminal.

sudo chmod 2775 /etc/yum.repos.d

Using Sublime create a text file call mongodb-org-2.6.repo with the follow and using Filezilla updload it to /etc/yum.repos.d directory.

name=MongoDB Repository

Do the following commands:

sudo yum install -y mongodb-org
sudo service mongod start
sudo chkconfig mongod on # this turns on auto start on reboot

This process is further explained at


On a small system you will also need to do the following:

chmod 664 mongod.conf

Then edit the /etc/mongod.conf file and add the follow lines to the :storage block to allow small file blocking.

      smallFiles: true

Then start the service with:

mongod -f /etc/mongod.conf # this checks the config file

AMI Build All-in-One

Full build process

  1. Create an EC2 Linux Instance base – Amazon Linux AMI 2016.09.1 (HVM), SSD Volume Type – ami-0b33d91d
  2. Install the LAMP Stack default Apache port set to 8080 as it will be served to an Nginx reverse proxy server on the same instance (Apache 2.4, MySQL, PHP 6.7)
  3. Install the MEAN Stack
  4. Install Nginx Reverse Proxy Server
  5. Install ColdFusion 2016 update 3 Server

The server is setup and available for Free with a service contract from GTK Solutions.

Building a public Amazon AMI

A frustrating issue with building a public Amazon AMI is the authorize key that you use to build and modify the instance must be removed (which removes your own access to the instance.) The private key must be removed before it is shared.


It’s like the old problem, which comes first the chicken or the egg. So you remove the key but now you can’t login to your own system. You can only rebuild an EC2 from the ami image. Beyond that, you only do an rm to delete the file but the block of key data is still there in the EBS disk image. Someone could easily unpack the block and undelete the file to restore the authorize key file, connect to your private instances and run up your AWS bill or worse.

What’s the solution? Using additional EBS connections to create an image. Here is the procedure:

  1. Create a new 1gb EBS volume, attach, and mount it on the running instance, say under /keys Use the Amazon EBS guide to format and attach the EBS volume
  2. Copy your authorized_keys to the /keys on the new EBS
  3. Delete all sensitive files and all authorized_keys (from the primary EBS) Also delete the bash.history file and any other logs or passwords.
     sudo chmod 660 /root/.bash_history


  4. Exit Putty terminal windows and using Filezilla save empty history files to /root/.bash_history and /home/ec2-user/.bash_history
  5. Delete /tmp files
  6. Do not snapshot the live EBS volume as it still contains the deleted files and you don’t want to make them public in the new AMI. Instead,
  7. Create a new EBS volume, attach, and mount it on the running instance, say under /ebsimage
  8. Copy the root file system over to the new EBS volume. This only copies the current view of the undeleted files and does not copy the blocks containing the deleted files or any other modified file information. The command might look something like:
    rsync -axvSHAX --exclude 'ebsimage' / /ebsimage/
  9. Copy you authorize_keys back to your primary EBS
  10. unmount and detach the new EBS volume.
  11. Create an EBS snapshot of the new EBS volume.
  12. Register the EBS snapshot as a new AMI.

Powered by

Up ↑