diff --git a/server/proxy/grpcproxy/auth.go b/server/proxy/grpcproxy/auth.go
index 0cabfc146..753dfa47a 100644
--- a/server/proxy/grpcproxy/auth.go
+++ b/server/proxy/grpcproxy/auth.go
@@ -18,98 +18,81 @@ import (
 	"context"
 
 	pb "go.etcd.io/etcd/api/v3/etcdserverpb"
-	"go.etcd.io/etcd/client/v3"
+	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
 type AuthProxy struct {
-	client *clientv3.Client
+	authClient pb.AuthClient
 }
 
 func NewAuthProxy(c *clientv3.Client) pb.AuthServer {
-	return &AuthProxy{client: c}
+	return &AuthProxy{authClient: pb.NewAuthClient(c.ActiveConnection())}
 }
 
 func (ap *AuthProxy) AuthEnable(ctx context.Context, r *pb.AuthEnableRequest) (*pb.AuthEnableResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).AuthEnable(ctx, r)
+	return ap.authClient.AuthEnable(ctx, r)
 }
 
 func (ap *AuthProxy) AuthDisable(ctx context.Context, r *pb.AuthDisableRequest) (*pb.AuthDisableResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).AuthDisable(ctx, r)
+	return ap.authClient.AuthDisable(ctx, r)
 }
 
 func (ap *AuthProxy) AuthStatus(ctx context.Context, r *pb.AuthStatusRequest) (*pb.AuthStatusResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).AuthStatus(ctx, r)
+	return ap.authClient.AuthStatus(ctx, r)
 }
 
 func (ap *AuthProxy) Authenticate(ctx context.Context, r *pb.AuthenticateRequest) (*pb.AuthenticateResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).Authenticate(ctx, r)
+	return ap.authClient.Authenticate(ctx, r)
 }
 
 func (ap *AuthProxy) RoleAdd(ctx context.Context, r *pb.AuthRoleAddRequest) (*pb.AuthRoleAddResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).RoleAdd(ctx, r)
+	return ap.authClient.RoleAdd(ctx, r)
 }
 
 func (ap *AuthProxy) RoleDelete(ctx context.Context, r *pb.AuthRoleDeleteRequest) (*pb.AuthRoleDeleteResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).RoleDelete(ctx, r)
+	return ap.authClient.RoleDelete(ctx, r)
 }
 
 func (ap *AuthProxy) RoleGet(ctx context.Context, r *pb.AuthRoleGetRequest) (*pb.AuthRoleGetResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).RoleGet(ctx, r)
+	return ap.authClient.RoleGet(ctx, r)
 }
 
 func (ap *AuthProxy) RoleList(ctx context.Context, r *pb.AuthRoleListRequest) (*pb.AuthRoleListResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).RoleList(ctx, r)
+	return ap.authClient.RoleList(ctx, r)
 }
 
 func (ap *AuthProxy) RoleRevokePermission(ctx context.Context, r *pb.AuthRoleRevokePermissionRequest) (*pb.AuthRoleRevokePermissionResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).RoleRevokePermission(ctx, r)
+	return ap.authClient.RoleRevokePermission(ctx, r)
 }
 
 func (ap *AuthProxy) RoleGrantPermission(ctx context.Context, r *pb.AuthRoleGrantPermissionRequest) (*pb.AuthRoleGrantPermissionResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).RoleGrantPermission(ctx, r)
+	return ap.authClient.RoleGrantPermission(ctx, r)
 }
 
 func (ap *AuthProxy) UserAdd(ctx context.Context, r *pb.AuthUserAddRequest) (*pb.AuthUserAddResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).UserAdd(ctx, r)
+	return ap.authClient.UserAdd(ctx, r)
 }
 
 func (ap *AuthProxy) UserDelete(ctx context.Context, r *pb.AuthUserDeleteRequest) (*pb.AuthUserDeleteResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).UserDelete(ctx, r)
+	return ap.authClient.UserDelete(ctx, r)
 }
 
 func (ap *AuthProxy) UserGet(ctx context.Context, r *pb.AuthUserGetRequest) (*pb.AuthUserGetResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).UserGet(ctx, r)
+	return ap.authClient.UserGet(ctx, r)
 }
 
 func (ap *AuthProxy) UserList(ctx context.Context, r *pb.AuthUserListRequest) (*pb.AuthUserListResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).UserList(ctx, r)
+	return ap.authClient.UserList(ctx, r)
 }
 
 func (ap *AuthProxy) UserGrantRole(ctx context.Context, r *pb.AuthUserGrantRoleRequest) (*pb.AuthUserGrantRoleResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).UserGrantRole(ctx, r)
