Does Karmada have a client-side way to access the API？

[XMingG99]

Like k8s, Karmada can set the proxy to allow external access to the API.
Does Karmada have a similar client-side way to access the API？
Refer to https://kubernetes.io/zh-cn/docs/tasks/run-application/access-api-from-pod/
https://kubernetes.io/zh-cn/docs/tasks/run-application/access-api-from-pod/

[whitewindmills]

You can access karmada-apiserver from a pod like this way using client-go:

• If you've setted the kubeconfig arg that refer to the karmada-apiserver:

restConfig := config.GetConfigOrDie()

if you need to access any member cluster, add host kindly:

restConfig.Host = restConfig.Host + fmt.Sprintf("/apis/cluster.karmada.io/v1alpha1/clusters/%s/proxy", clusterName)

• If you're using ServiceAccount, you need to ensure that the ServiceAccount already exists on the karmada control plane. For example:

const (
	clientDir    = "/var/run/secrets/client"
	tokenFile    = clientDir + "/token"
	caFile       = clientDir + "/ca.crt"
)
func CreateServiceAccountKarmadaConfig(host string, ca, token []byte) (*rest.Config, error) {
	if err := os.MkdirAll(clientDir, fs.ModeDir); err != nil {
		klog.Errorf("failed to mkdir client dir `%s`: %v", clientDir, err)
		// keep going on
	}
	if err := os.WriteFile(caFile, ca, fs.ModePerm); err != nil {
		klog.Errorf("error writing CA file `%s`: %v", caFile, err)
		return nil, err
	}
	if err := os.WriteFile(tokenFile, token, fs.ModePerm); err != nil {
		klog.Errorf("error writing token file `%s`: %v", tokenFile, err)
		return nil, err
	}

	tlsClientConfig := rest.TLSClientConfig{}

	if _, err := certutil.NewPoolFromBytes(ca); err != nil {
		klog.Errorf("expected to load client CA config from %s, but got err: %v", caFile, err)
	} else {
		tlsClientConfig.CAFile = caFile
	}

	return &rest.Config{
		Host:            host,
		TLSClientConfig: tlsClientConfig,
		BearerToken:     string(token),
		BearerTokenFile: tokenFile,
	}, nil
}

host: karmada-apiserver's addr
ca and token: thoes args are from your serviceaccount

[XMingG99]

Sorry to bother you again. Do you have any information about the client library(like client-go) related to Karmada,? Some code demos or some specific projects? I don't seem to find relevant information on the official website of Karmada.

[whitewindmills]

This is written by myself, if you have any questions, tell me kindly!
How do you access karmada-apiserver ? by kubeconfig or serviceaccount?

[XMingG99]

Thank you very much. We want to design a component to get the resource status of member clusters through karmada's APIs, such as CPU, memory, these hardware resources and the number of pods and other cloud-native resources, so we intend to use the client-side approach to implement this component, the probability is ServiceAccount, and is still learning about this piece of content.

[whitewindmills]

First, you should create your ServiceAccount in the Karmada control-plane no matter which way you use. It's not a problem, I think.

Second, kindly refer to the second item above, you can directly refer to this function CreateServiceAccountKarmadaConfig to create your rest-config. host is karmada-apiserver's addr that depends on how you deploy it, you should know it. The way to get ca and token depends on the Kubernetes version you are using. If your Kubernetes version is lower than v1.24, you can get them from your serviceaccount's secret, for example:

apiVersion: v1
imagePullSecrets:
- name: bar-dockercfg-lls6j
kind: ServiceAccount
metadata:
  creationTimestamp: "2023-02-27T02:44:26Z"
  name: bar
  namespace: default
  resourceVersion: "10226"
  uid: 991f44d3-0e7b-4258-892f-8c32e1391840
secrets:
- name: bar-token-kw7jh
- name: bar-dockercfg-lls6j

you can get them from bar-token-kw7jh secret, ca is the key ca.crt, token is the key token:

apiVersion: v1
data:
  ca.crt: -----BEGIN CERTIFICATE-----
