存档2021

Freeradius 验证服务器




Freeradius 验证服务器 安装


    # yum install freeradius freeradius-mysql freeradius-utils

    # vim /etc/raddb/clients.conf
        secret = testing123                     \\ [secret key]      重要 测试的时候使用
        client all {
         ipaddr = 0.0.0.0/0                       \\ 配置 监听的 地址 
         secret = test123                          \\ 配置 密码
         require_message_authenticator = no
        }

    # vim /etc/raddb/users                           \\ 仅仅为 测试用户为 steve  测试用户名密码 为test123
        steve   Cleartext-Password := "test123"
            Service-Type = Framed-User,
            Framed-Protocol = PPP,                      \\ 验证类型
            Framed-IP-Address = 127.0.0.1,
            Framed-IP-Netmask = 255.255.255.0,
            Framed-Routing = Broadcast-Listen,
            Framed-Filter-Id = "std.ppp",
            Framed-MTU = 1500,
            Framed-Compression = Van-Jacobsen-TCP-IP

    # radiusd -X                                        \\ 测试  调试模式 可以看到报错等信息
    # radtest steve test123 localhost 1812 testing123    \\ 测试 radtest [账号] [密码] [地址] [端口] [secret key]:
        Received Access-Accept                            \\ 新开窗口 有此返回说明成功

    # systemctl restart radiusd
    # systemctl status radiusd
    # ss -unl                       \\ 1812 1813被监听  需防火墙放行
    # systemctl stop radiusd


Freeradius  连接 数据库

    # cd /etc/raddb/mods-config/sql/main/mysql/
    # mysql -uroot -p
        CREATE DATABASE radius;
        GRANT ALL ON radius.* TO radius@localhost IDENTIFIED BY "123456";
        use radius
        source schema.sql
        INSERT INTO radcheck (UserName, Attribute, op, Value)VALUES ('user1', 'Cleartext-Password',':=', 'password1');
        flush privileges;                      \\ 创建 测试 用户
    # cd /etc/raddb/mods-enabled/
    # ln -s ../mods-available/sql ./          \\ 相当于在Freeradius开启sql功能模块
    # vim /etc/raddb/mods-available/sql
        driver = "rlm_sql_mysql"
        dialect = "mysql"
        server = "127.0.0.1"
        port = 3306
        login = "radius"               \\ 用户名
        password = "123456"             \\ 数据库密码
        radius_db = "radius"             \\ 认证数据库
        read_clients = yes                \\ 允许radius读取数据库里面的nas信息
        client_table = "nas"               \\ 指定存储nas信息的表
    # radiusd -X
    # radtest user1 password1 localhost 1812 testing123
        Received Access-Accept                            \\ 新开窗口 有此返回说明成功






        

K8S 搭建




kubernetes    k8s    ...未完成待续



Kubectl 命令自动补全
    # yum install bash-completion
    # echo 'source /usr/share/bash-completion/bash_completion' >> /etc/profile
    # echo 'source <(kubectl completion bash)' >> /etc/profile
    # source /etc/profile


https://github.com/kubernetes/kubernetes





https://github.com/kubernetes/kubernetes/releases  --> Additional binary downloads are linked in the CHANGELOG. --> Downloads for v1.20.2


Server binaries



master  node 都是用的 server端




kubernetes 安装


# cd /etc/yum.repos.d
# wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo             \\ 可地址来源 见备注


# cat <<EOF > /etc/yum.repos.d/kubernetes.repo                                          \\ 阿里云的 yum 源
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF




# yum install docker-ce kubelet kubeadm kubectl
# systemctl daemon-reload
# systemctl enable docker
# systemctl restart docker
# cat /proc/sys/net/bridge/bridge-nf-call-iptables             \\ 确保此值为 1
# cat /proc/sys/net/bridge/bridge-nf-call-ip6tables             \\ 确保此值为 1

# rpm -ql kubelet                              \\ 安装生成的文件
    /etc/kubernetes/manifests                   \\ 清单目录
    /etc/sysconfig/kubelet                       \\ 主配置文件
    /usr/bin/kubelet                              \\ 主程序
    /usr/lib/systemd/system/kubelet.service
# systemctl start kubelet
# systemctl status kubelet             \\ 未启动成功
# tail /var/log/messages                \\ 查看 日志
# systemctl stop kubelet
# systemctl enable kubelet

# kubeadm init --help                    \\ 初始化 帮助

# vim /etc/sysconfig/kubelet
    KUBELET_EXTRA_ARGS="--fail-swap-on=false"          \\ k8s默认不允许使用交换分区 如有交换分区可加此选项 不让报错




