Sam Robbins' Website on Lekshmi Kolappan

StackQuest - DevOps Knowledge Platform

Sat, 25 Oct 2025 23:00:00 +0000

What is the significance of this?

Interactive Learning Platform: A quest-based knowledge platform for mastering DevOps, SRE, and Cloud engineering concepts
Curated Content: High-quality questions and challenges across 12+ categories covering essential DevOps skills
Session Tracking: Intelligent system prevents question repetition for focused learning
Zero Infrastructure: Static site deployed on GitHub Pages with automatic CI/CD
Open Source Community: Contributions welcome to expand the knowledge base
Mobile Responsive: Works seamlessly on desktop and mobile devices

How is automation accomplished?

GitHub Actions CI/CD: Automated deployment to GitHub Pages on every push to main branch
Static Site Architecture: No server-side dependencies, fast loading times
JavaScript-powered: Client-side question randomization and session management
Markdown-based Content: Easy content management through markdown files
Category-based Organization: Structured content across multiple technology domains
Session Persistence: Browser localStorage for tracking answered questions

Prerequisites

Web browser (Chrome, Firefox, Safari, or Edge)
No installation or setup required - works directly in browser

Source Code

https://github.com/Lforlinux/StackQuest

How to contribute?

Getting Started

Fork the repository to your GitHub account
Clone your fork locally: git clone https://github.com/yourusername/StackQuest.git
Create a feature branch: git checkout -b feature/your-feature
Make your changes (add questions, fix bugs, improve UI, etc.)
Test locally by opening index.html in your browser
Commit and push your changes: git push origin feature/your-feature
Create a Pull Request on the original repository
GitHub Actions will automatically deploy your changes once merged

Deployment

The project uses GitHub Actions for automatic deployment to GitHub Pages:

Self-Hosted Finance

Sat, 27 Sep 2025 08:53:27 +0530

Self-Hosted Finance: Taking Control of Your Money with Actual Budget

Building your own personal finance stack, one Docker container at a time

💰 My Budgeting Journey: From Diary to Self-Hosted Finance

My personal finance journey started simple — with a pen and paper diary tracking every expense. As my financial life became more complex, I graduated to Google Sheets for better calculations and visualization. But when I discovered the power of dedicated budgeting software, I faced the same question that plagues every homelab enthusiast:

Self-Hosted Sound: Building My Personal High-Fidelity Music Streaming Setup

Wed, 02 Jul 2025 00:00:00 +0000

🎵 Self-Hosted Sound: Building My Personal High-Fidelity Music Streaming Setup

In a world where everything is now a subscription — from task managers to weather apps — streaming music has become another monthly bill we all accept without thinking. But as someone who has always leaned into open-source and self-hosted solutions, I began to ask myself a simple question:

Why pay every month for compressed audio when I could host my own music server — in full lossless quality — and actually own my collection?

HaaS: Homelab as a Service

Tue, 01 Jul 2025 00:00:00 +0000

In today’s world of SaaS everything — where every tool comes with a monthly subscription 💸 — I often find myself asking: “Why pay for all of this when powerful, open-source alternatives exist? 🐧” Having worked with open-source software from the very beginning of my career, I’ve always believed that owning your data and infrastructure is the way forward. 🗝️

For a long time, I dreamt of building my own NAS (Network Attached Storage) 🗄️. Like many hobbyists, I started with the world’s tiniest computer — the Raspberry Pi 🥧. I paired it with open-source NAS operating systems like TrueNAS and OpenMediaVault, experimenting for a few years. But while these setups were fun and educational, they fell short when it came to performance and reliability. ⚡️❌

Kubernetes GitOps Platform - Complete EKS Infrastructure & Platform Toolkit

Wed, 15 Jan 2025 23:00:00 +0000

What is the significance of this?

Complete Infrastructure as Code: Provision entire AWS EKS cluster and all platform services with a single command
GitOps Automation: ArgoCD automatically deploys and manages all platform applications from Git repositories
Production-Ready Platform: Comprehensive observability stack with monitoring, logging, and testing tools
High Availability: Multi-AZ deployment with auto-scaling worker nodes and Horizontal Pod Autoscaler (HPA)
Zero-Downtime Deployments: Kubernetes rolling updates ensure continuous service availability
Complete Observability: Prometheus, Grafana, Loki, and Promtail for metrics, logs, and dashboards
SRE-Ready: Availability testing and sanity checks built-in

