DEV Community: Anil Kumar Maurya

Why to use PUMA in production for your Rails App

Anil Kumar Maurya — Fri, 07 Aug 2020 10:05:28 +0000

If you are still using Unicorn, Thin or Passenger open source application server in production then this post is for you.

Point to note that Passenger Enterprise is different from Passenger open source, this post only talks about Passenger open source.

This Blog Post has very good comparison about features provided by Unicorn, Puma & Passenger

Point to note in this comparison is that PUMA is multithreaded and Passenger is multithreaded in only Enterprise edition

If you believe that multithreaded server is of no use because Ruby has GIL then you should read below snippet from Heroku Blog

Therefore Heroku recommends to use Puma in production

Infact, dev.to (this blogging platform) is hosted on Heroku and uses Puma in production

Puma is already battle tested by Heroku, Recently Gitlab also migrated to Puma from Unicorn

Read about Gitlab migration journey here

Puma really outshine other options when your application is dependent on lots of I/O operations.

I did some benchmark to compare Passenger open source & Puma performance

Configuration used during benchmarking

Passenger gem:

Version: 6.0.5
Workers count: 6 (Default)

Puma gem:

Version: 4.3.5
Workers count: 4
Threads count: 5 *5 threads per worker

Machine:
macOS Catalina, Dual-Core Intel Core i5, 8GB RAM

Benchmarking tool and configuration

Tool used: https://github.com/wg/wrk
Configuration:

Threads: 2
Connections: 100
Duration: 30 sec

When I/O operations are minimal

homes.json API perform one DB query and return back json data

Passenger benchmark:

536 requests per second

Puma benchmark:

883 requests per second

Take away
64% increase in number of requests served per second
Puma can serve 10,000 more requests in 30 seconds

When I/O operation increases

homes/1.json API performs 2 operations, one DB query and one network call and then return back json data
Network call is HTTP.get('https://facebook.com')

Passenger benchmark:

9 requests per second

Puma benchmark:

29 requests per second

Take away
Puma is 3x faster
Puma can serve 600 more requests in 30 seconds

How to set correct thread and worker count for Puma

Every Application is different therefore there is no universal Puma config which everyone can use.
You will have to try different combination of threads and workers count to find out which one is good for your application.
I created one gem https://github.com/anilmaurya/puma-benchmark which can help you in finding correct thread and worker count for your application.

Ref

Traefik v2 with Lets Encrypt on Amazon's Elastic Container Service (ECS)

Anil Kumar Maurya — Sun, 26 Jul 2020 16:02:27 +0000

In this post we will learn how to setup Traefik v2 on ECS with built in LetsEncrypt SSL.

Before I start, I want to mention that Traefik is awesome reverse proxy & load balancer.

Steps which we will follow:

Build docker image for Traefik on our local machine
Push it on Amazon's Elastic Container Registry (ECR)
Use pushed image in Task Definition to run Service & Task for Traefik.

Build docker image for Traefik on our local machine

Dockerfile

FROM      alekitto/traefik-alpine

COPY      traefik_ecs.yaml /etc/traefik/traefik.yaml
RUN touch /etc/traefik/acme.json
RUN chmod +x /etc/traefik/acme.json

traefik_ecs.yaml

## Static configuration
entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https

  websecure:
    address: ":443"
    http:
      tls:
        certResolver: myresolver

api:
  dashboard: true

providers:
  ecs:
    exposedByDefault: true
    autoDiscoverClusters: false
    clusters:
    - YOUR_ECS_CLUSTER_NAME
    region: YOUR_AWS_REGION
    accessKeyID: "YOUR_AWS_ACCESS_KEY_ID"
    secretAccessKey: "YOUR_AWS_SECRET_ACCESS_KEY"