# kubeadm init --pod-network-cidr=10.244.0.0/16 --service-cidr=10.96.0.0/12 --ignore-preflight-errors Swap
    kubeadm join 172.21.34.201:6443 --token g2mbcl.tluo55j437cbd4xp \
        --discovery-token-ca-cert-hash sha256:4ecb8cb6432a900c33e0a5a6a834c54dab34ec8d9bf6051cc86192644f10ee1d

# docker image ls         \\ 会有7个镜像
# ss -tnl                  \\ 6443
# mkdir -p $HOME/.kube
# cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# kubectl get -h               \\ 查询命令  get 帮助命令
# vim /etc/kubernetes/manifests/kube-scheduler.yaml
    #    - --port=0              \\ 注释掉这行
# vim /etc/kubernetes/manifests/kube-controller-manager.yaml
    #    - --port=0                \\ 注释掉这行
# kubectl get cs                    \\ 组件状态信息 如不注释掉上面 port=0 会报错

# kubectl get nodes                   \\ 查看 所有节点

# kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml  \\ flannel 部署
# docker image ls                      \\ 有 flannel 镜像
# kubectl get ns                        \\ 查看系统的 名称空间
# kubectl get pods -n kube-system        \\ flannel 正常运行 -n指定名称空间  没有-n是默认名称空间
    kube-flannel-ds-cnflp                           1/1     Running   0          13m


节点

    # hostnamectl set-hostname node01
    # vim /etc/hosts
        172.21.34.202 node01
    # scp 172.21.34.201:/etc/yum.repos.d/docker-ce.repo /etc/yum.repos.d/
    # scp 172.21.34.201:/etc/yum.repos.d/kubernetes.repo /etc/yum.repos.d/             \\ 复制到其他的两个节点
    # yum install docker-ce kubelet kubeadm kubectl

    # scp 172.21.34.201:/usr/lib/systemd/system/docker.service /usr/lib/systemd/system/docker.service    \\ 拉取 启动文件到节点
    # scp 172.21.34.201:/etc/sysconfig/kubelet /etc/sysconfig/kubelet                                     \\ 拉取 配置文件到节点

    # systemctl enable docker kubelet
    # systemctl start docker
    # kubeadm join 172.21.34.201:6443 --token gy0741.18zxk1skak3x6kop --discovery-token-ca-cert-hash sha256:4ecb8cb6432a900c33e0a5a6a834c54dab34ec8d9bf6051cc86192644f10ee1d --ignore-preflight-errors=Swap
    # docker image ls                     \\ 会有3个镜像


# kubectl get nodes                          \\ 有显示 node01节点 说明节点已经启动成功
# kubectl get pods -n kube-system -o wide





注: 
    阿里云 docker-ce 镜像地址:  https://mirrors.aliyun.com/docker-ce/  -->  linux --> centos --> docker-ce.repo

    https://mirrors.aliyun.com/kubernetes/ --> yum --> repos --> kubernetes-el7-x86_64 --> 

    flannel 网址: https://github.com/coreos/flannel

    如果提示 error execution phase preflight ... ... 错误  可能使 token 过期 或者不对 可以到 master上重新生成
        # kubeadm token create
            424mp7.nkxx07p940mkl2nd
        # openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'
            d88fb55cb1bd659023b11e61052b39bbfe99842b0636574a16c76df186fd5e0d








# kubectl run n1 --image=nginx --port=80
# kubectl get pods -o wide                   \\ -o wide 显示更多的信息   可以看到在node01上面运行的nginx 
    NAME   READY   STATUS    RESTARTS   AGE   IP           NODE     NOMINATED NODE   READINESS GATES
    n1     1/1     Running   0          29m   10.244.1.2   node01   <none>           <none>
# curl 10.244.1.2                              \\ master及节点中的机器都可以访问





.......................................................................................................................

待整理  014 kubernetes应用快速入门-QwQbP9FaLbI.mp4


# kubectl cluster-info          \\ 查看整个 k8s 集群的信息



# kubectl create deployment n1 --image=nginx   \\ 使用 deployment 创建名字为 n1的 pods 镜像是 nginx
# kubectl get deployment                        \\ 查看 deployment
# kubectl get pods -o wide                       \\ 查看 pods
    NAME                  READY   STATUS    RESTARTS   AGE     IP           NODE     NOMINATED NODE   READINESS GATES
    n1-5669f9c9d7-2wc9g   1/1     Running   0          3m43s   10.244.2.3   node02   <none>           <none>

