<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>devops on Dileep Kumar</title>
    <link>https://dileepkumar.dev/tags/devops/</link>
    <description>Recent content in devops on Dileep Kumar</description>
    <image>
      <title>Dileep Kumar</title>
      <url>https://dileepkumar.dev/papermod-cover.png</url>
      <link>https://dileepkumar.dev/papermod-cover.png</link>
    </image>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Fri, 15 May 2026 03:50:00 +0530</lastBuildDate><atom:link href="https://dileepkumar.dev/tags/devops/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>The Complete Guide to Integrating HashiCorp Vault with Kubernetes</title>
      <link>https://dileepkumar.dev/post/vault-kubernetes-integration-guide/</link>
      <pubDate>Fri, 15 May 2026 03:50:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/vault-kubernetes-integration-guide/</guid>
      <description>Master Vault &#43; Kubernetes integration — covering every auth method, secret injection pattern, deployment topology, and GitOps workflow with step-by-step implementation guides.</description>
    </item>
    
    <item>
      <title>Shai-Hulud: The Worm That Ate the Software Supply Chain (TeamPCP)</title>
      <link>https://dileepkumar.dev/post/shai-hulud-worm-teampcp-supply-chain-attack/</link>
      <pubDate>Fri, 15 May 2026 03:30:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/shai-hulud-worm-teampcp-supply-chain-attack/</guid>
      <description>If you work anywhere near open-source infrastructure, CI/CD pipelines, or cloud-native tooling, you need to know about the Mini Shai-Hulud worm. Named after the colossal sandworms of Frank Herbert&amp;rsquo;s Dune, this self-propagating malware—deployed by the threat actor group TeamPCP—burrowed through the npm and PyPI ecosystems in May 2026, compromising hundreds of packages and turning trusted developer tooling into a weapon.
This is not a theoretical supply chain risk. This is one of the most sophisticated attacks the open-source ecosystem has ever faced.</description>
    </item>
    
    <item>
      <title>Docker Commands Cheatsheet - A Quick Reference</title>
      <link>https://dileepkumar.dev/post/docker-commands-cheatsheet/</link>
      <pubDate>Tue, 14 Jan 2025 00:08:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-commands-cheatsheet/</guid>
      <description>Introduction This cheatsheet provides a quick reference for the most common Docker commands.
Getting Started # Run a test image to verify installation docker run hello-world # Display system-wide information docker info # Display Docker version information docker version Image Management # List all images docker images ls # Pull an image from a registry (Docker Hub by default) docker image pull alpine # Push an image to a registry docker image push your-username/your-image # Build an image from a Dockerfile # -t tags the image with a name docker image build -t my-app .</description>
    </item>
    
    <item>
      <title>Docker Configuration and Security - A Comprehensive Production Guide</title>
      <link>https://dileepkumar.dev/post/docker-configuration-and-security/</link>
      <pubDate>Tue, 14 Jan 2025 00:07:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-configuration-and-security/</guid>
      <description>Introduction Properly configuring Docker is essential for both security and functionality, especially in enterprise and production environments. This comprehensive guide covers critical configuration scenarios, security hardening techniques, and best practices for running Docker safely in production.
We&amp;rsquo;ll explore proxy configuration, registry trust management, security scanning, resource limits, and the principle of least privilege—all essential for production-ready Docker deployments.
Part 1: Configuring Docker for Corporate Networks Understanding the Proxy Challenge In corporate environments, direct internet access is often restricted.</description>
    </item>
    
    <item>
      <title>Docker Content Transfer - A Complete Guide to Moving Files and Data</title>
      <link>https://dileepkumar.dev/post/docker-content-transfer-and-data-management/</link>
      <pubDate>Tue, 14 Jan 2025 00:05:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-content-transfer-and-data-management/</guid>
      <description>Introduction While volumes and bind mounts are the primary methods for persistent data in Docker, there are times when you need to quickly copy files between your host machine and a running or stopped container. This is where the docker cp command becomes invaluable.
This comprehensive guide covers everything about transferring content with Docker, from basic file copying to advanced data management strategies, troubleshooting, and best practices.
Why You Need docker cp Common Use Cases:</description>
    </item>
    
    <item>
      <title>Docker Registry - A Complete Guide to Private Image Management</title>
      <link>https://dileepkumar.dev/post/docker-registry-setup-and-management/</link>
      <pubDate>Tue, 14 Jan 2025 00:04:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-registry-setup-and-management/</guid>
      <description>Introduction While Docker Hub is excellent for public images, production environments require private registries for proprietary applications. A private Docker registry gives you complete control over your container images, their storage location, access permissions, and distribution.
