kubernetes_tb宝满

master:kubectl操作api-server 增删改查，scheduler调度 ，controller manager控制应用副本，etcd存储应用状态

node：pod，kube-proxy

Master：集群控制节点，负责整个集群的管理和控制。
API Server： 提供接口，资源增删改查入口。
Controller Manager: 所有资源对象的自动化控制中心。
Scheduler： 负责资源调度。
Etcd：master的持续状态都存在etcd。

Node：工作节点，听从master的工作分配。
Kubelet： Pod容器创建、启停，集群管理等任务。
kube-proxy： 实现service 的通信与负载均衡组件。
Docker: Docker引擎，负责本机容器创建和管理工作。

 

Pod:

是在K8s集群中运行部署应用或服务的最小单元，它是可以支持多容器的。Pod的设计理念是支持多个容器在一个Pod中共享网络地址和文件系统，可以通过进程间通信和文件共享这种简单高效的方式组合完成服务。
 

RC:

replication controller是K8s集群中最早的保证Pod高可用的API对象。通过监控运行中的Pod来保证集群中运行指定数目的Pod副本。指定的数目可以是多个也可以是1个；少于指定数目，RC就会启动运行新的Pod副本；多于指定数目，RC就会杀死多余的Pod副本。即使在指定数目为1的情况下，通过RC运行Pod也比直接运行Pod更明智，因为RC也可以发挥它高可用的能力，保证永远有1个Pod在运行。

 

service: 

一个Pod只是一个运行服务的实例，随时可能在一个节点上停止，在另一个节点以一个新的IP启动一个新的Pod，因此不能以确定的IP和端口号提供服务。要稳定地提供服务需要服务发现和负载均衡能力。
在K8s集群中，客户端需要访问的服务就是Service对象。每个Service会对应一个集群内部有效的虚拟IP，集群内部通过虚拟IP访问一个服务。

 

deployment:

部署表示用户对K8s集群的一次更新操作。可以是创建一个新的服务，更新一个新的服务，也可以是滚动升级一个服务。滚动升级一个服务，实际是创建一个新的RS，然后逐渐将新RS中副本数增加到理想状态，将旧RS中的副本数减小到0的复合操作；这样一个复合操作用一个RS是不太好描述的，所以用一个更通用的Deployment来描述。以K8s的发展方向，未来对所有长期伺服型的的业务的管理，都会通过Deployment来管理。 

 

replica set:

RS是新一代RC，提供同样的高可用能力，区别主要在于RS后来居上，能支持更多种类的匹配模式。副本集对象一般不单独使用，而是作为Deployment的理想状态参数使用。

 

daemon set:

长期伺服型和批处理型服务的核心在业务应用，可能有些节点运行多个同类业务的Pod，有些节点上又没有这类Pod运行；而后台支撑型服务的核心关注点在K8s集群中的节点（物理机或虚拟机），要保证每个节点上都有一个此类Pod运行。节点可能是所有集群节点也可能是通过nodeSelector选定的一些特定节点。典型的后台支撑型服务包括，存储，日志和监控等在每个节点上支持K8s集群运行的服务。

 

job:

Job是K8s用来控制批处理型任务的API对象。批处理业务与长期伺服业务的主要区别是批处理业务的运行有头有尾，而长期伺服业务在用户不停止的情况下永远运行。Job管理的Pod根据用户的设置把任务成功完成就自动退出了。成功完成的标志根据不同的spec.completions策略而不同：单Pod型任务有一个Pod成功就标志完成；定数成功型任务保证有N个任务全部成功；工作队列型任务根据应用确认的全局成功而标志成功。

 

软件环境：

 master

node1

node2

ubuntu 1904添加网卡：

ip link 查看网卡

vim /etc/netplan/50-cloud-init.daml  写入网卡
root@master:~# cat /etc/netplan/50-cloud-init.yaml 
# This file is generated from information provided by
# the datasource.  Changes to it will not persist across an instance.
# To disable cloud-init's network configuration capabilities, write a file
# /etc/cloud/cloud.cfg.d/99-disable-network-config.cfg with the following:
# network: {config: disabled}
network:
    ethernets:
        ens33:
            dhcp4: true
        ens38:
                #dhcp4: true
            addresses: [192.168.134.130/24]
            nameservers:
                    addresses: [114.114.114.114]
            gateway4: 192.168.134.2
    version: 2

