DEV Community: Ganessh Kumar

My Notes on React

Ganessh Kumar — Tue, 05 Nov 2024 20:47:11 +0000

Boosting Your React App’s Performance with Lazy Loading and Memoization

Learn, unlearn and relearn

Ganessh Kumar — Fri, 01 May 2020 17:08:18 +0000

The illiterate of the 21st century will not be those who cannot read and write, but those who cannot learn, unlearn, and relearn - Alvin Toffler

Schools and Colleges play a vital role in teaching us. These institutions often tend to force their students to learn more and more, without mastering the fundamentals. Students who love their subjects and enjoy their books are becoming hard to find day by day. Industries view degree holders as an abstracted and tuned resources for their need.

So, “learning” has not been given the due respect by all the players: students, educational institutions and industries.

What about unlearning and relearning? Do they really make sense in our existing system?

Unlearning and relearning are tightly coupled and usually happens together.

Unlearning and relearning do not mean that one should forget the things he had learnt and learn it again at some point of time in his life. This is a very common misinterpretation I find among the people who know this quote. I have even seen people quoting “Tower of Hanoi” as an example where you have to decouple the things you have built to arrive at the final solution. I call this as a fictional example where they try to unlearn by demolishing something that is there.

Unlearning happens when you are open to new prospective to the things you already know. Relearning happens when you accept a new perspective and appreciate your knowledge from that perspective. Together they will help you to overcome your misconception and misunderstanding that was there from the time you learnt something new.

When we learn something for the first time, we will be focusing to get a bigger and abstracted view of it. We ignore small and important features. After learning something, a small discussion with friends or teaching someone or trying to summarize your learning will make you realize the minute details that you have missed when you learnt it.

Unlearning and relearning applies not only for education; but also to any form of knowledge or skill that we acquire. Our knowledge and skill can to be improved day by day.

Be open to thoughts. Keep learning, unlearning and relearning.

TL; DR: Be open to new perspective – clear out your misunderstandings – improve your understanding.

Pi-hole in Azure Container Instances

Ganessh Kumar — Fri, 01 May 2020 12:55:50 +0000

A simple guide to deploy Pi-hole, a black hole for Internet advertisements, in Azure Container Instances.

We use pi-hole's docker image.
We persist configurations and data across the container instances. To do so, we will use Azure Storage to mount file volumes in the containers.

1. Install Azure CLI and set your subscription

> az login

> az account set --subscription <subscription_id>

2. Create a Resource Group

> az group create --name <rg_name> --location <location>

3. Create a Storage account

> az storage account create --resource-group <rg_name> --name <storage_name> --location <location> --sku Standard_LRS

4. Create two file shares in the storage account created in the last step

az storage share create --account-name <storage_name> --name etc-pihole

az storage share create --account-name <storage_name> --name etc-dnsmasq

5. Obtain the storage account key

STORAGE_KEY=$(az storage account keys list --resource-group <rg_name> --account-name <storage_name> --query "[0].value" --output tsv)

5. Since our container will require a good number of configuration, let's use a yaml file

deploy-pi-hole.yaml

name: <container_group_name>
apiVersion: '2018-10-01'
location: <location>
tags: {}
properties:
  containers:
  - name: <container_name>
    properties:
      image: pihole/pihole:latest
      ports:
      - protocol: UDP
        port: 53
      - protocol: UDP
        port: 67
      - protocol: TCP
        port: 80
      - protocol: TCP
        port: 443
      environmentVariables:
      - name: TZ
        value: Asia/Kolkata
      - name: WEBPASSWORD
        value: <custom_large_string>
      resources:
        requests:
          memoryInGB: 1
          cpu: 1
      volumeMounts:
      - name: pihole
        mountPath: /etc/pihole/
        readOnly: false
      - name: dnsmasq
        mountPath: /etc/dnsmasq.d/
        readOnly: false
  restartPolicy: Always
  ipAddress:
    ports:
    - protocol: UDP
      port: 53
    - protocol: UDP
      port: 67
    - protocol: TCP
      port: 80
    - protocol: TCP
      port: 443
    type: public
    dnsNameLabel: <custom_dnsname>
  osType: Linux
  volumes:
  - name: pihole
    azureFile:
      shareName: etc-pihole
      readOnly: false
      storageAccountName: <storage_name>
      storageAccountKey: <value of $STORAGE_KEY>
  - name: dnsmasq
    azureFile:
      shareName: etc-dnsmasq
      readOnly: false
      storageAccountName: <storage_name>
      storageAccountKey: <value of $STORAGE_KEY>