This comprehensive guide covers everything from running a basic local registry to implementing production-grade solutions with authentication, TLS encryption, and high availability.
Why Run a Private Docker Registry? Security and Compliance:
Keep proprietary code and sensitive applications off public registries Meet regulatory requirements for data sovereignty Control who can access your images with fine-grained permissions Scan images for vulnerabilities before deployment Performance and Reliability:</description>
    </item>
    
    <item>
      <title>Docker Swarm and Services - A Comprehensive Guide to Container Orchestration</title>
      <link>https://dileepkumar.dev/post/docker-swarm-and-services/</link>
      <pubDate>Tue, 14 Jan 2025 00:03:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-swarm-and-services/</guid>
      <description>Introduction You&amp;rsquo;ve mastered single containers with docker run and multi-container applications on a single host with Docker Compose. But what happens when your application needs to scale beyond one machine? What if you need high availability, automatic failover, and load balancing across multiple servers?
This is where container orchestration comes in, and Docker Swarm is Docker&amp;rsquo;s native solution. Swarm transforms a pool of Docker hosts into a single, virtual Docker host, allowing you to deploy and manage containerized applications at scale.</description>
    </item>
    
    <item>
      <title>Docker Compose Mastery - A Comprehensive Guide to Multi-Container Applications</title>
      <link>https://dileepkumar.dev/post/docker-compose-mastery/</link>
      <pubDate>Tue, 14 Jan 2025 00:02:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-compose-mastery/</guid>
      <description>Introduction So far, we&amp;rsquo;ve dealt with single containers. But real-world applications are rarely that simple. They are often composed of multiple, interconnected services: a web server, a database, a caching layer, a message queue, and more. Managing the lifecycle, networking, and data for all these separate containers with individual docker run commands would be a nightmare.
This is the problem that Docker Compose solves. It is an essential tool for defining and running multi-container Docker applications.</description>
    </item>
    
    <item>
      <title>Docker Volumes and Bind Mounts - A Comprehensive Guide to Persisting Data</title>
      <link>https://dileepkumar.dev/post/docker-volumes-and-bind-mounts/</link>
      <pubDate>Tue, 14 Jan 2025 00:01:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-volumes-and-bind-mounts/</guid>
      <description>Introduction A core principle of Docker is that containers should be ephemeral and stateless. This means that any data created inside a container&amp;rsquo;s writable layer is lost forever when the container is removed. While this is great for creating predictable and clean environments, it poses a significant challenge for any application that needs to save data—like databases, user uploads, or logs.
To solve this, Docker provides three primary mechanisms for getting data into and out of containers: Volumes, Bind Mounts, and tmpfs mounts.</description>
    </item>
    
    <item>
      <title>Docker Images and Containers - A Comprehensive Guide</title>
      <link>https://dileepkumar.dev/post/docker-images-and-containers-complete-guide/</link>
      <pubDate>Tue, 14 Jan 2025 00:00:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/docker-images-and-containers-complete-guide/</guid>
      <description>Introduction Welcome to the world of Docker! This comprehensive guide is your first step into containerization. We will explore the absolute fundamentals: Dockerfiles, Images, and Containers. Understanding these three core components is the key to mastering Docker. By the end of this guide, you will not only have built and run your first containerized application but also grasped the &amp;ldquo;why&amp;rdquo; behind each step.
We&amp;rsquo;ll build a simple Python Flask web application from scratch, package it into a portable Docker image, and run it as an isolated container on your local machine.</description>
    </item>
    
    <item>
      <title>Kubernetes Cluster Setup with Kind: Complete Local Development Guide</title>
      <link>https://dileepkumar.dev/post/kubernetes-kind-cluster-setup/</link>
      <pubDate>Mon, 13 Jan 2025 01:00:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-kind-cluster-setup/</guid>
      <description>Introduction Kind (Kubernetes IN Docker) is a tool for running local Kubernetes clusters using Docker containers as nodes. It&amp;rsquo;s perfect for local development, testing, and CI/CD pipelines. In this comprehensive guide, I&amp;rsquo;ll show you how to set up and use Kind for your Kubernetes development workflow.