certificatesResolvers:
  myresolver:
    # Enable ACME (Let's Encrypt): automatic SSL.
    acme:
      email: "YOUR_EMAIL"
      storage: "acme.json"

      # CA server to use.
      # Uncomment the line to use Let's Encrypt's staging server,
      # leave commented to go to prod.
      #
      # Optional
      # Default: "https://acme-v02.api.letsencrypt.org/directory"
      #
      # caServer: "https://acme-staging-v02.api.letsencrypt.org/directory"
      # Use a TLS-ALPN-01 ACME challenge.
      #
      # Optional (but recommended)
      #
      # tlsChallenge:
      httpChallenge:

        # EntryPoint to use for the HTTP-01 challenges.
        #
        # Required
        #
        entryPoint: web

Now follow these steps to build docker image and push on Elastic Container Registry(ECR)

* Install AWS CLI https://aws.amazon.com/cli/ to execute these steps

export AWS_REGION='YOUR_AWS_REGION'

export AWS_ACCOUNT_ID='YOUR_ACCOUNT_ID'

export ECR_REPO_NAME='YOUR_REPO_NAME'

(aws ecr create-repository --repository-name $ECR_REPO_NAME) || true

eval $(aws ecr get-login --no-include-email --region eu-central-1)

docker build -t $ECR_REPO_NAME:\latest .

docker tag $ECR_REPO_NAME:\latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$ECR_REPO_NAME:\latest

docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$ECR_REPO_NAME:\latest

Create task definition to run task from image pushed on ECR

DOCKER LABELS

traefik.http.routers.dashboard.middlewares auth

traefik.http.middlewares.auth.basicauth.users anilmaurya:$apr1$1ktoln283782378923T43el/

traefik.http.routers.dashboard.rule Host(`example.com`) && (PathPrefix(`/api`) || PathPrefix(`/dashboard`))

traefik.http.routers.dashboard.service api@internal

Generate token for basicauth from this site https://hostingcanada.org/htpasswd-generator/

Create one service and run this traefik task definition, after traefik is running we need to add Docker labels to the containers running in same cluster

Example Docker labels:

traefik.http.routers.app.rule   Host(`example.com`)

traefik.http.services.app.loadbalancer.server.port  3000

Conclusion

Github: https://github.com/anilmaurya/ecs-traefik-v2

App can be accessed on https://example.com with SSL certificate from Lets Encrypt

traefik dashboard can be accessed on https://example.com/dashboard

** Replace example with your DNS

FastJsonparser, Fastest JSON parser for Ruby

Anil Kumar Maurya — Mon, 15 Jun 2020 13:17:59 +0000

FastJsonparser is ruby wrapper for simdjson which is written in c++.

JSON is de facto standard for exchanging data between web server and browser.

If your application is parsing large JSON data then you must consider optimising it for better performance.

I came across Simdjson which claims to parse gigabytes of JSON per second, It also claims to be over 2.5x faster than other production-grade JSON parsers. I thought this is fantastic why I am not using it.

I looked for the ways to use it and came across simdjson_ruby gem . It is wrapper for simdjson c++ library but unfortunately it was not working.

I started fixing it but got stuck in configurations then I thought why not create a new gem and import all code which I need from this gem, thus FastJsonparser was born.

To verify simdjson claim that it is really fast, I did benchmarking with existing gem Oj which claims to be fastest JSON parser for Ruby

Benchmark results:

Parsing 1.2 MB JSON file

Check benchmark reference here

Parsing local JSON

Check benchmark reference here

Clearly FastJsonparser outperforms both Oj and ruby’s built in JSON parser

How to Use FastJsonparser

Github: https://github.com/anilmaurya/fast_jsonparser

Let’s use it in your Ruby / Ruby on Rails projects and let me know how it performs.

P.S — Thank you https://github.com/saka1 for initial code.

When not to use Memoization in Ruby on Rails

Anil Kumar Maurya — Fri, 22 May 2020 11:45:52 +0000

Memoization is a wonderful concept in programming world. It helps in writing clean code which execute faster.

Continue reading on Medium »

