You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by xu...@apache.org on 2026/04/27 03:25:03 UTC

(dubbo-go-pixiu) branch develop updated: use hot reload update gateway (#892)

This is an automated email from the ASF dual-hosted git repository.

Alanxtl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/dubbo-go-pixiu.git


The following commit(s) were added to refs/heads/develop by this push:
     new ad9b844e use hot reload update gateway (#892)
ad9b844e is described below

commit ad9b844e2d1dfe9528d9efbbc9f60d89c04da553
Author: Joe Zhong <11...@qq.com>
AuthorDate: Mon Apr 27 11:24:58 2026 +0800

    use hot reload update gateway (#892)
    
    * use hot reload update gateway
    
    fix gofmt
    
    fix imports-formatter
    
    fix golangci-lint
    
    fix typo
    
    fix typo
    
    fix gofmt
    
    fix imports-formatter
    
    chore: trigger CI to recheck linter
    
    fix: rewrite http_handler to fix gofmt issue
    
    fix: split variable declaration to fix gofmt issue
    
    fix: inline map to avoid gofmt issue
    
    fix: apply gofmt formatting to http_handler.go
    
    fix: replace interface{} with string map and handle Body.Close error
    
    fix: guard against nil server in GetRouterManager to prevent panic in tests
    
    * Potential fix for pull request finding
    
    Co-authored-by: Copilot Autofix powered by AI <17...@users.noreply.github.com>
    
    * build(deps): bump minimatch from 3.1.2 to 3.1.5 in /admin/web (#883)
    
    Bumps [minimatch](https://github.com/isaacs/minimatch) from 3.1.2 to 3.1.5.
    - [Changelog](https://github.com/isaacs/minimatch/blob/main/changelog.md)
    - [Commits](https://github.com/isaacs/minimatch/compare/v3.1.2...v3.1.5)
    
    ---
    updated-dependencies:
    - dependency-name: minimatch
      dependency-version: 3.1.5
      dependency-type: indirect
    ...
    
    Signed-off-by: dependabot[bot] <su...@github.com>
    Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
    
    * Admin opa backend (#877)
    
    * add the OPA on the admin without readme
    
    * fmt
    
    * add the description of change in readme
    
    * remove the log
    
    * fix the issue
    
    * fix the issue
    
    * delete the log and improve the yml of docker
    
    * remove the redundent -
    
    * add the newLine
    
    * fix(admin): honor OPA request timeout with context and add 30s fallback
    
    * build(deps): bump go.opentelemetry.io/otel/sdk in /controllers (#887)
    
    Bumps [go.opentelemetry.io/otel/sdk](https://github.com/open-telemetry/opentelemetry-go) from 1.37.0 to 1.40.0.
    - [Release notes](https://github.com/open-telemetry/opentelemetry-go/releases)
    - [Changelog](https://github.com/open-telemetry/opentelemetry-go/blob/main/CHANGELOG.md)
    - [Commits](https://github.com/open-telemetry/opentelemetry-go/compare/v1.37.0...v1.40.0)
    
    ---
    updated-dependencies:
    - dependency-name: go.opentelemetry.io/otel/sdk
      dependency-version: 1.40.0
      dependency-type: indirect
    ...
    
    Signed-off-by: dependabot[bot] <su...@github.com>
    Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
    
    * feat: Add KVCache offload funtion in PIXIU gateway (#878)
    
    * feat: KV Cache
    
    * fix: fix some problems
    
    * feat: add KVCache feats
    
    * feat: v2
    
    * feat: v2
    
    * chore: ignore .worktrees
    
    * fix: fix some bugs
    
    * feat: v3
    
    * feat: v4
    
    * feat: fix some problems
    
    * fix: delete some unuesd gomod
    
    * fix: fix some problems
    
    * fix: fix some problems
    
    * add apache lisences
    
    * fix: fix some problems
    
    * fix: add unit test and fix some problems
    
    * fix: delete some unused code
    
    * fix: add docs
    
    * feat: add some new features
    
    * build(deps): bump go.opentelemetry.io/otel/sdk from 1.21.0 to 1.40.0 (#890)
    
    Bumps [go.opentelemetry.io/otel/sdk](https://github.com/open-telemetry/opentelemetry-go) from 1.21.0 to 1.40.0.
    - [Release notes](https://github.com/open-telemetry/opentelemetry-go/releases)
    - [Changelog](https://github.com/open-telemetry/opentelemetry-go/blob/main/CHANGELOG.md)
    - [Commits](https://github.com/open-telemetry/opentelemetry-go/compare/v1.21.0...v1.40.0)
    
    ---
    updated-dependencies:
    - dependency-name: go.opentelemetry.io/otel/sdk
      dependency-version: 1.40.0
      dependency-type: direct:production
    ...
    
    Signed-off-by: dependabot[bot] <su...@github.com>
    Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
    
    * feat(auth/saml): add SAML authentication filter (#893)
    
    * feat(auth/saml): add initial SAML auth filter scaffold
    
    * feat(auth/saml): implement core SAML authentication logic
    
    * test(auth/saml): add unit tests for SAML filter
    
    * fix(auth/saml): address code review findings
    
      - Distinguish ErrNoSession from other session errors in Decode()
      - DeepCopy config in PrepareFilterChain to avoid pointer sharing
      - Strip client-supplied SAML-controlled headers to prevent spoofing
      - Set CookieSameSite for cross-site ACS POST compatibility
      - Fix gofmt formatting in config_test.go
    
    * docs(auth/saml): add SAML filter user documentation
    
    * chore: revert .gitignore to upstream state
    
    * style: format plugin registry
    
    * refactor(auth/saml): reduce Apply complexity
    
    * style(auth/saml): format imports with imports-formatter
    
    * docs(auth/saml): add Chinese user guide
    
    * build(deps): bump github.com/buger/jsonparser in /tools/benchmark (#898)
    
    Bumps [github.com/buger/jsonparser](https://github.com/buger/jsonparser) from 1.1.1 to 1.1.2.
    - [Release notes](https://github.com/buger/jsonparser/releases)
    - [Commits](https://github.com/buger/jsonparser/compare/v1.1.1...v1.1.2)
    
    ---
    updated-dependencies:
    - dependency-name: github.com/buger/jsonparser
      dependency-version: 1.1.2
      dependency-type: indirect
    ...
    
    Signed-off-by: dependabot[bot] <su...@github.com>
    Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
    
    * build(deps-dev): bump picomatch from 2.3.1 to 2.3.2 in /admin/web (#899)
    
    Bumps [picomatch](https://github.com/micromatch/picomatch) from 2.3.1 to 2.3.2.
    - [Release notes](https://github.com/micromatch/picomatch/releases)
    - [Changelog](https://github.com/micromatch/picomatch/blob/master/CHANGELOG.md)
    - [Commits](https://github.com/micromatch/picomatch/compare/2.3.1...2.3.2)
    
    ---
    updated-dependencies:
    - dependency-name: picomatch
      dependency-version: 2.3.2
      dependency-type: indirect
    ...
    
    Signed-off-by: dependabot[bot] <su...@github.com>
    Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
    
    * fix 1
    
    * fix 2
    
    * fix 3
    
    * fix 4
    
    * fix 5
    
    * fix 6
    
    * fix 7
    
    * fix 8
    
    * fix check
    
    * fix lint
    
    * fix 9
    
    * fix 10
    
    * fix 11
    
    * fix 12
    
    * fix check
    
    ---------
    
    Signed-off-by: dependabot[bot] <su...@github.com>
    Co-authored-by: Copilot Autofix powered by AI <17...@users.noreply.github.com>
    Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
    Co-authored-by: nanjiek <12...@users.noreply.github.com>
    Co-authored-by: 陈乐樂 <12...@qq.com>
    Co-authored-by: linmao <lm...@gmail.com>
---
 controllers/internal/controller/config/config.go   |   2 +-
 .../internal/controller/gateway_controller.go      | 295 +++++++++++++++++++--
 controllers/internal/converter/converter.go        |   9 +-
 controllers/internal/converter/pixiu_config.go     |   3 +-
 controllers/internal/converter/policy_applier.go   |  19 +-
 pkg/cmd/gateway.go                                 |  10 +-
 pkg/common/http/manager.go                         |   4 +
 pkg/common/router/router.go                        |  29 +-
 pkg/config/config_load.go                          |  18 +-
 pkg/hotreload/cluster_reloader.go                  | 164 ++++++++++++
 pkg/hotreload/hotreload.go                         |   4 +-
 pkg/hotreload/http_handler.go                      | 289 ++++++++++++++++++++
 pkg/hotreload/logger.go                            |   4 -
 pkg/hotreload/route_reloader.go                    |  51 ++--
 pkg/server/listener_manager.go                     |   9 +-
 pkg/server/pixiu_start.go                          |   3 +
 pkg/server/router_manager.go                       |  59 ++++-
 17 files changed, 906 insertions(+), 66 deletions(-)

diff --git a/controllers/internal/controller/config/config.go b/controllers/internal/controller/config/config.go
index a60d9db4..16570ad4 100644
--- a/controllers/internal/controller/config/config.go
+++ b/controllers/internal/controller/config/config.go
@@ -33,7 +33,7 @@ const (
 	DefaultLogLevel         = "info"
 	DefaultMetricsAddr      = ":8080"
 	DefaultProbeAddr        = ":8081"
-	DefaultGatewayImage     = "dubboregistry/pixiu-proxy:v1.1.0"
+	DefaultGatewayImage     = "dubbogopixiu/pixiu-proxy:v1.1.0"
 	DefaultImagePullPolicy  = "IfNotPresent"
 )
 
diff --git a/controllers/internal/controller/gateway_controller.go b/controllers/internal/controller/gateway_controller.go
index d630ea07..03eb9ef2 100644
--- a/controllers/internal/controller/gateway_controller.go
+++ b/controllers/internal/controller/gateway_controller.go
@@ -24,8 +24,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
+	"net/http"
 	"reflect"
 	"strings"
+	"sync"
+	"time"
 )
 
 import (
@@ -529,18 +533,80 @@ func (r *GatewayReconciler) ensureGatewayConfigMap(ctx context.Context, gateway
 			isGatewayPolicy := policy.Spec.TargetRef.Kind == "Gateway" &&
 				string(policy.Spec.TargetRef.Name) == gateway.Name
 
+			r.Log.Info("processing cluster policy", "policy", policy.Name, "isGatewayPolicy", isGatewayPolicy)
+
 			if isGatewayPolicy {
 				for j := range policy.Spec.ClusterRef {
 					clusterConfig := &policy.Spec.ClusterRef[j]
 					clusterConfigMap[clusterConfig.Name] = clusterConfig
+					r.Log.Info("added cluster config", "clusterName", clusterConfig.Name, "endpointCount", len(clusterConfig.Endpoints))
 				}
 			} else {
 				for j := range policy.Spec.ServiceRef {
 					serviceConfig := &policy.Spec.ServiceRef[j]
 					serviceConfigMap[serviceConfig.Name] = serviceConfig
+					r.Log.Info("added service config", "serviceName", serviceConfig.Name, "endpointCount", len(serviceConfig.Endpoints))
 				}
 			}
 		}
+
+		r.Log.Info("cluster policy maps", "clusterConfigCount", len(clusterConfigMap), "serviceConfigCount", len(serviceConfigMap))
+
+		for _, cluster := range pixiuConfig.StaticResources.Clusters {
+			r.Log.Info("generated cluster", "name", cluster.Name, "endpointCount", len(cluster.Endpoints))
+		}
+
+		for _, cluster := range pixiuConfig.StaticResources.Clusters {
+			originalEndpoints := cluster.Endpoints
+			originalEndpointCount := len(originalEndpoints)
+
+			r.Log.Info("cluster before policy", "cluster", cluster.Name, "endpointCount", originalEndpointCount)
+
+			if clusterConfig, ok := clusterConfigMap[cluster.Name]; ok {
+				r.Log.Info("applying cluster config (exact match)", "cluster", cluster.Name, "hasEndpoints", len(clusterConfig.Endpoints) > 0)
+				if err := r.resolveClusterEndpoints(ctx, gateway.Namespace, cluster, clusterConfig); err != nil {
+					r.Log.Error(err, "failed to resolve cluster endpoints", "cluster", cluster.Name)
+				}
+				converter.ApplyClusterConfig(cluster, clusterConfig)
+			} else {
+				// match without namespace prefix (e.g., "default-service" -> "service")
+				parts := strings.SplitN(cluster.Name, "-", 2)
+				if len(parts) == 2 {
+					shortName := parts[1]
+					if clusterConfig, ok := clusterConfigMap[shortName]; ok {
+						r.Log.Info("applying cluster config (short name match)", "cluster", cluster.Name, "shortName", shortName, "hasEndpoints", len(clusterConfig.Endpoints) > 0)
+						if err := r.resolveClusterEndpoints(ctx, gateway.Namespace, cluster, clusterConfig); err != nil {
+							r.Log.Error(err, "failed to resolve cluster endpoints", "cluster", cluster.Name)
+						}
+						converter.ApplyClusterConfig(cluster, clusterConfig)
+					}
+				}
+			}
+
+			if serviceConfig, ok := serviceConfigMap[cluster.Name]; ok {
+				r.Log.Info("applying service cluster config (exact match)", "cluster", cluster.Name, "hasEndpoints", len(serviceConfig.Endpoints) > 0)
+				r.resolveServiceClusterEndpoints(ctx, gateway.Namespace, cluster, serviceConfig)
+				converter.ApplyClusterPolicy(cluster, serviceConfig)
+			} else {
+				parts := strings.SplitN(cluster.Name, "-", 2)
+				if len(parts) == 2 {
+					shortName := parts[1]
+					if serviceConfig, ok := serviceConfigMap[shortName]; ok {
+						r.Log.Info("applying service cluster config (short name match)", "cluster", cluster.Name, "shortName", shortName, "hasEndpoints", len(serviceConfig.Endpoints) > 0)
+						r.resolveServiceClusterEndpoints(ctx, gateway.Namespace, cluster, serviceConfig)
+						converter.ApplyClusterPolicy(cluster, serviceConfig)
+					}
+				}
+			}
+
+			if len(cluster.Endpoints) == 0 && originalEndpointCount > 0 {
+				r.Log.Info("policy resulted in no endpoints, restoring original endpoints",
+					"cluster", cluster.Name, "originalCount", originalEndpointCount)
+				cluster.Endpoints = originalEndpoints
+			}
+
+			r.Log.Info("cluster after policy", "cluster", cluster.Name, "endpointCount", len(cluster.Endpoints))
+		}
 	}
 
 	var filterPolicyList v1alpha1.PixiuFilterPolicyList
@@ -618,6 +684,12 @@ func (r *GatewayReconciler) ensureGatewayConfigMap(ctx context.Context, gateway
 				return "", fmt.Errorf("failed to update configmap: %w", err)
 			}
 			r.Log.Info("updated gateway configmap", "gateway", gateway.GetName(), "configmap", configMapName)
+
+			deploymentName := fmt.Sprintf("%s-%s", gateway.GetName(), string(gateway.GetUID())[:8])
+			if err := r.triggerHotReload(ctx, gateway, deploymentName); err != nil {
+				return "", fmt.Errorf("failed to trigger hot reload after configmap update: %w", err)
+			}
+			r.Log.Info("hot reload triggered successfully after configmap update", "gateway", gateway.GetName())
 		}
 	}
 
@@ -684,6 +756,11 @@ func (r *GatewayReconciler) ensureDataPlane(ctx context.Context, gateway *gatewa
 									ContainerPort: 8888,
 									Protocol:      corev1.ProtocolTCP,
 								},
+								{
+									Name:          "reload",
+									ContainerPort: 18380,
+									Protocol:      corev1.ProtocolTCP,
+								},
 							},
 							VolumeMounts: []corev1.VolumeMount{
 								{
@@ -729,12 +806,20 @@ func (r *GatewayReconciler) ensureDataPlane(ctx context.Context, gateway *gatewa
 		needsUpdate := false
 		existingHash := existingDeployment.Spec.Template.Annotations["pixiu.apache.org/config-hash"]
 		if existingHash != configHash {
-			r.Log.Info("config hash changed, triggering deployment update",
+			r.Log.Info("config hash changed, triggering hot reload",
 				"gateway", gateway.GetName(),
 				"deployment", deploymentName,
 				"oldHash", existingHash,
 				"newHash", configHash)
-			needsUpdate = true
+
+			if err := r.triggerHotReload(ctx, gateway, deploymentName); err != nil {
+				r.Log.Error(err, "failed to trigger hot reload, will update deployment", "gateway", gateway.GetName())
+				needsUpdate = true
+			} else {
+				// Update annotation only after successful hot reload
+				existingDeployment.Spec.Template.Annotations["pixiu.apache.org/config-hash"] = configHash
+				needsUpdate = true
+			}
 		}
 		if !reflect.DeepEqual(existingDeployment.Spec, deployment.Spec) {
 			needsUpdate = true
@@ -962,10 +1047,28 @@ func (r *GatewayReconciler) resolveClusterEndpoints(ctx context.Context, namespa
 	}
 
 	resolvedEndpoints := []*converter.Endpoint{}
+	resolveFailed := false
 	for _, epConfig := range clusterConfig.Endpoints {
 		if !isIPAddress(epConfig.Address) {
 			serviceName, serviceNamespace := parseServiceAddress(epConfig.Address, namespace)
+			r.Log.Info("resolving service DNS to Pod IPs", "address", epConfig.Address, "serviceName", serviceName, "namespace", serviceNamespace)
+
+			podEndpoints, err := r.resolveServiceEndpoints(ctx, serviceNamespace, serviceName, epConfig.Port)
+			if err == nil && len(podEndpoints) > 0 {
+				r.Log.Info("resolved service to Pod endpoints", "service", serviceName, "endpointCount", len(podEndpoints))
+				for _, podEp := range podEndpoints {
+					resolvedEndpoints = append(resolvedEndpoints, &converter.Endpoint{
+						ID: len(resolvedEndpoints) + 1,
+						SocketAddress: converter.SocketAddress{
+							Address: podEp.Address,
+							Port:    int(podEp.Port),
+						},
+					})
+				}
+				continue
+			}
 
+			r.Log.Info("failed to resolve to Pod IPs, trying Service ClusterIP", "service", serviceName, "error", err)
 			clusterIP, svcPort, err := r.resolveServiceClusterIP(ctx, serviceNamespace, serviceName, epConfig.Port)
 			if err == nil && clusterIP != "" {
 				resolvedEndpoints = append(resolvedEndpoints, &converter.Endpoint{
@@ -983,18 +1086,8 @@ func (r *GatewayReconciler) resolveClusterEndpoints(ctx context.Context, namespa
 				continue
 			}
 
-			resolvedEndpoints = append(resolvedEndpoints, &converter.Endpoint{
-				ID: func() int {
-					if epConfig.ID != nil {
-						return int(*epConfig.ID)
-					}
-					return len(resolvedEndpoints) + 1
-				}(),
-				SocketAddress: converter.SocketAddress{
-					Address: epConfig.Address,
-					Port:    int(epConfig.Port),
-				},
-			})
+			resolveFailed = true
+			r.Log.Info("failed to resolve service, skipping this endpoint", "address", epConfig.Address, "error", err)
 			continue
 		}
 
@@ -1012,9 +1105,14 @@ func (r *GatewayReconciler) resolveClusterEndpoints(ctx context.Context, namespa
 		})
 	}
 
-	if len(resolvedEndpoints) > 0 {
-		cluster.Endpoints = resolvedEndpoints
+	if len(resolvedEndpoints) == 0 {
+		if resolveFailed {
+			return fmt.Errorf("failed to resolve configured endpoints from ClusterPolicy")
+		}
+		return fmt.Errorf("ClusterPolicy configured no usable endpoints")
 	}
+
+	cluster.Endpoints = resolvedEndpoints
 	return nil
 }
 
@@ -1046,14 +1144,16 @@ func (r *GatewayReconciler) resolveServiceEndpoints(ctx context.Context, namespa
 					for _, endpointPort := range endpointSlice.Ports {
 						if endpointPort.Port != nil && endpointPort.Name != nil {
 							targetPort = int32(*endpointPort.Port)
-							return nil, nil
+							break // Found port, break to use it
 						}
 					}
 
-					for _, endpointPort := range endpointSlice.Ports {
-						if endpointPort.Port != nil {
-							targetPort = int32(*endpointPort.Port)
-							return nil, nil
+					if targetPort == port {
+						for _, endpointPort := range endpointSlice.Ports {
+							if endpointPort.Port != nil {
+								targetPort = int32(*endpointPort.Port)
+								break // Found port, break to use it
+							}
 						}
 					}
 				}
@@ -1159,3 +1259,156 @@ func isNumeric(s string) bool {
 	}
 	return len(s) > 0
 }
+
+// resolveServiceClusterEndpoints resolves Service DNS names in ServiceClusterConfig endpoints to actual IPs
+func (r *GatewayReconciler) resolveServiceClusterEndpoints(ctx context.Context, namespace string, cluster *converter.Cluster, serviceConfig *v1alpha1.ServiceClusterConfig) {
+	if len(serviceConfig.Endpoints) == 0 {
+		return
+	}
+
+	resolved := make([]v1alpha1.EndpointConfig, 0, len(serviceConfig.Endpoints))
+	idCounter := 1
+
+	for i := range serviceConfig.Endpoints {
+		ep := &serviceConfig.Endpoints[i]
+		if isIPAddress(ep.Address) {
+			// Keep IP addresses as-is
+			resolved = append(resolved, *ep)
+			idCounter++
+			continue
+		}
+
+		serviceName, serviceNamespace := parseServiceAddress(ep.Address, namespace)
+		r.Log.Info("resolving service DNS", "address", ep.Address, "serviceName", serviceName, "namespace", serviceNamespace)
+
+		endpoints, err := r.resolveServiceEndpoints(ctx, serviceNamespace, serviceName, ep.Port)
+		if err == nil && len(endpoints) > 0 {
+			r.Log.Info("resolved service to endpoints", "service", serviceName, "endpointCount", len(endpoints))
+			for _, resolvedEp := range endpoints {
+				id := int32(idCounter)
+				resolved = append(resolved, v1alpha1.EndpointConfig{
+					ID:      &id,
+					Address: resolvedEp.Address,
+					Port:    resolvedEp.Port,
+				})
+				idCounter++
+			}
+		} else {
+			r.Log.Info("failed to resolve service, keeping original address", "service", serviceName, "error", err)
+			// Keep the original unresolved entry
+			resolved = append(resolved, *ep)
+			idCounter++
+		}
+	}
+
+	serviceConfig.Endpoints = resolved
+}
+
+// triggerHotReload triggers hot reload on all pods in the deployment
+func (r *GatewayReconciler) triggerHotReload(ctx context.Context, gateway *gatewayv1.Gateway, _ string) error {
+	configMapName := fmt.Sprintf("%s-config", gateway.GetName())
+	configMap := &corev1.ConfigMap{}
+	if err := r.Get(ctx, client.ObjectKey{
+		Name:      configMapName,
+		Namespace: gateway.GetNamespace(),
+	}, configMap); err != nil {
+		return fmt.Errorf("failed to get configmap: %w", err)
+	}
+
+	configYAML, ok := configMap.Data["conf.yaml"]
+	if !ok {
+		return fmt.Errorf("conf.yaml not found in configmap")
+	}
+
+	httpClient := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	podList := &corev1.PodList{}
+	if err := r.List(ctx, podList,
+		client.InNamespace(gateway.GetNamespace()),
+		client.MatchingLabels{
+			"app.kubernetes.io/name":                 "pixiu-gateway",
+			"gateway.networking.k8s.io/gateway-name": gateway.GetName(),
+		}); err != nil {
+		return fmt.Errorf("failed to list pods: %w", err)
+	}
+
+	if len(podList.Items) == 0 {
+		r.Log.Info("no pods found for hot reload", "gateway", gateway.GetName())
+		return nil
+	}
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	var successCount int
+	var failureCount int
+
+	for _, pod := range podList.Items {
+		pod := pod
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			if pod.Status.Phase != corev1.PodRunning {
+				r.Log.Info("skipping non-running pod", "pod", pod.Name, "phase", pod.Status.Phase)
+				return
+			}
+
+			podIP := pod.Status.PodIP
+			if podIP == "" {
+				r.Log.Info("pod has no IP address", "pod", pod.Name)
+				return
+			}
+
+			reloadURL := fmt.Sprintf("http://%s:18380/-/reload", podIP)
+			r.Log.Info("triggering hot reload", "pod", pod.Name, "url", reloadURL)
+
+			req, err := http.NewRequestWithContext(ctx, http.MethodPost, reloadURL, strings.NewReader(configYAML))
+			if err != nil {
+				r.Log.Error(err, "failed to create reload request", "pod", pod.Name)
+				mu.Lock()
+				failureCount++
+				mu.Unlock()
+				return
+			}
+			req.Header.Set("Content-Type", "application/x-yaml")
+
+			resp, err := httpClient.Do(req)
+			if err != nil {
+				r.Log.Error(err, "failed to trigger hot reload", "pod", pod.Name, "url", reloadURL)
+				mu.Lock()
+				failureCount++
+				mu.Unlock()
+				return
+			}
+
+			_, _ = io.Copy(io.Discard, resp.Body)
+			if closeErr := resp.Body.Close(); closeErr != nil {
+				r.Log.Error(closeErr, "failed to close reload response body", "pod", pod.Name)
+			}
+
+			mu.Lock()
+			defer mu.Unlock()
+			if resp.StatusCode == http.StatusOK {
+				r.Log.Info("hot reload successful", "pod", pod.Name)
+				successCount++
+				return
+			}
+
+			failureCount++
+			r.Log.Error(fmt.Errorf("unexpected status code: %d", resp.StatusCode),
+				"hot reload failed", "pod", pod.Name)
+		}()
+	}
+
+	wg.Wait()
+
+	if successCount == 0 {
+		return fmt.Errorf("hot reload failed on all pods")
+	}
+
+	r.Log.Info("hot reload completed", "gateway", gateway.GetName(),
+		"successCount", successCount, "failureCount", failureCount, "totalPods", len(podList.Items))
+	return nil
+}
diff --git a/controllers/internal/converter/converter.go b/controllers/internal/converter/converter.go
index 062e8cca..df48a4c0 100644
--- a/controllers/internal/converter/converter.go
+++ b/controllers/internal/converter/converter.go
@@ -184,7 +184,8 @@ func (c *Converter) convertHTTPListener(httpListener *ir.HTTPListener, clusters
 
 	hcmConfig := HTTPConnectionManagerConfig{
 		RouteConfig: RouteConfiguration{
-			Routes: routes,
+			Routes:  routes,
+			Dynamic: true,
 		},
 		HTTPFilters: httpFilters,
 	}
@@ -298,7 +299,8 @@ func (c *Converter) convertTripleListener(tcpListener *ir.TCPListener, clusters
 
 	dubboConfig := DubboConnectionManagerConfig{
 		RouteConfig: RouteConfiguration{
-			Routes: routes,
+			Routes:  routes,
+			Dynamic: true,
 		},
 		DubboFilters: dubboFilters,
 	}
@@ -359,7 +361,8 @@ func (c *Converter) convertTCPListener(tcpListener *ir.TCPListener, clusters []*
 
 		dubboConfig := DubboConnectionManagerConfig{
 			RouteConfig: RouteConfiguration{
-				Routes: routes,
+				Routes:  routes,
+				Dynamic: true,
 			},
 			DubboFilters: dubboFilters,
 		}
diff --git a/controllers/internal/converter/pixiu_config.go b/controllers/internal/converter/pixiu_config.go
index 1805d760..68cf7325 100644
--- a/controllers/internal/converter/pixiu_config.go
+++ b/controllers/internal/converter/pixiu_config.go
@@ -73,7 +73,8 @@ type DubboFilter struct {
 }
 
 type RouteConfiguration struct {
-	Routes []*Route `yaml:"routes" json:"routes"`
+	Routes  []*Route `yaml:"routes" json:"routes"`
+	Dynamic bool     `yaml:"dynamic" json:"dynamic"`
 }
 
 type Route struct {
diff --git a/controllers/internal/converter/policy_applier.go b/controllers/internal/converter/policy_applier.go
index 44c22712..4060a9e8 100644
--- a/controllers/internal/converter/policy_applier.go
+++ b/controllers/internal/converter/policy_applier.go
@@ -154,8 +154,23 @@ func ApplyClusterConfig(cluster *Cluster, clusterConfig *v1alpha1.ClusterConfig)
 		cluster.Type = clusterConfig.Type
 	}
 
-	// Endpoints are already resolved in gateway_controller.go
-	// This function is called after endpoints are resolved
+	if len(clusterConfig.Endpoints) > 0 {
+		cluster.Endpoints = []*Endpoint{}
+		for i, ep := range clusterConfig.Endpoints {
+			endpoint := &Endpoint{
+				SocketAddress: SocketAddress{
+					Address: ep.Address,
+					Port:    int(ep.Port),
+				},
+			}
+			if ep.ID != nil {
+				endpoint.ID = int(*ep.ID)
+			} else {
+				endpoint.ID = i + 1
+			}
+			cluster.Endpoints = append(cluster.Endpoints, endpoint)
+		}
+	}
 }
 
 // ApplyFilterPolicy applies PixiuFilterPolicy config to ir.HTTPFilter
diff --git a/pkg/cmd/gateway.go b/pkg/cmd/gateway.go
index 84a7a992..7accdc37 100644
--- a/pkg/cmd/gateway.go
+++ b/pkg/cmd/gateway.go
@@ -116,6 +116,14 @@ func (d *DefaultDeployer) initialize() error {
 
 	hotreload.StartHotReload(d.configManger, d.bootstrap)
 
+	// Set config path for hot reload
+	hotreload.SetConfigPath(configPath)
+
+	// Start HTTP reload endpoint on port 18380
+	if err := hotreload.StartReloadServer(18380, ""); err != nil {
+		logger.Warnf("[startGatewayCmd] failed to start reload server: %s", err.Error())
+	}
+
 	return err
 }
 
@@ -125,7 +133,7 @@ func (d *DefaultDeployer) start() error {
 }
 
 func (d *DefaultDeployer) stop() error {
-	//TODO implement me
+	// TODO implement me
 	panic("implement me")
 }
 
diff --git a/pkg/common/http/manager.go b/pkg/common/http/manager.go
index 80e9b44c..5177bcad 100644
--- a/pkg/common/http/manager.go
+++ b/pkg/common/http/manager.go
@@ -66,6 +66,10 @@ func CreateHttpConnectionManager(hcmc *model.HttpConnectionManagerConfig) *HttpC
 			route.Match.Methods = []string{}
 		}
 	}
+
+	// Force enable dynamic routing for hot reload
+	hcmc.RouteConfig.Dynamic = true
+
 	hcm.routerCoordinator = router2.CreateRouterCoordinator(&hcmc.RouteConfig)
 	hcm.filterManager = filter.NewFilterManager(hcmc.HTTPFilters)
 	hcm.filterManager.Load()
diff --git a/pkg/common/router/router.go b/pkg/common/router/router.go
index 6a8393c5..3d970196 100644
--- a/pkg/common/router/router.go
+++ b/pkg/common/router/router.go
@@ -47,6 +47,9 @@ type RouterCoordinator struct {
 
 	timer    *time.Timer   // debounce timer
 	debounce time.Duration // merge window, default 50ms
+
+	needsRegistration atomic.Bool // whether needs to register as RouterListener
+	dynamic           bool        // whether dynamic routing is enabled
 }
 
 // CreateRouterCoordinator create coordinator for http connection manager
@@ -54,9 +57,16 @@ func CreateRouterCoordinator(routeConfig *model.RouteConfiguration) *RouterCoord
 	rc := &RouterCoordinator{
 		nextSnapshot: make([]*model.Router, 0, len(routeConfig.Routes)),
 		debounce:     50 * time.Millisecond, // merge window
+		dynamic:      routeConfig.Dynamic,
 	}
 	if routeConfig.Dynamic {
-		server.GetRouterManager().AddRouterListener(rc)
+		rm := server.GetRouterManager()
+		if rm != nil {
+			rm.AddRouterListener(rc)
+		} else {
+			// RouterManager not initialized yet, will register later
+			rc.needsRegistration.Store(true)
+		}
 	}
 	// build initial config and store snapshot
 	rc.mainSnapshot.Store(model.ToSnapshot(buildRouteConfiguration(routeConfig.Routes).Routes))
@@ -65,7 +75,24 @@ func CreateRouterCoordinator(routeConfig *model.RouteConfiguration) *RouterCoord
 	return rc
 }
 
+func (rm *RouterCoordinator) Close() {
+	if rm.dynamic {
+		routerMgr := server.GetRouterManager()
+		if routerMgr != nil {
+			routerMgr.RemoveRouterListener(rm)
+		}
+	}
+}
+
 func (rm *RouterCoordinator) Route(hc *http.HttpContext) (*model.RouteAction, error) {
+	if rm.dynamic && rm.needsRegistration.CompareAndSwap(true, false) {
+		routerMgr := server.GetRouterManager()
+		if routerMgr != nil {
+			routerMgr.AddRouterListener(rm)
+		} else {
+			rm.needsRegistration.Store(true)
+		}
+	}
 	return rm.route(hc.Request)
 }
 
diff --git a/pkg/config/config_load.go b/pkg/config/config_load.go
index 9e0d519a..ffd84b3a 100644
--- a/pkg/config/config_load.go
+++ b/pkg/config/config_load.go
@@ -23,6 +23,7 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
+	"sync/atomic"
 )
 
 import (
@@ -44,7 +45,7 @@ import (
 
 var (
 	configPath     string
-	config         *model.Bootstrap
+	config         atomic.Pointer[model.Bootstrap]
 	configLoadFunc LoadFunc = LoadYAMLConfig
 
 	once sync.Once
@@ -55,7 +56,12 @@ type LoadFunc func(path string) *model.Bootstrap
 
 // GetBootstrap get config global, need a better name
 func GetBootstrap() *model.Bootstrap {
-	return config
+	return config.Load()
+}
+
+// SetBootstrap set config global
+func SetBootstrap(cfg *model.Bootstrap) {
+	config.Store(cfg)
 }
 
 // Load config file and parse
@@ -66,9 +72,9 @@ func Load(path string) *model.Bootstrap {
 		RegisterConfigLoadFunc(LoadYAMLConfig)
 	}
 	if cfg := configLoadFunc(configPath); cfg != nil {
-		config = cfg
+		config.Store(cfg)
 	}
-	return config
+	return config.Load()
 }
 
 // RegisterConfigLoadFunc can replace a new config load function instead of default
@@ -207,7 +213,7 @@ func (m *ConfigManager) LoadBootConfig(path string) *model.Bootstrap {
 		}
 	}
 
-	config = configs
+	config.Store(configs)
 
 	err := m.check()
 
@@ -274,5 +280,5 @@ func (m *ConfigManager) ViewRemoteConfig() *model.Bootstrap {
 
 func (m *ConfigManager) check() error {
 
-	return Adapter(config)
+	return Adapter(config.Load())
 }
diff --git a/pkg/hotreload/cluster_reloader.go b/pkg/hotreload/cluster_reloader.go
new file mode 100644
index 00000000..6ea3bd81
--- /dev/null
+++ b/pkg/hotreload/cluster_reloader.go
@@ -0,0 +1,164 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hotreload
+
+import (
+	"github.com/pkg/errors"
+)
+
+import (
+	"github.com/apache/dubbo-go-pixiu/pkg/logger"
+	"github.com/apache/dubbo-go-pixiu/pkg/model"
+	"github.com/apache/dubbo-go-pixiu/pkg/server"
+)
+
+type ClusterReloader struct{}
+
+// CheckUpdate compares the old and new cluster configurations to determine if a reload is needed.
+func (c *ClusterReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool {
+	oldClusters := oldConfig.StaticResources.Clusters
+	newClusters := newConfig.StaticResources.Clusters
+
+	if len(oldClusters) != len(newClusters) {
+		logger.Infof("Cluster count changed: old=%d, new=%d", len(oldClusters), len(newClusters))
+		return true
+	}
+
+	oldClusterMap := make(map[string]*model.ClusterConfig)
+	for _, cluster := range oldClusters {
+		oldClusterMap[cluster.Name] = cluster
+	}
+
+	for _, newCluster := range newClusters {
+		oldCluster, exists := oldClusterMap[newCluster.Name]
+		if !exists {
+			logger.Infof("New cluster found: %s", newCluster.Name)
+			return true
+		}
+
+		if len(oldCluster.Endpoints) != len(newCluster.Endpoints) {
+			logger.Infof("Cluster %s endpoint count changed: old=%d, new=%d",
+				newCluster.Name, len(oldCluster.Endpoints), len(newCluster.Endpoints))
+			return true
+		}
+
+		for i := range newCluster.Endpoints {
+			if i >= len(oldCluster.Endpoints) {
+				return true
+			}
+			oldEp := oldCluster.Endpoints[i]
+			newEp := newCluster.Endpoints[i]
+			if oldEp.Address.Address != newEp.Address.Address ||
+				oldEp.Address.Port != newEp.Address.Port {
+				logger.Infof("Cluster %s endpoint changed: old=%s:%d, new=%s:%d",
+					newCluster.Name,
+					oldEp.Address.Address, oldEp.Address.Port,
+					newEp.Address.Address, newEp.Address.Port)
+				return true
+			}
+		}
+
+		if oldCluster.LbStr != newCluster.LbStr {
+			logger.Infof("Cluster %s lb policy changed: old=%s, new=%s",
+				newCluster.Name, oldCluster.LbStr, newCluster.LbStr)
+			return true
+		}
+	}
+
+	return false
+}
+
+// HotReload applies the new cluster configuration.
+func (c *ClusterReloader) HotReload(oldConfig, newConfig *model.Bootstrap) error {
+	logger.Info("Starting cluster hot reload")
+
+	srv := server.GetServer()
+	if srv == nil {
+		logger.Error("Server instance is nil")
+		return errors.New("server instance is nil")
+	}
+
+	clusterManager := srv.GetClusterManager()
+	if clusterManager == nil {
+		logger.Error("Cluster manager is nil")
+		return errors.New("cluster manager is nil")
+	}
+
+	oldClusterMap := make(map[string]*model.ClusterConfig)
+	for _, cluster := range oldConfig.StaticResources.Clusters {
+		oldClusterMap[cluster.Name] = cluster
+	}
+
+	newClusterMap := make(map[string]*model.ClusterConfig)
+	for _, cluster := range newConfig.StaticResources.Clusters {
+		newClusterMap[cluster.Name] = cluster
+	}
+
+	clustersToRemove := []string{}
+	for name := range oldClusterMap {
+		if _, exists := newClusterMap[name]; !exists {
+			clustersToRemove = append(clustersToRemove, name)
+		}
+	}
+	if len(clustersToRemove) > 0 {
+		logger.Infof("Removing %d cluster(s): %v", len(clustersToRemove), clustersToRemove)
+		clusterManager.RemoveCluster(clustersToRemove)
+	}
+
+	updated := 0
+	added := 0
+	for _, newCluster := range newConfig.StaticResources.Clusters {
+		if oldCluster, exists := oldClusterMap[newCluster.Name]; exists {
+			if c.clusterChanged(oldCluster, newCluster) {
+				logger.Infof("Updating cluster: %s (endpoints: %d)", newCluster.Name, len(newCluster.Endpoints))
+				clusterManager.UpdateCluster(newCluster)
+				updated++
+			}
+		} else {
+			logger.Infof("Adding new cluster: %s (endpoints: %d)", newCluster.Name, len(newCluster.Endpoints))
+			clusterManager.AddCluster(newCluster)
+			added++
+		}
+	}
+
+	logger.Infof("Cluster hot reload completed: added=%d, updated=%d, removed=%d",
+		added, updated, len(clustersToRemove))
+	logger.Info("Cluster hot reload completed successfully")
+	return nil
+}
+
+// clusterChanged checks if a cluster configuration has changed
+func (c *ClusterReloader) clusterChanged(old, new *model.ClusterConfig) bool {
+	if len(old.Endpoints) != len(new.Endpoints) {
+		return true
+	}
+
+	for i := range new.Endpoints {
+		if i >= len(old.Endpoints) {
+			return true
+		}
+		oldEp := old.Endpoints[i]
+		newEp := new.Endpoints[i]
+		if oldEp.Address.Address != newEp.Address.Address ||
+			oldEp.Address.Port != newEp.Address.Port {
+			return true
+		}
+	}
+
+	return old.LbStr != new.LbStr
+}
diff --git a/pkg/hotreload/hotreload.go b/pkg/hotreload/hotreload.go
index 133a234e..ea665dea 100644
--- a/pkg/hotreload/hotreload.go
+++ b/pkg/hotreload/hotreload.go
@@ -46,10 +46,9 @@ type Coordinator struct {
 	manager   *config.ConfigManager // Configuration manager
 }
 
-var coordinator = Coordinator{reloaders: []HotReloader{&LoggerReloader{}, &RouteReloader{}}}
+var coordinator = Coordinator{reloaders: []HotReloader{&LoggerReloader{}, &RouteReloader{}, &ClusterReloader{}}}
 
 // StartHotReload initializes the hot reload process.
-// It should be called when the project starts, e.g., in cmd/gateway.go.
 func StartHotReload(manager *config.ConfigManager, boot *model.Bootstrap) {
 	if manager == nil || boot == nil {
 		logger.Warn("ConfigManager or Bootstrap is nil, hot reload will not start")
@@ -100,7 +99,6 @@ func (c *Coordinator) hotReload(newBoot *model.Bootstrap) {
 	}
 }
 
-// equal checks if two string slices are equal.
 func equal(s1, s2 []string) bool {
 	if len(s1) != len(s2) {
 		return false
diff --git a/pkg/hotreload/http_handler.go b/pkg/hotreload/http_handler.go
new file mode 100644
index 00000000..737f66a9
--- /dev/null
+++ b/pkg/hotreload/http_handler.go
@@ -0,0 +1,289 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hotreload
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"sync"
+	"time"
+)
+
+import (
+	"gopkg.in/yaml.v3"
+)
+
+import (
+	"github.com/apache/dubbo-go-pixiu/pkg/config"
+	"github.com/apache/dubbo-go-pixiu/pkg/logger"
+	"github.com/apache/dubbo-go-pixiu/pkg/model"
+)
+
+var (
+	reloadMutex    sync.Mutex
+	configPath     string
+	reloadServer   *http.Server
+	reloadServerMu sync.Mutex
+	reloadSecret   string // shared secret for authentication
+)
+
+func SetConfigPath(path string) {
+	configPath = path
+}
+
+func SetReloadSecret(secret string) {
+	reloadSecret = secret
+}
+
+// ReloadHandler handles HTTP reload requests
+type ReloadHandler struct{}
+
+// checkAuth validates the request authentication
+func checkAuth(r *http.Request) bool {
+	// Allow localhost without authentication
+	host, _, err := net.SplitHostPort(r.RemoteAddr)
+	if err == nil && (host == "127.0.0.1" || host == "::1" || host == "localhost") {
+		return true
+	}
+
+	// Check shared secret if configured
+	if reloadSecret != "" {
+		token := r.Header.Get("X-Reload-Token")
+		return token == reloadSecret
+	}
+
+	// If no secret configured and not localhost, deny
+	return false
+}
+
+// ServeHTTP handles the reload HTTP request
+func (h *ReloadHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed, use POST", http.StatusMethodNotAllowed)
+		return
+	}
+
+	if !checkAuth(r) {
+		logger.Warnf("Unauthorized reload request from %s", r.RemoteAddr)
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	logger.Info("Received reload request via HTTP")
+
+	var err error
+	// Try to read from body first (handles chunked encoding where ContentLength == -1)
+	// If body is empty, fallback to file reload
+	if r.Body != nil {
+		content, readErr := io.ReadAll(r.Body)
+
+		if readErr != nil {
+			logger.Errorf("Failed to read request body: %v", readErr)
+			http.Error(w, fmt.Sprintf("Failed to read request body: %v", readErr), http.StatusBadRequest)
+			return
+		}
+
+		if len(content) > 0 {
+			// Body has content, use it
+			reloadMutex.Lock()
+			err = reloadFromYAML(content)
+			reloadMutex.Unlock()
+		} else {
+			// Body is empty, fallback to file reload
+			err = triggerConfigReload()
+		}
+	} else {
+		err = triggerConfigReload()
+	}
+
+	if err != nil {
+		logger.Errorf("Reload failed: %v", err)
+		http.Error(w, fmt.Sprintf("Reload failed: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	writeJSONResponse(w, "success", "Configuration reloaded successfully")
+	logger.Info("Reload completed successfully")
+}
+
+func writeJSONResponse(w http.ResponseWriter, status, message string) {
+	response := map[string]string{
+		"status":  status,
+		"message": message,
+		"time":    time.Now().Format(time.RFC3339),
+	}
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		logger.Errorf("Failed to encode response: %v", err)
+	}
+}
+
+// HealthHandler handles health check requests
+type HealthHandler struct{}
+
+// ServeHTTP handles the health check HTTP request
+func (h *HealthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if !checkAuth(r) {
+		logger.Warnf("Unauthorized health check request from %s", r.RemoteAddr)
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	writeJSONResponse(w, "healthy", "")
+}
+
+// triggerConfigReload reloads configuration from file
+func triggerConfigReload() error {
+	reloadMutex.Lock()
+	defer reloadMutex.Unlock()
+
+	if configPath == "" {
+		return fmt.Errorf("config path not set")
+	}
+
+	logger.Infof("Reloading configuration from: %s", configPath)
+
+	content, err := os.ReadFile(configPath)
+	if err != nil {
+		return fmt.Errorf("failed to read config file: %w", err)
+	}
+
+	return reloadFromYAML(content)
+}
+
+// reloadFromYAML performs the actual reload from YAML content
+func reloadFromYAML(content []byte) error {
+	newConfig := &model.Bootstrap{}
+	if err := yaml.Unmarshal(content, newConfig); err != nil {
+		return fmt.Errorf("failed to parse config: %w", err)
+	}
+
+	if err := config.Adapter(newConfig); err != nil {
+		return fmt.Errorf("failed to adapt config: %w", err)
+	}
+
+	oldConfig := config.GetBootstrap()
+	if oldConfig == nil {
+		return fmt.Errorf("current config is nil")
+	}
+
+	logger.Infof("Old config has %d listeners, new config has %d listeners",
+		len(oldConfig.StaticResources.Listeners), len(newConfig.StaticResources.Listeners))
+
+	// Execute reloaders serially with CheckUpdate validation
+	for _, reloader := range coordinator.reloaders {
+		// Check if update is needed before executing reload
+		if !reloader.CheckUpdate(oldConfig, newConfig) {
+			logger.Debugf("No update needed for %T", reloader)
+			continue
+		}
+
+		logger.Infof("Triggering reload for %T", reloader)
+		if err := reloader.HotReload(oldConfig, newConfig); err != nil {
+			logger.Errorf("Hot reload failed for %T: %v", reloader, err)
+			return fmt.Errorf("reload failed for %T: %w", reloader, err)
+		}
+	}
+
+	config.SetBootstrap(newConfig)
+	logger.Info("Configuration reloaded successfully and global config updated")
+	return nil
+}
+
+// StartReloadServer starts the HTTP server for reload endpoint
+// port: the port to listen on (0 means use default 8888)
+// secret: optional shared secret for authentication (empty means localhost-only)
+func StartReloadServer(port int, secret string) error {
+	reloadServerMu.Lock()
+	defer reloadServerMu.Unlock()
+
+	if reloadServer != nil {
+		return fmt.Errorf("reload server already running")
+	}
+
+	if port <= 0 {
+		port = 8888 // default port
+	}
+
+	if secret != "" {
+		reloadSecret = secret
+	}
+
+	addr := fmt.Sprintf(":%d", port)
+	logger.Infof("Starting reload HTTP server on %s", addr)
+
+	// Try to bind the port first to catch errors early
+	listener, err := net.Listen("tcp", addr)
+	if err != nil {
+		return fmt.Errorf("failed to bind port %d: %w", port, err)
+	}
+
+	mux := http.NewServeMux()
+	mux.Handle("/-/reload", &ReloadHandler{})
+	mux.Handle("/-/health", &HealthHandler{})
+
+	reloadServer = &http.Server{
+		Handler:      mux,
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+
+	// Start server in goroutine
+	go func() {
+		if err := reloadServer.Serve(listener); err != nil && err != http.ErrServerClosed {
+			logger.Errorf("Reload HTTP server failed: %v", err)
+		}
+	}()
+
+	logger.Infof("Reload HTTP server started successfully on port %d", port)
+	return nil
+}
+
+// StopReloadServer gracefully stops the reload HTTP server
+func StopReloadServer(timeout time.Duration) error {
+	reloadServerMu.Lock()
+	defer reloadServerMu.Unlock()
+
+	if reloadServer == nil {
+		return nil
+	}
+
+	logger.Info("Stopping reload HTTP server")
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	err := reloadServer.Shutdown(ctx)
+	reloadServer = nil
+
+	if err != nil {
+		logger.Errorf("Error stopping reload server: %v", err)
+		return err
+	}
+
+	logger.Info("Reload HTTP server stopped successfully")
+	return nil
+}
diff --git a/pkg/hotreload/logger.go b/pkg/hotreload/logger.go
index 6bc00424..a3bf5df4 100644
--- a/pkg/hotreload/logger.go
+++ b/pkg/hotreload/logger.go
@@ -42,7 +42,6 @@ func (r *LoggerReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool
 		return true
 	}
 
-	// Check if any logger configuration fields have changed.
 	if oc.Level != nc.Level ||
 		oc.Development != nc.Development ||
 		oc.DisableCaller != nc.DisableCaller ||
@@ -51,17 +50,14 @@ func (r *LoggerReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool
 		return true
 	}
 
-	// Check sampling configuration.
 	if !r.checkSampling(oc.Sampling, nc.Sampling) {
 		return true
 	}
 
-	// Check encoder configuration.
 	if !r.checkEncoderConfig(oc.EncoderConfig, nc.EncoderConfig) {
 		return true
 	}
 
-	// Check output paths.
 	if !equal(oc.OutputPaths, nc.OutputPaths) {
 		return true
 	}
diff --git a/pkg/hotreload/route_reloader.go b/pkg/hotreload/route_reloader.go
index 53a1ac30..8a830345 100644
--- a/pkg/hotreload/route_reloader.go
+++ b/pkg/hotreload/route_reloader.go
@@ -39,12 +39,10 @@ type RouteReloader struct{}
 func (r *RouteReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool {
 	oldRoutes := extractRoutes(oldConfig)
 	newRoutes := extractRoutes(newConfig)
-	// Compare the number of routes
 	if len(oldRoutes.Routes) != len(newRoutes.Routes) || oldRoutes.Dynamic != newRoutes.Dynamic {
 		return true
 	}
 
-	// Compare each route
 	for i := range newRoutes.Routes {
 		if oldRoutes.Routes[i].Match.Prefix != newRoutes.Routes[i].Match.Prefix ||
 			oldRoutes.Routes[i].Route.Cluster != newRoutes.Routes[i].Route.Cluster {
@@ -56,16 +54,44 @@ func (r *RouteReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool
 
 // HotReload applies the new route configuration.
 func (r *RouteReloader) HotReload(oldConfig, newConfig *model.Bootstrap) error {
-	oldRoutes := extractRoutes(oldConfig)
-	newRoutes := extractRoutes(newConfig)
+	logger.Info("Starting route hot reload")
+
+	srv := server.GetServer()
+	if srv == nil {
+		logger.Error("Server instance is nil")
+		return errors.New("server instance is nil")
+	}
+	logger.Info("Got server instance")
+
+	logger.Info("Reinitializing server components...")
+
+	listenerManager := srv.GetListenerManager()
+	if listenerManager == nil {
+		logger.Error("Listener manager is nil")
+		return errors.New("listener manager is nil")
+	}
+
+	srv.GetRouterManager().ClearRouterListeners()
+
+	refreshed := 0
+	for _, listener := range newConfig.StaticResources.Listeners {
+		logger.Infof("Refreshing listener: name=%s, protocol=%s", listener.Name, listener.ProtocolStr)
+
+		if err := listenerManager.UpdateListener(listener); err != nil {
+			logger.Errorf("Failed to refresh listener %s: %v", listener.Name, err)
+			return errors.Wrapf(err, "failed to refresh listener %s", listener.Name)
+		}
+		logger.Infof("Successfully refreshed listener: %s", listener.Name)
+		refreshed++
+	}
 
-	// Update routes in the RouterManager
-	err := server.GetRouterManager().UpdateRoutes(oldRoutes.Routes, newRoutes.Routes)
-	if err != nil {
-		logger.Infof("Failed to Routes reloaded.")
-		return err
+	if refreshed == 0 {
+		logger.Warn("No listeners were refreshed")
+	} else {
+		logger.Infof("Successfully refreshed %d listener(s)", refreshed)
 	}
 
+	logger.Info("Route hot reload completed successfully")
 	return nil
 }
 
@@ -78,7 +104,6 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
 	for _, listener := range config.StaticResources.Listeners {
 		for _, filterChain := range listener.FilterChain.Filters {
 			if filterChain.Name == constant.HTTPConnectManagerFilter {
-				// Extract route_config
 				rawRouteConfig, ok := filterChain.Config["route_config"]
 				if !ok {
 					logger.Debugf("No route_config found in filter chain: %+v", filterChain)
@@ -86,14 +111,12 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
 				}
 				logger.Debugf("Raw route_config: %+v", rawRouteConfig)
 
-				// Convert route_config to JSON bytes
 				routeConfigBytes, err := json.Marshal(rawRouteConfig)
 				if err != nil {
 					logger.Errorf("Failed to marshal route_config: %v", err)
 					continue
 				}
 
-				// Parse JSON bytes into model.RouteConfiguration
 				if err := json.Unmarshal(routeConfigBytes, &routeConfig); err != nil {
 					logger.Errorf("Failed to unmarshal route_config: %v", err)
 					continue
@@ -101,7 +124,6 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
 
 				logger.Debugf("Parsed route_config: %+v", routeConfig)
 
-				// Validate and filter routes
 				validRoutes := make([]*model.Router, 0, len(routeConfig.Routes))
 				for _, route := range routeConfig.Routes {
 					if err := validateRoute(route); err != nil {
@@ -115,7 +137,6 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
 				routeConfig.Routes = validRoutes
 				logger.Debugf("Valid routes after filtering: %+v", validRoutes)
 
-				// Return if we have valid routes
 				if len(validRoutes) > 0 {
 					return routeConfig
 				}
@@ -131,12 +152,10 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
 
 // validateRoute validates a single route, returning an error if invalid.
 func validateRoute(route *model.Router) error {
-	// Ensure route has a valid match condition
 	if route.Match.Prefix == "" && route.Match.Path == "" {
 		return errors.Errorf("route %s has no prefix or path defined", route.ID)
 	}
 
-	// Ensure cluster is specified
 	if route.Route.Cluster == "" {
 		return errors.Errorf("route %s has no cluster defined", route.ID)
 	}
diff --git a/pkg/server/listener_manager.go b/pkg/server/listener_manager.go
index e27b2c6b..0543d126 100644
--- a/pkg/server/listener_manager.go
+++ b/pkg/server/listener_manager.go
@@ -147,11 +147,14 @@ func (lm *ListenerManager) UpdateListener(m *model.Listener) error {
 	// lock
 	lm.rwLock.Lock()
 	defer lm.rwLock.Unlock()
-	ls, ok := lm.activeListenerService[m.Name]
+
+	// Use resolveListenerName to get the correct key
+	listenerKey := resolveListenerName(m)
+	ls, ok := lm.activeListenerService[listenerKey]
 	if !ok {
-		return errors.New("ListenerManager UpdateListener error: listener not found")
+		return errors.Errorf("ListenerManager UpdateListener error: listener not found with key %s", listenerKey)
 	}
-	logger.Infof("Update Listener %s", m.Name)
+	logger.Infof("Update Listener %s (key: %s)", m.Name, listenerKey)
 	ls.config = m
 	err := ls.Refresh(*m)
 	if err != nil {
diff --git a/pkg/server/pixiu_start.go b/pkg/server/pixiu_start.go
index 6473f402..3f04746d 100644
--- a/pkg/server/pixiu_start.go
+++ b/pkg/server/pixiu_start.go
@@ -141,6 +141,9 @@ func GetClusterManager() *ClusterManager {
 }
 
 func GetRouterManager() *RouterManager {
+	if server == nil {
+		return nil
+	}
 	return server.GetRouterManager()
 }
 
diff --git a/pkg/server/router_manager.go b/pkg/server/router_manager.go
index 9301f532..4bc3670e 100644
--- a/pkg/server/router_manager.go
+++ b/pkg/server/router_manager.go
@@ -17,6 +17,10 @@
 
 package server
 
+import (
+	"sync"
+)
+
 import (
 	"github.com/pkg/errors"
 )
@@ -33,6 +37,7 @@ type (
 	}
 
 	RouterManager struct {
+		mu  sync.RWMutex
 		rls []RouterListener
 	}
 )
@@ -43,19 +48,53 @@ func CreateDefaultRouterManager(server *Server, bs *model.Bootstrap) *RouterMana
 }
 
 func (rm *RouterManager) AddRouterListener(l RouterListener) {
+	rm.mu.Lock()
+	defer rm.mu.Unlock()
+
 	rm.rls = append(rm.rls, l)
 }
 
+func (rm *RouterManager) RemoveRouterListener(l RouterListener) {
+	rm.mu.Lock()
+	defer rm.mu.Unlock()
+
+	for i, listener := range rm.rls {
+		if listener == l {
+			rm.rls = append(rm.rls[:i], rm.rls[i+1:]...)
+			return
+		}
+	}
+}
+
+func (rm *RouterManager) ClearRouterListeners() {
+	rm.mu.Lock()
+	defer rm.mu.Unlock()
+
+	rm.rls = nil
+}
+
 func (rm *RouterManager) AddRouter(r *model.Router) {
 	logger.Infof("add router: %v", r)
-	for _, l := range rm.rls {
+
+	rm.mu.RLock()
+	listeners := make([]RouterListener, len(rm.rls))
+	copy(listeners, rm.rls)
+	rm.mu.RUnlock()
+
+	for _, l := range listeners {
 		l.OnAddRouter(r)
 	}
 }
 
 func (rm *RouterManager) DeleteRouter(r *model.Router) {
 	logger.Infof("del router: %v", r)
-	for _, l := range rm.rls {
+
+	rm.mu.RLock()
+	listeners := make([]RouterListener, len(rm.rls))
+	copy(listeners, rm.rls)
+	rm.mu.RUnlock()
+
+	for _, l := range listeners {
 		l.OnDeleteRouter(r)
 	}
 }
@@ -73,7 +112,13 @@ func (rm *RouterManager) UpdateRoutes(oldRoutes []*model.Router, newRoutes []*mo
 	// Notify listeners to delete existing routes
 	for _, route := range oldRoutes {
 		logger.Debugf("Notifying listeners to delete route: %s", route.String())
-		for _, listener := range rm.rls {
+
+		rm.mu.RLock()
+		listeners := make([]RouterListener, len(rm.rls))
+		copy(listeners, rm.rls)
+		rm.mu.RUnlock()
+
+		for _, listener := range listeners {
 			listener.OnDeleteRouter(route)
 		}
 	}
@@ -81,7 +126,13 @@ func (rm *RouterManager) UpdateRoutes(oldRoutes []*model.Router, newRoutes []*mo
 	// Notify listeners to add new routes
 	for _, route := range newRoutes {
 		logger.Debugf("Notifying listeners to add route: %s", route.String())
-		for _, listener := range rm.rls {
+
+		rm.mu.RLock()
+		listeners := make([]RouterListener, len(rm.rls))
+		copy(listeners, rm.rls)
+		rm.mu.RUnlock()
+
+		for _, listener := range listeners {
 			listener.OnAddRouter(route)
 		}
 	}