将Python项目部署到Kubernetes | 周末送书

点击下方图片了解Kubernetes培训详情。

随着项目的发展，一些传统的处理方案如VM、SaaS等所发挥的作用越来越有限。为此，我们将采用新的方案：一个自动化容器操作的开源平台——Kubernetes，来解决当前所面临的问题。本文将介绍如下内容：

怎样利用Kubernete在集群上部署Python项目；
怎样对集群进行配置；
怎样设置Kubernetes清单以及一些自动化功能。

这是前一篇有关Python自动化项目[1]的后续文章，在阅读本文之前有必要先回顾一下。

这是我的代码仓库，包含了完整的源代码和文档：https://github.com/MartinHeinz/python-project-blueprint

开发设置

为了在开发过程中更高效，有必要对Kubernetes进行本地化设置，即仅在一台计算机上运行的小型集群，它与实际的生产集群非常接近，为此，我们将采用 KinD：

顾名思义，KinD（Kubernetes-in-Docker）是指在Docker容器中运行Kubernetes集群。它是用于Kubernetes v1.11+测试的工具，支持多节点集群和HA集群。由于是在Docker容器中运行Kubernetes，所以KinD可以在Windows、Mac和Linux上运行。就是说，可以在任何安装了Docker容器的操作系统上运行KinD。

接下来，让我们安装KinD（在Linux上——如果是在Windows上，请在此处[2]查看安装方法）：

~ $ curl -Lo ./kind https://github.com/kubernetes-sigs/kind/releases/download/v0.7.0/kind-$(uname)-amd64
~ $ chmod +x ./kind
~ $ sudo mv ./kind /usr/local/bin/kind
~ $ kind --version
kind version 0.7.0

然后，就可以对集群进行设置了。为此，我们需要以下YAML清单：

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"
        authorization-mode: "AlwaysAllow"
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
- role: worker
- role: worker

此清单描述了集群的基本结构。它有3个节点：1个control-plane，2个worker。我们还为它提供了更多的设置和参数，方便以后配置Ingress控制器以使用HTTPS协议。这些设置的目的是：在指定的节点上，对host向ingress控制器进行端口转发。

小贴士：集群和Python应用程序的所有设置清单都可以在我的代码仓库中的Kubernetes目录[3]中找到。

现在，创建集群：

$ ~ kind create cluster --config kind-config.yaml --name cluster
$ ~ kubectl cluster-info --context kind-cluster
Kubernetes master is running at https://127.0.0.1:32769
KubeDNS is running at https://127.0.0.1:32769/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

$ ~ kubectl get nodes
NAME                    STATUS    ROLES     AGE       VERSION
cluster-control-plane   Ready     master    2m39s     v1.17.0
cluster-worker          Ready         2m3s      v1.17.0
cluster-worker2         Ready         2m3s      v1.17.0

在这里，‘kind create cluster’命令用来创建集群；‘kubctl cluster-info’和‘kubectl get’命令用来检测集群的运行状态。接下来，我们要为集群设置Ingress。为此，我们使用‘kubectl’命令将集群与KinD拟合：

~ $ kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/master/deploy/static/mandatory.yaml
~ $ kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/master/deploy/static/provider/baremetal/service-nodeport.yaml
~ $ kubectl patch deployments -n ingress-nginx nginx-ingress-controller -p '{"spec":{"template":{"spec":{"containers":[{"name":"nginx-ingress-controller","ports":[{"containerPort":80,"hostPort":80},{"containerPort":443,"hostPort":443}]}],"nodeSelector":{"ingress-ready":"true"},"tolerations":[{"key":"node-role.kubernetes.io/master","operator":"Equal","effect":"NoSchedule"}]}}}}'

上面的第一个命令作用是部署ingress-nginx组件；第二个命令的作用是通过NodePort暴露Nginx服务；最后一个命令的作用是给Ingress控制器打补丁。通过以上操作，我们创建的集群已经启动了。

配置清单

准备好群集后，就可以设置和部署应用程序了。为此，我们将使用非常简单的Flask应用程序提供echo服务：

# __main__.py

from flask import Flask, request

app = Flask(__name__)


@app.route("/")
def echo():
    return f"You said: {request.args.get('text', '')}\n"


if __name__ == "__main__":
    app.run(host='0.0.0.0', port=5000)

我选择Flask应用程序而不是某些CLI工具（或Python包），是因为这些工具有时会使所部署的应用程序停止工作。注意，务必将字段‘host’值设置为0.0.0.0，否则，将无法把应用程序暴露为公开的Kubernetes服务。

接下来，我们需要配置一下该应用程序的YAML清单，这里将分别阐述：

Namespace

apiVersion: v1
kind: Namespace
metadata:
name: blueprint

