使用 Service 把前端连接到后端

本任务会描述如何创建前端微服务和后端微服务。后端微服务是一个 hello 欢迎程序。 前端和后端的连接是通过 Kubernetes 服务对象（Service object）完成的。

教程目标

  • 使用部署对象（Deployment object）创建并运行一个微服务
  • 从后端将流量路由到前端
  • 使用服务对象把前端应用连接到后端应用

准备开始

  • 你必须拥有一个 Kubernetes 的集群，同时你的 Kubernetes 集群必须带有 kubectl 命令行工具。 如果你还没有集群，你可以通过 Minikube 构建一 个你自己的集群，或者你可以使用下面任意一个 Kubernetes 工具构建：

要获知版本信息，请输入 kubectl version.

  • 本任务使用 外部负载均衡服务， 所以需要对应的可支持此功能的环境。如果你的环境不能支持，你可以使用 NodePort 类型的服务代替。

使用部署对象（Deployment）创建后端

后端是一个简单的 hello 欢迎微服务应用。这是后端应用的 Deployment 配置文件：

service/access/hello.yaml 使用 Service 把前端连接到后端 - 图1
  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   name: hello
  5. spec:
  6.   selector:
  7.     matchLabels:
  8.       app: hello
  9.       tier: backend
  10.       track: stable
  11.   replicas: 7
  12.   template:
  13.     metadata:
  14.       labels:
  15.         app: hello
  16.         tier: backend
  17.         track: stable
  18.     spec:
  19.       containers:
  20.         - name: hello
  21.           image: “gcr.io/google-samples/hello-go-gke:1.0”
  22.           ports:
  23.             - name: http
  24.               containerPort: 80

创建后端 Deployment：

  1. kubectl apply -f https://k8s.io/examples/service/access/hello.yaml

查看后端的 Deployment 信息：

  1. kubectl describe deployment hello

输出类似于：

  1. Name:                           hello
  2. Namespace:                      default
  3. CreationTimestamp:              Mon, 24 Oct 2016 14:21:02 -0700
  4. Labels:                         app=hello
  5.                                 tier=backend
  6.                                 track=stable
  7. Selector:                       app=hello,tier=backend,track=stable
  8. Replicas:                       7 updated | 7 total | 7 available | 0 unavailable
  9. StrategyType:                   RollingUpdate
  10. MinReadySeconds:                0
  11. RollingUpdateStrategy:          1 max unavailable, 1 max surge
  12. OldReplicaSets:                 <none>
  13. NewReplicaSet:                  hello-3621623197 (7/7 replicas created)
  14. Events:
  15. ...

创建后端服务对象（Service object）

前端连接到后端的关键是 Service。Service 创建一个固定 IP 和 DNS 解析名入口， 使得后端微服务可达。Service 使用 selector 标签来寻找目标 Pod。

首先，浏览 Service 的配置文件：

service/access/hello-service.yaml 使用 Service 把前端连接到后端 - 图2
  1. apiVersion: v1
  2. kind: Service
  3. metadata:
  4.   name: hello
  5. spec:
  6.   selector:
  7.     app: hello
  8.     tier: backend
  9.   ports:
  10.   - protocol: TCP
  11.     port: 80
  12.     targetPort: http

配置文件中，你可以看到 Service 将流量路由到包含 app: hello 和 tier: backend 标签的 Pod。

创建 hello Service：

  1. kubectl apply -f https://k8s.io/examples/service/access/hello-service.yaml

此时，你已经有了一个在运行的后端 Deployment，你也有了一个 Service 用于路由网络流量。

创建前端应用

既然你已经有了后端应用，你可以创建一个前端应用连接到后端。前端应用通过 DNS 名连接到后端的工作 Pods。 DNS 名是 “hello”，也就是 Service 配置文件中 name 字段的值。

前端 Deployment 中的 Pods 运行一个 nginx 镜像，这个已经配置好镜像去寻找后端的 hello Service。 只是 nginx 的配置文件：

service/access/frontend.conf 使用 Service 把前端连接到后端 - 图3
  1. upstream hello {
  2.     server hello;
  3. }
  5. server {
  6.     listen 80;
  8.     location / {
  9.         proxy_pass http://hello;
  10.     }
  11. }

与后端类似，前端用包含一个 Deployment 和一个 Service。Service 的配置文件包含了 type: LoadBalancer， 也就是说，Service 会使用你的云服务商的默认负载均衡设备。

service/access/frontend.yaml 使用 Service 把前端连接到后端 - 图4
  1. apiVersion: v1
  2. kind: Service
  3. metadata:
  4.   name: frontend
  5. spec:
  6.   selector:
  7.     app: hello
  8.     tier: frontend
  9.   ports:
  10.   - protocol: “TCP”
  11.     port: 80
  12.     targetPort: 80
  13.   type: LoadBalancer
  14. —-
  15. apiVersion: apps/v1
  16. kind: Deployment
  17. metadata:
  18.   name: frontend
  19. spec:
  20.   selector:
  21.     matchLabels:
  22.       app: hello
  23.       tier: frontend
  24.       track: stable
  25.   replicas: 1
  26.   template:
  27.     metadata:
  28.       labels:
  29.         app: hello
  30.         tier: frontend
  31.         track: stable
  32.     spec:
  33.       containers:
  34.       - name: nginx
  35.         image: “gcr.io/google-samples/hello-frontend:1.0”
  36.         lifecycle:
  37.           preStop:
  38.             exec:
  39.               command: [“/usr/sbin/nginx”,”-s”,”quit”]

创建前端 Deployment 和 Service：

  1. kubectl apply -f https://k8s.io/examples/service/access/frontend.yaml

通过输出确认两个资源都已经被创建：

  1. deployment "frontend" created
  2. service "frontend" created

注意：这个 nginx 配置文件是被打包在 容器镜像 里的。 更好的方法是使用 ConfigMap，这样的话你可以更轻易地更改配置。

与前端 Service 交互

一旦你创建了 LoadBalancer 类型的 Service，你可以使用这条命令查看外部 IP：

  1. kubectl get service frontend

外部 IP 字段的生成可能需要一些时间。如果是这种情况，外部 IP 会显示为 <pending>。

  1. NAME       CLUSTER-IP      EXTERNAL-IP   PORT(S)  AGE
  2. frontend   10.51.252.116   <pending>     80/TCP   10s

使用相同的命令直到它显示外部 IP 地址：

  1. NAME       CLUSTER-IP      EXTERNAL-IP        PORT(S)  AGE
  2. frontend   10.51.252.116   XXX.XXX.XXX.XXX    80/TCP   1m

通过前端发送流量

前端和后端已经完成连接了。你可以使用 curl 命令通过你的前端 Service 的外部 IP 访问服务端点。

  1. curl http://<EXTERNAL-IP>

后端生成的消息输出如下：

  1. {"message":"Hello"}

接下来