标签：k8s

k8s集群环境基于阿里云VPC网络，采用kubeadm工具快速部署k8s高可用集群。

服务器：

• ubuntu 16.04.4 LTS (Xenial Xerus)，4.4.0-117-generic

• kubelet –version: Kubernetes v1.11.1

• docker -v: Docker version 17.03.3-ce, build e19b718

问题现象是通过kubectl get nodes -w监控node节点的状态时，发现偶尔会出现NotReady状态。这时候集群访问正常，外部访问应用服务正常，只是自动化接口测试时，偶尔报出 http接口请求的错误：java.net.ConnectException: 拒绝连接 (Connection refused)。初步怀疑是Node如果是NotReady状态，则对应节点上的服务会受到影响，导致请求被拒绝。

通过kubectl describe node查看node的信息，发现Conditions status Unknown， Kubelet stopped posting node status信息。

通过google得知，node挂了后到底多久会notready 多久开始调度? 40s判死刑,缓期5min善后！

注意：这个由kube-controller-manager的两个参数决定的

• –pod-eviction-timeout：缺省为 5m，五分钟，在 Pod 驱逐行为的超时时间。
• –node-monitor-grace-period：缺省为 40s，也就是 40 秒，无响应 Node 在标记为 NotReady 之前的等候时间。
  初步怀疑原因是，node的notready状态，触发了Kubernetes的Pod重调度流程。

首先分析一下该重调度流程：

1. kubelet周期性的调用rest apiserver接口将Node状态更新至etcd，周期为node-status-update-frequency，默认值10s

2. controller manager每node-monitor-period通过apiserver查询etcd，检查kubelet上报上来的状态，默认值为5s

3. node的状态将会在node-monitor-grace-period周期内更新，controller manager中设置默认值为40s

4. kubelet在更新自身状态的时候有nodeStatusUpdateRetry次重试，nodeStatusUpdateRetry的默认值为5次

说明： controller manager会在node-monitor-grace-period 40s之内获取etcd中的node状态，而期间kubelet更新了40s/10s=4次node状态。

通过查看/etc/kubernetes/manifests/kube-controoller-manager.yaml，发现配置是

- --node-monitor-grace-period=10s
- --pod-eviction-timeout=10s

因为kubelet默认更新Node状态的时间是10s，而controller manager判断Node是否health的时间也是10s，但是考虑到kubelet，controller manager通过apiserver，操作etcd之间是异步访问，实际更新Node的时间应该可能超过10s，他们之间的delay将会受到network latency, apiserver latency ,etcd latency，以及master node上的负载的影响。根据Kubernetes的list-watch机制，每次watch之前需要按照本地最大version list所有etcd中更新的logs，所以在delay的情况下，controller manager可能获取不到Node的状态更新，从而认为其Unhealthy，且10s之后根据eviction 10s，如果Node仍然为Unhealthy，则触发Pod的重调度，从而导致服务震荡，出现以上的connection refuse的问题。

通过上面解释，我们知道导致服务偶尔中断的原因是controller manager设置Node状态的时间和kubelet更新时间设置的太短，解决办法也很简单，去除这两个配置，采用默认值即可，经测试，没有发现NotReady现象，且接口自动化测试也通过。

社区默认的配置

快速更新和快速反应

该模式下会产生频繁的node update事件，加重etcd的负担

这种场景下20s之后，会认为node down了，接着–pod-eviction-timeout=30s之后，pod将会被驱逐，也就是50s会发生evict。但是会增加etcd的负载，每个node将会每2s更新一次etcd的状态。

如果环境有1000个节点，1分钟内将有15000个节点更新，这可能需要大型的etcd容器甚至是etcd的专用节点。

中等更新和平均反应

将会20s更新一次node状态，也就是说controller manager认为node状态不正常之前，会有2m60/205=30次更新node的状态。Node状态为down之后1m，就会触发evict。
如果1000node的场景，1分钟内将会有60s/20s*1000=3000次 etcd node状态的更新。

低更新和慢反应

Kubelet将会1m更新一次node的状态，在认为不健康之后会有5m/1m*5=25次重试更新的机会。Node为不健康的时候，1m之后pod开始evict。

目前我们采用的是默认的配置。

这里需要先了解kubelet和apiserver之间的交互过程。

k8s集群采用kubeadm init –config kubeadm-init.yaml进行高可用部署。

apiserver的高可用和etcd的高可用，采用的是static pod方式运行，基于容器方式运行k8s相关组件。

附录！

Kubernetes作为容器化应用集群管理系统，关键系统服务有 api-server, scheduler, controller-manager 三个。api-server 一方面作为 Kubernetes 系统的访问入口点，一方面作为背后 etcd 存储的代理服务器，Kubernetes 里的所有资源对象，包括 Service、Deployment、ReplicaSet、DaemonSet，Pod、Endpoint、ConfigMap、Secret 等等，都是通过 api-server 检查格式后，以 protobuf 格式序列化并存入 etcd。