这里没什么好说的。如果不采用默认值，就设置自己的名称空间。

ConfigMap

apiVersion: v1
kind: ConfigMap
metadata:
  name: env-config-blueprint
  namespace: blueprint
data:  # Example vars that will get picked up by Flask application
  FLASK_ENV: development
  FLASK_DEBUG: "1"

在这里，为应用程序定义诸多变量。其中字段‘data:’的值将作为应用程序在容器中的环境变量。上面的例子中，FLASK_ENV和FLASK_DEBUG等诸多变量将在应用程序启动时由Flask自动获取。

Secret

apiVersion: v1
kind: Secret
metadata:
  name: env-secrets-blueprint
  namespace: blueprint
data:
  VAR: VkFMVUU=  # base64 of "VALUE"

在这里，将设置应用程序的一些敏感数据。我们可以使用Secret向应用程序添加凭证和密钥之类的内容。但是，因为它包含敏感数据，所以我们使用以下命令动态的创建它：

~ $ kubectl create secret generic env-secrets-blueprint -n blueprint \
    --from-literal=VAR=VALUE \
    --from-literal=VAR2=VALUE2 \
    --dry-run -o yaml >> app.yaml

小贴士：部署应用程序所需的命令在此处[4]列出。

Deployment

piVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: blueprint
  name: blueprint
  namespace: blueprint
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: blueprint
    spec:
      containers:
#        - image: docker.pkg.github.com/martinheinz/python-project-blueprint/example:flask
#          ^^^^^  https://github.com/containerd/containerd/issues/3291 https://github.com/kubernetes-sigs/kind/issues/870
        - image: martinheinz/python-project-blueprint:flask
          name: blueprint
          imagePullPolicy: Always
          ports:
            - containerPort: 5000
              protocol: TCP
          envFrom:
            - configMapRef:
                name: env-config-blueprint
            - secretRef:
                name: env-secrets-blueprint
#      imagePullSecrets:  # In case you are using private registry (see kubectl command at the bottom on how to create regcred)
#        - name: regcred
  selector:
    matchLabels:
      app: blueprint

现在是最重要的内容——部署。相关配置是字段‘spec’部分，它指定了镜像、端口和环境变量。对于字段‘image’，我们指定来自Docker Hub的镜像。如果想使用像Artifactory这样的私有注册表，则须添加imagePullSecret来拉取私有镜像，它为提取镜像提供了集群凭证。这个‘secret’可以使用以下命令创建：

kubectl create secret docker-registry regcred \
    --docker-server=docker.pkg.github.com \
    --docker-username= --docker-password= \
    --dry-run -o yaml >> app.yaml

在这里，显示了怎样从GitHub中提取私有镜像。由于上述YAML中的问题，目前它不适用于KinD，但它可以与Cloud中的生产集群很好地工作（假设它是不使用KinD）。

如果要避免在每次重新部署应用程序时把镜像推送到远程注册表，则可以使用命令‘kind load docker-image martinheinz/python-project-blueprint:flask’将镜像加载到群集中。

设置好字段‘image’后，我们还需要指定为与应用程序进行信息交换而设定的监听端口，在本例中端口号为5000。接下来就是使用命令‘app.run(host='0.0.0.0', port=5000)’来启动应用程序。

最后，设置字段‘envFrom’,直接从上文的所述ConfigMap和Secret中取值，并将值赋予以‘ref’为后缀的相应字段。

Service

apiVersion: v1
kind: Service
metadata:
  name: blueprint
  namespace: blueprint
  labels:
    app: blueprint
spec:
  selector:
    app: blueprint
  ports:
    - name: http
      targetPort: 5000  # port the container accepts traffic on
      port: 443  # port other pods use to access the Service
      protocol: TCP

现在，我们已经在端口上侦听应用程序。接下来，我们需要暴露Service，将5000端口转发到集群节点上的的443端口。

Ingress

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: blueprint-ingress
  namespace: blueprint
  annotations:
    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
  labels:
    app: blueprint
spec:
  tls:
    - hosts:
      - localhost
      secretName: tls-secret
  rules:
    - host: localhost
      http:
        paths:
          - path: "/"
            backend:
              serviceName: blueprint
              servicePort: 443

最后一个问题——Ingress，怎样管理集群中对Services的外部访问。让我们首先看一下字段‘rules’，如上所示，字段‘host’取值为‘localhost’，字段‘path’取值为‘/’，字段‘backend’取值为上文所述的Servers中的值，这表明所有发送到‘localhost/’的请求均关联‘backend’。

字段‘tls’提供对HTTPS协议的支持。它是通过指定包含tls.crt和tls.key的Secret来实现的。让我们创建这个Secret：

