K8S部署使用

K8S基础入门

一.K8S概述

1.什么是k8s

k8s是一个docker集群的管理工具

k8s是容器的编排工具

2.k8s的核心功能

自愈: 重新启动失败的容器，在节点不可用时，替换和重新调度节点上的

容器，对用户定义的健康检查不响应的容器会被中止，并且在容器准备好

服务之前不会把其向客户端广播。

弹性伸缩: 通过监控容器的cpu的负载值,如果这个平均高于80%,增加容器

的数量,如果这个平均低于10%,减少容器的数量

服务的自动发现和负载均衡: 不需要修改您的应用程序来使用不熟悉的服务

发现机制，Kubernetes 为容器提供了自己的 IP 地址和一组容器的单个

DNS 名称，并可以在它们之间进行负载均衡。

滚动升级和一键回滚: Kubernetes 逐渐部署对应用程序或其配置的更

改，同时监视应用程序运行状况，以确保它不会同时终止所有实例。 如果

出现问题，Kubernetes会为您恢复更改，利用日益增长的部署解决方案的

生态系统。

3.k8s的安装方式

yum安装（1.5版本）最容器安装成功，最适合学习者学习

源码编译安装—难度最大 可以安装最新版

二进制安装—步骤繁琐 可以安装最新版 shell,ansible,saltstack

kubeadm 安装最容易, 网络 可以安装最新版

minikube 适合开发人员体验k8s, 网络

4.k8s的应用场景

k8s最适合怕微服务的项目

mav架构：一般的一个网站就是一个项目

微服务:以京东为例，一整套网站的项目，京东把一整套网站按照功能分为好多个网站，一个功能出现问题不会影响全局，而且代码交接，代码检测，代码上线都方便很多。

二.k8s yum安装

1.master安装下载：

安装包	服务	配置文件
yum install -y etcd	systemctl restart etcd.service	vim /etc/etcd/etcd.conf	①
yum install kubernetes-master.x86_64 -y	systemctl restart kube-apiserver.service	vim /etc/kubernetes/apiserver	②
yum install kubernetes-master.x86_64 -y	kube-controller-manager.service	vim /etc/kubernetes/config	③④

1.master节点安装etcd数据库

yum install etcd -y 23 vim /etc/etcd/etcd.conf
6行：ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"  
21行： ETCD_ADVERTISE_CLIENT_URLS="http://10.0.0.11:2379" 

systemctl start etcd.service  
systemctl enable etcd.service 
#测试数据库是否成功
etcdctl set testdir/testkey0 
etcdctl get testdir/testkey0

etcdctl -C http://10.0.0.11:2379 cluster-health

2.master节点安装kubernetes

yum install kubernetes-master.x86_64 -y
#配置apiserver
vim /etc/kubernetes/apiserver
8行: KUBE_API_ADDRESS="--insecure-bind- address=0.0.0.0"
11行：KUBE_API_PORT="--port=8080"
17行：KUBE_ETCD_SERVERS="--etcd- servers=http://10.0.0.11:2379"
23行：KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger ,SecurityContextDeny,ResourceQuota"
#配置Controller Manager与scheduler
vim /etc/kubernetes/config
22行：KUBE_MASTER="--master=http://10.0.0.11:8080"

#下载docker服务,#不是docker-ce社区版，而是docker1.13版
yum install -y docker

systemctl restart docker
systemctl enable docker
systemctl enable kube-apiserver.service
systemctl restart kube-apiserver.service
systemctl enable kube-controller-manager.service 
systemctl restart kube-controller-manager.service 
systemctl enable kube-scheduler.service 
systemctl restart kube-scheduler.service

3.检查服务是否安装正常

[root@k8s-master ~]#  kubectl get componentstatus
NAME                 STATUS    MESSAGE             ERROR
etcd-0               Healthy   {"health":"true"}   
scheduler            Healthy   ok                  
controller-manager   Healthy   ok   

2.node节点安装

10.0.0.12节点

10.0.0.13节点

yum install kubernetes-node.x86_64 -y
vim /etc/kubernetes/config
22行：KUBE_MASTER="--master=http://10.0.0.11:8080"

vim /etc/kubernetes/kubelet
5行：KUBELET_ADDRESS="--address=0.0.0.0"
8行：KUBELET_PORT="--port=10250"
11行：KUBELET_HOSTNAME="--hostname-override=10.0.0.12"
14行：KUBELET_API_SERVER="--api- servers=http://10.0.0.11:8080"

