Maruf's

Cat Foster

Mon, 01 Jan 2024 00:00:00 +0000

Competitive Programmer

Mon, 01 Jan 2024 00:00:00 +0000

Solved overall 1100+ problems on different Online Judges.
Solved 330+ problems on UVA Online Judge. [the_redback]
Solved 155+ problems on LightOJ [the_redback]
Former Candidate Master at Codeforces (Rating:1845, Expert at new rating system) [the_redback]. Solved 450+ problems. Visualize Codeforces stats here.
Former Expert at TopCoder (Rating: 1400) [the_redback]
Also participated in many online contests at CodeChef [the_redback], HackerRank [the_redback] and Spoj [maruf2hin]

Researcher

Mon, 01 Jan 2024 00:00:00 +0000

Software Engineer

Mon, 01 Jan 2024 00:00:00 +0000

Traveller

Mon, 01 Jan 2024 00:00:00 +0000

Catalog and detection techniques of microservice anti-patterns and bad smells: A tertiary study

Fri, 01 Sep 2023 00:00:00 +0000

Visualizing Anti-Patterns in Microservices at Runtime: A Systematic Mapping Study

Sun, 01 Jan 2023 00:00:00 +0000

Visualizing Microservice Architecture in the Dynamic Perspective: A Systematic Mapping Study

Tue, 01 Nov 2022 00:00:00 +0000

Microservice Architecture Reconstruction and Visualization Techniques: A Review

Mon, 01 Aug 2022 00:00:00 +0000

Microvision: Static analysis-based approach to visualizing microservices in augmented reality

Mon, 01 Aug 2022 00:00:00 +0000

Using Microservice Telemetry Data for System Dynamic Analysis

Mon, 01 Aug 2022 00:00:00 +0000

Survey on Tools and Techniques Detecting Microservice API Patterns

Fri, 01 Jul 2022 00:00:00 +0000

Code Smell Prioritization with Business Process Mining and Static Code Analysis: A Case Study

Wed, 01 Jun 2022 00:00:00 +0000

Technical Debt Resulting from Architectural Degradation and Code Smells: A Systematic Mapping Study

Sat, 01 Jan 2022 00:00:00 +0000

BearMapping

Mon, 27 Dec 2021 03:06:27 +0600

Built a Java Spring Boot microservices backend to automate literature review workflows and identify research papers based on user-defined queries.
Developed data ingestion and NLP pipelines in Python to process and index large volumes of research papers for efficient search and discovery.
Containerized services and deployed using Docker Compose to enable reproducible environments and simplified microservices orchestration.

Using Static Analysis to Address Microservice Architecture Reconstruction

Mon, 01 Nov 2021 00:00:00 +0000

Using Version Control and Issue Tickets to detect Code Debt and Economical Cost

Mon, 01 Nov 2021 00:00:00 +0000

On Microservice Analysis and Architecture Evolution: A Systematic Mapping Study

Thu, 01 Jul 2021 00:00:00 +0000

Microservice Architecture (MSA) Reconstruction

Wed, 27 Jan 2021 03:06:27 +0600

Designed a Software Architecture Reconstruction (SAR) framework in Java to generate dynamic service dependency graphs by parsing Istio distributed tracing logs.
Developed engine to detect runtime anti-patterns and architectural drift via telemetry analysis.
Implemented automated visualization pipelines for architecture tracking and system auditing.

KubeDB

Tue, 11 Feb 2020 03:06:15 +0600

A tool to automate database deploy on Kubernetes using CRD. It also takes scheduled backup of databases.

Built Kubernetes Custom Resource Definitions (CRDs) and controllers in Go to manage database lifecycle operations within Kubernetes clusters.
Developed modular operator architecture including API machinery, CLI, installer, and database-specific controllers for PostgreSQL, MongoDB, Elasticsearch, Redis, and MySQL.
Implemented reconciliation loops, leader election, and rolling upgrade mechanisms for reliable distributed database orchestration.

My Kubectl Cheat Sheet

Sun, 03 Mar 2019 00:15:10 +0600

Kubectl Cheat Sheet