netplan apply  重启网络

 
-------------------centos环境安装
#停止firewalld服务
systemctl stop firewalld && systemctl disable firewalld

#关闭selinux
sed -i 's/^SELINUX=enforcing$/SELINUX=disabled/' /etc/selinux/config && setenforce 0

#关闭swap设置
swapoff -a
yes | cp /etc/fstab /etc/fstab_bak
cat /etc/fstab_bak |grep -v swap > /etc/fstab

#解决流量路由不正确问题
cat <<EOF >  /etc/sysctl.d/k8s.conf
vm.swappiness = 0
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

# 使配置生效
modprobe br_netfilter
sysctl -p /etc/sysctl.d/k8s.conf

#更改hosts文件
cat >> /etc/hosts << EOF
192.168.0.20 master.example.com
192.168.0.49 node1.example.com 
192.168.0.50 node2.example.com
EOF

#安装docker
yum -y install docker 
systemctl enable docker && systemctl start docker

#配置阿里k8s源
cat >> /etc/yum.repos.d/k8s.repo << EOF
[kubernetes]
name=kuberbetes repo
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
gpgcheck=0
EOF

#安装kubelet/kubeadm/kubectl
yum -y install kubelet kubeadm kubectl
systemctl enable kubelet && systemctl start kubelet



-------------------centos环境安装结束

----------------ubuntu环境安装
swapoff -a
yes | cp /etc/fstab /etc/fstab_bak
cat /etc/fstab_bak |grep -v swap > /etc/fstab

#解决流量路由不正确问题
cat <<EOF >  /etc/sysctl.d/k8s.conf
vm.swappiness = 0
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

# 使配置生效
modprobe br_netfilter
sysctl -p /etc/sysctl.d/k8s.conf

#更改hosts文件
cat >> /etc/hosts << EOF
192.168.2.150 master.example.com
192.168.2.151 node1.example.com
192.168.2.152 node2.example.com
EOF

apt-get -y install docker.io
systemctl enable docker && systemctl start docker

apt-get update && apt-get install -y apt-transport-https curl

 cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
EOF

curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add - 

apt-get update
apt-get -y install kubelet=1.13.1-00 kubeadm=1.13.1-00 kubectl=1.13.1-00 kubernetes-cni=0.6.0-00
systemctl enable kubelet && systemctl start kubelet

ubuntu列举软件版本：
apt-cache madison kubelet 
----------------ubuntu环境安装结束


-------------------------------python3 自动拉取image的脚本：
import os

S_registry = 'registry.cn-beijing.aliyuncs.com/kubernetesdevops/'
D_registry = 'k8s.gcr.io/'

master_image = ['kube-apiserver:v1.13.1','kube-controller-manager:v1.13.1',
                'kube-scheduler:v1.13.1','kube-proxy:v1.13.1','pause:3.1',
                'etcd:3.2.24','coredns:1.2.6','flannel:v0.10.0-amd64','kubernetes-dashboard-amd64:v1.10.0']

def PullImage(registry,images):

    index = 1
    for image in images:

        cmd = "docker pull " + registry + image
        os.system(cmd)
        print("done!")
        index +=1

def TagImage(sregistry,dregistry,images):
    index = 1
    for image in images:

        cmd = "docker tag " + sregistry+image + " " +  dregistry + image
        os.system(cmd)
        print("done!")
        index +=1

if __name__ == '__main__':
    PullImage(S_registry,master_image)
    #TagImage(S_registry,D_registry,master_image)

-----------------------------python3 自动拉取images脚本结束

删除重复的tag：
for i in `docker images |grep beijing|awk '{print $1":"$2}'`;do docker rmi $i;done

拉取上面8个镜像，node1，2也都需要


-------------master初始化
kubeadm init --kubernetes-version=v1.13.1 --apiserver-advertise-address 192.168.134.130 --pod-network-cidr=10.244.0.0/16

kubeadm init --kubernetes-version=v1.13.1 --apiserver-advertise-address 192.168.134.130 --pod-network-cidr=10.244.0.0/16 --ignore-preflight-errors=SystemVerification

