Forem: Kartik

How choose which Kubernetes Way is Right for You

Kartik — Fri, 31 Oct 2025 03:30:00 +0000

As someone who's always digging into DevOps tools, I find that explaining a topic is the best way to really understand it. So today, I want to share what I've learned about the different ways you can run Kubernetes (K8s).

Getting a Kubernetes cluster started can seem tricky because there isn't just one way to do it. Let's break down the main options in simple terms.

The Many Flavors of Kubernetes

1. Managed Services (Provides support)

Think of this as the easiest way to get started. Cloud providers like Amazon (EKS), Microsoft (AKS), and Google (GKE) do all the heavy lifting for you. They manage the "brain" of the cluster (the Control Plane) so you don't have to.

Why use it? It's fast to set up and you get great support. The cloud provider handles all the tough stuff like security and updates.
What's the catch? It can cost more, and you have less control over the setup. You're also using that specific cloud's way of doing things.

2. Management Platforms (like Rancher)

Imagine you have many different Kubernetes clusters, maybe on different clouds. Rancher is like a single, friendly dashboard that lets you manage all of them from one place.

Why use it? It's perfect if you need to manage multiple clusters and want a simple, consistent experience.
What's the catch? It’s one more tool to learn and manage, but it's very helpful for complex setups.

3. Self-Managed with kOps (Most preferred)

This is the "do-it-yourself" path, where you have full control. You are in charge of setting up and managing the entire cluster. It sounds hard, but a tool called kOps makes it much simpler.

Why use it? You get complete control, it can be cheaper, and you aren't locked into any single cloud provider.
What's the catch? It requires more technical knowledge, and you are responsible for everything, including maintenance and upgrades.

Why is kOps so popular?

kOps (Kubernetes Operations) is a favorite in the community because it automates the hard parts of the DIY approach. You just tell kOps what you want your cluster to look like, and it builds it for you. It’s like giving a blueprint to a robot builder—it makes the process repeatable and reliable.

Let's Build a Cluster with kOps!

Now, let's get our hands dirty and see how it works.

Step 1: Get Your Tools Ready

First, you need to install kubectl, the AWS CLI, and kOps itself. You can do this on a Linux machine with these commands:

# Get your system ready
sudo apt-get update && sudo apt-get install -y curl

# Install kubectl
sudo apt-get install -y kubectl

# Install AWS CLI
sudo snap install aws-cli --classic

# Install kOps
curl -Lo kops https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64
chmod +x kops
sudo mv kops /usr/local/bin/kops

Step 2: Connect to AWS

Run aws configure in your terminal and provide your AWS Access Keys to connect your machine to your AWS account.

Step 3: Give kOps a Home

kOps needs a place to store your cluster's configuration. An S3 bucket is perfect for this. (Make sure to use a unique bucket name!)

aws s3api create-bucket --bucket my-kops-cluster-storage-123 --region us-east-1

Step 4: Create the Cluster Blueprint

This one command tells kOps everything it needs to know to plan your cluster.

kops create cluster \
    --name=mycluster.k8s.local \
    --state=s3://my-kops-cluster-storage-123 \
    --zones=us-east-1a \
    --node-count=1 \
    --node-size=t2.micro \
    --master-size=t2.micro

Step 5: Build It!

Now, tell kOps to build the cluster based on the blueprint you just made.

kops update cluster --name mycluster.k8s.local --state=s3://my-kops-cluster-storage-123 --yes

This will take a few minutes. Go grab a chai!

Step 6: Check if it's Ready

After a few minutes, run this command to see if your cluster is online:

kops validate cluster --state=s3://my-kops-cluster-storage-123

And that’s it! You’ve just created your own Kubernetes cluster. By understanding these different approaches, you can pick the one that fits your project best.

Understanding 𝐊𝐮𝐛𝐞𝐫𝐧𝐞𝐭𝐞𝐬 (𝐊𝟖𝐬) 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞

Kartik — Thu, 30 Oct 2025 03:30:00 +0000

I love reading blogs and documentation, so I wanted to share some knowledge I've gained. Today, I learned about 𝐊𝐮𝐛𝐞𝐫𝐧𝐞𝐭𝐞𝐬 (𝐊𝟖𝐬) 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞.
Kubernetes works like a team with a brain. The brain is called the 𝐂𝐨𝐧𝐭𝐫𝐨𝐥 𝐏𝐥𝐚𝐧𝐞, and it manages a group of worker computers called 𝐍𝐨𝐝𝐞𝐬. Your applications run on these Nodes inside packages called 𝐏𝐨𝐝𝐬. The Control Plane watches everything. If an app in a Pod fails, the brain automatically tells a Node to restart it, which is called auto-healing. When your app gets a lot of users, the brain tells the Nodes to create more copies of it to handle the traffic, which is called auto-scaling. In short, Kubernetes uses its brain to manage the workers, making sure your apps are always healthy, running, and ready for any amount of traffic.