> minikube version
> minikube start
> kubectl version
> kubectl get nodes

Run app in kubernetes

Run app in kubernetes by kubectl

> kubectl run kubernetes-bootcamp --image=docker.io/jocatalin/kubernetes-bootcamp:v1 --port=8080

also run GRPS_Sample //problematic

> kubectl run kubernetes-grpc-sample --image=maruftuhin/server_grpc_sample --port=8088

See deployments

> kubectl get deployments

run proxy and echo

> kubectl proxy

setting up POD_NAME variable

> export POD_NAME=$(kubectl get pods -o go-template --template '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}')
> echo Name of the Pod: $POD_NAME

> curl http://localhost:8001/api/v1/proxy/namespaces/default/pods/$POD_NAME

Pods

> kubectl get pods
> kubectl describe pods
> kubectl logs $POD_NAME

Execute commands on container

settings up env variables

> kubectl exec $POD_NAME env

run a container

> kubectl exec -ti $POD_NAME bash
> exit

Services on kubernetes

> kubectl get services

create and expose new service

> kubectl expose deployment/kubernetes-bootcamp --type="NodePort" --port 8080

setting up Node Port variable

> export NODE_PORT=$(kubectl get services/kubernetes-bootcamp -o go-template='{{(index .spec.ports 0).nodePort}}')
> echo NODE_PORT=$NODE_PORT

accessing POD from external

> curl host01:$NODE_PORT

accessing pod from internal

> kubectl exec -ti $POD_NAME curl localhost:8080

get description of only one deployment

> kubectl get pods -l <label>
i.e.
> kubectl get pods -l run=kubernetes-bootcamp
> kubectl get services -l run=kubernetes-bootcamp

setting up lable. 1st get POD NAME. then

> export POD_NAME=$(kubectl get pods -o go-template --template '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}')
> echo Name of the Pod: $POD_NAME

label it

> kubectl label pod $POD_NAME app=v1

List of pods using label “app=v1”

> kubectl get pods -l app=v1

delete services with label run=kubernetes-bootcamp

> kubectl delete service -l run=kubernetes-bootcamp

Scaling

> kubectl get deployments

scale to 4 replicas. [kubernetes–bootmcamp] is name of deloyments

> kubectl scale deployments/kubernetes-bootcamp --replicas=4

current pods

> kubectl get pods -o wide

Change log

> kubectl describe deployments/kubernetes-bootcamp

find exposed ip and service

> kubectl describe services/kubernetes-bootcamp

set environment variable NODE PORT

> export NODE_PORT=$(kubectl get services/kubernetes-bootcamp -o go-template='{{(index .spec.ports 0).nodePort}}')
> echo NODE_PORT=$NODE_PORT

Run this command to see which pod is serving

> curl host01:$NODE_PORT

Scale down service to 2 replicas from 4 replicas

> kubectl scale deployments/kubernetes-bootcamp --replicas=2

Description again

> kubectl get deployments
> kubectl get pods -o wide

Updating Application

> kubectl get deployments
> kubectl get pods

current image version of app

> kubectl describe pods

update the image to version 2

> kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=jocatalin/kubernetes-bootcamp:v2

Changes in Pods

> kubectl get pods

Verify update

service description

> kubectl describe services/kubernetes-bootcamp

setting up NODE PORT

> export NODE_PORT=$(kubectl get services/kubernetes-bootcamp -o go-template='{{(index .spec.ports 0).nodePort}}')
> echo NODE_PORT=$NODE_PORT

rollout status command to see update

> kubectl rollout status deployments/kubernetes-bootcamp

Rollback update

First deploy update tag v10 for example

> kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=jocatalin/kubernetes-bootcamp:v10

status

> kubectl get deployments
> kubectl get pods
> kubectl describe pods
# we can see, not all are v10 applied

rollback to previous working state

> kubectl rollout undo deployments/kubernetes-bootcamp

Run own program docker-gRPC

> docker images
> kubectl run grpc-sample3 --image=maruftuhin/server_grpc_sample:tag --port=8088
> kubectl get pods

