配置kubernetes服务

一、配置kubernetes环境，需要三台主机，分别作为master、node1、node2。
本次实验master端既做etcd，也做master、还做registry、也可分开放在不同的机器上，则共需要五台机器。
二、在每台实验所用的机器上做解析

[root@master ~]# cat /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.122.100  master
192.168.122.100  etcd
192.168.122.100  registry
192.168.122.144  node1
192.168.122.247   node2

三、部署master端软件
master端：

1、etcd服务作为K8s集群的主数据库,在安装各服务之前需要首先安装和启动。
yum -y install etcd
编辑/etc/etcd/etcd.conf配置文件
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379,http://0.0.0.0:4001"       监控所有网卡的两个端口
ETCD_NAME="master"          
#[Clustering]
ETCD_ADVERTISE_CLIENT_URLS="http://etcd:2379,http://etcd:4001"      用此路径访问etcd数据库
启动:
# systemctl enable etcd && systemctl start etcd
etcdctl -C http://etcd:4001
 cluster-health                                      #   查看远程地址的两个端口是否好用，出现cluster is healthy
# etcdctl -C http://etcd:2379 
cluster-health
2、安装Docker
[root@master ~]# yum install docker -y
修改Docker配置文件，使其允许从node的registry中拉取镜像,docker访问默认使用443端口，在if语句下面添加一行,不配置不能用
[root@master ~]# cat /etc/sysconfig/docker
# /etc/sysconfig/docker
# Modify these options if you want to change the way the docker daemon runs
OPTIONS='--selinux-enabled --log-driver=journald --signature-verification=false'
if [ -z "${DOCKER_CERT_PATH}" ]; then
    DOCKER_CERT_PATH=/etc/docker
fi
PTIONS='--insecure-registry registry:5000'
[root@master ~]# systemctl enable docker
[root@master ~]# systemctl  start  docker
3、安装kubernertes
[root@master ~]# yum install kubernetes -y
在kubernetes master上需要运行以下组件，故分别配置组件启动相应服务：
　　　　kubernetes API Server
　　　　kubernetes Controller Manager
　　　　kubernetes Scheduler
api server：在master节点上，用于k8s中的组件互联，是Kubectl命令管理工具联系其他创建相应资源的相应组件的一个api,修改apiserver配置文件下面4行。
scheduler调度器：决定Pod放在什么位置。创建有两个副本的RC，每一个副本都是一个Pod，Pod要创建到哪个节点上，RC无法决定，RC只负责创建，而是由调度器决定。
[root@master ~]# vim /etc/kubernetes/apiserver
# The address on the local server to listen to. ——监听地址
KUBE_API_ADDRESS="--insecure-bind-address=0.0.0.0"          

# The port on the local server to listen on.——监听端口
KUBE_API_PORT="--port=8080"

# Comma separated list of nodes in the etcd cluster ——逗号分割的存在etcd数据库中的节点列表
KUBE_ETCD_SERVERS="--etcd-servers=http://etcd:2379"

# default admission control policies——k8s支持的所有控制器，删掉ServiceAccount
KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ResourceQuota"
修改config配置文件下面1行
[root@master ~]# vim /etc/kubernetes/config
# How the controller-manager, scheduler, and proxy find the apiserver
KUBE_MASTER="--master=http://master:8080"       控制器调度器联系apiserver组件的地址
4、启动并设置开机自启apiserver、控制器、调度器。
服务名为 kube-apiserver.service、kube-controller-manager.service、kube-scheduler.service

四、部署所有node端软件

1、安装docker，修改/etc/sysconfig/docker配置，同master端相同，设置开机自启并启动。
2、下载kubernetes，（yum -y install kubernetes），因为在kubernetes node上需要运行以下组件：
　　　　Kubelet
　　　　kubernetes Proxy
故修改配置文件如下：
[root@node1 ~]# vim /etc/kubernetes/config
# How the controller-manager, scheduler, and proxy find the apiserver—— 连接apiserver的地址
KUBE_MASTER="--master=http://master:8080"      
[root@node1 ~]# vim /etc/kubernetes/kubelet
# kubernetes kubelet (minion) config
# The address for the info server to serve on (set to 0.0.0.0 or "" for all interfaces)
KUBELET_ADDRESS="--address=0.0.0.0"         kubelet监听地址

# You may leave this blank to use the actual hostname
KUBELET_HOSTNAME="--hostname-override=node1"           #使用自己的主机名称，node2为node2

