kubernetes_tb宝满

叁歲伎倆 2023-08-17 17:12 73阅读 0赞

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]
        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

转载于:https://www.cnblogs.com/alexhjl/p/11437752.html