😄 Built a fun little project to calculate how ancient you are... and sneakily learned Docker in the process!

Kartik — Sun, 18 May 2025 08:12:28 +0000

This is a basic Go lang project that shows your age if you know your birth year. In this, you have to input your birth year, and it will take the current year automatically. By using the formula Current Year - Birth Year, it shows your current age. This project is mainly intended to learn how to containerize an application. It is not a Go-focused project but mainly Docker-focused instead. A Dockerfile will be created to build a Docker image and run it inside a container.

Once containerized, the application can be run easily using Docker commands on any system that supports Docker, regardless of the host environment. This helps demonstrate the power of containerization and the portability it brings to software development.

The project will also serve as a base to practice Docker fundamentals like:

-> Writing a Dockerfile

-> Building a lightweight image for a Go application

-> Running the image as a container

-> Understanding how to manage input/output inside the container

Overall, this project provides a practical, beginner-friendly example of containerizing a simple application — making it a great starting point for learning Docker and DevOps workflows.

Setup and Usage
📝 Step 1: Clone the repository:
git clone https://github.com/kartik-paliwa1/Know-Your-Age
cd Know-Your-Age

📝Step 2: Create a Dockerfile:
FROM golang:1.20-alpine

WORKDIR /app

COPY . .

RUN go build -o age-calculator Main.go

CMD ["./age-calculator"]

🛠️ Step 3: Build the Docker Image
docker build -t age-calculator .

(-t age-calculator: Tags the image with a custom name
.: Refers to the current directory as the Docker context)

▶️ Step 4: Run the Docker Container
docker run -it age-calculator

When prompted, enter your birth year inside the container and see your age output.