Kubernetes为容器化应用提供了便利的资源调度， 部署运行，服务发现， 扩容缩容，自动运维等功能。

1. 系统各个组件分工明确(APIServer是所有请求入口，CM是控制中枢，Scheduler主管调度，而Kubelet负责运行)，配合流畅，整个运行机制一气呵成。

2. 可以看出除了配置管理和持久化组件ETCD，其他组件并不保存数据。意味除ETCD外其他组件都是无状态的。因此从架构设计上对kubernetes系统高可用部署提供了支撑。

3. 同时因为组件无状态，组件的升级，重启，故障等并不影响集群最终状态，只要组件恢复后就可以从中断处继续运行。

4. 各个组件和kube-apiserver之间的数据推送都是通过list-watch机制来实现。所以理解list-watch机制是深入理解kubernetes的关键。

5. 整体运行机制基于声明式数据(如nginx-depolyment.yaml)而非用户输入各种命令来工作，这是kubernetes最核心的设计理念。

list-watch机制分析

kubernetes中结合watch请求增加了list请求，主要做如下两件事情:

1. watch请求开始之前，先发起一次list请求，获取集群中当前所有该类数据(同时得到最新的ResourceVersion)，之后基于最新的ResourceVersion发起watch请求。

2. 当watch出错时(比如说网络闪断造成客户端和服务端数据不同步)，重新发起一次list请求获取所有数据，再重新基于最新ResourceVersion来watch。

kubernetes中基于ResourceVersion信息采用list-watch(http streaming)机制来保证组件间的数据实时可靠传送。

如今利用 Keras 构建深度学习模型已然成为一种风尚。Kubernetes 无需人工干预即可全部自动化完成任务的特点，使之成为部署学习模型的绝佳选择。今天我们就从 Keras 构建深度学习模型角度出发，通过 Flask 提供 REST API 服务，看看如何利用 Kubernetes 两个命令轻松部署深度学习模型。接下来，我将在 Google Cloud 上进行全程部署。

主要内容包括以下四部分：

• 使用 Google Cloud 创建环境；
• 使用 Keras、Flask 和 Docker 作为 API 提供深度学习模型；
• 使用 Kubernetes 部署所述模型；
• 结语。

使用 Google Cloud 创建环境

首先在 Google Compute Engine 上使用一个小型虚拟机来构建、服务和定位深度学习模型。我曾试图在 Windows 10 笔记本电脑上安装最新版本的 Docker CE（Community Edition），但我失败了。

所以我决定利用 Google Cloud 来进行部署，这要比弄清如何安装 Docker 更高效。

启动 Google Cloud VM，打开屏幕左侧的功能区，选择 “Select Compute” 再选择 “Create Instance”，你将看到已经运行了一个实例。

下一步选择使用的计算资源大小。默认（read: cheapest）设置可以正常工作，但鉴于我们最多只需要这个 VM 约 1 小时，我选择了 4vCPU 和 15GB 内存。

接下来，选择使用的操作系统和磁盘空间。我们选择 “Boot Disk” 以编辑默认值，将 CentOS 7 作为操作系统，并将磁盘容量从 10GB 增加到 100GB（CentOS 操作系统不是必要的）。我建议将磁盘大小增加到 10GB 以上，因为我们创建的 Docker 容器每个大约 1GB。

创建 VM 前需要将防火墙规则设置为：Allow HTTP traffic、Allow HTTPS traffic 。在模型部署到 Kubernetes 之前，我将进行防火墙设置，保证在 VM 上能测试到我们的 API。因此，检查下图这些方框是不够的 —— 还有更多工作要做。

现在点击 “Create”， Google Cloud 创建环境成功！

使用 Keras 构建深度学习模型

通过 SSH 进入到我们的 VM 并开始构建模型。最简单的方法是只需单击 VM 旁边的 SSH 图标（如下所示），浏览器会打开一个终端。

删除现有版本 Docker

sudo yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-selinux docker-engine-selinux docker-engine

请注意，如果选择 CentOS 7 以外的操作系统，这些命令会有所不同。

安装最新版本 Docker

sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager — add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install docker-ce

启动 Docker 并运行测试脚本

sudo systemctl start docker
sudo docker run hello-world

如果你看到的输出如下所示，则完成设置。

Hello from Docker!
This message shows that your installation appears to be working correctly.To generate this message, Docker took the following steps: 1. The Docker client contacted the Docker daemon. 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.    (amd64) 3. The Docker daemon created a new container from that image which runs the    executable that produces the output you are currently reading. 4. The Docker daemon streamed that output to the Docker client, which sent it    to your terminal.