MIIDKjCCAhKgAwIBAgIIdVgXmNm16lgwDQYJKoZIhvcNAQELBQAwMjENMAsGA1UE
CxMEY2NvczEhMB8GA1UEAxMYa3ViZS1hcGlzZXJ2ZXItbGItc2lnbmVyMCAXDTIz
MDIyNzAyMzcyMFoYDzIxMjIwMjAzMDIzNzIwWjAyMQ0wCwYDVQQLEwRjY29zMSEw
HwYDVQQDExhrdWJlLWFwaXNlcnZlci1sYi1zaWduZXIwggEiMA0GCSqGSIb3DQEB
AQUAA4IBDwAwggEKAoIBAQC5OLaGrxBggI3RYxxzhLBpvRSSSFxMMeJjVqoE/Wu/
UUw9FCCQddz3YcyAbM6o998bi+oemMPXiWP12wXAfFzMrpv6XVm4axt2Pg3xn2ZE
u/3dWaafCJqhMebduGxxP+7WhfWgmILJXsIr+Z6ISZSe3yJgvnk2M3gop+ct/5VF
PccB8CshPb+YrI+Sq+OO1i1pGAqiVBMdeF/AxaejHgbmo9KUyuFDEOkOJUOeud1s
z/i0L08/Duo0GPM+8FGWzYQQqEwDmbqScjdm5ELLhF34SyFFOgtl6mdCrj4YUySm
s6wtyvmzqqFJ0/ITqUkraHSpbG23LsLQzJcdeL3F7uirAgMBAAGjQjBAMA4GA1Ud
DwEB/wQEAwICpDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRudrJViDveQYgq
93evG7OUr7Ur+DANBgkqhkiG9w0BAQsFAAOCAQEAS4rEo2SuSi9ynHiSqpW9kV2d
FEav+IdR/slQ0nVRBAVnwlRbYzgtRanR6PP4qS/aKy9LYwPo/Zgrd5DHambar/0S
7ryR9zxdkjFj77vXeE6l1XzmoCU35dl+Au0dYkvwKfd0U2Qun8DhrANXRM0IL3hI
M5JT2AIpu3j5pUL6Mp0jKRdovLtSzdsqo56cX49JY8H0Ad7xHI4E/AJJPzVQS7+I
Xc0CB69RfMUBnSLS9p+A5K9aU/EBUB6UqxYygFP13YieGwjblkFNjB3rnvmGs3Uk
BKE6k+XDJMONCsukwf/c4iEihXB3GzOIhwGg/b3KY/1E0ce0ccfaPh29Jg5ruQ==
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDODCCAiCgAwIBAgIIZKzVUsy3BYYwDQYJKoZIhvcNAQELBQAwOTENMAsGA1UE
CxMEY2NvczEoMCYGA1UEAxMfa3ViZS1hcGlzZXJ2ZXItbG9jYWxob3N0LXNpZ25l
cjAgFw0yMzAyMjcwMjM3MjBaGA8yMTIyMDIwMzAyMzcyMFowOTENMAsGA1UECxME
Y2NvczEoMCYGA1UEAxMfa3ViZS1hcGlzZXJ2ZXItbG9jYWxob3N0LXNpZ25lcjCC
ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKiNmySN34PkwAUsAyBlFave
/aed2/4w8xBYSEbVn3Sji+jTG1MjP1i1t8k7Khsg7r9FnRG3EnlwE7/KfThXtsFS
RQxhsMjaR+NRePTvWnERdwiWELbeVFFSmfwRuWkatUo4LCY5OtA/agr72cqx3Yjb
uKrhRbOf81W4C1T3l3Z9dlnkbCNOgQ8oZ0drY+Mam7AjQpalFQjHnq/UvYwR33h0
V6EPbww6uK7CoDJjtkL07EL12HvK6t8Byr+QKxz7ySiKNcA2JBfZVeDE8eBr6xrp
+MLRTpTbrphHhKgIxTZuWW6ZYZxv40+NtpEXqTo3fdzyfoZzihQ2zIniQhlF9oEC
AwEAAaNCMEAwDgYDVR0PAQH/BAQDAgKkMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O
BBYEFLFmTO3fwMypig9Z2pkrnP7DgJ15MA0GCSqGSIb3DQEBCwUAA4IBAQA8nfYO
RST8YIEHo3upq6VNuAlltXQYQFxBByrSBQvJsukHLl6QxuDCdD1+7i/z0wvWu/+R
yHF/1iVSAIrvEDSOWK0XQn15qjfyExzn60lv0mfxsCX1NRZHILy6mIUME1rfVWd3
vRj/yIxMXWF2cHwUT+DFJQGaft26GeS0/B0u+JOlS4rSiyVgOm38lrkypMxpBF1u
I6ghThwDI65o7IFVHMB7gw2T3cjpUTmNWZHdhaB7bfI82P1Vkm0js5wg4jq0EUJz
L4vvDXiR4BkIZTSpMpu3sBPm2zBObR5B6wb5Dtzhx+WsMz+kaMzd0X2FDp/Z8nNZ
+i3anSvsxPs8nbOe
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDRDCCAiygAwIBAgIIWmMAHJyQ2BswDQYJKoZIhvcNAQELBQAwPzENMAsGA1UE
CxMEY2NvczEuMCwGA1UEAxMla3ViZS1hcGlzZXJ2ZXItc2VydmljZS1uZXR3b3Jr
LXNpZ25lcjAgFw0yMzAyMjcwMjM3MjBaGA8yMTIyMDIwMzAyMzcyMFowPzENMAsG
A1UECxMEY2NvczEuMCwGA1UEAxMla3ViZS1hcGlzZXJ2ZXItc2VydmljZS1uZXR3
b3JrLXNpZ25lcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALs4qrEE
veKnKn7iIuqm8GY42j+w9+gmhL6Dfu4hHZkDw26I7pToh58I7y/A4o0DbCJy4/Rs
wXh5P0doeR53ogoWGExV1qeK8kIDE9EhTGIYSE2dc9Qv0E+dpYkUoLQePYUffvni
rDYznWmY6IYtwA3AEMU3tVFYjICSoxvu5yJCKd8VYkvZpctxvqfX+wYMuMdmbIGW
5koq07h1zPSxw6Sqyt7Pie5hjOTOTlce61LGpJFKIRDHB3G8Y+mEOA9rkZh+EFlp
Z7zPAJAw4dTWWB3tkUVoMwyShccdwjEoSysTmxFk7/lehnoL2LzUM/kk7Ub6ajD1
RlrZLd1MnejEo58CAwEAAaNCMEAwDgYDVR0PAQH/BAQDAgKkMA8GA1UdEwEB/wQF
MAMBAf8wHQYDVR0OBBYEFBFeaNfKaGaB4v6wh1vQLZhjuKA7MA0GCSqGSIb3DQEB
CwUAA4IBAQAX5ieAs9D/JuZPwjf1omvnwt6WMAlNhmHN48zDwyWk75vGruV7TYtu
DXlBqXnLQ05CMITd5dKLOEvn3HO5BPlXVS9S1+bPX8AWsTjeC7l1u59Z+CdLYY3n
kK7/Ili3KRlCmwRbCS0nmeo52WYXZ5fqYkzQiF9tH/0zj9a6fbhU3dmEwW5Qljc2
ZDoZZDbpTatRkPM4bOdeRJKzDJIGZdlrOM8ET348sfGDJ9tvObcJLPxP9R/xRoor
yi34XnJohSf3WiRh1ZkatsE9ZPksH+s8kqrzXnDQkmLmvPqNiaNNc34t5g7jFaCQ
YvgCWRBQjDMDBqD1G430VrylZCtBU2y0
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDjzCCAnegAwIBAgIIUGPpVcpZ6mIwDQYJKoZIhvcNAQELBQAwVDFSMFAGA1UE
AwxJY2Nvcy1rdWJlLWFwaXNlcnZlci1vcGVyYXRvcl9sb2NhbGhvc3QtcmVjb3Zl
cnktc2VydmluZy1zaWduZXJAMTY3NzQ2NTg0MDAgFw0yMzAyMjcwMjQzNTlaGA8y
MTIyMDIwMzAyNDQwMFowVDFSMFAGA1UEAwxJY2Nvcy1rdWJlLWFwaXNlcnZlci1v
cGVyYXRvcl9sb2NhbGhvc3QtcmVjb3Zlcnktc2VydmluZy1zaWduZXJAMTY3NzQ2
NTg0MDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMkjvgI04Cj0ze35
6+R6zwiKxP8OvOpOrO+uMKV7HUHOaN9DwTF+CfzedGdSRjBxi8fTC5ErTb91HUDa
ZSC8LSdlsUrdQ52PsuPS2v1xCE81Fq2CmXXx7dDyD8wzPWBx6RB2dCxfy9w4/Ju/
MX076MN82nZBxJfcfbZEIKKlM4qyfgR7vqoDtgoBXnyDdSs3ur27M8Z65fuNLMC6
hbKTjy8KMsyjCSIHRztQl1TzHy7SrmZC543uTqaS1Dtrj66SE5pAYQgLXkCRb5LD
G3QKXcL8tm//MinhHOqoZyVue5KAY8YYYdWicyeEUVjUu8/tFUXK7wEP9rvzjMa6
9jtMaEsCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgKkMA8GA1UdEwEB/wQFMAMBAf8w
HQYDVR0OBBYEFKbJfciJ3LOZJ9PABnymZTu+gvzyMB8GA1UdIwQYMBaAFKbJfciJ
3LOZJ9PABnymZTu+gvzyMA0GCSqGSIb3DQEBCwUAA4IBAQAiGOYmDxZEySVbgE6l
SXJQjc5iYA4BFnJiah5oubATsLWKbeSVMxneQuv8gANRaavAuxWjYJNy4ybDdNWN
D97U3BOKtIuhjI3P/DEUvn0HFTBt/+WJ2p1uy2UdsBdvESURjx8GEr01nzsLRjNU
KLz6/jenOaFuT1pWLNFGdFF2olCt3+F7Eao2eZgK3GCZx1XC35Igt9H7vvdu3fDU
ThjAn7u1u3RkLMYLByMjZMjWDYqNnPbEG0cmsDhsl2Vhj6NkvNBiKrDwjzxbYGUP
W5q+J+7STk9zu5Y8hvkfGthyDP+D4AFVK4kAp7B0gxAmRjV/hyM1CVP3/Swqbexg
l62L
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDazCCAlOgAwIBAgIIe8HxwW+ezWYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UE
AwwbaW5ncmVzcy1vcGVyYXRvckAxNjc3NDY2NTcwMCIYDzE5MjYwMzIzMDI1NjEx
WhgPMjEyMDAyMDQwMjU2MTFaMCMxITAfBgNVBAMMGCouYXBwcy5jaXNpbmdsZTMu
Y2Nvcy5jbjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN5P673dxPVS
+6sSSSehTsnV1ZguLQUMjl6vbnia9lgbba7N80IeIl7MYVQqRONFihKMWlRLdiom
Z/WIFvleM9tWyQMYhGZm55zcCJTLuhp0bkRKWXda3foVxfZZwoC7SpfE6cfx4Hx0
GoT31oOhWMMhICxQXgX+75outyzFScxYVbv13e/ofpJunPEFruruFPG2M3SPZFwG
mLRy2ensK+0wJyWYHmjXpNxUOz2rC2vaOnXJpg9ygXSS6hlWa9Ha2J1XpOehVfgj
EbdxwiQjQT0zFCdD0ixjcNcHA6V+GHeRFhgJIx8pxHFqdffHkc/hq5DyMrSiSZXk
kggYVwRV3YMCAwEAAaOBmzCBmDAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0lBAwwCgYI
KwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUYTbLNkcXZwol06mVg/du
5YYz/uEwHwYDVR0jBBgwFoAUlDJA4L4+7z9zNxfQR+qpRZ+0sWYwIwYDVR0RBBww
GoIYKi5hcHBzLmNpc2luZ2xlMy5jY29zLmNuMA0GCSqGSIb3DQEBCwUAA4IBAQBs
dh1XWOpoFynxfNwTvgiWQwHbExI9BJFubgPL6VTknTOwxcoDn3fMpoz1wnN2Bgmk
ZBxf1rje6SDZmnddGKfScvzEFLzaECrDuLoDV6OdY4rJQ5KDSGv+XghTrRDiGc3u
RnQavfR1QYZSmzzdgaB3q8Gp04R2R9oBF68OI6djUhW0SUogItDaqjE3cnwpNFmJ
byMWyFEnOL4eUO4jTm48YGV1b93AX/MQdWL1S1xlwRbjgW4gLnyWU3dQWKyDZnRb
4PH2cxBkYEKg+mxWmY+cQL5447bu16L11E5Gk3JuyKQ3XbhHGaehoHHimZG6GiTi
3myZYshQiCcINxt+UTGQ
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDDjCCAfagAwIBAgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBtpbmdy
ZXNzLW9wZXJhdG9yQDE2Nzc0NjY1NzAwIBcNMjMwMjI3MDI1NjEwWhgPMjEyMjAy
MDMwMjU2MTFaMCYxJDAiBgNVBAMMG2luZ3Jlc3Mtb3BlcmF0b3JAMTY3NzQ2NjU3
MDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ9QyWijICrdUBWzu0EO
gNmsEsAluQeXxYZJhA7p7L5Nv5Ml8m+1GvAVGwS+nJu95ZvmXhZ+jedsMety6+LY
47n1kEuOLpHKvRFdY3UXFtH5FcixvZKVEQPBrMr/o/1hCFxka8XhufNZ6cl5FK3X
t+W/J7Lpy4NcZ3uyxIBouR5mDQ5jBD62qkIU1zuxFZbCyW6SQXQjrp/YjX4YfkFn
MZiWL03UAwJmT8tOpAlVhNdLgbYTNGepG9LrMToC8dMetysM3FXhjboTvB3rmFaU
RiUw7fVDqkzyZWsH0drk6IC+BEXn7Y+RoguIWR5Nan167PJ/5PQ+tCzEFrEfpX42
KV8CAwEAAaNFMEMwDgYDVR0PAQH/BAQDAgKkMBIGA1UdEwEB/wQIMAYBAf8CAQAw
HQYDVR0OBBYEFJQyQOC+Pu8/czcX0EfqqUWftLFmMA0GCSqGSIb3DQEBCwUAA4IB
AQCS9eCo/RfTkFCnm/ra30+vHrBuRo2yB0d0RXW8LZkfePhJ4I4H/LN+Uo2m7tmk
bmYP8LoreWADfkH497tqNI7q4VBDbCjnGYft9+t+FJx+XJduWKVymvJEEqNgFWj7
j/9f18FmnZyyzGiOoeDojWvJyFelgrlmg8jlH2zbDj8Onzaxb43k+YM0HTDsKVHc
onqPksuyLtABPiL0SLMPpEqXN+xOOb9cM1lmfAVZ8Ta2ulpFFMfI51BMLeHluw2o
TiNxMBn1kpXZywzHfoG/e+k01gTtG/obV+uqtLkgdyeDwj8SLhWLdQNiTcBgZ33b
N4UOOH5V0xShqmdETVVV3BFa
-----END CERTIFICATE-----

  namespace: Y2Nvcy1hcHBtYXJrZXQ=
  service-ca.crt: -----BEGIN CERTIFICATE-----
