Kubernetes 集群下的 Serverless 架构-JavaScript中文网-JavaScript教程资源分享门户

前言

Serverless 架构已经成为了现代应用开发的一种重要方式，它能够使得开发者更专注于业务逻辑，而无需关注底层架构的管理。而 Kubernetes 作为目前最流行的容器编排平台，也能够提供一种 Serverless 架构的支持方式。本文将会详细介绍在 Kubernetes 集群下实现 Serverless 架构的方案。

Kubernetes 中的 Serverless

在 Kubernetes 中，我们可以使用 Knative 来构建 Serverless 架构。Knative 是一个 Kubernetes 的扩展组件，它能够为 Kubernetes 提供 Serverless 的能力。Knative 中主要包含了两个组件：Knative Serving 和 Knative Eventing。

Knative Serving

Knative Serving 是 Knative 的核心组件，它提供了一种 Serverless 应用的构建和运行方式。Knative Serving 提供了以下几个重要概念：

Service：Knative Serving 中的 Service 与 Kubernetes 中的 Service 类似，但是它更加轻量级，能够支持更快的启动和伸缩。Service 是一个逻辑上的概念，它定义了一组 Pod，这些 Pod 可以对外提供服务。
Revision：Revision 是 Service 的一个版本，它定义了一个 Service 的具体实现。每当一个 Service 的代码或配置发生变化时，都会创建一个新的 Revision。Knative Serving 会自动管理多个 Revision 的版本，并且能够进行流量的切换和回滚。
Route：Route 定义了一个 Service 的访问路径和流量规则。Knative Serving 支持基于 HTTP 和 DNS 的路由方式。Route 可以将流量分发到不同的 Revision 上。

下面是一个简单的 Knative Serving 的示例：

// javascriptcn.com 代码示例
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: helloworld
spec:
  template:
    spec:
      containers:
        - image: gcr.io/knative-samples/helloworld-go
          env:
            - name: TARGET
              value: "Knative"

这个示例定义了一个名为 helloworld 的 Service，它使用了一个名为 gcr.io/knative-samples/helloworld-go 的镜像。这个镜像会输出一个 Hello World 的消息，并且会将环境变量 TARGET 的值替换为 Knative。我们可以使用 kubectl apply 命令来创建这个 Service：

$ kubectl apply -f service.yaml

创建完成后，我们可以使用 kubectl get ksvc 命令来查看这个 Service 的状态：

$ kubectl get ksvc helloworld
NAME        URL                                         LATESTCREATED   LATESTREADY     READY   REASON
helloworld  http://helloworld.default.example.com       helloworld-00001 helloworld-00001 True

可以看到，这个 Service 已经创建成功，并且可以通过 http://helloworld.default.example.com 访问。

Knative Eventing

Knative Eventing 提供了一种基于事件的消息传递机制，它能够将不同的事件源和事件消费者连接起来。Knative Eventing 提供了以下几个重要概念：

Broker：Broker 是一个消息队列，它用于存储事件消息。Knative Eventing 支持多种不同的 Broker 实现，包括 Apache Kafka 和 NATS 等。
Trigger：Trigger 定义了一个事件消费者，它会监听指定的事件类型和条件，并在事件发生时触发一个动作。Trigger 可以将事件发送到一个 HTTP 端点、一个 Knative Serving Service 或者一个事件网关上。
Event：Event 是一个 JSON 格式的消息，它包含了事件的类型和数据。事件可以由任何来源产生，例如 Kubernetes 中的资源变更、HTTP 请求或者自定义的代码逻辑等。

下面是一个简单的 Knative Eventing 的示例：

apiVersion: eventing.knative.dev/v1
kind: Broker
metadata:
  name: default

这个示例定义了一个名为 default 的 Broker，它使用了默认的 NATS 实现。我们可以使用 kubectl apply 命令来创建这个 Broker：

$ kubectl apply -f broker.yaml

创建完成后，我们可以使用 kubectl get broker 命令来查看这个 Broker 的状态：

$ kubectl get broker
NAME     URL                                                 AGE
default  http://default-broker.default.svc.cluster.local:9092  5s

可以看到，这个 Broker 已经创建成功，并且可以通过 http://default-broker.default.svc.cluster.local:9092 访问。

示例代码

下面是一个基于 Knative Serving 和 Knative Eventing 的示例代码：

// javascriptcn.com 代码示例
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
)

type helloWorldRequest struct {
    Name string `json:"name"`
}

type helloWorldResponse struct {
    Message string `json:"message"`
}

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
            return
        }

        var req helloWorldRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
            http.Error(w, "Bad request", http.StatusBadRequest)
            return
        }

        resp := helloWorldResponse{
            Message: fmt.Sprintf("Hello, %s!", req.Name),
        }

        if err := json.NewEncoder(w).Encode(resp); err != nil {
            http.Error(w, "Internal server error", http.StatusInternalServerError)
            return
        }
    })

    log.Printf("Listening on %s...", port)
    if err := http.ListenAndServe(fmt.Sprintf(":%s", port), nil); err != nil {
        log.Fatalf("Failed to start server: %v", err)
    }
}

这个示例是一个简单的 HTTP 服务，它会接收一个名为 name 的参数，并返回一个 Hello World 的消息。我们可以使用以下命令将这个服务打包成一个 Docker 镜像：

$ docker build -t my-helloworld:v1 .

然后，我们可以使用以下命令将这个镜像部署到 Kubernetes 集群中：

$ kubectl apply -f deployment.yaml

这个部署文件定义了一个名为 my-helloworld 的 Knative Serving Service，它使用了我们刚才打包的镜像。创建完成后，我们可以使用以下命令来查看这个 Service 的状态：

$ kubectl get ksvc my-helloworld

创建完成后，我们还需要创建一个 Knative Eventing 的 Trigger，用于监听 HTTP 请求：

// javascriptcn.com 代码示例
apiVersion: eventing.knative.dev/v1
kind: Trigger
metadata:
  name: my-helloworld-trigger
spec:
  broker: default
  filter:
    attributes:
      type: dev.knative.samples.helloworld
  subscriber:
    ref:
      apiVersion: serving.knative.dev/v1
      kind: Service
      name: my-helloworld

这个 Trigger 会监听类型为 dev.knative.samples.helloworld 的事件，并将事件发送到名为 my-helloworld 的 Knative Serving Service 上。我们可以使用以下命令来创建这个 Trigger：

$ kubectl apply -f trigger.yaml

创建完成后，我们就可以使用 curl 命令来测试这个服务了：

$ curl -H "Content-Type: application/json" -X POST -d '{"name":"Knative"}' http://default-broker.default.svc.cluster.local:8080
{"message":"Hello, Knative!"}

可以看到，这个服务已经成功返回了一个 Hello, Knative! 的消息。

总结

Knative 提供了一种基于 Kubernetes 的 Serverless 架构的支持方式，它能够帮助开发者更专注于业务逻辑，而无需关注底层架构的管理。本文介绍了 Knative Serving 和 Knative Eventing 的基本概念和使用方式，并且提供了一个完整的示例代码。希望本文能够帮助读者更好地理解 Kubernetes 中的 Serverless 架构。

来源：JavaScript中文网，转载请注明来源本文地址：https://www.javascriptcn.com/post/657a477dd2f5e1655d4853f2