输出：
Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 192.168.134.130:6443 --token dyfl39.tsd8zqpfaehj8l9b --discovery-token-ca-cert-hash sha256:7e1358ca2c2c2edce1e548e0690ed1327fb41eb8150bb543794e8b7f48c654cd

-----输出结束
-----声明一下kubeconfig
echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> /etc/profile
source /etc/profile

kubectl get nodes   发现notReady


安装flannel
curl https://raw.githubusercontent.com/coreos/flannel/62e44c867a2846fefb68bd5f178daf4da3095ccb/Documentation/kube-flannel.yml -O

一定要改镜像！打tag
docker tag k8s.gcr.io/flannel:v0.10.0-amd64 quay.io/coreos/flannel:v0.10.0-amd64


kubectl apply -f kube-flannel.yml

查看pods是否在运行
root@master:~# kubectl get pods --all-namespaces
NAMESPACE     NAME                             READY   STATUS    RESTARTS   AGE
kube-system   coredns-86c58d9df4-9h9sw         1/1     Running   0          50m
kube-system   coredns-86c58d9df4-t9s9d         1/1     Running   0          50m
kube-system   etcd-master                      1/1     Running   0          49m
kube-system   kube-apiserver-master            1/1     Running   0          49m
kube-system   kube-controller-manager-master   1/1     Running   0          49m
kube-system   kube-flannel-ds-amd64-m89kt      1/1     Running   0          2m24s
kube-system   kube-proxy-ln4qs                 1/1     Running   0          50m
kube-system   kube-scheduler-master            1/1     Running   0          49m


root@master:~# kubectl get nodes
NAME     STATUS   ROLES    AGE   VERSION
master   Ready    master   52m   v1.13.1

--------------master初始化结束



用kubeadm部署node1
注意node也要打flannel的tag

----------------------kubeadm安装dashboard
在master安装dashboard
先拉取镜像
docker pull registry.cn-beijing.aliyuncs.com/kubernetesdevops/kubernetes-dashboard-amd64:v1.10.0
或者用这个：
 docker pull registry.cn-shanghai.aliyuncs.com/coolyeah/kubernetes-dashboard-amd64:v1.10.1

再tag一下
docker tag registry.cn-beijing.aliyuncs.com/kubernetesdevops/kubernetes-dashboard-amd64:v1.10.0 k8s.gcr.io/kubernetes-dashboard-amd64:v1.10.0

去github找yaml文件：
https://github.com/kubernetes/dashboard/tree/v1.10.0
把yaml下载下来
curl -O https://raw.githubusercontent.com/kubernetes/dashboard/v1.10.0/src/deploy/recommended/kubernetes-dashboard.yaml

apply一下
kubectl apply -f kubernetes-dashboard.yaml
查看一下：
kubectl get pods --all-namespaces
发现起不来，再看一下详细情况：
 kubectl describe pods kubernetes-dashboard-79ff88449c-w55xl -n kube-system
发现Error:ErrImagePull
Failed to pull image "k8s.gcr.io/kubernetes-dashboard-amd64:v1.10.0": rpc error: code = Unknown desc = Error response from daemon: Get https://k8s.gcr.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
原来这个在node1上，所以node1，也要这个dashboard的image

可以delete掉：
kubectl delete -f kubernetes-dashboard.yaml

重新apply：
kubectl apply -f kubernetes-dashboard.yaml

查看一下：
kubectl get pods --all-namespaces
kubectl describe pods  kubernetes-dashboard-79ff88449c-554h9 -n kube-system

查看一下dashboard暴露的端口：
kubectl get service --namespace=kube-system

准备访问master的443端口：
http://192.168.134.130:443  发现访问不了
可以在161行新增nodePort:31234
164行新增type: NodePort  ,用nodePort方式启动
-------比如：
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kube-system
spec:
  ports:
    - port: 443
      targetPort: 8443
      nodePort:31234
  selector:
    k8s-app: kubernetes-dashboard
  type: NodePort
-----比如结束

删除dashboard：
kubectl delete -f kubernetes-dashboard.yaml

重建:
kubectl apply -f kubernetes-dashboard.yaml