Replace the place holders in the yaml file.

will be used as the password when you log in to pi-hole's dashboard.
will be used in the generated FQDN in the following format <custom_dnsname>.<location>.azurecontainer.io

6. Create the container instance

az container create --resource-group <rg_name> --file deploy-pi-hole.yaml

7. Get the IP address of the pi-hole running as container instance.

az container show --resource-group <rg_name> --name <container_group_name> --query ipAddress.ip --output tsv

Update: It has been 10 days since I started using pi-hole and it has blocked ~31% of my DNS queries so far.

If you found this article useful, check out my other articles from my blog, https://ganesshkumar.com/blog. Thank you for reading!

Self-hosting multiple applications in a single machine

Ganessh Kumar — Wed, 14 Aug 2019 20:39:11 +0000

I love self-hosting personal applications. I spun a machine on cloud and started hosting my applications. As I wanted to host my second application, I got struck routing both the application's request to the same machine without needing to specify a port number in the URL. Specifying a port number in the URL like http://miniflux.ganesshkumar.com:5000 and http://blog.ganesshkumar.com:4000 made the URL look ugly.

After searching for a while, I found that reverse proxy using nginx can come in handy. At this point, I also wanted to enforce SSL to the applications as my application needed login. Let's Encrypt provides free SSL certificates. Now I needed to put together nginx, certificates and my applications to work together. To reduce setup procedures, I opted to use Docker. In this post let's see how I put all the pieces together.

The first application I want to host in miniflux, a minimalist feed reader.

Let's create two folders in the home directory. data to hold all the volumes that will be mounted in docker and docker-compose to hold docker-compose files to launch the services and applications.

$ mkdir data docker-compose

1. Let's start our first application

Create the folders for data and docker-compose

$ mkdir data/miniflux docker-compose/miniflux

Then create docker-compose.yml file in the docker-compose/miniflux folder with the following content

version: '3'
services:
  miniflux:
    image: miniflux/miniflux:latest
    ports:
      - "8000:8080"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgres://<username>:<password>@db/miniflux?sslmode=disable
  db:
    image: postgres:10.1
    environment:
      - POSTGRES_USER=<username>
      - POSTGRES_PASSWORD=<password>
    volumes:
      - ${HOME}/data/miniflux:/var/lib/postgresql/data

Now running docker-compose up -d in the docker-compose folder will run this application in the background. We can reach the server on localhost:8000. Our first application is up and running now.

2. Starting nginx

Create the folders for data and docker-compose

$ mkdir data/nginx docker-compose/nginx

We will be mounting SSL certificates in nginx container, so that our applications will be served over a secured layer. Create folders for holding the certificates

$ mkdir -p data/letsencrypt/certs data/letsencrypt/certs-data

Then create docker-compose.yml file with the following contents

version: '3'
services:
  nginx:
    image: nginx:alpine
    container_name: nginx
    restart: always
    network_mode: host
    volumes:
      - ${HOME}/data/letsencrypt/certs:/etc/letsencrypt
      - ${HOME}/data/letsencrypt/certs-data:/data/letsencrypt
      - ${HOME}/data/nginx:/etc/nginx
    ports:
      - 80:80
      - 443:443

Before string the ngix container, we have to create a config file for nginx. Create data/nginx/nginx.conf file with the following content

events {
}

