Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

client-go est une bibliothèque client publiée et maintenue par k8s spécifiquement pour que les développeurs puissent interagir avec Kubernetes. Il prend en charge les opérations CRUD (créer, lire, mettre à jour, supprimer) sur les ressources k8s, la surveillance et le traitement des événements, ainsi que l'accès au contexte et à la configuration du cluster Kubernetes.

Client go est une machine client indépendante du cluster Kubernetes mais qui interagit avec le cluster. Installez l'environnement go sur cette machine et établissez une connexion avec Kubernetes.

Linux

Installer l'environnement Go

Pour installer l'environnement go sur un nouveau nœud (dans mon cas, une machine virtuelle), téléchargez d'abord le package d'installation go et téléchargez-le depuis le site officiel.Toutes les versions - Le langage de programmation Go

Puisque j'installe une version serveur de la machine virtuelle, lors de l'installation de l'environnement go, j'utilise la commande curl pour télécharger le package d'installation. Étant donné que vous devez déterminer la compatibilité entre l'environnement go et le cluster k8s, vous devez vérifier la version k8s du cluster.

[root@master ~]# kubectl version --short
Version du client : v1.23.1
Version du serveur : v1.23.1

Consultez la documentation officielle de Kubernetes et constatez qu'elle correspond à la version 1.19.5 de Go.

[root@client ~]# curl -L -O https://go.dev/dl/go1.19.5.linux-amd64.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100    75  100    75    0     0    131      0 --:--:-- --:--:-- --:--:--   131
100 65.7M  100 65.7M    0     0  3446k      0  0:00:19  0:00:19 --:--:-- 3513k
[root@client ~]# file go1.22.5.linux-amd64.tar.gz
# 验证下载文件的类型是否为压缩包
go1.22.5.linux-amd64.tar.gz: gzip compressed data, max compression, original size modulo 2^32 232839680 gzip compressed data, unknown method, has CRC, extra field, has comment, encrypted, from FAT filesystem (MS-DOS, OS/2, NT), original size modulo 2^32 232839680
[root@client ~]# rm -rf /usr/local/go && tar -C /usr/local -xzf go1.22.5.linux-amd64.tar.gz

Ajoutez go à la variable d'environnement et vérifiez la version de go pour déterminer si go est installé avec succès.

[root@client ~]# export PATH=$PATH:/usr/local/go/bin
[root@client ~]# go version
go version go1.19.5 linux/amd64

Ajoutez go à la variable d'environnement de manière persistante et écrivez le export PATH=... ci-dessus dans le fichier système.

[root@client ~]# vim ~/.bashrc
[root@client ~]# source ~/.bashrc

Configurer le client-go

Si vous utilisez la version Kubernetes >= v1.17.0, veuillez utiliser la balise v0.xy correspondante. Par exemple, k8s.io/[email protected] correspond à Kubernetes v1.20.4. Ma version est la 1.23.1, alors téléchargez la version client-go correspondante :

go get k8s.io/client-go@v0.23.1

Le fichier go mod crée et démarre la prise en charge du mode go :

go mod init <module-name>
export GO111MODULE=on

Un fichier go.mod initial sera alors créé, comprenant le nom du module et les informations de version go. Au fur et à mesure que le projet est déployé ou que des dépendances sont ajoutées, go sera automatiquement mis à jour, enregistrant toutes les dépendances et leurs versions. . Le fichier go.sum est également généré pour garantir la cohérence et l'exhaustivité des dépendances. Par conséquent, le fichier go.mod accumulera progressivement toutes les dépendances et informations de version requises par le projet.

Utilisez client-go pour capturer des informations

Écrire le fichier main.go

package main
 
import (
	"flag"
	"fmt"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
	"context"
)
 
func main() {
	// 配置 k8s 集群外 kubeconfig 配置文件
	var kubeconfig *string
	kubeconfig = flag.String("kubeconfig", "/etc/k8scoonfig/config", "absolute path to the kubeconfig file")
    namespace := flag.String("namespace","default","the namespace to list the pod from")
	flag.Parse()
 
	// use the current context in kubeconfig
	config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
	if err != nil {
		panic(err.Error())
	}
 
	// create the clientset
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err.Error())
	}
 
	// 获取集群中所有 Pod 列表
	pods, err := clientset.CoreV1().Pods("").List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("There are %d pods in the k8s clustern", len(pods.Items))
 
	// 获取指定 namespace 中的 Pod 列表
	pods, err = clientset.CoreV1().Pods(*namespace).List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		panic(err)
	}
	fmt.Printf("There are %d pods in namespace %sn", len(pods.Items), namespace)
	for _, pod := range pods.Items {
		fmt.Printf("Name: %s, Status: %s, CreateTime: %vn", pod.Name, pod.Status.Phase, pod.CreationTimestamp)
	}
}

Lorsque vous spécifiez l'espace de noms comme monitor-sa, vous pouvez voir que client-go a réussi à capturer le nombre de pods dans l'espace de noms du cluster.

[root@client client_go_examples]# ./app -kubeconfig=/etc/k8scoonfig/config -namespace="monitor-sa"
There are 18 pods in the k8s cluster
There are 3 pods in namespace monitor-sa
Name: node-exporter-jb9jp, Status: Running, CreateTime: 2024-07-06 11:47:33 +0000 UTC
Name: node-exporter-kpvxd, Status: Running, CreateTime: 2024-07-06 11:47:33 +0000 UTC
Name: node-exporter-pwdw4, Status: Running, CreateTime: 2024-07-06 11:47:33 +0000 UTC

les fenêtres

Téléchargez Kubectl. Notez que l'endroit que vous téléchargez et enregistrez ici est l'endroit auquel vous ferez référence plus tard, il est donc préférable de se souvenir du chemin de sauvegarde et de ne pas l'enregistrer dans le dossier de téléchargement.https://storage.googleapis.com/kubernetes-release/release/v1.18.0/bin/windows/amd64/kubectl.exe

Ajoutez-le ensuite à la variable d'environnement. Le kube est ici le dossier où kubectl.exe est stocké.

Ouvrez la ligne de commande Windows et testez si kubectl fonctionne correctement.

Configurez kube-config et copiez le fichier de configuration copié sur le système Linux vers Windows. Le répertoire ici est C:/user/.kube/config. Ensuite, configurez-le dans vscode.

Code VS

Téléchargez client-go localement, puis téléchargez le plug-in go et le plug-in Code Runner dans vscode :

Ensuite cstrl+shift+p, entrez la ligne de recherche vscode et installez les dépendances du plug-in go. Rechercher Go : outils d'installation/mise à jour

Si cela se produit, vous devez définir des variables d'environnement. Définissez les quatre variables d'environnement suivantes, où go_path est le répertoire dans lequel le code go que vous souhaitez exécuter est stocké et go_root est le répertoire dans lequel vous avez téléchargé go.

Vérifiez le chemin. S'il y a les éléments suivants, c'est normal :

À ce stade, essayez à nouveau de télécharger les outils GO:install/update, et cela réussira.

Après une installation réussie, installez client-go dans le répertoire gopath

go get k8s.io/client-go@v0.23.1
go get k8s.io/apimachinery@v0.23.1
#使用 go mod tidy 确保所有依赖项已被正确下载并添加到项目中：
go mod tidy
go run main.go

J'ai constaté que l'opération avait réussi :