How is automation accomplished?

Terraform Infrastructure: Complete AWS infrastructure provisioning (VPC, EKS, IAM, Security Groups) as code
Docker Containerization: Terraform runs in Docker for consistent execution across team members
Helm Charts: Application deployment automation with Helm templates and values management
ArgoCD GitOps: App-of-apps pattern automatically deploys entire platform toolkit from Git
Makefile Automation: One-command deployment (make deploy) for entire infrastructure stack
Auto-Scaling: HPA for pod scaling and AWS Auto Scaling Groups for worker node scaling
Automated Sync: ArgoCD continuously syncs Git changes to cluster with self-healing capabilities

Prerequisites

AWS Account: Programmatic access with IAM user
IAM Policies: AmazonEC2FullAccess, IAMFullAccess, AutoScalingFullAccess, AmazonEKSClusterPolicy, AmazonEKSWorkerNodePolicy, AmazonVPCFullAccess, AmazonEKSServicePolicy, AmazonEKS_CNI_Policy
Docker: Installed and running for Terraform containerization
AWS CLI: Configured with credentials (~/.aws/credentials or AWS_PROFILE)
Git: For cloning repositories

Source Code

Infrastructure Repository: https://github.com/Lforlinux/k8s-infrastructure-as-code
Platform Toolkit Repository: https://github.com/Lforlinux/k8s-platform-toolkit

How to provision the infrastructure

Quick Start Deployment

# Clone the infrastructure repository
git clone https://github.com/Lforlinux/k8s-infrastructure-as-code.git
cd k8s-infrastructure-as-code

# Configure AWS credentials
aws configure
# OR set AWS_PROFILE environment variable
export AWS_PROFILE=your-profile

# Deploy entire stack with one command
make deploy

Review the Terraform plan and type yes to proceed. The deployment includes:

Cloud CV - Serverless Resume with AWS Infrastructure as Code

Fri, 03 Jan 2025 23:00:00 +0000

What is the significance of this?

Serverless Architecture: A fully serverless resume website showcasing modern cloud-native development practices
Infrastructure as Code: Complete AWS infrastructure managed through Terraform with automated deployments
CI/CD Pipeline: GitHub Actions automation for one-click deployments with visitor counter functionality
Local Development: LocalStack integration for local AWS development without cloud costs
Professional Portfolio: Demonstrates SRE/DevOps expertise through the project itself

How is automation accomplished?

Terraform Infrastructure: Complete AWS infrastructure provisioned as code including S3, CloudFront, Lambda, DynamoDB, and API Gateway
GitHub Actions CI/CD: Automated deployment pipeline that builds, tests, and deploys on every commit
Serverless Backend: Python Lambda function with DynamoDB for visitor counter with CORS support
Static Website Hosting: S3 + CloudFront for global CDN with automatic HTTPS and custom domain support
LocalStack Development: Local AWS environment for development and testing without cloud costs
Infrastructure Monitoring: CloudWatch logs and metrics for observability and debugging

Prerequisites

AWS account with programmatic access
AWS IAM user with the following policies:
- AmazonS3FullAccess
- CloudFrontFullAccess
- AWSLambdaFullAccess
- AmazonDynamoDBFullAccess
- AmazonAPIGatewayAdministrator
- IAMFullAccess
- CloudWatchLogsFullAccess
Terraform >= 1.0
Docker (for LocalStack development)
Git and GitHub account

Source Code

https://github.com/Lforlinux/Cloud-CV

How to deploy the infrastructure

Automated Deployment (Recommended)

The project uses GitHub Actions for one-click deployment:

diffctl

Fri, 03 Jan 2025 23:00:00 +0000

diffctl

A smart, sysadmin-friendly diff checker for text and JSON. Built for Linux admins and power users, diffctl provides intelligent, side-by-side and unified diffing for text and JSON, with a modern UI and Docker support.

What is diffctl?

diffctl is a web-based tool that provides intelligent diffing capabilities for text and JSON content. It features automatic mode detection, real-time comparison, and a modern responsive interface.

