golang轻量级Kubernetes容器编排插件库k3s的使用

Golang轻量级Kubernetes容器编排插件库k3s的使用

K3s是一个轻量级的Kubernetes发行版,专为边缘计算、IoT设备、CI/CD环境和开发场景设计。它打包为单个二进制文件,小于100MB,内存占用仅为标准Kubernetes的一半。

K3s的主要特点

  1. 完全兼容Kubernetes标准
  2. 默认使用sqlite3作为存储后端(也支持etcd3、MariaDB、MySQL和Postgres)
  3. 将Kubernetes和其他组件打包为一个简单的启动器
  4. 针对轻量级环境进行了安全优化
  5. 对操作系统的依赖极少
  6. 通过websocket隧道暴露kubelet API

快速安装

使用安装脚本可以方便地下载K3s并添加为系统服务:

curl -sfL https://get.k3s.io | sh -

安装完成后:

  • kubeconfig文件会写入/etc/rancher/k3s/k3s.yaml
  • 服务会自动启动
  • 同时会安装kubectlcrictl等工具

手动安装

  1. 从最新release下载k3s二进制文件
  2. 运行服务器
sudo k3s server &
# Kubeconfig写入/etc/rancher/k3s/k3s.yaml
sudo k3s kubectl get nodes

# 在其他节点上运行agent
# NODE_TOKEN来自服务器上的/var/lib/rancher/k3s/server/node-token
sudo k3s agent --server https://myserver:6443 --token ${NODE_TOKEN}

Golang中使用k3s的示例

以下是一个使用Golang操作k3s集群的示例代码:

package main

import (
	"context"
	"fmt"
	"os"
	"path/filepath"

	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
	"k8s.io/client-go/util/homedir"
)

func main() {
	// 获取kubeconfig文件路径
	var kubeconfig string
	if home := homedir.HomeDir(); home != "" {
		kubeconfig = filepath.Join(home, ".kube", "config")
	} else {
		kubeconfig = "/etc/rancher/k3s/k3s.yaml" // k3s默认配置文件位置
	}

	// 使用kubeconfig创建配置
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
	if err != nil {
		fmt.Printf("Error building kubeconfig: %v\n", err)
		os.Exit(1)
	}

	// 创建Kubernetes客户端
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		fmt.Printf("Error creating clientset: %v\n", err)
		os.Exit(1)
	}

	// 获取节点列表
	nodes, err := clientset.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		fmt.Printf("Error listing nodes: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("Nodes in k3s cluster:")
	for _, node := range nodes.Items {
		fmt.Printf("- %s\n", node.Name)
	}

	// 创建示例Deployment
	deployment := &appsv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name: "demo-deployment",
		},
		Spec: appsv1.DeploymentSpec{
			Replicas: int32Ptr(2),
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{
					"app": "demo",
				},
			},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						"app": "demo",
					},
				},
				Spec: corev1.PodSpec{
					Containers: []corev1.Container{
						{
							Name:  "web",
							Image: "nginx:1.14.2",
							Ports: []corev1.ContainerPort{
								{
									Name:          "http",
									Protocol:      corev1.ProtocolTCP,
									ContainerPort: 80,
								},
							},
						},
					},
				},
			},
		},
	}

	// 在k3s集群中创建Deployment
	result, err := clientset.AppsV1().Deployments("default").Create(context.TODO(), deployment, metav1.CreateOptions{})
	if err != nil {
		fmt.Printf("Error creating Deployment: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Created deployment %q.\n", result.GetObjectMeta().GetName())
}

func int32Ptr(i int32) *int32 { return &i }

适用场景

K3s特别适合以下场景:

  • 边缘计算
  • IoT设备
  • 持续集成(CI)
  • 开发环境
  • ARM设备
  • 嵌入式Kubernetes
  • 需要简化Kubernetes集群管理的场景

技术组件

K3s捆绑了以下技术组件:

  • Containerd和runc
  • Flannel(CNI)
  • CoreDNS
  • Metrics Server
  • Traefik(ingress)
  • Klipper-lb(服务负载均衡)
  • Kube-router(网络策略)
  • Helm-controller
  • Kine(数据存储)
  • Local-path-provisioner(本地存储)

这些组件可以根据需要禁用或替换为其他技术。


更多关于golang轻量级Kubernetes容器编排插件库k3s的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang轻量级Kubernetes容器编排插件库k3s的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


K3s: 轻量级Kubernetes容器编排插件库使用指南