access from internal

> kubectl proxy
> curl --data "{\"name\": \"pc1\", \"a\":2,\"b\":3}" http://localhost:8001/api/v1/proxy/namespaces/default/pods/<pods id >/echo

access from external [Expose ]

> kubectl expose deployment/grpc-sample3 --type="NodePort" --port 8088
> kubectl get services/grpc-sample3

setting $Node_Port variable. but the ports can also be used from “kubectl get services/grpc-sample3” results

> export NODE_PORT=$(kubectl get services/grpc-sample3 -o go-template='{{(index .spec.ports 0).nodePort}}')
> kubectl get services/grpc-sample3
> kubectl get nodes
> kubectl get svc grpc-sample3 -o yaml
> minikube service grpc-sample3 --url
> curl --data "{\"name\": \"pc1\", \"a\":2,\"b\":3}" http://192.168.99.100:32258/echo

My Docker Cheat Sheet

Fri, 01 Mar 2019 04:05:30 +0600

Docker Cheat Sheet

Build and run a docker image

Build docker images from docker file, goto dockerfile directory and command:

docker build -t friendlynginx .

Run docker image from locally built image

docker run -d -p 50053:8088 friendlynginx
# -d for running it in background //50053:8088 is the exposed port

Connect with docker hub and push to directory, a directory maruftuhin/nginx is created i docker hub at first, then login

docker login
docker tag friendlynginx maruftuhin/nginx:tag
docker push maruftuhin/nginx

Pull image from docker hub:

docker pull maruftuhin/nginx:tag

Run image using tag , [if locally unavailable, it pulls from online]

docker run -p -d 4000:8088 maruftuhin/nginx:tag

List of images and containers

List of images

docker images

List all exited containers

docker ps -a -q -f status=exited

List of containers

docker ps -a
# -a for all

Stop/remove a container or image

Stop a container

docker stop <container_id>

Start a exited container

docker start <container id>

Remove an image

docker rmi <image_id>

Remove a container

docker rm <container id>
docker rm <container_name>

Remove more than one image/container

docker rm <container id> <container_id>

Making change in a container/image

Creates a container for a image and enters it directory

docker run -it <image_id> /bin/bash

Insert in a existing container [the container must be UP]

docker exec -it <container_id> bash
# example: docker exec -it ecf1310ac3ed bash

Anything can be installed in that container, example, at first insert into a container and command:

apt-get update
apt-get install fish
apt-get install php    #installs latest php

Exit container directory

exit

Creates a image/snapshot of a [may be modified] container

docker commit <container_id> new_id_of_image

Executing container commands

Start a exited container

docker start <container id>

Restart a crashed container

docker restart <contaienr_id>

Start fish in interactive mode

docker exec -it <container_id> fish

Start php inside container

docker exec -it <container_id> php -a
echo "hello world";
exit

Names of conatiners or Images

Rename existing container

docker rename <old_name> new_name

Giving the container a name, while rnning it

docker run -it --name newName <container_id> bash

Copy files from a container

Create a text file inside container. insert the container and command:

touch test.txt

Copy from container. Exit from container and command:

docker cp containerName:/test.txt .    #copies test.txt to host root

Copy into container

docker cp ./test1.txt  containerName:/

Container hostnames

Gives a new hostname to the container. it doesn’t change the Names of container. but when user is inside the container, it sees the hostname, in this case, it’s root@test.

docker run -it -h test.local <image_id> bash

Handling volumes

It links between a directory of host and directory of container. in command, left side of “:” defines the source of host direcotry and right side defines destination into container.In this case, changing in ~/data of directory of host machine also takes place changing in container automatically

Bind mounts, the pasth is absolute here

docker run -it --name test21 -v ~/data:/data <image_id> bash

Volume help

docker volume --help

Inspect a docker container

docker inspect <container_id>

Named volume [non-bind mount], here the path is not absolute

docker run -it  -v data:/data <container_id> bash

Used volumes of local machine in container

docker volume ls

If same volume is used in another container, they will share the volume.

docker run -it  -v data:/data <container_id> bash   //shares previous data volume