Key Features

Intelligent Mode Detection: Automatically detects whether input is text or JSON
Text Diff Mode: Compare plain text with line-by-line difference highlighting
JSON Diff Mode: Compare JSON objects with structured property-by-property comparison
Multiple View Modes: Unified view and side-by-side comparison
Real-time Comparison: Instant diff results as you type
Dark/Light Theme: Toggle between themes with persistent user preference
Docker Support: Easy deployment with Docker and Docker Compose

Installation

Option 1: Docker (Recommended)

Prerequisites

Docker and Docker Compose installed on your system

Quick Start with Docker

Clone the repository:

1
2

git clone https://github.com/Lforlinux/diffctl.git
cd diffctl

Build and run with Docker Compose:

`1`	`docker-compose up --build`

Open your browser and navigate to http://localhost:3000

Option 2: Local Development

Prerequisites

Node.js (version 16 or higher)
npm or yarn

Installation

Clone the repository:

1
2

git clone https://github.com/Lforlinux/diffctl.git
cd diffctl

Install dependencies:

`1`	`npm install`

Start the development server:

`1`	`npm run dev`

Open your browser and navigate to http://localhost:5173

Usage

Text Comparison

Enter your original text in the left textarea
Enter your modified text in the right textarea
The tool will automatically detect it as text mode
Click “Compare” to see the differences
Switch between “Unified View” and “Side-by-Side View”

JSON Comparison

Enter your original JSON in the left textarea
Enter your modified JSON in the right textarea
The tool will automatically detect it as JSON mode
Click “Compare” to see structured property differences
View added, removed, and modified properties

Theme Toggle

Click the theme toggle button in the top-right corner
Your preference is saved and will persist across sessions

Tech Stack

React 18: Modern React with hooks
Vite: Fast build tool and dev server
Tailwind CSS: Utility-first CSS framework
Custom Diff Logic: Proprietary text and JSON comparison algorithms

Features in Detail

Intelligent Mode Detection

The tool automatically analyzes both inputs to determine if they contain:

HaaS: Homelab as a Service - Private Cloud Infrastructure

Fri, 03 Jan 2025 23:00:00 +0000

What is the significance of this?

Private Cloud: Complete control over your data and infrastructure
Cost Savings: Eliminates multiple SaaS subscriptions ($50-200/month)
Data Sovereignty: No dependency on third-party cloud services
Learning Platform: Hands-on experience with enterprise technologies
Scalability: Start small and grow with your needs
Security: Enhanced privacy and control over sensitive data

How is automation accomplished?

Docker Orchestration: Containerized applications with automated lifecycle management
Portainer Management: Web-based container orchestration and monitoring
SSH Automation: Terminal-based configuration and maintenance
Tailscale VPN: Zero-config secure remote access
Synology DSM: Built-in package management and system administration
Backup Automation: Scheduled data protection and disaster recovery

Prerequisites

Synology NAS (DS923+ or compatible)
Docker and Portainer installed
Tailscale VPN account
Basic understanding of containerization
Network infrastructure (router, switches)

Source Code

https://github.com/portainer/portainer

How to deploy the infrastructure

Synology NAS Setup

Hardware Configuration

RAG-Powered Local LLM Assistant

Fri, 03 Jan 2025 23:00:00 +0000

What makes this special?

Complete Privacy: Your AI assistant runs entirely on your local infrastructure - no data leaves your network
Persistent Memory: Chroma vector database remembers everything you teach it, creating a truly personalized AI
Local LLM Power: Ollama runs powerful language models locally, no internet required for AI responses
Your Data, Your Control: All documents, conversations, and embeddings stored securely on your own storage
Zero Subscription Costs: Open-source stack with no ongoing fees or usage limits
Self-Hosted Excellence: Full control over your AI assistant’s capabilities and data retention

How does it work?

Smart Document Processing: Upload your documents and Chroma automatically creates searchable knowledge
Intelligent Memory: Your AI remembers past conversations and can reference your uploaded documents
Local Processing: Everything runs on your hardware - documents, conversations, and AI responses stay private
Easy Setup: One-command deployment with Docker Compose for hassle-free installation
Model Flexibility: Choose from various open-source LLM models that run entirely offline
Real-time Monitoring: Track your AI’s performance and resource usage with built-in dashboards