What is Kind? Kind is a tool designed to run Kubernetes clusters locally using Docker container &amp;ldquo;nodes&amp;rdquo;. Originally designed for testing Kubernetes itself, it&amp;rsquo;s now widely used for:</description>
    </item>
    
    <item>
      <title>Kubernetes Commands Cheatsheet: Complete kubectl Reference Guide</title>
      <link>https://dileepkumar.dev/post/kubernetes-commands-cheatsheet/</link>
      <pubDate>Mon, 13 Jan 2025 00:40:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-commands-cheatsheet/</guid>
      <description>Introduction This comprehensive cheatsheet covers essential kubectl commands for daily Kubernetes operations. Bookmark this for quick reference!
Cluster Info kubectl version kubectl cluster-info kubectl get nodes kubectl get componentstatuses kubectl config view kubectl config current-context kubectl config use-context &amp;lt;context-name&amp;gt; Pods # List kubectl get pods kubectl get pods -o wide kubectl get pods --all-namespaces kubectl get pods -n &amp;lt;namespace&amp;gt; kubectl get pods --show-labels kubectl get pods -l app=nginx # Create kubectl run nginx --image=nginx kubectl run nginx --image=nginx --dry-run=client -o yaml &amp;gt; pod.</description>
    </item>
    
    <item>
      <title>Production Kubernetes Cluster Setup with Kubeadm and Containerd</title>
      <link>https://dileepkumar.dev/post/kubernetes-production-cluster-setup/</link>
      <pubDate>Mon, 13 Jan 2025 00:30:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-production-cluster-setup/</guid>
      <description>Introduction Setting up a production-ready Kubernetes cluster requires careful planning and configuration. This guide walks you through creating a multi-node cluster using kubeadm and containerd as the container runtime.
Prerequisites Minimum Requirements:
2 GB RAM per machine 2 CPUs per machine Network connectivity between machines Unique hostname, MAC address, product_uuid Swap disabled Recommended for Production:
3+ control plane nodes (HA) 3+ worker nodes 4 GB+ RAM per node Load balancer for control plane Architecture Load Balancer (Optional for HA) ↓ Control Plane Nodes (3) ↓ Worker Nodes (3+) Step 1: Prepare All Nodes On all nodes (control plane + workers):</description>
    </item>
    
    <item>
      <title>Helm: The Kubernetes Package Manager - Installation and Usage Guide</title>
      <link>https://dileepkumar.dev/post/kubernetes-helm-package-manager/</link>
      <pubDate>Mon, 13 Jan 2025 00:20:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-helm-package-manager/</guid>
      <description>Introduction Managing multiple Kubernetes YAML files becomes complex quickly. Helm is the package manager for Kubernetes, simplifying deployment and management of applications through reusable templates called Charts.
What is Helm? Helm packages Kubernetes resources into Charts - reusable, versioned, and shareable packages.
Key Concepts:
Chart: Package of Kubernetes resources Release: Instance of a Chart running in cluster Repository: Collection of Charts Installing Helm # macOS brew install helm # Linux curl https://raw.</description>
    </item>
    
    <item>
      <title>Kubernetes DaemonSets and Jobs: Running System Services and Batch Workloads</title>
      <link>https://dileepkumar.dev/post/kubernetes-daemonsets-jobs/</link>
      <pubDate>Mon, 13 Jan 2025 00:10:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-daemonsets-jobs/</guid>
      <description>Introduction Not all workloads need to run continuously or be replicated across nodes. DaemonSets ensure one Pod per node (perfect for logging agents), while Jobs and CronJobs handle batch processing and scheduled tasks.
Understanding Different Workload Types Kubernetes Workload Controllers:
Controller Purpose Replicas Lifecycle Use Case Deployment Stateless apps Multiple Continuous Web servers, APIs StatefulSet Stateful apps Multiple Continuous Databases, queues DaemonSet Node services One per node Continuous Logging, monitoring Job Batch tasks Configurable Run to completion Data processing CronJob Scheduled tasks Configurable Scheduled Backups, reports Why Different Controllers?</description>
    </item>
    
    <item>
      <title>Kubernetes Advanced Scheduling: Node Affinity, Taints, and Tolerations</title>
      <link>https://dileepkumar.dev/post/kubernetes-advanced-scheduling/</link>
      <pubDate>Mon, 13 Jan 2025 00:05:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-advanced-scheduling/</guid>
      <description>Introduction By default, Kubernetes scheduler automatically places Pods on available nodes. But what if you need more control? Perhaps you want GPU-intensive workloads on specific nodes, or need to isolate production from development workloads. Node Affinity, Taints, and Tolerations give you fine-grained control over Pod placement.