+	return ap.authClient.UserGrantRole(ctx, r)
 }
 
 func (ap *AuthProxy) UserRevokeRole(ctx context.Context, r *pb.AuthUserRevokeRoleRequest) (*pb.AuthUserRevokeRoleResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).UserRevokeRole(ctx, r)
+	return ap.authClient.UserRevokeRole(ctx, r)
 }
 
 func (ap *AuthProxy) UserChangePassword(ctx context.Context, r *pb.AuthUserChangePasswordRequest) (*pb.AuthUserChangePasswordResponse, error) {
-	conn := ap.client.ActiveConnection()
-	return pb.NewAuthClient(conn).UserChangePassword(ctx, r)
+	return ap.authClient.UserChangePassword(ctx, r)
 }
diff --git a/server/proxy/grpcproxy/election.go b/server/proxy/grpcproxy/election.go
index a9ec0fddd..9ea8d9615 100644
--- a/server/proxy/grpcproxy/election.go
+++ b/server/proxy/grpcproxy/election.go
@@ -17,35 +17,34 @@ package grpcproxy
 import (
 	"context"
 
-	"go.etcd.io/etcd/client/v3"
+	clientv3 "go.etcd.io/etcd/client/v3"
 	"go.etcd.io/etcd/server/v3/etcdserver/api/v3election/v3electionpb"
 )
 
 type electionProxy struct {
-	client *clientv3.Client
+	electionClient v3electionpb.ElectionClient
 }
 
 func NewElectionProxy(client *clientv3.Client) v3electionpb.ElectionServer {
-	return &electionProxy{client: client}
+	return &electionProxy{electionClient: v3electionpb.NewElectionClient(client.ActiveConnection())}
 }
 
 func (ep *electionProxy) Campaign(ctx context.Context, req *v3electionpb.CampaignRequest) (*v3electionpb.CampaignResponse, error) {
-	return v3electionpb.NewElectionClient(ep.client.ActiveConnection()).Campaign(ctx, req)
+	return ep.electionClient.Campaign(ctx, req)
 }
 
 func (ep *electionProxy) Proclaim(ctx context.Context, req *v3electionpb.ProclaimRequest) (*v3electionpb.ProclaimResponse, error) {
-	return v3electionpb.NewElectionClient(ep.client.ActiveConnection()).Proclaim(ctx, req)
+	return ep.electionClient.Proclaim(ctx, req)
 }
 
 func (ep *electionProxy) Leader(ctx context.Context, req *v3electionpb.LeaderRequest) (*v3electionpb.LeaderResponse, error) {
-	return v3electionpb.NewElectionClient(ep.client.ActiveConnection()).Leader(ctx, req)
+	return ep.electionClient.Leader(ctx, req)
 }
 
 func (ep *electionProxy) Observe(req *v3electionpb.LeaderRequest, s v3electionpb.Election_ObserveServer) error {
-	conn := ep.client.ActiveConnection()
 	ctx, cancel := context.WithCancel(s.Context())
 	defer cancel()
-	sc, err := v3electionpb.NewElectionClient(conn).Observe(ctx, req)
+	sc, err := ep.electionClient.Observe(ctx, req)
 	if err != nil {
 		return err
 	}
@@ -61,5 +60,5 @@ func (ep *electionProxy) Observe(req *v3electionpb.LeaderRequest, s v3electionpb
 }
 
 func (ep *electionProxy) Resign(ctx context.Context, req *v3electionpb.ResignRequest) (*v3electionpb.ResignResponse, error) {
-	return v3electionpb.NewElectionClient(ep.client.ActiveConnection()).Resign(ctx, req)
+	return ep.electionClient.Resign(ctx, req)
 }
diff --git a/server/proxy/grpcproxy/lock.go b/server/proxy/grpcproxy/lock.go
index 9859b9369..9458080db 100644
--- a/server/proxy/grpcproxy/lock.go
+++ b/server/proxy/grpcproxy/lock.go
@@ -17,22 +17,22 @@ package grpcproxy
 import (
 	"context"
 
-	"go.etcd.io/etcd/client/v3"
+	clientv3 "go.etcd.io/etcd/client/v3"
 	"go.etcd.io/etcd/server/v3/etcdserver/api/v3lock/v3lockpb"
 )
 
 type lockProxy struct {
-	client *clientv3.Client
+	lockClient v3lockpb.LockClient
 }
 
 func NewLockProxy(client *clientv3.Client) v3lockpb.LockServer {
-	return &lockProxy{client: client}
+	return &lockProxy{lockClient: v3lockpb.NewLockClient(client.ActiveConnection())}
 }
 
 func (lp *lockProxy) Lock(ctx context.Context, req *v3lockpb.LockRequest) (*v3lockpb.LockResponse, error) {
-	return v3lockpb.NewLockClient(lp.client.ActiveConnection()).Lock(ctx, req)
+	return lp.lockClient.Lock(ctx, req)
 }
 
 func (lp *lockProxy) Unlock(ctx context.Context, req *v3lockpb.UnlockRequest) (*v3lockpb.UnlockResponse, error) {
-	return v3lockpb.NewLockClient(lp.client.ActiveConnection()).Unlock(ctx, req)
+	return lp.lockClient.Unlock(ctx, req)
 }
diff --git a/server/proxy/grpcproxy/maintenance.go b/server/proxy/grpcproxy/maintenance.go
index 3e8165625..50ecf67ff 100644
--- a/server/proxy/grpcproxy/maintenance.go
+++ b/server/proxy/grpcproxy/maintenance.go
@@ -19,32 +19,30 @@ import (
 	"io"
 
 	pb "go.etcd.io/etcd/api/v3/etcdserverpb"
-	"go.etcd.io/etcd/client/v3"
+	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
 type maintenanceProxy struct {
-	client *clientv3.Client
+	maintenanceClient pb.MaintenanceClient
 }
 
 func NewMaintenanceProxy(c *clientv3.Client) pb.MaintenanceServer {
 	return &maintenanceProxy{
-		client: c,
+		maintenanceClient: pb.NewMaintenanceClient(c.ActiveConnection()),
 	}
 }
 
 func (mp *maintenanceProxy) Defragment(ctx context.Context, dr *pb.DefragmentRequest) (*pb.DefragmentResponse, error) {
-	conn := mp.client.ActiveConnection()
-	return pb.NewMaintenanceClient(conn).Defragment(ctx, dr)
+	return mp.maintenanceClient.Defragment(ctx, dr)
 }
 
 func (mp *maintenanceProxy) Snapshot(sr *pb.SnapshotRequest, stream pb.Maintenance_SnapshotServer) error {
-	conn := mp.client.ActiveConnection()
 	ctx, cancel := context.WithCancel(stream.Context())
 	defer cancel()
 
 	ctx = withClientAuthToken(ctx, stream.Context())
 
-	sc, err := pb.NewMaintenanceClient(conn).Snapshot(ctx, sr)
+	sc, err := mp.maintenanceClient.Snapshot(ctx, sr)
 	if err != nil {
 		return err
 	}
@@ -65,31 +63,25 @@ func (mp *maintenanceProxy) Snapshot(sr *pb.SnapshotRequest, stream pb.Maintenan
 }
 
 func (mp *maintenanceProxy) Hash(ctx context.Context, r *pb.HashRequest) (*pb.HashResponse, error) {
-	conn := mp.client.ActiveConnection()
-	return pb.NewMaintenanceClient(conn).Hash(ctx, r)
+	return mp.maintenanceClient.Hash(ctx, r)
 }
 
 func (mp *maintenanceProxy) HashKV(ctx context.Context, r *pb.HashKVRequest) (*pb.HashKVResponse, error) {
-	conn := mp.client.ActiveConnection()
-	return pb.NewMaintenanceClient(conn).HashKV(ctx, r)
+	return mp.maintenanceClient.HashKV(ctx, r)
 }
 
 func (mp *maintenanceProxy) Alarm(ctx context.Context, r *pb.AlarmRequest) (*pb.AlarmResponse, error) {
-	conn := mp.client.ActiveConnection()
-	return pb.NewMaintenanceClient(conn).Alarm(ctx, r)
+	return mp.maintenanceClient.Alarm(ctx, r)
 }
 
 func (mp *maintenanceProxy) Status(ctx context.Context, r *pb.StatusRequest) (*pb.StatusResponse, error) {
-	conn := mp.client.ActiveConnection()
-	return pb.NewMaintenanceClient(conn).Status(ctx, r)
+	return mp.maintenanceClient.Status(ctx, r)
 }
 
 func (mp *maintenanceProxy) MoveLeader(ctx context.Context, r *pb.MoveLeaderRequest) (*pb.MoveLeaderResponse, error) {
-	conn := mp.client.ActiveConnection()
-	return pb.NewMaintenanceClient(conn).MoveLeader(ctx, r)
+	return mp.maintenanceClient.MoveLeader(ctx, r)
 }
 
 func (mp *maintenanceProxy) Downgrade(ctx context.Context, r *pb.DowngradeRequest) (*pb.DowngradeResponse, error) {
-	conn := mp.client.ActiveConnection()
-	return pb.NewMaintenanceClient(conn).Downgrade(ctx, r)
+	return mp.maintenanceClient.Downgrade(ctx, r)
 }