What you need

Docker & Docker Compose installed
8GB+ RAM (for running AI models locally)
Basic familiarity with Docker commands
Your own documents to create a personalized AI knowledge base

Source Code

https://github.com/Lforlinux/Opensource-LLM-RAG-Stack

How to deploy the infrastructure

Quick Start Deployment

# Clone the repository
git clone https://github.com/Lforlinux/Opensource-LLM-RAG-Stack.git
cd Opensource-LLM-RAG-Stack

# Quick start (includes model setup)
./start.sh

# Or manual setup:
# Start all services (includes Ollama)
docker-compose up -d

# Set up Ollama with a model
./scripts/setup-ollama.sh

Docker Compose Architecture

version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    ports: ["11434:11434"]
    volumes:
      - ollama-data:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_ORIGINS=*

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports: ["3000:8080"]
    environment:
      - OLLAMA_API_BASE_URL=http://ollama:11434
      - VECTOR_DB=chroma
      - DATABASE_URL=postgresql://user:password@postgres:5432/chatdb

  chroma:
    image: ghcr.io/chroma-core/chroma:latest
    ports: ["8000:8000"]
    environment:
      - CHROMA_DB_IMPL=duckdb+parquet

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: chatdb

Architecture

Self-Hosted Finance: Taking Control of Your Money with Actual Budget

Fri, 03 Jan 2025 23:00:00 +0000

What is the significance of this?

Financial Independence: Complete control over personal finance data with zero subscription costs
Data Sovereignty: Personal financial information never leaves your infrastructure
Cost Savings: Eliminates $179.88/year YNAB subscription, saving nearly $1,800 over 10 years
Privacy & Security: No third-party access to sensitive financial data
Customization: Unlimited flexibility in budgeting methodology and reporting

How is automation accomplished?

Docker Containerization: Actual Budget server running in Docker with automated restarts
Portainer Management: Web-based container orchestration and monitoring
Automated Backups: Scheduled database backups with version control
VPN Integration: Secure remote access via Tailscale for mobile budget management
Bank Sync: Automatic transaction import (country-specific features)
Goal Tracking: Automated progress monitoring for financial objectives

Prerequisites

Synology NAS (DS923+ or compatible)
Docker and Portainer installed
Tailscale VPN for secure remote access
Basic understanding of Docker containers
Budget data for migration (optional)

Source Code

https://github.com/actualbudget/actual

How to deploy the infrastructure

Docker Compose Setup

version: "3.8"

services:
  actual:
    image: actualbudget/actual-server:latest
    container_name: actual-budget
    restart: always
    ports:
      - "5006:5006"
    environment:
      - NODE_ENV=production
    volumes:
      - /volume1/docker-config/actual-budget:/data
    networks:
      - actual-network

networks:
  actual-network:
    driver: bridge

Deployment Steps

Create Directory Structure

`1`	`mkdir -p /volume1/docker-config/actual-budget`

Deploy with Portainer

Import the Docker Compose stack
Configure volume mounts for data persistence
Set up network connectivity

Access the Application

Navigate to http://your-nas-ip:5006
Create your first budget
Import existing financial data

Architecture

Core Components

Actual Budget Server: Node.js application serving budget data
SQLite Database: Local data storage with backup capabilities
Docker Container: Isolated runtime environment
Portainer: Container management and monitoring
Tailscale: Secure VPN for remote access

Data Flow

Transaction Entry: Manual entry or bank sync
Budget Allocation: Assign dollars to categories
Real-time Updates: Instant sync across devices
Reporting: Generate financial insights and trends

Key Features

Budget Management

Envelope Budgeting: YNAB-compatible methodology
Category Management: Custom spending categories
Goal Setting: Track progress toward financial objectives
Account Reconciliation: Keep bank accounts in sync

Advanced Features

Dashboard Customization: Import/export JSON configurations
Mobile Support: Responsive web interface
Offline Capability: Works without internet connection
Data Export: Full data portability

Financial Impact

Cost Comparison