Refer to my Github repository for my project : [https://github.com/kartik-paliwa1/Know-Your-Age]

How to install ansible and run your first ansible Ad-Hoc Command.

Kartik — Thu, 05 Dec 2024 21:07:08 +0000

Install Ansible and Run Your First Playbook

Prerequisites

Create two EC2 instances:
- Main instance: Install Ansible.
- Target instance: The system to configure.

Step 1: Install Ansible on the Main Instance

Commands:

sudo apt update
sudo apt install ansible

Verify Installation:

ansible --version

Step 2: Set Up Passwordless Authentication

On the Main Instance:

Generate an SSH Key Pair:

   ssh-keygen

The public key is usually located at ~/.ssh/id_rsa.pub.

Copy the Public Key: Open the file with a text editor (e.g., vim) and copy its contents.

On the Target Instance:

Log in:

   ssh <username>@<target_server_ip>

Paste the Public Key into ~/.ssh/authorized_keys:

   vim ~/.ssh/authorized_keys

Save changes with :wq.

Test SSH: From the main instance:

   ssh <target_server_ip>

Passwordless authentication should now work.

Step 3: Create an Inventory File

Create a file named inventory:

   [webservers]
   192.168.1.10
   192.168.1.11

   [databases]
   192.168.1.20

Step 4: Run Ad-Hoc Commands

Run a Command Across All Servers:

   ansible -i inventory all -m shell -a "command_to_execute"

Example:

   ansible -i inventory webservers -m shell -a "ls -la"

Step 5: Write and Run Playbooks

Create a Playbook (e.g., playbook.yml):

   ---
   - name: Update and upgrade systems
     hosts: all
     become: yes
     tasks:
       - name: Update package lists
         apt:
           update_cache: yes
       - name: Upgrade packages
         apt:
           upgrade: yes

Run the Playbook:

   ansible-playbook playbook.yml -i inventory

By following these steps, you’ll have a basic Ansible setup to manage your infrastructure effortlessly.

Deploying a web application on AWS

Kartik — Sun, 28 Jul 2024 18:07:42 +0000

Recently, I embarked on a journey to deploy a web application on Amazon Web Services (AWS), and I'm excited to share the process with you. This blog post will guide you through the steps I took to get my application up and running on AWS.

Key Steps:

Local Testing:

Clone the repository.
Set up environment variables in a .env file.
Install dependencies and start the project using npm.

AWS EC2 Setup:

Create an IAM user with admin permissions.
Launch an EC2 instance using an Ubuntu image and a t2.micro instance type.
Connect to the instance using SSH.
Update packages and install Git, Node.js, and npm.

Deployment on AWS:

Clone the repository on the remote VM.
Set up environment variables.
Assign an Elastic IP to the EC2 instance.
Install dependencies and start the project.
Update security group inbound rules to allow traffic on the specified port.

The project is then successfully deployed on AWS.🎉

For an in-depth learning experience and detailed steps, refer to my GitHub repository.
Happy deploying! 🚀

Feel free to leave any comments or questions below, and I'll be happy to help you with your deployment journey!

Github API integration project /Automating Github

Kartik — Wed, 24 Jul 2024 19:55:55 +0000

This project automates the process of retrieving and displaying user access information for any GitHub repository. By leveraging the GitHub API, this shell script can provide detailed insights into who has read, write, and admin access to a repository. This tool is particularly useful for DevOps engineers and project managers who need to audit repository access regularly.

How It Works

Setting Up: Start by exporting your GitHub username and personal access token as environment variables to keep them secure.

Running the Script: Execute the script with the desired repository owner and name as command line arguments.

Output Interpretation: The script uses the curl command to make API requests and jq to parse the JSON response, displaying users with specific access levels.

If you want to create the project, follow these detailed steps:

Step 1: Create a GitHub Organization and Repository
-Create a GitHub Organization:
-Go to GitHub.
-Click on your profile picture in the top-right corner and select "Your organizations."
-Click "New organization."
-Choose "Create a free organization" and fill in the required details such as organization name and email.

Create a Repository:
-Within your organization, click "New" to create a new repository.
-Name the repository and choose the visibility (public or private).

Step 2: Prepare Your Environment
-Install Required Tools:
Ensure you have curl installed. This tool will be used to make API requests.
-Install jq for parsing JSON data:
sudo apt install jq -y

Step 3: Write the Shell Script or clone it:
-Create the Shell Script :
Create a new shell script file, for example, list_users.sh.

Write the code from https://github.com/kartik-paliwa1/shell-script-for-API-integration/blob/main/list-users.sh

-Or you can directly clone it:
Write the below command to clone the repo.

git clone https://github.com/kartik-paliwa1/shell-script-for-API-integration

-Then open repo:
cd shell-script-for-API-integration

-Write your github user-name and your token:
export GITHUB_USERNAME="your_username"
export GITHUB_TOKEN="your_token"

Step 4: Execute the Script
-Set the File Permissions:
chmod 777 list_users.sh

-Run the Script:
Execute the script with your repository details:
./list_users.sh 'Organisation-name' 'Repo-name'

Step 5: Verify the Output:
The script should output the list of users with read access to the specified repository. For example:
Output:
kartik-paliwa1 has access to shell-script-for-API-integration

Credits: Learned this project from YT channel Abhishek.Veeramalla

My Journey to DevOps: Building an AWS Resource Tracker with Shell Scripting and AWS CLI

Kartik — Fri, 19 Jul 2024 18:11:55 +0000

I am excited to share that I have learned how to create a real-time shell script project for DevOps on AWS. This project involves creating a shell script to track AWS resources such as EC2 instances, S3 buckets, Lambda functions, and IAM users using the technologies like Shell scripting, AWS CLI, AWS Instances, Cron jobs, JQ (JSON parser). This can be an essential tool for efficient resource management, maintaining cost-effectiveness and generating daily reports in any cloud infrastructure.

Firstly I learned How to efficiently create and connect to virtual machines (VMs) using AWS services. After logging into an AWS EC2 instance through the AWS console and terminal, connect it to an EC2 instance. Should know that using the console is not efficient for DevOps engineers who frequently manage multiple VMs. Instead using terminal tools such as iTerm for Mac or alternatives like Putty, MobaXterm, and NoMachine for Windows. Next, logging into an EC2 instance using the terminal, knowing the importance of using the correct public IP and key pair for authentication, configure the terminal to secure the pem file permissions before successfully logging into the instance. Next, AWS CLI installation, configure, and use it to interact with AWS services. Then leveraged AWS documentation extensively to understand commands and their usage.

This project not only honed my skills in AWS and DevOps but also demonstrated the power of effective learning resources and documentation. A big shoutout to the community and the tutorial creator: Abhishek Veeramalla on YT for making this learning experience possible!

Starting my DevOps journey with: Linux (Basic commands)

Kartik — Fri, 19 Jul 2024 18:02:59 +0000

I have learned a lot about the basics of Linux commands and gained knowledge in this field. The Linux operating system is very handy and is the go-to operating system for any developer. Linux gives developers the freedom to make changes to the operating system according to the requirements of the work. With its powerful command line interface, developers can automate tasks, manage files, and control system processes with ease. Additionally, the flexibility and open-source nature of Linux allow for extensive customization and optimization, making it an ideal choice for both beginners and experienced professionals. Whether you are developing software, managing servers, or just learning about operating systems, Linux provides the tools and environment to excel in your work.

Here are some of the basic commands I read :

Starting my DevOps journey with: Linux (Basic commands)

Kartik — Mon, 27 May 2024 05:10:37 +0000

Here are some of the basic commands I read :