systemctl enable kubelet.service 
systemctl restart kubelet.service 
systemctl enable kube-proxy.service
systemctl restart kube-proxy.service

3.master检查节点

[root@k8s-master ~]# kubectl  get node
NAME        STATUS    AGE
10.0.0.12   Ready     9h
10.0.0.13   Ready     9h

4.所有节点配置flanmel网络

1.master与node服务器安装flanner

yum install flannel -y
vim /etc/sysconfig/flanneld
#连接数据库
FLANNEL_ETCD_ENDPOINTS="http://10.0.0.11:2379"

2.master节点设置

#设置数据库etcd中要分配网段
etcdctl mk /atomic.io/network/config '{ "Network": "172.18.0.0/16" }' 

3.node节点设置

yum install flannel -y
systemctl restart flanneld.service
systemctl enable flanneld.service

三.为master配置镜像仓库

#所有节点
vim /etc/docker/daemon.json
{
  "registry-mirrors": ["https://registry.docker-cn.com"],
  "insecure-registries": ["10.0.0.11:5000"]
}
#重启
systemctl restart docker

#master节点
docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry registry

四.pod资源

k8s创建一个容器，需要再起一个pod容器，

pod是最小资源单位

1.创建pod资源

k8s yaml的主要组成

apiVersion: v1 api版本
kind: pod 资源类型
metadata: 属性
spec: 详细

[root@k8s-master ~]# vim /k8s/pod/k8s_pod.yaml 
apiVersion: v1
kind: Pod  #资源类型
metadata:
  name: nginx1
  labels:
    app: web #标签
spec:
  containers:
    - name: nginx1 #容器名称
      image: 10.0.0.11:5000/nginx:1.13
      ports:
        - containerPort: 80

所有node节点配置pod-infrastructure:latest

[root@k8s-node01 ~]# vim /etc/kubernetes/kubelet 
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=10.0.0.11:5000/pod-infrastructure:latest"
#重启服务
systemctl restart kubelet.service

创建pod

[root@k8s-master ~]# kubectl  create  -f /k8s/pod/k8s_pod.yaml
pod "nginx1" created

创建两个容器

apiVersion: v1 kind: Pod metadata: name: test labels: app: web spec: containers: - name: nginx image: 10.0.0.11:5000/nginx:1.13 ports: - containerPort: 80 - name: busybox image: 10.0.0.11:5000/busybox:latest command: ["sleep","10000"]

apiVersion: v1
kind: Pod
metadata:
  name: test
  labels:
    app: web
spec:
  containers:
    - name: nginx
      image: 10.0.0.11:5000/nginx:1.13
      ports:
        - containerPort: 80
    - name: busybox
      image: 10.0.0.11:5000/busybox:latest
      command: ["sleep","10000"]   

五.ReplicationController资源

​ RC是K8s集群中最早的保证Pod高可用的API对象。通过监控运行中的Pod来保证集群中运行指定数目的Pod副本。指定的数目可以是多个也可以是1个；少于指定数目，RC就会启动运行新的Pod副本；多于指定数目，RC就会杀死多余的Pod副本。

即使在指定数目为1的情况下，通过RC运行Pod也比直接运行Pod更明智，因为RC也可以发挥它高可用的能力，保证永远有1个Pod在运行。

1.简单配置rc

[root@k8s-master ~]# kubectl get  rc

始终保证有一个在活着

2.运行rc文件

[root@k8s-master ~]# kubectl replace -f  /k8s/rc/k8s_pod2.yaml

3./k8s/rc/k8s_pod2.yaml文件信息

[root@k8s-master ~]# vim /k8s/rc/k8s_pod2.yaml
apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx1 #rc名字
spec:
  replicas: 5  #副本5
  selector:
    app: myweb1
  template:
    metadata:
      labels:
        app: myweb1 #rc所管理pod的标签
    spec:
      containers:
      - name: myweb1 #容器名字
        image: 10.0.0.11:5000/nginx:1.15
        ports:
        - containerPort: 80

4.对现有已创建资源进行修改,可以调整数量即使生效

[root@k8s-master ~]# kubectl edit rc nginx

六.rc的滚动升级

需求：需要升级的RC的yml配置文件

​ 需要回滚的RC的yml配置文件

1.升级

kubectl  rolling-update  nginx  -f k8s_pod2.yaml --update-period=5s

2.回滚

kubectl  rolling-update  nginx1  -f rc_5.yaml --update-period=1s

七.service资源（svc）