Period	YNAB Cost	Actual Budget	Savings
Monthly	$14.99	$0	$14.99
Yearly	$179.88	$0	$179.88
5 Years	$899.40	$0	$899.40
10 Years	$1,798.80	$0	$1,798.80

Additional Benefits

Data Ownership: Complete control over financial data
Privacy: No third-party access to sensitive information
Customization: Unlimited flexibility in budgeting approach
Learning: Valuable technical skills in homelab management

Security & Privacy

Data Protection

Local Storage: All data remains on your infrastructure
Encrypted Backups: Secure backup strategies
VPN Access: Tailscale for secure remote connections
No Cloud Dependencies: Complete data sovereignty

Best Practices

Regular Updates: Keep containers current for security
Backup Strategy: Automated, encrypted backups
Access Control: Secure authentication and authorization
Network Security: Isolated container networking

Monitoring & Maintenance

Health Checks

Container Status: Monitor via Portainer dashboard
Database Integrity: Regular backup verification
Performance Metrics: Resource usage monitoring
Log Analysis: Troubleshooting and optimization

Backup Strategy

# Automated backup script
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
cp /volume1/docker-config/actual-budget/actual.db /volume1/backups/actual_$DATE.db

Troubleshooting

Common Issues

Database Corruption

Self-Hosted Music Streaming: High-Fidelity Audio with Complete Control

Fri, 03 Jan 2025 23:00:00 +0000

What is the significance of this?

Audio Quality: Lossless FLAC streaming vs compressed MP3 from commercial services
Data Ownership: Complete control over your music library and metadata
Cost Savings: Eliminates monthly streaming subscriptions ($10-15/month)
Privacy: No tracking or data collection by streaming companies
Customization: Unlimited library size and organization
Offline Access: Full library available without internet connection

How is automation accomplished?

Docker Orchestration: Plex Media Server with automated container management
YouTube Integration: Automated music downloading via YouTubeDL-Material
Metadata Management: MongoDB for subscription and media metadata
Mobile Sync: Plexamp app with offline download capabilities
VPN Access: Secure remote streaming via Tailscale
Automated Organization: Smart library management and metadata matching

Prerequisites

Synology NAS (DS923+ or compatible)
Docker and Portainer installed
Tailscale VPN for secure remote access
FLAC music library (optional)
Basic understanding of media server concepts

Source Code

https://github.com/plexinc/plex-media-server

How to deploy the infrastructure

Docker Compose Setup

version: "3.8"

services:
  plex:
    container_name: plex
    image: lscr.io/linuxserver/plex:latest
    devices:
      - /dev/dri:/dev/dri
    privileged: true
    network_mode: host
    environment:
      - PUID=1026
      - PGID=100
      - VERSION=docker
    restart: unless-stopped
    volumes:
      - /volume1/docker-config/plex:/config:rw
      - /volume1/Movies:/Movies:rw
      - /volume1/Music:/Music:rw

  ytdl_material:
    image: tzahi12345/youtubedl-material:latest
    container_name: ytdl_material
    restart: always
    depends_on:
      - ytdl-mongo-db
    ports:
      - "8998:17442"
    environment: 
      ytdl_mongodb_connection_string: 'mongodb://ytdl-mongo-db:27017'
      ytdl_use_local_db: 'false'
      write_ytdl_config: 'true'
    volumes:
      - /volume1/docker-config/ytdl/appdata:/app/appdata
      - /volume1/Music/:/app/audio 
      - /volume1/docker-config/ytdl/video:/app/video
      - /volume1/docker-config/ytdl/subscriptions:/app/subscriptions
      - /volume1/docker-config/ytdl/users:/app/users

  ytdl-mongo-db:
    image: mongo:4
    container_name: mongo-db
    restart: always
    logging:
      driver: "none"
    volumes:
      - /volume1/docker-config/ytdl/db:/data/db

Deployment Steps

Create Directory Structure

1
2
3

mkdir -p /volume1/docker-config/plex
mkdir -p /volume1/docker-config/ytdl/{appdata,video,subscriptions,users,db}
mkdir -p /volume1/Music

Deploy with Portainer

Import the Docker Compose stack
Configure volume mounts for media and configuration
Set up network connectivity

Configure Plex

Access Plex web interface
Set up media libraries
Configure remote access via Tailscale