KEY_FILE="blueprint.key"
CERT_FILE="blueprint.crt"
HOST="localhost"
CERT_NAME=tls-secret
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ${KEY_FILE} -out ${CERT_FILE} -subj "/CN=${HOST}/O=${HOST}"
kubectl create secret tls ${CERT_NAME}


    
 --key ${KEY_FILE} --cert ${CERT_FILE} --dry-run -o yaml >> app.yaml

上面的代码片段首先设置了几个变量，然后使用openssl为TLS生成证书和密钥文件。最后一个命令创建了包含这两个文件的Secret。

部署应用

准备好所有清单后，我们终于可以部署我们的应用程序：

$ ~ kubectl config set-context kind-cluster --namespace blueprint

$ ~ KEY_FILE="blueprint.key"
$ ~ CERT_FILE="blueprint.crt"
$ ~ HOST="localhost"
$ ~ CERT_NAME=tls-secret

$ ~ openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ${KEY_FILE} -out ${CERT_FILE} -subj "/CN=${HOST}/O=${HOST}"

$ ~ kubectl create secret generic env-secrets-blueprint --from-literal=VAR=VALUE --dry-run -o yaml >> app.yaml && echo "---" >> app.yaml
$ ~ kubectl create secret tls ${CERT_NAME} --key ${KEY_FILE} --cert ${CERT_FILE} --dry-run -o yaml >> app.yaml

$ ~ kubectl apply -f app.yaml
namespace/blueprint unchanged
deployment.apps/blueprint created
configmap/env-config-blueprint unchanged
service/blueprint created
ingress.extensions/blueprint-ingress unchanged
secret/env-secrets-blueprint configured
secret/tls-secret configured

$ ~ kubectl get all
NAME                             READY   STATUS    RESTARTS   AGE
pod/blueprint-5d86484b76-dkw7z   1/1     Running   0          13s

NAME                TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
service/blueprint   ClusterIP   10.96.253.31           443/TCP   13s

NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/blueprint   1/1     1            1           13s

NAME                                   DESIRED   CURRENT   READY   AGE
replicaset.apps/blueprint-5d86484b76   1         1         1       13s

$ ~ curl -k https://localhost/?text=Hello
You said: Hello

在这里，大多数命令在上文都已经介绍过。而命令‘kubectl apply -f app.yaml’的作用是：在集群中创建所有必需的对象。创建之后，可以使用命令‘kubectl get all’来查看这些对象是否创建成功。最后，使用命令‘curl’来检测应用程序能否被访问。到此，我们的应用程序就可以在集群上运行了！

优化配置

如果你对所有的‘kind’和‘kubectl’命令感到不舒服，或者你只是像我一样懒，不想把它们都打出来，那么我就编写几个脚本：

启动集群

cluster:
 @if [ $$(kind get clusters | wc -l) = 0 ]; then \
  kind create cluster --config ./k8s/cluster/kind-config.yaml --name kind; \
 fi
 @kubectl cluster-info --context kind-kind
 @kubectl get nodes
 @kubectl config set-context kind-kind --namespace $(MODULE)

在这里，如果群集尚未启动，此脚本将对群集进行配置；若集群已启动，此脚本将展示该群集的所有信息，方便你查看节点的状态和切换命名空间。

重新部署/重新启动应用程序

deploy-local:
 @kubectl rollout restart deployment $(MODULE)

这个非常简单，它所做的就是推出新的部署。因此，如果有新镜像，就进行部署，否则就重新启动应用程序。

调试

cluster-debug:
 @echo "\n${BLUE}


    
Current Pods${NC}\n"
 @kubectl describe pods
 @echo "\n${BLUE}Recent Logs${NC}\n"
 @kubectl logs --since=1h -lapp=$(MODULE)

如果需要调试应用程序，则可能需要查看与应用程序相关的最新事件以及最近（过去一小时）的日志。这正是此脚本的作用。

获取远程shell

cluster-rsh:
# if your container has bash available
 @kubectl exec -it $$(kubectl get pod -l app=${MODULE} -o jsonpath="{.items[0].metadata.name}") -- /bin/bash

如果日志不足以解决问题，并且需要在容器中摸索，那么您可以运行此脚本来获得远程shell。

更新清单

manifest-update:
@kubectl apply -f ./k8s/app.yaml

我们以前见过这个命令。它对YAML清单进行重载，可以方便对Kubernetes对象的属性进行调整。

结论

这篇文章并不是Kubernetes教程，但我认为它足以让你入门，并让你的应用程序快速启动和运行。要了解更多关于Kubernetes的内容，我建议你多了解一下配置清单，尝试着调整和改变一些东西，然后看看会发生什么。在我看来，这是了解事物如何工作并适应kubectl命令的好方法。如果你有任何问题、建议或话题，请随时联系我或在我的代码仓库中创建话题。在代码仓库中，你可以找到所有的文档和清单。