RC、RS和Deployment只是保证了支撑服务的POD的数量，但是没有解决如何访问这些服务的问题。一个Pod只是一个运行服务的实例，随时可能在一个节点上停止，在另一个节点以一个新的IP启动一个新的Pod，因此不能以确定的IP和端口号提供服务。

要稳定地提供服务需要服务发现和负载均衡能力。服务发现完成的工作，是针对客户端访问的服务，找到对应的的后端服务实例。

在K8集群中，客户端需要访问的服务就是Service对象。每个Service会对应一个集群内部有效的虚拟IP，集群内部通过虚拟IP访问一个服务。

在K8s集群中微服务的负载均衡是由Kube-proxy实现的。Kube-proxy是K8s集群内部的负载均衡器。它是一个分布式代理服务器，在K8s的每个节点上都有一个；这一设计体现了它的伸缩性优势，需要访问服务的节点越多，提供负载均衡能力的Kube-proxy就越多，高可用节点也随之增多。

1.service原理图

网访问宿主机ip转到cluster ip的8080端口上在进行pod 分发rr轮询

Node IP	节点设备的IP，如物理机，虚拟机等容器宿主的实际IP。
Pod IP	Pod 的IP地址，是根据docker0网格IP段进行分配的。
Cluster IP	Service的IP，是一个虚拟IP，仅作用于service对象，由k8s管理和分配，需要结合service port才能使用，单独的IP没有通信功能，集群外访问需要一些修改。

#关于手动创建svc的port区别
#第一种:只指定了--port的虚拟ip的端口，没有指定容器真实的端口，所以默认容器的真实端口--target-port=808,默认和--posr虚拟ip的端口一致。
kubectl  expose  deployment nginx-deployment  --port=8080 --type=NodePort
#第二种：明确指定了虚拟ip的--port的端口，容器的真实端口--target-port=80
kubectl  expose  deployment nginx-deployment  --port=8008 --type=NodePort --target-port=80

2.service部署实现

1.实现service

[root@k8s-master ~]# vim myweb-svc.yaml 
apiVersion: v1
kind: Service
metadata:
  name: myweb
spec:
  type: NodePort
  ports:
    - port: 80      #clusterIP 随便写
      nodePort: 30001  #node port
      targetPort: 8080 #pod port
  selector:
    app: myweb

2.启动集群

[root@k8s-master ~]# kubectl create -f myweb-svc.yaml 
service "myweb" created
[root@k8s-master ~]# kubectl get svc
NAME         CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
kubernetes   10.254.0.1      <none>        443/TCP          6h
myweb        10.254.247.21   <nodes>       8080:30001/TCP   12s

3.浏览器访问测试

3.手动执行svc

kubectl expose -n tomcat myweb --port=8001 --target-port=8080 --type=NodePort

八.deployment资

之前service以及rc已经可以做到滚动升级并且服务发现、负载均衡等功能，为什么还需要deployment这个组件呢？前面使用rc和service是通过selector进行关联的，但是在rc的滚动升级过程中标签是可能发生改变的，所以升级之后service与rc可能失去关联关系导致无法访问。

1.使用deployment

1.定义一个deployment

vim /k8s/svc/k8s_svc.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: nginx
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: 192.168.56.201:5000/nginx:1.13
        ports:
        - containerPort: 80

2.创建deployment

kubectl  create -f  /k8s/svc/k8s_svc.yaml

3.deployment还不能被外界访问，创建svc

kubectl  expose  deployment  nginx-deployment  --port=80 --type=nodeName 

4.查看nginx版本

curl -I 
#省略
#nginx1.13版本

2.deployment版本回滚

直接修改yaml文件，修改镜像版本号经行回滚1.13—1.15

kubectl  edit + deploument名字

3.手动执行deployment

kubectl run -n  nginx nginx-deployment --image=10.0.0.11:5000/nginx:1.13 --replicas=3 --record

九.k8s弹性伸缩

弹性伸缩式k8s中的一大亮点功能，通过heapster监控得知负载大的时候，你可以对应用进行扩容，提升pod的副本数来应对大量的流量，当负载小的时候可以对应用进行缩容，以避免资源浪费。也可以让应用自动的进行扩容和缩容，这一功能有用。例如当微博出现了一个话题时，这个时候人们都去访问，此时他的服务器将无法处理大量的流量访问，这个时候就需要扩容，而当这个话题不在新鲜时，人们的访问流量也就是降下来了，那么就需要对服务器进行缩容处理，来自动适应流量需求。

1.autoscale命令