Building Decentralised Link Shortner on Ethereum blockchain using Truffle

Anil Kumar Maurya — Wed, 17 Jul 2019 10:25:12 +0000

https://anilmaurya.github.io/link-shortner/

Blockchain is emerging technology, it needs no introduction. By any chance if you are left behind and don’t know about blockchain then I recommend reading about blockchain first before reading this article. You can read about blockchain here or here or search on internet and you will find plenty of article to read from.

What is Ethereum ?

Launched in 2015, Ethereum is the world’s leading programmable blockchain. It is a global, open-source platform for decentralized applications. These decentralized applications (or “dapps”) gain the benefits of cryptocurrency and blockchain technology. Read more about ethereum here.

What is Truffle ?

Truffle is a framework for blockchain development, it streamlined smart contract creation, compilation, testing, and deployment onto Ethereum. Read more about truffle here

What is Decentralised App ?

Decentralised application does not require centralised server to work (hence no maintenance cost). It interacts with smart contract deployed on blockchain network.

What is Smart Contract ?

Smart contracts are programs which govern the behaviour of accounts within the Ethereum state. We will write smart contract in Solidity language, Solidity is an object-oriented, high-level language for implementing smart contracts. Read more about solidity from here.

Getting Started:

A) Install npm, node & Truffle

Follow https://docs.npmjs.com/downloading-and-installing-node-js-and-npm for installing npn & node.

Then install truffle

npm install -g truffle

check if truffle installed successfully or not

$ truffle version
Truffle v5.0.21 (core: 5.0.21)
Solidity v0.5.0 (solc-js)
Node v11.0.0
Web3.js v1.0.0-beta.37

B) Create Project

Create new folder for project & initialise with truffle. We will use React Truflle box

$ mkdir link\_shortner
$ cd link\_shortner/
$ truffle unbox react
✔ Preparing to download
✔ Downloading
✔ Cleaning up temporary files
✔ Setting up box

Unbox successful. Sweet!

Commands:

Compile: truffle compile
  Migrate: truffle migrate
  Test contracts: truffle test

If you are new to Truffle then read about created directory from https://www.trufflesuite.com/docs/truffle/getting-started/creating-a-project

C) Install Ganache for blockchain setup on local machine https://www.trufflesuite.com/docs/ganache/overview

Link Shortner Smart Contract

Create LinkShortner.sol file inside contracts/ folder and write following content in it.

pragma solidity ^0.5.0;

contract LinkShortner {
  event LinkAdded(uint linkId, string url);
  uint lastLinkId;

struct LinkTemplate {
  address userAddress;
  string url;
 }

mapping (uint => LinkTemplate) public linkMapping;

constructor() public {
  lastLinkId = 0;
 }

function createNewLink(string memory url) public returns (uint, string memory) {
   lastLinkId++;
  linkMapping[lastLinkId] = LinkTemplate(msg.sender, url);
    emit LinkAdded(lastLinkId, url);
  return(lastLinkId, url);
 }

function getLink(uint linkId) public view returns(address, string memory) {
  LinkTemplate memory link = linkMapping[linkId];
  return(link.userAddress, link.url);
 }

function getLastLink() public view returns(address, string memory, uint) {
  LinkTemplate memory link = linkMapping[lastLinkId];
  return(link.userAddress, link.url, lastLinkId);
 }

}

Now deploy this contract on local blockchain network:

$ truffle compile
$ truffle migrate

Ganache Screenshot after contract deployment

React Application for interaction with Smart Contract

Open client/src/App.js file

Replace

import SimpleStorageContract from "./contracts/SimpleStorage.json";

with

import SimpleStorageContract from "./contracts/LinkShortner.json";

Creating new link

contract.methods.createNewLink(this.state.url).send({ from: accounts[0] })

Install Metamask chrome extension

and run React app

cd client
npm run start

Deploying contract on Ropsten test network