Architecture

Core Components

Plex Media Server: Central media hub for music and video
YouTubeDL-Material: Automated music downloading from YouTube
MongoDB: Database for managing subscriptions and metadata
Portainer: Container orchestration and management
Tailscale: Secure VPN for remote access

Audio Quality Comparison

Format	Bitrate	Type	Quality
MP3 (High)	~320 kbps	Lossy	Good for casual listening
CD Audio	~1,411 kbps	Uncompressed	Full resolution
FLAC	700–3,500 kbps	Lossless	No quality loss
Hi-Res Audio	~9,216 kbps	Lossless (24-bit)	Studio quality

Key Features

Music Management

Lossless Audio: FLAC support for audiophile-quality streaming
Metadata Matching: Automatic artist, album, and track information
Library Organization: Smart categorization and search
Offline Sync: Download music for offline listening

Advanced Features

Gapless Playback: Seamless album listening experience
Loudness Leveling: Consistent volume across tracks
Crossfade: Smooth transitions between songs
Mobile Apps: Plexamp for iOS and Android

Audio Setup

Budget Audiophile Configuration

In-Ear Monitors: KZ EDX Pro ($10) for neutral tuning
Lossless Streaming: FLAC files from your own server
No Digital Processing: Clean analog sound path
Passive Noise Isolation: Immersive listening experience

Quality Benefits

Instrument Separation: Clear distinction between instruments
Dynamic Range: Full frequency response
No Compression Artifacts: Pure audio reproduction
Artist Intent: Music as recorded in studio

Media Sourcing

Legal FLAC Sources

Qobuz: High-resolution music downloads
Bandcamp: Direct artist support
HDtracks: Audiophile-quality downloads
Community Forums: Legal sharing recommendations

Collection Building

Album Purchases: Support artists directly
Lossless Rips: Convert existing CDs to FLAC
Community Sharing: Legal FLAC collections
YouTube Integration: Download and convert to FLAC

Mobile Experience

Plexamp Features

Offline Downloads: Full library available offline
Smart Playlists: AI-powered music discovery
Car Mode: Optimized for driving
Sleep Timer: Automatic playback control
Crossfade: Smooth transitions

Remote Access

Tailscale VPN: Secure connection from anywhere
Mobile Sync: Download music for offline use
Bandwidth Optimization: Adaptive quality streaming
Multi-Device: Sync across all devices

Cost Analysis

Streaming Service Comparison

Service	Monthly Cost	Audio Quality	Library Size
Spotify Premium	$10.99	320 kbps MP3	Unlimited
Apple Music	$10.99	Lossless	100M+ songs
Tidal HiFi	$19.99	Lossless	100M+ songs
Self-Hosted	$0	FLAC Lossless	Unlimited

Long-term Savings

Annual Savings: $131.88 (Spotify) to $239.88 (Tidal)
10-Year Savings: $1,318.80 to $2,398.80
No Subscription Fatigue: One-time setup cost
Data Ownership: Priceless privacy and control

Security & Privacy

Data Protection

Local Storage: All media remains on your infrastructure
No Tracking: No data collection or analytics
VPN Access: Secure remote connections only
User Control: Complete privacy over listening habits

Best Practices

Regular Updates: Keep containers current
Backup Strategy: Protect your music library
Access Control: Secure authentication
Network Isolation: Container network security

Troubleshooting

Common Issues

Audio Quality Problems

subnetctl

Fri, 03 Jan 2025 23:00:00 +0000

subnetctl

A web-based utility for managing and analyzing network subnets with advanced CIDR operations, designed for DevOps engineers and network administrators.

What is subnetctl?

subnetctl is a web-based tool that simplifies network subnet management, CIDR calculations, and network analysis. It’s particularly useful for cloud infrastructure management, IP address planning, and network troubleshooting.

Key Features

CIDR Operations: Calculate subnets, supernets, and network boundaries
IP Address Management: Validate, convert, and analyze IP addresses
Network Planning: Plan and optimize network allocations
Cloud Integration: Generate Terraform and CloudFormation network configurations
Visualization: Generate network diagrams and subnet maps
Modern Web Interface: Clean, responsive UI with real-time calculations

Installation