# kubectl delete pod n1-5669f9c9d7-2wc9g           \\ 删除 n1-5669f9c9d7-2wc9g 这个 pods
# kubectl get pod -o wide                           \\ 会看到 自动重新创建了 pods   名字及ip都会改变
    NAME                  READY   STATUS    RESTARTS   AGE   IP           NODE     NOMINATED NODE   READINESS GATES
    n1-5669f9c9d7-g55cb   1/1     Running   0          83s   10.244.1.4   node01   <none>           <none>


# kubectl expose               \\ 暴露


通过标签 和标签选择器 来创建 不是基于地址来创建的


# kubectl run n2 --image=nginx --port=80 --replicas=1 --dry-run=true




# kubectl expose deployment n1 --name=nginx1 --port=80 --target-port=80 --protocol=TCP

# kubectl get svc       \\ 查看服务  全称为 kubectl get services


# kubectl get pods -n kube-system -o wide    \\ 显示 DNS 

# kubectl get svc -n kube-system              \\ 可以看到DNS服务器为10.96.0.10
    kube-dns   ClusterIP   10.96.0.10   <none>        53/UDP,53/TCP,9153/TCP   6h5m



# kubectl run b1 --image=busybox --replicas=1 -it --restart=Never      \\ 创建个 客户端 pod b1基于镜像busybox   --restart=Never 如果pod b1 关掉了不自动重新创建
    cat /etc/resolv.conf          \\ DNS服务器是 10.96.0.10
        nameserver 10.96.0.10









# kubectl get pods --show-labels       \\ 显示pod是时候 显示标签




# kubectl edit svc nginx1           \\ 编辑服务器 nginx1
 


# kubectl delete svc nginx1      \\ 删除服务器 nginx1
# kubectl get svc                 \\ nginx1 已经删除



# kubectl describe deployment n1


# kubectl get deployment -w     \\ 不会退出 监控状态


# kubectl scale --replicas=5 deployment myapp

..........................................................................................................................

资源 对象

workload工作负载型资源: pod   replicaset   deployment  statefulset daemonset  cronjob 
服务发现及均衡   service  ingress
配置与存储       volume csi   
    configmap secret
    downwardapi
集群级资源 

- "echo $(date) >> /usr/share/nginx/html/index.html; sleep 5"   \\ 运行的命令


大部分资源的配置清单




使用yaml清单 创建pods 一个 pods 中 创建 两个容器

    # kubectl explain pods        \\ 显示pods版本
        KIND:     Pod
        VERSION:  v1
    # vim pod-demol.yaml             \\ 注意 大小写
        apiVersion: v1                \\ 版本
        kind: Pod                      \\ 类型
        metadata:                       \\ 定义元数据
          name: p1                       \\ 名字
          namespace: default              \\ 名称空间 默认
          labels:                          \\ 标签    类型是<map[string]string> 是映射
            app: mynginx                    \\ 随便写
            tier: frontend                   \\ 所属的层次 前端    随便写
        #  labels: {app:myapp, tier:frontend  \\ 所有的映射的数据都可以使用 花括号给出来 例如此
        spec:                            \\ 规格
          containers:                     \\ 容器 类型为<[]Object>
          - name: nginx1                   \\ 容器名  对象列表<[]Object> 使用 - 横线来引导 此为第一个容器
            image: nginx:latest             \\ 镜像
          - name: busybox1                   \\ 此为第二个容器   一个pods里面可以 有多个容器   辅助主容器工作
            image: busybox:latest
            command:                           \\ 额外修改第二个容器的 运行的命令  是个  对象列表<[]Object> 类型
            - "/bin/sh"                         \\ 
            - "-c"                               \\ 传递的第一个参数 -c
            - "sleep 3600"                        \\ 运行的命令
        #    command: ["/bin/sh","-c","sleep 3600"]          \\ 所有的列表 都可以使用 中括号给出来 例如此
                   
    # kubectl create -f p1.yaml         \\ 基于 yaml配置文件 创建 pods
        NAME       READY      STATUS      RESTARTS      AGE
        p1          2/2       Running        1          18s            \\ 2/2 为2个容器
    # kubectl get pods                     \\ 查看 pods
    # kubectl describe pods p1              \\ 显示 pods 的详细信息 会有ip等信息
    # curl 10.244.2.5
    # kubectl logs pod-demo nginx1            \\ 可查看nginx 日志
    # kubectl logs pod-demo busybox1           \\ 可看到 busybox1 日志
    # kubectl exec -it p1 -c nginx1 -- /bin/sh  \\ 可以连接 进去 nginx  p1为pods名  -- 与docker不一样 需要使用此符号 -c指明容器名
    # kubectl delete pods p1                     \\ 删除 pods  p1
    # kubectl create -f p1.yaml
    # kubectl get pods -w

    # kubectl delete -f p1.yaml                 \\ 亦可以 使用此 删除 p1.yaml 清单所创建的pods 此文件并不会删除 亦可在创建