Remove docker volume, volume_name is available in docker volume ls

docker volume rm <volume_name>

Multiple volume

docker run -it  -v data:/data  -v myBin:/myBin <container_id> bash

Copy volume from another container

docker run -it --name slave --volume-from <master_container_id/Name> <image_id> bash

Inspect docker volume

docker volume inspect <volume_name>

Show danglisg volumes [not used by any container]

docker volume ls -f dangling=true

Remove one volume that is not used

docker volume rm <volume name>

Removing all unsed volumes

docker volume prune

Anonymous volume. –rm will delete anonymous volume after remove container. here /foo is a anonymous volume

docker run --rm -v /foo -v awesome:/bar busybox top

Untagged Images

Show untagged images

docker images -f "dangling=true" -q

Delete all untagged images

docker images -f "dangling=true" -q | xargs docker rmi

Delete multiple images

Delete images of same name

docker images --format '{{.Repository}}:{{.Tag}}' | grep 'imagename' | xargs docker rmi
# or,
docker images -q imagename | uniq | xargs docker rmi --force

Docker killer!!! :P

Stop all container

docker ps -a -q | xargs docker stop

Delete all container

docker ps -a -q | xargs docker rm

Removing all unused volumes

docker volume prune

Remove untagged dockers

docker images -q -f "dangling=true" | xargs docker rmi

Remove stopped containers

docker ps -aq --no-trunc -f status=exited | xargs docker rm

Remove all images

docker images -q | xargs docker rmi

Start fresh

Dangerous!!! Deletes everything!!

sudo systemctl stop docker.service
sudo rm -rf /var/lib/docker
sudo systemctl start docker.service

Copy Local images to Minikube

For bash

docker save <image-name> | pv | (eval $(minikube docker-env) && docker load)
# or,
docker save <image-name> | (eval $(minikube docker-env) && docker load)

Stash

Mon, 11 Feb 2019 03:06:15 +0600

A complete Kubernetes native disaster recovery solution for backup and restore your volumes and databases in Kubernetes on any public and private clouds.

Kubernetes-native disaster recovery solution using restic for backup and restore volumes and databases.
Designed and implemented database-aware backup and Point-in-Time Recovery (PITR) workflows for MongoDB and Elasticsearch using custom hooks, sidecar orchestration, and scheduled snapshots to ensure data consistency.
Integrated Stash with KubeDB and built backup pipelines with automated recovery, improving database reliability across Kubernetes environments.

Mongodb Replica Set on Kubernetes

Sat, 12 Jan 2019 03:07:50 +0600

Replica-Sets

Run MongoDB Replica Set on Kubernetes using Statefulset and PersistentVolumeClaim. Minikube kubernetes cluster is used for this post.

Create Secret for Key file

MongoDB will use this key to communicate internal cluster.

$ openssl rand -base64 741 > ./replica-sets/key.txt

$ kubectl create secret generic shared-bootstrap-data --from-file=internal-auth-mongodb-keyfile=./replica-sets/key.txt
secret "shared-bootstrap-data" created

Deploy MongoDB Replica-Sets YAML

apiVersion: v1
kind: Service
metadata:
  name: mongodb-service
  labels:
    name: mongo
spec:
  ports:
  - port: 27017
    targetPort: 27017
  clusterIP: None
  selector:
    role: mongo
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongod
spec:
  serviceName: mongodb-service
  replicas: 3
  selector:
    matchLabels:
      role: mongo
      environment: test
      replicaset: MainRepSet
  template:
    metadata:
      labels:
        role: mongo
        environment: test
        replicaset: MainRepSet
    spec:
      containers:
      - name: mongod-container
        image: mongo:3.4
        command:
        - "numactl"
        - "--interleave=all"
        - "mongod"
        - "--bind_ip"
        - "0.0.0.0"
        - "--replSet"
        - "MainRepSet"
        - "--auth"
        - "--clusterAuthMode"
        - "keyFile"
        - "--keyFile"
        - "/etc/secrets-volume/internal-auth-mongodb-keyfile"
        - "--setParameter"
        - "authenticationMechanisms=SCRAM-SHA-1"
        resources:
          requests:
            cpu: 0.2
            memory: 200Mi
        ports:
        - containerPort: 27017
        volumeMounts:
        - name: secrets-volume
          readOnly: true
          mountPath: /etc/secrets-volume
        - name: mongodb-persistent-storage-claim
          mountPath: /data/db
      volumes:
      - name: secrets-volume
        secret:
          secretName: shared-bootstrap-data
          defaultMode: 256
  volumeClaimTemplates:
  - metadata:
      name: mongodb-persistent-storage-claim
      annotations:
        volume.beta.kubernetes.io/storage-class: "standard"
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Now Deploy the Yaml

