diff --git a/api/config_admission.go b/api/config_admission.go
index 9faa315..a1254e2 100644
--- a/api/config_admission.go
+++ b/api/config_admission.go
@@ -47,9 +47,10 @@ func createAdmission(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Admissions = append(cfg.Admissions, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Admissions = append(c.Admissions, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -102,14 +103,15 @@ func updateAdmission(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Admissions {
-		if cfg.Admissions[i].Name == req.Admission {
-			cfg.Admissions[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Admissions {
+			if c.Admissions[i].Name == req.Admission {
+				c.Admissions[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -149,16 +151,17 @@ func deleteAdmission(ctx *gin.Context) {
 	}
 	registry.AdmissionRegistry().Unregister(req.Admission)
 
-	cfg := config.Global()
-	admissiones := cfg.Admissions
-	cfg.Admissions = nil
-	for _, s := range admissiones {
-		if s.Name == req.Admission {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		admissiones := c.Admissions
+		c.Admissions = nil
+		for _, s := range admissiones {
+			if s.Name == req.Admission {
+				continue
+			}
+			c.Admissions = append(c.Admissions, s)
 		}
-		cfg.Admissions = append(cfg.Admissions, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_auther.go b/api/config_auther.go
index 53e1048..cfaab3c 100644
--- a/api/config_auther.go
+++ b/api/config_auther.go
@@ -46,9 +46,10 @@ func createAuther(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Authers = append(cfg.Authers, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Authers = append(c.Authers, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -100,14 +101,15 @@ func updateAuther(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Authers {
-		if cfg.Authers[i].Name == req.Auther {
-			cfg.Authers[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Authers {
+			if c.Authers[i].Name == req.Auther {
+				c.Authers[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -147,16 +149,17 @@ func deleteAuther(ctx *gin.Context) {
 	}
 	registry.AutherRegistry().Unregister(req.Auther)
 
-	cfg := config.Global()
-	authers := cfg.Authers
-	cfg.Authers = nil
-	for _, s := range authers {
-		if s.Name == req.Auther {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		authers := c.Authers
+		c.Authers = nil
+		for _, s := range authers {
+			if s.Name == req.Auther {
+				continue
+			}
+			c.Authers = append(c.Authers, s)
 		}
-		cfg.Authers = append(cfg.Authers, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_bypass.go b/api/config_bypass.go
index b84539b..925406f 100644
--- a/api/config_bypass.go
+++ b/api/config_bypass.go
@@ -47,9 +47,10 @@ func createBypass(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Bypasses = append(cfg.Bypasses, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Bypasses = append(c.Bypasses, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -102,14 +103,15 @@ func updateBypass(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Bypasses {
-		if cfg.Bypasses[i].Name == req.Bypass {
-			cfg.Bypasses[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Bypasses {
+			if c.Bypasses[i].Name == req.Bypass {
+				c.Bypasses[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -149,16 +151,17 @@ func deleteBypass(ctx *gin.Context) {
 	}
 	registry.BypassRegistry().Unregister(req.Bypass)
 
-	cfg := config.Global()
-	bypasses := cfg.Bypasses
-	cfg.Bypasses = nil
-	for _, s := range bypasses {
-		if s.Name == req.Bypass {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		bypasses := c.Bypasses
+		c.Bypasses = nil
+		for _, s := range bypasses {
+			if s.Name == req.Bypass {
+				continue
+			}
+			c.Bypasses = append(c.Bypasses, s)
 		}
-		cfg.Bypasses = append(cfg.Bypasses, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_chain.go b/api/config_chain.go
index 3b8a728..270c8c6 100644
--- a/api/config_chain.go
+++ b/api/config_chain.go
@@ -51,9 +51,10 @@ func createChain(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Chains = append(cfg.Chains, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Chains = append(c.Chains, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -111,14 +112,15 @@ func updateChain(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Chains {
-		if cfg.Chains[i].Name == req.Chain {
-			cfg.Chains[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Chains {
+			if c.Chains[i].Name == req.Chain {
+				c.Chains[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -158,16 +160,17 @@ func deleteChain(ctx *gin.Context) {
 	}
 	registry.ChainRegistry().Unregister(req.Chain)
 
-	cfg := config.Global()
-	chains := cfg.Chains
-	cfg.Chains = nil
-	for _, s := range chains {
-		if s.Name == req.Chain {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		chains := c.Chains
+		c.Chains = nil
+		for _, s := range chains {
+			if s.Name == req.Chain {
+				continue
+			}
+			c.Chains = append(c.Chains, s)
 		}
-		cfg.Chains = append(cfg.Chains, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_conn_limiter.go b/api/config_conn_limiter.go
index 943bd19..05ac61a 100644
--- a/api/config_conn_limiter.go
+++ b/api/config_conn_limiter.go
@@ -47,9 +47,10 @@ func createConnLimiter(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.CLimiters = append(cfg.CLimiters, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.CLimiters = append(c.CLimiters, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -102,14 +103,15 @@ func updateConnLimiter(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Limiters {
-		if cfg.Limiters[i].Name == req.Limiter {
-			cfg.Limiters[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.CLimiters {
+			if c.CLimiters[i].Name == req.Limiter {
+				c.CLimiters[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -149,16 +151,17 @@ func deleteConnLimiter(ctx *gin.Context) {
 	}
 	registry.ConnLimiterRegistry().Unregister(req.Limiter)
 
-	cfg := config.Global()
-	limiteres := cfg.Limiters
-	cfg.Limiters = nil
-	for _, s := range limiteres {
-		if s.Name == req.Limiter {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		limiteres := c.CLimiters
+		c.CLimiters = nil
+		for _, s := range limiteres {
+			if s.Name == req.Limiter {
+				continue
+			}
+			c.CLimiters = append(c.CLimiters, s)
 		}
-		cfg.Limiters = append(cfg.Limiters, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_hop.go b/api/config_hop.go
index 5981e6c..6307737 100644
--- a/api/config_hop.go
+++ b/api/config_hop.go
@@ -51,9 +51,10 @@ func createHop(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Hops = append(cfg.Hops, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Hops = append(c.Hops, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -111,14 +112,15 @@ func updateHop(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Hops {
-		if cfg.Hops[i].Name == req.Hop {
-			cfg.Hops[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Hops {
+			if c.Hops[i].Name == req.Hop {
+				c.Hops[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -158,16 +160,17 @@ func deleteHop(ctx *gin.Context) {
 	}
 	registry.HopRegistry().Unregister(req.Hop)
 
-	cfg := config.Global()
-	hops := cfg.Hops
-	cfg.Hops = nil
-	for _, s := range hops {
-		if s.Name == req.Hop {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		hops := c.Hops
+		c.Hops = nil
+		for _, s := range hops {
+			if s.Name == req.Hop {
+				continue
+			}
+			c.Hops = append(c.Hops, s)
 		}
-		cfg.Hops = append(cfg.Hops, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_hosts.go b/api/config_hosts.go
index 9b7d7e2..5ae51d0 100644
--- a/api/config_hosts.go
+++ b/api/config_hosts.go
@@ -47,9 +47,10 @@ func createHosts(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Hosts = append(cfg.Hosts, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Hosts = append(c.Hosts, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -102,14 +103,15 @@ func updateHosts(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Hosts {
-		if cfg.Hosts[i].Name == req.Hosts {
-			cfg.Hosts[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Hosts {
+			if c.Hosts[i].Name == req.Hosts {
+				c.Hosts[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -149,16 +151,17 @@ func deleteHosts(ctx *gin.Context) {
 	}
 	registry.HostsRegistry().Unregister(req.Hosts)
 
-	cfg := config.Global()
-	hosts := cfg.Hosts
-	cfg.Hosts = nil
-	for _, s := range hosts {
-		if s.Name == req.Hosts {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		hosts := c.Hosts
+		c.Hosts = nil
+		for _, s := range hosts {
+			if s.Name == req.Hosts {
+				continue
+			}
+			c.Hosts = append(c.Hosts, s)
 		}
-		cfg.Hosts = append(cfg.Hosts, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_ingress.go b/api/config_ingress.go
index c619d21..cf50f39 100644
--- a/api/config_ingress.go
+++ b/api/config_ingress.go
@@ -47,9 +47,10 @@ func createIngress(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Ingresses = append(cfg.Ingresses, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Ingresses = append(c.Ingresses, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -102,14 +103,15 @@ func updateIngress(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Ingresses {
-		if cfg.Ingresses[i].Name == req.Ingress {
-			cfg.Ingresses[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Ingresses {
+			if c.Ingresses[i].Name == req.Ingress {
+				c.Ingresses[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -149,16 +151,17 @@ func deleteIngress(ctx *gin.Context) {
 	}
 	registry.IngressRegistry().Unregister(req.Ingress)
 
-	cfg := config.Global()
-	ingresses := cfg.Ingresses
-	cfg.Ingresses = nil
-	for _, s := range ingresses {
-		if s.Name == req.Ingress {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		ingresses := c.Ingresses
+		c.Ingresses = nil
+		for _, s := range ingresses {
+			if s.Name == req.Ingress {
+				continue
+			}
+			c.Ingresses = append(c.Ingresses, s)
 		}
-		cfg.Ingresses = append(cfg.Ingresses, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_limiter.go b/api/config_limiter.go
index b7fed3a..8cbcc27 100644
--- a/api/config_limiter.go
+++ b/api/config_limiter.go
@@ -47,9 +47,10 @@ func createLimiter(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Limiters = append(cfg.Limiters, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Limiters = append(c.Limiters, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -102,14 +103,15 @@ func updateLimiter(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Limiters {
-		if cfg.Limiters[i].Name == req.Limiter {
-			cfg.Limiters[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Limiters {
+			if c.Limiters[i].Name == req.Limiter {
+				c.Limiters[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -149,16 +151,17 @@ func deleteLimiter(ctx *gin.Context) {
 	}
 	registry.TrafficLimiterRegistry().Unregister(req.Limiter)
 
-	cfg := config.Global()
-	limiteres := cfg.Limiters
-	cfg.Limiters = nil
-	for _, s := range limiteres {
-		if s.Name == req.Limiter {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		limiteres := c.Limiters
+		c.Limiters = nil
+		for _, s := range limiteres {
+			if s.Name == req.Limiter {
+				continue
+			}
+			c.Limiters = append(c.Limiters, s)
 		}
-		cfg.Limiters = append(cfg.Limiters, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_rate_limiter.go b/api/config_rate_limiter.go
index 93cbe5b..984adae 100644
--- a/api/config_rate_limiter.go
+++ b/api/config_rate_limiter.go
@@ -47,9 +47,10 @@ func createRateLimiter(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.CLimiters = append(cfg.CLimiters, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.RLimiters = append(c.RLimiters, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -102,14 +103,15 @@ func updateRateLimiter(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Limiters {
-		if cfg.Limiters[i].Name == req.Limiter {
-			cfg.Limiters[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.RLimiters {
+			if c.RLimiters[i].Name == req.Limiter {
+				c.RLimiters[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -149,16 +151,17 @@ func deleteRateLimiter(ctx *gin.Context) {
 	}
 	registry.RateLimiterRegistry().Unregister(req.Limiter)
 
-	cfg := config.Global()
-	limiteres := cfg.Limiters
-	cfg.Limiters = nil
-	for _, s := range limiteres {
-		if s.Name == req.Limiter {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		limiteres := c.RLimiters
+		c.RLimiters = nil
+		for _, s := range limiteres {
+			if s.Name == req.Limiter {
+				continue
+			}
+			c.RLimiters = append(c.RLimiters, s)
 		}
-		cfg.Limiters = append(cfg.Limiters, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_resolver.go b/api/config_resolver.go
index f09ff8f..1bde112 100644
--- a/api/config_resolver.go
+++ b/api/config_resolver.go
@@ -51,9 +51,10 @@ func createResolver(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	cfg.Resolvers = append(cfg.Resolvers, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Resolvers = append(c.Resolvers, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -110,14 +111,15 @@ func updateResolver(ctx *gin.Context) {
 		return
 	}
 
-	cfg := config.Global()
-	for i := range cfg.Resolvers {
-		if cfg.Resolvers[i].Name == req.Resolver {
-			cfg.Resolvers[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Resolvers {
+			if c.Resolvers[i].Name == req.Resolver {
+				c.Resolvers[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -157,16 +159,17 @@ func deleteResolver(ctx *gin.Context) {
 	}
 	registry.ResolverRegistry().Unregister(req.Resolver)
 
-	cfg := config.Global()
-	resolvers := cfg.Resolvers
-	cfg.Resolvers = nil
-	for _, s := range resolvers {
-		if s.Name == req.Resolver {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		resolvers := c.Resolvers
+		c.Resolvers = nil
+		for _, s := range resolvers {
+			if s.Name == req.Resolver {
+				continue
+			}
+			c.Resolvers = append(c.Resolvers, s)
 		}
-		cfg.Resolvers = append(cfg.Resolvers, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/api/config_service.go b/api/config_service.go
index 9a268c8..ae385bb 100644
--- a/api/config_service.go
+++ b/api/config_service.go
@@ -59,9 +59,10 @@ func createService(ctx *gin.Context) {
 
 	go svc.Serve()
 
-	cfg := config.Global()
-	cfg.Services = append(cfg.Services, &req.Data)
-	config.SetGlobal(cfg)
+	config.OnUpdate(func(c *config.Config) error {
+		c.Services = append(c.Services, &req.Data)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -123,14 +124,15 @@ func updateService(ctx *gin.Context) {
 
 	go svc.Serve()
 
-	cfg := config.Global()
-	for i := range cfg.Services {
-		if cfg.Services[i].Name == req.Service {
-			cfg.Services[i] = &req.Data
-			break
+	config.OnUpdate(func(c *config.Config) error {
+		for i := range c.Services {
+			if c.Services[i].Name == req.Service {
+				c.Services[i] = &req.Data
+				break
+			}
 		}
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
@@ -173,16 +175,17 @@ func deleteService(ctx *gin.Context) {
 	registry.ServiceRegistry().Unregister(req.Service)
 	svc.Close()
 
-	cfg := config.Global()
-	services := cfg.Services
-	cfg.Services = nil
-	for _, s := range services {
-		if s.Name == req.Service {
-			continue
+	config.OnUpdate(func(c *config.Config) error {
+		services := c.Services
+		c.Services = nil
+		for _, s := range services {
+			if s.Name == req.Service {
+				continue
+			}
+			c.Services = append(c.Services, s)
 		}
-		cfg.Services = append(cfg.Services, s)
-	}
-	config.SetGlobal(cfg)
+		return nil
+	})
 
 	ctx.JSON(http.StatusOK, Response{
 		Msg: "OK",
diff --git a/config/config.go b/config/config.go
index 65146b7..c88d5ac 100644
--- a/config/config.go
+++ b/config/config.go
@@ -35,13 +35,20 @@ func Global() *Config {
 	return cfg
 }
 
-func SetGlobal(c *Config) {
+func Set(c *Config) {
 	globalMux.Lock()
 	defer globalMux.Unlock()
 
 	global = c
 }
 
+func OnUpdate(f func(c *Config) error) error {
+	globalMux.Lock()
+	defer globalMux.Unlock()
+
+	return f(global)
+}
+
 type LogConfig struct {
 	Output   string             `yaml:",omitempty" json:"output,omitempty"`
 	Level    string             `yaml:",omitempty" json:"level,omitempty"`