- Register new account on infura.io
- Create new project
- Get project api and connection link:
ROPSTEN\_URL=https://ropsten.infura.io/v3/<your-api-key>

Goto Truffle project, install truffle-hdwallet-provider

npm install truffle-hdwallet-provider — save

Create .env file, put MNEMONIC and _URL to file

MNEMONIC=wallet mnemonic 12 words
ROPSTEN\_URL=https://ropsten.infura.io/v3/<your-api-key>

Update truffle-config with following content

const path = require("path");
require('dotenv').config()
const HDWalletProvider = require('truffle-hdwallet-provider')
const MNEMONIC = process.env.MNEMONIC
const ROPSTEN\_URL = process.env.ROPSTEN\_URL

module.exports = {
  // See <[http://truffleframework.com/docs/advanced/configuration](http://truffleframework.com/docs/advanced/configuration)>
  // to customize your Truffle configuration!
  contracts\_build\_directory: path.join(\_\_dirname, "client/src/contracts"),
  networks: {
    ropsten: {
      provider: function() {
        return new HDWalletProvider(MNEMONIC, ROPSTEN\_URL);
      },
      network\_id: '3',
    },
    development: {
      host: "127.0.0.1",
      port: 7545,
      network\_id: "\*",
   },
   test: {
     host: "127.0.0.1",
     port: 7545,
     network\_id: "\*",
  }
 }
};

Run following command to deploy

truffle migrate --network ropsten

Sinatra API for reading Short Link on ethereum network

Create folder backend

Add following content in backend/app.rb

# Require the bundler gem and then call Bundler.require to load in all gems
# listed in Gemfile.
require 'bundler'
Bundler.require

require 'sinatra'
require 'ethereum'

before do
  content\_type 'application/json'
end

class Contract
  def initialize
[@client](http://twitter.com/client) = Ethereum::HttpClient.new("[https://ropsten.infura.io/v3/](https://ropsten.infura.io/v3/ebcc6fb682fd49a589e84d8a2360cbf0)<API-KEY>")
    contract\_json = JSON.parse(File.read('LinkShortner.json'))
[@contract\_abi](http://twitter.com/contract_abi) = contract\_json['abi']
[@address](http://twitter.com/address) = contract\_json["networks"]["3"]["address"]
[@client](http://twitter.com/client).default\_account = "0x3b8B0b23C4850FA8289da815a6abEE4Fc2DF941A"
  end

def result(id)
    return nil unless id
    contract\_instance.call.get\_link(id.to\_i)[1]
  end

def contract\_instance
    Ethereum::Contract.create(name: "LinkShortner", address: [@address](http://twitter.com/address), abi: [@contract\_abi](http://twitter.com/contract_abi),
                              client: [@client](http://twitter.com/client))
  end
end
class App < Sinatra::Base
  get '/url' do
    response.headers["Access-Control-Allow-Origin"] = "\*"
    return {url: Contract.new.result(params[:id])}.to\_json
  end
end

Deploy sinatra API on heroku

heroku create
heroku buildpacks:set [https://github.com/timanovsky/subdir-heroku-buildpack](https://github.com/timanovsky/subdir-heroku-buildpack)
heroku buildpacks:add heroku/ruby
heroku config:set PROJECT\_PATH=backend
git push heroku master

Now use deployed API for reading short link

fetch("https://<heroku-app-url>/url?id="+id).then((response) => {
  return response.json();
}).then((response) => {
  const url = response.url
  console.log(url)
})

That’s it, now you have your link shortner decentralised app deployed on ethereum network. Generated short link can be shared with anyone, irrespective of browser. For creating short link Metamask plugin is required.

Code is hosted on github

Application is hosted at http://anilmaurya.github.io/link-shortner

References:

https://medium.com/@nhancv/deploy-smart-contract-with-truffle-79d2bf218332

https://hackernoon.com/making-a-decentralized-url-shortener-using-ethereum-4fdfccf712a6