Understanding Kubernetes Scheduling Default Scheduler Behavior: The Kubernetes scheduler automatically assigns Pods to nodes based on:
Available resources (CPU, memory) Node conditions (ready, disk pressure, memory pressure) Pod resource requests and limits Quality of Service (QoS) class Why Advanced Scheduling?</description>
    </item>
    
    <item>
      <title>Kubernetes Storage Mastery: Persistent Volumes, Claims, and StatefulSets</title>
      <link>https://dileepkumar.dev/post/kubernetes-storage-mastery/</link>
      <pubDate>Mon, 13 Jan 2025 00:00:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-storage-mastery/</guid>
      <description>Introduction Containers are ephemeral by nature - when they restart, all data is lost. For stateful applications like databases, this is unacceptable. Kubernetes provides a robust storage abstraction through Persistent Volumes (PV), Persistent Volume Claims (PVC), and Storage Classes to solve this challenge.
In this guide, I&amp;rsquo;ll show you how to implement persistent storage in Kubernetes, from basic concepts to production-ready StatefulSets.
Understanding Kubernetes Storage The Problem:
# Without persistent storage - data lost on restart!</description>
    </item>
    
    <item>
      <title>Kubernetes Configuration Management: Mastering ConfigMaps and Secrets</title>
      <link>https://dileepkumar.dev/post/kubernetes-configuration-management/</link>
      <pubDate>Sun, 12 Jan 2025 23:45:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-configuration-management/</guid>
      <description>Introduction Hardcoding configuration values and sensitive data directly into your application code is a recipe for disaster. It makes your applications inflexible, insecure, and difficult to manage across different environments. Kubernetes provides two powerful objects to solve this problem: ConfigMaps for configuration data and Secrets for sensitive information.
In this comprehensive guide, I&amp;rsquo;ll show you how to effectively manage application configuration and secrets in Kubernetes, following security best practices and production patterns.</description>
    </item>
    
    <item>
      <title>Kubernetes Services Deep Dive: ClusterIP, NodePort, and LoadBalancer Explained</title>
      <link>https://dileepkumar.dev/post/kubernetes-services-deep-dive/</link>
      <pubDate>Sun, 12 Jan 2025 23:40:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-services-deep-dive/</guid>
      <description>Introduction In Kubernetes, Pods are ephemeral - they can be created, destroyed, and replaced at any time. This creates a challenge: how do you reliably connect to your applications when Pod IP addresses constantly change? The answer is Kubernetes Services.
Services provide stable networking endpoints for your Pods, enabling reliable communication both within your cluster and from external clients. In this comprehensive guide, I&amp;rsquo;ll walk you through the three main Service types - ClusterIP, NodePort, and LoadBalancer - with practical examples and production best practices.</description>
    </item>
    
    <item>
      <title>Mastering Kubernetes Deployments: Scaling, Rolling Updates, and Rollbacks</title>
      <link>https://dileepkumar.dev/post/kubernetes-deployments-mastery/</link>
      <pubDate>Sun, 12 Jan 2025 23:35:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-deployments-mastery/</guid>
      <description>Introduction While Pods are the fundamental units in Kubernetes, you&amp;rsquo;ll rarely create them directly in production. Instead, you&amp;rsquo;ll use Deployments - a higher-level abstraction that provides declarative updates, scaling, and self-healing capabilities for your applications.
In this comprehensive guide, I&amp;rsquo;ll walk you through everything you need to know about Kubernetes Deployments, from basic creation to advanced rollout strategies and rollback procedures. This is essential knowledge for anyone managing production Kubernetes workloads.</description>
    </item>
    
    <item>
      <title>Kubernetes Pods - Complete Guide: From Basics to Production</title>
      <link>https://dileepkumar.dev/post/kubernetes-pods-complete-guide/</link>
      <pubDate>Sun, 12 Jan 2025 23:30:00 +0530</pubDate>
      
      <guid>https://dileepkumar.dev/post/kubernetes-pods-complete-guide/</guid>
      <description>Introduction Pods are the fundamental building blocks of Kubernetes. Understanding how to create, manage, and troubleshoot pods is essential for anyone working with Kubernetes. In this comprehensive guide, I&amp;rsquo;ll walk you through everything you need to know about Kubernetes pods, from basic creation to advanced troubleshooting techniques.
Whether you&amp;rsquo;re just starting with Kubernetes or looking to deepen your understanding, this guide covers both imperative (command-line) and declarative (YAML-based) approaches to pod management.</description>
    </item>
    
  </channel>
</rss>