创建深度学习模型

对 Adrian Rosebrock 编写的脚本进行复制。我对 Adrian 脚本进行两次编辑才能让它运行起来。如果你不关心 Docker 和 Tensorflow 的细节，请跳过这两段。

与 Docker 有关问题：在本地运行应用程序的默认行为是在本地主机（127.0.0 …）上提供应用程序，但应用程序在 Docker 容器内运行时会出现问题。解决方法:当调用 app.run() 时，将 url 指定为 0.0.0.0，类似于 app.run( host=’0.0.0.0′ )。现在，我们的应用程序可在本地和外部 IP 上使用。

与 Tensorflow 有关问题：当我运行 Adrian 原始脚本时，我无法成功调用模型。利用下面的解决方案，对代码进行后续更改。

global graph
graph = tf.get_default_graph()
...
with graph.as_default():
    preds = model.predict(image)

创建一个名为 “keras-app” 的新目录并将模型移动到该目录中。

mkdir keras-app
cd keras-app

创建一个名为 “app.py” 的文件。你可以选择你喜欢的文本编辑器。我更喜欢使用 Vim，先创建并打开 app.py 类型：

vim app.py

从文件内部，点击 “i” 键进入插入模式。将此代码进行粘贴：

# USAGE
# Start the server:
#     python app.py
# Submit a request via cURL:
#     curl -X POST -F image=@dog.jpg 'http://localhost:5000/predict'# import the necessary packages
from keras.applications import ResNet50
from keras.preprocessing.image import img_to_array
from keras.applications import imagenet_utils
from PIL import Image
import numpy as np
import flask
import io
import tensorflow as tf

# initialize our Flask application and the Keras model
app = flask.Flask(__name__)
model = None

def load_model():
    # load the pre-trained Keras model (here we are using a model
    # pre-trained on ImageNet and provided by Keras, but you can
    # substitute in your own networks just as easily)
    global model
    model = ResNet50(weights="imagenet")
    global graph
    graph = tf.get_default_graph()

def prepare_image(image, target):
    # if the image mode is not RGB, convert it    if image.mode != "RGB":
        image = image.convert("RGB")

    # resize the input image and preprocess it
    image = image.resize(target)
    image = img_to_array(image)
    image = np.expand_dims(image, axis=0)
    image = imagenet_utils.preprocess_input(image)

    # return the processed image    return image

@app.route("/predict", methods=["POST"])
def predict():
    # initialize the data dictionary that will be returned from the
    # view
    data = {"success": False}

    # ensure an image was properly uploaded to our endpoint    if flask.request.method == "POST":        if flask.request.files.get("image"):
            # read the image in PIL format
            image = flask.request.files["image"].read()
            image = Image.open(io.BytesIO(image))

            # preprocess the image and prepare it for classification
            image = prepare_image(image, target=(224, 224))

            # classify the input image and then initialize the list
            # of predictions to return to the client            with graph.as_default():
                preds = model.predict(image)
                results = imagenet_utils.decode_predictions(preds)
                data["predictions"] = []

                # loop over the results and add them to the list of
                # returned predictions                for (imagenetID, label, prob) in results[0]:
                    r = {"label": label, "probability": float(prob)}
                    data["predictions"].append(r)

                # indicate that the request was a success
                data["success"] = True

    # return the data dictionary as a JSON response    return flask.jsonify(data)

# if this is the main thread of execution first load the model and
# then start the serverif __name__ == "__main__":
    print(("* Loading Keras model and Flask starting server..."
        "please wait until server has fully started"))
    load_model()
    app.run(host='0.0.0.0')
view rawapp.py hosted with ❤ by GitHub

复制上述代码后，按 “Esc” 键退出编辑模式，键入保存并关闭文件 :x。

创建 requirements.txt 文件

我们将在 Docker 容器中运行上述代码。现在先创建一个 requirements.txt 文件。该文件将包含代码所需的运行包，例如 Keras、Flask 等。这样保证无论我们将 Docker 容器放置在哪，底层服务器都能安装代码所需依赖项。

创建并打开一个名为 “requirements” 的文件。通过键入 vim requirements.txt，用 vim 创建 txt 。将以下内容复制到 requirements.txt 中，进行保存并关闭。

keras
tensorflow
flask
gevent
pillow
requests

创建 Dockerfile

对 Dockerfile 进行创建，如下是 Docker 为构建和运行项目而读取的文件:

FROM python:3.6
WORKDIR /app
COPY requirements.txt /app
RUN pip install -r ./requirements.txt
COPY app.py /app
CMD ["python", "app.py"]~

现在我们指示 Docker 下载 Python 3 的基本镜像。完成后，我们要求 Docker 使用 Python 包管理器 pip 安装 requirements.txt 中的详细的包，再通知 Docker 运行脚本 python app.py。

