go客户端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package main
 
import (
	"context"
	"fmt"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes/scheme"
	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/clientcmd"
)
 
func restClientGetPods() {
	// 获取config，从本机中获取kubeconfig的配置文件。
	config, err := clientcmd.BuildConfigFromFlags("", clientcmd.RecommendedHomeFile)
	if err != nil {
		panic(err)
	}
 
	// 因为pod的group为空，version为v1
	config.GroupVersion = &v1.SchemeGroupVersion
	// 设置反序列化
	config.NegotiatedSerializer = scheme.Codecs
	// 指定ApiPath,参考/api/v1/namespaces/{namespace}/pods
	config.APIPath = "/api"
 
	// 根据配置文件，获取rest客户端
	client, err := rest.RESTClientFor(config)
	if err != nil {
		panic(err)
	}
 
	// 指定接收参数
	result := &v1.PodList{}
 
	// 指定namespace
	namespace := "kube-system"
	// 通过rest client获取pod的信息
	err = client.Get().
		Namespace(namespace).                                                    // 指定namespace
		Resource("pods").                                                        // 指定要获取的资源对象
		VersionedParams(&metav1.ListOptions{Limit: 100}, scheme.ParameterCodec). // 指定大小限制和序列化工具
		Do(context.TODO()).                                                      // 执行
		Into(result)                                                             // 将结果写入result
	if err != nil {
		panic(err)
	}
 
	for _, pod := range result.Items {
		fmt.Println(pod.Name)
	}
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

package main
 
import (
	"context"
	"fmt"
  "k8s.io/client-go/rest"
	"k8s.io/client-go/tools/clientcmd"
	v1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/utils/pointer"
)
 
const (
	NAMESPACE  = "dev"
	DEPLOYMENT = "dev-deploy"
	SERVICE    = "dev-service"
)
 
func initConfig() (*rest.Config, error) {
	// config
	// 从本机中获取kubeconfig的配置文件，因此第一个参数是空字符串
	config, err := clientcmd.BuildConfigFromFlags("", clientcmd.RecommendedHomeFile)
	if err != nil {
		return nil, err
	}
	return config, nil
}
 
 
// 初始化客户端
func initClient() (*kubernetes.Clientset, error) {
	config, err := initConfig()
	if err != nil {
		panic(err)
	}
	// 实例化clientSet对象
	return kubernetes.NewForConfig(config)
}
 
func createNamespace(clientSet *kubernetes.Clientset) {
	// 获取namespace的接口
	namespaceClient := clientSet.CoreV1().Namespaces()
	namespace := &corev1.Namespace{
		ObjectMeta: metav1.ObjectMeta{
			Name: NAMESPACE,
		},
		Status: corev1.NamespaceStatus{},
	}
	// 调用Create方法进行创建
	ns, err := namespaceClient.Create(context.TODO(), namespace, metav1.CreateOptions{})
	if err != nil {
		panic(err)
	}
 
	fmt.Println(ns.GetName())
}
 
func createDeploy(clientSet *kubernetes.Clientset) {
	// 获取deploy的接口
	deployClient := clientSet.AppsV1().Deployments(NAMESPACE)
	// 定义要创建的deployment
	deploy := &v1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name:      DEPLOYMENT,
			Namespace: NAMESPACE,
		},
		Spec: v1.DeploymentSpec{
			Replicas: pointer.Int32(2),
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{
					"app": "nginx",
				},
			},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Name: "nginx",
					Labels: map[string]string{
						"app": "nginx",
					},
				},
				Spec: corev1.PodSpec{
					Containers: []corev1.Container{
						{
							Name:  "nginx",
							Image: "nginx:1.17.1",
							Ports: []corev1.ContainerPort{
								{
									ContainerPort: 80,
									Protocol:      corev1.ProtocolTCP,
								},
							},
							ImagePullPolicy: "IfNotPresent",
						},
					},
				},
			},
		},
		Status: v1.DeploymentStatus{},
	}
	// 创建
	result, err := deployClient.Create(context.TODO(), deploy, metav1.CreateOptions{})
	if err != nil {
		panic(err)
	}
	fmt.Println(result.GetName())
}
 
// 创建svc
func createService(clientSet *kubernetes.Clientset) {
	// 获取serivce的接口
	serviceClient := clientSet.CoreV1().Services(NAMESPACE)
	// 定义service
	service := &corev1.Service{
		ObjectMeta: metav1.ObjectMeta{
			Name:      SERVICE,
			Namespace: NAMESPACE,
		},
		Spec: corev1.ServiceSpec{
			Ports: []corev1.ServicePort{
				{
					Port:     80,
					NodePort: 30001,
				},
			},
			Selector: map[string]string{
				"app": "nginx",
			},
			Type: corev1.ServiceTypeNodePort,
		},
		Status: corev1.ServiceStatus{},
	}
 
	result, err := serviceClient.Create(context.TODO(), service, metav1.CreateOptions{})
	if err != nil {
		panic(err)
	}
	fmt.Println(result.GetName())
}
 
// 测试
func Run() {
	// 创建clientSet的客户端
	clientSet, err := initClient()
	if err != nil {
		panic(err)
	}
 
	// 通过clientSet创建namespace
	createNamespace(clientSet)
 
	// 通过clientSet创建deployment
	createDeploy(clientSet)
 
	// 通过clientSet创建service
	createService(clientSet)
}
 
func deleteAll() {
	emptyDeleteOptions := metav1.DeleteOptions{}
	clientSet, err := initClient()
	if err != nil {
		return
	}
	// 删除svc
	err = clientSet.CoreV1().Services(NAMESPACE).Delete(context.TODO(), SERVICE, emptyDeleteOptions)
	if err != nil {
		return
	}
 
	// 删除deployment
	err = clientSet.AppsV1().Deployments(NAMESPACE).Delete(context.TODO(), DEPLOYMENT, emptyDeleteOptions)
	if err != nil {
		return
	}
 
	// 删除namespace
	err = clientSet.CoreV1().Namespaces().Delete(context.TODO(), NAMESPACE, emptyDeleteOptions)
	if err != nil {
		return
	}
 
	// 删除pod
	err = clientSet.CoreV1().Pods("default").Delete(context.TODO(), "nginx", emptyDeleteOptions)
	if err != nil {
		return
	}
}