Option 1: Docker (Recommended)

Prerequisites

Docker and Docker Compose installed on your system

Quick Start with Docker

Clone the repository:

1
2

git clone https://github.com/Lforlinux/subnetctl.git
cd subnetctl

Build and run with Docker Compose:

`1`	`docker-compose up --build`

Open your browser and navigate to http://localhost:3000

Option 2: Local Development

Prerequisites

Node.js (version 16 or higher)
npm or yarn

Installation

Clone the repository:

1
2

git clone https://github.com/Lforlinux/subnetctl.git
cd subnetctl

Install dependencies:

`1`	`npm install`

Start the development server:

`1`	`npm run dev`

Open your browser and navigate to http://localhost:5173

Usage

Basic Operations

Enter CIDR notation (e.g., 192.168.1.0/24) in the input field
View subnet information including network, broadcast, and host count
Calculate subnet boundaries and available IP ranges
Generate network visualizations and diagrams

Advanced Features

Network Planning: Plan complete network infrastructures with multiple subnets
Overlap Detection: Identify and resolve network conflicts
Cloud Integration: Generate Terraform and CloudFormation configurations
Bulk Analysis: Process multiple CIDR blocks simultaneously

Use Cases

Cloud Infrastructure

Plan AWS VPC subnets and CIDR blocks
Generate Terraform network configurations
Validate network designs before deployment

Network Troubleshooting

Identify IP address conflicts
Analyze network overlaps
Validate routing configurations

IP Address Management

Track IP address allocations
Plan network expansions
Optimize network utilization

Tech Stack

React 18: Modern React with hooks
Vite: Fast build tool and dev server
Tailwind CSS: Utility-first CSS framework
Custom Network Logic: Proprietary CIDR calculation algorithms

Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Overview of ChatGPT and DevOps use cases

Sat, 10 Dec 2022 01:23:24 +0530

What is ChatGPT?

GPT (Generative Pretrained Transformer) is a type of natural language processing (NLP) model developed by OpenAI. It is a large, powerful model that can generate human-like text based on the input it receives.
It is optimized for generating responses to user input in a conversational context, and it can be trained on specific domains

What is the significane of it?

Sam Altman, the CEO and founder of OpenAI, recently announced the official release of the openGPT one week earlier(on November 30).
Currently, the service is free. It might be turned to a paid service because, according to Sam, the average cost each chat is only a few cents.
The number of users has now surpassed 1 million, and it only took 5 days from debut to accomplish this. Instagram took 2.5 months, Facebook 10 months, and Netflix 48 months.

Is it useful for me?

Oh, Yeah! No matter whatever field you are on. ChatGPT is genius tool in many ways!

The results I’m seeing from ChatGPT makes me appreciate humans even more, especially those who think critically, and continue to push the boundaries on creative expression. ChatGPT feels like the baseline of what we are capable of and sets the bar so we can raise it.

Jenkins Pipeline

Sun, 25 Jul 2021 08:53:27 +0530

What is Jenkins Pipeline 🤔

Jenkins Pipeline allows us to write the Jenkins build steps in code
Pipelines are robust. So if your server undergoes an unpredicted restart, the pipeline will be automatically resumed.
Jenkins Pipelines support big projects. You can run many jobs, and even use pipelines in a loop

Jenkins Pipeline format

Jenkins Pipeline can be defined by a text file called JenkinsFile. You can implement pipeline as code using JenkinsFile, and this can be defined by using a DSL (Domain Specific Language).

Proxy vs Reverse Proxy

Sat, 24 Jul 2021 08:53:27 +0530

In this post we will see what is proxy and reverse proxy.
We will also discuss the differnce between them.

What is proxy?

Proxy is an act where someelse doing something for you on your behalf.

Simple explantion of a proxy act in the below image.

What is Proxy server?

It is a server that sits in front of a group of client machines. When those computers make requests to sites and services on the Internet, the proxy server intercepts those requests and then communicates with web servers on behalf of those clients, like a middleman.

Bash scripting - set command

Thu, 22 Jul 2021 08:53:27 +0530

🖥 Bash scripting - set command and its usage

In this post we will see what is set in bash scripting
We will also discuss when to use set -e.

Set command