注: 
    1. 关于 pods 的 yaml格式
        version: 版本
            group/version , 由 group和version组成 如果没有group 默认为core之意 为核心组 最根本的资源

            # kubectl api-versions      \\ 显示api 所支持的版本
                autoscaling/v1           \\ 稳定版 以后不会改变
                autoscaling/v2beta1       \\ beta 公测版本   以后可能会改变
                autoscaling/v2beta2

        kind:   资源类别
            pod

        metadata:  元数据
            name 名字
            namespace 名称空间
            labels 标签
            annotations 资源注解
            ownerReferences
            resourceVersion 
            uid                   唯一表示 系统自动生成
            selfLink 自引用

        spec: 规格 定义应该有什么样的特性  应该满足什么样的规范 由用户定义
            containers: 关于容器
                image: 镜像信息
        status: 显示当前资源的 当前状态    k8s会 把当前状态向目标状态 无限接近或转移 来能够满足用户需要  此项目 只读 

    2. 关于 pods 的定义格式

        # kubectl explain pods                \\ pods 资源 怎么定义
        # kubectl explain pods.metadata        \\ pods 中的 metadata 怎么定义
        # kubectl explain pods.spec
        # kubectl explain pods.spec.containers
        # kubectl explain pods.spec.containers.livenessProbe
            <Object>                  对象     需要嵌套很多二级字段的
            <[]Object>                对象列表     对象类型的数组
            <string>                  字符串
            <[]string>                字符串列表   字符串类型的数组
            <map[string]string>       映射 由键值组成的映射  另外一个jison 数组
                -required-            必选

        # kubectl get pods           \\ 查看pods
        # kubectl get pod n1-5669f9c9d7-g55cb -o yaml  \\ 查看pod n1的  yaml 








yaml清单 各个参数详解

apiVersion: v1
kind: Pod             # 类型为 Pod
metadata:              # 元数据
  name: p1              # 此为 pods 的名字
  namespace: default     # 名称空间 为 默认
  labels:                 # 标签
    # 标签1: 内容1          # 标签1 随便起 由字母 数字 _ - . 组成  只能字母或数字开头及结尾 中间可使用 下划线 杠杠 点
    app: mynginx            # 内容1 随便起 同上 但是可以为空
    tier: frontend
  annotations:          # 类似标签的功能 当不能 用于 标签选择   主要用于属性 注解等 
    nginx1: teo1         # 标注镜像的作者是teo1 而已
spec:                     # 规格 详解
  containers:              # <[]object>  关于容器的指令
  - name: nginx1            # <string>  此为 容器的名字
    image: nginx:latest      # <string> 此为 镜像的名字
    imagePullPolicy IfNotPresent   # <string>  下面为三个参数 此项创建后不允许更改 只能在创建前指定
                      # Alway 本地无论有没有 都去仓库下载   ... 如果标签为latest 则此项为默认值
                       # Never 本地有就用 没有也不去下载
                        # IfNotPresent 本地存在直接使用 本地没有才去仓库下载  ... 如果不是标签为latest的 此项为默认值
    ports:                    # 暴露端口 并不能真正意义上起到暴露端口的作用  真正暴露需要在server上定义
    - name: http               # 名字 随便起
      containerPore: 80         # 暴露 80     没指定协议 默认为 TCP协议
    - name: https
      containerPore: 443          # 暴露 443
    command: ["/bin/sh","-c","touch /tmp/healthy;sleep 30; rm -f /tmp/healthy; sleep 3600"]
                 # 第一种定义command的方式 如果没有提供command 会运行镜像中默认命令   ... 类似 dockerfile 中的entrypoint
    args:        # 这里的$() 为变量引用 相当于 shell中的 ${}   只当做参数来使用
                 # 1. 如果未定义 command 和args 则运行容器中的 entrypoint 和 cmd
                 # 2. 如果只定义了command 只运行 command ... 会忽略 entrypoint 和 cmd
                 # 3. 如果只定义了 args 则 使用entrypoint 当命令 args 当参数 ... 会忽略cmd
                 # 4. 如果定义了 command 和 args ... 会忽略 entrypoint 和 cmd

    livenessProbe:       # <Object> 探针1  存活探针 探测容器是否存活  容器的存活性探测方式
      exec:              # 执行一些命令 探针1.1 在容器内执行任意命令,并检查命令退出状态码,如果状态码为0,则探测成功,否则探测失败容器重启
        command: ["test","-e","/tmp/healthy"]  # 命令为    test -e 为文件是否存在
      httpGet:              # 请求一些资源 探针1.2 对容器的ip地址(指定的端口和路径)执行http get请求 响应码是2xx, 3xx,则探测成功。如果服务器没有响应或者返回错误响应则说明探测失败,容器将重启。
        port: 80            # <string> -required-   端口 必有的选项      
        path: \index.html   # <string>   
      tcpSocket             # 对套接字发请求 探针1.3 探针与容器指定端口建立tcp连接,如果连接建立则探测成功,否则探测失败容器重启。
      falureThreshold:         # 探测几次失败 我们在认为是 失败 默认为3次 最小值为1
      periodSeconds: 5         # 每次探测间隔多长时间  默认10s
      timeoutSeconds:          # 每次的超时 时间是多少 默认1s
      initialDelaySeconds: 10  # 初始化延迟探测的时间  在启动后多长时间进行探测 确保启动成功去探测 默认 容器一启动就探测

    readinessProbe       # <Object> 探针2  就绪性 探针  如果探测是吧 容器会 没有 就绪状态  详细看实例3  使用方式通 livenessProbe一样
    lifecycle            # <Object> 探针3  生命周期   定义启动后和终止前的钩子的
  - name: busybox1
    image: busybox:latest
    command:                # command 第二种定义的方式 一般使用此方式
    - "/bin/sh"             # 选择执行的 shell
    - "-c"                  # 参数
    - "sleep 3600"          # 执行的命令
  nodeName:                 # <string> 指定运行在哪一个节点
  nodeSelector:             # <map[string]string> 节点选择器
    disktype: ssd           # 此为标签 只运行在 disktype 标签的值为ssd 的 节点node上
  restartPolicy: OnFailure  # <string> 重新启动容器中所有容器的策略
                            # Always     总是重启  默认状态
                            # OnFailure  只有状态为错误的时候重启  正常停止不会重启
                            # Never      不重启