#以cpu负载为标准，超过60%就扩大deployment,最多10个pod，最小2个pod
kubectl  autoscale  -n hpa  deployment  nginx-deployment  --max=10 --min=2 --cpu-percent=60

2.需要注意的是：

• 一是k8s做出决策的间隔，它不会连续地执行扩缩容动作，而是存在一定的cd，目前扩容动作的cd为3分钟，缩容则为5分钟。
• 二是k8s针对扩容做了一个最大限制，每次扩容的pod数量不会大于当前副本数量的2倍
• 被监控的容器要有做cpu，内存的限制（取决与你的监控条件），不然容器是使用宿主机的资源，不会弹性伸缩。

3.弹性伸缩部署实验

1.k8s弹性伸缩需要附加插件heapster监控

监控不监控都可以实现弹性伸缩，监控起来可以让实验更明显

1.下载镜像并导入镜像到私人仓库

docker_heapster_grafana.tar.gz
docker_heapster_influxdb.tar.gz

docker_heapster.tar.gz

2.编写yaml文件

[root@k8s-master ~]# ls -1 /k8s/heapster/
grafana-service.yaml
heapster-controller.yaml
heapster-service.yaml
influxdb-grafana-controller.yaml
influxdb-service.yaml

3.创建rc----pod

4.创建弹性伸缩规则

kubectl  autoscale  -n hpa  deployment  nginx-deployment  --max=10 --min=2 --cpu-percent=60

5.压力测试

ab -n 100000 -c 40 http://10.0.0.12/index.html

6.测试截图

监控

扩容

缩容

十.k8s存储

1.k8s存储的分类

一个运行中的容器，对文件系统的写入，都是发生在其分层文件系统的可写层的，一旦容器运行结束，所有写入都会被丢弃。因此需要对持久化支持。

2. emptydir是什么

当pod的存储方案设定为emptydir的时候，pod启动时，就会在pod所在节点的磁盘空间开辟出一块空卷，最开始里面是什么都没有的，pod启动后容器产生的数据会存放到那个空卷中。空卷变成了一个临时卷
　　供pod内的容器读取和写入数据，一旦pod容器消失，节点上开辟出的这个临时卷就会随着pod的销毁而销毁.

emptydir例子

apiVersion: v1
kind: Pod
metadata:
name: test-pd
 spec:
   containers:
   - image: k8s.gcr.io/test-webserver
     name: test-container
     volumeMounts:
     - mountPath: /cache    #挂载到容器中的路径
       name: cache-volume
   volumes:
   - name: cache-volume
     emptyDir: {}   #指定存储方式为emptydir

emptydir的双容器共享功能

[root@k8s-master demo]# vim emptydir.yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: write
    image: 10.0.0.11:5000/nginx:1.13

    volumeMounts:
      - name: data
        mountPath: /data
  - name: read
    image: centos
    command: ["bash","-c","tail -f /data/hello"]
    volumeMounts:
      - name: data
        mountPath: /data
  volumes:
  - name: data
    emptyDir: {}

3.hostpath是什么

挂载Node文件系统上文件或者目录到Pod中的容器。
应用场景：Pod中容器需要访问宿主机文件。

缺点：宿主机损坏或者容器被重新建立在另一个宿主机上会导致数据丢失

[root@k8s-master demo]# vim hostpath.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: my-pod2
spec:
  containers:
  - name: busybox
    image: busybox
    args:
    - /bin/sh
    - -c - sleep 36000
    volumeMounts:
    - name: data
      mountPath: /data   #容器的目录
  volumes:
  - name: data
    hostPath:
      path: /tmp   #宿主机目录
      type: Directory  

4.nfs存储是什么

NFS 是Network File System的缩写，即网络文件系统。Kubernetes中通过简单地配置就可以挂载NFS到Pod中，而NFS中的数据是可以永久保存的，同时NFS支持同时写操作。

应用场景：两个容器共同采用一个目录资源

nfs存储例子

[root@k8s-master ~]# vim tomcat_demo/mysql-deploy.yml 

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  namespace: tomcat
  name: mysql
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: mysql
    spec:
      volumes:
      - name: mysql
        nfs:
          path: /data/mysql
          server: 10.0.0.11
      containers:
        - name: mysql
          image: 10.0.0.11:5000/mysql:5.7
          volumeMounts:
          - name: mysql
            mountPath: /var/lib/mysql  #容器的目录
          ports:
          - containerPort: 3306
          env:
          - name: MYSQL_ROOT_PASSWORD