查看svc：
root@master:~# kubectl get svc --namespace=kube-system
NAME                   TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)         AGE
kube-dns               ClusterIP   10.96.0.10      <none>        53/UDP,53/TCP   26h
kubernetes-dashboard   NodePort    10.109.246.38   <none>        443:31234/TCP   3s

访问master机器的31234端口：
https://192.168.2.150:31234

令牌,先要获取令牌：
kubectl get secret -n kube-system
发现kubernetes-dashboard-token-p9kvp
kubectl describe secret kubernetes-dashboard-token-p9kvp -n kube-system
把很长的token输入到web界面里
登陆进去发现有黄色告警信息

vim kube-user.yml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin
  namespace: kube-system
  labels:
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: admin
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
subjects:
  - kind: ServiceAccount
    name: admin
    namespace: kube-system
roleRef:
  kind: ClusterRole
  name: cluster-admin
  apiGroup: rbac.authorization.k8s.io

kubectl apply -f kube-user.yml
这次grep admin:
kubectl get secret -n kube-system | grep admin
最后获取令牌：
kubectl describe secret admin-token-q42p6 -n kube-system
登出web，重新用令牌登陆



小技巧：
拉取别人的镜像，放到自己的来云上面。
先pull 如：
docker pull registry.cn-beijing.aliyuncs.com/kubernetesdevops/kubernetes-dashboard-amd64:v1.10.0
再tag:
docker tag registry.cn-beijing.aliyuncs.com/kubernetes-alex/kubernetes-dashboard-amd64:v1.10.0
登陆仓库：
docker login registry.cn-beijing.aliyuncs.com
最后push上去
docker push registry.cn-beijing.aliyuncs.com/kubernetes-alex/kubernetes-dashboard-amd64:v1.10.0

=============================

kubectl命令行工具常用命令运营
# kubectl命令


## 命令行语法
    kubectl [command ]  [TYPE] [NAME] [flags]
    
    command: create/delete/get/describe/apply
    type: 资源对象类型,严格区分大小写。   
    name: 资源对象的名称，严格区分大小写。
    flags: 可选参数  -n 指定namespaces

## 资源对象类型
    daemonsets   ds
    deployments 
    events    ev  事件
    endpoints  ep  
    horizontalpodautoscalers   hpa    水平扩展
    ingresses   ing
    jobs
    nodes   no
    namespaces ns
    pods po
    persistentvolumes pv   物理卷
    persistentvolumesclaims   pvc   物理卷组
    resourcequotas  quota
    replicationcontrollers rc
    secerts 
    service   svc
    serviceaccounts sa

## 练习
同时查看多种资源对象
```
kubectl get pod/etcd-master.example.com  svc/kubernetes-dashboard -n kube-system
```



## kubectl 子命令
    annotate  添加或者更新资源对象的信息
    apply  kubectl apply -f filename    从配置文件更新资源对象
    attach  kubectl attach pod -c container 链接正在运行的pod
    cluster-info kubectl cluster-info  显示集群信息
    completion kubectl completion bash 输出shell命令执行后的返回码
    config kubectl config get-clusters  修改kubeconfig配置文件
    create kubectl create -f kube-user.yml 从配置文件创建资源对象
    delete kubectl delete -f kube-user.yml  从配置文件删除资源对象
    describe  kubectl describe sa  查看资源对象的详细信息
    edit kubectl edit sa 编辑资源对象的属性
    exec kubectl exec coredns-86c58d9df4-d8x49 ls -n kube-system   执行一个容器中的命令
    label kubectl label node node1.example.com a=b  为资源对象创建label标记



------------------------------------------
通过yaml创建pod对象
小技巧：
查看其他pod的情况并用yaml方式显示出来
kubectl edit pod coredns-86c58d9df4-9h9sw -n kube-system
学习怎么写yaml可以查看github kubernetes的handbook
https://github.com/feiskyer/kubernetes-handbook
https://github.com/kubernetes/examples
https://github.com/kubernetes/examples/tree/master/guestbook

小技巧：
改名所有下下来的tag：
 for i in `docker images|grep gcr|awk '{print $1":"$2}'|cut -d"/" -f2`;do docker tag k8s.gcr.io/$i registry.cn-shanghai.aliyuncs.com/alexhjl/$i;done
