<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sakshi Chaudhary on Medium]]></title>
        <description><![CDATA[Stories by Sakshi Chaudhary on Medium]]></description>
        <link>https://medium.com/@sakshi.ch496?source=rss-d85724583928------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*XiyeeWw_y2r6lM3qFIrcRg.jpeg</url>
            <title>Stories by Sakshi Chaudhary on Medium</title>
            <link>https://medium.com/@sakshi.ch496?source=rss-d85724583928------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 18:39:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sakshi.ch496/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Kubernetes on minikube (WSL) vs GKE/AKS/EKS]]></title>
            <link>https://medium.com/@sakshi.ch496/kubernetes-on-minikube-wsl-vs-gke-aks-eks-a169fe0832eb?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/a169fe0832eb</guid>
            <category><![CDATA[local-vs-managed-k8s]]></category>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Thu, 19 Mar 2026 08:17:04 GMT</pubDate>
            <atom:updated>2026-03-19T08:17:04.407Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XJx3MVvfI8-7eqAaUBYKjQ.png" /></figure><h3>Local Kubernetes vs Managed Kubernetes (GKE, AKS, EKS): Advantages and When to Use Each</h3><p>Organizations must decide whether to use managed services like Google Kubernetes Engine (GKE), Azure Kubernetes Service (AKS), or Amazon Elastic Kubernetes Service (EKS) or run Kubernetes locally (self-managed). Kubernetes has emerged as the de facto standard for container orchestration.</p><p>This article examines the benefits of local Kubernetes, contrasts it with managed solutions, and offers advice on when to use each.</p><h3>What is Local Kubernetes?</h3><p>Clusters that you install, set up, and maintain yourself either on-premises, on local servers, or even on developer machines are referred to as local Kubernetes (e.g., Minikube, kubeadm).</p><h3>Advantages of Local Kubernetes</h3><h3>1. Full Control and Customization</h3><p>With local Kubernetes, you control every layer:</p><ul><li>Networking (CNI plugins)</li><li>Storage (CSI drivers)</li><li>Security policies</li><li>Cluster configuration</li></ul><p>This is ideal for organizations needing deep customization or non-standard setups.</p><h3>2. Cost Efficiency at Scale</h3><p>Managed services charge for:</p><ul><li>Control plane</li><li>Worker nodes</li><li>Data transfer</li><li>Additional services</li></ul><p>With local Kubernetes:</p><ul><li>No control plane fees</li><li>Lower long-term cost if infrastructure already exists</li><li>Better for predictable, steady workloads</li></ul><h3>3. Vendor Independence</h3><p>Using local Kubernetes avoids:</p><ul><li>Vendor lock-in</li><li>Cloud-specific APIs and integrations</li></ul><p>This improves portability and flexibility.</p><h3>6. Better for Learning and Development</h3><p>Local setups (like Minikube or kind) are ideal for:</p><ul><li>Experimentation</li><li>CI testing</li><li>Learning</li></ul><h3>Disadvantages of Local Kubernetes</h3><ul><li>Requires significant expertise</li><li>Operational overhead (upgrades, scaling, monitoring)</li><li>Security responsibility lies fully with you</li></ul><h3>Managed Kubernetes (GKE, AKS, EKS)</h3><p>Managed Kubernetes services handle:</p><ul><li>Control plane management</li><li>Automatic upgrades</li><li>Scaling</li><li>Security patches</li></ul><h3>Benefits of Managed Services</h3><h4>1. Reduced Operational Overhead</h4><p>Cloud providers manage:</p><ul><li>Master nodes</li><li>Failover</li><li>Updates</li></ul><h4>2. Built-in Scalability</h4><ul><li>Auto-scaling clusters and nodes</li><li>Integration with cloud load balancers</li></ul><h4>3. Integrated Ecosystem</h4><ul><li>Native integration with cloud services</li><li>Logging, monitoring, IAM, storage</li></ul><h4>4. High Availability</h4><ul><li>Multi-zone deployments</li><li>SLA-backed uptime</li></ul><h3>When to Use Local Kubernetes</h3><p>Choose local Kubernetes if:</p><p>a. You need control over infrastructure.<br>b. You need to meet compliance or data residency requirements.<br>c. You need to support air-gapped environments.<br>d. You already have on-premises infrastructure.<br>e. You need to avoid vendor lock-in.<br>f. You need to support edge computing or hybrid environments.</p><h3>When to Use GKE, AKS, or EKS</h3><p>Choose managed Kubernetes if:</p><p>a. You need to deploy and start using Kubernetes quickly.<br>b. Your team does not have deep knowledge of Kubernetes.<br>c. You need high availability.<br>d. You need to integrate with cloud services.<br>e. Your workload is dynamic and requires auto-scaling.</p><h3>Conclusion</h3><p>There is no one-size-fits-all solution.</p><ul><li><strong>Local Kubernetes</strong> offers control, flexibility, and cost advantages but requires expertise and management.</li><li><strong>Managed Kubernetes (GKE, AKS, EKS)</strong> simplifies operations and accelerates development but at a higher cost and reduced control.</li></ul><p>The right choice depends on your organization’s priorities: control vs convenience, cost vs scalability, and compliance vs agility.</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a169fe0832eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Multinode Cluster for High Availability]]></title>
            <link>https://medium.com/@sakshi.ch496/building-a-multinode-cluster-for-high-availability-cb9c9f8d14f2?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb9c9f8d14f2</guid>
            <category><![CDATA[multinode-cluster]]></category>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Tue, 03 Mar 2026 04:54:33 GMT</pubDate>
            <atom:updated>2026-10-14T06:37:27.087Z</atom:updated>
            <content:encoded><![CDATA[<p>Running Kubernetes locally with multiple nodes gives you a realistic cluster experience without needing cloud infrastructure. In this guide, I will guide with the set up a multinode Kubernetes cluster using Minikube on your local machine .</p><h3>Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bY7uKWIS5KuRRnFVlsD4Qg.png" /></figure><h3>What You’ll Need</h3><p>Before we begin, make sure you have the following installed on your machine:</p><p><strong>Tools </strong>Minikube, Kubectl, RAM(8 GB+), CPU (4+ core)</p><h3>Key Concept: Each Node Has Its Own Network Stack</h3><p>One of the most important things to understand about a multinode cluster is that <strong>each node has its own network stack</strong> — its own IP address, routing table, iptables rules, and network interfaces. This is what makes inter-node communication non-trivial, and why a <strong>Container Network Interface (CNI) plugin</strong> is essential.</p><p>Lets get started with setting up Multinode cluster.</p><h3>Step 1: Start the Multinode Cluster</h3><p>Use the --nodes flag to specify the total number of nodes (1 control plane + N workers):</p><pre>minikube start \<br>  --nodes 3 \<br>  --cpus=2 \<br>  --memory=2048 \<br>  --cni=calico</pre><p><strong>Tip:</strong> Use --memory=4096 if you have enough RAM. Memory-starved nodes can cause intermittent failures</p><h3>Step 2: Verify Node Status</h3><pre>kubectl get nodes -o wide</pre><h3>Step 3: Label Your Worker Nodes</h3><pre>kubectl label node minikube-m02 node-role.kubernetes.io/worker=worker<br>kubectl label node minikube-m03 node-role.kubernetes.io/worker=worker</pre><h3>Step 4: Deploy a Test Workload Across Nodes</h3><p>Let’s deploy an Nginx app spread across both worker nodes:</p><pre># nginx-deployment.yaml<br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: nginx-multinode<br>spec:<br>  replicas: 4<br>  selector:<br>    matchLabels:<br>      app: nginx<br>  template:<br>    metadata:<br>      labels:<br>        app: nginx<br>    spec:<br>      topologySpreadConstraints:<br>        - maxSkew: 1<br>          topologyKey: kubernetes.io/hostname<br>          whenUnsatisfiable: DoNotSchedule<br>          labelSelector:<br>            matchLabels:<br>              app: nginx<br>      containers:<br>        - name: nginx<br>          image: nginx:latest<br>          ports:<br>            - containerPort: 80</pre><p>Apply it</p><pre>kubectl apply -f nginx-deployment.yaml</pre><p>You should see pods distributed across minikube-m02 and minikube-m03.</p><h3>Networking: How Nodes Communicate (CNI with Calico)</h3><h3>Why CNI Is Needed</h3><p>Since each node has its own network stack and IP range, <strong>Pods on different nodes cannot communicate by default</strong>. That means nginx in node 02 cannot communicate with nginx in node 03. The CNI plugin bridges this gap by:</p><ol><li>Assigning each node a <strong>Pod CIDR</strong> (subnet for Pods on that node)</li><li>Creating <strong>overlay or BGP routes</strong> so Pods on Node A can reach Pods on Node B</li><li>Managing <strong>network policies</strong> to control traffic between Pods</li></ol><h3>Calico in Action</h3><p>When you start Minikube with --cni=calico, it automatically deploys Calico as a DaemonSet on every node:</p><pre>kubectl get pods -n kube-system | grep calico</pre><p>Expected Output</p><pre>calico-kube-controllers-xxx   1/1   Running<br>calico-node-abc12             1/1   Running   # on minikube<br>calico-node-def34             1/1   Running   # on minikube-m02<br>calico-node-ghi56             1/1   Running   # on minikube-m03</pre><p>calico-node runs on <strong>every node</strong> and is responsible for programming the routing rules on that node&#39;s network stack.</p><h3>Pod-to-Pod Communication Across Nodes</h3><p>Here’s what happens when a Pod on Node 1 talks to a Pod on Node 2:</p><pre>Pod A (Node 1: 10.244.1.5)<br>  → Calico routes packet to Node 2 (192.168.49.3)<br>    → Node 2&#39;s Calico receives it<br>      → Delivers to Pod B (10.244.2.7)</pre><p>Each node’s Pod CIDR is visible via:</p><pre>kubectl get nodes -o jsonpath=&#39;{range .items[*]}{.metadata.name}{&quot;\t&quot;}{.spec.podCIDR}{&quot;\n&quot;}{end}&#39;</pre><h3>Network Policy Example</h3><p>With Calico, you can enforce <strong>network policies</strong>. For example, to allow only frontend pods to talk to backend pods:</p><pre>apiVersion: networking.k8s.io/v1<br>kind: NetworkPolicy<br>metadata:<br>  name: allow-frontend-to-backend<br>spec:<br>  podSelector:<br>    matchLabels:<br>      app: backend<br>  ingress:<br>    - from:<br>        - podSelector:<br>            matchLabels:<br>              app: frontend</pre><pre>kubectl apply -f network-policy.yaml</pre><h3>Testing Cross-Node Connectivity</h3><p>Verify Pods on different nodes can communicate:</p><pre># Get IPs of pods on different nodes<br>kubectl get pods -o wide<br><br># Exec into a pod on Node 1<br>kubectl exec -it &lt;pod-on-node1&gt; -- sh<br><br># Ping a pod on Node 2<br>ping &lt;pod-ip-on-node2&gt;</pre><p>If Calico is correctly configured, the ping should succeed across nodes.</p><h3>Useful Commands for Managing Your Multinode Cluster</h3><pre># Check cluster status<br>minikube status<br><br># SSH into a specific node<br>minikube ssh --node minikube-m02<br><br># Stop the cluster<br>minikube stop<br><br># Delete the cluster<br>minikube delete --all<br><br># Add a node later<br>minikube node add<br><br># Remove a node<br>minikube node delete minikube-m03</pre><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb9c9f8d14f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using HashiCorp Vault for Secret Management in a Production Kubernetes Cluster]]></title>
            <link>https://medium.com/@sakshi.ch496/using-hashicorp-vault-for-secret-management-in-a-production-kubernetes-cluster-379fff293a47?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/379fff293a47</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 07:57:36 GMT</pubDate>
            <atom:updated>2026-02-22T07:57:36.683Z</atom:updated>
            <content:encoded><![CDATA[<p><em>If you’ve ever stored a database password in a Kubernetes Secret, base64-encoded it, and called it “secure” this article is for you.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*tkd_aGDRokNQyfEtgW46Zg.png" /></figure><h3>This blog explains how we replaced Kubernetes Secrets with Vault including the real errors we hit and how we fixed them</h3><h3>Why Moved Away from Kubernetes Secrets</h3><p>“Kubernetes Secrets” sounds comforting. After all, that’s why they are called secrets. However, they are just base64-encoded strings that are kept in etcd. In just a few seconds, anyone with kubectl can decode them since they have secret access to your namespace. Fine-grained access control, automatic rotation, and an audit trail are all absent.</p><p>Configuration for the Django based todo application we were using on Kubernetes looked like this:</p><pre>envFrom:<br>  - secretRef:<br>      name: django-secret<br>  - secretRef:<br>      name: postgres-secret</pre><p>It was successful. But we didn’t know who had access to those secrets, we didn’t know how to rotate them without redeploying, and we didn’t know the answer to the question, “How long would it take us to know if this cluster was compromised?”<br>All of that is addressed by HashiCorp Vault. This is the tale of how we integrated it, flaws and all.The Architecture is shown below</p><pre>Django Pod starts<br>      │<br>      ▼<br>Vault Agent init container authenticates with Vault<br>      │<br>      ▼<br>Vault validates the pod service account<br>      │<br>      ▼<br>Vault Agent fetches secrets and writes to /vault/secrets/config<br>      │<br>      ▼<br>Django container starts → sources the file → env vars loaded<br>      │<br>      ▼<br>App connects to PostgreSQL — no .env file, no Kubernetes Secret</pre><p><strong>The key insight:</strong> Vault Agent functions inside your pod as a sidecar container. It automatically manages token renewal, secret retrieval, and authentication. Your application simply reads a file; it doesn’t need to be aware that Vault exists. It reduces secret management load. Let’s the steps to install , setup and use vault.</p><h3><strong>Step 1: Install Vault on Minikube via Helm</strong></h3><pre>helm repo add hashicorp https://helm.releases.hashicorp.com<br>helm repo update<br><br>helm install vault hashicorp/vault \<br>  --set &quot;server.dev.enabled=true&quot; \<br>  --set &quot;injector.enabled=true&quot;</pre><p>The injector.enabled=true flag is critical — this deploys the <strong>Vault Agent Injector</strong>, a mutating webhook that automatically adds the Vault Agent sidecar to any pod with the right annotations. Without it, nothing works.</p><p>Verify both components are running:</p><pre>kubectl get pods<br># vault-0                           1/1     Running<br># vault-agent-injector-xxxx         1/1     Running</pre><h3>Step 2: Store Your Secrets in Vault</h3><p>Exec into the Vault pod and set up your secrets engine:</p><pre>kubectl exec -it vault-0 -- /bin/sh<br><br># Enable KV v2 secrets engine<br>vault secrets enable -path=secret kv-v2<br><br># Store Django app secrets<br>vault kv put secret/django-app/config \<br>  SECRET_KEY=&quot;django-insecure-your-key-here&quot; \<br>  DATABASE_ENGINE=&quot;django.db.backends.postgresql&quot; \<br>  DATABASE_NAME=&quot;todos_db&quot; \<br>  DATABASE_HOST=&quot;postgres-service&quot; \<br>  DATABASE_USER=&quot;postgres&quot; \<br>  DATABASE_PASSWORD=&quot;your-password&quot; \<br>  DATABASE_PORT=&quot;5432&quot;<br><br># Verify everything was saved<br>vault kv get secret/django-app/config</pre><h3>Step 3: Write a Policy</h3><p>Vault’s default is <strong>deny everything</strong>. You must explicitly grant what your application can access:</p><pre>vault policy write django-policy - &lt;&lt;EOF<br>path &quot;secret/data/django-app/*&quot; {<br>  capabilities = [&quot;read&quot;]<br>}<br>EOF</pre><p>This policy says, any identity assigned django-policy can read secrets under secret/data/django-app/ Nothing else</p><h3>Step 4: Enable Kubernetes Authentication</h3><p>This is what allows pods to prove their identity to Vault using their Kubernetes service account token:</p><p>Enable kubernetes auth in vault</p><pre> vault auth enable kubernetes</pre><p>Configure and Verify it</p><pre>vault write auth/kubernetes/config \<br>  kubernetes_host=&quot;https://$KUBERNETES_PORT_443_TCP_ADDR:443&quot;</pre><p>Then Create a Role for pods service account.</p><pre>vault write auth/kubernetes/role/django-app \<br>  bound_service_account_names=django-sa \<br>  bound_service_account_namespaces=default \<br>  policies=django-policy \<br>  ttl=24h</pre><p>Verify Everything is Setup</p><pre>vault auth list<br>vault read auth/kubernetes/role/django-app<br>vault policy read django-policy</pre><h3>Step 5: Create the Service Account</h3><pre>kubectl create serviceaccount django-sa -n todo-app</pre><p>This is the identity your pod will use.</p><p>Now since we have created necessary, policy, role and permission for pod to access secrets in vault. we can now update django deployment to use vault’s secret key value.</p><h3>Step 6: Update the Deployment</h3><pre>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: django-app<br>  namespace: todo-app<br>spec:<br>  replicas: 2<br>  selector:<br>    matchLabels:<br>      app: django-app<br>  template:<br>    metadata:<br>      labels:<br>        app: django-app<br>      annotations:<br>        vault.hashicorp.com/agent-inject: &quot;true&quot;<br>        vault.hashicorp.com/role: &quot;django-app&quot;<br>        vault.hashicorp.com/agent-inject-secret-config: &quot;secret/data/django-app/config&quot;<br>        vault.hashicorp.com/agent-inject-template-config: |<br>          {{- with secret &quot;secret/data/django-app/config&quot; -}}<br>          export SECRET_KEY=&quot;{{ .Data.data.SECRET_KEY }}&quot;<br>          export DATABASE_ENGINE=&quot;{{ .Data.data.DATABASE_ENGINE }}&quot;<br>          export DATABASE_NAME=&quot;{{ .Data.data.DATABASE_NAME }}&quot;<br>          export DATABASE_HOST=&quot;{{ .Data.data.DATABASE_HOST }}&quot;<br>          export DATABASE_USER=&quot;{{ .Data.data.DATABASE_USER }}&quot;<br>          export DATABASE_PASSWORD=&quot;{{ .Data.data.DATABASE_PASSWORD }}&quot;<br>          export DATABASE_PORT=&quot;{{ .Data.data.DATABASE_PORT }}&quot;<br>          {{- end }}<br>    spec:<br>      serviceAccountName: django-sa<br>      containers:<br>      - name: django<br>        image: ****/todo-web:***<br>        imagePullPolicy: Always<br>        ports:<br>        - containerPort: 8000<br>        command: [&quot;/bin/sh&quot;, &quot;-c&quot;]<br>        args:<br>          - |<br>            source /vault/secrets/config <br>            python manage.py migrate --noinput <br>            python manage.py runserver 0.0.0.0:8000<br>        resources:<br>          requests:<br>            cpu: &quot;100m&quot;<br>            memory: &quot;128Mi&quot;<br>          limits:<br>            cpu: &quot;500m&quot;<br>            memory: &quot;512Mi&quot;<br>        livenessProbe:<br>          httpGet:<br>            path: /<br>            port: 8000<br>          initialDelaySeconds: 30<br>          periodSeconds: 10<br>        readinessProbe:<br>          httpGet:<br>            path: /<br>            port: 8000<br>          initialDelaySeconds: 10<br>          periodSeconds: 5</pre><p><strong><em>Error faced during vault implementation</em></strong></p><h4>Error 1: namespace not authorized</h4><p>After applying the deployment, the pods were stuck in Init:0/1. The init container logs showed:</p><pre>[ERROR] agent.auth.handler: error authenticating:<br>  | URL: PUT http://vault.default.svc:8200/v1/auth/kubernetes/login<br>  | Code: 403. Errors:<br>  | * namespace not authorized</pre><h4><strong>The cause:</strong></h4><p>When we created the Kubernetes auth role, we set bound_service_account_namespaces=default. But our Django app runs in the todo-app namespace. Vault was rejecting the authentication because the pod&#39;s namespace didn&#39;t match what the role allowed.</p><h4>The Fix:</h4><p>Update namespace to todo-app.</p><pre>kubectl exec -it vault-0 -- /bin/sh<br><br>vault write auth/kubernetes/role/django-app \<br>  bound_service_account_names=django-sa \<br>  bound_service_account_namespaces=todo-app \<br>  policies=django-policy \<br>  ttl=24h<br><br># Confirm the update<br>vault read auth/kubernetes/role/django-app<br># bound_service_account_namespaces    [todo-app]  ✓</pre><p>Then delete the stuck pod to force a fresh start:</p><pre>kubectl delete pod -l app=django-app -n todo-app</pre><p><strong>Lesson:</strong> Always double-check the namespace when creating Vault roles.</p><h4>Error 2: Secrets Injected but Django Not Reading Them</h4><p>After fixing the namespace issue, pods came up as 2/2 Running. The secrets file was being written correctly:</p><pre>kubectl exec -it &lt;pod&gt; -n todo-app -c django -- cat /vault/secrets/config<br># export SECRET_KEY=&quot;django-insecure-...&quot;<br># export DATABASE_ENGINE=&quot;django.db.backends.postgresql&quot;<br># ... all values correct</pre><p>But Django was still failing with:</p><pre>django.db.utils.OperationalError: could not translate host name &quot;db&quot; to address</pre><p>Checking the environment confirmed it:</p><pre>kubectl exec -it &lt;pod&gt; -n todo-app -c django -- env | grep DATABASE<br># (no output)</pre><p>The file existed with the right values. Django just wasn’t seeing them as environment variables.</p><p><strong>The cause:</strong> The original command used source /vault/secrets/config, but in minimal Alpine/sh environments, source is a bash built-in that doesn&#39;t exist in plain sh. The command silently failed, the env vars were never loaded, and Django fell back to its defaults, including DATABASE_HOST=&quot;db&quot;, a hardcoded value from an earlier version of settings.py.</p><p><strong>The fix:</strong> Replace source with . (dot), which is the POSIX-standard equivalent that works in any sh shell:</p><pre>command: [&quot;/bin/sh&quot;, &quot;-c&quot;]<br>args:<br> - |<br> . /vault/secrets/config &amp;&amp; \<br> python manage.py migrate - noinput &amp;&amp; \<br> python manage.py runserver 0.0.0.0:8000</pre><p>After applying this change and restarting the pods:</p><pre>kubectl get pods -n todo-app<br># django-app-67d9c4dc7-b5q8r   2/2     Running   0   74s<br># django-app-67d9c4dc7-v5vmm   2/2     Running   0   58s</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oMEhfDxKB6BNUPtgljpATg.png" /></figure><p><strong>Lesson:</strong> source is bash-specific. When your container runs /bin/sh (not /bin/bash), always use . instead. And always verify that env vars are actually loaded cat /vault/secrets/config</p><p><strong>Tags:</strong> Kubernetes HashiCorp Vault DevOps Security Django Secrets Management</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=379fff293a47" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Stopped Secret Leaks Before They Hit Git , Gitleaks + Pre-commit in Action]]></title>
            <link>https://medium.com/@sakshi.ch496/how-i-stopped-secret-leaks-before-they-hit-git-gitleaks-pre-commit-in-action-1e2974d31b55?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e2974d31b55</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Thu, 19 Feb 2026 04:13:38 GMT</pubDate>
            <atom:updated>2026-02-19T04:13:38.188Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*asgfC7meIO8xbBlApxpc_w.png" /></figure><p>One accidental commit can expose API keys, tokens, and passwords. Here’s how to automate secret detection and make it a habit before it brings chaos.</p><p>It happens more often than we’d like to admit. A developer accidentally commits an AWS access key, a secret, or a database password to a Git repository sometimes to a public one. The damage can be severe: data breaches, unauthorized access, and compliance violations. <strong>Gitleaks</strong> is a fast, open-source tool that scans your Git history and working tree for secrets, so you catch them before they ship.</p><h4><strong>1. Install gitleaks</strong></h4><p>On Ubuntu/Debian, install Gitleaks directly via apt:</p><pre>sudo apt install gitleaks</pre><h4>2. Scan Your Repository</h4><p>Run a scan against your current repository with verbose output to see detailed findings:</p><pre>gitleaks detect --source . --verbose<br># Scans your full Git commit history for secrets</pre><h4><strong>NOTE: <br></strong>Gitleaks scans your <em>Git history</em>, not your working directory. If you have uncommitted files with secrets, they will not be caught by this command alone.</h4><h4>3. Scanning Uncommitted Files</h4><p>To also scan your working tree — files that haven’t been committed yet — add the --no-git flag:</p><pre>gitleaks detect --source . --no-git --verbose<br># Scans working files and staged changes, bypasses Git history</pre><h4>4. Set Up Pre-commit Hooks</h4><p>The real power comes from automating secret detection on every git commit. Using pre-commit hooks, Gitleaks runs automatically and blocks the commit if secrets are found — before anything reaches your remote repository.</p><h4>✅Install pipx</h4><p>pipx is the recommended way to install Python CLI tools in isolated environments, keeping your system clean.</p><pre>sudo apt update<br>sudo apt install pipx<br>pipx ensurepath<br># Restart your terminal after this step</pre><h4>✅Install pre-commit</h4><p>Install the pre-commit framework via pipx:</p><pre>Veripipx install pre-commit<br># Verify installation<br>pre-commit --versionfy</pre><h4>✅Create the configuration file</h4><p>In the root of your repository, create a file named .pre-commit-config.yaml and add Gitleaks as a hook:</p><pre>repos:<br>  - repo: https://github.com/gitleaks/gitleaks<br>    rev: v8.18.2<br>    hooks:<br>      - id: gitleaks<br>        args: [&quot;detect&quot;, &quot;--no-git&quot;]<br><br># --no-git: scans your working tree + staged files<br># This catches secrets before they enter Git history</pre><h4>✅Install the Git hook</h4><p>Wire pre-commit into your local Git hooks directory:</p><pre>pre-commit install</pre><p>From now on, every git commit will automatically trigger Gitleaks. If a secret is detected, the commit is blocked with a clear error message.</p><p><strong>What happens now,</strong>Every git commit autoscans for secrets. If any are found, the commit fails and you&#39;ll see exactly which file and line contains the leak. Fix it, then commit again</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UHDUo2k5xnI7V77H8z-qIw.png" /></figure><h4>5. If Secrets Are Found</h4><p>Finding a secret is stressful, but acting fast minimizes damage. Follow these steps immediately:</p><h4>✅Revoke the secret immediately</h4><p>Go to your provider (AWS, GitHub, Stripe, etc.) and revoke or rotate the exposed credential right away. Do not wait. Assume it has already been seen.</p><h4>✅Remove from history</h4><p>If the secret was committed, use git filter-repo (preferred over filter-branch) to rewrite history and remove the sensitive data, then force-push to all remotes.</p><pre>pip install git-filter-repo<br>git filter-repo --path path/to/secret-file --invert-paths</pre><h4>✅Move secrets to environment variables or a vault</h4><p>Never hardcode credentials. Use environment variables, .env files (excluded via .gitignore), or a secrets manager like AWS Secrets Manager, HashiCorp Vault.</p><h4>✅Add protective entries to .gitignore</h4><p>Prevent accidental commits of sensitive files by keeping your .gitignore up to date:</p><pre># .gitignore<br>.env<br>.env.local<br>.env.*.local<br>*.pem<br>*.key<br>secrets/<br>config/credentials.yml</pre><h3>Conclusion</h3><p>Security doesn’t have to be a separate team’s responsibility. By integrating Gitleaks into your daily workflow, you build a safety net that operates silently in the background .</p><p>The pre-commit hook approach is particularly powerful because it creates a <strong>shift-left</strong> security posture: catching vulnerabilities at the earliest possible moment, when they’re cheapest to fix. A blocked commit is better than a breach investigation.</p><p>Make this setup part of every new repository you start, and consider adding it to your team’s onboarding checklist. The few minutes it takes to configure could save hours .</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e2974d31b55" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Network Commands Every DevOps Engineer Should Know]]></title>
            <link>https://medium.com/@sakshi.ch496/network-commands-every-devops-engineer-should-know-82dbb4815e37?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/82dbb4815e37</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Mon, 16 Feb 2026 17:10:42 GMT</pubDate>
            <atom:updated>2026-02-16T17:22:29.900Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ERT7dPiCtNnX8P-XDG4zQQ.png" /></figure><p>We’re a DevOps engineer, not a network specialist. But the thing is when the production server goes down at 3 AM, or when customers are complaining about slow response times, we can’t wait for someone to fix network stuff. So you need to know the network stuff.</p><p>Over the years, I’ve learned how these commands will save your time and bring mental peace. These are incredibly useful tools that help you figure out what’s actually going on when things goes wrong.</p><p>Let me walk you through them.</p><h3>1. ip a</h3><p><strong>What it does:</strong> Shows you all the network interfaces on your machine and their IP addresses.</p><p>You know that moment when you SSH into a server and think “wait, which network interface am I supposed to be using?” or “did this server actually get an IP address from DHCP?” That’s when ip a provide you info of network interfaces.</p><h3>Real-world scenario:</h3><p>You just deployed a new container, and it’s not communicating with the database. Before youlook for firewall rules and security groups, you run:</p><pre>ip a</pre><p>And you see that your container’s network interface didn’t get an IP address. Problem identified in 5 seconds.</p><h3>What you’re looking at:</h3><pre>2: eth0: &lt;BROADCAST,MULTICAST,UP,LOWER_UP&gt; mtu 1500<br>    inet 10.0.1.50/24 brd 10.0.1.255 scope global eth0</pre><ul><li>eth0 is your network interface</li><li>10.0.1.50 is your actual IP address</li><li>/24 means you&#39;re on a network with 254 other possible hosts</li><li>UP means it&#39;s actually working</li></ul><h3>2. ip r — How Does Traffic Actually Leave This Server?</h3><p><strong>What it does:</strong> Shows you the routing table , where your server sends different types of traffic.</p><p>Think of this as your server’s GPS. When your application tries to talk to the outside world (or even to other servers in your network), your server needs to know which direction to send that traffic. That’s what the routing table does.</p><h3>Real-world scenario:</h3><p>Your microservice can talk to some services but not others, and you’re unsure how . You run:</p><pre>ip r</pre><p>And you discover there’s no route to the subnet where those “other services” live.</p><h3>What you’re looking at:</h3><pre>default via 10.0.1.1 dev eth0<br>10.0.1.0/24 dev eth0 proto kernel scope link src 10.0.1.50</pre><p>In plain English:</p><ul><li>Any traffic that doesn’t match a specific rule goes to 10.0.1.1 (your default gateway, usually your router)</li><li>Traffic to other machines in the 10.0.1.0/24 range goes directly through eth0</li></ul><h3>3. traceroute — &quot;Where Did My Packet Go?&quot;</h3><h3><strong>What it does:</strong></h3><h4>Shows you every hop your traffic takes to reach a destination.</h4><p>At airport you try to figure out where your package is in the delivery line ? Traceroute is same for figuring out where is packets is going. It shows you every router, switch, and gateway your data passes through.</p><h3>Real-world scenario:</h3><p>Users in Europe are complaining that your app is slow, but users in the US are fine. You run:</p><pre>traceroute domain.com</pre><p>And you see that traffic is taking some weird route through three different continents before reaching your EU server.</p><h3>What you’re looking at:</h3><pre> 1  router.local (192.168.1.1)  1.432 ms<br> 2  isp-gateway.net (203.0.113.1)  400 ms<br> 3  * * *<br> 4  domain.com (93.184.216.34)  45.673 ms</pre><ul><li>Each line is a “hop”, a device your packet passes through</li><li>The numbers on the right are how long it took (in milliseconds)</li><li>* * * means that router didn&#39;t respond</li></ul><p>If you see one hop with dramatically higher latency [<strong>400ms</strong>]than the others, that’s your bottleneck.</p><h3>4. ping — Is The Domain Even Alive?</h3><p><strong>What it does:</strong> Sends a simple “hello” packet to a server and waits for a response.</p><p>This is literally the first thing you should do when troubleshooting connectivity. It’s like knocking on a door to see if anyone’s home. If ping doesn’t work, nothing will work.</p><h3>Real-world scenario:</h3><p>Your monitoring system says a server is down. Before you start panicking and checking if AWS is having an outage, you run:</p><pre>ping 10.0.1.50 [server ip]</pre><p>If you get responses, the server is alive ,your monitoring system might just be misconfigured.</p><h3>What you’re looking at:</h3><pre>64 bytes from 10.0.1.50: icmp_seq=1 ttl=64 time=0.432 ms<br>64 bytes from 10.0.1.50: icmp_seq=2 ttl=64 time=0.398 ms</pre><ul><li>time=0.432 ms — This is domain’s latency.</li><li>If you see packet loss (with no responce), you’ve got network problems</li></ul><p>I use this literally every time something doesn’t work.</p><h3>5. curl — HTTP Debugging tool</h3><p><strong>What it does:</strong> Makes HTTP requests from the command line, showing you exactly what’s happening.</p><p>If you work with APIs, web services,curl is going to be pretty useful. It lets you talk directly to web servers and see the raw response, without the help of browser.</p><h3>Real-world scenario:</h3><p>Your load balancer health checks keep failing. You run:</p><pre>curl -I http://your-app.com/health</pre><p>And you get a 404. Turns out the health check endpoint is /healthz not /health. One character lead to two hours of debugging.</p><h3>What you’re looking at:</h3><pre># See the headers too<br>curl -I <a href="https://api.example.com/users">https://api.example.com/users</a></pre><pre># Follow redirects<br>curl -L <a href="https://short.link/abc">https://short.link/abc</a></pre><pre># POST some data<br>curl -X POST -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{&quot;name&quot;:&quot;test&quot;}&#39; <a href="https://api.example.com/users">https://api.example.com/users</a></pre><pre># Check what certificate a site is using<br>curl -vI <a href="https://example.com/">https://example.com</a> 2&gt;&amp;1 | grep -i subject</pre><p>Use -v (verbose) when you need to see the full request, response headers, SSL handshake, the works.</p><h3>6. ss -tulnp — What&#39;s Running on This Server on which port?</h3><p><strong>What it does:</strong> Shows you all the network connections and listening ports on your system.</p><p>This is how you answer questions like “what’s listening on port 8080?” or “why is my app saying the port is already in use?”</p><h3>Real-world scenario:</h3><p>Your app won’t start because port 3000 is already in use. You run:</p><pre>ss -tulnp</pre><p>And you discover there’s an old instance of your app still running that didn’t shut down cleanly. Kill that process, start your app.</p><h3>Breaking down the flags:</h3><ul><li>-t : Show TCP sockets</li><li>-u : Show UDP sockets</li><li>-l : Show only listening sockets (servers waiting for connections)</li><li>-n : Show numbers instead of names (faster and often clearer)</li><li>-p : Show the process using each socket</li></ul><h3>What you’re looking at:</h3><pre>State   Recv-Q  Send-Q  Local Address:Port   Peer Address:Port  Process<br>LISTEN  0       128     0.0.0.0:22            0.0.0.0:*          users:((&quot;sshd&quot;,pid=1234,fd=3))<br>LISTEN  0       128     127.0.0.1:3000        0.0.0.0:*          users:((&quot;node&quot;,pid=5678,fd=20))</pre><ul><li>0.0.0.0:22 — SSH is listening on port 22, accepting connections from anywhere</li><li>127.0.0.1:3000 — Something is listening on port 3000, but ONLY from localhost</li><li>pid=5678 — That&#39;s the process ID if you need to kill it</li></ul><p><strong>I use this for:</strong></p><ul><li>Debugging “address already in use” errors</li><li>Checking if a service actually started (is it listening?)</li></ul><h3>Putting It All Together: A Real Debug Session</h3><p>Let me walk you through how these actually work together in real life.</p><p><strong>The problem:</strong> Your API abc.com/v1/users isn’t responding to requests from users.</p><p><strong>Step 1:</strong> Can you reach the server at all?</p><pre>ping abc.com</pre><p>✓ If yes Server is alive.</p><p><strong>Step 2:</strong> Is DNS resolving correctly?</p><pre>nslookup abc.com</pre><p>✓ Points to the right IP [server ip].</p><p><strong>Step 3:</strong> Can you make an HTTP request?</p><pre>curl -I http://abc.com/v1/users</pre><p>✗ Connection timeout.</p><p><strong>Step 4:</strong> Is the app even listening?</p><pre>ssh -i key user@ip<br>ss -tulnp | grep :80</pre><p>✓ App is listening on port 80.</p><p><strong>Step 5:</strong> Check the network interface and routing</p><pre>ip a  # Confirm the server has a proper IP<br>ip r  # Check routing table</pre><p>✓ Everything looks normal.</p><p><strong>Step 6:</strong> Trace the path</p><pre>traceroute abc.com</pre><p>You find raffic is dying at the firewall. Check security groups. See</p><ul><li>Is the <strong>required port open</strong>? (e.g., 80, 443)</li><li>Is the <strong>source IP / CIDR</strong> allowed?</li><li>Is the protocol correct (TCP vs UDP)?</li></ul><p>These can be overwhelming . You don’t need to memorize every flag and option for these commands. Honestly, I still google the syntax for curl POST requests . What matters is knowing which tool to reach for when.</p><ul><li>Server won’t respond? → ping</li><li>DNS issues? → nslookup</li><li>API problems? → curl</li><li>Port conflicts? → ss -tulnp</li><li>Routing weirdness? → ip r and traceroute</li><li>Interface confusion? → ip a</li></ul><p>What networking commands do you use every day? Any I missed that deserve to be on this list? Drop them in the comments — I’m always looking to level up my debugging game.</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82dbb4815e37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Explaining CPU Cores and Threads: A Complete Guide to Multi-Core Processing]]></title>
            <link>https://medium.com/@sakshi.ch496/explaining-cpu-cores-and-threads-a-complete-guide-to-multi-core-processing-c89cde900dec?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/c89cde900dec</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 11:53:20 GMT</pubDate>
            <atom:updated>2026-01-30T17:30:37.689Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*ct2e2FVSU8dKEiMQ1n9m-A.png" /></figure><p>Ever wondered how CPU are capable of handling multiple tasks like running youtube , running vscode, and other program so efficiently. Lets talk about it. What CPU core and threads are and how they work!</p><h4>What is CPU Core?</h4><p>A CPU core is a processing unit that is self-contained and capable of executing instructions. Every CPU core is capable of reading instructions from a program independently, which enables your computer to execute several operations simultaneously.</p><p>Imagine the CPU cores as separate Chef in a hotel. Each Chef (CPU core) is able to perform tasks independently, which means that multiple tasks can be accomplished simultaneously rather than waiting in a line.</p><h4>History and Evolution Regarding Core</h4><p>Initially processor/cpu had only single core in them. And with increase in digitalizaton the demand for more processing power were increasing. Manufacturer tried increasing clock speed of processor but it lead to physical limitations like high heat and power consumption. The solution was to add more core to enhance execution and performance power. This has lead to the creation of Multi-Core processor of current age.</p><p><em>To know complete history of processor evolution, visit https://www.computerhope.com/history/processor.htm</em></p><p>Now let’s understand concept of thread.</p><h4>Understanding Thread :</h4><p>A thread is a sequence of programmed instructions, which may be managed independently by the operating system’s scheduler. It refer to how many sequences of instructions a CPU core may process simultaneously.</p><p><strong>Can thread switch between multiple core?</strong></p><p>Abosolutely Yes.</p><p>Think of this in relation to the kitchen analogy. If a particular cooking station is too hot or too busy for a particular cook (Core 1), the head chef (Operating System) could direct the cook (Thread A) to gather all the ingredients for the particular dish and move it to another cooking station (Core 2) where there is more space.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*n-3C_T8puaRJ9SignCY2vg.png" /><figcaption>Fig: Core and Threads</figcaption></figure><h4>Why Threads move ?</h4><p>As we discussed thread is instructions run in a core. when there are Multi-Core processor, there is more probability that some core can be idle for sometime and some core can get overwhelmed. This scenario in core require better management of thread which is known as multi-threading. Some reasons of why Multi-Core processor use multi-threading is discussed below.</p><p><strong>Load Balancing</strong>: The OS ensurs that no core is running 100% of the time while others are idle. It is distributing threads across cores to keep things “even.”</p><p><strong>Thermal Management</strong>: If one core is running too hot, the OS might move its threads to a “cooler” core to prevent the CPU from slowing down also called thermal throttling.</p><p><strong>Power Saving</strong>: On laptops or phones, it might move all threads to a few cores and turn off others to save battery.</p><h4>Few more question to answer.</h4><h4>Why does Core and Thread Distiction even Matters And what are its Application ?</h4><p>Let’s find the answer…</p><p>A processor with 8 cores and 16 threads will not be as good as a processor with 16 cores, even though both processors will present 16 logical processors to the operating system. This would take some thoughtful analysis. So take your time to detangle it or you can understand with chefs analogy that having 16 individual chef will be better than having 8 chefs and making these 8 chefs to juggle on 2 tasks each. This approach would increase the cost for hotel because paying 8 chefs would be cheaper than paying 16 individual chefs.</p><p><strong>Now let’s it see it in action</strong></p><p>Various applications require cores and threads in different proportions. Video encoding, 3D graphics, and scientific calculations are applications that scale well with more cores because they can break down their tasks into multiple independent tasks.</p><p>When it comes to multitasking on a daily basis, the more threads available, the better your operating system will be able to juggle background tasks, system processes, and multiple running programs, thus providing a more fluid experience.</p><p>AI intensive task have some different story which I will cover in another blog.</p><h3>Conclusion</h3><p>CPU cores and threads function together as the basis of current computing performance. Cores deliver raw computing power with separate execution units, and threads optimize efficiency by keeping cores busy with multiple instruction flows.</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c89cde900dec" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Horizontal Pod Autoscaler (HPA): A Complete Practical Guide]]></title>
            <link>https://medium.com/@sakshi.ch496/kubernetes-horizontal-pod-autoscaler-hpa-a-complete-practical-guide-6afb9feffa00?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/6afb9feffa00</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Sat, 17 Jan 2026 16:03:40 GMT</pubDate>
            <atom:updated>2026-01-26T08:27:13.759Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6G1ODr48qoOvpmxsv4Yz4g.png" /></figure><p>Honestly, HPA along with CA [Cluster Autoscaler] is what brings the true power and elegance of Kubernetes to life by enabling applications to <strong>scale automatically</strong> based on real demand.</p><p>Modern cloud-native applications must handle <strong>unpredictable traffic patterns</strong> while remaining <strong>cost-efficient and highly available</strong>. Kubernetes solves this challenge with the <strong>Horizontal Pod Autoscaler (HPA)</strong>.</p><p>In this article, let’s understand <strong>what HPA is, why it’s needed, prerequisites, how to implement it step-by-step, common issues, and best practices</strong>, using a Django application.</p><h3><strong>What is HPA in Kubernetes?</strong></h3><p><strong>Horizontal Pod Autoscaler (HPA)</strong> is a Kubernetes feature that <strong>automatically adjusts the number of pod replicas</strong> in a Deployment, ReplicaSet, or StatefulSet based on observed metrics such as:</p><ul><li>CPU utilization</li><li>Memory usage</li><li>Custom or external metrics</li></ul><p>Instead of manually scaling pods, HPA <strong>dynamically increases or decreases replicas</strong> to match real-time application demand.</p><h3>Why is HPA Required?</h3><h3>1. Handling Variable Traffic Patterns</h3><p>Application traffic fluctuates throughout the day. Without HPA:</p><ul><li>You either <strong>overprovision resources</strong>, wasting money</li><li>Or <strong>underprovision</strong>, causing slowdowns or outages</li></ul><p>HPA automatically adapts to traffic changes.</p><h3>2. Cost Optimization</h3><p>HPA scales:</p><ul><li><strong>Up during peak traffic</strong></li><li><strong>Down during low traffic</strong></li></ul><p>This ensures you <strong>only pay for the resources you actually need</strong>, significantly reducing infrastructure costs.</p><h3>3. High Availability</h3><p>When traffic spikes:</p><ul><li>HPA adds more pods</li><li>Prevents application crashes and performance degradation</li></ul><p>This improves <strong>resilience and uptime</strong>.</p><h3>4. Manual Scaling Is Not Practical</h3><p>Manually monitoring metrics and scaling pods:</p><ul><li>Is slow</li><li>Error-prone</li><li>Impossible to do 24/7</li></ul><h3>5. Better Resource Utilization</h3><p>HPA ensures:</p><ul><li>No resource starvation</li><li>No unnecessary resource waste</li><li>Efficient cluster-wide resource usage</li></ul><p>HPA reacts <strong>automatically and instantly</strong>.</p><h3><strong>Prerequisite</strong></h3><p>Prior to the implementation of HPA, it should be ensured to have<br><strong>1. Metric Server</strong><br>The Metrics Server must be running inside your cluster</p><pre># Check if Metrics Server is installed<br>kubectl get deployment metrics-server -n kube-system<br><br>#Install if not present<br>kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C2pcnrt0NV-15ympwhVKqQ.png" /><figcaption>Fig: metrics-server</figcaption></figure><p><strong>2. Resource Requests Defined<br></strong>Your pods must declare resource requests in their deployment files. These amounts are then used as a baseline for percentage calculations by the HPA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sZtLoP7jpeCwJGPQGeug9g.png" /></figure><p><strong>3. Running a Deployment<br></strong>You require a deployment, a replica set, or a stateful set to scale. You can apply django-deployment.yaml</p><h3>How to implement?</h3><p><strong>Step 1: Add Resource Request in Deployment</strong></p><pre>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: django-app<br>  namespace: todo-app<br>spec:<br>  replicas: 2<br>  selector:<br>    matchLabels:<br>      app: django-app<br>  template:<br>    metadata:<br>      labels:<br>        app: django-app<br>    spec:<br>      containers:<br>      - name: django<br>        image: *********<br>        imagePullPolicy: Always<br>        ports:<br>        - containerPort: 8000<br>        command: [&quot;python&quot;, &quot;manage.py&quot;, &quot;runserver&quot;, &quot;0.0.0.0:8000&quot;]<br>        envFrom:<br>        - secretRef:<br>            name: django-secrets<br>        - secretRef:<br>            name: postgres-secret<br>        resources:<br>          requests:<br>            cpu: &quot;100m&quot;<br>            memory: &quot;128Mi&quot;<br>          limits:<br>            cpu: &quot;500m&quot;<br>            memory: &quot;512Mi&quot;<br>        readinessProbe:<br>          httpGet:<br>            path: /<br>            port: 8000<br>          initialDelaySeconds: 10<br>          periodSeconds: 5</pre><pre># Scale based on CPU (target 50% utilization)<br>kubectl apply -f name_of_django_deploymeny.yaml</pre><p><strong>Step 2: Create an HPA resource</strong></p><pre>---<br># Horizontal Pod Autoscaler for Django Todo Application<br>apiVersion: autoscaling/v2<br>kind: HorizontalPodAutoscaler<br>metadata:<br>  name: django-todo-hpa<br>  namespace: default<br>spec:<br>  # Target the Django deployment<br>  scaleTargetRef:<br>    apiVersion: apps/v1<br>    kind: Deployment<br>    name: django-app  <br><br>  # Scaling limits<br>  minReplicas: 2<br>  maxReplicas: 10<br><br>  # Metrics to scale on<br>  metrics:<br>  # CPU-based scaling<br>  - type: Resource<br>    resource:<br>      name: cpu<br>      target:<br>        type: Utilization<br>        averageUtilization: 50  <br><br>  # Memory-based scaling<br>  - type: Resource<br>    resource:<br>      name: memory<br>      target:<br>        type: Utilization<br>        averageUtilization: 70  <br><br>  # Scaling behavior configuration<br>  behavior:<br>    # Scale down policies<br>    scaleDown:<br>      stabilizationWindowSeconds: 300 <br>      policies:<br>      - type: Percent<br>        value: 50 <br>        periodSeconds: 15<br>      - type: Pods<br>        value: 2  <br>        periodSeconds: 15<br>      selectPolicy: Min  <br><br>    # Scale up policies<br>    scaleUp:<br>      stabilizationWindowSeconds: 0  <br>      policies:<br>      - type: Percent<br>        value: 100  <br>        periodSeconds: 15<br>      - type: Pods<br>        value: 4  <br>        periodSeconds: 15<br>      selectPolicy: Max  <br></pre><p><strong>Step 3: Test Scaling by performing load testing</strong></p><pre>kubectl run -it cpu-stress --image=busybox --restart=Never -n todo-app -- /bin/sh</pre><p>To test the functionality of hpa we do load testing on django application.</p><p>As traffic increases:</p><ul><li>CPU usage rises</li><li>HPA increases pod replicas automatically</li></ul><p>You can see the scaling of pods using commands</p><pre>kubectl get hpa -n todo-app<br>kubectl top pods -n todo-app</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*mU3oKDcNbuva2Tg0F0QZAQ.png" /></figure><p>The load on pods and memory stat can be seen with hpa in TARGETS section</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dwqTmSG4cgiX0Lg0zLqRFw.png" /><figcaption>Fig. HPA status</figcaption></figure><h3><strong>Benfits</strong></h3><p>a. Under high traffic, the application is stable.</p><p>b. No need for manual intervention.</p><p>c. Effective utilization of cluster resources.</p><p>d. Enhanced dependability and efficiency.</p><p>And you can see despite the huge traffic load application didn’t crash , it keeps running ensuring availability of application during <strong>peak hour</strong> which traffic is high.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DyYlpU-NuGvgKBx5LaD3HQ.png" /><figcaption>Fig. Uptime of app during high traffic</figcaption></figure><p><strong>Issues Faced</strong></p><ol><li>CPU requests missing</li></ol><blockquote><strong><em>HPA was showing TARGET as &lt;unkown&gt;. It was because hpa was not able to read deployment requests.</em></strong></blockquote><p>2. livelinessProbe killing container</p><blockquote><strong><em>HPA was stuck because liveness probe was killing Django before metrics could be collected, resolved by increasing initialDelaySeconds.</em></strong></blockquote><p>3. HPA causes instability in databases</p><blockquote><strong><em>As database not ideally designed for horizontal scaling HPA caused data inconsistency and performance issues.</em></strong></blockquote><p>By facing some of these I understood that HPA is only as effective as the metrics, probes, and resource defined. Utilizing them properly enhaces the HPA performance.</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6afb9feffa00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitOps Magic: Automating Django Deployments with ArgoCD and Jenkins]]></title>
            <link>https://medium.com/@sakshi.ch496/gitops-magic-automating-django-deployments-with-argocd-and-jenkins-183a3240a8da?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/183a3240a8da</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 05:08:28 GMT</pubDate>
            <atom:updated>2026-01-05T05:55:02.517Z</atom:updated>
            <content:encoded><![CDATA[<p>This blog is next part of previous blog <a href="https://medium.com/@sakshi.ch496/zero-cost-kubernetes-tutorial-complete-wsl-home-lab-setup-for-beginners-96f4b9fac8ac">https://medium.com/@sakshi.ch496/zero-cost-kubernetes-tutorial-complete-wsl-home-lab-setup-for-beginners-96f4b9fac8ac</a> in which we deployed apps mannually using kubectl command. Now stop manually deploying your apps. Let Git be your single source of truth. ✨</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/852/1*YkKCtn1f4oCq6oGyhji1IQ.png" /></figure><p>I’ll walk you through setting up a full CI/CD pipeline that, each time a developer pushes code, automatically deploys a Django application to a local Minikube cluster. There is no need for manual intervention.<br>After completing this tutorial, you will have</p><ol><li>Docker images are automatically created by Jenkins upon code commits</li><li>ArgoCD keeps an eye out for changes to your Git repository.</li><li>Kubernetes deployments that happen automatically when manifests are updated</li><li>A comprehensive GitOps workflow</li></ol><p>✅Before we dive in, make sure you have</p><ul><li>Minikube running in WSL (check out my previous blog if you need help with this)</li><li>Fundamental knowledge of Helm charts</li><li>Some familiarity with the Jenkins pipeline</li><li>An account on GitHub</li></ul><p>When a developer pushes a feature change, we want to deploy the Django container with the updated app image.<br>Jenkins, Argocd, Helm, Github, and a minikube cluster are the tools used.</p><h3>Step 1. Install helm 🛠️</h3><pre>## Get the most recent version ##<br>wget https://get.helm.sh/helm-v4.0.4-linux-amd64.tar.gz<br><br>## Unpack it ##<br>tar -zxvf helm-v4.0.4-linux-amd64.tar.gz<br><br>## move helm binary to make access system wide ##<br>sudo mv linux-amd64/helm /usr/local/bin/helm</pre><h4>Use Helm to install Argocd in Minikube.</h4><p>We will deploy ArgoCD in a custom namespace called <strong>argocd</strong></p><p>Add the argocd helm repository and add the argo helm repository</p><pre>helm repo add argo https://argoproj.github.io/argo-helm<br>helm repo update</pre><h4>Create namespace for argocd</h4><pre>kubectl create namespace argocd</pre><h3>Step 2. Install and Deploy ArgoCD in your cluster 🎯</h3><pre>helm install argocd argo/argo-cd \<br>  --namespace argocd \<br>  --create-namespace \<br>  --wait</pre><p>Wait for pods to be ready and verify installation</p><pre>kubectl wait --for=condition=ready pod \<br>  --all -n argocd \<br>  --timeout=300s<br><br>kubectl get pods -n argocd</pre><p>List ArgoCD pods using command</p><p>You should see all pods in a “Running” state. If you do, congratulations! ArgoCD is alive.</p><pre>kubectl get pods -n argocd</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*u2s2rAVr5B39ZNv_TfF00w.png" /></figure><h4>Step 3. Set Up Jenkins Locally</h4><p>The <strong>next step</strong> is to <strong>set up Jenkins locally</strong> and deploy docker-compose.yaml.</p><pre>version: &#39;2.2&#39;<br>services:<br>  jenkins:<br>    image: jenkins/jenkins:lts-jdk17<br>    privileged: true<br>    user: root<br>    ports:<br>      - 8080:8080<br>      - 50000:50000<br>    container_name: jenkins-lts<br>    restart: always<br>    volumes:<br>      - /home/ubuntu/jenkins_home:/var/jenkins_home<br>      - /var/run/docker.sock:/var/run/docker.sock<br>      - /usr/bin/docker:/usr/bin/docker<br>      - /home/ubuntu/.minikube:/var/jenkins_home/.minikube:rw<br>      - /home/ubuntu/.kube:/var/jenkins_home/.kube:rw<br>      - /home/ubuntu/.kube/config:/root/.kube/config:ro<br>      - /usr/local/bin/kubectl:/usr/local/bin/kubectl:ro<br>      - /home/ubuntu/todo_project:/var/jenkins_home/workspace:rwx<br>      - /home/ubuntu/.ssh:/var/jenkins_home/.ssh:rw<br>    environment:<br>      - DOCKER_HOST=unix:///var/run/docker.sock<br>      - MINIKUBE_HOME=/root/.minikube</pre><p><em>Note: Change paths according to you local system</em></p><p>Run docker compose up command</p><pre>## this runs jenkins docker container in background on port 8080 ##<br>docker compose up -d</pre><h3>Step 4. Create Your Jenkins Pipeline</h3><p>Now create a pipeline to build the django application and update image in django-deployment.yaml</p><pre>pipeline {<br>    agent any<br><br>    environment {<br>        PROJECT_NAME = &quot;todo-web&quot;   // Docker Hub repo name<br>        DOCKERHUB_USER = &quot;********&quot;<br>        // Python configuration<br>        PYTHON_VERSION = &#39;3.11&#39;<br><br>        // Docker configuration<br>        DOCKER_REGISTRY = &quot;docker.io&quot; <br>        DOCKER_IMAGE_NAME = &#39;todo-app&#39;<br>        DOCKER_IMAGE_TAG = &quot;${BUILD_NUMBER}&quot;<br>       <br>    }<br><br>     options {<br>        timestamps()<br>        buildDiscarder(logRotator(numToKeepStr: &#39;5&#39;))<br>    }<br><br>    stages {<br><br>        stage(&#39;Checkout Source&#39;) {<br>            steps {<br>                checkout([<br>                    $class: &#39;GitSCM&#39;,<br>                    branches: [[name: &#39;*/main&#39;]],<br>                    userRemoteConfigs: [[<br>                        url: &#39;git@github.com:********/todo-app.git&#39;,<br>                        credentialsId: &#39;jenkins-github-ssh-coonnection&#39;<br>                    ]]<br>                ])<br>            }<br>        }<br><br>        stage(&#39;Set Commit and Tag&#39;) {<br>            steps {<br>                script {<br>                    env.GIT_COMMIT = sh(script: &quot;git rev-parse --short HEAD&quot;, returnStdout: true).trim()<br>                    env.IMAGE_TAG  = &quot;${BUILD_NUMBER}-${env.GIT_COMMIT}&quot;<br><br>                    echo &quot;GIT_COMMIT: ${env.GIT_COMMIT}&quot;<br>                    echo &quot;IMAGE_TAG: ${env.IMAGE_TAG}&quot;<br>                }<br>            }<br>        }<br>        <br>          stage(&#39;Setup Tools&#39;) {<br>            steps {<br>                script {<br>                    echo &quot;Installing Syft and Grype...&quot;<br>                    sh &#39;&#39;&#39;<br>                    <br>                         # Install Python if not present<br>                        if ! command -v python3 &amp;&gt; /dev/null; then<br>                            echo &quot;Installing Python3...&quot;<br>                            apt-get update &amp;&amp; apt-get install -y python3 python3-venv python3-pip<br>                        fi<br>                    &#39;&#39;&#39;<br>                }<br>            }<br>        }<br>        <br>          stage(&#39;Setup Python Environment&#39;) {<br>            steps {<br>                script {<br>                    echo &quot;Setting up Python virtual environment...&quot;<br>                    sh &#39;&#39;&#39;<br>                        # Create virtual environment<br>                        python3 -m venv venv || python -m venv venv<br>                        <br>                        # Activate and upgrade pip<br>                        . venv/bin/activate<br>                        pip install --upgrade pip setuptools wheel<br>                        <br>                        echo &quot;✓ Python environment ready&quot;<br>                        python --version<br>                        pip --version<br>                    &#39;&#39;&#39;<br>                }<br>            }<br>        }<br>        <br>        stage(&#39;Install Dependencies&#39;) {<br>            steps {<br>                script {<br>                    echo &quot;Installing Python dependencies...&quot;<br>                    sh &#39;&#39;&#39;<br>                        . venv/bin/activate<br>                        <br>                        # Install from requirements.txt<br>                        if [ -f requirements.txt ]; then<br>                            echo &quot;Installing from requirements.txt...&quot;<br>                            pip install -r requirements.txt<br>                        fi<br>                        <br>                        # List installed packages<br>                        echo &quot;Installed packages:&quot;<br>                        pip list<br>                        <br>                        echo &quot;✓ Dependencies installed&quot;<br>                    &#39;&#39;&#39;<br>                }<br>            }<br>        }<br>        <br>        stage(&#39;Run Tests&#39;) {<br>            steps {<br>                script {<br>                    echo &quot;Running Django tests...&quot;<br>                    sh &#39;&#39;&#39;<br>                        . venv/bin/activate<br>                        <br>                        # Run Django tests<br>                        python manage.py test --noinput || echo &quot;⚠️ Tests failed or not configured&quot;<br>                        <br>                        # Optional: Run with coverage<br>                        # pip install coverage<br>                        # coverage run --source=&#39;.&#39; manage.py test<br>                        # coverage report<br>                        # coverage html -d coverage_html<br>                        <br>                        echo &quot;✓ Tests completed&quot;<br>                    &#39;&#39;&#39;<br>                }<br>            }<br>        }<br>        <br><br>        <br>   stage(&#39;Build Docker Image and Update Manifest Repo&#39;) {<br><br>    steps {<br>        script {<br>            echo &quot;Updating Kubernetes manifest repository...&quot;<br><br>            sshagent(credentials: [&#39;jenkins-github-ssh-coonnection&#39;]) {<br>                sh &quot;&quot;&quot;<br>                    set -e<br>                    docker build -t todo:${BUILD_NUMBER} .<br><br>                    # Clean old repo if exists<br>                    rm -rf k8s-manifest-for-todo-app<br><br>                    # Clone manifest repository using SSH<br>                    git clone git@github.com:Sakshi9111/k8s-manifest-for-todo-app.git<br>                    cd k8s-manifest-for-todo-app<br><br>                    # Update image tag in deployment.yaml<br>                    sed -i &quot;s|image: .*|image: todo:${BUILD_NUMBER}|g&quot; kubernetes/base/django-deployment.yaml<br><br>                    # Git config<br>                    git config user.email &quot;**********&quot;<br>                    git config user.name &quot;***********&quot;<br><br>                    # Commit and push<br>                    git add .<br>                    git commit -m &quot;Update  to version&quot; || echo &quot;No changes to commit&quot;<br>                    git push origin main<br><br>                    echo &quot;✓ Manifest repository updated&quot;<br>                &quot;&quot;&quot;<br>                }<br>            }<br>        }<br>    }<br>       <br>    }<br><br>    post {<br>        success {<br>            echo &quot;Pipeline executed successfully. Image updated to ${env.IMAGE_TAG}&quot;<br>        }<br>        failure {<br>            echo &quot;Deployment failed. Check logs for details.&quot;<br>        }<br>        always {<br>            echo &quot;Cleaning up workspace...&quot;<br>            cleanWs()<br>        }<br>    }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xfGEDhGGZcyVtDUf1ausSA.png" /><figcaption>Fig: Jenkins Pipeline</figcaption></figure><h3>Step 5: Access ArgoCD UI 🖥️</h3><p>Now we use Argocd to set up the CD. We will set up CD to deploy to Minikube since we already have argocd installed.</p><p>Install the Argo cli for convenience. However you can setup the pipeline directly from browser as well. But cli works better and quick for me. Use what works best for you.</p><pre>kubectl port-forward svc/argocd-server -n argocd 8080:443</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*1GS1Jc7xY2YeZcLLtz5RLg.png" /></figure><p>Use port-forward to access the user interface and access UI from Browser</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rz4_Y0CeNxhjyij5iU30VQ.png" /><figcaption>Fig: ArgoCD in action</figcaption></figure><p>Use this script to install and login, save some time</p><pre>#!/bin/bash<br><br>echo &quot; Installing Helm and ArgoCD&quot;<br><br># Install Helm<br>echo &quot; Installing Helm...&quot;<br>curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash<br><br># Verify Helm<br>helm version<br><br># Add ArgoCD Helm repo<br>echo &quot; Adding ArgoCD Helm repository...&quot;<br>helm repo add argo https://argoproj.github.io/argo-helm<br>helm repo update<br><br># Create namespace<br>echo &quot; Creating argocd namespace...&quot;<br>kubectl create namespace argocd<br><br># Install ArgoCD<br>echo &quot; Installing ArgoCD...&quot;<br>helm install argocd argo/argo-cd \<br>  --namespace argocd \<br>  --set server.service.type=NodePort \<br>  --set server.service.nodePortHttp=30080 \<br>  --set server.insecure=true \<br>  --wait<br><br># Wait for pods<br>echo &quot; Waiting for ArgoCD pods to be ready...&quot;<br>kubectl wait --for=condition=ready pod \<br>  --all -n argocd \<br>  --timeout=300s<br><br># Get password<br>echo &quot; Getting ArgoCD admin password...&quot;<br>ARGOCD_PASSWORD=$(kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath=&quot;{.data.password}&quot; | base64 -d)<br><br># Install ArgoCD CLI<br>echo &quot; Installing ArgoCD CLI...&quot;<br>curl -sSL -o argocd-linux-amd64 https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64<br>sudo install -m 555 argocd-linux-amd64 /usr/local/bin/argocd<br>rm argocd-linux-amd64<br><br># Get access URL<br>echo &quot;&quot;<br>echo &quot;✅ Installation Complete!&quot;<br>echo &quot;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━&quot;<br>echo &quot; Access ArgoCD:&quot;<br>echo &quot;&quot;<br>echo &quot;  Method 1 - Port Forward:&quot;<br>echo &quot;    kubectl port-forward svc/argocd-server -n argocd 8090:443&quot;<br>echo &quot;    URL: https://localhost:8090&quot;<br>echo &quot;&quot;<br><br>echo &quot;&quot;<br>echo &quot; Login Credentials:&quot;<br>echo &quot;  Username: admin&quot;<br>echo &quot;  Password: $ARGOCD_PASSWORD&quot;<br>echo &quot;&quot;<br>echo &quot; CLI Login:&quot;<br>echo &quot;  kubectl port-forward svc/argocd-server -n argocd 8090:443 &amp;&quot;<br>echo &quot;  argocd login localhost:8090 --insecure --username admin --password $ARGOCD_PASSWORD&quot;<br>echo &quot;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━&quot;</pre><p><strong>Login to argocd</strong> and create a connection to repository</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hWTMl8ETz23P32_6tJ4GKQ.png" /><figcaption>Fig: ArgoCD repo connection</figcaption></figure><h3><strong>Step 6.Create your ArgoCD Application</strong>📦</h3><p><strong>Create an Application</strong> using argocd CLI command . Next create Argocd app with these details.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c-LqMxTlK5kZflAKgiL5_Q.png" /><figcaption>Fig: ArgoCD application Summary</figcaption></figure><p>ArgoCD cli command to create the app</p><pre>argocd app create todo-app \<br>  --repo https://github.com/Sakshi9111/k8s-manifest-for-todo-app.git \<br>  --path kubernetes/base \<br>  --dest-server https://kubernetes.default.svc \<br>  --dest-namespace todo-app \<br>  --sync-policy automated \<br>  --auto-prune \<br>  --self-heal</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jIbeYnjgQG2PV-RiPTXtaA.png" /></figure><p>Now when a developer pushes changes to repo, it triggers jenkins build pipeline . The pipeline updates image in django-deployment.yaml inside the repo using this part in jenkins pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/877/1*XfO9R24KIeFfFCPlwnp-lg.png" /><figcaption>fig: jenkinsfile snippet for image update</figcaption></figure><h3>Step 7: See the Magic Happening✨</h3><p>Now for the moment of truth. Here’s what happens when a developer pushes code:</p><ol><li><strong>Developer commits and pushes</strong> to the application repo</li><li><strong>Jenkins webhook triggers</strong> the pipeline</li><li><strong>Pipeline runs</strong></li><li><strong>Docker image is built</strong> with a new tag (BUILD_NUMBER)</li><li><strong>Manifest repo is updated</strong> with the new image tag</li><li><strong>ArgoCD detects the change</strong></li><li><strong>New deployment rolls out</strong> automatically to your cluster</li></ol><p>Lets see it in images…</p><p>ArgoCD auto detects changes in repo and deploys the new changes to minikube</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xgGKrLSNpW8nzlGFrgOaAA.png" /></figure><p>You can see the resources getting deployed , some are syncing while some are already healthy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cZ2lBTzVlCOV1gnH6MTtTA.png" /></figure><p>This is how we can deploy django application to minikube using gitops approach.</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=183a3240a8da" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Zero-Cost Kubernetes Tutorial: Complete WSL Home Lab Setup for Beginners]]></title>
            <link>https://medium.com/@sakshi.ch496/zero-cost-kubernetes-tutorial-complete-wsl-home-lab-setup-for-beginners-96f4b9fac8ac?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/96f4b9fac8ac</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Mon, 22 Dec 2025 07:41:20 GMT</pubDate>
            <atom:updated>2025-12-31T10:33:02.862Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/858/1*i5t_N1POPRtyADXg4cn5bQ.png" /></figure><p>Learn Kubernetes the hands-on way without expensive cloud bills or complicated VirtualBox setup.</p><p>I was looking for way to learn kubernetes at zero cost and created home lab at zero cost.</p><p>By the end of this tutorial, you’ll have:</p><ul><li>A fully functional Kubernetes cluster running locally</li><li>Hands-on experience deploying a real Django todo application</li><li>Understanding of pods, services, and ingress controllers</li><li>A foundation for learning advanced Kubernetes concepts</li></ul><h4>Prerequisites</h4><ul><li>At least 8GB RAM</li><li>20GB free disk space</li><li>Visual Studio</li><li>Basic understanding of docker and linux</li></ul><p><strong>Step 1. Installing WSL 2 for Kubernetes</strong></p><p>WSL2 (Windows Subsystem for Linux 2) is a feature in Windows 11 that allows you to run a real Linux kernel in a lightweight virtual machine.</p><p>Follow this article to setup wsl on windows</p><p><a href="https://www.geeksforgeeks.org/installation-guide/how-to-install-wsl2-windows-subsystem-for-linux-2-on-windows-10/">https://www.geeksforgeeks.org/installation-guide/how-to-install-wsl2-windows-subsystem-for-linux-2-on-windows-10/</a></p><p><strong>Step 2. Setting Up Your First Cluster</strong></p><p>First install docker on wsl</p><pre>sudo apt-get remove docker docker-engine docker.io containerd runc<br>sudo apt-get update<br>sudo apt-get install \<br>    apt-transport-https \<br>    ca-certificates \<br>    curl \<br>    gnupg-agent \<br>    software-properties-common<br>curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -<br>sudo add-apt-repository \<br>   &quot;deb [arch=amd64] https://download.docker.com/linux/ubuntu \<br>   $(lsb_release -cs) \<br>   stable&quot;<br>sudo apt-get update<br>sudo apt-get upgrade -y<br>sudo apt-get install docker-ce docker-ce-cli containerd.io -y</pre><p>Install and Configure Minikube</p><pre>curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb<br>sudo apt install ./minikube_latest_amd64.deb -y<br>rm minikube_latest_amd64.deb</pre><p>🚂 Start Minikube</p><pre>minikube start</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/965/1*L0ri2bM4QZvYQFzQpG3-1g.png" /></figure><p>You can check dashboard of minikube which shows pod lists. Run command</p><pre>minikube dashboard</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IvNyaxKMI1_hQl5a7obAVQ.png" /></figure><p><strong>Step 3. Kubectl Preparation</strong></p><p>kubectl is the primary tool for interacting with Kubernetes clusters.</p><p>🔐<em>Add new k8s key</em></p><pre>sudo mkdir -p /etc/apt/keyrings<br><br>curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key \<br>| sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg</pre><p>📦Add k8s repo and update packages</p><pre>echo &quot;deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] \<br>https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /&quot; \<br>| sudo tee /etc/apt/sources.list.d/kubernetes.list<br><br>sudo apt update</pre><p>📥Install k8s tools and verify kubectl version</p><pre>sudo apt install -y kubectl kubeadm kubelet<br><br>kubectl version --client</pre><h4><strong>Step 4. Deploying Your First Application</strong></h4><p>After minikube is setup on wsl. Now its time to deploy your very first application on k8s. Clone the appliction from git repo which is todo-application for only deployment purpose on wsl.</p><pre>git clone https://github.com/Sakshi9111/todo-app.git</pre><p>This repository contains a Django-based todo application designed for Kubernetes deployment.</p><p><strong>Next clone the manifest files for deployment.</strong></p><pre>git clone https://github.com/Sakshi9111/k8s-manifest-for-todo-app.git<br>cd k8s-manifest-for-todo-app</pre><p>These YAML files define how our application will run in Kubernetes.</p><p>✉️ <strong>Create a namespace</strong> for todo application applying namespace.yaml inside folder namespace.</p><pre>kubectl apply -f namespace.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fgYAZsjKRJz3UD6enpJmzw.png" /></figure><p>Verify if namespace is created</p><pre>kubectl get ns</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*lwgNw5pKbUnzR56zNMD5iw.png" /></figure><p><strong>Creating secrets</strong> for both database [postgres] and app. I am not adding apply commands as I am pretty sure you won’t need it and do it on your own by now 👍</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*ROn14HKTA3jAk4KDcrTzjA.png" /></figure><p><strong>Create volume</strong> for database</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sdy6NWqnZoaWldy2Dut_hQ.png" /></figure><p>Now deploy postgres database and verify if it is created in todo-app namespace.</p><p><em>Note: For postgres deployment were are using StatefulSet for deployment as it provides stable pod and stable storage for critical database data.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CZ5fUKZEJeHRb0IeOEssVQ.png" /></figure><p>To <strong>expose the database</strong> pod with service apply postgres-service.yaml</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WuvoBdVQB38OnwBh6XB5RQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*vRKmY1XXc5h60Ul5noipoQ.png" /></figure><p><strong>Now create the pod</strong> for django application</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wu68FlV8ABH9uNBSGjL3Ew.png" /></figure><p><strong>Expose application</strong> using service. So now we have two services , one for exposing the database and another for exposing application pod.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VCIAPxRwKHWoyiX37NzNvw.png" /></figure><p>However these pods are accessible only inside minikube[k8s cluster]. To access application from browser we have to expose it outside of cluster using ingress. There are other options to expose it externally.</p><p>🌐 For this lab we will go with ingress and see the live application hosted on wsl minikube .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AzqH92fgThHsFMqlJW71iw.png" /></figure><p>Alright so you can see now ingress exposing the application with hosts todo.local that is domain name for application.</p><p><strong>Get clusterIP</strong></p><pre>minikube ip</pre><p>Add <strong>clusterIP to /etc/hosts</strong>. This will add todo.local is wsl’s domain list.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iC7H7HLMetUQZ4VX9ljXjA.png" /></figure><p>While you can access using domain todo.local on wsl . To acccess it from browser we have to port forward the the django-service.</p><pre>kubectl port-forward -n todo-app service/django-service 8000:8000 --address=0.0.0.0</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DyzbyRL5ELAcq-TmNymJ-Q.png" /></figure><p><strong>On Browser:</strong> <a href="http://todo.local:8000/">http://todo.local:8000</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lUQjlCm0S47KyrY5YT0Uog.png" /></figure><p><strong>Congratulations</strong>, you have deployed a end-to-end django application on minikube [wsl] at no cost.</p><p>✋ <em>follow for more such articles.</em></p><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96f4b9fac8ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Setup On Ec2 and Deploying an Nginx pod]]></title>
            <link>https://medium.com/@sakshi.ch496/kubernetes-setup-on-ec2-and-deploying-an-nginx-pod-2e9f893beb77?source=rss-d85724583928------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e9f893beb77</guid>
            <dc:creator><![CDATA[Sakshi Chaudhary]]></dc:creator>
            <pubDate>Tue, 16 Dec 2025 06:22:46 GMT</pubDate>
            <atom:updated>2025-12-16T10:14:55.803Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*YMgVyTV1NM3mVXgE.png" /></figure><p>This lab is setup is in three phase. It gives you hands on lab experience for k8s and understading of how master and worker node work together in kubernetes. In first phase we create instances and attach necessary security group. In phase 2 we install and setup master node and worker node. In phase three we deploy and access a nginx app along with understanding how the internal stuff are working.</p><p>Lets start with creating ec2 instance for master and workers.</p><p>Prerequisite 🌟</p><ol><li>Access to AWS account</li><li>AWS cli installed on local to create aws resources</li></ol><h3>Phase I 🗽</h3><ol><li>Get Ubuntu 20.04 LTS AMI ID</li></ol><pre>aws ec2 describe-images \<br>  --owners 099720109477 \<br>  --filters &quot;Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*&quot; &quot;Name=state,Values=available&quot; \<br>  --query &quot;Images | sort_by(@, &amp;CreationDate)[-1].ImageId&quot; \<br>  --region us-east-1 --output text</pre><p>2. Create Security Group for Master Node</p><pre>aws ec2 create-security-group \<br>  --group-name k8s-master-sg \<br>  --description &quot;Security group for Kubernetes master node&quot; \<br>  --vpc-id vpc-xxxxxxxx</pre><p>3.Security Group of master node</p><pre>aws ec2 authorize-security-group-ingress --group-name k8s-master-sg --protocol tcp --port 22 --cidr YOUR_IP/32<br>aws ec2 authorize-security-group-ingress --group-name k8s-master-sg --protocol tcp --port 6443 --cidr 0.0.0.0/0<br>aws ec2 authorize-security-group-ingress --group-name k8s-master-sg --protocol tcp --port 2379-2380 --cidr 0.0.0.0/0<br>aws ec2 authorize-security-group-ingress --group-name k8s-master-sg --protocol tcp --port 10250 --cidr 0.0.0.0/0<br>aws ec2 authorize-security-group-ingress --group-name k8s-master-sg --protocol tcp --port 10251 --cidr 0.0.0.0/0<br>aws ec2 authorize-security-group-ingress --group-name k8s-master-sg --protocol tcp --port 10252 --cidr 0.0.0.0/0</pre><p>4. Launch Master Node</p><pre>aws ec2 run-instances \<br>  --image-id ami-xxxxxxxxxxxxxxx \<br>  --count 1 \<br>  --instance-type t3.medium \<br>  --key-name YourKeyPairName \<br>  --security-groups k8s-master-sg \<br>  --block-device-mappings &#39;[{&quot;DeviceName&quot;:&quot;/dev/sda1&quot;,&quot;Ebs&quot;:{&quot;VolumeSize&quot;:20,&quot;VolumeType&quot;:&quot;gp3&quot;}}]&#39; \<br>  --tag-specifications &#39;ResourceType=instance,Tags=[{Key=Name,Value=k8s-master}]&#39;</pre><p>5.Create Security Group for Worker Node</p><pre>aws ec2 create-security-group \<br>  --group-name k8s-worker-sg \<br>  --description &quot;Security group for Kubernetes worker nodes&quot; \<br>  --vpc-id vpc-xxxxxxxx</pre><p>6. Add inbound Rule</p><pre>aws ec2 authorize-security-group-ingress --group-name k8s-worker-sg --protocol tcp --port 22 --cidr YOUR_IP/32<br>aws ec2 authorize-security-group-ingress --group-name k8s-worker-sg --protocol tcp --port 10250 --cidr 0.0.0.0/0<br>aws ec2 authorize-security-group-ingress --group-name k8s-worker-sg --protocol tcp --port 30000-32767 --cidr 0.0.0.0/0</pre><p>7. Launch Worker Node</p><pre>aws ec2 run-instances \<br>  --image-id ami-xxxxxxxxxxxxxxx \<br>  --count 2 \<br>  --instance-type t3.small \<br>  --key-name YourKeyPairName \<br>  --security-groups k8s-worker-sg \<br>  --block-device-mappings &#39;[{&quot;DeviceName&quot;:&quot;/dev/sda1&quot;,&quot;Ebs&quot;:{&quot;VolumeSize&quot;:20,&quot;VolumeType&quot;:&quot;gp3&quot;}}]&#39; \<br>  --tag-specifications &#39;ResourceType=instance,Tags=[{Key=Name,Value=k8s-worker}]&#39;</pre><p>We will now have three server one for master and two for woker.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DqNhhIHGuzfBT-IyQk_OMQ.png" /></figure><p>Now connect to ec2 instance and update the server.</p><pre>sudo apt update &amp;&amp; sudo apt upgrade -y</pre><p>2. Setup hostname to identify servers</p><pre># On master node<br>sudo hostnamectl set-hostname k8s-master<br><br># On worker nodes<br>sudo hostnamectl set-hostname k8s-worker-1<br>sudo hostnamectl set-hostname k8s-worker-2</pre><p>3. Update /etc/hosts with the name of worker and master as DNS Name</p><pre>sudo nano /etc/hosts<br><br>&lt;master-private-ip&gt; k8s-master<br>&lt;worker1-private-ip&gt; k8s-worker-1<br>&lt;worker2-private-ip&gt; k8s-worker-2</pre><p>Verify with ping command</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*UN4kPTEc7LROGcRcxlotxQ.png" /></figure><p>4. Install Docker Dependencies</p><pre>sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release -y</pre><pre>curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg<br><br>echo &quot;deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable&quot; | sudo tee /etc/apt/sources.list.d/docker.list &gt; /dev/null</pre><pre>sudo apt update<br>sudo apt install docker-ce docker-ce-cli containerd.io -y</pre><pre>sudo mkdir /etc/docker<br>cat &lt;&lt;EOF | sudo tee /etc/docker/daemon.json<br>{<br>  &quot;exec-opts&quot;: [&quot;native.cgroupdriver=systemd&quot;],<br>  &quot;log-driver&quot;: &quot;json-file&quot;,<br>  &quot;log-opts&quot;: {<br>    &quot;max-size&quot;: &quot;100m&quot;<br>  },<br>  &quot;storage-driver&quot;: &quot;overlay2&quot;<br>}<br>EOF</pre><pre>sudo systemctl enable docker<br>sudo systemctl daemon-reload<br>sudo systemctl restart docker</pre><pre>sudo usermod -aG docker $USER</pre><h3><strong>Phase II 👆</strong></h3><p>swap should be disabled on all server that is both on master node and worker node. If swap is on kubelet will not start.</p><pre>sudo swapoff -a<br>sudo sed -i &#39;/ swap / s/^\(.*\)$/#\1/g&#39; /etc/fstab</pre><p>Now install Kubernetes</p><pre># Remove old repository if it exists<br>sudo rm -f /etc/apt/sources.list.d/kubernetes.list<br>sudo rm -f /usr/share/keyrings/kubernetes-archive-keyring.gpg<br><br># Create keyrings directory and add new Kubernetes repository<br>sudo mkdir -p /etc/apt/keyrings<br>curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg<br><br>echo &#39;deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /&#39; | sudo tee /etc/apt/sources.list.d/kubernetes.list</pre><p>Supporting tool for Kubernetes</p><pre>sudo apt update<br>sudo apt install kubelet kubeadm kubectl -y<br>sudo apt-mark hold kubelet kubeadm kubectl<br>sudo systemctl enable kubelet</pre><p>Add necessary Bridge Kernel Module</p><pre>sudo modprobe br_netfilter<br>sudo modprobe ip_vs<br>sudo modprobe ip_vs_rr<br>sudo modprobe ip_vs_wrr<br>sudo modprobe ip_vs_sh</pre><p>To make module persistent add these in k8s.conf</p><pre>cat &lt;&lt;EOF | sudo tee /etc/modules-load.d/k8s.conf<br>br_netfilter<br>ip_vs<br>ip_vs_rr<br>ip_vs_wrr<br>ip_vs_sh<br>EOF</pre><pre>cat &lt;&lt;EOF | sudo tee /etc/sysctl.d/k8s.conf<br>net.bridge.bridge-nf-call-ip6tables = 1<br>net.bridge.bridge-nf-call-iptables = 1<br>net.ipv4.ip_forward = 1<br>EOF<br><br>sudo sysctl --system</pre><p>Now we have to get token from master node and use it to join worker node to master node following below steps</p><ol><li>Initialise Cluster and create config for kube [<strong>on master node</strong>]. This will bootstrap the kubernetes control plane, creates api, etcd, scheduler and control manager . After that install flannel which allows pod-to-pod communication.</li></ol><pre>sudo kubeadm init --pod-network-cidr=10.244.0.0/16<br>mkdir -p $HOME/.kube<br>sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config<br>sudo chown $(id -u):$(id -g) $HOME/.kube/config</pre><pre>kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml</pre><p>2. If token has expired create new token from master node then use the new command on the worker node.</p><pre>kubeadm token create --print-join-command [on master node]</pre><pre>kubeadm join &lt;master-ip&gt;:6443 --token &lt;token&gt; --discovery-token-ca-cert-hash sha25<br><br>6:&lt;hash&gt;</pre><p>3. Verify Successful Join of worker node with the control plane</p><pre>kubectl get nodes</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/643/1*LD0uOL3O8ZNWpNdm7yu6rQ.png" /></figure><h3>Phase III ✋</h3><p>After master node and worker node are ready lets deploy a nginx web app to access it from browser using nodePort service type.</p><h4>Deploying and Accessing Nginx WebApp</h4><p>On master node create nginx deployment. When we run deployment command kubectl command send request to API server. API server then stores the deployment object in etcd. Then controller detects new deployment and creates replicaset of desired replica. ReplicaSet controller then creates pod object but its only kube-scheduler which decides where pods should run based on CPU , memory availability.</p><pre>kubectl create deployment nginx-deployment --image=nginx:latest --replicas=3</pre><p>Expose the WebApp with NodePort service</p><pre>kubectl expose deployment nginx-deployment --type=NodePort --port=80 --target-port=80</pre><p>Master node will schedule nginx server on a worker node. Access the nginx from browser using ip on worker node.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c3dsReJWTlMny_8p3cpVng.png" /></figure><p>You might wonder how the nginx pods running on worker node got traffic when nginx deployment was created on master node. Traffic flow looks like this</p><pre>[Internet] <br>    ↓<br>[Master Node - Port 30565]<br>    ↓ <br>[kube-proxy iptables rules]<br>    ↓<br>[Load balancer decision]<br>    ↓<br>[Flannel overlay network]<br>    ↓<br>[Worker Node: 172.31.42.180]<br>    ↓<br>[nginx Pod: 10.244.1.27:80]</pre><p><em>💬 Enjoyed this post or found it helpful? Leave a comment and clap.</em></p><p><strong><em>About Sakshi:</em></strong><em> A cloud &amp; DevOps Engineer and technical writer with 5 + years of experience. Sakshi helps organisation implement with cost-effective infrastructure setup with security implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e9f893beb77" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>