#    command: ["/bin/sh","-c","sleep 3600"]






实例1. 使用 livenessProbe.exec 探针 检测 存活状态 
    # kubectl explain pods.spec.containers.livenessProbe   \\ 可查看livenessProbe的 配置参数
    # vim p2.yaml
        apiVersion: v1
        kind: Pod
        metadata:
          name: p2
          namespace: default
        spec:
          containers:
          - name: liveness-exec-container
            image: busybox:latest
            imagePullPolicy: IfNotPresent
            command: ["/bin/sh","-c","touch /tmp/healthy;sleep 30; rm -f /tmp/healthy; sleep 3600"]
            livenessProbe:
              exec:
                command: ["test","-e","/tmp/healthy"]
              initialDelaySeconds: 2
              periodSeconds: 5
    # kubectl create -f p2.yaml     \\ 创建 pods p2
    # kubectl get pods -w            \\ 可观察 启动 ... 过大概一分钟 探针生效了 会重启此容器  
    # kubectl describe pods p2        \\ 描述信息  查看pods的 详细信息
    # kubectl delete pods p2           \\ 完事 可删除pods
  

实例2. 使用 livenessProbe.httpGet 
    # kubectl explain pods.spec.containers.livenessProbe.httpGet
    # vim p3.yaml
        apiVersion: v1
        kind: Pod
        metadata:
          name: p3
          namespace: default
        spec:
          containers:
          - name: liveness-httpget-container
            image: nginx:latest
            imagePullPolicy: IfNotPresent
            ports:
            - name: http                \\ 定义了端口的名字  以下可以使用http 代替80端口
              containerPort: 80          \\ 定义了端口为 80
            livenessProbe:
              httpGet:
                port: http                 \\ 此为定义端口  现为http是由于上面定义了端口的名字 http 的端口为80 此应用名字即可 
                path: /index.html           \\ 探针 要访问的 主页
              initialDelaySeconds: 2
              periodSeconds: 5

    # kubectl create -f p3.yaml                \\ 创建 pods p3
    # kubectl get pods
    # kubectl exec -it p3 -- /bin/sh             \\ 连入  p3
        # rm -f /usr/share/nginx/html/index.html  \\ 删除主页文件 为测试探针是否生效
    # kubectl get pods                             \\ 可看到 重启过一次
    # kubectl describe pods p3                      \\ 描述信息  查看pods的 详细信息  亦可看到重启过

    # kubectl delete -f p3.yaml                       \\ 测试完可删除 通过yaml文件删除 其所创建的pods
    # kubectl delete pods p3                           \\ 完事 可删除pods




