One of the most popular English newspaper in Bangladesh is The Daily Star. I was searching for their rss feed url to read them on time. But failed as it is not there. So, I decided to make my own.

It is a valid RSS: https://newsindex.fahadahammed.com/feed/get_feed_data/thedailystar/feed.xml

I would love to take some suggestions from you if you think you have. And also I am just freely giving it to public and if The Daily Star has something to say about this, I am open to listen and talk.

I have a VM with one CPU only and there I run #nginx 1.18.0 in ubuntu server. It involves with some lightweight work like static content serve and as well as dynamic content with load balancer capability.

If I check the command:

# ps -ef --forest | grep nginx | grep -v color

root 578518 1 0 12:49 ? 00:00:00 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
www-data 578519 578518 0 12:49 ? 00:00:00 _ nginx: worker process
www-data 578520 578518 0 12:49 ? 00:00:00 _ nginx: cache manager process
www-data 578521 578518 0 12:49 ? 00:00:00 _ nginx: cache loader process

gives me some interesting facts.

1. It has 1 master process.
2. it has 1 worker process.
3. It has 1 cache manages process.
4. It has 1 cache loader process.

What are these processes?

• master process performs some specific operations such as reading configuration from disk, bind ports and create child processes.
• worker processes do all of the work we ask nginx to do to handle the traffics and similar things like network connections, read and write content to disk, handle communications with upstream servers.
• cache loader only runs on startup and load the disk-based caches into memory and then exits. So, If you check the process list when nginx is started some times back, then you won’t find this process.
• cache manager process runs periodically and manage the cache cleanup, invalidating cache objects and similar things. It is scheduled and thus not always taking resources.

There are some default parameter in the configuration which acts ok in many cases.

• With one CPU in this VM and with default configuration like worker_processes as auto. Which is saying a number 1 with available CPU core.
• Each worker process manages multiple connections simultaneously in a non blocking way. This approach minimizes the need for context switches, enhancing performance.
• Worker processes are single-threaded and operate independently. This means each one can grab new connections and process them without waiting for others.
• Despite their independence, worker processes can communicate with each other through shared memory. This is particularly useful for accessing shared cache data, session persistence information, and other shared resources.

Of Course depending on specific use case, tweaking those default values are possible to configure.

To take down the services deployed by Kubernetes, this oneliner is pretty handy in some situations despite being too cluttered command… But it does work in situations.

% kubectl get deployments | awk '{print $1}' | grep -v "NAME" | while read f; 
do
    kubectl scale deployment $f --replicas=0;
done

I should rename the title to “Install Postman in POP OS” as recently I have been working on a POP OS. This thing is sleek. I love the workflow. It comes with default FLATPAK and no SNAP. I did not want to use snap.

So here I am, installing Postman from their binary compressed file.

Here is the script I have used to install postman.

After running this script, You should be able to find POSTMAN searching on application menu.

As of 16th October 2022, We have Kubernetes Version 1.25.2 and It follows X.Y.Z versioning where X is the major, Y is the Minor and Z is the Patch version. From 2014 to now, It has grown so much that we all might agree that this Software is one of a kind.

I am not here to talk about its maturity and usefulness or similar. I have first been introduced to this tool back in 2015 as it was an Alpha version back then which made me hate my life a lot of time configuring and managing self-configured clusters. I should not feel low by accepting that I still have very little knowledge about this tool and practices related to Kubernetes. But over the years I tried to make it work for me and simplified my understanding. From version 1.6, Taints, Toleration, and Node Affinity got extra focus as they got a promotion to Beta. Let me share my thoughts about them.

To understand them, I took an example of a typical home’s furniture use case.

Assume, I have these three pieces of furniture in my home.

And my wife has some rules to follow when using them.

1. The cupboard should be used only for kitchen items.
2. The Wardrobe is primarily for special clothes where we do have a hanging solution.
3. The closet is about other clothes, shoes, etc items to keep.

In her opinion, If We do not abide by those rules, It will destroy tranquility. 🙂

Let us assume that these rules are categorized into 3.

1. Taint
2. Toleration
3. Affinity

To match these rules with the furniture, assume that some rules are applied to the furniture and some are to the things we keep on the furniture.

• Taint:
  • These rules are applicable to the furniture. i.e. Some kind of identity matching like a portion of the furniture is marked in some way.
  • Tainting works with Toleration.
  • Taint is the counterpart of Toleration.
• Toleration:
  • These rules are applicable to the items or things. i.e. Some kind of identity matching with the furniture where it is expected.
  • Toleration is the counterpart of Taint.