上传到阿里云的镜像仓库：
 for i in `docker images |grep shanghai`;do docker push $i;done

创建一个nginx.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: registry.xxx.com/nginx:latest
    imagePullPolicy: IfNotPresent
    ports:
    - containerPort: 80

IfNotPresent，当本地镜像不存在时会pull

kubectl create -f nginx.yaml
如果不指定namespace 会在当前的namespace中创建pod
kubectl get pod
查看pod在哪个node运行：
kubectl describe pod nginx
删除pod：
kubectl delete pod nginx   或者 kubectl delete -f nginx.yaml


master节点为什么不运行pod？
因为master节点有个标记，kubectl get node --show-labels 可以显示所有标记


pod的生命周期：
Pending： 记录状态  下载镜像
Running：调度完成 
Successed: 程序终止  
Failed: 有未终止容器
Unknown:
kubectl先根据yaml定义来创建pod，pod的相关信息存入到etcd上。apiserver返回确认的信息给客户端。apiserver开始查询etcd中的状态变化，调度器就会查看资源对象是否绑定到哪个节点，没有绑定节点就会为pod挑选一个节点，调度到这个节点上来。如果已经定义了绑定到存在的节点中，则调度器调度到节点中，调度成功后把状态结果反馈到etcd。


kubernetes设计理念
pdf 第49页

kubernetes核心技术概念和api对象
pdf第51页

k8s核心组件与通信端口
pdf58页

kube-apiserver原理分析：
kubectl api-versions //查询api支持的版本
root@master:~# kubectl api-versions
admissionregistration.k8s.io/v1beta1
apiextensions.k8s.io/v1beta1
apiregistration.k8s.io/v1
apiregistration.k8s.io/v1beta1
apps/v1
apps/v1beta1
apps/v1beta2
authentication.k8s.io/v1
authentication.k8s.io/v1beta1
authorization.k8s.io/v1
authorization.k8s.io/v1beta1
autoscaling/v1
autoscaling/v2beta1
autoscaling/v2beta2
batch/v1
batch/v1beta1
certificates.k8s.io/v1beta1
coordination.k8s.io/v1beta1
events.k8s.io/v1beta1
extensions/v1beta1
networking.k8s.io/v1
policy/v1beta1
rbac.authorization.k8s.io/v1
rbac.authorization.k8s.io/v1beta1
scheduling.k8s.io/v1beta1
storage.k8s.io/v1
storage.k8s.io/v1beta1
v1

kubectl api-resources --api-group=apps/v1     //查询资源对象

kubectl get --raw /api/v1/namespaces

kubectl proxy --port=8080 &      //开启本地代理网关，也可以不加--port=8080


----------------------------
kubernetes scheduler
负责pod的生命周期中的后半部分。
通过apiserver查询未分配node的pod，根据调度策略调度pod。
通常通过RC/Deployment/Daemonset/Job完成pod的调度。

scheduler工作原理：
1.API创建新的pod
2.Controller Manager 补充pod的副本
3.Scheduler 按照特定的调度算法绑定到集群中匹配的node上
4.绑定成功，将绑定信息写入etcd

scheduler节点调度：
nodeSelector（定向调度）：
    调度到label匹配的node节点中
nodeAffinity（亲和性调度）：
    调度到label匹配的node节点中（可以设置优选，匹配更丰富）
    requiredDuringSchedulingRequiredDuringExecution（类似于selector）
    requiredDuringSchedulingIgnoredDuringExecution   (满足条件)
    preferredDuringSchedulingIgnoredDuringExecution（优选条件）
podAffinity：
    调度到匹配的pod运行的node节点中。

nodeAffinity
requiredDuringSchedulingRequiredDuringExecution： 当pod不满足条件时，系统将从该node上移除之前调度的pod。
requiredDuringSchedulingIgnoredDuringExecution：与上面类似，区别： 当node条件不满足时，系统不一定要从该node上移除之前调度的pod。
preferredDuringSchedulingIgnoredDuringExecution： 指定在满足调度条件的node中，那些node应该更优先的进行调度。 同时当node不满足条件时，系统不一定从移除之前调度的pod。

给node节点创建label标记
kubectl label nodes node01.example.com cpucounts=four
查看node的标记
kubectl get nodes --show-labels

