<?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 Janakasandaruwan on Medium]]></title>
        <description><![CDATA[Stories by Janakasandaruwan on Medium]]></description>
        <link>https://medium.com/@janakasandaruwan1996?source=rss-c02e2d381a90------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Ws0Lxro5HTLX1wLN</url>
            <title>Stories by Janakasandaruwan on Medium</title>
            <link>https://medium.com/@janakasandaruwan1996?source=rss-c02e2d381a90------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 21:03:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@janakasandaruwan1996/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[Your CLI Isn’t Magic: What Actually Happens When You Deploy with occ]]></title>
            <link>https://medium.com/@janakasandaruwan1996/your-cli-isnt-magic-what-actually-happens-when-you-deploy-with-occ-774e413abc25?source=rss-c02e2d381a90------2</link>
            <guid isPermaLink="false">https://medium.com/p/774e413abc25</guid>
            <dc:creator><![CDATA[Janakasandaruwan]]></dc:creator>
            <pubDate>Thu, 30 Apr 2026 16:59:55 GMT</pubDate>
            <atom:updated>2026-04-30T16:59:55.004Z</atom:updated>
            <content:encoded><![CDATA[<p>The first time I deployed something to OpenChoreo with the CLI, I typed five commands and ended up with a running service. That sounds great until you try to debug it. Behind those five commands, the platform created five different resources, in a specific order, with specific relationships between them. If you don’t know what they are, the CLI feels like magic. Magic is fine until something breaks.</p><p>This is the walkthrough I wish I’d read first. Not “here are the commands to copy”, but “here’s what each command is doing, and why the platform is shaped this way”. We’ll go from an empty cluster to a service running across three environments. At each step, I’ll point to the resource the CLI just created on your behalf.</p><p>The CLI is occ. The flow is the same for any component you&#39;d deploy: a service, a worker, a scheduled task. I&#39;ll keep the example generic, so substitute your own component when you try this.</p><h3>The mental model, up front</h3><p>OpenChoreo separates <em>developer intent</em> from <em>what’s actually running</em>. In practice, that means five resources:</p><ul><li><strong>Component</strong> is what you, the developer, declare you want. A name, a type, some parameters.</li><li><strong>WorkflowRun</strong> is one execution of a build. Source code in, container image out.</li><li><strong>ComponentRelease</strong> is a frozen snapshot of your component plus the image that just got built. It’s immutable, and it’s the thing you promote.</li><li><strong>ReleaseBinding</strong> ties a release to a specific environment, with per-environment overrides.</li><li><strong>RenderedRelease</strong> is the final Kubernetes manifests that the dataplane runs.</li></ul><p>The CLI creates these one at a time as you go. The walkthrough is really about watching that chain assemble.</p><h3>Getting the CLI talking to a cluster</h3><p>occ is a single binary. Grab it from the GitHub releases page, or pull a build for the latestmain, drop it on yourPATH, and check it works:</p><pre>occ version</pre><p>Now point it at a control plane. The control plane is the OpenChoreo API server, where all the resources we just talked about live:</p><pre>occ config controlplane update default --url https://api.&lt;your-domain&gt;<br>occ login</pre><p>occ login opens a browser for PKCE-based auth. When it returns, you can talk to the cluster:</p><pre>occ namespace list<br>occ project list -n default</pre><p>Nothing interesting yet. We haven’t created anything. The cluster is a blank slate, and we’re about to fill it in one resource at a time.</p><h3>Declaring intent: the Component</h3><p>The natural instinct is to write a YAML manifest. Don’t. The CLI can scaffold one for you, and the reason that matters is that the scaffold isn’t a static template. It’s generated from the platform’s own schemas. Your platform team defines a ComponentType (a workload template) and a Workflow (a build template). occ scaffold reads those schemas, applies the defaults, and leaves required fields as placeholders for you to fill in.</p><pre>occ component scaffold my-service \<br>  --clustercomponenttype &lt;type&gt; \<br>  --clusterworkflow &lt;workflow&gt; \<br>  -o component.yaml</pre><p>A few practical notes:</p><ul><li>--clustercomponenttype and --clusterworkflow reference cluster-scoped resources. Use --componenttype and --workflow for namespace-scoped ones.</li><li>Add --clustertraits &lt;name&gt;,&lt;name&gt; to pre-wire traits like autoscaling, alerts, or api management. Whatever the platform team defined.</li><li>--skip-optional trims the output to just required fields. --skip-comments strips inline descriptions.</li></ul><p>Open the generated file. The first thing I’d do is set autoDeploy: false. With auto-deploy on, the platform deploys whenever you apply changes. That&#39;s convenient, but it collapses the steps we&#39;re trying to see. Manual mode forces each transition to be explicit.</p><p>Fill in the workflow parameters (your repo URL, branch, app path, whatever your build workflow asks for) and apply:</p><pre>occ apply -f component.yaml<br>occ component list</pre><p>You’ve now created a Component. That&#39;s it. No image has been built. Nothing is running. You&#39;ve declared intent, and the cluster acknowledged it.</p><h3>Building an image: the WorkflowRun</h3><p>The component knows what to build because of the workflow parameters you filled in. Triggering the build is one command:</p><pre>occ component workflow run my-service</pre><p>This creates a WorkflowRun, a concrete execution of the platform&#39;s build workflow. You can list runs and tail logs:</p><pre>occ component workflowrun list my-service<br>occ component workflowrun logs my-service</pre><p>A build usually takes a few minutes. The interesting part isn’t the build itself, since every CI system builds containers. The interesting part is that the workflow is defined by your platform team, not by you. You don’t pick a base image or write a Dockerfile unless the workflow asks you to. The platform team has already encoded the defaults, and you just get an image out the other side.</p><p>When the run finishes, the image exists. Still, nothing is running.</p><h3>Deploying: ComponentRelease and ReleaseBinding</h3><p>This is where two resources show up at once, and the distinction matters:</p><pre>occ component deploy my-service</pre><p>Under the hood, deploy creates two things. The first is a ComponentRelease: a frozen snapshot of your component, its traits, its parameters, and the workload with the image that just got built. It&#39;s immutable. If you redeploy later with a new build, you get a new release, and the old one stays around. The second is a ReleaseBinding: a record that says &quot;this release should run in this environment, with these overrides&quot;.</p><p>The release is the artifact. The binding is the deployment. That separation is why promotion across environments is cheap. You’re not rebuilding or re-snapshotting anything. You’re just making another binding that points at the same release.</p><p>Watch the binding reconcile:</p><pre>occ releasebinding list</pre><p>Wait for Ready. Once it&#39;s ready, the data plane has the rendered manifests applied, and the workload is running.</p><h3>Calling the service</h3><p>The binding’s status exposes the invoke URL once the platform has provisioned routing for it.</p><pre>INVOKE_URL=$(occ releasebinding get my-service-development | \<br>  yq &#39;.status.endpoints[0].externalURLs.http | .scheme + &quot;://&quot; + .host + &quot;:&quot; + (.port | tostring) + .path&#39;)</pre><pre>curl &quot;$INVOKE_URL/&lt;your-route&gt;&quot;</pre><p>If something looks wrong, the runtime logs are one command away:</p><pre>occ component logs my-service<br>occ component logs my-service --env development</pre><p>The --env flag matters once you have more than one environment, which is where we&#39;re going next.</p><h3>Promotion: the part that shows you the design</h3><p>Promotion is where the release/binding split earns its keep. The project has a DeploymentPipeline that defines the allowed order of environments, say development, staging, production. Promoting is just creating another binding for the same release:</p><pre>occ component deploy my-service --to staging</pre><p>No rebuild. No new release. Same artifact, new binding. That’s the model: build once, promote the same bits everywhere.</p><p>Production is where environment-specific overrides show up:</p><pre>occ component deploy my-service --to production \<br>  --set spec.componentTypeEnvironmentConfigs.replicas=3</pre><p>Same image, same release, different replica count. The override lives on the production ReleaseBinding and doesn&#39;t touch the other environments. This is the part of the model I find genuinely useful. Overrides are bound to the binding, so you can reason about each environment on its own without forking the underlying release.</p><p>If you’ve been running occ releasebinding list between each step, you can see the chain: one component, one release, three bindings.</p><h3>Cleaning up</h3><pre>occ component delete my-service</pre><p>This removes the component and the releases and bindings that hang off it.</p><h3>What you actually learned</h3><p>If you typed all this in, you watched five resources appear, in order, each one a step further from developer intent and closer to Kubernetes manifests on a data plane:</p><pre>Component → WorkflowRun → ComponentRelease → ReleaseBinding → RenderedRelease</pre><p>The CLI hides this chain behind verbs like deploy and promote. Most of the time, that&#39;s the right call. You don&#39;t want to think about five resources to ship a service. But when something does go wrong, you know where to look. A failed build is a WorkflowRun problem. A pod that won&#39;t come up is a ReleaseBinding or RenderedRelease problem. A drift between environments is an override of the binding.</p><p>That’s the value of doing it once in manual mode. After this, turn autoDeploy back on, let the platform run the chain for you on every push, and trust that you know what&#39;s happening underneath.</p><h3>Try it yourself</h3><p>If shipping a service to your platform still feels like wiring together CI scripts, Helm charts, and environment-specific glue, OpenChoreo is worth a look.</p><p>It models the path from source to running workload as a small set of resources you can see and reason about, with one CLI driving the whole flow.</p><p>OpenChoreo is open source and actively evolving.</p><ul><li>GitHub: <a href="https://github.com/openchoreo/openchoreo">https://github.com/openchoreo/openchoreo</a></li><li>CLI walkthrough sample: <a href="https://github.com/openchoreo/openchoreo/tree/release-v1.0/samples/occ-cli/go-greeter-manual-deploy">https://github.com/openchoreo/openchoreo/tree/release-v1.0/samples/occ-cli/go-greeter-manual-deploy</a></li></ul><p>Start with the sample, run through the steps in manual mode, and watch the chain from Component to RenderedRelease assemble one resource at a time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=774e413abc25" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Configuration Management in OpenChoreo: Closing the Kubernetes Gap]]></title>
            <link>https://medium.com/@janakasandaruwan1996/configuration-management-in-openchoreo-closing-the-kubernetes-gap-b76429ce4248?source=rss-c02e2d381a90------2</link>
            <guid isPermaLink="false">https://medium.com/p/b76429ce4248</guid>
            <dc:creator><![CDATA[Janakasandaruwan]]></dc:creator>
            <pubDate>Wed, 22 Apr 2026 17:25:17 GMT</pubDate>
            <atom:updated>2026-07-08T05:39:44.924Z</atom:updated>
            <content:encoded><![CDATA[<p>Every platform team starts with the same promise: Kubernetes will standardize how applications are configured and deployed.</p><p>And for a while, it does.</p><p>Until you have more than one environment. More than one cluster. More than one team.</p><p>Now configuration is scattered across ConfigMaps, Secrets, Helm values, overlays, and external vaults. Secrets leak into Git (sometimes encoded, rarely secure). Developers copy-paste “standard” environment variables from outdated docs. Platform engineers quietly maintain the wiring that holds everything together.</p><p>Nothing is fundamentally broken. But nothing is truly simple either.</p><p>This is the gap between what Kubernetes provides and what a real platform needs.</p><p>This post explores where that gap comes from and how OpenChoreo addresses it.</p><h3><strong>How Kubernetes Manages Configuration for Workloads</strong></h3><p>Kubernetes separates configuration from code using two primitives:</p><ul><li><strong>ConfigMaps</strong> for non-sensitive data</li><li><strong>Secrets</strong> for sensitive data</li></ul><p>Both are simple key-value stores, consumed by workloads either as environment variables or mounted files.</p><p>This is the Kubernetes standard, and it works. The friction begins when you try to manage these objects through GitOps.</p><h3>The GitOps Secret Problem</h3><p>GitOps is simple in spirit: your cluster state lives in Git, and a controller reconciles the cluster to match. For ConfigMaps, this is a clean fit. For Secrets, it is not.</p><p>The issue is obvious the first time you try it. A Kubernetes Secret is a YAML file with base64-encoded values. Committing it to Git means publishing the decoded values to anyone with read access to the repo. Even if the repo is private, it is a copy of sensitive data living outside your secret management system, replicated across developer laptops, CI runners, and backups.</p><p>The community has produced three main workarounds, each with its own trade-offs.</p><h4><strong>Bitnami Sealed Secrets</strong></h4><p>Sealed Secrets encrypts a Kubernetes Secret into a <em>SealedSecret</em> custom resource using an asymmetric key. A controller in the cluster holds the private key and decrypts the SealedSecret into a regular Secret at runtime. The SealedSecret is safe to commit to Git.</p><p>The mental model is simple: encrypt, then commit. There are no external dependencies beyond the controller. The trade-off is that Git becomes the source of truth for secrets again, just encrypted. There is no integration with external vaults, and rotation is painful: every rotation means re-running `kubeseal`, committing a new SealedSecret, and merging it through the pipeline for each environment. Sealing key renewal, which the controller does automatically, is often mistaken for secret rotation. It is not. The underlying values still have to be rotated by hand.</p><h4><strong>Secret Store CSI Driver</strong></h4><p>The CSI driver mounts secrets from an external store (AWS Secrets Manager, Azure Key Vault, HashiCorp Vault, GCP Secret Manager) directly into the pod filesystem through a CSI volume, configured via a `SecretProviderClass`.</p><p>Secrets stay in the external store, and rotation is centralized: rotate in the vault, and the mount reflects the new value. The main limitation is the injection model. The CSI driver is volume-mount only. If the application expects secrets as environment variables, you enable the “sync as Kubernetes Secret” side feature, which re-introduces a regular Kubernetes Secret anyway.</p><h4><strong>External Secrets Operator (ESO)</strong></h4><p>ESO takes a different approach. It introduces CRDs (<em>SecretStore</em>, <em>ClusterSecretStore</em>, <em>ExternalSecret</em>, <em>PushSecret</em>) that declare which external provider to talk to and which keys to fetch. ESO then materializes a regular Kubernetes Secret inside the cluster, kept in sync with the external store.</p><p>ESO supports 40+ providers out of the box (AWS Secrets Manager, Azure Key Vault, HashiCorp Vault, Google Cloud Secret Manager, Bitwarden, 1Password, and more). Because it produces a real Kubernetes Secret, either env var or volume mount injection works unchanged. It is declarative, versionable, and GitOps-friendly: the ExternalSecret is the thing in Git, not the value. <em>PushSecret</em> enables a controlled write path back to the provider.</p><p>They each solve a piece of the Git-vs-secret problem. But they stop at the secret layer. The platform still has to decide how configuration and secrets work for real applications, across real environments, across real clusters.</p><h3>The Real Problem: Environments, Clusters, and Governance</h3><p>Once you move beyond a single environment and a single cluster, a new class of problems appears on top of the GitOps vs secret issue.</p><p>Once you have more than one environment and more than one cluster, a second set of problems shows up on top of the GitOps-secret question.</p><h4><strong>Environment Drift</strong></h4><p>The same workload usually requires different values in dev, staging, and prod. Different log levels. Different replica counts. Different feature flags. Without a first-class place to express “this varies per environment,” teams reach for Kustomize overlays, Helm value files, or environment-specific folders, and which fields are meant to vary becomes implicit in the file layout.</p><h4><strong>Cluster and Plane Sprawl</strong></h4><p>Serious platforms rarely run on a single cluster. Different environments often live on different clusters: dev and staging on one set, production on another, with network and access boundaries between them.</p><p>At the same time, these clusters can share a single key vault per organization or multiple key vaults per cluster. The secrets differ per cluster, but the source of truth behind them is usually consolidated.</p><p>Without a shared model across the clusters, a platform engineer hand-wires each one: installing controllers, writing provider configs, inventing naming conventions, and keeping them in sync as things change. The wiring works, but it is rebuilt per cluster, per environment, per team.</p><h4><strong>Governance of Configuration and Secrets</strong></h4><p>Configuration and secrets are not just a technical artifact. They are a governance concern.</p><p>For secrets, a platform engineer wants to know where they live, who rotates them, and which clusters they land on. A developer wants to consume a secret by name without ever seeing its value or knowing which key vault it came from. In a raw Kubernetes setup, both roles end up editing the same objects, whichever mechanism wires the secret into the pod, and there is no clear line between governing a secret and using it.</p><p>Governance is not only about secrets. For example, platform engineers often want to enforce standard application configuration across every workload in the organization: a shared log format (say, structured JSON instead of plain text), a common set of environment variables, or default values for other app settings. In plain Kubernetes, there is no natural place to apply these once. Each team copies the env vars into their Deployment manifests, drift sets in, and the developers spend cycles reviewing PRs to keep things consistent.</p><p>The usual story looks like this:</p><p>1. The platform engineer creates the secret in the vault and writes whichever Kubernetes resource is needed to pull it into the right cluster.</p><p>2. The platform engineer also writes a wiki page, a Helm chart, or a template repo describing the “standard” application env vars every workload should include.</p><p>3. The developer copies most of that into their Deployment, references the secret by name, and hopes the naming convention and the standard block both stay in sync over time.</p><p>This works. It just does not scale, and it is the seam that OpenChoreo’s configuration model is built to clean up.</p><h3>OpenChoreo</h3><p>At this point, the problem is no longer about ConfigMaps, Secrets, or even GitOps.</p><p>It’s about having a <strong>coherent model</strong> for configuration and secrets across environments, clusters, and teams without pushing that complexity onto every application.</p><p>This is the gap OpenChoreo is designed to close.</p><p>For configurations, OpenChoreo does three things:</p><ul><li>Gives the developer one place to describe what the workload consumes: configs and secrets, env vars and files, in a single list.</li><li>Gives the platform engineer one place to govern where secrets come from, how they get wired, and what standard defaults apply.</li><li>Gives the platform a first-class home for per-environment differences, without overlays.</li></ul><p>None of this replaces ConfigMaps or Secrets. OpenChoreo gives each role a CRD shaped for the job they actually do, and does the wiring once.</p><h3>Configuring Workloads in OpenChoreo</h3><p>The model involves three main CRDs for configuration, plus <em>ComponentType</em> on the platform-engineer side.</p><p><strong>Step 1: The Developer Writes a Workload</strong></p><p>A <em>Workload</em> is the developer-authored runtime contract for a component. It lists everything each container consumes, with configs and secrets intermixed. Env vars and files both live under the container spec.</p><pre>apiVersion: openchoreo.dev/v1alpha1<br>kind: Workload<br>spec:<br>  container:<br>    env:<br>      - key: LOG_LEVEL              # plain env var → ConfigMap<br>        value: info<br>      - key: DATABASE_PASSWORD      # secret env var → ExternalSecret<br>        valueFrom:<br>          secretKeyRef:<br>            name: database-secret<br>            key: password<br>    files:<br>      - key: application.toml       # plain file → ConfigMap<br>        mountPath: /conf<br>        value: |<br>          schema_generation:<br>            enable: true<br>      - key: ssl.pem                # secret file → ExternalSecret<br>        mountPath: /certs<br>        valueFrom:<br>          secretKeyRef:<br>            name: certificates<br>            key: privateKey</pre><p>A few things to notice:</p><ul><li>Plain and secret values share one shape. The developer does not author ConfigMaps or Secrets directly.</li><li>The Workload is environment-independent. It says what the container needs, not what the production values happen to be.</li><li>Secret values are referenced by name. The developer never sees the actual value in Git or anywhere else.</li></ul><p><strong>Step 2: Per-Environment Overrides in ReleaseBinding</strong></p><p>Anything that should vary per environment lives in a <em>ReleaseBinding</em>. The Workload stays the same everywhere; the binding is where prod becomes prod.</p><pre>apiVersion: openchoreo.dev/v1alpha1<br>kind: ReleaseBinding<br>spec:<br>  environment: production<br>  workloadOverrides:<br>    container:<br>      env:<br>        - key: LOG_LEVEL            # override the Workload default<br>          value: error<br>        - key: FEATURE_FLAG         # prod-only value<br>          value: &quot;false&quot;<br>      files:<br>        - key: application.toml<br>          mountPath: /conf<br>          value: |<br>            schema_generation:<br>              enable: false</pre><p>There is one <em>ReleaseBinding</em> per environment. Dev, staging, and prod each bind the same <em>ComponentRelease</em> (an immutable snapshot of the component’s configuration and image) with their own overrides.</p><p><strong>Step 3: The Platform Engineer Governs Secrets with SecretReference</strong></p><p>The platform engineer creates the real secret in the vault once. Then they declare a `SecretReference` in the control plane: a pointer, nothing sensitive.</p><pre>apiVersion: openchoreo.dev/v1alpha1<br>kind: SecretReference<br>metadata:<br>  name: database-secret<br>spec:<br>  refreshInterval: 1h<br>  template:<br>    type: Opaque<br>  data:<br>    - secretKey: password<br>      remoteRef:<br>        key: secret/data/prod/db<br>        property: password</pre><p>The developer’s Workload references `<em>database-secret</em>` by name. They never touch the vault, never see the value, never know which path in Vault or Azure Key Vault the value came from. Rotation happens in the vault; ESO syncs.</p><p><strong>Step 4: The Platform Engineer Wires Configs Once, in ComponentType</strong></p><p><em>ComponentType </em>is the platform-engineer-authored template that turns a Workload into real Kubernetes resources: Deployment, Service, ConfigMaps, ExternalSecrets, volumes, mounts. It is written once and reused by every component of that type.</p><p>OpenChoreo then generates the ConfigMaps and ExternalSecrets (which ESO materializes into Kubernetes Secrets) and injects them into the workload exactly the way the ComponentType defines. The developer’s env vars and files land in the container as the template specifies. Same wiring, same naming convention, for every component that uses the type.</p><h3><strong>How It Works Under the Hood</strong></h3><p>At a high level, developers and platform engineers author CRDs on the control plane, and OpenChoreo produces the Kubernetes resources that run on the data plane.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NBxfvzJvBVLQUjffcxspFQ.png" /><figcaption><em>Fig: Control plane CRDs feed into a RenderedRelease, which is applied to the data plane. ESO syncs the Kubernetes Secret from the referenced vault secret.</em></figcaption></figure><h4><strong>Why ESO for Secret Sync</strong></h4><p>For the secret side of the flow, OpenChoreo integrates with External Secrets Operator. A few reasons:</p><ul><li><strong>Broad provider coverage:</strong> ESO supports 40+ secret backends out of the box: HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, GCP Secret Manager, and more. Platform teams are not locked into one vendor, and switching providers later is a `SecretStore` change.</li><li><strong>GitOps fit: </strong>The <em>ExternalSecret</em> is the thing that lives in Git, not the secret value. That matches the rest of OpenChoreo’s GitOps-friendly CRDs.</li><li><strong>Both injection modes work.:</strong> Because ESO produces a real Kubernetes Secret, env var, and volume mount injection both work unchanged. Developers do not have to think about which mechanism is in play underneath.</li></ul><p>At a high level, when a developer or platform engineer changes any of the control plane CRDs, OpenChoreo produces a <em>RenderedRelease</em> (the final set of Kubernetes manifests for a component in a given environment) and applies it to the target data plane. That creates the ConfigMaps, ExternalSecrets, and Deployment on the cluster. ESO then takes over for secrets: it reads each ExternalSecret, fetches the value from the configured vault, and syncs it into a Kubernetes Secret that the workload mounts or consumes as env vars.</p><h3><strong>Why This Holds at Scale</strong></h3><p>A few outcomes fall out of this model:</p><ul><li>Secrets stay out of Git. The control plane holds references, not values.</li><li>Developers consume configuration and secrets by name, environment-independent, with no access to the values.</li><li>Platform engineers govern where secrets come from and how configs get wired, once, at the SecretReference and ComponentType level.</li><li>Per-environment differences live in ReleaseBinding. No overlays to maintain.</li><li>The same architecture covers every plane with no per-plane hand-wiring.</li><li>Switching secret providers is a SecretStore change, not an application change.</li></ul><p>Configuration stops being a per-service concern. It becomes part of the platform.</p><h3><strong>Try It Yourself</strong></h3><p>If configuration and secret management still feel scattered across tools, templates, and environment-specific conventions, OpenChoreo is worth exploring.</p><p>It brings configuration, secrets, and environment handling into a single model that stays consistent across services and clusters.</p><p>OpenChoreo is open source and actively evolving.</p><ul><li>GitHub: <a href="https://github.com/openchoreo/openchoreo">https://github.com/openchoreo/openchoreo</a></li><li>Sample ComponentType with configuration: <a href="https://github.com/openchoreo/openchoreo/blob/release-v1.0/samples/component-types/component-with-configs/component-with-configs.yaml">https://github.com/openchoreo/openchoreo/blob/release-v1.0/samples/component-types/component-with-configs/component-with-configs.yaml</a></li></ul><p>Start with a simple component and see how workloads, secrets, and environments are modeled together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b76429ce4248" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>