实例3. 使用 readinessProbe.httpGet    \\ 使用 就绪性 探针  容器启动到就绪会有时间差  就绪意味着可以提供服务会直接关联到server上去
    # kubectl explain pods.spec.containers.readinessProbe.httpGet  \\ 所有 以后使用pods 几乎 必须 要做 此探针
    # vim p3.yaml
        apiVersion: v1
        kind: Pod
        metadata:
          name: p4
          namespace: default
        spec:
          containers:
          - name: readiness-httpget-container
            image: nginx:latest
            imagePullPolicy: IfNotPresent
            ports:
            - name: http
              containerPort: 80
            readinessProbe:
              httpGet:
                port: http
                path: /index.html
              initialDelaySeconds: 2
              periodSeconds: 5
    # kubectl get pods  \\ 会发现 1/1   右边的1 代表 容器的个数  左边的1代表 就绪的个数 也就是 正常的个数 如果不正常
        NAME                  READY   STATUS    RESTARTS   AGE
        p4                    1/1     Running   0          5m8s
    # kubectl exec -it p4 -- /bin/sh                   \\ 连接到P4
        # rm -f /usr/share/nginx/html/index.html        \\ 删除主页文件 为测试探针是否生效
    # kubectl get pods                                   \\ 会发现 0/1 左边为0 则探针已探测出没有主页文件
    # kubectl exec -it p4 -- /bin/sh                      \\ 连接到P4
        # echo "aaaa" >> /usr/share/nginx/html/index.html  \\ 创建文件
    # kubectl get pods                                      \\ 会发现 1/1   




实例4. 使用 lifecycle                                          \\ 钩子 探针    此项目不常用 了解工作方式即可
    # kubectl explain pods.spec.containers.lifecycle
    # kubectl explain pods.spec.containers.lifecycle.postStart  \\ pods启动后的 执行的操作 如此操作失败 会被终止 重启与否取决于重启策略
    # kubectl explain pods.spec.containers.lifecycle.preStop     \\ pods被终止之前 立即执行的命令 等此命令执行完了 pods才会终止
















...............................................................................................................

常用命令
    # kubectl get pods
    # kubectl get pods -w

    # kubectl delete p2
    # kubectl create -f p2.yaml


................................................................................................................



关于查看 标签 的命令
    # kubectl get pods --show-labels            \\ 查看所有pods的标签    --show-labels 显示标签
    # kubectl get pods -L app                    \\ -L 标签  显示拥有 app标签的值
    # kubectl get pods -L app,run --show-labels   \\ 显示多个
    # kubectl get pods -l app --show-labels        \\ 过滤  只显示拥有 app 标签的 pods
    # kubectl label pods b1 name=teo1               \\ 打标签 把pods b1 打上 name为 teo1 的标签
    # kubectl get pods --show-labels                 \\ 显示刚刚打的标签
    # kubectl label pods b1 name=teo2 --overwrite     \\ 重新打标签为teo2
    # kubectl get pods -l name=teo2 --show-labels      \\ 仅查找 有标签 name=teo2 的pods
    # kubectl get pods -l name=teo2,release=stable      \\ 仅查找 有标签 name=teo2同时release=stable 的pods
        =    等于
        ==   等于
        !=   不等于
    # kubectl get pods -l "name in (teo,teo1,teo2)"     \\ 仅查找 有标签name的值为(teo,teo1,teo2)中的一个就行
        in
        notin 
    # kubectl 



标签选择器
    等值关系: =等于    ==等于    !=不等于



# kubectl get nodes --show-labels         \\ 查看所有节点 并 显示其标签

# kubectl label nodes node01 disktype=ssd   \\ 给 节点node01 打标签  可配合 nodeSelector: 使用 pods选择要运行在哪个节点上



pod 状态
    pending 挂起 条件不能满足 调度没有完成 
    running 运行
    failed  失败
    succeeded 成功
    unknown 未知









ReplicaSet                \\ 注意 要创建复杂的标签
简称 rs

    控制器 标签选择器 可以创建一个不分彼此的pods资源   可以在外面加一个 server组件使用同一个标签选择器





# kubectl  explain rs          \\ 查看 rs   ReplicaSet 可以简写成rs
# kubectl explain rs.spec




# vim rs1.yaml清单
    apiVersion: apps/v1
    kind: ReplicaSet          \\ 定义了 类型 为 ReplicaSet
    metadata:
        name: rs1
        namespace: default
    spec:
        replicas: 2               \\ 定义了数量 为 2个  会按照模板启动两个pods
        selector:                  \\ 选择器
            matchLabels:            \\ 以此定义的标签 来管理 pods 很主要
                app: rs1             \\ 标签01
                release: canary       \\ 标签02
        template:                      \\ 定了pods 模板
            metadata:
                name: rs1-pod
                labels:                   \\ 定义了模板里面的pods的标签
                    app: rs1               \\ 要符合标签01
                    release: canary         \\ 要符合标签02
                    environment: qa          \\ 标签02
            spec:
                containers:
                - name: p1                     \\ 此名字并不主要 会自动生成新的名字
                  image: nginx                  \\ 容器的镜像
                  ports:
                  - name: http
                    containerPort: 80