在资源对象中添加调度设置
spec:
  nodeSelector:
      cpucounts: four

实验步骤：
1.创建一个pod，添加调度信息。
2.查看pod的运行状态
3.给node节点创建匹配的label
4.验证pod运行正常

如果没有匹配的node，Pod状态将会一直处于pending状态。

cat nodeselector_nginx.yaml   上面给node01带了个标签cpucounts=four,这里就会匹配到
apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  nodeSelector:
    cpucounts: four
  containers:
  - name: nginx
    image: docker.io/library/nginx     
    imagePullPolicy: IfNotPresent
    ports:
    - containerPort: 80

kubectl apply -f nodeselector_nginx.yaml
如果不启动，describe一下看详细情况
kubectl describe pod nginx

 cat nodeAffinity-R.yaml  当前pod调度到拥有标签area=test1/test2的节点上
apiVersion: v1
kind: Pod
metadata:
  name: testschduler
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: area
            operator: In
            values:
            - test1
            - test2
  containers:
  - name: myapp
    image: nginx
requiredDuringSchedulingIgnoredDuringExecution： 
    1.值为一个对象列表，由一个到多个nodeSelectorTerm定义的对象组成。
    2.多个nodeSelectorTerm之间只要满足其中一个即可。

nodeSelectorTerm： 
    1.用于定义节点选择器条目，由一个或多个matchExpressions对象定义的匹配规则组成。
    2.规则之间 逻辑与关系，必须满足一个nodeSelectorTerm下的所有matchExpressions。

matchExpressions：
    由一个或多个标签选择器组成
operator: 
    标签选择器表达式中的操作符
    常用： In NotIn Exists DoesNotExist Lt Gt






cat nodeAffinity-P.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: testschduler
spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - wight: 90
        preference:
          matchExpressions:
          - key: area
            operator: In
            values:
            - test1
            - test2
      - wight: 80
        preference:
          matchWxpressions:
          - key: vm
            operator: Exists
            values: []

  containers:
  - name: myapp
    image: nginx
当前pod调度到拥有标签
area=test1/test2 或者存在vm标签的节点上。

wight=170  area=test1 vm=true
wight=90 area=test1 
wight=80 vm=true








cat podAffinity-R.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: testschduler
spec:
  affinity:
    podAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
        matchExpressions:
          - key: area
            operator: In
            values:
            - test1
            - test2
        topologyKey: kubernetes.io/hostname
通过labelSelector选择pod，根据pod对象所在 


--------------------------------------------
Controller manager
由kube-controller-manager 和cloud-controller-manager组成。
controller manager是 kubernetes的大脑。
通过apiserver监控整个集群的状态，确保符合预期状态。



Metrics 度量： （性能参数）
controller manager metrics 提供了控制器内部逻辑的性能度量。
默认监听 10252端口（prometheus）

Go语言运行时度量
etcd请求延时
云服务提供商API请求延时

访问： http://localhost:10252/metrics

------------------------------------------------
kubelet
每个节点都运行一个kubelet进程，默认端口10250。
接受并执行master发来的指令，管理pod和其中的容器。
每个kubelet都会向apiserver注册自身信息。
定期向master节点汇报当前节点的情况。
通过cAdvisor监控节点和容器的资源。

kubelet监听10250端口



容器健康检查：
LivenessProbe探针
用于判断容器是否健康。如果探测不健康则通过kubelet删除该容器。
如果一个容器不包含探针kubelet会认为值为success。

ReadinessProbe
用于判断容器是否启动完成且准备接收请求。如果探测到失败，则pod的状态被修改。

来诊断容器的健康状态。kubelet定期调用容器中的livenessprobe探针

实现方式
ExecAction: 在容器内部执行一条命令，如果退出状态码为0，则表明容器健康。
TCPSocketAction: 通过容器的IP地址和端口号执行TCP检查，如果端口能够被访问则表明容器健康。
HTTPGetAction: 通过容器的IP地址和端口及路径调用HTTP GET方法，如果状态码大于等于200且小于400，则认为容器健康。



cAdvisor资源监控：
一个开源的分析容器资源使用率和性能特性的代理工具。
自动查找所有在其所在的节点上的容器，自动采集CPU、内存、文件系统和网络使用的统计信息。
cAdvisor通过其所在的节点机的4194端口暴露一个UI。