http {
    server {
        listen      80;
        listen [::]:80;
        server_name miniflux.ganesshkumar.com;

         location / {
                rewrite ^ https://$host$request_uri? permanent;
        }

        location ^~ /.well-known {
                allow all;
                root  /data/letsencrypt/;
        }
    }
}

This config dictates to redirect any request to miniflux.ganesshkumar.com to https://ganesshkumar.com. Also serve the request to /.well-known to be served from /data/letscrypt directory. This .well-known endpoint will be used by Let's Encrypt to verify our DNS entry for miniflux.

Now, we can run docker-compose up -d from the docker-compose directory to start the nginx server. The request to miniflux will not reach the application yet, as we haven't routed it to localhost:8000 but still the nginx server will help set up the SSL certificates for the miniflux domain.

3. Setting up SSL certificates

Let's Encrypt provides to tool certbot to create our SSL certificates. Let's use the docker image of certbot to do that. Run the following docker command.

$ docker run -it --rm \
        -v certs:/etc/letsencrypt \
        -v certs-data:/data/letsencrypt \
        deliverous/certbot \
        certonly \
        --webroot --webroot-path=/data/letsencrypt
        -d miniflux.ganesshkumar.com

The above command will generate a challage and tries to solve it at miniflux.ganesshkumar.com/.well-known. Our nginx server has enough configuration to host the contents of .well-known folder generated by the certbot.

On successful execution of the above command, you will have your certificates generated at data/letsencrypt/certs-data directory.

4. Routing the request to the application

Now let's modify the contents of nginx.conf file, to route the requests to miniflux.ganesshkumar.com to localhost:8000.

Add the following code to the http section of nginx.conf

    server {
        listen      443           ssl http2;
        listen [::]:443           ssl http2;
        server_name               miniflux.ganesshkumar.com;

        ssl                       on;

        add_header                Strict-Transport-Security "max-age=31536000" always;

        ssl_session_cache         shared:SSL:20m;
        ssl_session_timeout       10m;

        ssl_protocols             TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;
        ssl_ciphers               "ECDH+AESGCM:ECDH+AES256:ECDH+AES128:!ADH:!AECDH:!MD5;";

        ssl_stapling              on;
        ssl_stapling_verify       on;
        resolver                  8.8.8.8 8.8.4.4;

        ssl_certificate           /etc/letsencrypt/live/miniflux.ganesshkumar.com/fullchain.pem;
        ssl_certificate_key       /etc/letsencrypt/live/miniflux.ganesshkumar.com/privkey.pem;
        ssl_trusted_certificate   /etc/letsencrypt/live/miniflux.ganesshkumar.com/chain.pem;

        access_log                /dev/stdout;
        error_log                 /dev/stderr info;

        location / {
            proxy_pass           http://127.0.0.1:8000;
            proxy_set_header     Host $host;
            proxy_set_header     X-Forwarded-For $remote_addr;
        }
    }

We are almost done. Restart the nginx server to use the latest configuration. Run the following command in nginx's docker-compose directory.

$ docker-compose down
$ docker-compose up -d

That all. Our request to http://miniflux.ganesshkumar.com will be redirected to https://miniflux.ganesshkumar.com which will be served from localhost:8000, making sure that all the requests are being served over SSL.

To add a second application, just repeat all the four steps. You will be serving both the applications from the same machine using nginx reverse proxy.

5. Renewing SSL certificate

After few months your SSL certificate will expire. You can run the following command to renew the certificate.

$ docker run -t --rm \
      -v certs:/etc/letsencrypt \
      -v certs-data:/data/letsencrypt \
      deliverous/certbot \
      renew \
      --webroot --webroot-path=/data/letsencrypt

$ docker-compose kill -s HUP nginx

This set up has made the process of deploying any new application to the server simple :)

Adding MSL Shell to Windows Terminal

Ganessh Kumar — Wed, 14 Aug 2019 20:18:57 +0000

