10bingo opened a new issue, #2408:
URL: https://github.com/apache/apisix-ingress-controller/issues/2408

   ### Issue description
   
   Hi APISIX team,
   
   We’re using a production deployment setup based on 
apisix-ingress-controller, Apache APISIX, and APISIX Dashboard.
   In this setup, our DevOps team manages ApisixRoute CRD resources, while the 
development team is responsible for configuring route-level plugins (e.g., 
plugins configured via Dashboard or Admin API).
   
   However, we’re encountering a serious usability issue:
   
   ❗ Problem
   When the DevOps team updates an ApisixRoute resource (e.g., via kubectl 
apply or GitOps pipeline), any plugin configurations that were previously 
applied by the development team via Dashboard are overwritten/lost.
   
   This creates a broken workflow:
   
   Developers configure plugins via Dashboard (which calls the Admin API).
   
   Later, when CRDs are updated (e.g., route path or upstream), the plugins 
configured via Admin API are replaced by what's defined in the CRD (which may 
not contain plugin section).
   
   The plugin configuration is not preserved, even if it was working fine 
before.
   
   🤝 Expected Collaboration Model
   We want to decouple responsibilities like this:
   
   DevOps manages routing and upstreams via ApisixRoute.
   
   Developers manage plugin configuration via Dashboard (Admin API).
   
   But currently there is no official way to synchronize or preserve Admin 
API-based plugin changes when CRD-based route updates happen.
   
   ✅ What we’re asking for
   We’d like to know:
   
   Is there an official best practice for separating CRD-based routing and 
Admin API-based plugin configuration?
   
   Could APISIX Ingress Controller preserve Admin API plugin config (or at 
least detect drift)?
   
   Could a hybrid model be supported where plugins configured by developers via 
Admin API are merged or patched during CRD sync?
   
   If not yet supported, would the team accept a proposal to add a "plugin 
preservation" or "plugin layering" mechanism?
   
   📌 Temporary Workaround Considered
   We’re currently considering writing a custom sync controller that:
   
   Watches for ApisixRoute changes in the cluster
   
   Detects whether a route has been updated
   
   Then calls Admin API to reapply or merge the expected plugin configuration
   
   But this feels error-prone and redundant if it could be supported by the 
APISIX Ingress Controller natively.
   
   ### Environment
   
   we use lastest apisix-ingress-controller and apisix 3.12
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscr...@apisix.apache.org.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org

Reply via email to