<?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 Rishabh Pandey on Medium]]></title>
        <description><![CDATA[Stories by Rishabh Pandey on Medium]]></description>
        <link>https://medium.com/@0.all_existence.0?source=rss-d6a5a30dea20------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Stories by Rishabh Pandey on Medium</title>
            <link>https://medium.com/@0.all_existence.0?source=rss-d6a5a30dea20------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:05:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@0.all_existence.0/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[vSphere VM to KubeVirt VM: Complete Migration Guide]]></title>
            <link>https://medium.com/@0.all_existence.0/vsphere-vm-to-kubevirt-vm-complete-migration-guide-959c90ef5950?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/959c90ef5950</guid>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 12 Jul 2026 16:23:10 GMT</pubDate>
            <atom:updated>2026-07-13T03:00:50.615Z</atom:updated>
            <content:encoded><![CDATA[<h3>What’s This About?</h3><p>You have a virtual machine running on <strong>VMware ESXi</strong> (maybe a web server, database, or application), and you want to move it to <strong>Harvester HCI</strong> — an open-source hyperconverged infrastructure platform built on Kubernetes and <strong>KubeVirt</strong>.</p><blockquote><strong><em>Note:</em></strong><em> In this guide, I’m working with the free ESXi hypervisor (no vCenter license). The OVA export is done directly from the </em><strong><em>ESXi vSphere Web Console</em></strong><em> (the host UI at </em><em>https://&lt;esxi-ip&gt;).</em></blockquote><p>This guide covers the most reliable path: <strong>Export → Package → Serve → Import</strong>.</p><h3>Export Your VM from ESXi vSphere Console</h3><h3>Power Off the VM First</h3><p>Log into your ESXi host at https://&lt;esxi-ip&gt;. In the vSphere Web Console:</p><pre>Virtual Machines → Select LAMP-vm1<br>→ Actions → Power → Power Off</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yfyiSvsS7ImreFn7tkmBaA.png" /></figure><h3>Export as OVF</h3><p>Once the VM is powered off:</p><pre>Right-click VM → Export</pre><p>ESXi’s built-in exporter downloads multiple files to your computer:</p><p>File Purpose LAMP-vm1.ovf Descriptor tells Harvester the VM config , LAMP-vm1-1.vmdk Disk image the actual VM data, LAMP-vm1.mf Manifest checksums for integrity, LAMP-vm1.nvram BIOS/EFI settings</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wtVy2VnnPjm7NfSFCGqlyA.png" /></figure><h3>Package Files into OVA</h3><p>An <strong>OVA</strong> is just a<strong> </strong><strong>.tar</strong> archive of the files above.</p><h3>On macOS (avoid a common pitfall)</h3><p>macOS’s default tar adds hidden metadata (.DS_Store, __MACOSX) that <strong>corrupts the OVA</strong>. Use <strong>GNU tar</strong> instead:</p><pre># Install gnu-tar if needed<br>brew install gnu-tar</pre><pre># Navigate to your files<br>cd ~/Downloads/LAMP-vm1</pre><pre># Create OVA (GNU tar prevents Mac metadata corruption)<br>gtar cvf LAMP-vm1.ova \<br>  --format=ustar \<br>  LAMP-vm1.ovf \<br>  LAMP-vm1.mf \<br>  LAMP-vm1.nvram \<br>  LAMP-vm1-1.vmdk</pre><h3>On Linux/Windows (WSL)</h3><pre>cd ~/Downloads/LAMP-vm1</pre><pre>tar cvf LAMP-vm1.ova \<br>  LAMP-vm1.ovf \<br>  LAMP-vm1.mf \<br>  LAMP-vm1.nvram \<br>  LAMP-vm1-1.vmdk</pre><h3>Verify the OVA is Valid</h3><pre># Check OVF inside is readable XML<br>gtar xOf LAMP-vm1.ova LAMP-vm1.ovf | head -1</pre><p>Harvester needs to download the OVA. Simplest way: run a local web server on your machine.</p><pre>cd ~/Downloads/LAMP-vm1</pre><pre>python3 -m http.server 8080</pre><p>You’ll see:</p><pre>Serving HTTP on 0.0.0.0 port 8080 ...</pre><h3>Find Your Machine’s IP</h3><p><strong>Mac:</strong></p><pre>ipconfig getifaddr en0</pre><p><strong>Linux:</strong></p><pre>hostname -I</pre><p><strong>Windows:</strong></p><pre>ipconfig<br># Look for &quot;IPv4 Address&quot;</pre><h3>Test Reachability from Harvester</h3><p>SSH into a Harvester node and confirm it can reach the file:</p><pre>curl -I http://192.16.10.32:8080/LAMP-vm1.ova</pre><pre># Should return:<br># HTTP/1.0 200 OK<br># Content-Length: 2900000000</pre><h3>Create OvaSource in Harvester</h3><p>Tell Harvester where to find your OVA. Create a YAML file:</p><p><strong>File: </strong><strong>ova-source.yaml</strong></p><pre>apiVersion: migration.harvesterhci.io/v1beta1<br>kind: OvaSource<br>metadata:<br>  name: lamp-ova<br>  namespace: default<br>spec:<br>  url: &quot;http://192.xxx.x.xx:8080/LAMP-vm1.ova&quot;<br>  httpTimeoutSeconds: 600</pre><h3>Apply It</h3><pre>kubectl apply -f ova-source.yaml</pre><pre># Verify<br>kubectl get ovasource.migration</pre><h3>Create VirtualMachineImport</h3><p>This is where the magic happens — Harvester begins converting your VMware VM into a KubeVirt VM.</p><p><strong>File: </strong><strong>vm-import.yaml</strong></p><pre>apiVersion: migration.harvesterhci.io/v1beta1<br>kind: VirtualMachineImport<br>metadata:<br>  name: lamp-vm1<br>  namespace: default<br>spec:<br>  virtualMachineName: &quot;LAMP-vm1&quot;<br>  networkMapping:<br>  - sourceNetwork: &quot;VM Network&quot;<br>    destinationNetwork: &quot;default/untagged-nw&quot;<br>  defaultNetworkInterfaceModel: &quot;virtio&quot;<br>  defaultDiskBusType: &quot;scsi&quot;<br>  sourceCluster:<br>    name: lamp-ova<br>    namespace: default<br>    kind: OvaSource<br>    apiVersion: migration.harvesterhci.io/v1beta1</pre><h3>What Each Field Does</h3><p>Field Meaning virtualMachineName Name of the source VM inside the OVA networkMapping Maps old network (VM Network in ESXi) → new network (untagged-nw in Harvester) defaultNetworkInterfaceModel virtio for better KVM performance defaultDiskBusType scsi to match ESXi&#39;s original disk bus</p><h3>Apply It</h3><pre>kubectl apply -f vm-import.yaml</pre><h3>Watch the Import Happen</h3><h3>Real-Time Status</h3><pre>kubectl get virtualmachineimport.migration -w</pre><h3>Detailed Controller Logs</h3><pre>kubectl logs -n harvester-system \<br>  deployment/vm-import-controller -f</pre><h3>What Happens Behind the Scenes</h3><p>Here’s the actual timeline from my successful import:</p><pre>05:11  Running preflight checks                    ✅<br>05:11  Sanitizing the import spec                  ✅<br>05:11  Shutting down source VM (already off)       ✅<br>05:11  Downloading OVA from HTTP server            ⏳<br>05:13  Parsed OVF: disk 50GB, bus scsi             ✅<br>05:29  Extracting VMDK from OVA                    ✅<br>05:29  Converting VMDK → RAW image                 ✅<br>05:30  Creating Harvester VirtualMachineImage      ✅<br>05:30  Evaluating &amp; uploading to Longhorn          ⏳<br>05:32  Parsed VM config:<br>        - CPU: 2 vCPU<br>        - RAM: 2048MB<br>        - Firmware: UEFI + SecureBoot<br>        - NIC: virtio → VM Network                 ✅<br>05:32  Creating PVC (Longhorn storage)             ✅<br>05:34  VM imported successfully!                   🎉</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L6ai6px_yTu3kptNKBgr7w.png" /></figure><h3>Verify in Harvester UI</h3><p>Open the Harvester dashboard:</p><pre>Harvester UI → Virtual Machines<br>→ Look for &quot;LAMP-vm1&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BWxjQ5TXjn36Z_VcLYNtxA.png" /></figure><p><strong>Reference:</strong></p><p><a href="https://docs.harvesterhci.io/v1.8/advanced/addons/vmimport/">https://docs.harvesterhci.io/v1.8/advanced/addons/vmimport/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=959c90ef5950" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OpenClaw and Virtualisation Infrastructure — Talking to Harvester HCI Like a Human]]></title>
            <link>https://medium.com/@0.all_existence.0/openclaw-and-virtualisation-infrastructure-talking-to-harvester-hci-like-a-human-52fb4a502f10?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/52fb4a502f10</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[openclaw]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 14 Jun 2026 16:43:29 GMT</pubDate>
            <atom:updated>2026-06-23T07:46:53.280Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nlP87deQbYb3GfIM8p6SeQ.png" /></figure><p>I have a two-node Harvester cluster and It runs VMs, manages storage and handles whatever workloads I throw at it. Just a clean, simple HCI setup doing its job quietly in the background.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RR5j4H5fFZjxW-B5RF53YQ.png" /></figure><p>But here’s the thing. Every time I want to know what’s running, I’m back at the keyboard. <strong>kubectl get vms -A</strong>. Tab through the Harvester UI. Check the namespace. Check the node. It’s fine. It works. It’s just… friction.</p><p>Then I installed <strong>OpenClaw </strong>and something clicked.</p><h3>What is OpenClaw?</h3><p>It’s a <strong>self-hosted AI agent</strong> that runs on your own machine. No SaaS subscriptions. No data leaving to someone else’s cloud unless you choose it to. You bring your own LLM API key OpenAI, Anthropic, xAI, your call — and OpenClaw becomes a personal assistant that actually lives on your infrastructure, not above it.</p><p>It runs quietly as a daemon in the background. You open a terminal, type a question and it answers. It can reach out to external systems, call tools and take real actions on your behalf.</p><p>Which immediately got me thinking: <em>can I point this at my Harvester cluster?</em></p><h3>MCP — The Universal Plug Socket</h3><p><strong>MCP</strong> stands for <strong>Model Context Protocol</strong>. Here’s the simplest way I can explain it.</p><p>Before MCP, if you wanted an AI to talk to some external system your Kubernetes cluster, your database, your calendar you had to write a custom plugin. Wire it into that specific agent’s API. Match its exact interface and then maintain that integration forever, for every agent you wanted to use.</p><p>Every AI tool had its own plugin format. Nothing talked to anything else.</p><p>MCP changes that. It’s an <strong>open standard</strong> that any AI agent can speak and any tool can implement. You build an MCP server once, and it works with OpenClaw, Claude Desktop, Cursor or any other MCP-compatible agent. The agent discovers what tools are available automatically no bespoke integration code, no glue scripts.</p><p>In plain terms: <strong>MCP is how OpenClaw learns what it’s allowed to do with your infrastructure.</strong></p><h3>The Missing Piece — A Harvester MCP Server</h3><p>I went looking, and found exactly what I needed:</p><p><a href="https://github.com/starbops/harvester-mcp-server">https://github.com/starbops/harvester-mcp-server</a></p><p>The full picture:</p><p>You<br> └─▶ OpenClaw (AI agent, running on your Mac)<br> └─▶ Harvester MCP Server (local binary, your machine)<br> └─▶ Harvester Kubernetes API (your cluster)</p><p>Ask OpenClaw how many VMs are running. It calls the MCP server. The MCP server hits <strong>/apis/kubevirt.io/v1/virtualmachines</strong>. You get a plain English answer. No <strong>kubectl</strong>. No namespace flags. No YAML hunting.</p><h3>Setting It Up</h3><p>Build the MCP Server<br>You need <strong>Go 1.23+</strong>. On macOS:</p><pre>git clone https://github.com/starbops/harvester-mcp-server.git<br><br>make build<br>mkdir -p bin<br>go build -o bin/harvester-mcp-server ./cmd/harvester-mcp-server</pre><p><strong>Get Your Harvester Kubeconfig</strong></p><pre>scp rancher@&lt;harvester-vip&gt;:/etc/rancher/rke2/rke2.yaml ~/.kube/harvester.yaml<br><br>##change server address<br><br># Verify both nodes are reachable<br>KUBECONFIG=~/.kube/harvester.yaml kubectl get nodes</pre><p><strong>Install OpenClaw</strong></p><pre>curl -fsSL https://openclaw.ai/install-cli.sh | bash<br><br>#The installer bundles its own Node runtime and drops everything under ~/.openclaw/.<br>#Add it to your PATH:<br><br>echo &#39;export PATH=&quot;$HOME/.openclaw/bin:$PATH&quot;&#39; &gt;&gt; ~/.zshrc<br>source ~/.zshrc<br><br>openclaw --version<br># OpenClaw 2026.6.6<br><br>#Onboard<br>openclaw onboard --install-daemon</pre><p>A full interactive wizard launches in your terminal. It asks for your <strong>LLM provider</strong> — OpenAI, Anthropic, xAI and your API key. Skip channels (Telegram, Discord, WhatsApp) and skip skills for now. You don’t need any of that to talk to Harvester.</p><p>At the end it asks how you want to hatch your agent. Pick <strong>Hatch in Terminal</strong> to see it come alive immediately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JGGYth5OaJ4mFZ88Rfq3NA.png" /></figure><p>OpenClaw installs itself as a <strong>background daemon</strong> on macOS via <strong>launchd </strong>so it survives reboots without you thinking about it.</p><h4>The Dashboard</h4><p>Once the gateway is running, you can also access a full web UI:</p><pre>openclaw gateway run<br>openclaw dashboard</pre><p>It opens in your browser. You get a full chat interface, session history, and tool visibility — the same agent, just with a proper UI instead of a terminal prompt.</p><p><strong>Wire in the Harvester MCP Server<br></strong>Here’s where it gets interesting. Instead of manually editing the JSON config and risking a syntax error, I just opened the OpenClaw chat and asked it to do it:</p><pre>openclaw chat<br><br>Add the harvester MCP server to my config. The binary is at <br>/Users/yourname/harvester-mcp-server/bin/harvester-mcp-server <br>and the kubeconfig is at /Users/yourname/.kube/harvester.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e4_mIfuQTL96nZmMwnBXlQ.png" /></figure><p>It then wrote the <strong>mcpServers</strong> block directly into <strong>~/.openclaw/openclaw.json</strong>, verified the binary was executable, confirmed the kubeconfig file existed and replied:</p><blockquote>Done. I updated the MCP config to use: ... I also verified the server binary is executable and the kubeconfig file exists.</blockquote><h3>Talking to Harvester</h3><p>Open the agent:</p><pre>openclaw chat<br><br>#Then just ask<br><br>How many virtual machines are running in my Harvester cluster?<br>List all namespaces in the cluster<br>What pods are running in the harvester-system namespace?<br>Show me the details of VM st-mct-gpuvm01</pre><p>It works. You can see the response in the screenshot above.</p><p>OpenClaw takes the question, passes it to the LLM, the LLM calls the MCP server, the MCP server hits the Kubernetes API and back comes a clean summary. The entire stacktwo Harvester nodes, RKE2, Longhorn, KubeVirt becomes conversational.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cet__61-VKycM8FGNy4_nA.png" /></figure><h3>Worth It</h3><p>OpenClaw on your Mac. MCP in the middle. Harvester on the other end. Half an hour of setup for a fundamentally different relationship with your infrastructure.</p><p><strong><em>Two-node Harvester 1.8.0 cluster running RKE2, Longhorn. Simple setup, surprisingly fun to talk to.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52fb4a502f10" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Integrating Harvester with Rancher]]></title>
            <link>https://medium.com/@0.all_existence.0/integrating-harvester-with-rancher-1bc417ebb538?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/1bc417ebb538</guid>
            <category><![CDATA[cncf]]></category>
            <category><![CDATA[rancher]]></category>
            <category><![CDATA[harvesters]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 07 Jun 2026 09:24:30 GMT</pubDate>
            <atom:updated>2026-06-07T09:24:30.960Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>TL;DR:</em></strong><em> Integrating Harvester with Rancher was trickier than expected. Here’s what went wrong and how I fixed it.</em></p><h3>The Setup</h3><p>I’m running Harvester as my HCI platform, with Rancher v2.13.3 deployed on an RKE2 cluster inside a VM on Harvester itself. DNS is handled by an internal BIND server pointing <strong>rancher.dummy.com</strong> to the RKE2 VM IP and cert-manager is managing Rancher&#39;s TLS certs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u-amd-YoegkwauXejgB0MA.png" /></figure><h3>First Blocker — Harvester Can’t Find Rancher</h3><p>The very first thing that hit me was Harvester nodes not being able to resolve <strong>rancher.dummy.com</strong>. Makes sense, Harvester was using the corporate DNS servers (<strong>10.x.x.x., 10.x.x.x</strong>) which had no idea about my internal domain.</p><p><em>To add your internal BIND server to Harvester nodes, follow the official docs</em><a href="https://docs.harvesterhci.io/v1.8/install/update-harvester-configuration/#dns-servers"><em> link</em></a></p><p>Once DNS is sorted, verify its working from any Harvester node</p><p>The CoreDNS restart matters, it picks up the new <strong>/etc/resolve.conf</strong> so pods inside the cluster also get the updated DNS. One fix, two layers covered.</p><p>If you just want to test quickly without touching DNS, you can drop an <strong>/etc/hosts</strong> entry on each Harvester node. Once DNS was sorted, <strong>curl </strong><a href="https://rancher.dummy.com/ping"><strong>https://rancher.dummy.com/ping</strong></a> returned <strong>pong</strong> from the Harvester node. First win.</p><h3>The Cert Rabbit Hole</h3><p>This is where the real pain started. The <strong>cattle-cluster-agent </strong>the pod running in the <strong>cattle-system</strong> namespace on Harvester that is responsible for maintaining the connection between Harvester and Rancher, syncing cluster state and relaying management instructions crashed immediately after the integration was triggered</p><p>The first error was:</p><blockquote><strong>unable to read CA file from /etc/kubernetes/ssl/certs/serverca: open /etc/kubernetes/ssl/certs/serverca: no such file or directory</strong> <strong>Strict CA verification is enabled but encountered error finding root CA</strong></blockquote><p>The agent starts up and the very first thing it does is look for a trusted CA file on disk at <strong>/etc/kubernetes/ssl/certs/serverca</strong>. Think of this like a security guard checking his list of trusted ID issuers before letting anyone in. The file wasn’t there so the guard had no list. It logged the error but kept going, hoping to find the CA another way.</p><p>The second way it tries is by fetching the <strong>cacerts</strong> setting from Rancher itself at <a href="https://rancher.dummy.com/v3/settings/cacerts"><strong>https://rancher.dummy.com/v3/settings/cacerts</strong></a>. But before it can trust that response, it needs to verify Rancher’s TLS certificate first. And that’s where everything fell apart:</p><blockquote><strong>Certificate chain is not complete, please check if all needed intermediate certificates are included in the server certificate (in the correct order) and if the cacerts setting in Rancher either contains the correct CA certificate (in the case of using self signed certificates) or is empty (in the case of using a certificate signed by a recognized CA). error: tls: failed to verify certificate: x509: certificate signed by unknown authority</strong></blockquote><h3>How a Certificate Chain Actually Works</h3><p>Think of it like a chain of trust with three links:</p><p><strong>Root CA</strong> (the trusted authority) → <strong>Intermediate CA</strong> (optional, signs on behalf of root) → <strong>Leaf cert</strong> (the actual server certificate — rancher.dummy.com)</p><p>When an agent connects to a server, it receives the leaf cert. It then asks: <strong>“Who signed this?”</strong> It walks up the chain looking for a signer it recognises. If it reaches a CA it already trusts — job done, connection allowed. If it hits a dead end and finds nobody it recognises — rejected.</p><p>For this to work, two things must be true. First, the server must serve the <strong>full chain</strong> — leaf cert plus all the CA certs above it. Second, the client must have the <strong>root CA</strong> in its trusted store.</p><h3>What Was Actually Happening</h3><p>Rancher had been installed with a <strong>SelfSigned</strong> ClusterIssuer in cert-manager. Here’s the problem with that:</p><p><strong>rancher-selfsigned (ClusterIssuer)</strong> → Self-signed — generates a cert that signs ITSELF → <strong>tls-rancher-ingress cert</strong> → Issuer: empty — nobody signed it → CA: FALSE — it’s not a CA → No CA bundle — nothing for anyone to verify against</p><p>A self-signed ClusterIssuer doesn’t create a CA — it just stamps a certificate with its own signature and calls it done. There’s no parent authority, no chain, no bundle. It’s like printing your own ID card and signing it yourself. The security guard takes one look and says: <strong>“I don’t know who issued this — you’re not getting in.”</strong></p><p>On top of that, nginx was serving its built-in fallback cert — the infamous <strong>Acme Co / Kubernetes Ingress Controller Fake Certificate</strong> — because the real TLS secret was broken. So the agent wasn’t even seeing a Rancher cert at all.</p><p>Running an openssl check confirmed it:</p><pre>openssl s_client -connect rancher.dummy.com:443 -showcerts &lt;/dev/null 2&gt;/dev/null \<br>  | openssl x509 -noout -text | grep -E &quot;Issuer|CA&quot;<br><br># Issuer: O=Acme Co, CN=Kubernetes Ingress Controller Fake Certificate<br># CA:FALSE</pre><p>That “Acme Co” cert is nginx’s built-in fallback.</p><h3>The Fix — Building a Real Chain</h3><p>The solution was to build a proper CA-backed chain from scratch, with a real CA cert at the top that everyone could be told to trust.</p><p>First, a genuine CA certificate was created , one with <strong>isCA: true</strong> — using the existing self-signed issuer just as a one-time bootstrap:</p><pre>kubectl apply -f - &lt;&lt;EOF<br>apiVersion: cert-manager.io/v1<br>kind: Certificate<br>metadata:<br>  name: rancher-selfsigned-ca<br>  namespace: cattle-system<br>spec:<br>  isCA: true<br>  commonName: rancher-selfsigned-ca<br>  secretName: rancher-selfsigned-ca-secret<br>  issuerRef:<br>    name: rancher-selfsigned<br>    kind: ClusterIssuer<br>EOF</pre><p>Then came a gotcha — <strong>ClusterIssuers look for their backing secret in the cert-manager namespace</strong>, not wherever the certificate lives. Had to copy it across:</p><pre>kubectl get secret rancher-selfsigned-ca-secret -n cattle-system -o yaml \<br>  | sed &#39;s/namespace: cattle-system/namespace: cert-manager/&#39; \<br>  | kubectl apply -f -</pre><p>With the secret in the right place, a proper CA-backed ClusterIssuer was created and the Rancher ingress annotation updated to use it:</p><pre>kubectl apply -f - &lt;&lt;EOF<br>apiVersion: cert-manager.io/v1<br>kind: ClusterIssuer<br>metadata:<br>  name: rancher-ca-clusterissuer<br>spec:<br>  ca:<br>    secretName: rancher-selfsigned-ca-secret<br>EOF</pre><pre>kubectl edit ingress rancher -n cattle-system<br># cert-manager.io/cluster-issuer: rancher-selfsigned  →  rancher-ca-clusterissuer</pre><p>Deleting the old TLS secret forced cert-manager to regenerate it using the new issuer. But even then, the chain was still incomplete — <strong>cert-manager only puts the leaf cert in the secret, not the CA</strong>. Had to stitch them together manually:</p><pre>kubectl get secret tls-rancher-ingress -n cattle-system \<br>  -o jsonpath=&#39;{.data.tls\.crt}&#39; | base64 -d &gt; /tmp/leaf.crt</pre><pre>kubectl get secret rancher-selfsigned-ca-secret -n cert-manager \<br>  -o jsonpath=&#39;{.data.tls\.crt}&#39; | base64 -d &gt; /tmp/ca.crt</pre><pre>cat /tmp/leaf.crt /tmp/ca.crt &gt; /tmp/fullchain.crt</pre><pre>kubectl create secret tls tls-rancher-ingress \<br>  -n cattle-system \<br>  --cert=/tmp/fullchain.crt \<br>  --key=/tmp/rancher.key \<br>  --dry-run=client -o yaml | kubectl apply -f -</pre><pre>kubectl rollout restart daemonset/rke2-ingress-nginx-controller -n kube-system</pre><p>After the nginx restart, openssl finally showed <strong>two certificates</strong> in the chain and <strong>Issuer: CN=rancher-selfsigned-ca</strong>. Progress.</p><h3>The cacerts and Checksum Problem</h3><p>With the cert chain fixed, the agent was now able to see the correct issuer but still failing. The <strong>cacerts</strong> setting in Rancher was empty, so the agent had no CA to trust against.</p><p>Even with the chain being served correctly by the ingress, the agent also checks Rancher’s <strong>cacerts</strong> API setting as its source of truth for what CA to trust. Think of it as Rancher saying: <em>“Here is the CA cert I use — you should trust this.”</em> If it’s empty, the agent has nothing to verify against and rejects the connection.</p><p>Setting it sounds simple. It isn’t, because the cert has newlines and JSON doesn’t like those. After a few failed attempts with raw kubectl patch, <strong>jq</strong> turned out to be the clean solution:</p><pre>CERT=$(cat /tmp/ca.crt | jq -Rs .)<br>kubectl patch settings.management.cattle.io cacerts \<br>  --type=merge \<br>  -p &quot;{\&quot;value\&quot;: $CERT}&quot;</pre><p>Then came the final error — a checksum mismatch:</p><blockquote><strong><em>ERROR: Configured cacerts checksum (9bb…) does not match given — ca-checksum (f040beb2…)</em></strong></blockquote><p>The agent deployment carries a <strong>CATTLE_CA_CHECKSUM</strong> environment variable — a sha256 fingerprint of the expected CA cert. The checksum in the deployment was out of sync with the cert now in cacerts. Computing the sha256 of the CA cert and updating <strong>CATTLE_CA_CHECKSUM</strong> in the agent deployment to match was the final piece:</p><pre>cat /tmp/ca.crt | sha256sum | awk &#39;{print $1}&#39;</pre><pre>kubectl edit deployment cattle-cluster-agent -n cattle-system<br># Set CATTLE_CA_CHECKSUM to the sha256 output</pre><h3>Wiring It All Together</h3><p>With DNS resolving, the cert chain complete, <strong>cacerts</strong> set and the checksum matching, the actual integration from the UI was anticlimactic in a good way.</p><p>From Rancher:</p><p><strong>Virtualization Management → Import Existing → Harvester</strong> <br>generates a registration URL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qAx5umdDhGUdT3KHI1LyIw.png" /></figure><p>On the Harvester side, paste the CA cert into <br><strong>Settings → additional-ca</strong></p><p>and the registration URL into <br><strong>Settings → cluster-registration-url</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UWTKEUtXewpqLuik6BwQ8w.png" /></figure><p>Rancher UI shows <strong>harvester-cluster → State: Active</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jJB1zD75-h42yFLe5dTpvQ.png" /></figure><h3>References</h3><ul><li><a href="https://docs.harvesterhci.io/v1.8/install/update-harvester-configuration/#dns-servers">Harvester — Update DNS Server Configuration</a></li><li><a href="https://docs.harvesterhci.io/v1.7/rancher/rancher-integration/">Harvester — Rancher Integration</a></li><li><a href="https://docs.harvesterhci.io/v1.7/rancher/virtualization-management/">Harvester — Virtualization Management</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bc417ebb538" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Meets Virtualization: Installing Harvester on Bare Metal]]></title>
            <link>https://medium.com/@0.all_existence.0/kubernetes-meets-virtualization-installing-harvester-on-bare-metal-ed04c3ac10bc?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed04c3ac10bc</guid>
            <category><![CDATA[virtualization]]></category>
            <category><![CDATA[kubevirt]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 22 Mar 2026 04:24:42 GMT</pubDate>
            <atom:updated>2026-03-22T04:25:35.981Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Introduction</strong></h3><p>Setting up a local lab is one of the best ways to learn modern infrastructure hands-on. In this guide, I walk through how I installed <strong>Harvester</strong> on a Mini PC and built a simple air-gapped environment.</p><p>I installed <strong>Harvester</strong> version v1.7, configured static networking, and successfully brought up a single-node cluster that I could access and explore locally. The setup was done using a bootable USB and a direct LAN connection between my laptop and the Mini PC with x86_64 architecture, allowing me to access the Harvester UI without internet access.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k33ZmME7Qzg035vTNpsncA.png" /></figure><h4>What is Harvester?</h4><p><a href="https://docs.harvesterhci.io/v1.7/">Harvester</a> is a modern, open-source hyperconverged infrastructure (HCI) platform built on Kubernetes. It runs on bare metal and provides built-in virtualization and distributed storage, allowing you to run virtual machines alongside containerized workloads.</p><p>It also integrates with Rancher for cluster management and helps bridge traditional VM-based infrastructure with modern cloud-native applications.</p><h4>Prerequisites:</h4><p>Before getting started, I made sure my Mini PC met the basic requirements for a lab setup:</p><pre> CPU with virtualization support (Intel VT-x / AMD-V)<br> At least 16 GB RAM (I had ~31 GB)<br> SSD storage (NVMe in my case)<br> UEFI boot enabled in BIOS<br> USB boot enabled</pre><p>On the software side, I downloaded the Harvester v1.7 ISO and used balenaEtcher to create a bootable USB.</p><h4>Getting the Network Ready:</h4><p>Since the setup was completely air-gapped, I connected my laptop directly to the Mini PC using a LAN cable — no router, no DHCP, just a simple point-to-point network. To make this work, I manually assigned static IP addresses on both systems so they could communicate over the same subnet.</p><p>On the Mini PC (running Ubuntu before installation), I configured the network interface:</p><pre>sudo ip addr add x.x.x.50/24 dev eno1<br>sudo ip link set eno1 up</pre><p>On my PC, I set:</p><pre>IP: x.x.x.10<br>Subnet: 255.255.255.0</pre><p>With both machines configured, I verified connectivity using a quick ping test from my Mac:</p><pre>ping x.x.x.50</pre><p>Getting successful replies confirmed that the direct connection was working as expected a small but critical step before proceeding with the Harvester installation.</p><h4>Booting into the Installer</h4><p>After flashing the ISO to a USB drive, I plugged it into the Mini PC and entered the BIOS.</p><p>By default, most systems try to boot from the internal disk or even attempt a network boot (PXE), which often results in messages like <strong>“Start PXE over IPv4”.</strong> To avoid this, I adjusted the boot priority and set the USB drive as the first boot device.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2eVrCLqWTgflN7ONqzEkZw.jpeg" /></figure><p><strong>Boot from USB</strong></p><p>I inserted the USB into the Mini PC and powered it on.</p><p>Why change boot order?</p><p>By default, systems boot in this order:</p><pre>1. Internal Disk<br>2. Network (PXE)<br>3. USB</pre><p>If USB is not first:</p><p>System skips USB<br>Falls back to PXE<br>Shows: “Start PXE over IPv4”</p><p><strong>Fix Boot Order<br></strong>Enter BIOS (F10 / F12 / ESC) and set:</p><pre>1. USB<br>2. Internal Disk<br>3. Network Boot</pre><p>Also recommended:</p><pre>Disable Fast Boot<br>Disable Network Boot (PXE)</pre><h4><strong>Installation Experience (with Technical Details)</strong></h4><p>Once the system booted into the Harvester installer, the process was clean and guided. I selected <strong>“Create a new Harvester cluster” </strong>and proceeded with the core configuration.</p><p>At a high level, the inputs are simple but each one maps to important underlying components in Harvester (Kubernetes + KubeVirt + Longhorn).</p><p><strong>Cluster Initialization</strong></p><p>I chose to bootstrap a single-node cluster, which internally initializes:</p><ul><li>Kubernetes control plane</li><li>Embedded etcd</li><li>Longhorn storage engine</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fIsVa7D0Qt8jVa4s_j8u3Q.jpeg" /></figure><p>Basic details configured:</p><ul><li>Hostname: node1</li><li>User: …………</li><li>Cluster token: used for node join (even though single-node)</li><li>Disk Configuration</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EVjrR_6xKGQrjSKtEuciHQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o1SXC73_ROZ9CjhA8p4jgA.jpeg" /></figure><p>I used the same SSD for both OS and data:</p><ul><li>Installation Disk: primary SSD</li><li>Data Disk: same device</li><li>Persistent Storage: ~60GB allocated</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yjOZs8A-BVBSlA1z3Prdug.jpeg" /></figure><p><strong>Under the hood:</strong></p><p>Harvester installs a minimal OS (based on SLE Micro) Longhorn uses the data disk to create distributed volumes (even in single node mode)</p><p>⚠ This step wipes any existing OS (Ubuntu in my case)</p><p><strong>Network Configuration (Critical in Air-Gapped Setup)<br></strong>Since there was no DHCP, I configured a static network on <strong>eno1:</strong></p><pre>IP: x.x.x.50<br>Subnet: 255.255.255.0<br>Gateway: 192.168.1.1 (dummy)<br>DNS: 192.168.1.1 (dummy)</pre><p>Key points:</p><ul><li>Static IP is mandatory for predictable access</li><li>Gateway/DNS are required by installer validation, even if unused</li><li>This IP becomes the node’s management endpoint</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Q6rra2wPGtDxAlZbO0aKw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fl4c1KXNDDHZlACWNywEzw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8gIcj38AcD0DEK4Wj13oIg.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NKNqKvFDt7BnNI4Gqbgikg.jpeg" /></figure><p><strong>Virtual IP (VIP)</strong></p><p>I configured a VIP: x.x.x.100</p><p>Technical role:</p><ul><li>Acts as a stable endpoint for the cluster</li><li>In multi-node setups → managed via kube-vip</li><li>In single-node → still useful as a consistent access point</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s49UDWNJ7Ol39We4tQKkfQ.jpeg" /></figure><p><strong>Kubernetes Network Defaults</strong></p><p>I kept the default CIDR ranges:</p><ul><li>Pod CIDR: 10.42.0.0/16</li><li>Service CIDR: 10.43.0.0/16</li></ul><p>These are provisioned via:</p><ul><li>CNI (Canal/Flannel depending on version)</li><li>kube-proxy for service routing</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LAwhWocFZ52PrxaqB5DxHw.jpeg" /></figure><p><strong>Other Settings</strong></p><ul><li>NTP: left default (warnings expected in air-gapped mode)</li><li>Proxy: skipped</li><li>No external registry/mirror configured at this stage</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a_vpuOE1ik1IjGJJK03iOA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WZDArnOw_A-BEITZ_SBObw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pbIscINSmtHSHhQv_pK_mg.jpeg" /></figure><p><strong>Installation Process</strong></p><p>Installation Process</p><p>After confirming the configuration, the installer:</p><ul><li>Partitions disks</li><li>Installs Harvester OS</li><li>Bootstraps Kubernetes cluster</li><li>Deploys core components</li><li>Longhorn (storage)</li><li>KubeVirt (VM runtime)</li><li>Harvester UI (management)</li></ul><p>The process took ~15–20 minutes, followed by an automatic reboot.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*xKD93GDZS34nHJciaHWzdw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4km2s1JoXD5-qPq02hSW6Q.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H6OPxSHbjnjuSKkSXxyFrA.jpeg" /></figure><p><strong>Accessing the UI</strong></p><p>From my laptop, I opened:</p><pre><br>https://x.x.x.100<br>(or the node IP)</pre><p>After accepting the self-signed certificate warning, I logged in using the admin user and the password I had set during installation.</p><p>Seeing the dashboard come up with the node in a Ready state confirmed that everything was working as expected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wP675kOxkld_x0dS0T6OoA.png" /></figure><h4>What Happens Behind the Scenes</h4><p>During installation, Harvester sets up a full stack automatically:</p><ul><li>A lightweight Kubernetes cluster (k3s)</li><li>KubeVirt for virtualization</li><li>Longhorn for distributed storage</li><li>Harvester services for UI and API</li></ul><p>All of this runs on a single node in this setup.</p><h4>Verifying the Setup</h4><p>To make sure everything was healthy, I checked:</p><pre>kubectl get nodes<br>kubectl get pods -A</pre><p>The node was in Ready state and all system pods were running, which confirmed a successful installation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/834/1*0Tq_MVwprSbFs5LsVCcq1A.png" /></figure><h4>Final Thoughts</h4><p>Setting up Harvester on a Mini PC turned out to be a great hands-on learning experience. It gave me a deeper understanding of Kubernetes-based virtualization, storage, and infrastructure management all in a controlled local environment.</p><p>If you’re looking to explore modern infrastructure without relying on cloud resources, this is a great place to start.</p><p>REFERENCES:-</p><p><a href="https://docs.harvesterhci.io/v1.7/install/index/">ISO Installation | Harvester</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed04c3ac10bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bootstrapping Rancher’s RKE2 Kubernetes Cluster on a Podman VM with Cilium CNI and MetalLB…]]></title>
            <link>https://medium.com/@0.all_existence.0/deploy-an-rke2-kubernetes-cluster-on-podman-vm-with-cilium-cni-and-metallb-loadbalancer-21c5e722555a?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/21c5e722555a</guid>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 12 Oct 2025 13:04:51 GMT</pubDate>
            <atom:updated>2025-10-12T16:10:29.673Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bootstrapping Rancher’s RKE2 Kubernetes Cluster on a Podman VM with Cilium CNI and MetalLB LoadBalancer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SyMxHpelkoVjbCD0RFaSng.png" /></figure><h3>Introduction</h3><p>In this blog, I share my experience of running a lightweight Kubernetes cluster using RKE2 with Cilium as the CNI and MetalLB as the load balancer, all inside a Podman VM on my Mac.</p><p>Using Podman VM for Kubernetes provides a convenient, low-overhead way to run container workloads natively on macOS without relying on heavyweight solutions. However, networking inside the VM and exposing LoadBalancer services entails unique challenges. Here, I detail the entire setup, including my chosen tarball-based installation of RKE2 and how I solved access to MetalLB services from my Mac.</p><h3>What I Performed</h3><ul><li>Provisioned and started a Podman VM with sufficient resources on macOS</li><li>Installed RKE2 via tarball (binary) installation to avoid RPM and filesystem issues common in immutable Fedora CoreOS-based Podman VM</li><li>Configured RKE2 to use Cilium container networking</li><li>Installed MetalLB load balancer to enable <strong>LoadBalancer </strong>service types.</li><li>Deployed an NGINX application exposed via MetalLB</li><li>Set up SSH port forwarding to forward MetalLB-assigned IP ports from the Podman VM to macOS</li><li>Verified external access from Mac Chrome browser to the NGINX app</li></ul><h3>Step-By-Step Setup</h3><h3>1. Create and Start Podman VM</h3><p>I created the VM with appropriate CPU, memory, and disk:</p><pre>podman machine init rke2-vm --cpus 6 --memory 12288 --disk-size 50<br>podman machine start rke2-vm<br>podman machine ssh rke2-vm</pre><h3>2. RKE2 Server with Custom config.yaml</h3><p>Create the RKE2 server configuration file<strong> /etc/rancher/rke2/config.yaml</strong> with the following content:</p><pre>write-kubeconfig-mode: &quot;0644&quot;<br><br>tls-san:<br>  - &quot;X.X.X.X&quot;   # VM IP for API server access<br><br>cni:<br>  - cilium<br><br>helm:<br>  charts:<br>    rke2-cilium: true<br>    rke2-metrics-server: true<br>    rke2-ingress-nginx: true<br>    rke2-coredns: true<br><br>node-name: &quot;rke2-node1&quot;<br><br>disable:<br>  - servicelb  # Disable RKE2 default service load balancer as MetalLB is used</pre><h3>3. Install RKE2 Using Tarball Installer</h3><p>Due to RPM and filesystem constraints on the Fedora CoreOS-based Podman VM, I opted to manually download and install RKE2 from the official GitHub tarball for ARM64</p><pre>curl -L -o rke2.tar.gz https://github.com/rancher/rke2/releases/download/v1.33.5+rke2r1/rke2.linux-arm64.tar.gz<br>sudo mkdir -p /opt/rke2<br>sudo tar -C /opt/rke2 -xzf rke2.tar.gz<br>sudo chmod +x /opt/rke2/bin/rke2</pre><h3>4. Configure RKE2 as a Systemd Service</h3><p>I created the systemd service file</p><pre>sudo tee /etc/systemd/system/rke2-server.service &gt; /dev/null &lt;&lt;&#39;EOF&#39;<br>[Unit]<br>Description=RKE2 Server<br>After=network.target<br><br>[Service]<br>Type=notify<br>ExecStart=/opt/rke2/bin/rke2 server --config /etc/rancher/rke2/config.yaml<br>Restart=always<br>RestartSec=5s<br>LimitNOFILE=1048576<br>LimitNPROC=1048576<br>Delegate=yes<br>KillMode=process<br>Environment=&quot;PATH=/opt/rke2/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin&quot;<br><br>[Install]<br>WantedBy=multi-user.target<br>EOF</pre><p>Set hostname and hosts mapping:</p><pre>sudo hostnamectl set-hostname rke2-node1<br>sudo bash -c &#39;echo &quot;127.0.0.1 rke2-node1&quot; &gt;&gt; /etc/hosts&#39;</pre><p>Handling SELinux Enforcement</p><p>The RKE2 server initially failed to start due to SELinux enforcing mode blocking operations, I temporarily disabled SELinux enforcement to allow RKE2 to run:</p><pre>getenforce<br># Output: Enforcing<br><br>sudo setenforce 0</pre><p>Reloaded systemd and enabled the service:</p><pre>sudo systemctl daemon-reload<br>sudo systemctl enable rke2-server<br>sudo systemctl start rke2-server</pre><pre>sudo systemctl status rke2-server<br>● rke2-server.service - RKE2 Server<br>     Loaded: loaded (/etc/systemd/system/rke2-server.service; enabled; preset: disabled)<br>    Drop-In: /usr/lib/systemd/system/service.d<br>             └─10-timeout-abort.conf, 50-keep-warm.conf<br>     Active: active (running) since Sun 2025-10-12 19:26:49 +08; 1h 1min ago<br> Invocation: 1e9e8fed05874b50ba2cffa2d218dca9<br>   Main PID: 16774 (rke2)<br>      Tasks: 259 (limit: 14126)<br>     Memory: 5.2G (peak: 5.2G)<br>        CPU: 4min 42.571s<br>     CGroup: /system.slice/rke2-server.service<br>             ├─ 4397 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 8a1d5c66c67cd9fec9&gt;<br>             ├─ 4595 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 65ada6eb389ed7df2e&gt;<br>             ├─ 4918 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 05f67de56a0a408cb2&gt;<br>             ├─ 4947 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 5f217e09f1e97f84e1&gt;<br>             ├─ 5091 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 31e239f813d2a351c0&gt;<br>             ├─ 5704 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id effd59fcc9500ca128&gt;<br>             ├─ 5717 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id e9ae94bfaf79c00004&gt;<br>             ├─16774 &quot;/opt/rke2/bin/rke2 server&quot;<br>             ├─16833 containerd -c /var/lib/rancher/rke2/agent/etc/containerd/config.toml<br>             ├─16982 kubelet --volume-plugin-dir=/var/lib/kubelet/volumeplugins --file-check-frequency=5s --sync-frequency=30s --cloud-provider=&gt;<br>             ├─17023 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 23666a593c3c33378a&gt;<br>             ├─18507 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 02a76f50410a06a65f&gt;<br>             ├─18517 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 9d2b6e2c56b67a8e63&gt;<br>             ├─19203 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 843772a64d8b1b4e4c&gt;<br>             ├─19358 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 986bb9344bd939dabb&gt;<br>             ├─20360 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id fb7d01791e9679c347&gt;<br>             ├─23075 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id b44c8b774792ca9071&gt;<br>             ├─23567 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 711046abc6b338598a&gt;<br>             └─23803 /var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin/containerd-shim-runc-v2 -namespace k8s.io -id 6512cfa03a9860116c&gt;</pre><h3><strong>5- Add kubectl and kubeconfig to path</strong></h3><p>To add <strong>kubectl</strong> and the RKE2-generated <strong>kubeconfig</strong> to your PATH and environment on your Podman VM or local Mac, here is what you can do:</p><pre>nano ~/.bashrc<br>export PATH=$PATH:/var/lib/rancher/rke2/data/v1.33.5-rke2r1-522501607126/bin<br>source ~/.bashrc</pre><pre>nano ~/.bashrc<br>export KUBECONFIG=/etc/rancher/rke2/rke2.yaml<br>source ~/.bashrc</pre><h3><strong>6- Verify setup</strong></h3><pre>$ kubectl get nodes<br>NAME         STATUS   ROLES                       AGE   VERSION<br>rke2-node1   Ready    control-plane,etcd,master   82m   v1.33.5+rke2r1<br><br>$ kubectl get pods -A<br>NAMESPACE        NAME                                                   READY   STATUS      RESTARTS      AGE<br>default          nginx-5869d7778c-gcck7                                 1/1     Running     0             63m<br>kube-system      cilium-fg9db                                           1/1     Running     0             81m<br>kube-system      cilium-operator-7dfbd8f499-9w6t9                       1/1     Running     9 (66m ago)   81m<br>kube-system      cloud-controller-manager-rke2-node1                    1/1     Running     1 (82m ago)   82m<br>kube-system      etcd-rke2-node1                                        1/1     Running     0             81m<br>kube-system      helm-install-rke2-ingress-nginx-mpjc5                  0/1     Completed   0             66m<br>kube-system      helm-install-rke2-metrics-server-gt842                 0/1     Completed   0             82m<br>kube-system      helm-install-rke2-runtimeclasses-hhzck                 0/1     Completed   0             82m<br>kube-system      helm-install-rke2-snapshot-controller-crd-qdbnq        0/1     Completed   0             82m<br>kube-system      helm-install-rke2-snapshot-controller-kdh4b            0/1     Completed   1             82m<br>kube-system      kube-apiserver-rke2-node1                              1/1     Running     0             82m<br>kube-system      kube-controller-manager-rke2-node1                     1/1     Running     0             82m<br>kube-system      kube-proxy-rke2-node1                                  1/1     Running     0             66m<br>kube-system      kube-scheduler-rke2-node1                              1/1     Running     0             82m<br>kube-system      rke2-coredns-rke2-coredns-6464f98784-q552p             1/1     Running     0             81m<br>kube-system      rke2-coredns-rke2-coredns-autoscaler-67bb49dff-btqwj   1/1     Running     0             81m<br>kube-system      rke2-ingress-nginx-controller-tfxph                    1/1     Running     0             65m<br>kube-system      rke2-metrics-server-75d485c65b-cvncd                   1/1     Running     0             66m<br>kube-system      rke2-snapshot-controller-696989ffdd-tcbhb              1/1     Running     0             66m<br>metallb-system   controller-58fdf44d87-gmq59                            1/1     Running     0             62m<br>metallb-system   speaker-rcqdh                                          1/1     Running     0             62m</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qmxNl9fe2V1FiU2x0BQ7nA.png" /></figure><h3>7. Install MetalLB Load Balancer</h3><p>To install MetalLB, apply the manifest:</p><pre>kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.15.2/config/manifests/metallb-native.yaml</pre><p>Created MetalLB IP pool and advertisement (metallb-config.yaml):</p><pre>apiVersion: metallb.io/v1beta1<br>kind: IPAddressPool<br>metadata:<br>  namespace: metallb-system<br>  name: default-address-pool<br>spec:<br>  addresses:<br>  -  Y.Y.Y.Y-x.x.x.x<br>---<br>apiVersion: metallb.io/v1beta1<br>kind: L2Advertisement<br>metadata:<br>  namespace: metallb-system<br>  name: example<br>spec:<br>  ipAddressPools:<br>  - default-address-pool</pre><h3><strong>8. Deploy NGINX and Expose via LoadBalancer</strong></h3><p>Deployed NGINX:</p><pre>kubectl create deployment nginx --image=nginx<br>kubectl expose deployment nginx --port=80 --type=LoadBalancer</pre><p>Checked MetalLB assigned external IP:</p><pre>core@rke2-node1:~$ kubectl get svc nginx<br>NAME    TYPE           CLUSTER-IP     EXTERNAL-IP       PORT(S)        AGE<br>nginx   LoadBalancer   10.43.112.94   192.168.127.240   80:32361/TCP   66m<br><br>core@rke2-node1:~$ kubectl describe svc nginx<br>Name:                     nginx<br>Namespace:                default<br>Labels:                   app=nginx<br>Annotations:              metallb.io/ip-allocated-from-pool: default-address-pool<br>Selector:                 app=nginx<br>Type:                     LoadBalancer<br>IP Family Policy:         SingleStack<br>IP Families:              IPv4<br>IP:                       10.43.112.94<br>IPs:                      10.43.112.94<br>LoadBalancer Ingress:     192.168.127.240 (VIP)<br>Port:                     &lt;unset&gt;  80/TCP<br>TargetPort:               80/TCP<br>NodePort:                 &lt;unset&gt;  32361/TCP<br>Endpoints:                10.42.0.236:80<br>Session Affinity:         None<br>External Traffic Policy:  Cluster<br>Internal Traffic Policy:  Cluster<br>Events:                   &lt;none&gt;</pre><p><strong>9. Setup SSH Port Forwarding from Podman VM to Mac</strong></p><p>Because Podman VM uses user-mode NAT networking, MetalLB IPs are not directly reachable from Mac.</p><p>Created an SSH tunnel forwarding port 18080 on Mac to MetalLB IP port 80 inside VM:</p><pre>ssh -i ~/.local/share/containers/podman/machine/machine -L 18080:192.168.127.240:80 core@127.0.0.1 -p 58090</pre><h4>10. Access NGINX in Mac Chrome</h4><p>Now open:</p><pre> curl localhost:18080<br>&lt;!DOCTYPE html&gt;<br>&lt;html&gt;<br>&lt;head&gt;<br>&lt;title&gt;Welcome to nginx!&lt;/title&gt;<br>&lt;style&gt;<br>html { color-scheme: light dark; }<br>body { width: 35em; margin: 0 auto;<br>font-family: Tahoma, Verdana, Arial, sans-serif; }<br>&lt;/style&gt;<br>&lt;/head&gt;<br>&lt;body&gt;<br>&lt;h1&gt;Welcome to nginx!&lt;/h1&gt;<br>&lt;p&gt;If you see this page, the nginx web server is successfully installed and<br>working. Further configuration is required.&lt;/p&gt;<br><br>&lt;p&gt;For online documentation and support please refer to<br>&lt;a href=&quot;http://nginx.org/&quot;&gt;nginx.org&lt;/a&gt;.&lt;br/&gt;<br>Commercial support is available at<br>&lt;a href=&quot;http://nginx.com/&quot;&gt;nginx.com&lt;/a&gt;.&lt;/p&gt;<br><br>&lt;p&gt;&lt;em&gt;Thank you for using nginx.&lt;/em&gt;&lt;/p&gt;<br>&lt;/body&gt;<br>&lt;/html&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v2aRN9legmKT6wO5IOWpCQ.png" /></figure><p>This connects your Mac browser to the NGINX service running inside the Kubernetes cluster through MetalLB and the SSH tunnel.</p><h3>Conclusion</h3><p>Running RKE2 with Cilium and MetalLB inside a Podman VM on macOS is a powerful way to experiment with Kubernetes in a lightweight environment. The key challenge lies in networking and service exposure due to Podman’s user-mode NAT, which requires SSH port forwarding from the VM to macOS.</p><p>This approach combines container-native virtualization and Kubernetes tooling, enabling a local cloud-native development experience without heavy dependencies or complex installations.</p><p>Reference :</p><ul><li><a href="https://metallb.universe.tf/installation/">Installation :: MetalLB, bare metal load-balancer for Kubernetes</a></li><li><a href="https://podman.io/docs/installation">Podman Installation | Podman</a></li><li><a href="https://cilium.io/#networking">Cilium - Cloud Native, eBPF-based Networking, Observability, and Security</a></li><li><a href="https://docs.rke2.io/">Introduction | RKE2</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=21c5e722555a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automate Docker image creation with BuildPack and Github Actions]]></title>
            <link>https://medium.com/@0.all_existence.0/automate-docker-image-creation-with-buildpack-and-github-actions-f64d2e0c00c9?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/f64d2e0c00c9</guid>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 28 Sep 2025 12:25:41 GMT</pubDate>
            <atom:updated>2025-09-28T12:30:18.005Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LfnbFcgA7SFozLDqrego0g.png" /></figure><h3><strong>Introduction</strong></h3><p>This POC demonstrates how to build a Node.js application using BuildPacks integrate it with GitHub Actions and finally run the resulting Docker image locally</p><p>The main goals of this POC are:</p><ul><li>Understand Buildpacks and their role in app deployment</li><li>Automate Docker image creation without writing a Dockerfile</li><li>Deploy a Node.js app using GitHub Actions</li><li>Test the built image locally</li></ul><h3>What is a Buildpack?</h3><p><strong>Buildpacks</strong> are a way to transform your source code into runnable container images automatically. They detect your application type, install dependencies, and configure the runtime environment all without needing a Dockerfile.</p><h3><strong>Complete Steps:</strong></h3><ol><li><strong>Clone a Node Js Project</strong></li></ol><p>For this I’ve already set up a Node.js project along with the GitHub Actions workflow YAML in my repository. You can download it directly to get started.</p><pre>https://github.com/allexistence/buildpack-ga.git</pre><p><strong>2. Setup GitHub Actions Workflow</strong></p><p>You can Refere file below file:</p><p><a href="https://github.com/allexistence/buildpack-ga/blob/main/.github/workflows/buildpack.yml">https://github.com/allexistence/buildpack-ga/blob/main/.github/workflows/buildpack.yml</a></p><pre>name: Build and Publish Node.js App with Buildpacks<br><br>on:<br>  push:<br>    branches:<br>      - main<br><br>jobs:<br>  build:<br>    runs-on: ubuntu-latest<br><br>    steps:<br>      - name: Checkout code<br>        uses: actions/checkout@v4<br><br>      - name: Set up Pack CLI<br>        uses: buildpacks/github-actions/setup-pack@v5.0.0<br>      <br>      - name: Set up Docker Buildx<br>        uses: docker/setup-buildx-action@v3<br><br>      - name: Log in to DockerHub<br>        uses: docker/login-action@v3<br>        with:<br>          username: ${{ secrets.DOCKER_USERNAME }}<br>          password: ${{ secrets.DOCKER_PASSWORD }}<br><br>      - name: Build and push image with Buildpacks<br>        run: |<br>          pack build *****/buildpack-ga:latest \<br>            --builder paketobuildpacks/builder:base \<br>            --publish</pre><p>Make sure to create <strong>Repository Secrets</strong> in GitHub for DOCKER_USERNAME and DOCKER_PASSWORD.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U1gEyGB2bG20MWM6kiNTbA.png" /></figure><p><strong>3- Pull the Image Locally and Run</strong></p><p>Once the GitHub Action successfully builds and pushes the Docker image, you can pull and run it locally:</p><pre># Pull the image<br>docker pull &lt;your-docker-username&gt;/&lt;name of image&gt;:latest<br><br># Run the container<br>docker run -p 3000:3000 &lt;your-docker-username&gt;/&lt;name of image&gt;:latest</pre><ul><li>Open <a href="http://localhost:3000/">http://localhost:3000/</a> in your browser.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*6aNijz3S3G9NJ8LBaNNWyg.png" /></figure><h3>Conclusion</h3><p>This POC demonstrates a automated workflow for building and deploying Node.js applications using Buildpacks and GitHub Actions:</p><ul><li>No Dockerfile required Buildpacks handle dependency management and runtime setup.</li><li>CI/CD integration with GitHub Actions enables automatic image builds and deployment.</li><li>Local testing is easy via docker pull &amp; run.</li></ul><p>This approach ensures reproducible builds, faster setup, and easier scaling making it ideal for both learning and production-ready pipelines.</p><p><strong>REFERENCE:-</strong></p><ul><li><a href="https://github.com/buildpacks/pack">GitHub - buildpacks/pack: CLI for building apps using Cloud Native Buildpacks</a></li><li><a href="https://github.com/paketo-buildpacks">Paketo Buildpacks</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f64d2e0c00c9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying Harbor Image Registry on Your Kubernetes Cluster]]></title>
            <link>https://medium.com/@0.all_existence.0/deploying-harbor-image-registry-on-your-kubernetes-cluster-ab8dd0d42af8?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab8dd0d42af8</guid>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 10 Aug 2025 17:40:26 GMT</pubDate>
            <atom:updated>2025-08-10T18:44:36.457Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p><strong>Harbor</strong> is an open-source container registry that offers role-based access control (RBAC), built-in vulnerability scanning and flexible replication. Running Harbor locally lets you explore real world registry workflows including login, push, pull and scan in a safe, controlled environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vCn-QvhE7fpqbiM3hgcpNQ.png" /></figure><p>In this blog, we will go through:</p><ul><li>Starting a local Kubernetes cluster</li><li>Enabling required Minikube addons for ingress, DNS, and storage.</li><li>Understanding how<strong> harbor.test</strong> works locally.</li><li>Deploying Harbor using the Bitnami Helm chart with a custom values.yaml</li><li>Creating a project in Harbor and pushing an image.</li><li>Troubleshooting login issues — self-signed certs &amp; insecure registry setup.</li></ul><h4>Start Minikube</h4><p>We start Minikube with extra CPU and memory so Harbor can run smoothly</p><pre>minikube start --cpus=6 --memory=8192</pre><p>Harbor has multiple components (core, portal, registry, DB, Redis, Trivy), so 6 CPU / 8 GB RAM ensures they all schedule without issues.</p><h4><strong>Enable the required addons</strong></h4><pre>minikube addons enable ingress<br>minikube addons enable ingress-dns<br>minikube addons enable csi-hostpath-driver</pre><p>Why these addons?</p><ul><li><strong>Ingress</strong> → Needed to expose Harbor via a hostname.</li><li><strong>Ingress-dns</strong> → Automatically resolves .test domains (like harbor.test ) to Minikube’s IP.</li><li><strong>Csi-hostpath-driver</strong> → Provides dynamic PersistentVolumes for Harbor’s storage.</li></ul><p>Before we install Harbor, let’s set up a hostname for it. We will map the Harbor UI and registry to <strong>harbor.test</strong> so we can access it easily in the browser instead of using an IP address</p><h4><strong>Make harbor.test work locally</strong></h4><p>On macOS, we point .test domains to Minikube:</p><pre>sudo mkdir -p /etc/resolver<br>echo -e &quot;nameserver $(minikube ip)\nport 53&quot; | sudo tee /etc/resolver/test</pre><p>Conceptually:</p><p>Browser/Docker CLI requests <strong>harbor.test</strong>. DNS sends it to Minikube’s IP. Nginx Ingress routes it to Harbor’s core service.</p><h4><strong>Deploy Harbor using Bitnami Helm</strong></h4><p>Install:</p><pre>helm repo add bitnami https://charts.bitnami.com/bitnami<br>helm repo update<br>kubectl create namespace harbor<br>helm upgrade --install harbor bitnami/harbor -n harbor -f values.yaml</pre><p>values.yaml:</p><pre><br>exposureType: ingress<br>externalURL: https://harbor.test<br><br>ingress:<br>  core:<br>    hostname: harbor.test<br>    ingressClassName: nginx<br>    tls: true<br>    selfSigned: true<br>    annotations:<br>      nginx.ingress.kubernetes.io/ssl-redirect: &quot;true&quot;<br>      nginx.ingress.kubernetes.io/proxy-body-size: &quot;0&quot;<br>  notary:<br>    enabled: false<br><br><br>adminPassword: &quot;......&quot;<br><br><br>global:<br>  storageClass: csi-hostpath-sc  <br><br><br>persistence:<br>  enabled: true<br>  resourcePolicy: keep<br>  imageChartStorage:<br>    type: filesystem<br>    filesystem:<br>      rootdirectory: /storage<br>  persistentVolumeClaim:<br>    registry:<br>      storageClass: &quot;&quot;            <br>      accessModes: [ReadWriteOnce]<br>      size: 5Gi<br>    jobservice:<br>      storageClass: &quot;&quot;<br>      accessModes: [ReadWriteOnce]<br>      size: 1Gi<br>    trivy:<br>      storageClass: &quot;&quot;<br>      accessModes: [ReadWriteOnce]<br>      size: 5Gi<br>   <br>    chartmuseum:<br>      storageClass: &quot;&quot;<br>      accessModes: [ReadWriteOnce]<br>      size: 1Gi<br><br># Built-in PostgreSQL &amp; Redis (multi-arch)<br>postgresql:<br>  enabled: true<br>  primary:<br>    persistence:<br>      enabled: true<br>      storageClass: &quot;&quot;<br>      size: 2Gi<br><br>redis:<br>  enabled: true<br>  architecture: standalone<br>  master:<br>    persistence:<br>      enabled: true<br>      storageClass: &quot;&quot;<br>      size: 1Gi<br><br><br>ipFamily:<br>  ipv4:<br>    enabled: true<br>  ipv6:<br>    enabled: false</pre><p>Check:</p><pre>kubectl get all -n harbor<br>NAME                                     READY   STATUS    RESTARTS      AGE<br>pod/harbor-core-6cc997db6-5kf6q          1/1     Running   1             59m<br>pod/harbor-jobservice-6b5ff897cd-j78vl   1/1     Running   0             59m<br>pod/harbor-portal-b5b9f46fd-tmrdk        1/1     Running   0             59m<br>pod/harbor-postgresql-0                  1/1     Running   0             59m<br>pod/harbor-redis-master-0                1/1     Running   0             59m<br>pod/harbor-registry-69845c4bf7-qdwml     2/2     Running   0             59m<br>pod/harbor-trivy-0                       1/1     Running   0             59m<br><br>kubectl -n harbor get ingress<br>NAME             CLASS   HOSTS         ADDRESS        PORTS     AGE<br>harbor-ingress   nginx   harbor.test                 80, 443   61m<br><br>kubectl get pv -n harbor <br>NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                                     STORAGECLASS      VOLUMEATTRIBUTESCLASS   REASON   AGE<br>pvc-00fc6f70-28bb-4703-8724-95bb052db600   5Gi        RWO            Delete           Bound    harbor/data-harbor-trivy-0                csi-hostpath-sc   &lt;unset&gt;                          86m<br>pvc-3c7be713-538f-4c53-8b14-a63c862f7311   2Gi        RWO            Delete           Bound    harbor/data-harbor-postgresql-0           csi-hostpath-sc   &lt;unset&gt;                          86m<br>pvc-74073449-ffff-481d-8710-6fe9b2ba250b   5Gi        RWO            Delete           Bound    harbor/harbor-registry                    csi-hostpath-sc   &lt;unset&gt;                          86m<br>pvc-a70cb452-8048-45cb-ac51-85e864b13e91   1Gi        RWO            Delete           Bound    harbor/harbor-jobservice                  csi-hostpath-sc   &lt;unset&gt;                          86m<br>pvc-fed1cfaf-2e70-4ba7-ab0d-f9a142b7a7a0   1Gi        RWO            Delete           Bound    harbor/redis-data-harbor-redis-master-0   csi-hostpath-sc   &lt;unset&gt;                          86m<br><br>kubectl get pvc -n harbor<br>NAME                               STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS      VOLUMEATTRIBUTESCLASS   AGE<br>data-harbor-postgresql-0           Bound    pvc-3c7be713-538f-4c53-8b14-a63c862f7311   2Gi        RWO            csi-hostpath-sc   &lt;unset&gt;                 86m<br>data-harbor-trivy-0                Bound    pvc-00fc6f70-28bb-4703-8724-95bb052db600   5Gi        RWO            csi-hostpath-sc   &lt;unset&gt;                 86m<br>harbor-jobservice                  Bound    pvc-a70cb452-8048-45cb-ac51-85e864b13e91   1Gi        RWO            csi-hostpath-sc   &lt;unset&gt;                 86m<br>harbor-registry                    Bound    pvc-74073449-ffff-481d-8710-6fe9b2ba250b   5Gi        RWO            csi-hostpath-sc   &lt;unset&gt;                 86m<br>redis-data-harbor-redis-master-0   Bound    pvc-fed1cfaf-2e70-4ba7-ab0d-f9a142b7a7a0   1Gi        RWO            csi-hostpath-sc   &lt;unset&gt;                 86m<br></pre><h4><strong>Create a project in Harbor</strong></h4><p>Visit <a href="https://harbor.test/">https://harbor.test</a> <br>Login with admin / &lt;password&gt; and create your own project</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mBNe48WPHjJG_aGTHTyBIw.png" /></figure><h4><strong>Login using docker cli</strong></h4><pre>docker login harbor.test</pre><p>If login fails with:</p><blockquote>time=”…..&quot; level=info msg=”Error logging in to endpoint, trying next endpoint” error=”Get \”https://harbor.test/v2/\&quot;: tls: failed to verify certificate: x509: “harbor.test” certificate is not trusted”</blockquote><blockquote>Get “https://harbor.test/v2/&quot;: tls: failed to verify certificate: x509: “harbor.test” certificate is not trusted</blockquote><p>Then you must peroform either of below step:</p><ul><li>Add Harbor’s self-signed cert to your Docker trust store,</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HYD6v7_Uj4BOrofiLmWkjg.png" /></figure><ul><li>Use<strong> — insecure-registry</strong> for Docker Desktop</li></ul><blockquote>Bitnami’s Harbor chart supports both x86 and ARM, so it runs well on Intel and Apple Silicon.</blockquote><blockquote>This setup is ideal for testing image workflows locally</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab8dd0d42af8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Uncovering Pod to Pod Traffic in Kubernetes Using Cilium and Hubble]]></title>
            <link>https://medium.com/@0.all_existence.0/uncovering-pod-to-pod-traffic-in-kubernetes-using-cilium-and-hubble-0e59a096cce9?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/0e59a096cce9</guid>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 27 Jul 2025 12:46:14 GMT</pubDate>
            <atom:updated>2026-02-19T16:29:31.618Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Introduction</strong></h3><p>Kubernetes networking can often feel like a black box. Pods talk to each other somehow. But who’s calling whom? Which HTTP endpoints are getting hit? And what actually happens when traffic gets dropped or misrouted? If you’ve ever found yourself asking:<br>Why can’t pod A reach pod B?<br>What does service-to-service traffic really look like?</p><p>Then it’s time to meet <strong>Cilium + Hubble</strong></p><p>In this blog, we’ll walk through how to:</p><ul><li>Spin up a local Kubernetes cluster on your machine using <strong>Minikube</strong></li><li>Deploy <strong>Cilium</strong> as the CNI, unlocking powerful eBPF-based networking</li><li>Use <strong>Hubble</strong> to get real-time visibility into pod-to-pod traffic including detailed HTTP flow logs</li><li>Deploy a sample app and actually <em>watch</em> the network traffic live in your browser</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EDkrR7psoRO2WFGePSwfvA.png" /></figure><h4><strong>Why Cilium and Hubble?</strong></h4><p>Cilium is an eBPF-powered Kubernetes CNI with security and scalability.<br>Hubble is the observability layer of Cilium and can be used to obtain cluster-wide visibility into the network and security layer of your Kubernetes cluster.</p><p><strong>Install dependencies :</strong></p><p><strong>1- minikube</strong></p><pre>curl -LO https://github.com/kubernetes/minikube/releases/latest/download/minikube-darwin-arm64<br>sudo install minikube-darwin-arm64 /usr/local/bin/minikube</pre><p>2- <strong>Helm , kubectl and cillium cli</strong></p><pre>brew install helm kubectl cilium-cli</pre><h4><strong>Step 1: Start a Clean Minikube Cluster</strong></h4><pre>minikube delete --all<br><br>minikube start --cni=false --network-plugin=cni --driver=vfkit</pre><h4><strong>Step 2: Install Cilium with Hubble Enabled</strong></h4><pre>helm repo add cilium https://helm.cilium.io/<br>helm repo update</pre><p>Now install Cilium with full observability enabled:</p><pre>helm install cilium cilium/cilium \<br>  --namespace kube-system \<br>  --version 1.14.5 \<br>  --set routingMode=tunnel \<br>  --set ipv6.enabled=false \<br>  --set operator.replicas=1 \<br>  --set hubble.enabled=true \<br>  --set hubble.relay.enabled=true \<br>  --set hubble.ui.enabled=true \<br>  --set l7Proxy=true \<br>  --set bpf.monitorAggregation=none</pre><h4><strong>Step 3: Launch the Hubble UI</strong></h4><p>Expose the Hubble UI locally:</p><pre>kubectl port-forward -n kube-system svc/hubble-ui 12000:80</pre><p>Then open <a href="http://localhost:12000/">http://localhost:12000</a> in your browser.</p><p>You’ll see a beautiful dashboard ready to display pod-to-pod traffic in real time</p><h4>Step 4: Deploy a Frontend-Backend App</h4><p>We’ll now create two pods:<br>Frontend runs curl in a contianer and backend replies with Hello from Backend</p><h4><strong>backend.yaml</strong></h4><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: backend<br>  labels:<br>    app: backend<br>spec:<br>  containers:<br>    - name: backend<br>      image: hashicorp/http-echo<br>      args: [&quot;-text=Hello&quot;]<br>      ports:<br>        - containerPort: 5678<br>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: backend<br>spec:<br>  selector:<br>    app: backend<br>  ports:<br>    - port: 80<br>      targetPort: 5678</pre><h4><strong>frontend.yaml</strong></h4><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: frontend<br>  labels:<br>    app: frontend<br>spec:<br>  containers:<br>  - name: curl<br>    image: curlimages/curl<br>    command: [&quot;sleep&quot;, &quot;3600&quot;]</pre><p>Apply them:</p><pre>kubectl apply -f backend.yaml<br>kubectl apply -f frontend.yaml</pre><h4>Step 5: Generate Traffic</h4><p>Let’s have the frontend pod call the backend:</p><pre>kubectl exec -it frontend -c curl -- curl backend<br><br>Hello</pre><h4><strong>Step 6: Observe Flows in Real-Time</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*FkOFKPHrjIinKwgjEIy9Cg.png" /></figure><h3>Cleanup</h3><pre>kubectl delete -f frontend.yaml -f backend.yaml<br>helm uninstall cilium -n kube-system<br>minikube delete</pre><h4><strong>Final Thoughts</strong></h4><p>Cilium and Hubble bring deep visibility, scalability, and security to Kubernetes networking through eBPF. They simplify service-to-service observability, enforce fine-grained policies and eliminate legacy IP-based limitations. In a cloud-native world they turn opaque cluster traffic into a transparent, secure, and observable system.</p><p><strong>Reference:</strong><br><a href="https://docs.cilium.io/en/stable/overview/intro/">https://docs.cilium.io/en/stable/overview/intro/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0e59a096cce9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GPU Accelerated AI Inference with llama.cpp in a Linux Container on macOS]]></title>
            <link>https://medium.com/@0.all_existence.0/gpu-accelerated-ai-inference-with-llama-cpp-in-a-linux-container-on-macos-37b6557f5d59?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/37b6557f5d59</guid>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 13 Jul 2025 10:01:04 GMT</pubDate>
            <atom:updated>2025-07-16T00:34:36.069Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Introduction: What I’ve Performed</strong></h3><p>I wanted to run a large language model inside a Linux container on my Mac Host using the GPU when possible and falling back to the CPU if I ran out of memory. To achieve this, I first installed Podman Desktop on my Mac host and used it to spin up a Fedora-based container image with a patched Mesa Vulkan driver (via slp/mesa-krunkit).</p><p>Next I launched an interactive container mounting my local <strong>~/model </strong>directory so it could access multi-gigabyte GGUF model files. Inside that container, I built <strong>llama.cpp</strong> with its Vulkan backend enabled and ran inference in two modes GPU offload (-ngl 99) and when RAM was constrained a pure-CPU fallback (-ngl 0)</p><p>This end to end workflow demonstrates how you can use Apple Silicon’s GPU inside a Linux container and gracefully revert to the CPU all within the Podman environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nfPfSfnMR6WG-c72r6f8eQ.png" /></figure><h3><strong>Containers and MacOS</strong></h3><p>Containers rely on Linux kernel features like namespaces and cgroups but macOS uses the XNU kernel, so you can’t run Linux containers natively. Tools like <strong>Podman Desktop</strong> solve this by quietly running containers inside a lightweight Linux VM using <strong>libkrun</strong>, a tiny hypervisor built on QEMU and Apple’s HVF.</p><p>Apple Silicon’s GPU can’t be passed directly to a Linux VM like a PCI device, because macOS needs it for the display. As Full passthrough would disconnect the screen So instead I use <strong>paravirtualization:</strong> the VM gets a virtual GPU device via <strong>virtio-gpu</strong> enabling shared memory and command streams between guest and host.</p><p>Inside container <strong>Mesa’s Venus driver</strong> intercepts Vulkan calls and sends them over virtio-gpu to the host. On the macOS side <strong>MoltenVK</strong> translates these Vulkan commands into <strong>Metal</strong>, Apple’s native GPU API bridging the gap between Linux containers and Apple’s graphics stack.</p><p>With this full pipeline in place I use <strong>llama.cpp</strong> inside the container to run large language models. By setting <strong>-ngl 99</strong> inference is offloaded to the Mac GPU through Vulkan and Metal. If GPU memory runs low or GPU offloading fails we can gracefully fall back to the CPU by running <strong>llama.cpp</strong> with <strong>-ngl 0</strong> no container rebuilds or host tweaks needed.</p><h3>GPU Access in Virtual Machines</h3><p>In today’s world of AI and high-performance computing getting top performance usually means offloading work to the <strong>GPU</strong>. GPUs are designed for massive parallelism making them ideal for tasks like training models and running inference.</p><p>But when your AI workload runs inside a <strong>virtualised environment </strong>as it often does in the cloud or on your local machine <strong>getting access to the physical GPU becomes a challenge</strong>. That is because Virtualization creates a boundary between the guest system and the host’s hardware and GPUs are particularly tricky to expose across that boundary.</p><p>There are a few ways to work around this limitation, each with its own trade-offs depending on the hardware and platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/1*mz37FuLAhZ90zOzU7-7Jyw.png" /></figure><h3><strong>Demonstration</strong></h3><p>Below a streamlined step-by-step guide to launching and running inference inside your GPU-enabled Podman container:</p><p><strong>1- Install Podman Desktop on MAC using brew</strong></p><pre>brew install podman-desktop</pre><p><a href="https://podman-desktop.io/docs/installation/macos-install">https://podman-desktop.io/docs/installation/macos-install</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_5bhWHpsFpqRuWzB_i0wsQ.png" /></figure><p>After installing Podman Desktop you can use the built-in Podman CLI through the UI,</p><p><strong>2- Setup podman machine using libkrun as machine provider</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*9Ww7HlA-pb-Zf3sKWXXLRA.png" /></figure><p>By default, Podman uses the Apple hypervisor provider type. If you are already running an Apple hypervisor Podman machine and want to create a <strong>Gpu enabled (libkrun)</strong> machine, reset the Podman machine to avoid any port conflicts.<br>Use Below link to setup podman machine using libkrun as Provider type.<br><a href="https://podman-desktop.io/docs/installation/macos-install#using-libkrun-as-machine-provider">https://podman-desktop.io/docs/installation/macos-install#using-libkrun-as-machine-provider</a></p><p>After Podman Machine setup to use GPU capabilities within a Podman container for running GPU-accelerated workloads. Below is link on how to get started setting up your OS to utilize the GPU.</p><p><a href="https://podman-desktop.io/docs/podman/gpu">https://podman-desktop.io/docs/podman/gpu</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0pR9YSkQ9-m_HgWZxXwIFQ.png" /></figure><p><strong>3 -GPU Access to Container</strong></p><p>Using the GPU functionality requires a specialized Containerfile containing a patched MESA driver.</p><p>Create the following Containerfile to build image and then build the image.</p><pre>FROM fedora:40<br>USER 0<br><br>RUN dnf -y install dnf-plugins-core &amp;&amp; \<br>    dnf -y install dnf-plugin-versionlock &amp;&amp; \<br>    dnf -y install mesa-vulkan-drivers vulkan-loader-devel vulkan-headers vulkan-tools vulkan-loader glslc &amp;&amp; \<br>    dnf -y copr enable slp/mesa-krunkit fedora-40-aarch64 &amp;&amp; \<br>    dnf -y downgrade mesa-vulkan-drivers.aarch64 --repo=copr:copr.fedorainfracloud.org:slp:mesa-krunkit &amp;&amp; \<br>    dnf versionlock mesa-vulkan-drivers &amp;&amp; \<br>    dnf clean all</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/847/1*_iAZOl4EETlR_8OSEgkacQ.png" /></figure><p>After succesfull image build verify you can see the GPU by running a test container</p><pre> podman run --rm -it --device /dev/dri --name gpu-info &lt;gpu-container-image&gt;  vulkaninfo | grep &quot;GPU&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3w99tAloNo1ccxm2dN-sHw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*rC1UhDEJa58LD5LFe2ihuw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/457/1*hw_eBgsN56kpCDe7F2R64g.png" /></figure><p><strong>4- Exec Into the Container &amp; Install Dependencies<br></strong>Now with your GPU-enabled image in place and your GGUFv2 model sitting in your local directory, you can launch an interactive container mount the mode and pull in everything you need to build llama.cpp</p><pre>podman run --rm -it --device /dev/dri --name llama-cpp -v $HOME/&lt;loacl-dir&gt;/model:/models docker.io/library/gpu-inference /bin/bash</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e1-ET-FXHw95IOlG8l0aqQ.png" /></figure><p>Aboce cmd drops you into a throw-away shell inside the <strong>GPU inference</strong> image with <strong>/models</strong> pointing at your host’s model directory.</p><p>Once you’re in the container install the development tools and Vulkan/Mesa bits. We install these packages because llama.cpp needs a C++ compiler and build tools plus the Vulkan/Mesa libraries and headers to compile its GPU-offload backend and talk to the virtio-GPU device.</p><pre>dnf -y install git @development-tools gcc-c++ cmake wget libcurl-devel curl vulkan-loader-devel vulkan-headers vulkan-tools glslc <br><br># Clone &amp; build llama.cpp<br>git clone https://github.com/ggml-org/llama.cpp.git<br>cd llama.cpp<br><br># Note: no space after -D<br>cmake -B build -DGGML_OPENMP=OFF -DGGML_VULKAN=ON<br><br># Note: --target (no space) and list targets<br>cmake --build build --config Release -j --target llama-cli llama-bench llama-server</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5jRd5hQy5PVLu_VbMdoMSw.png" /></figure><h3>Run Inference</h3><p>After building <strong>llama.cpp</strong>, you can execute your model in two modes</p><pre># 1. GPU-accelerated (offload up to 99 layers)<br>./build/bin/llama-cli -m /models/&lt;your model Name&gt; -p &quot;what is a large language model&quot; -ngl 99<br><br># 2. CPU-only fallback0<br>./build/bin/llama-cli -m /models/&lt;Your model Name&gt; -p &quot;what is a large language model&quot; -ngl 0<br><br><br># m points to your GGUF model file (mounted at /models).<br># p supplies the text prompt.<br># -ngl N controls GPU offload:<br>   # 99 offloads as many transformer layers as possible to the GPU.<br>   # 0 disables GPU offload, forcing inference on the CPU</pre><p><strong>What -ngl does</strong></p><p>-ngl N (alias --n-gpu-layers N ) tells <strong>llama.cpp</strong> how many transformer layers to keep in GPU memory.</p><ul><li>-ngl 0 → CPU-only, no GPU off-load.</li><li>-ngl 99 (or any number ≥ the model’s layer-count) → put as many layers as will fit – if the model has 26 layers, 26 is the real max anything higher is just capped there</li></ul><p><strong>GPU-accelerated <br></strong>Because of the limited RAM available on my Mac, the inference test failed when I tried to run it with GPU off-loading enabled</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QoaIJq-p2_TRLBOuZx3p9w.png" /><figcaption>GPU inference</figcaption></figure><pre><br>print_info: BOS token        = 2 &#39;&lt;bos&gt;&#39;<br>print_info: EOS token        = 1 &#39;&lt;eos&gt;&#39;<br>print_info: EOT token        = 107 &#39;&lt;end_of_turn&gt;&#39;<br>print_info: UNK token        = 3 &#39;&lt;unk&gt;&#39;<br>print_info: PAD token        = 0 &#39;&lt;pad&gt;&#39;<br>print_info: LF token         = 227 &#39;&lt;0x0A&gt;&#39;<br>print_info: EOG token        = 1 &#39;&lt;eos&gt;&#39;<br>print_info: EOG token        = 107 &#39;&lt;end_of_turn&gt;&#39;<br>print_info: max token length = 48<br>load_tensors: loading model tensors, this can take a while... (mmap = true)<br>load_tensors: offloading 26 repeating layers to GPU<br>load_tensors: offloading output layer to GPU<br>load_tensors: offloaded 27/27 layers to GPU<br>load_tensors:      Vulkan0 model buffer size =  9972.92 MiB<br>load_tensors:   CPU_Mapped model buffer size =  2250.00 MiB<br>.MESA-VIRTIO: debug: vn_ring_submit abort on fatal<br>Aborted (core dumped)</pre><p><strong>CPU-only fallback</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fmYPGvOV8glZasgP5u2fOQ.png" /><figcaption>Inference Using CPU Offload</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qMqsbU3Op0L9oa2BwCkiDw.png" /></figure><h3><strong>5. Flow — What Happened Under the Hood</strong></h3><p>So how did everything actually work behind the scenes? Let’s walk through the full stack that made AI inference with GPU acceleration possible inside a Linux container on macOS.</p><p>This might seem like magic at first but it’s actually a smart combination of open-source tools, virtualization, and hardware abstraction working together step by step.</p><p>To begin, I launched a container using Podman Desktop (or via the CLI using <strong>podman machine</strong>). Behind the scenes, this starts a lightweight virtual machine managed by libkrun, a minimalist virtual machine monitor built on top of Apple’s Hypervisor Framework.</p><p>One of the key things <strong>libkrun</strong> does is expose a <strong>paravirtualized GPU device</strong> called <strong>virtio-gpu</strong> to the Linux guest. This isn’t a direct hardware GPU, it’s a virtual interface designed specifically for virtualized environments. From inside the VM, it appears just like a real GPU device at <strong>/dev/dri/card0</strong>, but in reality, it serves as a communication pipeline between the guest system and the Mac host&#39;s physical GPU using shared memory.</p><p>Inside the Fedora-based container, I used the <strong>Mesa Vulkan driver</strong> (patched via the <strong>slp/mesa-krunkit</strong> repo). This driver speaks the <strong>Venus protocol</strong>, which takes Vulkan API calls made by GPU-enabled applications (like <strong>llama.cpp</strong> ) and encodes them into messages. These messages are sent through a shared memory page set up by the hypervisor.</p><p>On the macOS host, a component called <strong>virglrenderer</strong> receives these Venus messages, decodes them, and forwards them to <strong>MoltenVK</strong>, a compatibility layer that translates Vulkan calls into Apple’s native <strong>Metal</strong> API.</p><p>Finally, Apple’s <strong>Metal/MPS GPU libraries</strong> execute the underlying compute operations directly on the physical M1/M2 GPU.</p><p>In short, here’s the full data path:</p><blockquote><strong><em>Vulkan API (in container) → Venus → virglrenderer (on host) → MoltenVK → Metal → Apple GPU</em></strong></blockquote><h3><strong>The AI Engine: </strong><strong>llama.cpp + GGUF Models</strong></h3><p>Inside the container, we clone and build <strong>llama.cpp, A</strong>n ultra-lightweight C++ inference engine for running LLMs (large language models) offline</p><p>I use a <strong>GGUF v2 model</strong> (which is a new standard format for compressed LLM weights). These models are:</p><p>Quantized (small in size, fast to load)</p><ul><li>Self-describing (with architecture info built in)</li><li>Designed to work well with tools like llama.cpp</li></ul><p>To run inference, we pass parameters like:</p><pre>./build/bin/llama-cli -m /models/your-model.gguf -p &quot;Translate &#39;innovation&#39; into French.&quot; -ngl 99  # Offload to GPU</pre><p>If GPU memory runs out, we can switch to CPU-only mode with -ngl 0</p><h3>Stacked View</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CElwEJnow5xA35YBWdag4Q.png" /></figure><blockquote>Running GPU-accelerated AI inference inside a Linux container on macOS might sound complex, but with the right stack <strong>Podman</strong>, <strong>libkrun</strong>, <strong>Mesa-Vulkan</strong>, and <strong>llama.cpp </strong>it’s entirely possible even on Apple Silicon.</blockquote><blockquote>This approach lets you take full advantage of the Mac’s GPU through a lightweight virtualized pipeline using <strong>virtio-gpu</strong>, <strong>Venus</strong>, and <strong>MoltenVK</strong>, all from inside a container. If GPU resources run low, llama.cpp gracefully falls back to CPU inference, making it ideal for experimenting on machines with limited memory</blockquote><p><strong>REFERENCES:</strong></p><p><a href="https://developers.redhat.com/articles/2025/06/05/how-we-improved-ai-inference-macos-podman-containers?utm_source=chatgpt.com#running_container_gpu_acceleration_on_macos">https://developers.redhat.com/articles/2025/06/05/how-we-improved-ai-inference-macos-podman-containers?utm_source=chatgpt.com#running_container_gpu_acceleration_on_macos</a></p><p><a href="https://sinrega.org/2024-03-06-enabling-containers-gpu-macos/">https://sinrega.org/2024-03-06-enabling-containers-gpu-macos/</a></p><p><a href="https://podman-desktop.io/docs/podman/gpu">https://podman-desktop.io/docs/podman/gpu</a></p><p><a href="https://github.com/ggml-org/llama.cpp/blob/master/docs/docker.md">https://github.com/ggml-org/llama.cpp/blob/master/docs/docker.md</a></p><p><a href="https://github.com/containers/krunkit">https://github.com/containers/krunkit</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37b6557f5d59" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding vSphere API Data Flow]]></title>
            <link>https://medium.com/@0.all_existence.0/understanding-vsphere-api-data-flow-7ed39f6b938a?source=rss-d6a5a30dea20------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ed39f6b938a</guid>
            <dc:creator><![CDATA[Rishabh Pandey]]></dc:creator>
            <pubDate>Sun, 29 Jun 2025 09:10:36 GMT</pubDate>
            <atom:updated>2025-06-29T09:53:11.042Z</atom:updated>
            <content:encoded><![CDATA[<p>When interacting with VMware vCenter to manage and automate your virtual infrastructure, there are two primary ways to make API calls: using a REST client (vAPI) or a SOAP client. Each approach supports different features and has its own constraints enforced by the vSphere stack.</p><p>Parts of this blog are adapted from This official blog post, <a href="https://blogs.vmware.com/performance/2022/07/endpoint-limits-for-concurrent-rest-requests-from-vcenter-apis.html">https://blogs.vmware.com/performance/2022/07/endpoint-limits-for-concurrent-rest-requests-from-vcenter-apis.html</a></p><h3>REST vs SOAP Clients</h3><p>REST Clients (vAPI) use the vSphere Automation APIs, designed to modernize vCenter integrations. REST APIs make it easy to automate tasks such as VM cloning, tagging, or managing the content library. REST endpoints are typically accessed via URLs like <a href="https://{api_host}/api/vcenter/....">https://{api_host}/api/vcenter/....</a></p><p>SOAP Clients calls are made using tools like PowerCLI, Java, Perl, or Python scripts. They are ideal for tasks involving provisioning, inventory, and host management. However SOAP clients cannot manage vSphere tagging services or content libraries.</p><p><strong>Visualising the API Data Flow<br></strong>Below is a diagram illustrating both REST and SOAP API request flows through vCenter</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lzgVkOJFJqucASPGouar8Q.png" /></figure><blockquote><strong>Figure:</strong> Data flow of REST (left) and SOAP (right) API requests through Envoy, vAPI endpoint, and vpxd service providers within vCenter</blockquote><p><strong>High-Level API Request Flow</strong></p><p>All incoming REST or SOAP API requests from external clients first arrive at vCenter’s reverse proxy known as <strong>Envoy</strong> which acts as the gatekeeper for all incoming requests. The Envoy service brokers both external client connections and internal vCenter services with internal communication taking place over HTTP</p><p>Envoy’s primary responsibility is to determine the appropriate destination for each incoming request:</p><ul><li>For <strong>REST requests</strong>, Envoy forwards them to the <strong>vAPI endpoint</strong>, which serves as an API aggregator for multiple vCenter infrastructure services, including API service providers, <strong>vpxd</strong>, the <strong>content library</strong>, and <strong>tagging services</strong>. The vAPI endpoint leverages <strong>Jetty</strong> as its web server to handle REST API traffic.</li><li>For <strong>SOAP requests</strong>, Envoy sends them directly to the relevant API service provider, typically <strong>vpxd</strong>, bypassing the vAPI endpoint entirely. This direct routing is optimized for SOAP-based provisioning, inventory, and host management operations. However, it’s important to note that SOAP clients do not have access to content library or tagging services.</li></ul><h3><strong>Key API Service Providers</strong></h3><p>vCenter relies on several key service providers to deliver its rich set of infrastructure operations. These components handle everything from provisioning and inventory management to tagging and content library services</p><p><strong>API Service Providers (vAPI services):</strong> These vCenter services expose the infrastructure operations available to clients through the REST API. Examples include appliance management, token services, compute policy, trust management, certificate management, and the vmware-vmon service, which oversees the lifecycle of the Platform Services Controller and vCenter itself.</p><ul><li><strong>vpxd:</strong> The core vCenter process responsible for provisioning virtual machines, managing inventory, and performing host-related operations. SOAP requests are typically directed to vpxd for these essential tasks.</li><li><strong>Content Library:</strong> A centralized repository that stores VM templates, vApp templates, ISO images, and other types of files. The content library makes it easy to share assets across multiple vCenter instances, whether they’re located in the same datacenter or in different geographical regions.</li><li><strong>Tag Services:</strong> These services allow you to create and apply metadata tags to vSphere inventory objects, making it simpler to organize, categorize, and search for resources. Tags provide a flexible way to manage your environment and align objects with business or operational requirements.</li></ul><h3>API Data Flow</h3><p>Every API request undergoes three fundamental steps:</p><p><strong>Authentication:</strong> Verifying that the requestor is a valid user.<br><strong>Authorization:</strong> Checking whether the user has the right permissions on the requested objects (e.g., permission to clone a VM).<br><strong>Execution:</strong> Performing the requested operation.</p><h4><strong>REST Client Initiates a Request</strong></h4><p>Envoy receives the REST request<br><strong>Blocking requests:</strong> Wait for the operation (e.g., VM clone) to finish before returning a result to the client.<br><strong>Non-blocking requests:</strong> Return immediately with a <strong>Task ID</strong>, which can be used to poll the operation’s status.</p><p>Envoy <strong>forwards REST requests to the vAPI endpoint</strong>, where authentication is performed. The vAPI endpoint then routes the request to the appropriate service provider (e.g., <strong>vpxd</strong>) for authorization checks and execution of the task. Once the operation completes (or the Task ID is generated), the response is propagated back to the client module.</p><h4>SOAP Client Initiates a Request</h4><p>Envoy receives the SOAP request.<br>Envoy directly forwards the request to the appropriate service provider, typically vpxd, which performs authentication, authorization, and executes the requested task.<br>Unlike REST, SOAP calls skip the vAPI endpoint and communicate directly with vCenter’s SOAP services, which specialize in provisioning and inventory operations but do not support managing tags or the content library.</p><p><strong>REFERENCES:</strong></p><p><a href="https://developer.broadcom.com/xapis/vsphere-automation-api/latest/">https://developer.broadcom.com/xapis/vsphere-automation-api/latest/</a></p><p><a href="https://developer.broadcom.com/sdks/vsphere-management-sdk/8.0">https://developer.broadcom.com/sdks/vsphere-management-sdk/8.0</a></p><p><a href="https://developer.broadcom.com/sdks?tab=Compute%2520Virtualization">https://developer.broadcom.com/sdks?tab=Compute%2520Virtualization</a></p><p><a href="https://blogs.vmware.com/performance/2022/07/endpoint-limits-for-concurrent-rest-requests-from-vcenter-apis.html">Endpoint Limits for Concurrent REST Requests from vCenter APIs</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ed39f6b938a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>