$ kc create -f ./replica-sets/mongodb-rc.yaml 
service "mongodb-service" created
statefulset "mongod" created

Wait for Pod running and PVC

$ kubectl get all
NAME                  DESIRED   CURRENT   AGE
statefulsets/mongod   3         3         2m

NAME          READY     STATUS    RESTARTS   AGE
po/mongod-0   1/1       Running   0          2m
po/mongod-1   1/1       Running   0          2m
po/mongod-2   1/1       Running   0          2m

$ kubectl get pvc
NAME                                        STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
mongodb-persistent-storage-claim-mongod-0   Bound     pvc-ba24dc66-319a-11e8-8dd9-080027779e8d   1Gi        RWO            standard       1h
mongodb-persistent-storage-claim-mongod-1   Bound     pvc-bf2e51a5-319a-11e8-8dd9-080027779e8d   1Gi        RWO            standard       1h
mongodb-persistent-storage-claim-mongod-2   Bound     pvc-c7948f87-319a-11e8-8dd9-080027779e8d   1Gi        RWO            standard       1h

Setup ReplicaSet Configuration

Finally, we need to connect to one of the “mongod” container processes to configure the replica set.

Run the following command to connect to the first container. In the shell initiate the replica set (we can rely on the hostnames always being the same, due to having employed a StatefulSet):

$ kubectl exec -it mongod-0 -c mongod-container bash
$ mongo
> rs.initiate({_id: "MainRepSet", version: 1, members: [
       { _id: 0, host : "mongod-0.mongodb-service.default.svc.cluster.local:27017" },
       { _id: 1, host : "mongod-1.mongodb-service.default.svc.cluster.local:27017" },
       { _id: 2, host : "mongod-2.mongodb-service.default.svc.cluster.local:27017" }
 ]});

Keep checking the status of the replica set, with the following command, until the replica set is fully initialised and a primary and two secondaries are present:

> rs.status();