cr容器运行时：container runtime
容器运行时是Kubernetes最重要的组件之一。
负责真正管理镜像和容器的生命周期。
kubelet通过CRI与容器运行时交互，以管理镜像和容器。


获取node的性能指标
看看各node上面有没有10255端口，如果没启动的话。
可以修改
 vim /var/lib/kubelet/kubeadm-flags.env 
加入
--read-only-port=10255
完整行：
KUBELET_KUBEADM_ARGS=--read-only-port=10255 --cgroup-driver=cgroupfs --network-plugin=cni --pod-infra-container-image=k8s.gcr.io/pause:3.1 --resolv-conf=/run/systemd/resolve/resolv.conf
systemctl restart kubelet
或者：
vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
添加一行
Environment="KUBELET_API=--read-only-port=10255"
修改一行
ExecStart=/usr/bin/kubelet $KUBELET_API $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_KUBEADM_ARGS $KUBELET_EXTRA_ARGS
完整文件：-------------完整文件开始
# Note: This dropin only works with kubeadm and kubelet v1.11+
[Service]
Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf"
Environment="KUBELET_CONFIG_ARGS=--config=/var/lib/kubelet/config.yaml"
# This is a file that "kubeadm init" and "kubeadm join" generates at runtime, populating the KUBELET_KUBEADM_ARGS variable dynamically
EnvironmentFile=-/var/lib/kubelet/kubeadm-flags.env
Environment="KUBELET_API=--read-only-port=10255"
# This is a file that the user can use for overrides of the kubelet args as a last resort. Preferably, the user should use
# the .NodeRegistration.KubeletExtraArgs object in the configuration files instead. KUBELET_EXTRA_ARGS should be sourced from this file.
EnvironmentFile=-/etc/default/kubelet
ExecStart=
ExecStart=/usr/bin/kubelet $KUBELET_API $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_KUBEADM_ARGS $KUBELET_EXTRA_ARGS
------------------------完整文件结束
systemctl daemon-reload
systemctl restart kubelet
最后就能通过链接获取该主机的所有状态性能
curl 192.168.2.151:10255/stats/summary



--------------------------------------------------------------------------------
docker视频教程
-------------------------------
Prometheus视频
https://github.com/aaron111com/Jenkinsdocs/blob/master/chapter/Prometheus%E5%AE%89%E8%A3%85%E9%83%A8%E7%BD%B2+%E7%9B%91%E6%8E%A7+%E7%BB%98%E5%9B%BE+%E5%91%8A%E8%AD%A6.md

1.安装node_export在/usr/local
tar zxvf node_exporter-0.18.1.linux-amd64.tar.gz -C /usr/local/

vim /etc/systemd/system/node_exporter.service
[Unit]
Description=node_exporter
After=network.target

[Service]
Restart=on-failure
ExecStart=/usr/local/node_exporter-0.18.1.linux-amd64/node_exporter

[Install]
WantedBy=multi-user.target

systemctl start node_export
systemctl status node_exporter
systemctl enable node_exporter
netstat -ntulp| grep 9100    #node_exporter 监听9100端口
浏览器可以访问http://192.168.2.150:9100/metrics


2.安装prometheus
tar zxvf prometheus-2.12.0.linux-amd64.tar.gz -C /usr/local/
vim /etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus Server
Documentation=https://prometheus.io/docs/introduction/overview/
After=network-online.target

[Service]
Restart=on-failure
ExecStart=/usr/local/prometheus-2.12.0.linux-amd64/prometheus --config.file=/usr/local/prometheus-2.12.0.linux-amd64/prometheus.yml --storage.tsdb.path=/var/lib/prometheus --web.external-url=http://0.0.0.0:9090

[Install]
WantedBy=multi-user.target

systemctl start prometheus
netstat -ntulp| grep 9090
systemctl enable prometheus

静态配置添加一台主机：
vim /usr/local/prometheus-2.12.0.linux-amd64/prometheus.yml
# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
  - static_configs:
    - targets:
      # - alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
    - targets: ['localhost:9090']
  # add custom monitor job,monitor node_exporter 通过静态方式添加一台主机，监控node_expoter
  - job_name: "my target"                   
    static_configs:
    - targets: ['localhost:9100'] 

