背景

client-go是go语言访问Kubernetes API的一种新的框架。本文记录client-go访问Kubernetes的过程。最终实现了给服务器端发送container ID，服务器端会返回该container所在pod的pod Name与Spacename。我们Kubernetes集群中一个pod都只运行了一个container。
程序用httprouter包来作为http的访问接口。返回的值编码为Json文件，客户拿到Json之后再进行解析，最终拿到需要的信息。如图：

程序实现基本功能之后，用Dockerfile将程序打包成docker镜像。

源代码

package main

import (
    "flag"
    "fmt"
    "github.com/julienschmidt/httprouter"
    "net/http"
    "io"
    "io/ioutil"
    apiv1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "encoding/json"
)

type Container_msg struct {
    Name string
    Namespace string
}

func main() {
    router := httprouter.New()

    kubeconfig := flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
    flag.Parse()

    if *kubeconfig == "" {
        panic("-kubeconfig not specified")
    }

    config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
    if err != nil {
        panic(err)
    }

    clientset, err := kubernetes.NewForConfig(config)

    if err != nil {
        panic(err)
    }

    router.POST("/api/v1/containerID",func(w http.ResponseWriter, r *http.Request, _ httprouter.Params){

        podsClient := clientset.Pods(apiv1.NamespaceAll)

        // List Pods
        list, err := podsClient.List(metav1.ListOptions{
        })
        if err != nil {
            panic(err)
        }

        body,_ := ioutil.ReadAll(io.LimitReader(r.Body,1122334))


        for _, d := range list.Items {
            containerID := d.Status.ContainerStatuses[0].ContainerID[9:]
            if string(body)==containerID{
                container_msg := Container_msg{
                    d.Name,
                    d.Namespace,
                }

                c,err := json.Marshal(container_msg)

                if err != nil{
                    panic(err)
                }

                fmt.Fprintf(w,"%v", c)
            }
        }
    })
        http.ListenAndServe(":8082", router)
}

具体实现

上面我已经先把程序的源代码贴出来了，接下来就进行逐步分析

1.获取第三方包client-go与httprouter

https://github.com/kubernetes/client-go
https://github.com/julienschmidt/httprouter
进入它们的github中看使用说明按步骤安装即可。
简单来说，就是分别使用go get k8s.io/client-go/…与go get github.com/julienschmidt/httprouter命令即可。
不过要记得在安装之前配置GOPATH环境变量。比如我的项目是放在naruto目录中的，所以我的GOPATH设置为naruto目录。
配置完GOPATH环境变量，安装完第三方包，我们就可以直接使用它们了。

2.使用httprouter包中的方法获取客户发来的container ID

router := httprouter.New()

建立http连接

http.ListenAndServe(":8082", router)
在8082端口进行监听

router.POST
获取客户端POST的数据

3.用client-go获取Kubernetes集群中pod信息

clientset, err := kubernetes.NewForConfig(config)
使用config建立client-go与Kubernetes集群的关系
config文件是Kubernetes集群的配置文件，存放在集群Master节点的～/.kube/config中
建立好连接之后， 我们就可以使用clientset的对应方法来获取pod或deployment等对象资源的信息。

4.比较获取到的container ID与集群中各pod的container ID

因为我们集群中一个pod仅运行着一个container，所以，我们只需要将pod中container的ID得到之后与获取到的客户发来了container ID做比较即可。假如相等，就可以把此pod的信息返回给客户端。

body,_ := ioutil.ReadAll(io.LimitReader(r.Body,1122334))

