KubeVela: Golang云原生应用交付与管理插件库使用指南

KubeVela 是一个开源的、基于 Go 语言开发的云原生应用交付与管理平台，它构建在 Kubernetes 之上，提供了更高级别的抽象来简化应用的部署和管理。

核心概念

1. Application - 应用的核心抽象，定义了要部署的内容
2. Component - 应用的组成部分，可以是微服务、数据库等
3. Trait - 为组件添加的特性，如自动扩缩容、Ingress等
4. Workflow - 定义应用的交付流程

安装与设置

首先需要安装 KubeVela CLI 工具：

curl -fsSl https://kubevela.io/script/install.sh | bash

验证安装：

vela version

基本使用示例

1. 初始化应用

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/oam-dev/kubevela-core-api/apis/core.oam.dev/v1beta1"
	"k8s.io/apimachinery/pkg/runtime"
	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/client/config"
)

func main() {
	scheme := runtime.NewScheme()
	_ = clientgoscheme.AddToScheme(scheme)
	_ = v1beta1.AddToScheme(scheme)

	cfg, err := config.GetConfig()
	if err != nil {
		fmt.Printf("Error getting config: %v\n", err)
		os.Exit(1)
	}

	k8sClient, err := client.New(cfg, client.Options{Scheme: scheme})
	if err != nil {
		fmt.Printf("Error creating client: %v\n", err)
		os.Exit(1)
	}

	app := &v1beta1.Application{
		Spec: v1beta1.ApplicationSpec{
			Components: []v1beta1.ApplicationComponent{
				{
					Name:       "my-web-service",
					Type:       "webservice",
					Properties: runtime.RawExtension{Raw: []byte(`{"image": "nginx:latest", "port": 80}`)},
				},
			},
		},
	}
	app.SetName("demo-app")
	app.SetNamespace("default")

	err = k8sClient.Create(context.Background(), app)
	if err != nil {
		fmt.Printf("Error creating application: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("Application created successfully!")
}

2. 添加特性(Trait)

// 在上面的Application定义中添加Trait
app.Spec.Components[0].Traits = []v1beta1.ApplicationTrait{
	{
		Type: "ingress",
		Properties: runtime.RawExtension{
			Raw: []byte(`{"domain": "example.com", "http":{"/": 80}}`),
		},
	},
}

3. 定义工作流(Workflow)

app.Spec.Workflow = &v1beta1.Workflow{
	Steps: []v1beta1.WorkflowStep{
		{
			Name: "deploy-web",
			Type: "deploy",
			Properties: runtime.RawExtension{
				Raw: []byte(`{"policies": ["my-policy"]}`),
			},
		},
		{
			Name: "notify",
			Type: "notification",
			Properties: runtime.RawExtension{
				Raw: []byte(`{"slack": {"message": "Deployment completed"}}`),
			},
		},
	},
}

高级功能

1. 自定义组件类型

package main

import (
	"context"
	"fmt"

	"github.com/oam-dev/kubevela-core-api/apis/core.oam.dev/common"
	"github.com/oam-dev/kubevela-core-api/apis/core.oam.dev/v1beta1"
	"k8s.io/apimachinery/pkg/runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

func registerCustomComponent(k8sClient client.Client) error {
	compDef := &v1beta1.ComponentDefinition{
		Spec: v1beta1.ComponentDefinitionSpec{
			Workload: common.WorkloadTypeDescriptor{
				Definition: common.WorkloadGVK{
					APIVersion: "apps/v1",
					Kind:       "Deployment",
				},
			},
			Schematic: &common.Schematic{
				CUE: &common.CUE{
					Template: `
output: {
	apiVersion: "apps/v1"
	kind:       "Deployment"
	spec: {
		selector: matchLabels: {
			"app.oam.dev/component": context.name
		}
		template: {
			metadata: labels: {
				"app.oam.dev/component": context.name
			}
			spec: {
				containers: [{
					name:  context.name
					image: parameter.image
					if parameter["cmd"] != _|_ {
						command: parameter.cmd
					}
				}]
			}
		}
	}
}
parameter: {
	image: string
	cmd?: [...string]
}`,
				},
			},
		},
	}
	compDef.SetName("custom-component")
	return k8sClient.Create(context.Background(), compDef)
}

2. 使用KubeVela SDK

package main

import (
	"context"
	"fmt"

	"github.com/kubevela/workflow/api/v1alpha1"
	"github.com/kubevela/workflow/pkg/cue/packages"
	"github.com/kubevela/workflow/pkg/cue/process"
	"github.com/kubevela/workflow/pkg/executor"
	"github.com/kubevela/workflow/pkg/types"
)

func runWorkflow() error {
	ctx := context.Background()
	pd := packages.NewPackageDiscover()
	proc := process.NewContextProcessor(pd)
	
	wf := &v1alpha1.Workflow{
		Steps: []v1alpha1.WorkflowStep{
			{
				Name: "step1",
				Type: "my-step",
				Properties: map[string]interface{}{
					"param1": "value1",
				},
			},
		},
	}

	exec := executor.NewWorkflowExecutor(wf, proc, pd)
	_, err := exec.Execute(ctx, &types.WorkflowExecuteOptions{
		Namespace: "default",
	})
	return err
}

最佳实践

1. 模块化设计：将应用拆分为多个组件，每个组件专注于单一功能
2. 重用特性：为常见需求（如监控、日志）创建可重用的Trait
3. 渐进式交付：利用工作流实现金丝雀发布、蓝绿部署等策略
4. 策略管理：使用Policy定义部署策略（如资源限制、节点选择）

调试与监控

// 获取应用状态
func getAppStatus(k8sClient client.Client, name, namespace string) error {
	app := &v1beta1.Application{}
	err := k8sClient.Get(context.Background(), client.ObjectKey{Name: name, Namespace: namespace}, app)
	if err != nil {
		return err
	}
	
	fmt.Printf("Application status: %+v\n", app.Status)
	
	for _, comp := range app.Status.Services {
		fmt.Printf("Component %s health status: %s\n", comp.Name, comp.Healthy)
	}
	
	return nil
}

KubeVela 提供了强大的抽象能力，使得开发者可以专注于应用本身而非底层基础设施。通过其插件化架构，可以轻松扩展功能以满足各种云原生场景需求。