# location of the api-server
KUBELET_API_SERVER="--api-servers=http://master:8080"     
3、启动并设置开机自启以下服务：
kubelet.service
kube-proxy.service
4、测试，master端查看节点状态，都是ready则配好：
[root@master ~]# kubectl get nodes
    NAME         STATUS    AGE
    node1   Ready     3m
    node2   Ready     43s

五、实验中所有主机都部署flannel
凡是在k8s管理的节点下，都在一个大网络中，后面的所有资源在这个大子网中再创建小子网，但这些都无需手动配置，flannel自动完成。配置flannel的目的就是为了方便，不需要自己再配置路由。故在k8s中Flannel这个组件是非常重要的。
#如果没有配置flannel，则所有的pod及其副本没有ip，无法被ping，此时回头再配置flanned，则flannel服务无法启动，需要把pod全部删除。
1、集群中的所有机器安装flannel

 # yum install flannel -y

2、集群中的所有机器修改配置，使连接etcd

vim /etc/sysconfig/flanneld
# etcd url location.  Point this to the server where etcd runs——配置连接etcd数据库 FLANNEL_ETCD_ENDPOINTS="http://etcd:2379"  

3、在master端配置 flannel 使用的 network，并将配置保存在 etcd 中:

[root@master ~]# etcdctl mk /atomic.io/network/config '{ "Network": "172.17.0.0/16" }'     //mk创建网络，update更新网络，
    { "Network": "172.17.0.0/16" }

4、集群中的所有机器启动flannel服务设置开机自启

 # systemctl restart flanneld

flannel将从etcd中获取network 配置，并为本节点产生一个subnet保存在etcd中，并且自动产生一个文件为/run/flannel/subnet.env，可以看一下这个文件，发现存放着我们用命令配置的网络信息。

[root@master kubernetes]# cat /run/flannel/subnet.env
    FLANNEL_NETWORK=172.17.0.0/16  #全局的 falnnel network
    FLANNEL_SUBNET=172.17.78.1/24   #本节点上分配到的小子网，此后所有容器就可以直接通讯，无需手动配置
    FLANNEL_MTU=1400             #本节点上 flannel mtu
    FLANNEL_IPMASQ=false

六、部署插件
共两个：dashboard镜像，提供一个管理界面web ui，Kubectl 和Web UI都是k8s的管理工具，此处用kubectl命令，故dashboard省略不配。
镜像2：启动k8s的pod还需要的一个额外的镜像，必须配置：
registry.access.redhat.com/rhel7/pod-infrastructure:latest，国内没有，故在阿里云上购买美国服务器（香港服务器有问题）

 # yum install docker -y
    # systemctl start docker
    # docker search  pod-infrastructure  //从找到的结果中下载一个名字尽量接近的镜像,原装的不能下载
    # docker pull docker.io/tianyebj/pod-infrastructure
    # docker save -o podinfrastructure.tar  docker.io/tianyebj/pod-infrastructure

七、

1、将镜像拷贝给所有node，然后导入:
    # scp   美国服务器IP:/podinfrastructure.tar   /
    # docker load < podinfrastructure.tar  
查看导入之后的镜像
# docker images
    REPOSITORY                                               TAG          IMAGE ID            CREATED             SIZE
    daocloud.io/daocloud/google_containers_kubernetes-dashboard-amd64   v1.6.1              71dfe833ce74        10 months ago       134 MB
    docker.io/tianyebj/pod-infrastructure           latest       34d3450d733b    14 months ago   205 MB
2、所有node修改配置文件重启服务
# vim /etc/kubernetes/kubelet   //修改镜像名称
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=docker.io/tianyebj/pod-infrastructure:latest" 
# systemctl  restart kubelet

八、部署DNS插件应用
　每个Kubernetes service都绑定了一个虚拟IP 地址（ClusterIP），而且Kubernetes最初使用向pod中注入环境变量的方式实现服务发现，但这会带来环境变量泛滥等问题。故需要增加集群DNS服务为每个service映射一个域名。
#如果没有配置dns，则同一个pod和其副本的ip都相同，ping测试pod的ip会发现无法到达，故必须配置。
1、下载以下三个镜像：
还是没有国内源，需要先在国外服务器上下载然后打包拷贝到所有node本地，再导入
docker.io/ist0ne/kubedns-amd64:latest
docker.io/mritd/kube-dnsmasq-amd64:latest
docker.io/ist0ne/exechealthz-amd64:latest
2、修改每一个node上的配置，此处的–cluster-dns可自定义为10.254.0.0/16下的子网。

[root@node1 /]# cat /etc/kubernetes/kubelet
# Add your own!
KUBELET_ARGS="--cluster-dns=10.254.10.2 --cluster-domain=cluster.local. --allow-privileged=true"
[root@node1 ~]# systemctl restart kubelet.service