构建 Docker 容器

构建并测试应用程序，首先要构建 Docker 容器，请运行：

sudo docker build -t keras-app:latest .

这条代码指示 Docker 为当前工作中的代码构建容器 director keras-app。此命令将需要一两分钟才能完成。后台的 Docker 也会同时下载 Python 3.6 的镜像并安装requirements.txt 中列出的软件包。

运行 Docker 容器

运行 Docker 容器来测试应用：

sudo docker run -d -p 5000:5000 keras-app

关于 5000:5000 的简单说明 ——设置的 Docker 让外部端口 5000 可用，并将本地应用程序转发到该端口（也在本地端口 5000 上运行），通过检查运行容器的状态，运行命令 sudo docker ps -a 可看到类似如下内容：

[gustafcavanaugh@instance-3 ~]$ sudo docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                    PORTS                    NAMES
d82f65802166        keras-app           "python app.py"     About an hour ago   Up About an hour          0.0.0.0:5000->5000/tcp   nervous_northcutt

测试模型

让该模型接收一张狗的照片作为输入，命令返回狗的品种作为测试。

从终端运行：

curl -X POST -F image=@dog.jpg 'http://localhost:5000/predict'

确保 “dog.jpg” 在你当前的目录中（或提供该文件的相应路径）

显示结果如下：