for _, d := range list.Items {
    containerID := d.Status.ContainerStatuses[0].ContainerID[9:]
    if string(body)==containerID{
     container_msg := Container_msg{
               d.Name,
               d.Namespace,
           }

     c,err := json.Marshal(container_msg)

      if err != nil{
             panic(err)
           }

     fmt.Fprintf(w,"%v", c)

打包成docker镜像

通过编写Dockerfile文件来建立一个新的镜像。

FROM img.reg.3g:15000/go:1.8     //以这个镜像为基础镜像
COPY naruto /pf      //将naruto目录下的文件复制到容器中文件系统／目录下的pf目录中
ENV GOPATH /pf            //配置环境变量
RUN go build /pf/main_v1.go   //编译写好的程序
CMD /main_v1 -kubeconfig=/pf/config   //以运行该程序的进程为容器的主进程

我们需要将main.go、config、第三方包、Dockerfile都放在同一目录下。通过docker build命令建立镜像。

背景

相信大家应该都在自己的电脑中部署过tomcat与mysql集群，我们可以通过访问tomcat来访问后台数据库。kubernetes是一个可自动部署、扩缩、管理容器化应用的工具。本篇博客主要讲解如何在kubernetes中部署tomcat与mysql集群。当然，这涉及到kubernetes的自动化部署功能。至于扩缩、管理功能，我这里就不详述了，以后有机会再讲解。

基础

在kubernetes中部署tomcat与mysql集群之前必须要有以下这些基础：

1. 已安装、配置kubernetes
2. 集群中有tomcat与mysql容器镜像
3. 有docker基础

具体步骤

部署tomcat

创建tomcat RC对象

我们想要在kubernetes集群中配置tomcat服务器，首先要保证集群中的节点上有tomcat镜像，镜像可以从docker Hub中拉取，也可以放在自己的私有仓库中。这在我之前的博客中讲过，这里就不详述了。

要部署tomcat服务，我们需要做两件事，一是创建RC（Replication Controller），二是创建Service。RC是kubernetes中的副本控制器，也就是说，RC负责自动部署容器化应用。Service是我们访问tomcat服务的入口地址，我们是通过Service来对该服务就行访问的。

创建RC与Service对象，我这里用的是创建yaml文件的方式。yaml文件中的内容是声明式的。这些声明让kubernetes做你想要它做的事情。声明与命令有所不同，声明是告诉它你的需要是什么，而不涉及具体的实现的步骤，而命令，如linux中的ls，你是告诉它去做什么。声明与命令是不同的，请自己体会。话不多说了，上代码：

  1 apiVersion: v1
  2 kind: ReplicationController
  3 metadata:
  4   name: myweb
  5 spec:
  6   replicas: 5
  7   selector:
  8     app: myweb
  9   template:
 10     metadata:
 11       labels:
 12         app: myweb
 13     spec:
 14       containers:
 15       - image: kubeguide/tomcat-app:v1
 16         name: myweb
 17         resources:
 18           limits:
 19             cpu: "2"
 20             memory: 4Gi
 21         ports:
 22         - containerPort: 8080
 23         env:
 24         - name: MYSQL_SERVICE_HOST
 25           value: 'mysql'
 26         - name: MYSQL_SERVICE_PORT
 27           value: '3306'

如上所示就是我写的yaml文件，此文件名为myweb-rc1.yaml
这里我简单的说明一下此yaml文件声明了什么：

  1 apiVersion: v1      //描述RC对象的版本是v1
  2 kind: ReplicationController    //我现在在声明RC对象
  3 metadata:     //metadata中的是对此RC对象描述信息
  4   name: myweb      //此RC对象在default命名空间中名为myweb，同一个命名空间中的命名一定是不同的
  5 spec:     //spec中是对RC对象的具体描述
  6   replicas: 5    //我要创建5个副本，单位当然是pod
  7   selector:      //选择器，用来选择对象的
  8     app: myweb    //我选择了标签为app: myweb的pod
  9   template:     //模版，以下用来描述创建的pod的模版
 10     metadata:   //对pod模版描述的元数据
 11       labels:      //给以下的东西打上标签，以让selector来选择
 12         app: myweb   //给pod模版打上app: myweb这样的标签
 13     spec:             //对pod模版的具体描述
 14       containers:         //以下就是要放入pod模版中的容器了
 15       - image: kubeguide/tomcat-app:v1    //选择镜像
 16         name: myweb         //容器名
 17         resources:           //给该容器分配的资源大小
 18           limits:
 19             cpu: "2"
 20             memory: 4Gi
 21         ports:         //容器端口号
 22         - containerPort: 8080         
 23         env:          //给该容器设置环境变量，这里就可以将mysql与我们的tomcat连接
 24         - name: MYSQL_SERVICE_HOST
 25           value: 'mysql'
 26         - name: MYSQL_SERVICE_PORT
 27           value: '3306'

大家可能看完比较蒙，仔细研究就发现其实yaml文件的规范还是比较严谨的。它是通过缩进与对齐的方式来表达了具体的信息的。比如一个metadata，在我这个yaml文件中就有两个。实际上通过缩进与对齐，我们就可以了解到，第一个metadata是对这个RC对象进行描述的元数据，而第二个metadata因为缩进了，实际上它是对pod模版进行描述的元数据。当然是不一样的。spec也有两个，同样的道理，大家可以自行分析。

创建tomcat RC对象的结果

如下，我截了个屏：

可以看到，我在创建完了tomcat的RC对象之后，它就立马自动部署了5个pod，这5个pod已经健康的跑起来了。为什么是创建5个pod？因为我在yaml文件中声明了我需要5个副本。是不是很方便？

创建tomcat Service对象

单单创建了RC对象还不行，虽然RC对象为我们自动部署了5个pod，但是我们还需要一个Service对象来作为入口地址来对创建好的tomcat进行访问，所以，接下来我们的任务就是创建Service对象。
此文件名为myweb-svc1.yaml。还是直接上代码：

  1 apiVersion: v1
  2 kind: Service
  3 metadata:
  4   name: myweb
  5 spec:
  6   ports:
  7   - name: myweb-svc
  8     port: 8080
  9     targetPort: 8080
 10     nodePort: 31111
 11   selector:
 12     app: myweb
 13   type: NodePort

关于yaml文件声明的含义我已经解释过了。这里不再重复解释。只挑不同的地方强调一下：

  1 apiVersion: v1
  2 kind: Service   //对象是Service了哦
  3 metadata:
  4   name: myweb
  5 spec:  
  6   ports:
  7   - name: myweb-svc         //端口名称，Service是必须指定端口名称的
  8     port: 8080          //Service的端口号
  9     targetPort: 8080        //容器暴露的端口号
 10     nodePort: 31111       //node的真实端口号
 11   selector:
 12     app: myweb     //Service选择了标签为app: myweb的pod
 13   type: NodePort

重点在于三个端口的区别，容器有端口，Service有端口，node也有真实的端口号，这里我们将这三者关联起来，在一会访问的时候会看出门道。所以，我们就拿结果说话吧。

创建tomcat Service对象的结果

大家可以看到，我已经创建好了名为myweb的Service。而且这个Service也已经通过selector选择了刚才创建好的5个pod。所以我可以通过Service来访问tomcat的服务了。我这里使用命令行来演示。

访问服务的方式

我们可以通过两种方式来访问已经创建好的服务。

1. 集群内部访问服务

我们可以通过Service IP + Service端口号的方式来从集群内部访问已经创建好的服务，所以，我们来看看tomcat Service的IP与端口号。

好了，现在可以进行访问了。

可以看到该服务已经通了，已经可以访问了，具体访问的是哪个pod中的tomcat，这是要根据具体情况进行负载均衡的。

2. 集群外部访问服务

从集群的外部我们可以通过node IP + node端口号的方式来对服务进行访问。pod实际上已经分在了不同的node中了，我们只用找到其中一个pod所在的node就行了。

可以看到我这个pod所在的IP地址。刚才已经看到了，在yaml文件中我将物理端口设为31111。好的，接下来就可以从外部对服务进行访问了。

可以看到，此时也可以访问服务。

部署mysql

如果你能将tomcat部署成功了，那么部署mysql就没有什么好讲的了。照前面做就行了。

创建mysql RC对象

我将此RC对象命名为mysql-rc1.yaml
直接上代码：

  1 apiVersion: v1
  2 kind: ReplicationController
  3 metadata:
  4   name: mysql
  5 spec:
  6   replicas: 1
  7   selector:
  8     app: mysql
  9   template:
 10     metadata:
 11       labels:
 12         app: mysql
 13     spec:
 14         containers:
 15         - image: img.reg.3g:15000/mysql:5.7.13
 16           name: mysql
 17           resources:
 18             limits:
 19               cpu: "2"
 20               memory: 4Gi
 21           ports:
 22           - containerPort: 3306
 23           env:
 24           - name: MYSQL_ROOT_PASSWORD
 25             value: "123456"

不同之处在于创建mysql的RC对象yaml文件时，注入了一个name为MYSQL_ROOT_PASSWORD的环境变量，这个是给mysql数据库设置密码，这个环境变量的注入是必须的，如果没有此环境变量，虽然RC可以被创建成功，但是系统是无法启动mysql容器的。不信可以试试。算了，还是给你演示一下吧。

创建mysql RC对象的结果

我把环境变量删了之后运行的结果如下：

可以看到，删掉环境变量的mysql RC虽然可以创建成功，但是容器启动失败了。
增加环境变量之后的结果

增加环境变量之后就可以启动起来容器了

创建mysql Service对象

同样道理，mysql也需要一个访问入口地址。创建的Service yaml文件名为mysql-svc1.yaml
还是直接上代码

  1 apiVersion: v1
  2 kind: Service
  3 metadata:
  4   name: mysql
  5 spec:
  6   ports:
  7   - name: mysql-svc
  8     port: 3306
  9     targetPort: 3306
 10     nodePort: 31101
 11   selector:
 12     app: mysql
 13   type: NodePort

没什么好解释的。

创建mysql Service对象的结果

可以看到，mysql Service对象也已经启动成功了。

由于前面已经详细介绍过如何访问服务了，这里我就不再赘述了。大家可以自己访问mysql的服务看看。

需要注意的细节

我认为，在kubernetes中部署应用集群的时候有两点特别需要注意的，当然，是我会犯错的地方，与大家分享：

1. yaml文件的格式问题
   我初次编写yaml文件可是花了不少时间，就是因为格式的问题，总是创建不了RC或者Servcice。尤其是需要注意，缩进要用空格缩进而不能用TAB键缩进。否则是成功不了的。
2. 理解pod、Service、node IP以及端口的关系
   这里的概念可能会比较难以理解，但一定要搞清楚，这是访问时的重点

总结

在kubernetes中部署容器，不仅可以用yaml，也可以用Json。还有，现在有许多容器化应用都是通过deployment部署的。当然，如果用RC部署也是可以的。我是第一次在kubernetes中部署容器化应用集群，所以就从简单的入手。希望本篇博客能够帮助到有些也刚刚接触kubernetes的同学。