# output similar to:
{
	"set" : "MainRepSet",
	"date" : ISODate("2018-03-27T12:11:31.577Z"),
	"myState" : 2,
	"term" : NumberLong(1),
	"syncingTo" : "mongod-2.mongodb-service.default.svc.cluster.local:27017",
	"heartbeatIntervalMillis" : NumberLong(2000),
	"optimes" : {
		"lastCommittedOpTime" : {
			"ts" : Timestamp(1522152676, 1),
			"t" : NumberLong(1)
		},
		"appliedOpTime" : {
			"ts" : Timestamp(1522152686, 1),
			"t" : NumberLong(1)
		},
		"durableOpTime" : {
			"ts" : Timestamp(1522152686, 1),
			"t" : NumberLong(1)
		}
	},
	"members" : [
		{
			"_id" : 0,
			"name" : "mongod-0.mongodb-service.default.svc.cluster.local:27017",
			"health" : 1,
			"state" : 1,
			"stateStr" : "PRIMARY",
			"uptime" : 399,
			"optime" : {
				"ts" : Timestamp(1522152686, 1),
				"t" : NumberLong(1)
			},
			"optimeDurable" : {
				"ts" : Timestamp(1522152686, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2018-03-27T12:11:26Z"),
			"optimeDurableDate" : ISODate("2018-03-27T12:11:26Z"),
			"lastHeartbeat" : ISODate("2018-03-27T12:11:30.360Z"),
			"lastHeartbeatRecv" : ISODate("2018-03-27T12:11:30.697Z"),
			"pingMs" : NumberLong(0),
			"electionTime" : Timestamp(1522152306, 1),
			"electionDate" : ISODate("2018-03-27T12:05:06Z"),
			"configVersion" : 1
		},
		{
			"_id" : 1,
			"name" : "mongod-1.mongodb-service.default.svc.cluster.local:27017",
			"health" : 1,
			"state" : 2,
			"stateStr" : "SECONDARY",
			"uptime" : 505,
			"optime" : {
				"ts" : Timestamp(1522152686, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2018-03-27T12:11:26Z"),
			"syncingTo" : "mongod-2.mongodb-service.default.svc.cluster.local:27017",
			"configVersion" : 1,
			"self" : true
		},
		{
			"_id" : 2,
			"name" : "mongod-2.mongodb-service.default.svc.cluster.local:27017",
			"health" : 1,
			"state" : 2,
			"stateStr" : "SECONDARY",
			"uptime" : 399,
			"optime" : {
				"ts" : Timestamp(1522152686, 1),
				"t" : NumberLong(1)
			},
			"optimeDurable" : {
				"ts" : Timestamp(1522152686, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2018-03-27T12:11:26Z"),
			"optimeDurableDate" : ISODate("2018-03-27T12:11:26Z"),
			"lastHeartbeat" : ISODate("2018-03-27T12:11:30.360Z"),
			"lastHeartbeatRecv" : ISODate("2018-03-27T12:11:29.915Z"),
			"pingMs" : NumberLong(0),
			"syncingTo" : "mongod-0.mongodb-service.default.svc.cluster.local:27017",
			"configVersion" : 1
		}
	],
	"ok" : 1
}

mongodb-0 has become Primary and Others two Secondary Nodes.

Then run the following command to configure an “admin” user (performing this action results in the “localhost exception” being automatically and permanently disabled):

> db.getSiblingDB("admin").createUser({
      user : "main_admin",
      pwd  : "abc123",
      roles: [ { role: "root", db: "admin" } ]
 });

Insert Data

Insert Data into mongod-0 pod.

> db.getSiblingDB('admin').auth("main_admin", "abc123");
> use test;
> db.testcoll.insert({a:1});
> db.testcoll.insert({b:2});
> db.testcoll.find();

Verify Cluster Data

exec into Secondary Pod (here, mongo-1)

$ kubectl exec -it mongod-1 -c mongod-container bash
$ mongo
> db.getSiblingDB('admin').auth("main_admin", "abc123");
> db.getMongo().setSlaveOk()
> use test;
> db.testcoll.find();

Verify PVC

$ kubectl delete -f ./replica-sets/mongodb-rc.yaml
$ kubectl get all
$ kubectl get persistentvolumes

Recreate MongoDB

$ kubectl apply -f ./replica-sets/mongodb-rc.yaml
$ kubectl get all

Verify Data:

$ kubectl exec -it mongod-0 -c mongod-container bash
$ mongo
> db.getSiblingDB('admin').auth("main_admin", "abc123");
> use test;
> db.testcoll.find();

As PVC was not deleted, We will still have existing Data.

Verify Clusterization

Delete mongod-0 Pod and keep cheking rs.status(), eventually another node of the remaining two will become Primary Node.

Appscode/Analytics

Sat, 27 May 2017 03:00:07 +0600

Worked with docker-hub APIs to collect analytic data.
Stored analytical datas in Google sheets using GO client.
Used pixel tracking [aka, web beacon] to event each view of GitHub or other web pages in real time.

3D Racing Game

Fri, 27 Jan 2017 03:06:27 +0600

Final year thesis & project.
Developed for both PC and Android.
Tools: Unity 5 Game Engine, Android SDK, C#.

Department of Student Welfare (DSW) Management System

Mon, 27 Jun 2016 03:10:03 +0600

Data Encryption Project

Sat, 27 Feb 2016 03:11:03 +0600

Scientific Calculator

Mon, 27 Feb 2012 03:10:27 +0600