Todd Rodzen

Agile Application Development

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.


my Resume:

my Coding and AWS systems design blog:

my Personal Portfolio:

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

Powered by

Up ↑