3、master端创建两个yaml文件设置dns

第一个，kube-dns-rc_14.yaml 如下，空格个数要求严格。
[root@master ～]# vim kube-dns-rc_14.yaml 
apiVersion: v1
kind: ReplicationController
metadata:
  name: kube-dns-v20
  namespace: kube-system
  labels:
    k8s-app: kube-dns
    version: v20
    kubernetes.io/cluster-service: "true"
spec:
  replicas: 1
  selector:
    k8s-app: kube-dns
    version: v20
  template:
    metadata:
      labels:
        k8s-app: kube-dns
        version: v20
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
        scheduler.alpha.kubernetes.io/tolerations: '[{"key":"CriticalAddonsOnly", "operator":"Exists"}]'
    spec:
      containers:
      - name: kubedns
        image: docker.io/ist0ne/kubedns-amd64:latest
        imagePullPolicy: IfNotPresent
        resources:
          # TODO: Set memory limits when we've profiled the container for large
          # clusters, then set request = limit to keep this container in
          # guaranteed class. Currently, this container falls into the
          # "burstable" category so the kubelet doesn't backoff from restarting it.
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        livenessProbe:
          httpGet:
            path: /healthz-kubedns
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        readinessProbe:
          httpGet:
            path: /readiness
            port: 8081
            scheme: HTTP
          # we poll on pod startup for the Kubernetes master service and
          # only setup the /readiness HTTP server once that's available.
          initialDelaySeconds: 3
          timeoutSeconds: 5
        args:
        # command = "/kube-dns"
        - --domain=cluster.local. 
        - --dns-port=10053
        - --kube-master-url=http://192.168.122.100:8080         此处ip为master的ip
        ports:
        - containerPort: 10053
          name: dns-local
          protocol: UDP
        - containerPort: 10053
          name: dns-tcp-local
          protocol: TCP
      - name: dnsmasq
        image: docker.io/mritd/kube-dnsmasq-amd64:latest
        imagePullPolicy: IfNotPresent
        livenessProbe:
          httpGet:
            path: /healthz-dnsmasq
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        args:
        - --cache-size=1000
        - --no-resolv
        - --server=127.0.0.1#10053
        - --log-facility=-
        ports:
        - containerPort: 53
          name: dns
          protocol: UDP
        - containerPort: 53
          name: dns-tcp
          protocol: TCP
      - name: healthz
        image: docker.io/ist0ne/exechealthz-amd64:latest
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            memory: 50Mi
          requests:
            cpu: 10m
            # Note that this container shouldn't really need 50Mi of memory. The
            # limits are set higher than expected pending investigation on #29688.
            # The extra memory was stolen from the kubedns container to keep the
            # net memory requested by the pod constant.
            memory: 50Mi
        args:
        - --cmd=nslookup kubernetes.default.svc.cluster.local. 127.0.0.1 >/dev/null
        - --url=/healthz-dnsmasq
        - --cmd=nslookup kubernetes.default.svc.cluster.local. 127.0.0.1:10053 >/dev/null
        - --url=/healthz-kubedns
        - --port=8080
        - --quiet
        ports:
        - containerPort: 8080
          protocol: TCP
      dnsPolicy: Default  # Don't use cluster DNS.

master第二个yaml文件kube-dns-svc_14.yaml 
[root@master ～]# cat kube-dns-svc_14.yaml 
apiVersion: v1
kind: Service
metadata:
  name: kube-dns
  namespace: kube-system
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    kubernetes.io/name: "KubeDNS"
spec:
  selector:
    k8s-app: kube-dns
  clusterIP: 10.254.10.2
  ports:
  - name: dns
    port: 53
    protocol: UDP
  - name: dns-tcp
    port: 53
    protocol: TCP

4、启动

[root@master ～]# kubectl create -f kube-dns-rc_14.yaml 
replicationcontroller "kube-dns-v20" created
[root@master ～]# kubectl create -f kube-dns-svc_14.yaml 
service "kube-dns" created

5、查看，状态为running，ready为3/3即成功，状态为Terminating即终止，为ImagePullBackOff，说明镜像拉取错误，检查镜像。

[root@k8s-master /]# kubectl get pod  -o wide  --all-namespaces
NAMESPACE     NAME                                           READY     STATUS    RESTARTS   AGE       IP          NODE
kube-system   kube-dns-v20-gbd1m                             3/3       Running   0          19m       10.0.27.3   k8s-node-2
kube-system   kubernetes-dashboard-latest-1231782504-t79t7   1/1       Running   0          6h        10.0.27.2   k8s-node-2