# kubectl create -f rs1.yaml 
# kubectl get rs                  \\ 会生成rs
    rs1             2         2         0       3s
# kubectl get pods                  \\ 会生成两个pods 但是名字并不是上面定义的
    rs1-mvxwr             1/1     Running   0          11s
    rs1-xgxd6             1/1     Running   0          11s
# kubectl describe pods rs1-mvxwr      \\ 查看 详细信息
# curl 10.244.1.12                      \\ 可正常访问
# kubectl get pods
# kubectl delete pods rs1-xgxd6           \\ 删除 一个 pods
# kubectl get pods                         \\ 会发现 会自动 新建一个pods
# kubectl get pods --show-labels 

# kubectl create -f p1.yaml                  \\ 如果多一个的话 如改另一个pods标签为rs的管理标签 rs会自动随机杀掉一个
# kubectl get pods --show-labels
# kubectl label pods p1 release=canary
# kubectl label pods p1 app=rs1 --overwrite     \\ 打成一样的标签
# kubectl get pods --show-labels                 \\ 会自动 杀掉一个

# kubectl edit rs rs1           \\ 修改rs1的配置  可以动态修改  扩容或缩蓉
    replicas: 5                  \\ 把pods数量从2个 改成5个
# kubectl get pods                \\ 会有5个pods




# kubectl edit rs rs1           \\ 更改镜像的版本
    - image: nginx:v2            \\ 修改镜像的版本 如果有的话是可以的
# kubectl rs -o wide              \\ rs 会被修改 大那是 pods 现在还未被修改 需要重新生成的pods会被使用新的镜像
# kubectl get pods -o wide
# kubectl delete pods rs1-4j776     \\ 干掉一个 会新建一个 新建的为 新的v2的镜像
# kubectl get pods -o wide           \\ 此为 金丝雀发布 如先杀掉2个使用新的 如果没有问题在杀掉其他3个
                                      \\ 蓝绿发布  详细待查询       灰度发布  详细带查询




deployment  
简称 deploy

    deployment 滚动更新可以  可以管理 创建 多个 ReplicaSet



    ReplicaSet 可以管理 创建 多个 pods

    # kubectl explain deployment
    # kubectl explain deployment.spec
        strategy 更新策略
            type Recreate             \\ <string> 重建更新 删除一个 创建一个
            type RollingUpdate         \\ 滚动更新 如果type为此项 下面 rollingUpdate定义其策略 才生效 否则下面不生效
            rollingUpdate   <Object>    \\ 定义 type 滚动更新的 策略
                maxSurge    <string>     \\ 对应的更新过程中 最多目标的副本数有几个 可直接指定数量 或者指定百分比
                maxUnavailable            \\ 最多有几个不可用 比如 有5个  此项为2 说明 最少有3个是可用的   不可以同时为0
        revisionHistoryLimit               \\ 保留多少个历史版本 默认10个
        paused                              \\ 暂停  一般不开此项上来就更新



    # kubectl explain deployment.spec.strategy.rollingUpdate




    # kubectl explain deployment.spec.template


    # kubectl explain deployment.spec.strategy




    Deployment 控制 Replica Sets 控制 pods





    # vim d.yaml
        apiVersion: apps/v1
        kind: Deployment
        metadata:
          name: d1
          namespace: default
        spec:
          replicas: 2
          selector:
            matchLabels:
              app: myapp2
              release: canary2
          template:
              metadata:
                labels:
                  app: myapp2
                  release: canary2
              spec:
                containers:
                - name: myapp
                  image: nginx
                  ports:
                  - name: http
                    containerPort: 80

    # kubectl apply -f d1.yaml    \\ apply 有creat功能 也可以创建 
    # kubectl get deploy           \\ 有 deploy
    # kubectl get rs                \\ 还有 rs  只有一个 rs
    # kubectl get pods               \\ 会有 两个pods创建
    # vim d.yaml
        replicas: 3                    \\ 副本数改为3
    # kubectl apply -f d1.yaml          \\ apply 可以执行多次
    # kubectl get pods                   \\ 现在为3个
    # kubectl describe deploy d1          \\ 看到 d1 的详细信息
        RollingUpdateStrategy:  25% max unavailable, 25% max surg       \\ 默认即为滚动更新 可看到默认的更新的选项 不足25%会不足一个
    # kubectl get pods -l app=myapp2 -w   \\ 新开窗口 查看滚动更新  -l 标签只查看app=myaap2的
    # vim d.yaml                                             \\ 修改一下 镜像
        image: wodby/nginx
    # kubectl apply -f d.yaml                                  \\ 可查询 另一个窗口的 更新流程

    # kubectl get rs -o wide                                     \\ 会有 两个  rs  其中一个 是以前的模板 可以用此模板来回滚
    # kubectl rollout history deployment d1                       \\ 可以查看 滚动历史
    # kubectl patch deployments d1 -p '{"spec":{"replicas":5}}'    \\ patch 打补丁 方式修改 副本数为5
    # kubectl get pods                                              \\ 可看到 pods 数量为5个

    # kubectl explain deploy.spec.strategy.rollingUpdate              \\ 打补丁 修改更新策略  亦可以d1.yaml方式修改
    # kubectl patch deployments d1 -p '{"spec":{"strategy":{"rollingUpdate":{"maxSurge":1,"maxUnavailable":0}}}}'
    # kubectl describe deployments d1                                   \\ 可看到更新策略为最多可以多1个 不能少
        RollingUpdateStrategy:  0 max unavailable, 1 max surge

    # kubectl get pods -l app=myapp2 -w            \\ 新开窗口 继续查看更新状态
    # kubectl set image deployment d1 myapp=nginx && kubectl rollout pause deployment d1   \\ 使用命令 更新镜像版本 立即执行暂停 可看更新状态 金丝雀发布
    # kubectl rollout status deployment d1           \\ 也可以查看更新过程

    # kubectl rollout resume deployment d1             \\ 继续 更新
    # kubectl get rs -o wide                            \\ 应该会看到有三个版本 但是这里只用了两个镜像 只有两个版本
    # kubectl rollout history deployment d1              \\ 可查看一共有几个版本
    # kubectl rollout undo deployment d1                  \\ 回滚到上一个版本
    # kubectl rollout undo deployment d1 --to-revision=1   \\ 也可指明 回滚到指定版本
    # kubectl rollout history deployment d1                 \\ 出现新的版本 刚刚回滚的版本也没有了 会替换为新的版本
    # kubectl get rs -o wide                                 \\ 可看到 当前正在工作的版本是 上一个版本了