Use the set command to set or unset values of shell options and positional parameters. You can change the value of shell attributes and positional parameters, or display the names and values of shell variables using set command.

Boto3 Resource, Client and Session

Thu, 15 Jul 2021 01:23:24 +0530

Core concepts of Boto3

There are few concepts of boto3 (aws sdk) like Session, Resource, Client, Meta, Collections, Paginators
In this post we will discuss about the kehy difference between Resource, Client and Session

Session

A session manages state about a particular configuration. By default, a session is created for you when needed. However, it’s possible and recommended that in some scenarios you maintain your own session. Sessions typically store the following:

Jenkins as a Container

Mon, 28 Dec 2020 01:23:24 +0530

Run jenkins as a container with the stateful volume!

Why Jenkins as a container 🤔

It’s helps simplify the installation process.
Decrease dependency errors.
The Turnaround time for an Jenkins server installation is just few minutes.
Cross platform compatible.

Why do we need a stateful volume!🤨

Containers are often an ephemeral where in Jeknins we need to save our workloads even if we are not using it regularly. As in we will setting up the users, credentials inside Jenkins so it is important to save this as a stateful volume.

Let’s get started! 🎬

Create the volume for Jenkins on Docker host.

Docker-container-howitworks

Fri, 18 Dec 2020 08:53:27 +0530

🐳 Docker container creation - How it works!

In this post we will see what is happening when we run a command # docker container run -it -d nginx
We will also discuss some components involved during the container creation process

Docker CLI (docker) 💻

Docker CLI (docker)

`1`	`/usr/bin/docker`

Docker is used as a reference to the whole set of docker tools and at the beginning, it was a monolith. But now docker-cli is only responsible for user-friendly communication with docker.

Kubectl alias

Thu, 17 Dec 2020 08:53:27 +0530

Play with kubernets at ease!

Alias? What,Why 🤔

An alias is a (usually short) name that the shell translates into another (usually longer) name or command. Aliases allow you to define new commands by substituting a string for the first token of a simple command.
It can be used to avoid typing long commands or as a means to correct incorrect input. For common patterns it can reduce keystrokes and improve efficiency. A simple example is setting default options on commands to avoid having to type them each time a command is run
✨ Be lazy - use less keys on your keyboard ✨ 😜

Start your day with a list of things you know you tend to waste time on As Alicia Rades writes on the lifehack

AWS EKS Deployment through terraform

Fri, 19 Jun 2020 23:00:00 +0000

What is the significance of this?

Using this repository, you can provision the application as well as all of your cloud infrastructure with a single command.

How is automation accomplished?

Terraform has been used to provision infrastructure on AWS.
To make provision for application On the AWS EKS, deployment has been performed through using Helm template.
To fit the Kubernetes design, the NodeJS service has been changed to a microservice.
Terraform has been converted into a docker container microservice to improve team cooperation by ensuring that everyone uses the same version of the software.
This project makes use of Makefile to automate the provisioning of the full stack with a single command.
For convenience of usage, the load and performance testing tool locust has been transformed into a docker container.

Prerequisite

AWS account access
AWS iam programmatic user access with the follwing policy attached to the user
AmazonEC2FullAccess,IAMFullAccess,AutoScalingFullAccess,AmazonEKSClusterPolicy,
AmazonEKSWorkerNodePolicy,AmazonVPCFullAccess,AmazonEKSServicePolicy,AmazonEKS_CNI_Policy

Source Code

https://github.com/Lforlinux/aws-terraform-nodejs

How to provision the infra

Makefile has been leveraged for the simple approach towards the one-click entire stack deployment.

Jenkins as a container

Fri, 19 Jun 2020 23:00:00 +0000

Run jenkins as a container with the stateful volume!

Why Jenkins as a container 🤔

It’s helps simplify the installation process.
Decrease dependency errors.
The Turnaround time for an Jenkins server installation is just few minutes.
Cross platform compatible.

Why do we need a stateful volume!🤨

Containers are often an ephemeral where in Jeknins we need to save our workloads even if we are not using it regularly. As in we will setting up the users, credentials inside Jenkins so it is important to save this as a stateful volume.

Let’s get started! 🎬

Create the volume for Jenkins on Docker host.