After installing any flavors of Linux using Windows Subsystem for Linux, WSL, on Windows 10, you open Microsoft's latest Windows Terminal and do not find your linux shell in it?

Then this guide is for you.

Make sure you have installed your desired version of Linux from the Windows Store.

In Windows Terminal click the dropdown icon and select settings. Alternatively, you can open it with Ctrl + , shortcut. This will open profiles.json file in your text editor

In the profiles.json file, find the profiles section. profiles is an array where each element in the array maps to a shell (powershell or cmd or any linux shell)

    "profiles" : 
    [
        {
            "acrylicOpacity" : 0.5,
            "background" : "#012456",
            "closeOnExit" : true,
            "colorScheme" : "Campbell",
            "commandline" : "powershell.exe",
            "cursorColor" : "#FFFFFF",
            "cursorShape" : "bar",
            "fontFace" : "Consolas",
            "fontSize" : 10,
            "guid" : "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",
            "historySize" : 9001,
            "icon" : "ms-appx:///ProfileIcons/{61c54bbd-c2c6-5271-96e7-009a87ff44bf}.png",
            "name" : "Windows PowerShell",
            "padding" : "0, 0, 0, 0",
            "snapOnInput" : true,
            "startingDirectory" : "%USERPROFILE%",
            "useAcrylic" : false
        },
        {
            "acrylicOpacity" : 0.75,
            "closeOnExit" : true,
            "colorScheme" : "Campbell",
            "commandline" : "cmd.exe",
            "cursorColor" : "#FFFFFF",
            "cursorShape" : "bar",
            "fontFace" : "Consolas",
            "fontSize" : 10,
            "guid" : "{0caa0dad-35be-5f56-a8ff-afceeeaa6101}",
            "historySize" : 9001,
            "icon" : "ms-appx:///ProfileIcons/{0caa0dad-35be-5f56-a8ff-afceeeaa6101}.png",
            "name" : "cmd",
            "padding" : "0, 0, 0, 0",
            "snapOnInput" : true,
            "startingDirectory" : "%USERPROFILE%",
            "useAcrylic" : true
        }
    ],

Add an entry in this array for your linux shell. To populate this, you need the following values
- Command to start your shell
  - To get list of WSL shells run the command wsl.exe --list
  - To start a particular WSL shell run wsl.exe -d <shell_name_from_above>
  - To set the home directory as default directory add ~ to the wsl.exe command
  - Our command to start Ubuntu-18.04 is wsl.exe ~ -d Ubuntu-18.04
- A new GUID (unique id in this array)
  - A random GUID can be generated from the linux shell by running uuidgen command
  - Replace <guid> in the below snippet with your new GUID (leave the paranthesis intact)
- Name and icon for the entry
  - Give an identifiable name like Ubuntu-18.04
  - For icon, you can give any file system path in the system. I am opting to use the default linux penguine logo that has been packaged along with the Windows Terminal. Hence, I set ms-appx:///ProfileIcons/{9acb9455-ca41-5af7-950f-6bca1bc9722f}.png as my icon path.

        {
            "acrylicOpacity":0.75,
            "closeOnExit":true,
            "colorScheme":"Campbell",
            "commandline":"wsl.exe ~ -d Ubuntu-18.04",
            "cursorColor":"#FFFFFF",
            "cursorShape":"bar",
            "fontFace":"Consolas",
            "fontSize":12,
            "guid":"{<guid>}",
            "historySize":9001,
            "icon" : "ms-appx:///ProfileIcons/{9acb9455-ca41-5af7-950f-6bca1bc9722f}.png",
            "name":"Ubuntu-18.04",
            "padding":"0, 0, 0, 0",
            "snapOnInput":true,
            "startingDirectory":"%USERPROFILE%",
            "useAcrylic":true
        }

As soon as you save the profiles.json file, the changes will be picked up by the Windows Terminal and you can see your WSL shell.

Start a shell and start configuring it. I have configure my shell to be zsh shell with oh-my-zsh extension.