参考：25-k8s集群中-RBAC用户角色资源权限-CSDN博客
此内容是在原文基础上，概念摘抄，案例实操，并标注了部分重点，在自己学习中不好理解的地方标注了重点
一、RBAC概述
1，k8s集群的交互逻辑（简单了解）
我们通过k8s各组件架构，知道各个组件之间是使用https进行数据加密及交互的，那么同理，我们作为“使用”k8s的各种资源的使用者，也是通过https进行数据加密的；
k8s通过我们家目录下的证书来判断我们是谁？通过证书内容来认定我们的权限；
用户证书的位置
[root@master ~]# ll -a ~/.kube/config
-rw------- 1 root root 5643 3月 29 16:04 /root/.kube/config
2，k8s的安全架构（简单了解）
3，RBAC用户授权的逻辑（重要）
用户/主题Topic
1,User
2,SerciceAccount
3,Group
用户角色：
1，Role：局部资源角色
2，ClusterRole：全局资源角色
角色绑定：
1，RoleBinding
2，ClusterRoleBinding
4，查看现有的集群默认角色
[root@master ~]# kubectl get clusterrole | grep -v system
admin：主要用于授权命名空间所有读写的权限
cluster-admin:超级管理员，由集群所有权限
edit：允许对大多数对象进行读写操作，不允许查看或者修改角色、角色绑定；
view：允许对命名空间大多数对象进行读写，不允许查看角色、角色绑定、secret；
#####
kubeadm用户，只有使用kubeadm部署k8s时才会出现，不用关心它；
二、流程介绍
1，用户的创建流程
1,User
2,SerciceAccount
3,Group
本质上讲，在k8s系统中，用户，就是一个文件，这个文件在当前登录用户的家目录下；
这个文件config，就代表“我”是谁；
这里面并没有角色、权限信息，角色和权限信息，在其他位置；
· ssl流程介绍
知道了ssl原理，https请求过程，我们就了解了，ssl的安全机制；
实际上k8s当中“根证书”早就生成好了，在我们kubeadm部署的时候，就自动帮我们生成了；
k8s是模拟ca机构，给自己颁发证书，自己验证自己，所以，文件中有私钥、公钥等；
[root@k8s231 ~]# ll /etc/kubernetes/pki/
total 56
-rw-r--r-- 1 root root 1281 Jan 1 19:39 apiserver.crt
-rw-r--r-- 1 root root 1155 Jan 1 19:39 apiserver-etcd-client.crt
-rw------- 1 root root 1679 Jan 1 19:39 apiserver-etcd-client.key
-rw------- 1 root root 1675 Jan 1 19:39 apiserver.key
-rw-r--r-- 1 root root 1164 Jan 1 19:39 apiserver-kubelet-client.crt
-rw------- 1 root root 1679 Jan 1 19:39 apiserver-kubelet-client.key#根证书
-rw-r--r-- 1 root root 1099 Jan 1 19:39 ca.crt#ca机构的私钥
-rw------- 1 root root 1679 Jan 1 19:39 ca.key
drwxr-xr-x 2 root root 162 Jan 1 19:39 etcd
-rw-r--r-- 1 root root 1115 Jan 1 19:39 front-proxy-ca.crt
-rw------- 1 root root 1675 Jan 1 19:39 front-proxy-ca.key
-rw-r--r-- 1 root root 1119 Jan 1 19:39 front-proxy-client.crt
-rw------- 1 root root 1679 Jan 1 19:39 front-proxy-client.key
-rw------- 1 root root 1675 Jan 1 19:39 sa.key
-rw------- 1 root root 451 Jan 1 19:39 sa.pub
· 生成用户证书
一个用户一个证书，这个用户证书，就是用来生成，用户文件的（也就是家目录下的config）
· 生成kubeconfig用户授权文件
有了这个授权文件，我们就拥有了一个用户了；
但是，还没有任何权限，还无法使用；
2，创建角色和规则
通过资源清单的方式，创建角色和规则；
角色就是：
1，Role：局部资源角色
2，ClusterRole：全局资源角色
规则就是：这个角色的权限；能使用什么资源、不能使用什么资源，，，，
3，角色与用户的绑定
根据角色的不同，创建资源清单，对应不同的绑定资源清单的编写；
1，RoleBinding
2，ClusterRoleBinding
只要角色和用户绑定完成，那么，RBAC的整个流程就结束了；
我们就成功创建了一个带有特定权限的用户；就可以分发给“同事”进行使用了；
4，逻辑流程的总结
三、RBAC创建初体验
1，创建用户【user】
· 生成用户ssl证书
1，上传/下载cfssl证书生成工具
cfssl工具百度网盘地址：
链接：https://pan.baidu.com/s/1gDRQuxekvgInplLkpjvhQw?pwd=f31x
提取码：f31x
或者去github地址下载：Releases · cloudflare/cfssl · GitHub
[root@master rbac]# mkdir -p /dolphin/rbac && cd /dolphin/rbac
上传下载的目录到该文件[root@master rbac]# rz
[root@master rbac]# ll
总用量 10556
-r-------- 1 root root 10808877 4月 25 11:01 cfssl.zip
2，解压cfssl工具压缩包
[root@master rbac]# unzip cfssl.zip
Archive: cfssl.zip
inflating: cfssl_1.6.4_linux_amd64
inflating: cfssl-certinfo_1.6.4_linux_amd64
inflating: cfssljson_1.6.4_linux_amd64
[root@master rbac]# ll
总用量 39128
-rw-r--r-- 1 root root 12054528 8月 30 2023 cfssl_1.6.4_linux_amd64
-rw-r--r-- 1 root root 9560064 8月 30 2023 cfssl-certinfo_1.6.4_linux_amd64
-rw-r--r-- 1 root root 7643136 8月 30 2023 cfssljson_1.6.4_linux_amd64
-r-------- 1 root root 10808877 4月 25 11:01 cfssl.zip
3，删除压缩包，将cfssl文件改名
为什么改名？为了便于使用~如果你不嫌费力，可以不改~
[root@master rbac]# rename _1.6.4_linux_amd64 "" *
[root@master rbac]# ll
总用量 28572
-rw-r--r-- 1 root root 12054528 8月 30 2023 cfssl
-rw-r--r-- 1 root root 9560064 8月 30 2023 cfssl-certinfo
-rw-r--r-- 1 root root 7643136 8月 30 2023 cfssljson
4，将cfssl文件编程全局命令
将这三个文件，移动到/usr/local/bin目录下，编程全局命令~
[root@master rbac]# mv ./* /usr/local/bin/
5，给cfssl执行文件加执行权限
[root@master rbac]# chmod +x /usr/local/bin/cfssl*
6，编辑cfssl工具的生成用户ssl证书的配置文件
根证书
root@master rbac]# cat ca-config.json
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
],
"expiry": "87600h"
}
}
}
}
客户端验证签名证书
[root@master rbac]# cat csr.json
{
"CN": "dolphin",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
}
]
}
7，使用cfssl工具生成用户的ssl证书
[root@master rbac]# cfssl gencert -ca=/etc/kubernetes/pki/ca.crt -ca-key=/etc/kubernetes/pki/ca.key -config=ca-config.json -profile=kubernetes csr.json | cfssljson -bare dolphin
-------提示：这里如果写的k8s就是创建的用户组，这里写dolphin就是创建的，后边创建用户组也会讲到-----或者用下边这个命令，会默认使用k8s的上述配置
cfss gencert -initca -ca-config.json | cfssjson -bare ca
参数解释：
#使用k8s自带的证书来签发客户端证书（位置就在/etc/kubernetes/pki/下面）；
-ca=/etc/kubernetes/pki/ca.crt
-ca-key=/etc/kubernetes/pki/ca.key
-config=ca-config.json
-profile=kubernetes csr.json | cfssljson -bare xinjizhiwa
查看证书
[root@master rbac]# ll
总用量 20
-rw-r--r-- 1 root root 292 4月 25 11:09 ca-config.json
-rw-r--r-- 1 root root 220 4月 25 11:10 csr.json
-rw-r--r-- 1 root root 997 4月 25 11:23 dolphin.csr
-rw------- 1 root root 1679 4月 25 11:23 dolphin-key.pem
-rw-r--r-- 1 root root 1281 4月 25 11:23 dolphin.pem
至此，我们用户的ssl证书申请完毕了；
· 生成用户kubeconfig文件
1，编辑生成kubeconfig文件的执行脚本
[root@master rbac]# cat kubeconfig.sh
#!/bin/bash# 配置集群;
# --certificate-authority：指定K8s的ca根证书文件路径
# --embed-certs：
# 1，true，表示将根证书文件的内容写入到配置文件中，
# 2，false,则只是引用配置文件，将kubeconfig
# --server：指定APIServer的地址。
# --kubeconfig：指定kubeconfig的配置文件名称
kubectl config set-cluster dolphin-cluster \
--certificate-authority=/etc/kubernetes/pki/ca.crt \
--embed-certs=true \
--server=https://192.168.190.200:6443 \
--kubeconfig=dolphin.kubeconfig
# 设置客户端认证，客户端将来需要携带证书让服务端验证
kubectl config set-credentials dolphin-client \
--client-key=dolphin-key.pem \
--client-certificate=dolphin.pem \
--embed-certs=true \
--kubeconfig=dolphin.kubeconfig# 设置默认上下文，可以用于绑定多个客户端和服务端的对应关系（客户端和服务端绑定）。
kubectl config set-context dolphin \
--cluster=dolphin-cluster \
--user=dolphin-client \
--kubeconfig=dolphin.kubeconfig# 设置当前使用的上下文(正式生效)
kubectl config use-context dolphin --kubeconfig=dolphin.kubeconfig[
2，执行生成kubeconfig用户文件的执行脚本
正式生成用户
[root@master rbac]# bash kubeconfig.sh
Cluster "dolphin-cluster" set.
User "dolphin-client" set.
Context "dolphin" created.
Switched to context "dolphin".
查看生成的kubeconfig用户文件
[root@master rbac]# ll
总用量 32
-rw-r--r-- 1 root root 292 4月 25 11:09 ca-config.json
-rw-r--r-- 1 root root 220 4月 25 11:10 csr.json
-rw-r--r-- 1 root root 997 4月 25 11:23 dolphin.csr
-rw------- 1 root root 1679 4月 25 11:23 dolphin-key.pem
-rw------- 1 root root 5785 4月 25 14:06 dolphin.kubeconfig
-rw-r--r-- 1 root root 1281 4月 25 11:23 dolphin.pem
-rw-r--r-- 1 root root 1161 4月 25 14:05 kubeconfig.sh
[root@master rbac]#
拓展知识：也可以使用config资源清单编写生成用户kubeconfig文件
[root@master rbac]# cat dolphin.kubeconfig
apiVersion: v1
clusters:
- cluster:
certificate-authority-data: ......(/etc/kubernetes/pki/ca.crt)
server: https://192.168.190.200:6443
name: dolphin-cluster
contexts:
- context:
cluster: dolphin-cluster
user: dolphin-client
name: dolphin
current-context: dolphin
kind: Config
preferences: {}
users:
- name: dolphin-client
user:
client-certificate-data: ......（xinjizhiwa.pem或者写入公钥串，pem记得base64 -d之后使用）
client-key-data: ......(xinjizhiwa-key.pem)
此时使用这个用户，去查看pod，会提示你没有权限，因为咱们还没有创建、绑定角色；
[root@master rbac]# kubectl get pods --kubeconfig=dolphin.kubeconfig
Error from server (Forbidden): pods is forbidden: User "dolphin" cannot list resource "pods" in API group "" in the namespace "default"
至此，用户dolphin创建完成
2，创建角色编写规则
· 编辑角色资源清单
上述内容中，我们知道，角色有两种，一种是全局角色ClusterRole，另一种是局部角色Role；
我们先创建一个局部的Role角色作为学习；
[root@master rbac]# cat role.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: dolphin-role
namespace: default
rules:
# 声明API组；[""]代表v1,["apps"]代表apps/v1 通过命令kubectl api-resources可以查看api组
- apiGroups: ["","apps"]
# 声明API组下面的资源类型（不支持简写，只能写全称）
resources: ["pods","deployments","services"]
# 声明使用方式
verbs: ["get","list","delete"]
· 创建角色
[root@master rbac]# kubectl apply -f role.yaml
查看角色
[root@master rbac]# kubectl get role
NAME CREATED AT
dolphin-role 2024-04-25T07:49:09Z
至此，用户和角色及规则都创建成功了；
3，绑定用户与角色
· 编辑绑定资源清单
[root@master rbac]# cat bind.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: dolphin-bind
namespace: default
#声明用户主题（绑定的用户是哪个）
subjects:
#由于我们用户类型有三种，所以需要写明用户类型
- kind: User
name: dolphin
apiGroup: rbac.authorization.k8s.io
#声明角色主题（绑定的角色是哪个）
roleRef:
kind: Role
name: dolphin-role
apiGroup: rbac.authorization.k8s.io
· 创建绑定资源
[root@master rbac]# kubectl apply -f bind.yaml
rolebinding.rbac.authorization.k8s.io/dolphin-bind created
4，测试用户
协议个pod资源，使用用户“dolphin”创建，发现创建不了，提示权限不够；
因为，我们在创建角色规则的时候，只给了删除、和查看的能力，没有给create创建能力；
[root@master rbac]# cat pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: pod-nginx
spec:
containers:
- name: c1
image: nginx:1.20.1-alpine
[root@master rbac]# ^C
[root@master rbac]# cat pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: pod-nginx
spec:
containers:
- name: c1
image: nginx:1.20.1-alpine
[root@master rbac]# kubectl apply -f pod.yaml --kubeconfig=dolphin.kubeconfig
因为我们有default默认名称空间的查看、删除权限，所以我们可以进行查看；
测试查看功能
测试删除功能
[root@master rbac]# kubectl delete pods --all --kubeconfig=dolphin.kubeconfig
pod "resourcelimit-demo" deleted
到此，普通用户的创建、角色绑定、角色配置就学习完毕了；
5，总结
1、用户拿着钥匙（./kube/config）去k8s访问资源命名空间中的资源
2、 通过命名空间的RoleBinding查看是否有绑定访问资源的关系
3、通过判断绑定关系对应的角色Role是否有权限支持相关操作
四、其他节点使用用户登录操作k8s
我们有了用户文件，将用户文件发送给“同事”，同事直接使用这个文件，就可以按照绑定的规则，操作k8s资源了；
1，模拟将用户文件发给同事
比如，同事正在使用node1，我们把用户文件发给他
[root@master rbac]# scp dolphin.kubeconfig node1:/root/
2，同事在node1使用用户文件操作k8s资源
--kubeconfig=dolphin.kubeconfig
3，操作资源不指定文件，默认指定设置
[root@node1 ~]# cp dolphin.kubeconfig ~/.kube/config
[root@node1 ~]# kubectl get pods
NAME READY STATUS RESTARTS AGE
pod-nginx 1/1 Running 0 106s
五、用户组Group案例
1，用户组的概念
1. 用户组的好处在于，无需单独为一个用户创建权限和绑定了，只需要统一吧一个组进行授权，然后，将改组的用户加入进去，就每一个用户都拥有该组的权限了；
2. APIServer会优先校验用户名（ssl证书中的CN字段），若用户名没有对应的权限，则再去校验用户组（o）的权限；
k8s中的用户、用户组都是提取ssl证书签名字段中的一个字段，不是在集群中创建的；
--证书签名中的CN字段：代表用户
--证书签名中的o字段：代表用户组
2，创建用户组Group
· 编辑cfssl证书请求文件
[root@master rbac]# mkdir group && cd group
[root@master group]# cat ca-group.json
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
],
"expiry": "87600h"
}
}
}
}
[root@master group]# cat devops-csr.json
{
"CN": "devops", # 下边创建证书如果用的是这个CN的值“devops”，那么就是创建的用户
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "devops-group", # 下边创建证书用的这个O的值“devops-group”所以创建的是用户组证书
"OU": "System"
}
]
}
· 生成用户组证书
再次声明，你创建的是用户、还是用户组，取决于你的证书名称选择的签名字段，选择的是CN还是O对应的值；
[root@master group]# cfssl gencert -ca=/etc/kubernetes/pki/ca.crt -ca-key=/etc/kubernetes/pki/ca.key -config=ca-group.json -profile=kubernetes devops-csr.json | cfssljson -bare devops-group
· 编辑脚本生成用户组kubeconfig用户组文件
[root@master group]# cat kubeconfig.sh
#!/bin/bashkubectl config set-cluster devops-cluster \
--certificate-authority=/etc/kubernetes/pki/ca.crt \
--embed-certs=true \
--server=https://192.168.190.200:6443 \
--kubeconfig=devops-group.kubeconfig
# 设置客户端认证
kubectl config set-credentials devops-client \
--client-key=devops-group-key.pem \
--client-certificate=devops-group.pem \
--embed-certs=true \
--kubeconfig=devops-group.kubeconfig# 设置默认上下文
kubectl config set-context devops-group \
--cluster=devops-cluster \
--user=devops-client \
--kubeconfig=devops-group.kubeconfig# 设置当前使用的上下文
kubectl config use-context devops-group --kubeconfig=devops-group.kubeconfig
· 执行脚本生成用户组文件
[root@master group]# bash kubeconfig.sh
Cluster "devops-cluster" set.
User "devops-client" set.
Context "devops-group" created.
Switched to context "devops-group".
3，创建角色、绑定用户组
· 编辑资源清单
[root@master group]# cat rbac.yaml
#创建角色
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
namespace: default
name: role-group
rules:
- apiGroups: ["","apps"]
resources: ["pods","nodes","services","deployments"]
verbs: ["get", "watch", "list","create"]---
#绑定用户组与角色
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: group-rolebinding
namespace: default
#声明要绑定的用户/用户组
subjects:
# 声明主体类型：组
- kind: Group
# 组名(对应的O字段)
name: devops-group
apiGroup: rbac.authorization.k8s.io
roleRef:
# 角色类型
kind: Role
# 绑定角色名称
name: role-group
apiGroup: rbac.authorization.k8s.io
· 创建Role和RoleBinding资源
[root@master group]# kubectl apply -f rbac.yaml
role.rbac.authorization.k8s.io/role-group created
rolebinding.rbac.authorization.k8s.io/group-rolebinding created
至此，devops-groups用户组创建完成
测试用用户组devops-group.kubecofig的凭证访问资源，访问成功
[root@master group]# kubectl get pods --kubeconfig=devops-group.kubeconfig
4，创建用户加入用户组
· 创建用户
[root@master group]# mkdir /dolphin/rbac/user-zhangsan && cd /dolphin/rbac/user-zhangsan
[root@master user-zhangsan]# cat ca-config.json
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
],
"expiry": "87600h"
}
}
}
}
[root@master user-zhangsan]# cat group-user-zhangsan.json
{
"CN": "zhangsan",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "devops-group",
"OU": "System"
}
]
}
生成用户证书 （下边用的是group-user-zhangsan.json 的CN字段，所以创建的时候用户证书）
[root@master user-zhangsan]# cfssl gencert -ca=/etc/kubernetes/pki/ca.crt -ca-key=/etc/kubernetes/pki/ca.key -config=ca-config.json -profile=kubernetes group-user-zhangsan.json | cfssljson -bare zhangsan
· zhangsan用户加入用户组
1，编辑生成kubeconfig用户文件的执行脚本
[root@master user-zhangsan]# cat kubeconfig.sh
#!/bin/bashkubectl config set-cluster zhangsan-cluster \
--certificate-authority=/etc/kubernetes/pki/ca.crt \
--embed-certs=true \
--server=https://192.168.190.200:6443 \
--kubeconfig=zhangsan.kubeconfig
# 设置客户端认证
kubectl config set-credentials zhangsan-client \
--client-key=zhangsan-key.pem \
--client-certificate=zhangsan.pem \
--embed-certs=true \
--kubeconfig=zhangsan.kubeconfig# 设置默认上下文
kubectl config set-context zhangsan-context \
--cluster=zhangsan-cluster \
--user=zhangsan-client \
--kubeconfig=zhangsan.kubeconfig# 设置当前使用的上下文
kubectl config use-context zhangsan-context --kubeconfig=zhangsan.kubeconfig
2，执行脚本
[root@master user-zhangsan]# bash kubeconfig.sh
Cluster "zhangsan-cluster" set.
User "zhangsan-client" set.
Context "zhangsan-context" created.
Switched to context "zhangsan-context".
5，测试用户是否拥有用户组的权限
[root@master user-zhangsan]# kubectl get pods --kubeconfig=zhangsan.kubeconfig
总结，只要拥有了用户组，我们创建用户的时候，签名中“O”字段，与用户组名相同，那么创建出来的用户，就用用了用户组的权限，就不在需要配置角色、绑定了；方便很多
六、基于【服务账号serviceaccount】授权
serviceaccount用户，简称sa资源，用于自动化程序的用户创建；
创建sa用户，就不需要使用证书来创建了，它是k8s集群中的一个资源，sa资源；
1，创建sa资源
· 声明式创建
[root@k8s231 sa]# vim sa01.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
name: py01
[root@k8s231 sa]# kubectl apply -f sa01.yaml
serviceaccount/py01 created
查看sa服务账号
[root@k8s231 sa]# kubectl get sa
NAME SECRETS AGE
default 1 51d
py01 1 4s
· 响应式创建
[root@k8s231 sa]# kubectl create serviceaccount py02
查看sa用户
[root@k8s231 sa]# kubectl get sa
NAME SECRETS AGE
default 1 51d
py01 1 2m4s
py02 1 4s
2，授权python程序对k8s-API的访问权限
· 创建用户
[root@k8s231 sa]# kubectl create serviceaccount py02
· 创建角色
[root@k8s231 sa]# vim role.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: python-role
rules:
- apiGroups: [""]
resources: ["pods"]
verbs: ["get","watch","list"]
[root@k8s231 sa]# kubectl apply -f role.yaml
· 绑定sa账号和角色
[root@k8s231 sa]# vim bind.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: python-role-sa
subjects:
- kind: ServiceAccount
name: py02
roleRef:
kind: Role
name: python-role
apiGroup: rbac.authorization.k8s.io
[root@k8s231 sa]# kubectl apply -f bind.yaml
3，部署一个python的pod资源
[root@k8s231 sa]# vim pod.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: dm-py
spec:
replicas: 2
selector:
matchLabels:
apps: python
template:
metadata:
labels:
apps: python
spec:
#这里就是sa账号，指定sa的名称，请确认该账号是有权限访问K8S集群的哟!
serviceAccountName: py02
containers:
- image: python:3.9.16-alpine3.16
name: py
command:
- tail
- -f
- /etc/hosts
[root@k8s231 sa]# kubectl apply -f pod.yaml
4，进入pod中执行python代码
[root@k8s231 sa]# kubectl exec -it dm-py-64975879c8-b9sxg -- sh
/ # python --version
Python 3.9.16#写一个python脚本
/ # cat > view-k8s-resources.py <<EOF
> from kubernetes import client, config
>
> with open('/var/run/secrets/kubernetes.io/serviceaccount/token') as f:
> token = f.read()
>
> configuration = client.Configuration()
> configuration.host = "https://kubernetes" # APISERVER地址
> configuration.ssl_ca_cert="/var/run/secrets/kubernetes.io/serviceaccount/ca.crt" # CA证书
> configuration.verify_ssl = True # 启用证书验证
> configuration.api_key = {"authorization": "Bearer " + token} # 指定Token字符串
> client.Configuration.set_default(configuration)
> apps_api = client.AppsV1Api()
> core_api = client.CoreV1Api()
> try:
> print("###### Deployment列表 ######")
> #列出default命名空间所有deployment名称
> for dp in apps_api.list_namespaced_deployment("default").items:
> print(dp.metadata.name)
> except:
> print("没有权限访问Deployment资源！")
>
> try:
> #列出default命名空间所有pod名称
> print("###### Pod列表 ######")
> for po in core_api.list_namespaced_pod("default").items:
> print(po.metadata.name)
> except:
> print("没有权限访问Pod资源！")
> EOF
/ #####安装py使用k8s的插件########
/ # pip install kubernetes -i https://pypi.tuna.tsinghua.edu.cn/simple/#执行python脚本
/ # python3 view-k8s-resources.py
###### Deployment列表 ######
没有权限访问Deployment资源！
###### Pod列表 ######
dm-py-64975879c8-b9sxg
dm-py-64975879c8-z76fp
pod-nginx
2202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
