<?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 Bharathi Tenneti on Medium]]></title>
        <description><![CDATA[Stories by Bharathi Tenneti on Medium]]></description>
        <link>https://medium.com/@btenneti?source=rss-aef259db058d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*tqBxjngKGQEaGXhl</url>
            <title>Stories by Bharathi Tenneti on Medium</title>
            <link>https://medium.com/@btenneti?source=rss-aef259db058d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 15:03:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@btenneti/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[The Destination, the path, and the code.]]></title>
            <link>https://medium.com/@btenneti/the-destination-the-path-and-the-code-91ec1c61b113?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/91ec1c61b113</guid>
            <category><![CDATA[atheism]]></category>
            <category><![CDATA[sanatana-dharma]]></category>
            <category><![CDATA[spirituality]]></category>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Thu, 01 Oct 2026 18:15:49 GMT</pubDate>
            <atom:updated>2026-10-02T02:08:18.890Z</atom:updated>
            <content:encoded><![CDATA[<p>The Destination, the path, and the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e3j7LtCgVeOVMnQD6Ewxvw.png" /></figure><p>I was recently in a conversation with an atheist friend about religion, faith, spirituality, trauma, and how all of these can shape one’s path toward inner awareness, if that is the destination one wishes to reach.<br>It made me think about something I had never really felt the need to articulate before — usually am not a person with particularly strong opinions on most matters.</p><p><em>But I felt the need to say this out loud: whichever path we choose — an organized religion, a spiritual tradition, atheism, or simply a life of questioning and inquiry — there should always be room for introspection. <br>We should occasionally perform a </em><strong><em>small quality check</em></strong><em> on our own thoughts: </em><strong><em>Am I arriving at this conclusion after genuinely examining it, or am I rejecting it because of something I have experienced, something that hurt me, or something I have simply decided I don’t want to believe? </em></strong><em><br>To me, that distinction matters. Blindly following a belief system and blindly rejecting one can, in different ways, become the same thing — neither requires us to truly look within.</em></p><p>The more I thought about it, the more my natural tendency to draw an analogy with technology came up. Perhaps finding our way through life is not entirely different from developing a production-grade application.</p><p>The goal is ultimately to have something that works reliably, scales, handles failures gracefully, and survives the real world. One way to get there is to learn from frameworks, established patterns, best practices, and the lessons of those who have built systems before us — and to have good testcases and error handling in place before we encounter every possible failure in production.<br>Another way is to reject all frameworks, build everything from scratch, and learn through our own failures until, eventually, we develop our own patterns that work.</p><p>And there is yet another possibility: an application that works beautifully in the happy path, but falls apart the moment reality introduces an unexpected condition.<br>None of these paths necessarily determine the final outcome.<br>The interesting question is <em>how we get there</em>. Perhaps spiritual traditions, like good engineering practices, are not meant to replace our own thinking, but to give us time-tested tools for navigating problems that human beings have been debugging for thousands of years.</p><p>We can still question the framework, modify it, reject parts of it, or even build our own. But perhaps the real wisdom lies in being curious enough to learn from what has already been tested, while humble enough to continuously test and debug ourselves.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=91ec1c61b113" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enable Perses Dashboards for Red Hat Advanced Cluster Management]]></title>
            <link>https://medium.com/@btenneti/enable-perses-dashboards-for-red-hat-advanced-cluster-management-b39a704bc3a7?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b39a704bc3a7</guid>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 20:14:12 GMT</pubDate>
            <atom:updated>2026-08-10T20:14:12.209Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p_pdnFftzaPlS88j1AFtVw.png" /></figure><h3>Visualizing Multi-Cluster Health with Perses and the Cluster Observability Operator</h3><p>As <a href="https://www.redhat.com/en/technologies/cloud-computing/openshift">Redhat OpenShift </a>deployments grow beyond a handful of clusters, centralized observability becomes essential. Platform engineers need a consistent way to monitor cluster health, identify capacity trends, and troubleshoot issues across an entire fleet without switching between individual clusters.</p><p><a href="https://docs.redhat.com/en/documentation/red_hat_advanced_cluster_management_for_kubernetes/2.17/html/about/welcome-to-red-hat-advanced-cluster-management-for-kubernetes">Red Hat Advanced Cluster Management for Kubernetes (RHACM)</a> provides that centralized control plane. From a single hub cluster, administrators can provision, manage, govern, secure, and observe OpenShift clusters distributed across datacenters, public clouds, and edge environments.</p><p><a href="https://www.redhat.com/en/blog/new-observability-features-red-hat-openshift-421-and-red-hat-advanced-cluster-management-kubernetes-216">Observability</a> is one of RHACM’s key capabilities. By collecting metrics from managed clusters and aggregating them into a centralized Thanos instance, RHACM provides a fleet-wide view of infrastructure health and application performance.</p><p>While RHACM provides built-in dashboards, platform teams often need dashboards tailored to their own operational requirements, such as:</p><ul><li>Fleet-wide cluster health</li><li>Capacity planning and resource utilization</li><li>Platform SLOs</li><li>Custom application metrics</li><li>Business-specific KPIs</li></ul><p>This is where <a href="https://developers.redhat.com/articles/2026/04/02/red-hat-build-perses-cluster-observability-operator"><strong>Perses</strong></a> becomes particularly interesting.</p><p>Starting with OpenShift 4.20, Red Hat provides Perses as the Kubernetes-native dashboarding platform through the <strong>Cluster Observability Operator (COO)</strong>. Unlike traditional dashboard platforms such as Grafana, Perses represents dashboards and datasources as Kubernetes Custom Resources.</p><p>This Kubernetes-native approach makes dashboards declarative, version-controlled, and well suited to GitOps workflows. Teams can manage dashboards in the same way they manage other Kubernetes resources and application manifests.</p><p>This article outlines way to configure Perses dashboards for an RHACM environment, connect Perses to RHACM’s fleet-wide Thanos instance, and deploy custom dashboards that provide operational visibility across managed clusters.</p><h3>Architecture Overview</h3><p>At a high level, the observability stack consists of the following components:</p><ol><li><strong>Managed OpenShift clusters</strong> expose platform and application metrics through Prometheus.</li><li><strong>MultiCluster Observability (MCO)</strong> on the RHACM hub aggregates metrics from managed clusters into a centralized Thanos deployment.</li><li><strong>MultiCluster Observability Add-on (MCOA)</strong> is deployed to managed clusters by RHACM and collects metrics from those clusters for forwarding to the hub.</li><li><strong>Cluster Observability Operator (COO)</strong> installs and manages the Perses components on OpenShift.</li><li><strong>Perses</strong> queries the centralized Thanos endpoint through the RHACM RBAC Query Proxy. This provides secure, role-aware access to the metrics exposed by the observability stack.</li></ol><p>This architecture allows platform teams to define dashboards once and visualize operational metrics from across the entire managed-cluster fleet through a centralized interface.</p><p>More importantly, dashboards and datasources can be represented as Kubernetes resources, making them natural candidates for GitOps, version control, and Infrastructure-as-Code practices.</p><h3>Prerequisites</h3><p>This guide assumes that the following environment has already been provisioned:</p><ul><li>An OpenShift hub cluster running RHACM</li><li>MultiClusterHub instance created</li><li>One or more OpenShift clusters imported into RHACM</li><li>Cluster Administrator privileges</li><li>The oc CLI configured to access the hub cluster</li><li>OpenShift Data Foundation (ODF), or any other supported object-storage solution for Thanos</li></ul><p>For more detailed setup, please refer <a href="https://github.com/bharathi-tenneti/custom-perses-openshift-dashboards/blob/main/SETUP.md">https://github.com/bharathi-tenneti/custom-perses-openshift-dashboards/blob/main/SETUP.md</a></p><h3>Configure Object Storage for Thanos</h3><p>RHACM’s observability stack requires object storage for Thanos. In this example, we use an OpenShift Data Foundation NooBaa ObjectBucketClaim.</p><p>Create the ObjectBucketClaim:</p><pre>apiVersion: objectbucket.io/v1alpha1<br>kind: ObjectBucketClaim<br>metadata:<br>  name: acm-thanos-bucket<br>  namespace: open-cluster-management-observability<br>spec:<br>  generateBucketName: acm-thanos<br>  storageClassName: openshift-storage.noobaa.io</pre><p>ObjectBucketClaim creates the bucket and associated credentials. These credentials can then be used to configure Thanos object-storage secret:</p><pre>oc patch secret thanos-object-storage -n open-cluster-management-observability --type=merge \<br>  -p &quot;{\&quot;stringData\&quot;:{\&quot;thanos.yaml\&quot;:\&quot;type: S3\nconfig:\n  bucket: $(oc get configmap acm-thanos-bucket -n open-cluster-management-observability -o jsonpath=&#39;{.data.BUCKET_NAME}&#39;)\n  endpoint: s3.openshift-storage.svc.cluster.local\n  insecure: true\n  access_key: $(oc get secret acm-thanos-bucket -n open-cluster-management-observability -o jsonpath=&#39;{.data.AWS_ACCESS_KEY_ID}&#39; | base64 -d)\n  secret_key: $(oc get secret acm-thanos-bucket -n open-cluster-management-observability -o jsonpath=&#39;{.data.AWS_SECRET_ACCESS_KEY}&#39; | base64 -d)\n\&quot;}}&quot; \<br>2&gt;/dev/null || oc create secret generic thanos-object-storage \<br>  -n open-cluster-management-observability \<br>  --from-literal=thanos.yaml=&quot;type: S3<br>config:<br>  bucket: $(oc get configmap acm-thanos-bucket -n open-cluster-management-observability -o jsonpath=&#39;{.data.BUCKET_NAME}&#39;)<br>  endpoint: s3.openshift-storage.svc.cluster.local<br>  insecure: true<br>  access_key: $(oc get secret acm-thanos-bucket -n open-cluster-management-observability -o jsonpath=&#39;{.data.AWS_ACCESS_KEY_ID}&#39; | base64 -d)<br>  secret_key: $(oc get secret acm-thanos-bucket -n open-cluster-management-observability -o jsonpath=&#39;{.data.AWS_SECRET_ACCESS_KEY}&#39; | base64 -d)&quot;Note: The exact object-storage configuration may vary depending on the storage provider and RHACM/Observability version.</pre><h3>Create the MultiClusterObservability Instance</h3><p>Create a MultiClusterObservability resource to enable centralized metrics collection:</p><pre>apiVersion: observability.open-cluster-management.io/v1beta2<br>kind: MultiClusterObservability<br>metadata:<br>  name: observability<br>spec:<br>  availabilityConfig: Basic<br>  observabilityAddonSpec:<br>    enableMetrics: true<br>    interval: 300<br>  storageConfig:<br>    metricObjectStorage:<br>      name: thanos-object-storage<br>      key: thanos.yaml<br>    storageClass: ocs-storagecluster-ceph-rbd</pre><p>Once the resource is reconciled, RHACM deploys the components required to collect and aggregate metrics from the managed clusters.</p><h3>Install the Cluster Observability Operator</h3><p>The <strong>Cluster Observability Operator (COO)</strong> manages the observability components used by OpenShift, including Perses.</p><p>The operator can be installed through the OpenShift OperatorHub/catalog, or by applying the appropriate operator <a href="https://github.com/bharathi-tenneti/custom-perses-openshift-dashboards/blob/main/base/coo-operator-perses.yaml">manifests</a> for your OpenShift version. After installation, verify that the operator is running successfully before proceeding with Perses configuration.</p><h3>Enable the RHACM Metrics UI</h3><p>RHACM provides capabilities that control how platform metrics and their UI integration are exposed. <br>Enable the metrics UI:</p><pre>oc patch mco observability \<br>  -n open-cluster-management-observability \<br>  --type=merge \<br>  -p &#39;{&quot;spec&quot;:{&quot;capabilities&quot;:{&quot;platform&quot;:{&quot;metrics&quot;:{&quot;default&quot;:{&quot;enabled&quot;:true},&quot;ui&quot;:{&quot;enabled&quot;:true}}}}}}&#39;</pre><h3>Enable the MultiCluster Observability Add-on</h3><p>The MultiCluster Observability Add-on is responsible for collecting metrics from managed clusters.</p><p>Enable platform and user-workload metrics:</p><pre>oc patch mco observability \<br>  -n open-cluster-management-observability \<br>  --type=merge \<br>  -p &#39;{&quot;spec&quot;:{&quot;capabilities&quot;:{&quot;platform&quot;:{&quot;metrics&quot;:{&quot;default&quot;:{&quot;enabled&quot;:true}}},&quot;userWorkloads&quot;:{&quot;metrics&quot;:{&quot;default&quot;:{&quot;enabled&quot;:true}}}}}}&#39;</pre><p>The exact capabilities available can vary by RHACM and observability version, so verify the supported configuration for your environment.</p><h3>Configure the Perses Datasource</h3><p>Now that RHACM is collecting and aggregating metrics, Perses needs a datasource through which it can query the fleet-wide Thanos instance.</p><p>The following example creates a PersesGlobalDatasource:</p><pre>apiVersion: perses.dev/v1alpha2<br>kind: PersesGlobalDatasource<br>metadata:<br>  name: dynamic-fleet-thanos-datasource<br>spec:<br>  client:<br>    tls:<br>      enable: true<br>      caCert:<br>        type: file<br>        certPath: /ca/service-ca.crt<br>  config:<br>    default: false<br>    display:<br>      name: &quot;ACM MultiCluster Thanos Engine&quot;<br>    plugin:<br>      kind: PrometheusDatasource<br>      spec:<br>        proxy:<br>          kind: HTTPProxy<br>          spec:<br>            url: &#39;http://rbac-query-proxy.open-cluster-management-observability.svc.cluster.local:8080&#39;</pre><p>The important part of this configuration is the RHACM <strong>RBAC Query Proxy</strong>.</p><p>Perses does not need to connect directly to the underlying Thanos components. Instead, queries are routed through the RHACM query proxy, allowing RHACM’s access-control mechanisms to remain part of the request path.</p><p>The result is a datasource that can expose fleet-wide metrics to Perses while maintaining the security model provided by RHACM.</p><h3>Explore the Built-in Perses Dashboards</h3><p>Once Perses and the datasource are configured, the OpenShift console provides access to the Perses dashboard experience.</p><p>The built-in dashboards provide a useful starting point for understanding the metrics already available through the observability stack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oz94fpLhqLDbDnjxXOr66g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mGIqRAA2eUkpVRhtjQsf3g.png" /></figure><p>From here, you can create dashboards that combine metrics from multiple managed clusters rather than limiting the visualization to a single cluster.</p><h4>Create New Dashboards and Migrate Existing Grafana Dashboards</h4><p>OpenShift 4.20 supports both Grafana and Perses. However, Perses represents Red Hat’s Kubernetes-native direction for dashboarding, making it an important platform to consider for new dashboard development.</p><p>If you already have a large collection of Grafana dashboards, migrating everything manually isn’t necessary. Perses provides migration approaches for Grafana dashboards, including the percli command-line tool and dashboard import capabilities in the UI.</p><p>For example, existing Grafana dashboards can be imported and then adapted to the Perses model.</p><p>However, migration should not be treated as a completely automatic process.</p><p>Complex or highly customized Grafana dashboards may require additional work, particularly around:</p><ul><li>Dashboard variables</li><li>Datasource references</li><li>Panel configurations</li><li>Query syntax</li><li>Reusable components</li><li>Dashboard-level filters</li></ul><p>A migrated dashboard may therefore need to be reviewed and modified before it is ready for production use.</p><p>For simple dashboards, migration can be relatively straightforward. For heavily customized dashboards, it may be more efficient to use the migration as a starting point and then rebuild portions of the dashboard using native Perses concepts.</p><h3>Dashboard-as-Code</h3><p>One of the biggest advantages of Perses is that dashboards can be represented as Kubernetes resources.</p><p>Instead of treating a dashboard as an object that only exists inside a UI, teams can store dashboard definitions alongside their application and platform configuration.</p><p>For example:</p><pre>git repository<br>│<br>├── dashboards/<br>│   ├── cluster-health.yaml<br>│   ├── capacity.yaml<br>│   └── application-slo.yaml<br>│<br>├── datasources/<br>│   └── thanos.yaml<br>│<br>└── applications/</pre><p>This makes it possible to apply familiar GitOps practices to observability:</p><p><strong>Git → CI/CD → Kubernetes → Perses → Dashboard</strong></p><p>A dashboard change can therefore go through the same review and deployment process as any other platform configuration.</p><h3>Custom Perses Dashboards</h3><p>For this article, the accompanying <a href="https://github.com/bharathi-tenneti/custom-perses-openshift-dashboards/blob/main/base/coo-operator-perses.yaml">repository</a> contains examples of custom Perses dashboards that demonstrate how fleet-wide metrics can be visualized.</p><p><strong>Custom Dashboard 1</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lID9Op1EhuqjDaqe_jN3MA.png" /></figure><p><strong>Custom Dashboard 2</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jUhS4A_1Fo_OuLxQY9xuQw.png" /></figure><p>These dashboards can serve as starting points for building platform-specific views around cluster health, resource utilization, application metrics, and operational KPIs.</p><h3>Takeaway</h3><p>Dashboarding in OpenShift isn’t new. What changes with Perses is <strong>how dashboards are built, managed, and integrated into the Kubernetes platform</strong>.</p><p>Perses brings dashboards and datasources closer to the Kubernetes resource model. Combined with the Cluster Observability Operator and RHACM’s centralized observability stack, it provides a way to build dashboards that can visualize metrics across an entire OpenShift fleet.</p><p>The combination is particularly interesting for platform teams because it brings together three concepts:</p><ul><li><strong>RHACM</strong> provides centralized multi-cluster management and observability.</li><li><strong>Thanos</strong> provides a centralized, scalable metrics layer.</li><li><strong>Perses</strong> provides Kubernetes-native dashboards on top of that metrics layer.</li></ul><p>The result is a dashboarding workflow that is much more aligned with modern Kubernetes and GitOps practices:</p><p>For teams already operating OpenShift and RHACM at scale, Perses provides a natural next step toward treating observability dashboards as part of the platform itself rather than as a separate, manually managed application.</p><h4>References</h4><ul><li><a href="https://github.com/bharathi-tenneti/custom-perses-openshift-dashboards/blob/main/base/coo-operator-perses.yaml">custom-perses-openshift-dashboards/base/coo-operator-perses.yaml at main · bharathi-tenneti/custom-perses-openshift-dashboards</a></li><li><a href="https://developers.redhat.com/articles/2026/04/02/red-hat-build-perses-cluster-observability-operator">Red Hat build of Perses with the cluster observability operator | Red Hat Developer</a></li><li><a href="https://github.com/perses/perses">GitHub - perses/perses: The CNCF sandbox for observability visualisation. Already supports Prometheus, Tempo, Loki and Pyroscope - more data sources to come!</a></li><li><a href="https://developers.redhat.com/articles/2026/07/07/manage-observability-red-hat-build-perses#governance__security__and_understanding_perses_rbac">Visualize your cluster: Manage observability with Red Hat build of Perses | Red Hat Developer</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b39a704bc3a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Single Node OpenShift (SNO) Lab on Proxmox]]></title>
            <link>https://medium.com/@btenneti/building-a-single-node-openshift-sno-lab-on-proxmox-8052f8a2f658?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/8052f8a2f658</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[homelab]]></category>
            <category><![CDATA[red-hat-openshift]]></category>
            <category><![CDATA[single-node-cluster]]></category>
            <category><![CDATA[proxmox]]></category>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Wed, 06 May 2026 03:14:55 GMT</pubDate>
            <atom:updated>2026-05-06T03:14:55.127Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C7c5FlPEcJW1M_YuABc2OQ.png" /></figure><h3>Slightly chaotic and a highly educational journey into OpenShift install.</h3><p>💡 <strong>Think of this as:</strong> <em>“I paid $100 for a Dell Optiplex and called it an OpenShift install hands-on training course.”</em></p><p>Before we begin, let’s align expectations.</p><p><strong>✅ Goal of this writeup. <br></strong>Learn how OpenShift install actually works (not just “click next”) <br>Understand DNS &amp; networking in a real cluster<br>Build SNO on cheap, <em>slightly-questionable</em> hardware</p><p><strong>❌ Non-goals<br></strong>Not production-ready (not even close)<br>Not HA or enterprise-grade<br>Not a “copy-paste” shortcut guide<br>Definetely no fancy($$$$) servers</p><h3>The Hardware Spec</h3><p>I used a refurbished <strong>Dell OptiPlex 7050</strong>. It’s small, quiet, and surprisingly capable for a beginner home lab, below is the spec.</p><p><strong>CPU — </strong>Intel i7–7700 (4 Cores / 8 Threads)<br><strong>RAM — </strong>48 GB (16GB Base + 32GB added)<br><strong>Storage (Boot) — </strong>128 GB M.2 SSD (Proxmox OS)<br><strong>Storage (Data) — </strong>2 TB SATA SSD (VM Disks)</p><h3>Homelab layout</h3><p>I’m using Proxmox as the hypervisor so I can run a proper DNS server instead of dnsmasq on my Mac (did that, suffered enough, not going back).<br>Also, I wanted to test OpenShift in a VM before trying bare metal—<em>mainly to limit how many things can go wrong at once.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gOlNBwAVr6LD1hfaqahTNw.png" /><figcaption>Homelab architecture</figcaption></figure><h3>1. The Foundation: Proxmox VE</h3><p>I used <a href="https://www.proxmox.com/en/downloads">Proxmox VE</a> to turn this desktop into a multi-VM environment.</p><ol><li><strong>Flash ISO:</strong> Use Balena Etcher or Rufus to flash the Proxmox ISO to a USB.</li><li><strong>Boot &amp; Install:</strong> Hit <strong>F12</strong> on the Optiplex, select the USB, and target was the 128 GB M.2 drive for the OS.</li><li><strong>Access UI:</strong> Once finished, hit the web interface from your laptop: https://&lt;PROXMOX_IP&gt;:8006</li></ol><h3>2. The Traffic Controller: AdGuard DNS</h3><p>OpenShift is notoriously picky about DNS. Instead of fighting with my home router, I created a dedicated Debian VM (1 CPU, 1 GB RAM) and installed <strong>AdGuard Home</strong>.</p><p><strong>Installation:</strong></p><pre>curl -s -S -L https://raw.githubusercontent.com/AdguardTeam/AdGuardHome/master/scripts/install.sh | sh</pre><p><strong>Critical DNS Records (DNS Rewrites):</strong></p><p>OpenShift needs to know where the API and Apps live. I assigned my SNO VM the IP 192.168.1.193.</p><ul><li>api.ocp.mydomain.lab.home → 192.168.1.193</li><li>*.apps.ocp.mydomain.lab.home → 192.168.1.193</li></ul><h3>3. The ISO Factory: Agent-based Installer</h3><p>I used the <strong>Agent-based Installer</strong> because it’s more “hands-on” than the Assisted Installer, there’s lot of docs out there on this, ill keep it brief.</p><ul><li><strong>Get the Tools:</strong> Download the <a href="https://mirror.openshift.com/pub/openshift-v4/clients/ocp/latest-4.21/openshift-install-mac.tar.gz">openshift-install binary</a> and your <a href="https://console.redhat.com/openshift/downloads">Pull Secret.</a></li><li><strong>Configure:</strong> Create a folder and, configure your <a href="https://github.com/bharathi-tenneti/sno-lab/tree/main">install-config.yaml and </a><a href="https://github.com/bharathi-tenneti/sno-lab/tree/main">agent-config.yaml</a></li><li><strong>Generate Image:<br></strong>openshift-install agent create image --dir=./sno-cluster</li><li><strong>The Result:</strong> This gives you an agent.iso which you’ll upload to Proxmox. Also it gives auth/kubeconfig that you can use to login to the cluster once installed.</li></ul><h3>4. The SNO VM Build</h3><p>With the ISO ready, it’s time to carve out the VM. OpenShift is resource-heavy, so don’t skimp on these specs or the installer will likely “choke” during the bootstrap phase.</p><ul><li><strong>CPU:</strong> 6 Cores (Type: host)</li><li><strong>Memory:</strong> 32 GB (Fixed — <strong>Disable Ballooning</strong>)</li><li><strong>Disk:</strong> 500 GB (Bus: VirtIO Block) (Used the 2TB disk as storage layer for this)</li><li><strong>BIOS:</strong> OVMF (UEFI)</li><li><strong>Machine:</strong> q35</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BJK7SDLHA9Zy1hgW9qx6Vw.png" /></figure><h4>The “Watch and Wait” Phase</h4><p>Once you power on the VM, it’s time to stare at the console like it owes you money!! <strong><em>(Where’s my money Brian!!! ..huh?)</em></strong></p><p>The node will boot into Red Hat Enterprise Linux CoreOS (RHCOS) and start the ignition process.<br>To see what’s actually happening under the hood, you can SSH into the node (using the key you provided in your install-config.yaml) and tail the installer logs:</p><pre># SSH into the temporary bootstrap node<br>ssh core@192.168.1.193<br><br># Monitor the high-level install progress<br>journalctl -b -f -u agent-installer.service<br><br># Check the status of the cluster operators once the API is up<br>cd sno-cluster<br>export KUBECONFIG=auth/kubeconfig<br>oc get nodes<br>oc get co</pre><p><em>Ha! If only it were that easy. You’re going to hit issues — so keep reading.</em></p><h4>Pro-Tip: It’s going to be <em>legen — wait for it — still waiting…</em></h4><p>While the VM is chugging away, you can monitor the progress from your local workstation using the installer binary:</p><pre>./openshift-install --dir=./my-config agent wait-for install-complete</pre><h3>Welcome to the Fight Club: The “Boss Fights”</h3><h3>Round 1: The Boot Loop Trap</h3><p><strong>The Problem:</strong> After the first phase of installation, the VM reboots. If the ISO is still first in the boot order, Proxmox will restart the installation from scratch.</p><p><strong>The Fix:</strong> You have to be fast. As soon as the “rebooting” message appears, go to the <strong>Proxmox VM Options &gt; Boot Order</strong> and drag the hard disk to the top (above the ISO).</p><h3>Round 2: The DNS “Split-Brain” (.home TLD)</h3><p><strong>The Problem:</strong> I could resolve the API via nslookup, but ping or the browser failed.</p><p><strong>The Fix:</strong> macOS/Linux often treat .home or .local as mDNS (Bonjour/Avahi) addresses and ignore standard DNS.</p><ul><li><strong>Deep Clean:</strong> Use sudo killall -HUP mDNSResponder.</li><li><strong>The Manual Path:</strong> I disabled IPv6 and manually set the DNS server on my laptop to the AdGuard IP, adding ocp.mydomain.lab.home as an explicit Search Domain.</li></ul><h3>Round 3: The Pull Secret Trap</h3><p><strong>The Problem:</strong> The node reaches a “pivot” point but no containers start. sudo podman ps shows nothing.</p><p><strong>The Fix:</strong> This is almost always a corrupted Pull Secret or a networking block. Ensure your VM has an unrestricted route to quay.io and registry.redhat.io. If it can&#39;t pull the images, the bootstrap will spin forever.</p><h3>Round 4: Static IP vs. DHCP Loops</h3><p><strong>The Problem:</strong> The SNO node occasionally picked up a random DHCP IP, breaking the API records I set in AdGuard.</p><p><strong>The Fix:</strong> Don’t rely on DHCP. Hardcode the <strong>Static IP</strong> directly into the agent-config.yaml before generating the ISO. This pins the node to 192.168.1.193 from the first second of boot. <strong><em>I am glad you asked why — Because this is your first time, and you wanna go to sleep at a decent 2 AM!!</em></strong></p><h3>Conclusion</h3><p>Building a lab like this is 10% following documentation and 90% fighting your own local network.<br>OpenShift didn’t want to install. My Mac didn’t want to talk to it. My router didn’t know it existed. But after three ISO regenerations and a lot of caffeine, I have a ‘Login’ screen. <br>They say you can’t buy happiness, but apparently, you can buy a Dell Optiplex(48GB !!) and suffer your way towards enlightenment.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8052f8a2f658" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boosting Developer Inner Loop Productivity with VS Code, Cline, and OpenShift Lightspeed (MCP)]]></title>
            <link>https://medium.com/@btenneti/boosting-developer-inner-loop-productivity-with-vs-code-cline-and-openshift-lightspeed-mcp-10cd337f7a31?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/10cd337f7a31</guid>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Wed, 22 Apr 2026 16:07:48 GMT</pubDate>
            <atom:updated>2026-04-23T15:45:18.613Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O4A8O8P-lcDBKnFNoXpnNw.png" /></figure><p>As the title suggests, this post walks through a quick setup for integrating <strong>VS Code</strong> with <a href="https://docs.redhat.com/en/documentation/openshift_container_platform/4.21/html/openshift_lightspeed/index"><strong>OpenShift Lightspeed</strong> </a>using the <strong>Cline extension</strong> to accelerate the developer inner loop.</p><p>If you’re building containers destined for OpenShift — or you’re a newly minted OpenShift administrator who previously managed VMware and are now <em>wondering what exactly your new role has become </em>— then <strong>OpenShift Lightspeed</strong> may become your new favorite coworker.</p><p>OpenShift Lightspeed is a generative AI-powered virtual assistant integrated directly into the OpenShift web console. Using natural language prompts, it helps IT teams — from beginners to seasoned admins — troubleshoot cluster issues, learn best practices, and simplify operational tasks.</p><h3>Why Developers Should Care?</h3><p>Because developers already have enough context switching in their lives. You’re in VS Code, making progress, and then suddenly need to:</p><ul><li>write Kubernetes or OpenShift YAML</li><li>update CI/CD pipeline configs</li><li>troubleshoot a failed deployment</li><li>understand an unfamiliar resource definition</li><li>figure out why something that worked yesterday is now “degraded”</li></ul><p>Yes, tools like Copilot or Claude can help generate code and YAML.</p><p>But when you need guidance aligned to <strong>OpenShift best practices</strong>, <strong>Red Hat-supported patterns</strong>, and real platform context, <a href="https://docs.redhat.com/en/documentation/openshift_container_platform/4.21/html/openshift_lightspeed/index"><strong>OpenShift Lightspeed</strong></a> brings a different kind of value. <br>And if that insight is available directly inside your editor, even better.</p><p>For this demo, I’ll connect both <strong>OpenShift Lightspeed</strong> and <strong>GitHub</strong> as MCP servers, bringing platform and repository context directly into VS Code.</p><h3>Prerequisites</h3><p>Before getting started, make sure you have:</p><ul><li>An <strong>OpenShift cluster running version 4.17+</strong></li><li><strong>OpenShift Lightspeed</strong> <a href="https://developers.redhat.com/articles/2025/10/09/integrate-incident-detection-openshift-lightspeed-mcp#installing_the_incident_detection_mcp_server">installed and configured</a></li><li><strong>VS Code with Cline extension</strong> installed from the Marketplace</li><li>Access to your preferred model provider (Codex, Copilot, etc.)</li><li>A <strong>GitHub Personal Access Token</strong> for GitHub MCP integration</li></ul><h3>Expose OpenShift Lightspeed via Route</h3><p>To connect Lightspeed through MCP from VS Code, expose the service using an OpenShift Route:</p><blockquote>```<br>apiVersion: route.openshift.io/v1<br>kind: Route<br>metadata:<br> name: ols-route<br> namespace: openshift-lightspeed<br>spec:<br> to:<br> name: lightspeed-app-server<br> weight: 100<br> kind: Service<br> port:<br> targetPort: https<br> tls:<br> termination: reencrypt<br> wildcardPolicy: None<br>```</blockquote><h4><strong>Local MCP Server Setup</strong></h4><blockquote>Clone the OpenShift Lightspeed MCP server locally. You will need your LightSpeed Route URL, and Token for your Cluster.<br>```<br>git clone <a href="https://github.com/thoraxe/ols-mcp.git">https://github.com/thoraxe/ols-mcp.git</a><br>```<br>(Currently this uses the local MCP server source. Future OpenShift Lightspeed releases are expected to provide a direct streamable MCP endpoint.)</blockquote><h4><strong>VS Code Setup</strong></h4><p>In Cline, configure the following MCP servers:</p><ul><li>OpenShift Lightspeed</li><li>GitHub</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VYYlz0-8kKF8O41rj9VuKA.png" /><figcaption>MCP server config for Openshift Lightspeed , and Github</figcaption></figure><h3>Example Prompts</h3><p>Once configured, you can begin prompting directly from VS Code.<br>Try asking:</p><ul><li><em>“Why is my Pod ‘&lt;&lt;web-app-v2&gt;&gt;’ stuck in </em><em>ImagePullBackOff?&quot;</em></li><li><em>“I’m getting a 503 error on my route. Can you check the health of the associated service?”</em></li><li><em>“Analyze the logs for the ‘auth-service’ pod and tell me why it crashed in the last 10 minutes.”</em></li><li><em>“What is the difference between the current deployment and the previous successful one?”</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fr06zlsdR_DueR6-_UFWjw.png" /><figcaption>Lightspeed suggesting YAML fixes</figcaption></figure><h3>Why GitHub MCP Helps</h3><p>With GitHub MCP enabled, you can also:</p><ul><li>review previous merged PRs and create new ones.</li><li>identify breaking changes</li><li>inspect commit history</li><li>correlate code changes with cluster failures</li></ul><p>For a full working example, check out: <br><a href="https://github.com/bharathi-tenneti/ols-cline-demo"><strong>https://github.com/bharathi-tenneti/ols-cline-demo</strong></a></p><h3><strong>Final Thoughts</strong></h3><p>What I like about this setup is its simplicity.<br>Instead of bouncing between VS Code, GitHub, docs, and the OpenShift console, you can bring that context into one place and keep working.</p><ul><li><strong>GitHub MCP</strong> adds repo context</li><li><strong>OpenShift Lightspeed</strong> adds platform guidance</li><li><strong>VS Code + Cline</strong> keep it all in your daily workflow</li></ul><p>It won’t replace experience, but it can save time, reduce friction, and help you stay in flow.<br>And if it cuts down the number of times you ask <em>“Why is this pod broken?”</em> — even better.</p><h4><strong>Articles and Blogs on OpenShift Lightspeed</strong></h4><ul><li><a href="https://developers.redhat.com/articles/2025/06/18/openshift-lightspeed-assessing-ai-openshift-operations#preliminary_conclusions">OpenShift Lightspeed: Assessing AI for OpenShift operations | Red Hat Developer</a></li><li><a href="https://developers.redhat.com/articles/2026/02/04/how-connect-openshift-lightspeed-mcp-your-ide#prepare_your_environment">How to connect OpenShift Lightspeed MCP to your IDE | Red Hat Developer</a></li><li><a href="https://developers.redhat.com/articles/2025/10/09/integrate-incident-detection-openshift-lightspeed-mcp#installing_the_incident_detection_mcp_server">Integrate incident detection with OpenShift Lightspeed via MCP | Red Hat Developer</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10cd337f7a31" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[✨✨ Fantastic Operators and where to find them! ✨✨]]></title>
            <link>https://medium.com/@btenneti/fantastic-operators-and-where-to-find-them-31ee26b4a552?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/31ee26b4a552</guid>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Thu, 08 Jan 2026 20:56:49 GMT</pubDate>
            <atom:updated>2026-01-08T20:56:49.479Z</atom:updated>
            <content:encoded><![CDATA[<p>Okay, You’ve installed OpenShift, brought multiple clusters up, and have your initial set of containers running. At this point, the platform is technically “live” — but for a platform administrator, this is where the real work begins.</p><p>Ensuring cluster stability, improving day-to-day operations, and making debugging easier at scale requires going beyond the default installation. Kubernetes Operators discussed below are not an exhaustive list. Instead, they reflect the ones that repeatedly showed up in customer conversations and pilot environments — solving real operational problems that platform teams encounter once clusters move beyond initial setup.</p><ol><li><strong>Node Feature Discovery (NFD) Operator</strong></li></ol><ul><li>Automatically labels nodes based on hardware, kernel, CPU, PCI, GPU, NIC, and custom features.</li><li>Critical for hardware-aware scheduling (GPU, SR-IOV, DPDK, SmartNIC workloads)</li><li>Reduces manual labeling and enables intelligent placement of specialized workloads.</li></ul><p><strong><em>Where to find:</em></strong></p><p>Redhat docs <a href="https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/specialized_hardware_and_driver_enablement/psap-node-feature-discovery-operator">NFD</a><br><a href="https://ai-on-openshift.io/odh-rhoai/nvidia-gpus/#how-does-this-work">https://ai-on-openshift.io/odh-rhoai/nvidia-gpus/#how-does-this-work</a></p><p><strong>2. Cluster Observability Operator (COO)</strong></p><p>While OpenShift’s default monitoring covers the platform itself, Cluster Observability Operator provides scalable, namespace-aware application observability through automated, and declarative monitoring stack management.</p><p><strong><em>Where to find:</em></strong><br><a href="https://docs.redhat.com/en/documentation/red_hat_openshift_cluster_observability_operator/1-latest/html/about_red_hat_openshift_cluster_observability_operator/cluster-observability-operator-overview-1">COO Redhat docs</a><br><a href="https://www.redhat.com/en/blog/unlocking-deeper-insights-new-observability-features">COO along with ACM</a></p><p><strong>3. Kube Descheduler Operator</strong></p><p>While scheduling pods on nodes comes as part of Openshfit, Kube Descheduler Operator allows you to evict pods so that they can be rescheduled on more appropriate nodes.</p><p><strong><em>Where to find:</em></strong></p><p>RedHat docs for <a href="https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/nodes/controlling-pod-placement-onto-nodes-scheduling#nodes-descheduler-configuring">Kube Descheduler Operator</a><br><a href="https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html-single/virtualization/index#virt-configuring-descheduler-evictions_virt-enabling-descheduler-evictions">Descheduler for VMs on Openshift Virtualization</a></p><p><strong>4. Fencing and Remediation (FAR) Operator</strong></p><p>The <strong>Fencing and Remediation (FAR) Operator</strong> detects failed nodes in HA OpenShift clusters and automatically fences and remediates them to maintain cluster stability.</p><p><strong><em>Where to find:</em></strong></p><p><a href="https://docs.redhat.com/en/documentation/workload_availability_for_red_hat_openshift/25.9/html/remediation_fencing_and_maintenance/fence-agents-remediation-operator-remediate-nodes">https://docs.redhat.com/en/documentation/workload_availability_for_red_hat_openshift/25.9/html/remediation_fencing_and_maintenance/fence-agents-remediation-operator-remediate-nodes</a></p><p><strong>5.</strong> <strong>Node Maintenance Operator</strong></p><p>The <strong>Node Maintenance Operator</strong> automates placing nodes into maintenance mode (cordon/drain) and bringing them back, ensuring safe eviction and rescheduling of workloads during planned maintenance.</p><p><strong><em>Where to find:</em></strong></p><p><a href="https://docs.redhat.com/en/documentation/workload_availability_for_red_hat_openshift/25.9/html-single/remediation_fencing_and_maintenance/index#installing-standalone-nmo">https://docs.redhat.com/en/documentation/workload_availability_for_red_hat_openshift/25.9/html-single/remediation_fencing_and_maintenance/index#installing-standalone-nmo</a></p><p>Deploying and managing the right OpenShift Operators ensures clusters remain stable, performant, and easy to troubleshoot as they scale — this list is not exhaustive and continues to grow as new Operators emerge to solve evolving operational challenges.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31ee26b4a552" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Apache Camel Transformation route visually with Kaoto Data mapper]]></title>
            <link>https://medium.com/@btenneti/design-apache-camel-transformation-route-visually-with-kaoto-data-mapper-2498a1afe9db?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/2498a1afe9db</guid>
            <category><![CDATA[low-code-development]]></category>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[apache-camel]]></category>
            <category><![CDATA[openshift]]></category>
            <category><![CDATA[kaoto]]></category>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Sat, 12 Apr 2025 22:13:48 GMT</pubDate>
            <atom:updated>2025-04-12T22:28:26.503Z</atom:updated>
            <content:encoded><![CDATA[<p>In this tutorial, you’ll learn how to quickly build and visualize an Apache Camel integration using the <a href="https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel/4.4/html-single/kaoto/index"><strong>Kaoto low-code editor</strong></a> and the <a href="https://access.redhat.com/webassets/avalon/d/red_hat_integration/2022.q2/apache-camel-3.14-doc/manual/3.14.x/camel-jbang.html"><strong>Camel JBang CLI</strong></a>. By using the <a href="https://developers.redhat.com/products/red-hat-build-of-apache-camel/overview"><strong>Red Hat supported Camel build</strong></a>, you ensure a fully supported path from development to deployment — seamlessly integrating with <a href="https://www.redhat.com/en/technologies/cloud-computing/openshift"><strong>Red Hat OpenShift</strong></a>, the enterprise-grade Kubernetes platform chosen for this tutorial.</p><h3>Use Case</h3><p>Let’s explore a common <strong>enterprise integration pattern</strong> where a request is received at a <strong>REST endpoint</strong>, the incoming XML data is <strong>transformed</strong>, and then <strong>routed conditionally</strong> based on its content.</p><p>In this tutorial, we’ll use the <strong>Kaoto low-code editor</strong> to visually design and implement this flow. The <strong>Kaoto Data Mapper</strong> allows us to easily map data using source and target XSD schemas, making complex transformations approachable and maintainable. We’ll also use <strong>Kaoto’s Splitter</strong> and <strong>Content-Based Router</strong> components to handle dynamic routing — sending transformed messages to appropriate <strong>AMQ queues</strong></p><h3><strong>Pre-requisites</strong></h3><ol><li>VSCode</li><li><a href="https://marketplace.visualstudio.com/items?itemName=redhat.apache-camel-extension-pack">Came extension pack for VSCode</a>.</li><li><a href="https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel/4.0/html/tooling_guide/camel-jbang?extIdCarryOver=true&amp;intcmp=7013a000003SyOEAA0&amp;sc_cid=7015Y0000045AWRQA2#installing-camel-jbang">Camel JBang CLI</a></li><li>Running Openshift cluster</li><li>AMQ Broker</li></ol><h3>Create Camel Project in VSCode</h3><p>In a destination folder opened in VsCode, Open CMD + SHFT + P command pallette in VSCode, and type Camel and select New Camel File to create camel route, pick YAML DSL for this example in next step.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D6qnai87VTLEI5dnN3crzQ.png" /></figure><p>Use Camel command to create camel-quarkus project that will wrap above created route.camel.yaml inside src/main/resources/camel folder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cE_LKuQuhwog8SMjvWSgQA.png" /></figure><p>Once the camel quarkus project gets created, you can delete the route.camel.yaml file at the root, since it will be under /src/main/resources/camel. <br>The default route.camel.yaml includes a timer that sets body for a log component.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tAv4oWAvZIjMxUGGCh_2ZA.png" /></figure><p>Use the icon on top right corner to split, and explore the source code YAML for the route, along with the visual editor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IdOFQ_dswKSpG0BDj5ogtg.png" /></figure><p>Use below command to test this route, and it should print messages every second, Hello message with routeID.</p><pre>$ mvn quarkus:dev<br></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*izI_Djx-LXTN5lB45rqVLg.png" /></figure><p>Now that you have tested the default timer route, time to develop and test the transformation route. <br>To do this, you can either use the camel kaoto editor to add components by using the + signs, or directly copy the pre created route from this <a href="https://github.com/bharathi-tenneti/camel_development_starter/blob/main/camel-examples/rest-cbr-amq/src/main/resources/camel/route.camel.yaml">repo</a>. Be sure to copy the needed applications.props, and the xsd schemas as well for the Kaoto Data Mapper to work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JHwzCfBIu4YivkUmuOa-uQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GnjnPX55kzgpxKnZy4UWSw.png" /></figure><p>You can explore the Kaoto Data Mapper, to look at the configured data mapping between shiporder.xsd -&gt; item.xsd. Note how the <strong>for-each</strong> splitter is configured on each line Item.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U2DuiW6rpJFAgr4Nji894A.png" /></figure><h3><strong>Test Locally</strong></h3><ol><li>Get AMQ broker up and running locally using podman</li></ol><pre>$ podman pull apache/activemq-artemis:latest<br>$ podman run -d -p 61616:61616 -p 8161:8161 apache/activemq-artemis:latest<br>$ podman ps</pre><ol><li>Point your browser to <strong>localhost:61616</strong>, and “<strong>artemis</strong>” should work as both username and password.</li><li>Launch transformation camel route for the rest endpoint, route should up as shown below.</li></ol><pre>mvn clean quarkus:dev</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mBqtdmMtq_P5aJTSWhSBQQ.png" /></figure><p>3. Test the rest endpoint with below sample XML message, and you should get the itemized response back, and also the messages should be routed to AMQ Queues “premium_orders”, and “general_orders”, based on the Note element in the REST request.</p><pre>$ curl -X POST http://localhost:8080/transform \ <br>-H &quot;Content-Type: application/xml&quot; \<br>-d &#39;&lt;shiporder&gt;<br>&lt;item&gt;<br>&lt;title&gt;Harry Potter&lt;/title&gt;<br>&lt;note&gt;Special Edition&lt;/note&gt;<br>&lt;price&gt;111.90&lt;/price&gt;<br>&lt;/item&gt;<br>&lt;item&gt;<br>&lt;title&gt;Lord of the Rings&lt;/title&gt;<br>&lt;note&gt;Used&lt;/note&gt;<br>&lt;price&gt;9.90&lt;/price&gt;<br>&lt;/item&gt;<br>&lt;item&gt;<br>&lt;title&gt;House of Dragons&lt;/title&gt;<br>&lt;note&gt;new&lt;/note&gt;<br>&lt;price&gt;20.90&lt;/price&gt;<br>&lt;/item&gt;<br>&lt;/shiporder&gt;&#39;</pre><p>REST Response</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;items&gt;<br>&lt;item&gt;<br>&lt;title&gt;Harry Potter&lt;/title&gt;<br>&lt;note&gt;Special Edition&lt;/note&gt;<br>&lt;quantity/&gt;<br>&lt;price&gt;111.90&lt;/price&gt;<br>&lt;/item&gt;<br>&lt;item&gt;<br>&lt;title&gt;Lord of the Rings&lt;/title&gt;<br>&lt;note&gt;Used&lt;/note&gt;<br>&lt;quantity/&gt;<br>&lt;price&gt;9.90&lt;/price&gt;<br>&lt;/item&gt;<br>&lt;item&gt;<br>&lt;title&gt;House of Dragons&lt;/title&gt;<br>&lt;note&gt;new&lt;/note&gt;<br>&lt;quantity/&gt;<br>&lt;price&gt;20.90&lt;/price&gt;<br>&lt;/item&gt;<br>&lt;/items&gt;</pre><p>AMQ Queues</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s9lmhHbV6MsOpgY2FW8RFw.png" /></figure><h3>Deploy to Openshift</h3><p>If you have a running openshift cluster, you can use the quarkus kubernetes plugin to deploy directly from your local working environment.</p><pre>mvn clean package -DskipTests -Dquarkus.kubernetes.deploy=true</pre><p>Make sure you point to a running AMQ broker to test this end to end from Red Hat Openshift.</p><h3>Additional Links</h3><p><a href="https://kaoto.io/">https://kaoto.io/</a></p><p><a href="https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel/4.4/html-single/kaoto/index">https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel/4.4/html-single/kaoto/index</a></p><p><a href="https://www.redhat.com/architect/portfolio/detail/75-kaoto-apache-camel-integration-designer-demo">https://www.youtube.com/watch?v=MRKs7uAaUOA&amp;list=PLU-T8l-XOWOPjrXPojx2WDSegigcNzKs4&amp;index=4</a></p><p><a href="https://www.redhat.com/architect/portfolio/detail/75-kaoto-apache-camel-integration-designer-demo">https://www.redhat.com/architect/portfolio/detail/75-kaoto-apache-camel-integration-designer-demo</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2498a1afe9db" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to schedule VM(Virtual Machine) snapshots using Kubernetes cron jobs — Red Hat Openshift…]]></title>
            <link>https://medium.com/@btenneti/how-to-schedule-vm-virtual-machine-snapshots-using-kubernetes-cron-jobs-red-hat-openshift-eebad658cc7f?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/eebad658cc7f</guid>
            <category><![CDATA[red-hat-openshift]]></category>
            <category><![CDATA[openshift-virtualization]]></category>
            <category><![CDATA[kubernetes-cronjob]]></category>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Wed, 18 Dec 2024 15:11:34 GMT</pubDate>
            <atom:updated>2024-12-18T21:22:50.376Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to schedule VM(Virtual Machine) snapshots using Kubernetes CronJobs — Red Hat Openshift Virtualization</h3><p>In this tutorial, we will walk through the process of creating and scheduling VM snapshots in <a href="https://www.redhat.com/en/technologies/cloud-computing/openshift/virtualization">Red Hat OpenShift Virtualization</a> (OCP Virt) using <a href="https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/">Kubernetes CronJobs</a>.</p><h4>Prerequisites</h4><ul><li>A working OpenShift cluster with OpenShift Virtualization installed.</li><li>Access to the OpenShift CLI (oc), and cluster-admin access.</li></ul><h4>Steps:</h4><h3>1. Create a Fedora VM using template.</h3><p>Start by creating a snapshot-demo project, and creating a Fedora VM within OpenShift Virtualization using GUI, you can also create using YAML directly.</p><pre>oc new-project snapshot-demo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*__TXchvhu8dRggtIqNpPtA.png" /></figure><h3>2. Create the Role and RoleBinding for Permissions</h3><p>The CronJob needs to have appropriate permissions to interact with the OpenShift Virtualization resources, including creating snapshots. We’ll create a Kubernetes Role and RoleBinding for this purpose.</p><pre>apiVersion: rbac.authorization.k8s.io/v1<br>kind: Role<br>metadata:<br>  name: snapshot-creator<br>  namespace: snapshot-demo<br>rules:<br>- apiGroups: [&quot;snapshot.storage.k8s.io&quot;]<br>  resources: [&quot;volumesnapshots&quot;, &quot;volumesnapshotcontents&quot;]<br>  verbs: [&quot;get&quot;, &quot;list&quot;, &quot;create&quot;, &quot;delete&quot;, &quot;patch&quot;]</pre><pre>apiVersion: rbac.authorization.k8s.io/v1<br>kind: RoleBinding<br>metadata:<br>  name: snapshot-creator-rolebinding<br>  namespace: snapshot-demo<br>subjects:<br>  - kind: ServiceAccount<br>    name: default<br>    namespace: snapshot-demo<br>roleRef:<br>  kind: Role<br>  name: snapshot-creator<br>  apiGroup: rbac.authorization.k8s.io</pre><pre>oc apply -f role.yaml<br>oc apply -f rolebinding.yaml</pre><h3>3. Create the CronJob to Schedule Snapshots</h3><p>Next, create a Kubernetes CronJob that will automatically schedule the snapshot creation. The CronJob will run every 10 minutes and trigger the snapshot creation .</p><p>Here’s the YAML for the CronJob:</p><pre>apiVersion: batch/v1<br>kind: CronJob<br>metadata:<br>  name: vm-snapshot-scheduler<br>spec:<br>  schedule: &quot;*/10 * * * *&quot; # Runs every 10 minutes<br>  jobTemplate:<br>    spec:<br>      template:<br>        spec:<br>          containers:<br>          - name: create-snapshot<br>            image: quay.io/openshift/origin-cli:latest<br>            command:<br>            - /bin/sh<br>            - -c<br>            - |<br>              cat &lt;&lt;EOF | oc apply -f -<br>              apiVersion: snapshot.storage.k8s.io/v1<br>              kind: VolumeSnapshot<br>              metadata:<br>                name: fedora-01-$(date +%Y%m%d%H%M)<br>                namespace: snapshot-demo<br>              spec:<br>                volumeSnapshotClassName: ocs-external-storagecluster-rbdplugin-snapclass<br>                source:<br>                  persistentVolumeClaimName: fedora-01<br>              EOF<br>          restartPolicy: OnFailure</pre><pre>oc apply -f cronjob.yaml -n snapshot-demo<br>cronjob.batch/vm-snapshot-scheduler created</pre><h3>4. Create a test job for snapshot</h3><p>Run a test job to quickly check the snapshot creation, and list out the snapshots for verification.</p><pre>oc create job --from=cronjob/vm-snapshot-scheduler test-snapshot-job -n snapshot-demo<br>job.batch/test-snapshot-job created<br><br>oc get volumesnapshots -n snapshot-demo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-C8KGnaXAiLA9VIjd5g3Dg.png" /></figure><h3>Conclusion</h3><p>This tutorial showed you how to schedule VM snapshots in OpenShift Virtualization using Kubernetes CronJobs. The process includes creating the necessary permissions with Roles and RoleBindings, defining a VirtualMachineSnapshot, and automating the snapshot creation with CronJobs.</p><p>By scheduling VM snapshots, you can ensure that the state of your virtual machines is consistently captured, enabling easier recovery and rollback to previous states.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eebad658cc7f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying JBoss EAP for Red Hat Openshift Service on AWS (ROSA)]]></title>
            <link>https://medium.com/@btenneti/deploying-jboss-eap-for-red-hat-openshift-service-on-aws-rosa-5b0d8d2bba90?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b0d8d2bba90</guid>
            <category><![CDATA[jboss]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[openshift]]></category>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Thu, 03 Nov 2022 19:34:45 GMT</pubDate>
            <atom:updated>2022-11-03T20:08:06.999Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*kQo7KBpcf2sIbox_921WOg.jpeg" /></figure><p>Redhat Openshift Service on AWS (ROSA) is a joint venture between Redhat and AWS, providing a managed way to run Openshift for organizations. This way the development teams can focus on innovation, and quickly build, deploy and scale applications. Learn more <a href="https://www.redhat.com/en/technologies/cloud-computing/openshift/aws">here</a> and <a href="https://aws.amazon.com/marketplace/pp/prodview-tnyp2h3acabm6?ref=hmpg_recommendations_widget">here</a>.</p><p>Today’s post is on how to deploy JBoss EAP application on a ROSA environment, using Redhat Container registry base image. Let’s get started!</p><blockquote><strong><em>Prerequisite<br></em></strong>Once you provision ROSA cluster via AWS Management console, you will get access to Redhat Openshift console, it will look similar to below screenshot.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cs3mwv_KsKTx2bWVAdxH2g.png" /></figure><blockquote><strong>Connect and configure Openshift environment</strong></blockquote><ol><li>Go ahead , and login to Openshift via terminal using “<em>oc login</em>” command.</li><li>Create new project/namespace for the demo</li></ol><pre><em>$ oc new-project eap-demo</em></pre><p>3. For any https-enabled features, go ahead and create a secret out of Keystore file.<br>Use keytool command to generate keystore using below command.</p><pre><em>$ keytool -genkey -keyalg RSA -alias eapdemo-selfsigned -keystore keystore.jks -validity 360 -keysize 2048</em></pre><p>4. Create an openshift secret from above keystore file.</p><pre><em>$ oc create secret generic eap7-app-secret — from-file=keystore.jks </em></pre><blockquote><strong>Authenticate Red Hat Container Registry</strong></blockquote><p>In order to use JBoss EAP for Openshift image, we need to configure authentication to the Red Hat Container Registry.</p><ol><li>Follow this link, to get your access set up, and <a href="https://access.redhat.com/terms-based-registry/#/">create a yaml file pull secret.</a></li><li>Once you get to the Token Information screen, select “Openshift Secret” tab, as we want to pull the container images for our openshift namespace.</li><li>Download, the yaml file, which will be in <em>“&lt;&lt;serviceaccount&gt;&gt;-secret.yaml” </em>format.</li><li>Create the Auth token secret, with above file.</li></ol><pre><em>$ oc create -f &lt;&lt;1234567_serviceaccount&gt;&gt;-secret.yaml</em></pre><p>5. Above command will result in a secret being created, now its time to link this secret for pull</p><pre>$<em> oc secrets link default </em>&lt;&lt;<em>1234567-serviceaccount&gt;&gt;-pull-secret — for=pull<br>$ oc secrets link builder &lt;&lt;1234567-serviceaccount&gt;&gt;-pull-secret — from=pull</em></pre><blockquote><strong>Import latest JBoss EAP Openshift Image streams and templates</strong></blockquote><ol><li>Now you are ready to import the JBoss EAP Image resources into your openshift namespace, or if you are a cluster admin, you can choose to import into all of your Openshift Projects.</li><li>Go ahead and run below script in your terminal,</li></ol><pre><em>for resource in \<br> eap72-image-stream.json \<br> eap72-amq-persistent-s2i.json \<br> eap72-amq-s2i.json \<br> eap72-basic-s2i.json \<br> eap72-https-s2i.json \<br> eap72-mongodb-persistent-s2i.json \<br> eap72-mongodb-s2i.json \<br> eap72-mysql-persistent-s2i.json \<br> eap72-mysql-s2i.json \<br> eap72-postgresql-persistent-s2i.json \<br> eap72-postgresql-s2i.json \<br> eap72-third-party-db-s2i.json \<br> eap72-tx-recovery-s2i.json \<br> eap72-sso-s2i.json<br>do<br> oc replace — force -f \<br>https://raw.githubusercontent.com/jboss-container-images/jboss-eap-7-openshift-image/eap72/templates/${resource}<br>done</em></pre><p>2. To import images across projects, please replace with below command, in above script, for ``<em>`$ oc replace ……</em>```</p><pre>……<br><em>oc replace -n openshift — force -f \</em><br>……….</pre><blockquote><strong>Deploy JBoss EAP application (s2I) to Openshift</strong></blockquote><p>It’s time, let’s deploy <em>kitchensink</em> app, from this <a href="https://github.com/bharathi-tenneti/jboss-eap-quickstarts">github repo</a>.</p><ol><li>Run below oc command from your terminal.</li></ol><pre><em>$ oc new-app — template=eap72-basic-s2i \<br>-p IMAGE_STREAM_NAMESPACE=eap-demo \<br>-p SOURCE_REPOSITORY_URL=https://github.com/jboss-developer/jboss-eap-quickstarts \<br>-p SOURCE_REPOSITORY_REF=openshift \<br>-p CONTEXT_DIR=kitchensink</em></pre><p>2. In the openshift console, you should see Build pod running at this time, creating the final S2I image. You can also follow logs from terminal.</p><pre><em>$ oc get bc -o name</em></pre><p>3. You should see Build , and Deploy pod finished as shown below. and container running.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9eKau7RThGh29JsZhck9yQ.png" /><figcaption>Pod Details</figcaption></figure><p>4. Provide the Build config name from above step</p><pre><em>$ oc logs -f buildconfig/BUILD_CONFIG_NAME</em></pre><blockquote><strong>Check Service and Route</strong></blockquote><ol><li>Check the service created for the application</li></ol><pre>$ oc get service</pre><p>2. Template should have already exposed a route, if not , go ahead and expose.</p><pre><em>$ oc expose service/SERVICE_NAME — port=8080</em></pre><blockquote><strong>Access the deployed application</strong></blockquote><p>Go to Openshift console, and navigate to Projects -&gt; Routes, and click the URL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aNs2vod9R98mgKo5DiLWhQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-F2bsvDNYy_JANepKT9CRw.png" /></figure><p>Feel free to play around with deployed app, and try to access the <strong><em>/rest/members </em></strong>REST API, to see the app in action.</p><blockquote><strong>Conclusion</strong></blockquote><p>Hopefully this article is helpful for you to get a quick start on how to deploy JBoss EAP using, Openshift container templates, and deployed on Red Hat Openshift Service on AWS (ROSA), a managed cloud service.</p><blockquote><strong><em>Important Links</em></strong></blockquote><p><a href="https://aws.amazon.com/marketplace/pp/prodview-tnyp2h3acabm6?ref=hmpg_recommendations_widget">https://aws.amazon.com/marketplace/pp/prodview-tnyp2h3acabm6?ref=hmpg_recommendations_widget</a></p><p><a href="https://www.redhat.com/en/technologies/cloud-computing/openshift/aws">https://www.redhat.com/en/technologies/cloud-computing/openshift/aws</a></p><p><a href="https://access.redhat.com/documentation/en-us/red_hat_jboss_enterprise_application_platform/7.2/html-single/getting_started_with_jboss_eap_for_openshift_container_platform/index#build_run_java_app_s2i">https://access.redhat.com/documentation/en-us/red_hat_jboss_enterprise_application_platform/7.2/html-single/getting_started_with_jboss_eap_for_openshift_container_platform/index#build_run_java_app_s2i</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5b0d8d2bba90" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is God running Kubernetes in this universe??]]></title>
            <link>https://medium.com/@btenneti/is-god-running-kubernetes-in-this-universe-477c8d813d1e?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/477c8d813d1e</guid>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Thu, 15 Sep 2022 14:40:19 GMT</pubDate>
            <atom:updated>2022-09-15T14:40:19.209Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/988/1*DbmCSjpPLfg7XydDUMF0bA.png" /></figure><p>As I am going through Day 3 of my Cloud container journey, the instructor said something that brought an epiphany that “We are all just Containers….”</p><p>“WE ARE JUST CONTAINERS…”, Sure, we might have different base images, and have different layers added to us, defining our gender, race, ethnicity etc., At the end of the day , our lifecycle is the same. We all come into this world as clean containers with few basic layers, and then we go on adding our own, making us unique, in all sorts of Good, Bad, weird ways.</p><p>In the end though, guy up there will issue “stop”, and we cease to exist, and the next time he runs, our container starts clean(re-birth).</p><p>If this doesn’t convince you that GOD/SUPER POWER is using kubernetes to manage all of us(containers..), I don’t know what will!! No wonder everything is running on cloud, or is it everyone?..hmmm…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=477c8d813d1e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Little mirrors…]]></title>
            <link>https://medium.com/@btenneti/little-mirrors-4de522ed95c1?source=rss-aef259db058d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4de522ed95c1</guid>
            <category><![CDATA[motherhood]]></category>
            <category><![CDATA[kids]]></category>
            <category><![CDATA[parenting]]></category>
            <dc:creator><![CDATA[Bharathi Tenneti]]></dc:creator>
            <pubDate>Thu, 21 Jul 2022 01:30:32 GMT</pubDate>
            <atom:updated>2025-04-13T16:53:34.465Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uSR5gy8hk-PDjPiiQ2yeMQ.png" /></figure><p>Often heard, and rarely followed idiom, “Kids see you better than they hear you”. It is baffling, how most of us raise kids through their early childhood years, without paying much attention to this point.</p><p>It is so true though! Recently I have started paying more attention to what I say to my 6 year old girl, <em>vs</em> what she is actually seeing me do. <br> — I keep telling her how makeup is bad for skin, and yet, she <em>sees</em> me putting on makeup now and then.<br> — I keep telling her how vegetables make her strong, when at the same table, she <em>sees</em> my husband quietly ignoring some.<br> — I tell her watching too much TV/Ipad is bad for eyes, and yet she <em>sees</em>, that the last thing I touch before going to bed is my phone.<br>Guess what she does now, she does <em>not</em> eat so called vegetables, watches way too much TV than we prefer, and wants to put on makeup, every time she wears a pretty dress. Somehow in her little mind, she sees these rules as being phony.</p><p>However, same rules never sounded hypo-critic coming out of my own mother, as she never had to say them out loud, I just never <em>saw</em> these things happening growing up. <br>I wonder what made my mom’s silence work, and why my repeated chanting of these rules does not, with my girl. <br>We come across many proverbs/idioms in life, which sound intelligent and thought provoking. One such being, “Be the change you want to see”, people often associate this saying with lofty ideals, similar to changing the world.</p><p>Well, it can be as simple as switching off that screen, eating right foods, and be the change that we want to see in our kids, as they are indeed our little mirrors :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4de522ed95c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>