...............................................................................................................................

DaemonSet  在每一个节点上要运行一个资源  在整个集群个每一个节点上只运行某个指定pods的一个 并且只一个副本 或者在集群中符合选择器的节点上,每一个节点只运行指定的pods副本 用于系统级的管理功能 可以直接把节点上的某个目录作为存储卷关联至pods中,让pods实现某些管理功能


简称 ds     待看.........................



# vim ds1.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: redis
      namespace: default
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: redis
          role: logstor
      template:
          metadata:
            labels:
              app: redis
              role: logstor
          spec:
            containers:
            - name: redis
              image: redis:4.0-alpine
              ports:
              - name: redis
                containerPort: 6379
    ---                                      \\ --- 来隔开 资源
    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: ds1
      namespace: default
    spec:
      selector:
        matchLabels:
          app: filebeat
          release: stable
      template:
          metadata:
            labels:
              app: filebeat
              release: stable
          spec:
            containers:
            - name: filebeat
              image: ikubernetes/filebeat:5.6.5-alpine
              env:
              - name: REDIS_HOST
                value: redis.default.svc.cluster.local
              - name: REDIS_LOG_LEVEL
                value: info

# kubectl apply -f ds1.yaml
# kubectl expose deployment redis --port=6379


# kubectl get svc                                    \\ service 简称 svc
# kubectl exec -it redis-56fd57fd76-nnfqx -- /bin/sh  \\ 
    # netstat -tnl                                     \\ 6379已经是监听的
    # nslookup redis.default.svc.cluster.local          \\ 可以解析成功
    # redis-cli -h redis.default.svc.cluster.local       \\ 连接进入redis
        keys *                                            \\ 查看 键值  发现为空
        exit
# kubectl get pods
# kubectl exec -it ds1-8r7st -- /bin/sh
    # ps aux                             \\ 查看 redis 运行状态
    # cat /etc/filebeat/filebeat.yml      \\ 查看 redis 配置文件
    # printenv                             \\ 查看 环境变量
        REDIS_HOST=redis.default.svc.cluster.local       \\ 名称解析   会有








    # kubectl get pods              \\ 可看到ds1 已经运行起来了
    # kubectl logs ds1-cj7c2         \\ 查看日志









IP:178.20.210.111
  端口:48999
  密钥:ee376ba8d9d75bc4a5067b94a3d168421d37306539626363393666626235636665633833316663353730376266356431612e636f6d