DEV Community: Pratap kute

Why I’d Never Let AI Rewrite It

Pratap kute — Wed, 20 Aug 2025 05:47:40 +0000

Background – How I Landed the Task

When I first joined Ozone, one of my first assignments was migrating node services to Supervisord. Soon after that, my CTO dropped a bigger challenge on my plate—something more open-ended: "Why don't you build us a tool to validate the configs we generate?"

Now, here’s the tricky part—each client has their own environment, which means their generated configuration files look different. Manually validating them is not very practical. What worked for one client would completely break for another. That’s when we needed custom tooling, tailored for this validation.

And before we dive in—don’t worry, this isn’t going to be a deep dive into technical jargon. My goal here is to share the approach I took to build it, the thinking process, and a few lessons (and scars 😆) I picked up along the way.

My Approach: From Scribbles to CLI

Luckily, my CTO had drafted a rough idea of how this tool should behave. It was going to be a CLI tool— simple, quick to test with and the priorities were:

It should make writing tests painless.
Proper reporting - reporting had to be meaningful
Integration with our in-house tools

The tool’s soul, so to speak, was about detecting misconfiguration via a set of rules and tests.

I began by documenting all the possible scenarios I could think of. Choosing a language was my first real roadblock. I explored Python, Go, shell scripting (yes, don't underestimate them!), and TS. Since our team was heavily invested in Typescirpt already, I settled on that.

What came next was the real grind. I struggled with defining inputs for the CLI. There were so many edge cases to think about that I almost lost track. But once I forced myself to diagram how the data should flow—what talks to what, which component owns which behavior—it finally clicked. That rough diagram became my roadmap.
I leaned on patterns like strategy and behavioral structures, making sure the tool was more future-proof than a “just make it work” hack.

About 2–3 months later, with some support (yep, I wasn’t a one-man army—though I’ll leave you to guess who had my back), I had a working tool. We cut the first release, gave stakeholders a proper demo, and even shared a neat internal doc to help folks use it effectively. That moment—watching people actually run my tool—was incredibly rewarding.

What I Gained From the Journey

1. Real Conversations With a Leadership

One of the best parts was working so closely with my CTO. He’s got this way of looking at problems very differently than most developers. While I’m neck-deep thinking about code dependencies, he’s laser-focused on the outcome: “Does this tool actually solve the problem for stakeholders?” That perspective really stuck with me—it’s not about the fanciest design; it’s about whether the product delivers value.

2. The Feedback Loop

If you’re building something internal, feedback is your compass. It’s not just about adding shiny features; it’s about asking: “Are people actually using this? Is it solving their pain points?” And once you get that feedback—don’t get defensive. Use it. That’s how the tool got better with each iteration.

3. If I Could Rewrite the Tool Today…

Okay, confession: I did use AI tools (including ChatGPT) while building parts of it. They helped speed up the small stuff. But here’s the frustrating part—AI loves adding fluff, skipping business context, and suggesting shiny solutions that don’t make sense in the real world. It’s like asking directions in Pune and ending up in another city because the guy at the corner shop sounded sure.

If you ask me, “Would you rewrite this tool with AI help?” I’d say no. Not because AI is useless—it absolutely gave me short-lived boosts—but because it robs you of the most valuable part: learning how to think through problems yourself.
The “pre-AI” era taught me patience, how to read real blog posts, and how to experiment my way toward an elegant solution. That mindset is what actually made this tool successful.

So yes, I have mixed feelings about AI. I still use it, but carefully—like a seasoning. Too much, and the whole dish tastes off.

Closing Thoughts

Looking back, that project wasn’t just about building a tool for me. It was about learning how to think at a product level, communicate with leaders, take criticism without sulking, and most importantly—trust my own problem-solving instincts. The fact that the tool actually lives on and helps real people? That’s the cherry on top.

The shell script

Pratap kute — Sun, 13 Oct 2024 08:17:43 +0000

Index

Journey of Shell Script (History) - Short
My Journey with Shell Scripting
My New Gig Experience
My Take on Shell Scripting

1. Shell Script History

Shell scripting was born alongside Unix in the early 1970s, like peanut butter and jelly—meant to be together. The Thompson shell arrived in 1971, letting users chain commands like a pro. But it was the Bourne shell (sh) in 1977 that gave shell scripting its real mojo by adding scripting features and control structures. That shell was so popular that it led to the creation of Bash (Bourne Again Shell) in 1989, which was like sh, but on steroids. Since then, shells like zsh and fish have come along, each with their own quirks and features, but all paying homage to the OG shells. Today, shell scripting is still a favorite for system administration, automation, and scaring off people who don't like command lines.

Reference: IBM Developer

2. My Journey with Shell Scripting

Let’s be honest: when I was first introduced to Linux, I was a total nerd about it. When I started my degree, I got sucked into the terminal world. My first experience? Bash. I thought I had mastered it—boy, was I wrong. I used to flex my “skills” (okay, they were super amateur) in front of my classmates. I was so busy making the terminal look pretty and playing with different command-line tools that I completely missed the point. Eventually, I got overwhelmed by all the options and tapped out.

Fast forward to my first professional gig at a startup, where we were using Ubuntu 18. I felt like my old knowledge gave me an edge over my colleagues, but I quickly realized I was still a noob. Thankfully, my CTO Nitin Bhide and coworkers were incredibly supportive, helping me polish my shell skills. I started small—with basics like ls, pwd, and cat. Oh, and don't get me started on text editors. I tried vim first, but it gave me a headache, so I happily settled for Nano. From there, the ride was smooth.

The point of this little flashback? Your professional experience shapes your understanding, and having good mentors along the way makes all the difference.

Use cases for shell scripts (as I see them):

Automating repetitive small tasks
Creating custom commands
Analyzing system logs and generating reports
Backing up config files and data
Writing small build scripts

Of course, there’s more, but I mostly use shell scripts for repetitive tasks and CI/CD pipeline tweaks. I haven't written any massive scripts, but you get the idea.

3. My New Gig Experience

In my current gig, shell scripts are everywhere. Small tools? Check. Big tools? Also check. Imagine my surprise—because I had no clue big tools could be built around shell scripts! Not only do we have scripts that deploy entire solutions on AWS, but we also have a full build pipeline designed in shell. We even have internal tools written in shell scripts. These aren’t just thrown together either; they’re meticulously crafted. I’ve seen syntax in shell scripting that I didn’t even know existed, like:

Associative Arrays

# Declare an associative array
declare -A FAMOUS_CITIES

# Add elements to the associative array
FAMOUS_CITIES[Mumbai]="Gateway of India"
FAMOUS_CITIES[Delhi]="India Gate"
FAMOUS_CITIES[Bangalore]="Lalbagh Botanical Garden"

# Print the value of a specific key
echo ${FAMOUS_CITIES[Mumbai]} # Outputs: Gateway of India

Functions and Recursion (Yes, really)

To solve problems where loops might be insufficient.

factorial() {
  if [ $1 -le 1 ]; then
    echo 1
  else
    prev=$(factorial $(($1 - 1)))
    echo $(($1 * $prev))
  fi
}
echo "Factorial of 5 is $(factorial 5)"

Custom Logging Mechanisms

log() {
  echo "$(date): $@" >> script.log
}
log "Script started"

We even built our own config parser and template generator in shell script. I quickly realized I had a lot to learn in this space! Here’s what I’ve picked up so far, thanks to my CTO:

Shell scripts are still super powerful and relevant, even for large tools.
It’s ridiculously easy to integrate shell scripts with other tools.
You can design a decent CLI tool with shell scripting.

Now, don’t ask me how we designed these scripts—it was all my CTO, who’s an absolute legend in leading open banking solutions. If you want to know more, check out his profile: Freddi Gyara

4. My Take on Shell Scripting

I’ve learned a lot from these tools, but here’s the thing: shell scripting is amazing for small to medium-sized scripts (up to 1,500 lines, in my opinion). But if you try to push beyond that, the tool starts to crack. Why? Let me break it down:

Complexity: The bigger the tool, the harder it becomes to add new features without breaking something.
Tooling: Shell scripting doesn’t have the fancy tooling modern programming languages provide.
Dependencies: You’ll likely end up reinventing the wheel for things like logging since there’s no easy way to manage dependencies.
Debugging and Error Handling: Debugging shell scripts? It’s like pulling teeth. There’s no fancy breakpoint system, just the good old set keyword.

set -e  # Exit on error
set -x  # Print commands as they are executed

So, here’s my final thought: use shell scripting for small utilities, but for anything bigger (or if your team grows beyond five or six people), switch to Python or in more language. It’ll save you a lot of headaches!

Concourse a CI/CD tool

Pratap kute — Mon, 01 Apr 2024 16:12:15 +0000

Introduction

CI/CD: It's the Rockstar of software development – everyone's talking about it! It's more than just a process, it's a whole way of life (well, maybe not that dramatic), but it definitely brings devs and ops together to ship awesomer software, faster and stronger . That's where Concourse comes in to be your CI/CD hero. Let's unpack this nifty tool and see how it makes your DevOps life a breeze.

why I choose concourse?

Before I dive into Concourse, let me tell you why I chose it in the first place. We were using Buildbot previously, which is a great tool by the way (Python.org even uses it!). However, I found Buildbot lacking in two crucial areas: documentation and configuration as code

Documentation: If you head over to the Buildbot docs, you'll find the API documentation isn't as descriptive as the Python docs themselves (maybe I'm wrong… 😅 ). This led to some less-than-ideal CI/CD workflow implementations by our old team.

Configuration as YAML: Why YAML? It lets you focus on building the workflow itself, not writing tons of code. Buildbot gives you more control over how you build your CI/CD workflow, but it makes you focus more on the code itself rather than the tasks at hand. So, for configuration as code (like Ansible), I believe it's best.

So, when I was tasked with building another workflow on Buildbot (being very new to CI/CD at the time), it was a disaster for me (don't worry, I was decent at Python!… 😜). I wrote the pipeline, but it took me a month and a half to wrap my head around the whole codebase. It was a pain to write and maintain new workflows

We needed a simple solution for our CI/CD pipeline. We were already using Docker to ship our code, so our workflow mostly involved building images and compiling source code

I explored several open-source, self-hosted tools. Concourse stood out because of its ease of deployment and maintenance thanks to YAML. Now, I know Concourse might seem like overkill, but hey, if a future team wants to use Kubernetes or other fancy stuff, Concourse can handle it all!.. 😏

Key Features of Concourse

Concourse is known for its expressive, versatile, safe and stateless architecture. It is designed around a few core principles: every task run in isolation, configuration as code, and having a declarative style. This means you describe your pipeline, and Concourse will figure out what needs to happen to get there. This approach greatly simplifies pipeline management and reduces the risk of errors.

Configuration as code

resources:
- name: booklit
  type: git
  source: {uri: "https://github.com/concourse/booklit"}

jobs:
- name: unit
  plan:
  - get: booklit
    trigger: true
  - task: test
    file: booklit/ci/test.yml

Visualize you pipeline

why we switch to concourse?

First up, Concourse is BFFs (Best Friends Forever 😝) with test-driven development (TDD) – they practically speak the same language (well, robot framework at least ) Second, its fancy visualization makes your pipelines crystal clear at a glance, troubleshooting becomes a walk in the park. Third, it's all about containers, meaning consistent builds and environments throughout the software lifecycle – a big win since we're basically living in Dockerland anyway. Plus, bootstrapping with Concourse pipeline is a breeze compared to Buildbot – like night and day!

Cons… 😮‍💨

Concourse ain't perfect, though . It can be a bit sluggish sometimes, especially with Docker builds because of those annoying volume creation drivers (there's a whole GitHub issue on that if you're curious ). There's also a bit of a learning curve, which can be a hurdle for new devs to jump over.

All things considered, our pipelines take about 40% longer to run in Concourse compared to Buildbot – not ideal for speed demons.

But hey, at least our code is way more streamlined now, right? 🤐 Plus, Concourse lets us dedicate workers for specific tasks like GPU build and CUP build, versioning and complex workflows – those little things add up! We're constantly learning and getting better at wrangling this beast of a tool, day by day.

Conclusion

Concourse: It's like the Swiss Army Knife of DevOps tools 🇨🇭. Packed with features and benefits, it fits right in with the whole DevOps thing . Need to pimp your CI/CD pipeline, boost transparency, and support TDD? Concourse could be your BFF . But remember, just like any fancy tool, It's all about using it right to achieve Moksha of DevOps !!

HTML meta tags

Pratap kute — Fri, 09 Feb 2024 07:58:28 +0000

An Introduction to HTML5 Meta Tags

HTML5 Meta tags are an essential part of any web page's structure. They provide information about the web page to search engines, browsers, and social media platforms. This information includes the title, description, keywords, author, and other metadata that help users find your website and understand its content.

Understanding Meta Tags: The Labels of Webpages

When I first started coding, I became familiar with webpages (HTML). I believe many developers had a similar experience, especially those who began after 2009. I often used it to save web pages, but I always wondered: what are meta tags?

Meta tags are like labels that tell web browsers and search engines important information about a webpage. They help browsers understand how to display the page and tell search engines what the page is about. It's like putting a name tag on your school bag so everyone knows whose it is and what's inside.

There are numerous things meta tags can accomplish for you. For instance, you can utilize them to perform tasks such as refreshing the page and setting the character encoding, without needing to write JavaScript.

<meta http-equiv="refresh" content="2500">

Isn't that convenient?”

What are HTML5 Meta Tags?

HTML5 Meta tags are special bits of code you add to the head section of your webpage's code. They give extra info about your webpage, but people don't see them directly on the page. Instead, search engines and other tools use them to understand your webpage better.

Here are some common types of meta tags:

Title: This tag sets the title of your webpage. It shows up in the browser's title bar and search engine results.
Description: This tag gives a summary of what your webpage is about. It also shows up in search results.
Keywords: This tag lists important words or phrases related to your webpage's content.
Author: This tag says who made the webpage.
Viewport: This tag controls how your webpage looks on mobile devices.
Robots: This tag tells search engines if they should index your webpage or follow its links.

Why do web developers need to care about Meta Tags?

Meta tags are important bits of code you put in your website's HTML. They help search engines like Google understand what your page is about so they can rank it properly in search results.

Think of it like this: when you meet someone new, you introduce yourself and give them some basic information about who you are, right? Meta tags do the same thing for your website. They tell search engines what your page is all about, so they can show it to people who are searching for that kind of information.

Social media sites like Facebook and Twitter also use these meta tags to show a preview of your webpage when someone shares it. So if you don't have these tags, the social media platform might just guess what your page is about, and it might not look as good when someone shares it.

How to Use HTML5 Meta Tags?

To use HTML5 Meta tags, you need to insert them into the head section of your web page. Here is an example of how to insert the title, description, and keywords meta tags:

<head>
  <title>My Web Page Title</title>
  <meta name="description" content="This is a brief description of my web page content.">
  <meta name="keywords" content="web page, HTML5, meta tags">
</head>

There are many use cases for meta tags. For more details, you can visit the MDN page

Conclusion

HTML5 Meta tags are an essential part of any web page's structure. They provide additional information about the web page that is used by search engines, browsers, and social media platforms. By using meta tags correctly, you can improve your web page's search engine rankings and increase its visibility on social media platforms.

References

Mozilla Developer Network (MDN)

W3Schools

What is HTML

Pratap kute — Mon, 09 Jan 2023 08:39:17 +0000

HTML (HyperText Markup Language) is a markup language used to structure and present content on the World Wide Web. It consists of a series of elements, or tags, that define the structure and content of a web page.

HTML is an accepted standard for structuring and displaying information on the World Wide Web. The fifth version, HTML 5, was issued in October 2014 by the World Wide Web Consortium (W3C).

How HTML page works

In order to make an HTML page, you can make use of a text editor to write the HTML code, save it with a .html suffix, and then open it in a web browser. The browser will interpret the HTML code and display the page based on the tags and attributes indicated.

HTML tags are utilized to define the structure and contents of a website. They are written within angled brackets, frequently in pairs, comprising of an opening and closing tag. For example, <p> stands for a paragraph, while <h1> denotes a heading.

<h1>My Heading</h1>

Attributes offer additional details about an HTML element. They are situated within the opening tag, and contain a name and a value. For example, the href attribute is used to define a link in an <a> tag.

<a href="https://www.Youtube.com/"></a>

You can also use CSS (Cascading Style Sheets) to style and layout your HTML page. CSS is a separate language that is used to define the appearance and layout of an HTML document. It can be used to change the font, color, size, and other style properties of HTML elements, as well as to control the layout of a page.

In summary, HTML works by using tags and attributes to define the structure and content of a web page, and CSS is used to style and layout the page. Together, these technologies enable you to create rich and interactive web experiences.

What’s new in HTML 5

HTML5 has brought about a great many feature when compared to its preceding versions. One of the most noteworthy changes is its incorporation of web standards, which has improved the compatibility of web pages across browsers and devices.

Some of the notable features of HTML5 include:

Improved support for audio and video: HTML5 introduced new elements for embedding audio and video content, such as the <audio> and <video> tags. This allows web developers to easily add multimedia content to their pages without the need for third-party plugins like Flash.
Enhanced graphics capabilities: HTML5 introduces the <canvas> element, which allows developers to create and manipulate graphics using JavaScript. This enables the creation of interactive graphics, games, and other visual content.
Improved support for web forms: HTML5 introduces new form elements and attributes that make it easier for developers to create and style web forms. This includes new input types such as email, URL, and tel, as well as new attributes for input validation and autofocus.
Enhanced semantic elements: HTML5 introduces new semantic elements that better reflect the content they contain. For example, the <header> element is used to represent the header of a document or section, while the <footer> element represents the footer. This helps search engines better understand the content of a page and improve its ranking in search results.

HTML5 has been widely adopted by web developers and is supported by all modern web browsers. It has also played a significant role in the development of web-based applications and mobile applications, as it provides a powerful platform for creating rich and interactive experiences on the web.

Multiple services in a Docker container with supervisord

Pratap kute — Sat, 10 Dec 2022 12:51:45 +0000

Docker is mostly used for packing the application, the goal is generally that anyone could execute

docker run <containername>

so how does docker know what to execute? It uses ENTRYPOINT or CMD to start services, Both parameters are used to specify the programs/commands to execute while initializing a container from the docker image.

The container's primary process is responsible for managing all operations that it starts which we define at ENTRYPOINT or CMD at the end of the Dockerfile. Docker always recommends that your areas of concern be by using one service per container.

Supervisor A process control system

A supervisor is a client/server system that allows its users to monitor and control many processes on UNIX-like operating systems.

It is meant to be used to control processes related to a project or a customer and to start like any other program at boot time.

I have detail explained about supervisord in this article.

Multiple services in a container

Dockerfile CMD

CMD ["supervisord", "-c", "/path/to_your_file/supervisor.conf", "-n"]

Supervisor conf file sample

[unix_http_server]
file=/tmp/supervisor.sock
chmod=0755               

[supervisord]
logfile=/tmp/supervisord.log
logfile_maxbytes=50MB        
logfile_backups=10           
loglevel=info               
pidfile=/tmp/supervisord.pid 
nodaemon=false               
minfds=1024                  
minprocs=200
;environment variables
environment=ENV="PROD",
            PATH="/path/../...",

[inet_http_server]         ; inet (TCP) server disabled by default
port=127.0.0.1:9001        ; (ip_address:port specifier, *:port for all iface)

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock 

[program:redis-server]
command=redis-server
process_name=%(program_name)s
numprocs=1
directory=/home/path/to/location/
autostart=true
autorestart=true
startsecs=10
stopsignal=TERM
stopwaitsecs=5 ; max num secs to wait b4 SIGKILL (default 10)
user=root
priority=1
stopasgroup=true 
killasgroup=true

[program:logger]
command=/home/path/to/excutable/logger
process_name=%(program_name)s
numprocs=1
directory=/home/path/to/location/
autostart=true
autorestart=true
startsecs=10
stopsignal=TERM
stopwaitsecs=5
user=root
priority=30
stopasgroup=true 
killasgroup=true

In the above config file, we have two services one is Redis-server and logger services running as root. Each service has priority to start services. for each config param refer to the supervised documentation

In the command section, You can also use a shell script to run your services but be aware of the zombie process created when you kill or restart the services.

Docker How & Why to Use?

Pratap kute — Fri, 26 Aug 2022 11:04:00 +0000

How to use docker

In my last article, I wrote about how Docker Hello world works. In that, I have explained about container and docker ecosystem

Docker packs, ships, and runs the application as a lightweight containerization tool and builds an agile software delivery pipeline to ship new features faster. so let’s start using docker.

I recommend you start with the docker command line (CLI) tool first, then go for the docker desktop. Now let's say you want your Dockerfile image first, take a simple example

1. Create a Dockerfile with no extension

FROM alpine
CMD ["echo", "Love from India"]

In the first line, we are using a base image (A base image is an image that is used to create all of your container images ) You can use multiple flavors of images, such as Ubuntu, Debian, etc., but alpine images are small in size.

Dockerfile has FROM, COPY, RUN, CMD, etc instructions which tell docker demon how to build an image. Each instruction is a layer in the container. CMD is a special instruction that tells specifies what command to run within the container. Best practices for writing Dockerfile

2. Let’s build the image

docker build -t love:latest .

Docker build is a command that builds Docker images from a Dockerfile and a “context”. In the above command, we used the -t option as a tag in the 'name: tag' format, and . is a reference to context (The transfer of context from the local machine to the Docker daemon) and we have given the name love:latest to our image.

As you see in step 1/2 the image alpine:latest image got pulled from the docker hub and in the second step 2/2 we have given instructions to echo a string which is love from India.

3. Running docker container

docker container run love

when you run the above command you will see the output to the terminal

If you want just practice these commands without installing docker on your machine, head to https://labs.play-with-docker.com/ on this platform, you need a docker id and play with docker.

Why is Docker useful?

Docker allows you to exactly replicate your development environment which gives you leverage to distribute it QA team or in a production environment. It alleviates the problem of “it’s broken on my machine!”.

If you want to add another server (Ex: Database) to your existing infrastructure you don't have to worry about configuring that server and reinstalling the dependency, just pull that particular image from the Docker hub.

Docker is an easy tool to use when you get started using its daily development and OPS practices. with docker, you can run multiple separate containers with, a separate version of Python or any other language, app versions

Docker makes running multiple servers very easy, especially with orchestration engines like Kubernetes and Docker Swarm

When not to use Docker?

By default docker container run as root so every service in the container runs as root, it’s not the best implementation for the production environment.

The size of your docker container application grows exponentially when new updates come in.

Building, testing, managing, and distributing Large and complicated applications require a dedicated sysadmin or DevOps engineer team.

Docker Hello world

Pratap kute — Tue, 16 Aug 2022 12:01:03 +0000

Docker

Docker is an open-source containerisation platform. It enables developers to package applications into containers standardized executable components combining application
source code with the operating system (OS) libraries and dependencies required to run that code in any environment

containerisation: It’s Linux kernel virtualization where you run applications in isolated user spaces called containers that use the same shared operating system.

Docker ecosystem

Docker client
Docker server
Docker Machine
Docker image
Docker hub
Docker compose
Docker swarm

Note: To install docker on your machine follow these instructions.

Hello world

Now let's do hello world so when you type the following command in that hello-world refers to image (docker image)

docker run hello-world

Docker CLI takes that command and passes it to the docker server.

If that image is not on your computer (Image cache), it reaches out to the docker hub. docker pulls that image and creates a container out of it.

Pay attention to what steps docker took to print the hello world.

Docker has revolutionized how we build, test and deploy the software, In the next article I will explain how to build your own Docker images and deploy them.

Django cookiecutter

Pratap kute — Mon, 08 Aug 2022 09:22:00 +0000

Do you know, how to set up your production-ready Django project with all twelve-factor app standards within minutes? if your answer is no then use Django-Cookiecutter

A command-line utility that creates projects from cookiecutters
(project templates), e.g. creating a Python package project from a Python package project template.

There are all types of cookie-cutters just search it on GitHub. Your life will be easier

Cookiecutter Django is a project template for jump-starting production-ready Django projects. The template offers several generation options

Note:- It’s only for a senior developer 😏

Which is the best CI/CD self-hosted open source tool?

Pratap kute — Wed, 27 Jul 2022 10:00:00 +0000

I have used python based CI tool buildbot which is a great tool but we want to move away from buildbot only because in some scenarios we want to compile low-level micro-service which are in c++ to a different architecture. Buildbot doesn't have such a feature.

So can you suggest one? Till now I looked at the concourse.

What is supervisord?

Pratap kute — Thu, 21 Jul 2022 08:33:00 +0000

A process control system
what is supervisord
why use supervisord
sample file

A Process Control System

the process control system monitors and controls several processes on your system

it handles the start/monitor/stop/restart of your services. if you are from Linx/UNIX world you will know that init as “process id 1”

The init process is the last step in the boot procedure and is identified by process id "1". Init is responsible for starting system processes

Init typically will start multiple instances of "Getty" which waits for console logins which spawn one's user shell process. Upon shutdown, init controls the sequence and processes for the shutdown.
The init process is never shut down. It is a user process and not a kernel system process although it does run as root.

what is supervisord?

It’s a process control tool which is written in pure python

Supervisord is a client/server system that allows its users to monitor and control several processes on UNIX-like operating systems.

It shares some of the same goals as programs like launchd,daemontools, and runit. Unlike some of these programs, it is not meant to be run as a substitute for init as “process id 1”. Instead it is meant to be used to control processes related to a project or a customer, and is meant to start like any other program at boot time.

Supervisor can be installed with pip install:

pip install supervisor

details instruction to install supervisord

supervisord uses configuration files so it’s easy to understand what each process is doing

supervisord.conf is a Windows-INI-style (Python ConfigParser) file. It has sections (each denoted by a [header]) and key/value pairs within the sections.

why use supervisord?

consider the scenario where you have written a hello world program and you want to start that particular program after booting up your OS in this kind of scenario where you can use supervisord.

We use supervisord in docker to run multiple services (program). In the next blog, I will explain how to use supervisord in docker to control.

Sample file

; Sample supervisor config file.
;
; For more information on the config file, please see:
; http://supervisord.org/configuration.html
;
; Notes:
;  - Shell expansion ("~" or "$HOME") is not supported.  Environment
;    variables can be expanded using this syntax: "%(ENV_HOME)s".
;  - Quotes around values are not supported, except in the case of
;    the environment= options as shown below.
;  - Comments must have a leading space: "a=b ;comment" not "a=b;comment".
;  - Command will be truncated if it looks like a config file comment, e.g.
;    "command=bash -c 'foo ; bar'" will truncate to "command=bash -c 'foo ".
;
; Warning:
;  Paths throughout this example file use /tmp because it is available on most
;  systems.  You will likely need to change these to locations more appropriate
;  for your system.  Some systems periodically delete older files in /tmp.
;  Notably, if the socket file defined in the [unix_http_server] section below
;  is deleted, supervisorctl will be unable to connect to supervisord.

[unix_http_server]
file=/tmp/supervisor.sock   ; the path to the socket file
;chmod=0700                 ; socket file mode (default 0700)
;chown=nobody:nogroup       ; socket file uid:gid owner
;username=user              ; default is no username (open server)
;password=123               ; default is no password (open server)

; Security Warning:
;  The inet HTTP server is not enabled by default.  The inet HTTP server is
;  enabled by uncommenting the [inet_http_server] section below.  The inet
;  HTTP server is intended for use within a trusted environment only.  It
;  should only be bound to localhost or only accessible from within an
;  isolated, trusted network.  The inet HTTP server does not support any
;  form of encryption.  The inet HTTP server does not use authentication
;  by default (see the username= and password= options to add authentication).
;  Never expose the inet HTTP server to the public internet.

;[inet_http_server]         ; inet (TCP) server disabled by default
;port=127.0.0.1:9001        ; ip_address:port specifier, *:port for all iface
;username=user              ; default is no username (open server)
;password=123               ; default is no password (open server)

[supervisord]
logfile=/tmp/supervisord.log ; main log file; default $CWD/supervisord.log
logfile_maxbytes=50MB        ; max main logfile bytes b4 rotation; default 50MB
logfile_backups=10           ; # of main logfile backups; 0 means none, default 10
loglevel=info                ; log level; default info; others: debug,warn,trace
pidfile=/tmp/supervisord.pid ; supervisord pidfile; default supervisord.pid
nodaemon=false               ; start in foreground if true; default false
silent=false                 ; no logs to stdout if true; default false
minfds=1024                  ; min. avail startup file descriptors; default 1024
minprocs=200                 ; min. avail process descriptors;default 200
;umask=022                   ; process file creation umask; default 022
;user=supervisord            ; setuid to this UNIX account at startup; recommended if root
;identifier=supervisor       ; supervisord identifier, default is 'supervisor'
;directory=/tmp              ; default is not to cd during start
;nocleanup=true              ; don't clean up tempfiles at start; default false
;childlogdir=/tmp            ; 'AUTO' child log dir, default $TEMP
;environment=KEY="value"     ; key value pairs to add to environment
;strip_ansi=false            ; strip ansi escape codes in logs; def. false

; The rpcinterface:supervisor section must remain in the config file for
; RPC (supervisorctl/web interface) to work.  Additional interfaces may be
; added by defining them in separate [rpcinterface:x] sections.

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

; The supervisorctl section configures how supervisorctl will connect to
; supervisord.  configure it match the settings in either the unix_http_server
; or inet_http_server section.

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock ; use a unix:// URL  for a unix socket
;serverurl=http://127.0.0.1:9001 ; use an http:// url to specify an inet socket
;username=chris              ; should be same as in [*_http_server] if set
;password=123                ; should be same as in [*_http_server] if set
;prompt=mysupervisor         ; cmd line prompt (default "supervisor")
;history_file=~/.sc_history  ; use readline history if available

; The sample program section below shows all possible program subsection values.
; Create one or more 'real' program: sections to be able to control them under
; supervisor.

;[program:theprogramname]
;command=/bin/cat              ; the program (relative uses PATH, can take args)
;process_name=%(program_name)s ; process_name expr (default %(program_name)s)
;numprocs=1                    ; number of processes copies to start (def 1)
;directory=/tmp                ; directory to cwd to before exec (def no cwd)
;umask=022                     ; umask for process (default None)
;priority=999                  ; the relative start priority (default 999)
;autostart=true                ; start at supervisord start (default: true)
;startsecs=1                   ; # of secs prog must stay up to be running (def. 1)
;startretries=3                ; max # of serial start failures when starting (default 3)
;autorestart=unexpected        ; when to restart if exited after running (def: unexpected)
;exitcodes=0                   ; 'expected' exit codes used with autorestart (default 0)
;stopsignal=QUIT               ; signal used to kill process (default TERM)
;stopwaitsecs=10               ; max num secs to wait b4 SIGKILL (default 10)
;stopasgroup=false             ; send stop signal to the UNIX process group (default false)
;killasgroup=false             ; SIGKILL the UNIX process group (def false)
;user=chrism                   ; setuid to this UNIX account to run the program
;redirect_stderr=true          ; redirect proc stderr to stdout (default false)
;stdout_logfile=/a/path        ; stdout log path, NONE for none; default AUTO
;stdout_logfile_maxbytes=1MB   ; max # logfile bytes b4 rotation (default 50MB)
;stdout_logfile_backups=10     ; # of stdout logfile backups (0 means none, default 10)
;stdout_capture_maxbytes=1MB   ; number of bytes in 'capturemode' (default 0)
;stdout_events_enabled=false   ; emit events on stdout writes (default false)
;stdout_syslog=false           ; send stdout to syslog with process name (default false)
;stderr_logfile=/a/path        ; stderr log path, NONE for none; default AUTO
;stderr_logfile_maxbytes=1MB   ; max # logfile bytes b4 rotation (default 50MB)
;stderr_logfile_backups=10     ; # of stderr logfile backups (0 means none, default 10)
;stderr_capture_maxbytes=1MB   ; number of bytes in 'capturemode' (default 0)
;stderr_events_enabled=false   ; emit events on stderr writes (default false)
;stderr_syslog=false           ; send stderr to syslog with process name (default false)
;environment=A="1",B="2"       ; process environment additions (def no adds)
;serverurl=AUTO                ; override serverurl computation (childutils)

; The sample eventlistener section below shows all possible eventlistener
; subsection values.  Create one or more 'real' eventlistener: sections to be
; able to handle event notifications sent by supervisord.

;[eventlistener:theeventlistenername]
;command=/bin/eventlistener    ; the program (relative uses PATH, can take args)
;process_name=%(program_name)s ; process_name expr (default %(program_name)s)
;numprocs=1                    ; number of processes copies to start (def 1)
;events=EVENT                  ; event notif. types to subscribe to (req'd)
;buffer_size=10                ; event buffer queue size (default 10)
;directory=/tmp                ; directory to cwd to before exec (def no cwd)
;umask=022                     ; umask for process (default None)
;priority=-1                   ; the relative start priority (default -1)
;autostart=true                ; start at supervisord start (default: true)
;startsecs=1                   ; # of secs prog must stay up to be running (def. 1)
;startretries=3                ; max # of serial start failures when starting (default 3)
;autorestart=unexpected        ; autorestart if exited after running (def: unexpected)
;exitcodes=0                   ; 'expected' exit codes used with autorestart (default 0)
;stopsignal=QUIT               ; signal used to kill process (default TERM)
;stopwaitsecs=10               ; max num secs to wait b4 SIGKILL (default 10)
;stopasgroup=false             ; send stop signal to the UNIX process group (default false)
;killasgroup=false             ; SIGKILL the UNIX process group (def false)
;user=chrism                   ; setuid to this UNIX account to run the program
;redirect_stderr=false         ; redirect_stderr=true is not allowed for eventlisteners
;stdout_logfile=/a/path        ; stdout log path, NONE for none; default AUTO
;stdout_logfile_maxbytes=1MB   ; max # logfile bytes b4 rotation (default 50MB)
;stdout_logfile_backups=10     ; # of stdout logfile backups (0 means none, default 10)
;stdout_events_enabled=false   ; emit events on stdout writes (default false)
;stdout_syslog=false           ; send stdout to syslog with process name (default false)
;stderr_logfile=/a/path        ; stderr log path, NONE for none; default AUTO
;stderr_logfile_maxbytes=1MB   ; max # logfile bytes b4 rotation (default 50MB)
;stderr_logfile_backups=10     ; # of stderr logfile backups (0 means none, default 10)
;stderr_events_enabled=false   ; emit events on stderr writes (default false)
;stderr_syslog=false           ; send stderr to syslog with process name (default false)
;environment=A="1",B="2"       ; process environment additions
;serverurl=AUTO                ; override serverurl computation (childutils)

; The sample group section below shows all possible group values.  Create one
; or more 'real' group: sections to create "heterogeneous" process groups.

;[group:thegroupname]
;programs=progname1,progname2  ; each refers to 'x' in [program:x] definitions
;priority=999                  ; the relative start priority (default 999)

; The [include] section can just contain the "files" setting.  This
; setting can list multiple files (separated by whitespace or
; newlines).  It can also contain wildcards.  The filenames are
; interpreted as relative to this file.  Included files *cannot*
; include files themselves.

;[include]
;files = relative/directory/*.ini