kubenetes创建编排：yaml/json

---

创建一个简单的pod，只含有一个tomcat

1.搭建好kubenetes的整套环境

2.写一个编排yaml格式

kubenetes里面的创建service、rc、pod都是这种形式(另外一种是json)
根据名字基本也不难猜到是什么意思。

apiVersion: v1
kind: Pod
metadata:
  name: example-app
  labels:
    app: example-app
    version: v1
spec:
  containers:
  - name: java
    image: tomcat-1
    ports:
    - containerPort: 8080

下面配置的container表示创建pod的时候里面有这些container，如果不存在则会自动帮你创建container
container不用解释了吧，把它当做一个应用就行.

3.启动一个pod

kubectl create -f test.yaml

完成。如果报错参考
http://blog.csdn.net/jinzhencs/article/details/51435020

附：JSON格式

{
    "kind": "Pod",
    "apiVersion": "v1",
    "metadata": {
        "name": "demo",
        "labels": {
            "name": "demo",
            "version": "v1"
        }
    },
    "spec": {
        "containers": [
            {
                "name": "tomcat-test",
                "image": "index.tenxcloud.com/tenxcloud/tomcat",
                "ports": [
                    {
                        "containerPort": 8100

                    }
                ]
            },
            {
                "name": "mysql-1", // 不能写成 mysql.abc.com
                "image": "mysql-imagexxxxxxxxx", // 要确定有此镜像，可以是本机的或者是远程仓库的
                "ports": [
                    {
                        "containerPort": 8105

                    }
                ]
            }
        ]
    }
}

---

创建包含多个container的pod、rc、service

1.创建pod

-demo-pod.json

{
    "kind": "Pod",                 //类型 Pod、Service、ReplicationController 注意首字母必须大写
    "apiVersion": "v1", 
    "metadata": {                  //pod本身的信息
        "name": "tomcat-ming-pod", //pod的名称
        "labels": {                //pod的标签，用于kubenetes其他组件来标识这个pod
            "name": "tomcat-ming-pod",
            "version": "v1"
        }
    },
    "spec": {
        "containers": [            //这个pod包含的docker container，一个pod可以由多个container组成
            {
                "name": "tomcat-container-1", //第一个container的name
                "image": "tomcat-1",          //镜像，可以是本机已有的或者远程仓库的
                "ports": [
                    {
                        "containerPort": 8080//
                        //"hostPort":5000    //把这个容器本身暴露在外网的端口，一般不这么做
                                             //都是通过service把服务暴露的，而不是容器本身暴露
                    }
                ]
            }，
            {
                //第二个container的配置，例如mysql、redis
            }
        ]
    }
}

2.创建service使得外部能够访问pod内的服务

-demo-service.json

{
    "kind": "Service",     //类型:service
    "apiVersion": "v1",
    "metadata": {          //service本身的一些信息
        "name": "tomcat-ming-service",
        "labels": {        //service的标签 用于其他组件标识定位到这个service 一般没啥用
            "name": "tomcat-ming-service"
        }
    },
    "spec": {              //主要配置 用于配置service代理的端口转向哪个pod的服务
        "type": "NodePort",//类型:ip:port形式暴露服务
        "ports":           //表明可以一次代理多个ip:port，目前只需要代理一个端口即可
                           //一般一整套系统也只应该有一个出口，比如haproxy或是tomcat
            [{
            "port": 8080,  //service本身的port，并没什么用，无视
            "targetPort":8080,//目标container的port
            "nodePort":32016  //外网访问的端口，此处有坑，范围必须是30000-32000/35000具体忘记了
            }],
        "selector": {         //筛选pod
            "name": "tomcat-ming-pod", //根据之前定义的pod的标签里面的name
            "version": "v1"            //还可以自定义一些键值对.
        }
    }
}

目前这里我有一个问题，就是一个pod如果有2个tomcat，那么container内部都是8080，
那么service这里的targetPort 8080最终会指向谁？

但可能是我的无稽之谈，因为一个pod内应该是几个不同的系统，比如
haproxy、tomcat、redis、mysql，由此他们的container启动的端口也就不会有冲突。
targetPort自然不会有冲突。这个问题先pass

补充:
同一个pod内不允许端口重复

---

附上目前我用的rc模板(使用freemark)

{
    "kind": "ReplicationController",
    "apiVersion": "v1",
    "metadata": {
        "name": "${stackName}",
        "namespace":"${namespace}",
        "labels": {
            "release": "${releaseUuid}",
            "appName": "${appName}",
            "deployType": "${deployType}",
            "stackName": "${stackName}",
            <#list containerList as containerInfo>
                   "${containerInfo.microServiceName}-version": "${containerInfo.version}"
            <#if containerInfo_has_next>,</#if></#list>
            }
        },
    "spec": {
        "replicas": ${replicas},
        "template": {
            "metadata": {
                "name": "${stackName}",
                "labels": {
                    "release": "${releaseUuid}",
                    "appName": "${appName}",
                    "deployType": "${deployType}",
                    "stackName": "${stackName}",
                    <#list containerList as containerInfo>
                           "${containerInfo.microServiceName}-version": "${containerInfo.version}"
                    <#if containerInfo_has_next>,</#if></#list>
                    }
                },
            "spec": {
                "volumes":
                    [{
                        "name": "ulog",
                        "hostPath":
                            {
                            "path": "/var/logs/ulog"
                            }
                    },
                    {
                        "name": "serverlog",
                        "hostPath":
                            {
                            "path": "/var/logs/serverlogs"
                            }
                    }],
                "dnsPolicy": "Default",    
                "imagePullSecrets": [
                    <#list secretList as secret>{ 
                            "name": "${secret}"
                    }
                    <#if secret_has_next>,</#if> 
                    </#list>
                ],
                "containers": [
                <#list containerList as containerInfo>{
                        "name": "${containerInfo.microServiceName}",
                        "image": "${containerInfo.imageUrl}",
                        "imagePullPolicy": "Always",
                        <#if containerInfo.portList??>
                        "ports": [
                            <#list containerInfo.portList as portInfo>{
                                "containerPort":${portInfo.targetPort?c},
                                "protocol":"${portInfo.protocol}"
                                <#if portInfo.hostPort??>
                                    ,
                                    "hostPort":"${portInfo.hostPort?c}"
                                </#if>
                           }
                           <#if portInfo_has_next>,</#if> 
                           </#list>
                        ],
                        </#if>
                        <#if containerInfo.envList??>
                        "env": [
                            <#list containerInfo.envList as envInfo>{
                                "name": "${envInfo.name}",
                                "value": "${envInfo.value}"
                           }
                           <#if envInfo_has_next>,</#if> 
                           </#list>
                        ],
                        </#if>
                        "volumeMounts": [
                        {
                          "mountPath": "/var/logs/k8s/serverlogs",
                          "name": "serverlog"
                        },
                        {
                          "mountPath": "/var/logs/k8s/ulog",
                          "name": "ulog"
                        }
                        ],
                        "resources": {
                          "requests":{
                            <#if containerInfo.cpu??>
                              "cpu": "${containerInfo.cpu}"
                            </#if>
                            <#if containerInfo.cpu??>
                                <#if containerInfo.memory??>
                                ,
                                </#if>
                            </#if>
                            <#if containerInfo.memory??>
                              "memory": "${containerInfo.memory}"
                            </#if>
                          }
                        }
                   }<#if containerInfo_has_next>,</#if></#list>
                ]
            }
        }
    }
}