第152天学习打卡（Kubernetes 集群安全机制）

Posted 2021-06-26 doudoutj

K8s集群安全机制

1.概述

（1）访问k8s集群的时候，需要经过三个步骤完成具体操作

• 第一步 认证
• 第二步 鉴权（授权）
• 第三步 准入控制

（2）进行访问时候，过程中都需要经过apiserver(进行统一协调管理)，apiserver做统一协调。访问过程中需要证书，token,或者用户名 + 密码。 如果访问pod还需要serviceAccount.

第一步认证 传输安全

• 传输安全：对外不暴露8080端口，只能内部访问，对外使用端口6443
• 认证
  • 客户端身份认证常用方式
    • https证书认证，基于ca证书
    • http token认证，通过token识别用户
    • http基本认证， 用户名 + 密码认证

第二步 鉴权（授权）

• 基于RBAC（基于角色访问控制）进行鉴权操作

第三步 准入控制

• 就是准入控制器的列表，如果列表有请求内容，就通过，没有就拒绝。

2.RABC

基于角色的访问控制

• 角色

  • role:特定命名空间访问权限
  • ClusterRole:所有命名空间访问权限

• 角色绑定

  • roleBinding:角色绑定到主体
  • ClusterRoleBinding:集群角色绑定到主体

• 主体

  • user:用户组

  • group:用户组

  • serviceAccount: 服务账号

1.创建命名空间

[root@master ~]# kubectl create ns roledemo #创建命名空间
namespace/roledemo created
[root@master ~]# kubectl get ns #查看命名空间
NAME                   STATUS   AGE
default                Active   4d
ingress-nginx          Active   2d4h
kube-node-lease        Active   4d
kube-public            Active   4d
kube-system            Active   4d
kubernetes-dashboard   Active   3d
roledemo               Active   4s
roletest               Active   7m49s

2.在新创建的命名空间中创建pod

[root@master ~]# kubectl run nginx --image=nginx -n roledemo
pod/nginx created
[root@master ~]# kubectl get pods -n roledemo
NAME    READY   STATUS    RESTARTS   AGE
nginx   1/1     Running   0          36s
[root@master ~]# 

3.创建角色

[root@master ~]# kubectl apply -f rbac-role.yaml #创建一个角色
role.rbac.authorization.k8s.io/pod-reader created
[root@master ~]# kubectl get role -n roledemo # 查看
NAME         CREATED AT
pod-reader   2021-06-09T13:22:19Z
[root@master ~]# 

4.创建角色绑定

[root@master ~]# rz
[root@master ~]# cat rbac-rolebinding.yaml
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: read-pods
  namespace: roledemo
subjects:
- kind: User
  name: mary # Name is case sensitive
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role #this must be Role or ClusterRole
  name: pod-reader # this must match the name of the Role or ClusterRole you wish to bind to
  apiGroup: rbac.authorization.k8s.io
[root@master ~]# kubectl apply -f rbac-rolebinding.yaml
rolebinding.rbac.authorization.k8s.io/read-pods created
[root@master ~]# kubectl get role,rolebinding -n roledemo
NAME                                        CREATED AT
role.rbac.authorization.k8s.io/pod-reader   2021-06-09T13:22:19Z

NAME                                              ROLE              AGE
rolebinding.rbac.authorization.k8s.io/read-pods   Role/pod-reader   70s

5.使用证书来识别身份

[root@master ~]# mkdir mary
[root@master ~]# cd mary
[root@master mary]# vim rabc-user.sh

这里是使用的二进制方式搭建的集群中进行测试的，我搭建的不是基于二进制的集群（就看截图效果吧）：

还需要拷贝以下的证书文件

[root@master mary]# vim rabc-user.sh
[root@master mary]# vim ca-config.json
[root@master mary]# vim ca-csr.json
[root@master mary]# vim ca-key.pem ca.pem
2 files to edit
[root@master mary]# 

还差ca.csr文件

最终的结果应该是这样：

# more cert.sh 
#生成ca-config.json证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"：
        ]
      }
    }
  }
}
EOF

#生成ca-csr.json文件
cat > ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

#生成ca-key.pem ca.pem
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

#-----------------------

#生成server-csr.json文件
cat > server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "127.0.0.1",
      "172.17.0.218",
      "172.17.0.219",
      "172.17.0.219",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

#生成server.pem,server-key.pem
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

#-----------------------

#生成admin-csr.json文件
cat > admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

#最后生成admin证书---admin-key.pem ，admin.pem
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

#-----------------------

#生成代理
cat > kube-proxy-csr.json <<EOF
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF


# sh cert.sh
//查看生成的证书
# ls | grep pem
admin-key.pem
admin.pem
ca-key.pem
ca.pem
kube-proxy-key.pem
kube-proxy.pem
server-key.pem
server.pem

参考：kubernetes（K8S）创建自签TLS证书 - 我是一条最咸的咸鱼 - 博客园 (cnblogs.com)

B站学习网址：k8s教程由浅入深-尚硅谷_哔哩哔哩_bilibili