• Affinity:
  • This is not directly connected with the first two categories.
  • These rules are workable with the object’s properties.
  • It works with some conditions or matching of certain tags. i.e I have some shoes but one of them is a bit special and I want to keep it always in my wardrobe’s special section, not the closet with other shoes or not with clothes.

Enough with this symbolic representation. I guess you have got a basic idea of what are they.

If you do work with Linux Servers or Linux Systems like me, you must have heard about the command “ss“. If you are not sure, you might know “netstat“. Netstat is obsolete now. The features it provided now can be obtained or achieved by “ss” and some other commands.
If you check the man page of Netstat you will find these lines.

This program is mostly obsolete.  Replacement for netstat is ss.
       Replacement for netstat -r is ip route.  Replacement for netstat
       -i is ip -s link.  Replacement for netstat -g is ip maddr.

You can also find some replacements table from this google spreadsheet link.

I am not going to talk about the legacy command of “netstat“. The purpose of this article will be about “ss“.

SS tool collects the network information directly from the kernel via sockets API. I will share some commands and expected results from that.

But, first, let me ask you the question which is an example of what you can ask SS.

How to find the process id of a port that is open for connection?

# ss -tulpn | grep ":22 "
Netid   State    Recv-Q   Send-Q      Local Address:Port      Peer Address:Port  Process                                                                   
tcp     LISTEN   0        128               0.0.0.0:22             0.0.0.0:*      users:(("sshd",pid=756,fd=3))                                    
tcp     LISTEN   0        128                  [::]:22                [::]:*      users:(("sshd",pid=756,fd=4))                             

Let me break down the command and its outputs. To be clear, I have added the heading. It is not supposed to be there as I grepped the lines having a port. For better understanding, I did add the line.
Here,

       -t, --tcp
              Display TCP sockets.
       -u, --udp
              Display UDP sockets.
       -l, --listening
              Display only listening sockets (these are omitted by
              default).
       -p, --processes
              Show process using socket.
       -n, --numeric
              Do not try to resolve service names. Show exact bandwidth
              values, instead of human-readable.

You will not be able to view all the process information without “root” user. After finding the process id you can go further with “ps” command.

How many connections right now in a particular port and what are the IP addresses of those connections are from?

# ss -t -a  | grep ssh
LISTEN    0      128           0.0.0.0:ssh               0.0.0.0:*           
ESTAB     0      36     SERVER_PUBLIC_IP:ssh         CLIENTS_IP:58852       
LISTEN    0      128              [::]:ssh                  [::]:*

You can test this by doing telnet SERVER_PUBLIC_IP 22 to test using the above command. It will have another connection with “ESTAB”.
This command is not pretty. We can achieve the same goal by using only SS.

ss -o state established '( dport = :ssh or sport = :ssh )'
Netid       Recv-Q        Send-Q                Local Address:Port                Peer Address:Port        Process                          
tcp         0             0                    SERVER_PUBLIC_IP:ssh                CLIENTS_IP1:58852        timer:(keepalive,87min,0)       
tcp         0             0                    SERVER_PUBLIC_IP:ssh                 CLIENTS_IP2:45892        timer:(keepalive,118min,0)

How to find connections to certain ports from specific IP addresses? Also, you want to close the connections other than specific IP addresses. How?

# ss -o state established '( dport = :ssh or sport = :ssh not dst = ALLOWED_IP )' -p
Netid          Recv-Q          Send-Q                    Local Address:Port                    Peer Address:Port           Process          
tcp            0               0                        SERVER_PUBLIC_IP:ssh                    CLIENT_IP:53750           users:(("ssh",pid=894,fd=13))

The result is pretty clear. It is searching for SSH connection and also filtering the result where IP is not the allowed one. If you add “-K” at the above command, it will close all the connections that are found through the filter.

ss -o state established '( dport = :ssh or sport = :ssh not dst = ALLOWED_IP )' -p -k

I guess that is it for today. I will share my other experience with SS and associated or extended commands with a similar purpose later.

Thanks for reading.

I have been playing with RaspberryPI for a while. There are several project I tried to do with RaspberryPI. These boards play a significant role in my home lab for different experiments like Docker Private Repository, Media Server, Ad Blocker with pi-hole, Secure Proxy for anonymity, secure network access with VPN, Home Security Camera/Surveillance, Data Collector or scraper etc. But This time, I did buy a “DHT-22” sensor for monitoring room temperature and humidity. Humidity is my main concern and wanted to see how it fluctuates.

So, my main plan was to get a DHT-22 to connect properly