K3s是Rancher Labs开发的轻量级Kubernetes发行版,专为资源受限环境和边缘计算场景设计。相比标准Kubernetes,K3s具有以下特点:

  1. 体积小(<100MB)
  2. 内存占用低(仅需512MB即可运行)
  3. 安装简单(单二进制文件)
  4. 内置containerd替代Docker
  5. 支持SQLite替代etcd

安装K3s

快速安装

# 安装K3s服务端
curl -sfL https://get.k3s.io | sh -

# 获取节点信息
sudo k3s kubectl get nodes

# 获取kubeconfig
sudo cat /etc/rancher/k3s/k3s.yaml

高可用安装

# 第一个服务端节点
curl -sfL https://get.k3s.io | sh -s - server --cluster-init

# 后续节点加入集群
curl -sfL https://get.k3s.io | sh -s - server --server https://<第一个节点IP>:6443

Golang中使用K3s客户端

安装Kubernetes客户端库

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

示例代码:连接K3s集群并操作资源

package main

import (
	"context"
	"fmt"
	"log"
	"path/filepath"
	"time"

	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
	"k8s.io/client-go/util/homedir"
)

func main() {
	// 获取kubeconfig路径,通常位于~/.kube/config或/etc/rancher/k3s/k3s.yaml
	home := homedir.HomeDir()
	kubeconfig := filepath.Join(home, ".kube", "config")
	
	// 使用kubeconfig创建配置
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
	if err != nil {
		log.Fatalf("Error building kubeconfig: %v", err)
	}

	// 创建Kubernetes客户端
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		log.Fatalf("Error creating clientset: %v", err)
	}

	// 示例1: 列出所有Pod
	pods, err := clientset.CoreV1().Pods("").List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		log.Fatalf("Error listing pods: %v", err)
	}
	fmt.Println("Pods in cluster:")
	for _, pod := range pods.Items {
		fmt.Printf("- %s in namespace %s\n", pod.Name, pod.Namespace)
	}

	// 示例2: 创建命名空间
	namespace := &corev1.Namespace{
		ObjectMeta: metav1.ObjectMeta{
			Name: "test-namespace",
		},
	}
	_, err = clientset.CoreV1().Namespaces().Create(context.TODO(), namespace, metav1.CreateOptions{})
	if err != nil {
		log.Printf("Error creating namespace: %v", err)
	} else {
		fmt.Println("Namespace created successfully")
	}

	// 示例3: 部署简单应用
	deployment := `
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: test-namespace
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
`
	// 使用动态客户端应用YAML
	discoveryClient, _ := clientset.Discovery().RESTClient()
	_, err = discoveryClient.Post().
		AbsPath("/apis/apps/v1/namespaces/test-namespace/deployments").
		Body([]byte(deployment)).
		DoRaw(context.TODO())
	if err != nil {
		log.Printf("Error creating deployment: %v", err)
	} else {
		fmt.Println("Deployment created successfully")
	}

	// 等待并检查部署状态
	time.Sleep(10 * time.Second)
	deploy, err := clientset.AppsV1().Deployments("test-namespace").Get(context.TODO(), "nginx-deployment", metav1.GetOptions{})
	if err != nil {
		log.Printf("Error getting deployment: %v", err)
	} else {
		fmt.Printf("Deployment status: %d/%d replicas available\n", 
			deploy.Status.AvailableReplicas, *deploy.Spec.Replicas)
	}
}

K3s常用操作

管理K3s服务

# 启动服务
sudo systemctl start k3s

# 停止服务
sudo systemctl stop k3s

# 查看服务状态
sudo systemctl status k3s

# 卸载K3s
/usr/local/bin/k3s-uninstall.sh

部署应用

# 使用kubectl部署
kubectl create deployment nginx --image=nginx

# 暴露服务
kubectl expose deployment nginx --port=80

# 使用Helm
helm repo add bitnami https://charts.bitnami.com/bitnami
helm install my-release bitnami/nginx

K3s高级配置

使用外部数据库

# 使用MySQL作为数据存储
curl -sfL https://get.k3s.io | sh -s - server \
  --datastore-endpoint="mysql://username:password@tcp(hostname:3306)/database-name"

配置containerd镜像仓库

# 创建配置文件
sudo mkdir -p /etc/rancher/k3s
cat <<EOF | sudo tee /etc/rancher/k3s/registries.yaml
mirrors:
  "docker.io":
    endpoint:
      - "https://mirror.example.com"
EOF

# 重启k3s
sudo systemctl restart k3s

K3s是边缘计算、IoT和开发环境的理想选择,它保留了Kubernetes所有核心功能,同时大幅降低了资源消耗和复杂性。通过Golang客户端可以轻松实现自动化管理,非常适合集成到CI/CD流程中。

回到顶部