MIIDKjCCAhKgAwIBAgIIdVgXmNm16lgwDQYJKoZIhvcNAQELBQAwMjENMAsGA1UE
CxMEY2NvczEhMB8GA1UEAxMYa3ViZS1hcGlzZXJ2ZXItbGItc2lnbmVyMCAXDTIz
MDIyNzAyMzcyMFoYDzIxMjIwMjAzMDIzNzIwWjAyMQ0wCwYDVQQLEwRjY29zMSEw
HwYDVQQDExhrdWJlLWFwaXNlcnZlci1sYi1zaWduZXIwggEiMA0GCSqGSIb3DQEB
AQUAA4IBDwAwggEKAoIBAQC5OLaGrxBggI3RYxxzhLBpvRSSSFxMMeJjVqoE/Wu/
UUw9FCCQddz3YcyAbM6o998bi+oemMPXiWP12wXAfFzMrpv6XVm4axt2Pg3xn2ZE
u/3dWaafCJqhMebduGxxP+7WhfWgmILJXsIr+Z6ISZSe3yJgvnk2M3gop+ct/5VF
PccB8CshPb+YrI+Sq+OO1i1pGAqiVBMdeF/AxaejHgbmo9KUyuFDEOkOJUOeud1s
z/i0L08/Duo0GPM+8FGWzYQQqEwDmbqScjdm5ELLhF34SyFFOgtl6mdCrj4YUySm
s6wtyvmzqqFJ0/ITqUkraHSpbG23LsLQzJcdeL3F7uirAgMBAAGjQjBAMA4GA1Ud
DwEB/wQEAwICpDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRudrJViDveQYgq
93evG7OUr7Ur+DANBgkqhkiG9w0BAQsFAAOCAQEAS4rEo2SuSi9ynHiSqpW9kV2d
FEav+IdR/slQ0nVRBAVnwlRbYzgtRanR6PP4qS/aKy9LYwPo/Zgrd5DHambar/0S
7ryR9zxdkjFj77vXeE6l1XzmoCU35dl+Au0dYkvwKfd0U2Qun8DhrANXRM0IL3hI
M5JT2AIpu3j5pUL6Mp0jKRdovLtSzdsqo56cX49JY8H0Ad7xHI4E/AJJPzVQS7+I
Xc0CB69RfMUBnSLS9p+A5K9aU/EBUB6UqxYygFP13YieGwjblkFNjB3rnvmGs3Uk
BKE6k+XDJMONCsukwf/c4iEihXB3GzOIhwGg/b3KY/1E0ce0ccfaPh29Jg5ruQ==
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDODCCAiCgAwIBAgIIZKzVUsy3BYYwDQYJKoZIhvcNAQELBQAwOTENMAsGA1UE
CxMEY2NvczEoMCYGA1UEAxMfa3ViZS1hcGlzZXJ2ZXItbG9jYWxob3N0LXNpZ25l
cjAgFw0yMzAyMjcwMjM3MjBaGA8yMTIyMDIwMzAyMzcyMFowOTENMAsGA1UECxME
Y2NvczEoMCYGA1UEAxMfa3ViZS1hcGlzZXJ2ZXItbG9jYWxob3N0LXNpZ25lcjCC
ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKiNmySN34PkwAUsAyBlFave
/aed2/4w8xBYSEbVn3Sji+jTG1MjP1i1t8k7Khsg7r9FnRG3EnlwE7/KfThXtsFS
RQxhsMjaR+NRePTvWnERdwiWELbeVFFSmfwRuWkatUo4LCY5OtA/agr72cqx3Yjb
uKrhRbOf81W4C1T3l3Z9dlnkbCNOgQ8oZ0drY+Mam7AjQpalFQjHnq/UvYwR33h0
V6EPbww6uK7CoDJjtkL07EL12HvK6t8Byr+QKxz7ySiKNcA2JBfZVeDE8eBr6xrp
+MLRTpTbrphHhKgIxTZuWW6ZYZxv40+NtpEXqTo3fdzyfoZzihQ2zIniQhlF9oEC
AwEAAaNCMEAwDgYDVR0PAQH/BAQDAgKkMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O
BBYEFLFmTO3fwMypig9Z2pkrnP7DgJ15MA0GCSqGSIb3DQEBCwUAA4IBAQA8nfYO
RST8YIEHo3upq6VNuAlltXQYQFxBByrSBQvJsukHLl6QxuDCdD1+7i/z0wvWu/+R
yHF/1iVSAIrvEDSOWK0XQn15qjfyExzn60lv0mfxsCX1NRZHILy6mIUME1rfVWd3
vRj/yIxMXWF2cHwUT+DFJQGaft26GeS0/B0u+JOlS4rSiyVgOm38lrkypMxpBF1u
I6ghThwDI65o7IFVHMB7gw2T3cjpUTmNWZHdhaB7bfI82P1Vkm0js5wg4jq0EUJz
L4vvDXiR4BkIZTSpMpu3sBPm2zBObR5B6wb5Dtzhx+WsMz+kaMzd0X2FDp/Z8nNZ
+i3anSvsxPs8nbOe
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDRDCCAiygAwIBAgIIWmMAHJyQ2BswDQYJKoZIhvcNAQELBQAwPzENMAsGA1UE
CxMEY2NvczEuMCwGA1UEAxMla3ViZS1hcGlzZXJ2ZXItc2VydmljZS1uZXR3b3Jr
LXNpZ25lcjAgFw0yMzAyMjcwMjM3MjBaGA8yMTIyMDIwMzAyMzcyMFowPzENMAsG
A1UECxMEY2NvczEuMCwGA1UEAxMla3ViZS1hcGlzZXJ2ZXItc2VydmljZS1uZXR3
b3JrLXNpZ25lcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALs4qrEE
veKnKn7iIuqm8GY42j+w9+gmhL6Dfu4hHZkDw26I7pToh58I7y/A4o0DbCJy4/Rs
wXh5P0doeR53ogoWGExV1qeK8kIDE9EhTGIYSE2dc9Qv0E+dpYkUoLQePYUffvni
rDYznWmY6IYtwA3AEMU3tVFYjICSoxvu5yJCKd8VYkvZpctxvqfX+wYMuMdmbIGW
5koq07h1zPSxw6Sqyt7Pie5hjOTOTlce61LGpJFKIRDHB3G8Y+mEOA9rkZh+EFlp
Z7zPAJAw4dTWWB3tkUVoMwyShccdwjEoSysTmxFk7/lehnoL2LzUM/kk7Ub6ajD1
RlrZLd1MnejEo58CAwEAAaNCMEAwDgYDVR0PAQH/BAQDAgKkMA8GA1UdEwEB/wQF
MAMBAf8wHQYDVR0OBBYEFBFeaNfKaGaB4v6wh1vQLZhjuKA7MA0GCSqGSIb3DQEB
CwUAA4IBAQAX5ieAs9D/JuZPwjf1omvnwt6WMAlNhmHN48zDwyWk75vGruV7TYtu
DXlBqXnLQ05CMITd5dKLOEvn3HO5BPlXVS9S1+bPX8AWsTjeC7l1u59Z+CdLYY3n
kK7/Ili3KRlCmwRbCS0nmeo52WYXZ5fqYkzQiF9tH/0zj9a6fbhU3dmEwW5Qljc2
ZDoZZDbpTatRkPM4bOdeRJKzDJIGZdlrOM8ET348sfGDJ9tvObcJLPxP9R/xRoor
yi34XnJohSf3WiRh1ZkatsE9ZPksH+s8kqrzXnDQkmLmvPqNiaNNc34t5g7jFaCQ
YvgCWRBQjDMDBqD1G430VrylZCtBU2y0
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDjzCCAnegAwIBAgIIUGPpVcpZ6mIwDQYJKoZIhvcNAQELBQAwVDFSMFAGA1UE
AwxJY2Nvcy1rdWJlLWFwaXNlcnZlci1vcGVyYXRvcl9sb2NhbGhvc3QtcmVjb3Zl
cnktc2VydmluZy1zaWduZXJAMTY3NzQ2NTg0MDAgFw0yMzAyMjcwMjQzNTlaGA8y
MTIyMDIwMzAyNDQwMFowVDFSMFAGA1UEAwxJY2Nvcy1rdWJlLWFwaXNlcnZlci1v
cGVyYXRvcl9sb2NhbGhvc3QtcmVjb3Zlcnktc2VydmluZy1zaWduZXJAMTY3NzQ2
NTg0MDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMkjvgI04Cj0ze35
6+R6zwiKxP8OvOpOrO+uMKV7HUHOaN9DwTF+CfzedGdSRjBxi8fTC5ErTb91HUDa
ZSC8LSdlsUrdQ52PsuPS2v1xCE81Fq2CmXXx7dDyD8wzPWBx6RB2dCxfy9w4/Ju/
MX076MN82nZBxJfcfbZEIKKlM4qyfgR7vqoDtgoBXnyDdSs3ur27M8Z65fuNLMC6
hbKTjy8KMsyjCSIHRztQl1TzHy7SrmZC543uTqaS1Dtrj66SE5pAYQgLXkCRb5LD
G3QKXcL8tm//MinhHOqoZyVue5KAY8YYYdWicyeEUVjUu8/tFUXK7wEP9rvzjMa6
9jtMaEsCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgKkMA8GA1UdEwEB/wQFMAMBAf8w
HQYDVR0OBBYEFKbJfciJ3LOZJ9PABnymZTu+gvzyMB8GA1UdIwQYMBaAFKbJfciJ
3LOZJ9PABnymZTu+gvzyMA0GCSqGSIb3DQEBCwUAA4IBAQAiGOYmDxZEySVbgE6l
SXJQjc5iYA4BFnJiah5oubATsLWKbeSVMxneQuv8gANRaavAuxWjYJNy4ybDdNWN
D97U3BOKtIuhjI3P/DEUvn0HFTBt/+WJ2p1uy2UdsBdvESURjx8GEr01nzsLRjNU
KLz6/jenOaFuT1pWLNFGdFF2olCt3+F7Eao2eZgK3GCZx1XC35Igt9H7vvdu3fDU
ThjAn7u1u3RkLMYLByMjZMjWDYqNnPbEG0cmsDhsl2Vhj6NkvNBiKrDwjzxbYGUP
W5q+J+7STk9zu5Y8hvkfGthyDP+D4AFVK4kAp7B0gxAmRjV/hyM1CVP3/Swqbexg
l62L
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDazCCAlOgAwIBAgIIe8HxwW+ezWYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UE
AwwbaW5ncmVzcy1vcGVyYXRvckAxNjc3NDY2NTcwMCIYDzE5MjYwMzIzMDI1NjEx
WhgPMjEyMDAyMDQwMjU2MTFaMCMxITAfBgNVBAMMGCouYXBwcy5jaXNpbmdsZTMu
Y2Nvcy5jbjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN5P673dxPVS
+6sSSSehTsnV1ZguLQUMjl6vbnia9lgbba7N80IeIl7MYVQqRONFihKMWlRLdiom
Z/WIFvleM9tWyQMYhGZm55zcCJTLuhp0bkRKWXda3foVxfZZwoC7SpfE6cfx4Hx0
GoT31oOhWMMhICxQXgX+75outyzFScxYVbv13e/ofpJunPEFruruFPG2M3SPZFwG
mLRy2ensK+0wJyWYHmjXpNxUOz2rC2vaOnXJpg9ygXSS6hlWa9Ha2J1XpOehVfgj
EbdxwiQjQT0zFCdD0ixjcNcHA6V+GHeRFhgJIx8pxHFqdffHkc/hq5DyMrSiSZXk
kggYVwRV3YMCAwEAAaOBmzCBmDAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0lBAwwCgYI
KwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUYTbLNkcXZwol06mVg/du
5YYz/uEwHwYDVR0jBBgwFoAUlDJA4L4+7z9zNxfQR+qpRZ+0sWYwIwYDVR0RBBww
GoIYKi5hcHBzLmNpc2luZ2xlMy5jY29zLmNuMA0GCSqGSIb3DQEBCwUAA4IBAQBs
dh1XWOpoFynxfNwTvgiWQwHbExI9BJFubgPL6VTknTOwxcoDn3fMpoz1wnN2Bgmk
ZBxf1rje6SDZmnddGKfScvzEFLzaECrDuLoDV6OdY4rJQ5KDSGv+XghTrRDiGc3u
RnQavfR1QYZSmzzdgaB3q8Gp04R2R9oBF68OI6djUhW0SUogItDaqjE3cnwpNFmJ
byMWyFEnOL4eUO4jTm48YGV1b93AX/MQdWL1S1xlwRbjgW4gLnyWU3dQWKyDZnRb
4PH2cxBkYEKg+mxWmY+cQL5447bu16L11E5Gk3JuyKQ3XbhHGaehoHHimZG6GiTi
3myZYshQiCcINxt+UTGQ
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDDjCCAfagAwIBAgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBtpbmdy
ZXNzLW9wZXJhdG9yQDE2Nzc0NjY1NzAwIBcNMjMwMjI3MDI1NjEwWhgPMjEyMjAy
MDMwMjU2MTFaMCYxJDAiBgNVBAMMG2luZ3Jlc3Mtb3BlcmF0b3JAMTY3NzQ2NjU3
MDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ9QyWijICrdUBWzu0EO
gNmsEsAluQeXxYZJhA7p7L5Nv5Ml8m+1GvAVGwS+nJu95ZvmXhZ+jedsMety6+LY
47n1kEuOLpHKvRFdY3UXFtH5FcixvZKVEQPBrMr/o/1hCFxka8XhufNZ6cl5FK3X
t+W/J7Lpy4NcZ3uyxIBouR5mDQ5jBD62qkIU1zuxFZbCyW6SQXQjrp/YjX4YfkFn
MZiWL03UAwJmT8tOpAlVhNdLgbYTNGepG9LrMToC8dMetysM3FXhjboTvB3rmFaU
RiUw7fVDqkzyZWsH0drk6IC+BEXn7Y+RoguIWR5Nan167PJ/5PQ+tCzEFrEfpX42
KV8CAwEAAaNFMEMwDgYDVR0PAQH/BAQDAgKkMBIGA1UdEwEB/wQIMAYBAf8CAQAw
HQYDVR0OBBYEFJQyQOC+Pu8/czcX0EfqqUWftLFmMA0GCSqGSIb3DQEBCwUAA4IB
AQCS9eCo/RfTkFCnm/ra30+vHrBuRo2yB0d0RXW8LZkfePhJ4I4H/LN+Uo2m7tmk
bmYP8LoreWADfkH497tqNI7q4VBDbCjnGYft9+t+FJx+XJduWKVymvJEEqNgFWj7
j/9f18FmnZyyzGiOoeDojWvJyFelgrlmg8jlH2zbDj8Onzaxb43k+YM0HTDsKVHc
onqPksuyLtABPiL0SLMPpEqXN+xOOb9cM1lmfAVZ8Ta2ulpFFMfI51BMLeHluw2o
TiNxMBn1kpXZywzHfoG/e+k01gTtG/obV+uqtLkgdyeDwj8SLhWLdQNiTcBgZ33b
N4UOOH5V0xShqmdETVVV3BFa
-----END CERTIFICATE-----