添加完，重启prometheus
systemctl restart prometheus

打开浏览器页面
http://192.168.2.150:9090
访问status->targets


服务发现：
动态发现，事业云环境，动态伸缩，迅速配置。
kubernetes为例：
需要配置api的地址和认证凭据。
prometheus一直监听集群的变化
获取新增/删除集群中机器的信息，并更新采集对象列表。


prometheus数据存储：
本地存储：通过自带的时序数据库将数据保存到本地的磁盘。
远端存储：适用于存储大量的监控数据，支持opentsdb，influxdb，elasticsearch等后端存储。通过适配器实现存储的远程读写接口，便可以监控。


安装grafana
https://mirrors.tuna.tsinghua.edu.cn/help/grafana/
Debian / Ubuntu 用户
首先信任 https://packages.grafana.com/ 的 GPG 公钥:
curl https://packages.grafana.com/gpg.key | sudo apt-key add -

确保你的 apt 支持 HTTPS:
sudo apt-get install -y apt-transport-https
选择你希望安装的 Grafana 版本（与你的 Debian/Ubuntu 系统版本无关），文本框中内容写进 /etc/apt/sources.list.d/grafana.list

你的 Grafana 版本: 
deb https://mirrors.tuna.tsinghua.edu.cn/grafana/apt/ stable main
安装 Grafana
sudo apt-get update
sudo apt-get install grafana
启动：
systemctl start grafana-server
访问3000端口
192.168.2.150:3000

添加数据源
Prometheus，黏贴地址，dashboard里导入3个

访问这个装主机监控插件，监控cpu，内存，磁盘，网络
https://grafana.com/dashboards/9276
导入grafana：
选择dashboard
import，然后导入json。



数据告警：
alertmanager
 tar zxvf alertmanager-0.19.0.linux-amd64.tar.gz -C /usr/local/
 cat /etc/systemd/system/alertmanager.service
[Unit]
Description=Alertmanager
After=network-online.target

[Service]
Restart=on-failure
ExecStart=/usr/local/alertmanager-0.19.0.linux-amd64/alertmanager --config.file=/usr/local/alertmanager-0.19.0.linux-amd64/alertmanager.yml

[Install]
WantedBy=multi-user.target

systemctl start alertmanager
systemctl enable alertmanager

netstat -ntulp| grep 9093

浏览器访问http://192.168.2.150:9093
修改Prometheus的配置文件：
root@master:/usr/local/prometheus-2.12.0.linux-amd64# cat prometheus.yml 
# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
  - static_configs:
    - targets:
      - localhost:9093         #修改成alertmanager的地址

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  - "rules/host_rules.yml"     #新建文件夹rules和下面yml
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
    - targets: ['localhost:9090']
  # add custom monitor job,monitor node_exporter 
  - job_name: "my target"                   
    static_configs:
    - targets: ['localhost:9100']


mkdir rules
vim rules/host_rules.yml
groups:
- name: 'Linux Instances'
  rules:
  - alert: InstanceDown
    expr: up == 0
    for: 5s
    labels:
      severity: page
   # Prometheus templates apply here in the annotation and label fields of the alert.
    annotations:
      description: 'has been down for more than 5 s.'
重启Prometheus
systemctl restart prometheus

这时候把node_exporter关掉
systemctl stop node_exporter
prometheus的界面就会报警

如果要配置邮件报警：
alertmanager需要配置一下，
global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.qq.com:465'
  smtp_from: 'xxxxx@qq.com'
  smtp_auth_username: 'xxxx@qq.com'
  smtp_auth_password: 'xxxkbpfmygbecg'
  smtp_require_tls: false

route:
  group_by: ['alertname']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 1h
  receiver: 'toemail'
receivers:
- name: 'toemail'
  email_configs:
  - to: 'xxxxx@qq.com'
    send_resolved: true
- name: 'web.hook'
  webhook_configs:
  - url: 'http://127.0.0.1:5001/'
inhibit_rules:
  - source_match:
      severity: 'critical'
    target_match:
      severity: 'warning'
    equal: ['alertname', 'dev', 'instance']

systemctl restart alertmanager