with my spare RapberryPI 3B+. I did order the sensor and 3 male-to-male jumper for connectivity. Though I should have had a BreadBoard too. However, raspberryPI had already Ubuntu Server 20 installed.

For DHT-22, I needed to connect the female-to-female into the pins

14: Ground
17: 3v3 Power
18: GPIO 24

This GPIO-24 was important to note down as it was needed in Python Code to access the sensor through this pin.

Yes, I have used python to access the sensor. For testing, I have used this code:

#!/usr/bin/python3

import Adafruit_DHT
import datetime

def th_reader():
    # for DHT11
    # sensor = 11
    # for DHT22
    sensor = 22

    gpio = 24

    h_t = Adafruit_DHT.read_retry(sensor, gpio)
    humidity = h_t[0]
    temperature = h_t[1]
    if humidity is not None and temperature is not None:
        temp = '{0:0.1f}°C'.format(temperature)
        humid = '{0:0.1f}%'.format(humidity)
        return {
                "temperature": temp,
                "humidity": humid
                }
    else:
        temp = None
        humid = None
        return {
                "temperature": temp,
                "humidity": humid
                }


if __name__ == '__main__':
   print(th_reader())

The output it gives-

{'temperature': '26.1°C', 'humidity': '85.8%'}

But the requirements to run the code is-

sudo apt-get update
sudo apt-get install python3-pip
sudo python3 -m pip install --upgrade pip setuptools wheel
sudo pip3 install Adafruit_DHT

You can check other methods to install from here: https://github.com/adafruit/Adafruit_Python_DHT

This was enough for me. I wanted to run the script every 5 minutes through cron and store the data to already running influxDB instance in another RaspberryPI at which I can create dashboards and others. You can check how I am using InfluxDB through here: https://fahadahammed.com/explore-influxdb-part-1/

So, I did create a bucket in the influxDB and modified the code to this-

#!/usr/bin/python3

import Adafruit_DHT
import datetime
import threading
from influxdb_client import InfluxDBClient, Point, WritePrecision
from influxdb_client.client.write_api import SYNCHRONOUS

def th_reader():
    # for DHT11
    # sensor = 11
    # for DHT22
    sensor = 22

    gpio = 24

    h_t = Adafruit_DHT.read_retry(sensor, gpio)
    humidity = h_t[0]
    temperature = h_t[1]
    if humidity is not None and temperature is not None:
        temp = '{0:0.1f}°C'.format(temperature)
        humid = '{0:0.1f}%'.format(humidity)
        return {
                "temperature": temperature,
                "humidity": humidity
                }
    else:
        temp = None
        humid = None
        return {
                "temperature": temp,
                "humidity": humid
                }


def write_to_influxdb(data_to_write):
    # You can generate an API token from the "API Tokens Tab" in the UI
    token = "<INFLUX_TOKEN>"
    org = "myorg"
    bucket = "dht"
    influx_url = "<INFLUX_URL>"

    with InfluxDBClient(url=influx_url, token=token, org=org) as client:
        write_api = client.write_api(write_options=SYNCHRONOUS)
        pt = Point("temperature").tag("host", "pi").field("temperature", int(data_to_write.get("temperature"))).time(datetime.datetime.utcnow(), WritePrecision.NS)
        write_api.write(bucket, org, pt)
        client.close()
    with InfluxDBClient(url=influx_url, token=token, org=org) as client:
        write_api = client.write_api(write_options=SYNCHRONOUS)
        ph = Point("humidity").tag("host", "pi").field("humidity", data_to_write.get("humidity")).time(datetime.datetime.utcnow(), WritePrecision.NS)
        write_api.write(bucket, org, ph)
        client.close()
    
    return True


if __name__ == '__main__':
   th_data = th_reader()
   print(th_data)
#    write_to_influxdb(data_to_write=th_data)
   t1 = threading.Thread(target=write_to_influxdb, kwargs={"data_to_write": th_data})
   t1.start()

If you want to use the code block, please do replace the <INFLUX_URL> and <INFLUX_TOKEN> with valid ones.

Now the output is the same json but without the ‘%’ and ‘°C’. Because I needed to get a numerical value and set the required prefixes in graph.

I have used InfluxDB Data Point to write data.

Exported JSON of this minimal dashboard is-

I have other plans to use the DHT-22 like controlling exhaust fan or similar. Maybe later. For now, I will just collect data and observe the fluctuation of my rooms temperature and humidity.

It was fun working with InfluxDB and DHT-22 with RaspberryPI.

Thanks for reading. Please give me feedback If you have idea for me or point me some improvements.