-----BEGIN CERTIFICATE-----
MIIDSTCCAjGgAwIBAgIIChqT6aUW3UkwDQYJKoZIhvcNAQELBQAwMTEvMC0GA1UE
AwwmY2Nvcy1zZXJ2aWNlLXNlcnZpbmctc2lnbmVyQDE2Nzc0NjU4NTMwIBcNMjMw
MjI3MDI0NDEyWhgPMjEyMjAyMDMwMjQ0MTNaMDExLzAtBgNVBAMMJmNjb3Mtc2Vy
dmljZS1zZXJ2aW5nLXNpZ25lckAxNjc3NDY1ODUzMIIBIjANBgkqhkiG9w0BAQEF
AAOCAQ8AMIIBCgKCAQEAwKeAwA+lexMDtB2L2iJNVJHDnLEwyuoOReCQo6UJ7t23
XjUa5PnwaDFG12p+kGo4NiBzDa4+oA6N8zNpMf48h3teVcq4Azhb5IFU3T0ACmf+
wiGMwHfHVDAKhNI9zDTkDLaqZq5tub8huoVT5sOXA+T9kncydkLFkyxhoRhI6Tw4
WgsfoYlGGoSndshGU/oWgxeMERTMfNaOtF6QIbt2mIxqkMCGdlpHGIKxl32Y5Epe
WAeMIuCfBNf+ftCkJ7OtA9QgvHkowMomE574+e/UdQqOvr67vqGVsMTNRTHNC2/5
bOCQ9XonWEtf70mqRhKxKaUFPClhKuxDTjRC/Nb2TwIDAQABo2MwYTAOBgNVHQ8B
Af8EBAMCAqQwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU03WhrUA+4hnOChDs
+jToNQf39jYwHwYDVR0jBBgwFoAU03WhrUA+4hnOChDs+jToNQf39jYwDQYJKoZI
hvcNAQELBQADggEBAEeX2M95mAoOQ/6gGfzSpYDLta2N2jhuvWXuindDgNro1EhE
cjqlij4wsUhlfzIva3tffNfjLqs9QrgBt4jtVqDzgXNy+SeoH35ZEFNQB6nq5VsB
oU7OUjvw8cPrciDYS99RPms1be9z+Y6UN+eCuToT7L6msm+tK/f9cQMIZQl88CgQ
4EadYd9XvG48ERj6VgWi6t8v5OfYtyUlISNUOJOSlNbbFK1+ch/6Q/QRxNHZL7TS
I3P7MX7ADUkPuq8jPeQF6rLpbnyo3he0lwHlTPViAl7y69flgnxe8RGR3OBf5KX/
Vh0BSUXvIcQ4AbtC0Rbenwk011//IxqRceR12PM=
-----END CERTIFICATE-----

  token: ZXlKaGJHY2lPaUpTVXpJMU5pSXNJbXRwWkNJNklrc3hTVVI2YVVaM01ubGxMV3RNWDNKdFVEUTFNbWxoVEhZMmMzSTNNSEJLV1UxdFRETjNiVmhtYkhjaWZRLmV5SnBjM01pT2lKcmRXSmxjbTVsZEdWekwzTmxjblpwWTJWaFkyTnZkVzUwSWl3aWEzVmlaWEp1WlhSbGN5NXBieTl6WlhKMmFXTmxZV05qYjNWdWRDOXVZVzFsYzNCaFkyVWlPaUpqWTI5ekxXRndjRzFoY210bGRDSXNJbXQxWW1WeWJtVjBaWE11YVc4dmMyVnlkbWxqWldGalkyOTFiblF2YzJWamNtVjBMbTVoYldVaU9pSmhjSEJ0WVhKclpYUXRkRzlyWlc0dGEzYzNhbWdpTENKcmRXSmxjbTVsZEdWekxtbHZMM05sY25acFkyVmhZMk52ZFc1MEwzTmxjblpwWTJVdFlXTmpiM1Z1ZEM1dVlXMWxJam9pWVhCd2JXRnlhMlYwSWl3aWEzVmlaWEp1WlhSbGN5NXBieTl6WlhKMmFXTmxZV05qYjNWdWRDOXpaWEoyYVdObExXRmpZMjkxYm5RdWRXbGtJam9pT1RreFpqUTBaRE10TUdVM1lpMDBNalU0TFRnNU1tWXRPR016TW1VeE16a3hPRFF3SWl3aWMzVmlJam9pYzNsemRHVnRPbk5sY25acFkyVmhZMk52ZFc1ME9tTmpiM010WVhCd2JXRnlhMlYwT21Gd2NHMWhjbXRsZENKOS5Ockt5X2pFTC1RM3g2NEVlMlA5V3lvWjNrZnQ1ZnZYQU9Qd3A1S0hnVzFfVHZwLUgyWXRKVncwNWRnVVFSVjRBSUhEdWhmQkVScC03R0JncTdBNU9tZXlKY1YtdGkxdEw0RVBjYTZVTVBPMmJhbnFnOHExcFNYUy11NEVSUWhZZnE4T1d5ai1xQUlEVHlDNUpBQWNLWFdnenhxcGhWRThkeVpBMTRTX2d4UXowLTdwSU5yVVNEaVpmSnFNYjV2cjlRTEJXSXFjQW1KdGRVM0xlRWpvcGtQZ3ZxcHRrYm1JanQyUkQ2Wm5UeW9PZEJZdW4zSjhySVhTaVhVYkxaYWctS2Z2M0R3dUJpMFBoZlRzNk1wOUdTQ2pZeGR1Zi1OSDBPNUF2M3NUbUY5cm1BYTE4UlFjbDZPcGc2YWJHMFQ0WTJIMTJ0TGhqNUczSjVYUTJLbU5qOUE=
kind: Secret
metadata:
  annotations:
    kubernetes.io/service-account.name: bar
    kubernetes.io/service-account.uid: 991f44d3-0e7b-4258-892f-8c32e1391840
  creationTimestamp: "2023-02-27T02:44:26Z"
  name: bar-token-kw7jh
  namespace: default
  resourceVersion: "20485"
  uid: ae236a32-7fab-4bac-8e84-a35cfca9a13c
type: kubernetes.io/service-account-token

otherwise you should create token by TokenRequest API.

Finally, you should change your rest-config's Host, like this:

restConfig.Host = restConfig.Host + fmt.Sprintf("/apis/cluster.karmada.io/v1alpha1/clusters/%s/proxy", clusterName)

clusterName is your member cluster's name. You can create any client in client-go using the rest-config!

[XMingG99]

I'll try that, thank you.