{"predictions":[{"label":"beagle","probability":0.987775444984436},
{"label":"pot","probability":0.0020967808086425066},
{"label":"Cardigan","probability":0.001351703773252666},
{"label":"Walker_hound","probability":0.0012711131712421775},
{"label":"Brittany_spaniel","probability":0.0010085132671520114}],"
success":true}

我们的模型正确地将狗归类为比格犬。这说明你已成功运行了一个训练有素的深度学习模型与 Keras、Flask 一起服务，并用 Docker 对它进行包装。

使用 Kubernetes 部署模型

创建 Docker Hub 帐户

将构建的模型上传到 Docker Hub。（如果你没有 Docker Hub 帐户，请立即创建一个帐户）。我们不会将容器移动到 Kubernetes 集群中，而是指示 Kubernetes 从集中托管的服务器中（即 Docker Hub）安装我们的容器。

登录 Docker Hub 帐户

创建 Docker Hub 帐户后，从命令行登录 sudo docker login。你需要提供用户名和密码，就像登录网站一样。

如果你看到如下消息：

Login Succeeded

登录成功！

标记容器

在上传之前标记容器的命名。运行 sudo docker images 并找到 keras-app 容器的镜像 ID。

输出如下所示：

REPOSITORY          TAG                 IMAGE ID            
CREATED             SIZE keras-app           latest              
ddb507b8a017        About an hour ago   1.61GB

标记 keras-app，请务必遵循我的格式，将 image id 和 docker hub id 的值替换为你的特定值。

#Format
sudo docker tag <your image id> <your docker hub id>/<app name>
#My Exact Command - Make Sure To Use Your Inputs
sudo docker tag ddb507b8a017 gcav66/keras-app

容器传送到 Docker Hub

从 shell 运行容器：

#Format
sudo docker push <your docker hub name>/<app-name>
#My exact command
sudo docker push gcav66/keras-app

当你导航回 Docker Hub 网站，将会看到 keras-app 存储库。

创建 Kubernetes 集群

在 Google Cloud 主屏幕上，选择 “Kubernetes Engine”。

再创建一个新的 Kubernetes 集群。

接下来，我们将自定义集群中的 Node 大小。我将选择 4vCPU 和 15 GB 的 RAM。你可以使用较小的集群尝试此操作。请记住，默认设置会启动 3 个 Node，因此你的集群将拥有你提供资源的 3 倍，即在我的情况下，45 GB 的 RAM。

单击进行创建，你需要一到两分钟才能启动集群。单击 “Click Run in Cloud Shell” 以显示 Kubernetes 集群的控制台。请注意，在你创建和测试的 Docker 容器中，这是一个独立于 VM 的 shell 环境。我们可以在 VM 上安装 Kubernetes，但 Google 的 Kubernetes 服务可以为我们提供自动化安装。

在 Kubernetes 上运行我们的 Docker 容器。请注意，镜像标记仅指向 Docker Hub 上的托管 Docker 镜像。另外，指定 port 在端口 5000 运行应用程序。

kubectl run keras-app --image=gcav66/keras-app --port 5000

在 Kubernetes 中，容器都在 Pod 内部运行。我们可以通过输入 kubectl get pods 验证 Pod 是否运行。结果如下则输入正确：

gustafcavanaugh@cloudshell:~ (basic-web-app-test)$ kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
keras-app-79568b5f57-5qxqk   1/1       Running   0          1m

现在 Pod 正在运行，我们需要将端口 80 上的 Pod 暴露给外网。这意味着访问我们部署的 IP 地址的同时也可以访问我们的 API。也就是说我们不必在网址之后再指定一个端口号（告别 :5000）。

kubectl expose deployment keras-app --type=LoadBalancer --port 
80 --target-port 5000

通过运行 kubectl get service 来确定部署状态（以及确定需要调用 API 的 URL） 。若命令输入如下则运行正确：

gustafcavanaugh@cloudshell:~ (basic-web-app-test)$ kubectl get service
NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
keras-app    LoadBalancer   10.11.250.71   35.225.226.94   80:30271/TCP   4m
kubernetes   ClusterIP      10.11.240.1    <none>          443/TCP        18m

抓住 Keras 应用程序的 cluster-ip，打开本地终端（或任何有狗照片的地方）并运行以下命令来调用 API curl -X POST -F image=@dog.jpg 'http://<your service IP>/predict' 。

结果如下所示，API 正确返回图片的 beagle 标签：

$ curl -X POST -F image=@dog.jpg 'http://35.225.226.94/predict'
{"predictions":
[{"label":"beagle","probability":0.987775444984436},
{"label":"pot","probability":0.0020967808086425066},
{"label":"Cardigan","probability":0.001351703773252666},
{"label":"Walker_hound","probability":0.0012711131712421775},
{"label":"Brittany_spaniel","probability":0.0010085132671520114}],
"success":true}

结语

在本教程中，我们使用 Keras 和 Flask 作为 REST API 提供深度学习模型，而后我们将该应用程序放在 Docker 容器中，将容器上传到 Docker Hub，并使用 Kubernetes 进行部署。

只需两个命令，Kubernetes 就可以部署我们的应用程序并将其暴露给外网。是不是感觉很自豪？当然这个方案还有很多可以改进的空间。比如，我们可以将 Flask 中的 Python Web 服务器从本地 Python 服务器改为类似 gunicorn 产品级别的服务器；我们还可以探索 Kubernetes 的扩展性和管理功能等等。

备份 k8s yaml 配置

for n in $(kubectl get -o=name pvc,configmap,serviceaccount,secret,ingress,service,deployment,statefulset,hpa,job,cronjob)
do
    mkdir -p $(dirname $n)
    kubectl get -o=yaml --export $n > $n.yaml
done

Kubernetes 的稳健性、可靠性使它成为现阶段最流行的云原生技术之一，但也有不少用户反映， Kubernetes 技术学习起来十分复杂，只适用于大集群且成本较高。这篇文章将打破你的观念，教你在小型项目中部署 Kubernetes 集群。

选择 K8S 部署小型集群的三大理由

理由一：花费时间少

在部署小型集群之前，你需要思考以下这些问题：

• 应该如何部署应用程序？（仅仅 rsync 到服务器？）

• 依赖关系是怎么样的？（如果利用 python 或 ruby，你必须在服务器上安装它们！）

• 手动运行命令？（如果以 nohup 的方式在后台运行二进制文件这可能不是最好的选择，但去配置路由服务，是否还需要学习 systemd？）

• 如何通过不同域名或 HTTP 路径运行多个应用程序？（你可能需要设置 haproxy 或 Nginx！）

• 当更新应用程序后应该如何推出新变化？（停止服务、部署代码、重启服务？如何避免停机？）

• 如果搞砸了部署怎么办？有什么方法可以回滚？

• 应用程序是否需要使用其他服务？又该如何配置这些服务？（如：redis）

以上这些问题很有可能在你部署小型集群时出现，但 Kubernetes 为上述所有问题都提供了解决方案。或许还有其他方法可以解决上述问题，但是利用 Kubernetes 往往事半功倍，因为我们需要更多的时间专注于应用程序。

理由二：Kubernetes 记录整个部署过程

让我们看看利用 Kubernetes 部署集群的第二个理由。

你在工作时是否也是这样的状态：我上次运行了什么命令？当时服务器在运行什么服务？这让我想到了著名的 bash.org：

<erno> hm. I've lost a machine.. literally _lost_. it responds to ping, it works completely, I just can't figure out where in my apartment it is.

                                                                                                                            http://bash.org/?5273

这种情况曾经出现在我的工作中，让原本 10 分钟的工作量变成了一个周末。

但是如果你选择 Kubernetes 部署集群，就不会有这种困扰。因为 Kubernetes 使用描述性格式，如此用户就可以很轻松地知道接下来应该运行哪些内容，如何部署构建块。此外，控制层也会正常处理节点故障并自动重新调度 Pod。（对于像 Web 应用程序这样的无状态服务，就不再需要担心失败。）

理由三：Kubernetes 简单易学

Kubernetes 拥有自己的词汇表、工具，以及与传统 Unix 完全不同的配置服务器。Kubernetes 的知识足以建立和维护基础设施。使用 Kubernetes，你可以完全可以在 Kubernetes 中配置服务，无需 SSH 到服务器。你不必学习 systemd 也不必知道什么是运行级别; 你不必格式化磁盘，或学习如何使用 ps，vim。

我通过一个例子，来证明我的观点！

这是利用 Unix :

[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network.target remote-fs.target nss-lookup.target[Service]
Type=forking
PIDFile=/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/usr/sbin/nginx -s reload
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true
[Install]
WantedBy=multi-user.target

真的比利用 Kubernetes 难：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 1
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80

当你远程执行基础架构管理时，是不需要手动维护服务器的。你可以使用：ansible、salt、chef、puppet 等来完成这件事。当然，你需要学习使用很多 Kubernetes 相关工具，这要比学习替代品轻松的多。

小 结

Kubernetes 并不是将一件事做到极致的工具而是一个全方位的解决方案，它取代了开发人员习惯使用的许多技术和工具。

接下来我们用实际操作，为大家部署一个小型 Kubernetes 集群。

建立小型 Kubernetes 集群

下面就开始我们的教程。对于这个例子，我们将使用谷歌的 Kubernetes引擎（GKE），但如果谷歌不是你的菜，你也可以选择亚马逊（EKS）或微软（AKS）。

要构建我们的 Kubernetes 集群，我们将需要：

• 域名（10 美元 /年，具体取决于域名）；

• DNS 主机由 cloudflare 提供（免费）；

• GKE 中的 3 个 node kubernetes 集群（5 美元 / 月）；

• 将 Webapp 作为 Docker 容器发送到 Google Container Registry（GCR）（免费）；

• 一些 yaml 文件配置 Kubernetes。

此外，为了节省成本，我们不会使用谷歌的 ingress controller 。相反，我们将在每个节点上运行 Nginx 作为 Daemon，并构建一个自定义运算符，将工作节点外部 IP 地址与 Cloudflare 同步。

谷歌设置

首先访问 console.cloud.google.com 并创建一个项目（如果你还没有项目）。你还需要设置结算帐户。然后前往 hamburger 菜单中的 Kubernetes 页面并创建一个新的集群。

你需要执行以下操作：

• 选择 Zonal 区域类型（我使用了 us-central1-a 作为我的区域）；

• 选择你的 Kubernetes 版本；

• 使用最便宜的实例类型（f1-micro）创建 3 个 node 池；

• 对于该节点池，在高级屏幕中，将引导磁盘大小设置为 10GB，启用可抢占的 node（它们更便宜），启用自动升级和自动修复；

• 在节点池下面还有一些其他选项。我们想要禁用 HTTP 负载均衡（GCP 中的负载均衡很昂贵且不稳定）并且还禁用所有 StackDriver 的服务以及禁用 Kubernetes dashboard 。

通过设置所有这些选项，你可以继续创建集群。

以下是减少的成本：

• Kubernetes 控制层：免费，因为谷歌不收取专家的费用；

• Kubernetes 工作节点：5.04 美元/月，3 个微节点通常为 11.65 美元/月，通过使用它们的可抢占性，我们将其降至 7.67 美元/月（“永久免费”等级则达到 5.04 美元）；

• 存储成本：免费，存储成本可以在 GCP 中累计。我们将免费获得 30GB 的永久磁盘，这就是我们选择 10GB 大小的原因；

• 负载均衡器成本：免费，我们禁用 HTTP 负载均衡，因为仅此一项费用将达到 18 美元/月。相反，我们将在每个节点上运行我们自己的 HTTP 代理，并将 DNS 指向公共 IP；

• 网络费用：免费，只要你每月低于 1GB，出口就是免费的（之后每GB 8 美分）。

因此，我们可以拥有一个 3 个节点的 Kubernetes 集群，价格与单个数字机器相同。

除了设置 GKE 之外，我们还需要添加一些防火墙规则，以允许外网点击我们节点上的 HTTP 端口。操作是：从 hamburger 菜单转到 VPC 网络，防火墙规则添加为 TCP 端口 80 和 443 的规则，IP 范围为 0.0.0.0/0。

本地设置

随着集群的启动和运行，我们就可以对其进行配置。通过 cloud.google.com/sdk/docs 的说明安装 gcloud 工具。

安装完成后，你可以通过运行以下命令进行设置：

gcloud auth login

你还需安装 Docker，将其连接到 GCR 上，方便你进行容器推送：

gcloud auth configure-docker

你也可以按照此处的说明安装和设置 kubectl （此工具适用于 Windows，OSX 或 Linux）。

gcloud components install kubectl
gcloud config set project PROJECT_ID
gcloud config set compute/zone COMPUTE_ZONE
gcloud container clusters get-credentials CLUSTER_NAME

构建 Web 应用程序

你可以使用任何编程语言构建 Web 应用。我们只需构建一个 port 端口的 HTTP 应用程序。就个人而言，我更喜欢在 Go 中构建这些应用程序，但对于某些类型，让我们尝试使用 Crystal。

创建一个 main.cr 文件：

# crystal-www-example/main.crrequire "http/server"Signal::INT.trap do
  exit
end

server = HTTP::Server.new do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hello world from crystal-www-example! The time is #{Time.now}"end

server.bind_tcp("0.0.0.0", 8080)
puts "Listening on http://0.0.0.0:8080"server.listen

我们还需要一个 Dockerfile：

# crystal-www-example/Dockerfile
FROM crystallang/crystal:0.26.1 as builder

COPY main.cr main.cr

RUN crystal build -o /bin/crystal-www-example main.cr --release

ENTRYPOINT [ "/bin/crystal-www-example" ]

我们可以通过以下命令来构建和测试我们的 Web 应用程序：

docker build -t gcr.io/PROJECT_ID/crystal-www-example:latest .
docker run -p 8080:8080 gcr.io/PROJECT_ID/crystal-www-example:latest

然后输入 localhost:8080 在浏览器中访问。接着我们可以通过以下方式将我们的应用程序推到 GCR 中运行：

docker push gcr.io/PROJECT_ID/crystal-www-example:latest

配置 Kubernetes

对于此示例，我们将创建几个 yaml 文件来表示各种服务，然后通过运行 kubectl apply 在集群中配置它们。Kubernetes 的配置具有描述性，这些 yaml 文件将会告诉 Kubernetes 我们希望看到的状态。

我们需要做的事情：

• 为我们的 crystal-www-example Web 应用程序创建部署和服务；

• 为 Nginx 创建一个 Daemon Set 和 Config Map；

• 运行自定义应用程序使用 Cloudflare 到 DNS 同步 node IP。

Web App 配置

首先让我们配置 webapp：(先将 PROJECT_ID 替换为你的项目 ID）

# kubernetes-config/crystal-www-example.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: crystal-www-example
  labels:
    app: crystal-www-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: crystal-www-example
  template:
    metadata:
      labels:
        app: crystal-www-example
    spec:
      containers:
      - name: crystal-www-example
        image: gcr.io/PROJECT_ID/crystal-www-example:latest
        ports:
        - containerPort: 8080---

kind: Service
apiVersion: v1
metadata:
  name: crystal-www-example
spec:
  selector:
    app: crystal-www-example
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080

现在创建一个 Deployment，它会通知 Kubernetes 创建一个 Pod，其中包含一个运行 Docker 容器的容器，以及一个用于集群内的 service discovery 。要应用此配置运行（在 kubernetes-config 文件夹中）：

kubectl apply -f .

我们可以使用以下方法测试它是否在运行：

kubectl get pod
# you should see something like:
# crystal-www-example-698bbb44c5-l9hj9          1/1       Running   0          5m

我们还可以创建代理 API，以便我们访问它：

kubectl proxy

然后访问：

http://localhost:8001/api/v1/namespaces/default/services/crystal-www-example/proxy/

Nginx 配置

通常，在 Kubernetes 中处理 HTTP 服务时，你会使用 ingress controller。不幸的是，Google 的 HTTP 负载均衡器非常昂贵，因此我们将运行自己的 HTTP 代理并手动配置它。

我们将使用 Daemon Set 和 Config Map。Daemon Set 是在每个节点上运行的应用程序。Config Map 基本上是一个小文件，我们可以在容器中安装它，我们将存储 Nginx 配置。

yaml 看起来像这样：

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      hostNetwork: true
      dnsPolicy: ClusterFirstWithHostNet
      containers:
      - image: nginx:1.15.3-alpine
        name: nginx
        ports:
        - name: http
          containerPort: 80
          hostPort: 80
        volumeMounts:
        - name: "config"
          mountPath: "/etc/nginx"
      volumes:
      - name: config
        configMap:
          name: nginx-conf

---

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-conf
data:
  nginx.conf: |
    worker_processes 1;
    error_log /dev/stdout info;

    events {
      worker_connections 10;
    }

    http {
      access_log /dev/stdout;

      server {
        listen 80;
        location / {
          proxy_pass http://crystal-www-example.default.svc.cluster.local:8080;
        }
      }
    }

你可以看到我们如何在 Nginx 容器内挂载 config map 的 nginx.conf。我们还在规范上设置了两个附加字段：hostNetwork: true、dnsPolicy: ClusterFirstWithHostNet 。

• hostNetwork: true 以便我们可以绑定主机端口并从外网到达 Nginx；

• dnsPolicy: ClusterFirstWithHostNet 以便我们可以访问集群内的服务。

应用更改：通过点击节点的公共 IP 来到达 Nginx。

你可以通过运行找到：

kubectl get node -o yaml
# look for:
# - address: ...
#   type: ExternalIP

我们的网络应用程序现在可通过互联网访问了。现在想想给它起一个好听的名字！

连接 DNS

我们需要 A 为集群的节点设置 3 条 DNS 记录：

然后添加一个 CNAME 条目以指向那些 A 记录。（即 www.example.com CNAME kubernetes.example.com）我们可以手动执行此操作，但最好自动执行此操作，以便在扩展或替换节点时 DNS 记录自动更新。

我认为这也是一个很好的说明示例，说明如何让 Kubernetes 为你工作而不是反对它。Kubernetes 完全可编写脚本，并且具有强大的 API。因此你可以使用不太难编写的自定义组件填补空白。我为此构建了一个小型 Go 应用程序，可在此处找到：kubernetes-cloudflare-sync。

建立一个 informer：

factory := informers.NewSharedInformerFactory(client, time.Minute)
lister := factory.Core().V1().Nodes().Lister()
informer := factory.Core().V1().Nodes().Informer()
informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
  AddFunc: func(obj interface{}) {
    resync()
  },
  UpdateFunc: func(oldObj, newObj interface{}) {
    resync()
  },
  DeleteFunc: func(obj interface{}) {
    resync()
  },
})
informer.Run(stop)

informer 将在节点更改时随时调用我的 resync 函数。然后使用 Cloudflare API 库（github.com/cloudflare/cloudflare-go）同步 IP ，类似于：

var ips []stringfor _, node := range nodes {  for _, addr := range node.Status.Addresses {    if addr.Type == core_v1.NodeExternalIP {
      ips = append(ips, addr.Address)
    }
  }
}
sort.Strings(ips)for _, ip := range ips {
  api.CreateDNSRecord(zoneID, cloudflare.DNSRecord{
    Type:    "A",
    Name:    options.DNSName,
    Content: ip,
    TTL:     120,
    Proxied: false,
  })
}

就像我们的网络应用程序一样，我们将此应用程序作为 Kubernetes 中的部署：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubernetes-cloudflare-sync
  labels:
    app: kubernetes-cloudflare-sync
spec:
  replicas: 1
  selector:
    matchLabels:
      app: kubernetes-cloudflare-sync
  template:
    metadata:
      labels:
        app: kubernetes-cloudflare-sync
    spec:
      serviceAccountName: kubernetes-cloudflare-sync
      containers:
      - name: kubernetes-cloudflare-sync
        image: gcr.io/PROJECT_ID/kubernetes-cloudflare-sync
        args:
        - --dns-name=kubernetes.example.com
        env:
        - name: CF_API_KEY
          valueFrom:
            secretKeyRef:
              name: cloudflare
              key: api-key
        - name: CF_API_EMAIL
          valueFrom:
            secretKeyRef:
              name: cloudflare
              key: email

你需要使用 cloudflare api 密钥和电子邮件地址创建 Kubernetes 密码：

kubectl create secret generic cloudflare --from-literal=email='EMAIL' --from-literal=api-key='API_KEY'

你还需要创建服务帐户（它允许我们的部署访问 Kubernetes API 来检索节点）。首次运行（特别是对于 GKE）：

kubectl create clusterrolebinding cluster-admin-binding --clusterrole cluster-admin --user YOUR_EMAIL_ADDRESS_HERE

然后申请：

apiVersion: v1
kind: ServiceAccount
metadata:
  name: kubernetes-cloudflare-sync
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: kubernetes-cloudflare-sync
rules:
- apiGroups: [""]
  resources: ["nodes"]
  verbs: ["list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: kubernetes-cloudflare-sync-viewer
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: kubernetes-cloudflare-sync
subjects:
- kind: ServiceAccount
  name: kubernetes-cloudflare-sync
  namespace: default

配置就绪后，运行 Cloudflare 的应用程序将在任何节点更改时被更新。以上就是基于 Kubernetes 部署小型集群的详细教程。

总 结

Kubernetes 就是这样一个收放自如的技术。就像你可能永远用不到 SQL 数据库中的所有功能，但你不得不承认 SQL 数据库极大地提高了你快速交付解决方案的能力。

Kubernetes 与 SQL 十分相似。在 Kubernetes 庞大的技术体系下，我们也并不能用到所有功能，却能在每个项目中恰到好处的使用部分功能实现完美部署。在每次利用 Kubernetes 部署小型集群时，我都会从中获得新的认知。

所以我的观点是，Kubernetes 对于小型部署也很有意义，而且既易于使用又便宜。如果你从来没有尝试过，现在就开动起来吧！

END