38-44-k8s-配置管理-安全机制-ingress-helm_ingress-controller yml中secret

38-k8s-配置管理-安全机制-ingress-helm：

Kubernetes配置管理

1、Secret

Secret的作用是加密数据，然后存在etcd里面，让Pod容器以挂载Volume方式进行访问

场景：用户名和密码进行加密

一般场景的是对某个字符串进行base64编码进行加密

echo -n ‘admin’ | base64

1、创建secret加密数据

• 创建secret加密数据的yaml文件 secret.yaml

  apiVersion: v1
  kind: Secret
  metadata:
    name: mysecret
  type: Opaque
  data:
    username: YWRtaW4=
    password: MWYyZDFlMmU2N2Rm
  1
  2
  3
  4
  5
  6
  7
  8

然后使用下面命令创建一个pod

kubectl create -f secret.yaml

通过get命令查看

kubectl get pods

kubectl get secret

2、变量形式挂载到Pod

创建secret-val.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - name: nginx
    image: nginx
    env:
      - name: SECRET_USERNAME
        valueFrom:
          secretKeyRef:
            name: mysecret
            key: username
      - name: SECRET_PASSWORD
        valueFrom:
          secretKeyRef:
            name: mysecret
            key: password
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

kubectl apply -f secret-val.yaml

kubectl get pods

然后我们通过下面的命令，进入到我们的容器内部

kubectl exec -it mypod bash
1

然后我们就可以输出我们的值，这就是以变量的形式挂载到我们的容器中

最后如果我们要删除这个Pod，就可以使用这个命令

kubectl delete -f secret-val.yaml
1

3、以数据卷形式挂载

创建secret-vol.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - name: nginx
    image: nginx
    volumeMounts:
    - name: foo
      mountPath: "/etc/foo"
      readOnly: true
  volumes:
  - name: foo
    secret:
      secretName: mysecret
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

根据配置创建容器 kubectl apply -f secret-val.yaml

进入容器 kubectl exec -it mypod bash

查看 ls /etc/foo

如果需要删除

kubectl delete secret --all

kubectl delete -f secret-vol.yaml

2、ConfigMap

ConfigMap作用是存储不加密的数据到etcd中，让Pod以变量或数据卷Volume挂载到容器中，应用场景：配置文件

1、创建配置文件

首先创建一个配置文件 redis.properties

redis.host=127.0.0.1
redis.port=6379
redis.password=123456
1
2
3

2、创建ConfigMap

我们使用命令创建configmap

kubectl create configmap redis-config --from-file=redis.properties
1

然后查看详细信息

kubectl get cm
kubectl describe cm redis-config
1
2

3、Volume数据卷形式挂载

创建一个 cm.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: busybox
      image: busybox
      command: [ "/bin/sh","-c","cat /etc/config/redis.properties" ]
      volumeMounts:
      - name: config-volume
        mountPath: /etc/config
  volumes:
    - name: config-volume
      configMap:
        name: redis-config
  restartPolicy: Never
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

然后使用该yaml创建我们的pod

# 创建
kubectl apply -f cm.yaml
# 查看
kubectl get pods
kubectl logs mypod
1
2
3
4
5

4、以变量的形式挂载Pod

首先我们也有一个 myconfig.yaml文件，声明变量信息，然后以configmap创建

apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfig
  namespace: default
data:
  special.level: info
  special.type: hello
1
2
3
4
5
6
7
8

然后我们就可以创建我们的配置文件

# 创建pod
kubectl apply -f myconfig.yaml
# 获取
kubectl get cm
1
2
3
4

创建config-var.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: busybox
      image: busybox
      command: [ "/bin/sh", "-c", "echo $(LEVEL) $(TYPE)" ]
      env:
        - name: LEVEL
          valueFrom:
            configMapKeyRef:
              name: myconfig
              key: special.level
        - name: TYPE
          valueFrom:
            configMapKeyRef:
              name: myconfig
              key: special.type
  restartPolicy: Never
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

kubectl apply -f config-var.yaml

kubectl logs mypod

Kubernetes集群安全机制

当我们访问K8S集群时，需要经过三个步骤完成具体操作

认证 ——》 鉴权【授权】——》 准入控制

进行访问的时候，都需要经过 apiserver， apiserver做统一协调，比如门卫

• 访问过程中，需要证书、token、或者用户名和密码
• 如果访问pod需要serviceAccount

1、认证

对外不暴露8080端口，只能内部访问，对外使用的端口6443

客户端身份认证常用方式

• https证书认证，基于ca证书
• http token认证，通过token来识别用户
• http基本认证，用户名 + 密码认证

2、鉴权

基于RBAC进行鉴权操作

基于角色访问控制

3、准入控制

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

RBAC介绍

基于角色的访问控制，为某个角色设置访问内容，然后用户分配该角色后，就拥有该角色的访问权限

k8s中有默认的几个角色

1、role：特定命名空间访问权限

2、ClusterRole：所有命名空间的访问权限

角色绑定

1、roleBinding：角色绑定到主体

2、ClusterRoleBinding：集群角色绑定到主体

主体

1、user：用户

2、group：用户组

3、serviceAccount：服务账号

1、RBAC实现鉴权

• 创建命名空间

  kubectl create ns role-demo

2、创建命名空间

我们可以首先查看已经存在的命名空间

kubectl get namespace
1

3、命名空间创建Pod

为什么要创建命名空间？因为如果不创建命名空间的话，默认是在default下

kubectl run nginx --image=nginx -n roledemo

[root@hadoop102 ~]# kubectl get pods -n role-demo

1
2
3
4

4、创建角色

我们通过 rbac-role.yaml进行创建

kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: role-demo
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
1
2
3
4
5
6
7
8
9

tip：这个角色只对pod 有 get、list权限

然后通过 yaml创建我们的role

# 创建
kubectl apply -f rbac-role.yaml
# 查看
kubectl get role -n role-demo
1
2
3
4

5、创建角色绑定

通过 rbac-rolebinding.yaml的方式，来创建我们的角色绑定

[root@hadoop102 k8s-yaml]# cat rbac-rolebinding.yaml
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: read-pods
  namespace: role-demo
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 创建角色绑定
kubectl apply -f rbac-rolebinding.yaml
# 查看角色绑定
kubectl get role,rolebinding -n role-demo
1
2
3
4

6、使用证书识别身份

rbac-user.sh 证书脚本

cat > mary-csr.json <<EOF
{
  "CN": "mary",
  "hosts": [],
  "key":{
    "algo": "rsa",
    "size": 2048:q!
  },
  "names":[
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing"
    }

  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key.pem -config.json -profile=kubernetes mary-csr.json | cfssljson -bare mary

kubectl config set-cluster kubernetes \
  --certificate-authority=ca.pem \
  --embed-certs=true \
  --server=https://192.168.10.102:6443 \
  --kubeconfig=mary-kubeconfig

kubectl config set-credentials mary \
  --client-key=mary-key.pem \
  --client-certificate=mary.pem \
  --embed-certs=true \
  --kubeconfig=mary-kubeconfig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

包含了很多证书文件，在TSL目录下，需要复制过来（根据尚硅谷学习，最开始二进制位搭建成功。后续补上。后面一点为实际操作）

通过下面命令执行我们的脚本

./rbac-user.sh
1

最后我们进行测试

# 用get命令查看 pod 【有权限】
kubectl get pods -n roledemo
# 用get命令查看svc 【没权限】
kubectl get svc -n roledmeo
1
2
3
4

以下图片来源尚硅谷

Ingress对外暴露端口

原来我们需要将端口号对外暴露，通过 ip + 端口号就可以进行访问

原来是使用Service中的NodePort来实现

• 在每个节点上都会启动端口
• 在访问的时候通过任何节点，通过ip + 端口号就能实现访问

但是NodePort还存在一些缺陷

• 因为端口不能重复，所以每个端口只能使用一次，一个端口对应一个应用
• 实际访问中都是用域名，根据不同域名跳转到不同端口服务中

1、Ingress和Pod关系

pod 和 ingress 是通过service进行关联的，而ingress作为统一入口，由service关联一组pod中

• 首先service就是关联我们的pod
• 然后ingress作为入口，首先需要到service，然后发现一组pod
• 发现pod后，就可以做负载均衡等操作

2、Ingress工作流程

在实际的访问中，都是需要维护很多域名， a.com 和 b.com。然后不同的域名对应的不同的Service，然后service管理不同的pod

需要注意，ingress不是内置的组件，需要我们单独的安装

使用Ingress

步骤如下所示

• 部署ingress Controller【需要下载官方的】
• 创建ingress规则【对哪个Pod、名称空间配置规则】

3、创建Nginx Pod

创建一个nginx应用，然后对外暴露端口

# 创建pod
kubectl create deployment local-nginx --image=nginx
# 查看
kubectl get pods
kubectl get deploy
1
2
3
4
5

对外暴露端口

kubectl expose deployment local-nginx  --port=80 --target-port=80 --type=NodePort
kubectl get svc
1
2

4、部署 ingress controller

这个文件里面，需要注意的是 hostNetwork: true，改成ture是为了让后面访问到

通过这种方式，其实我们在外面就能访问，这里还需要在外面添加一层（https://gitee.com/HaoZhouRS/study-notes）

kubectl apply -f ingress-controller.yaml
1

最后通过下面命令，查看是否成功部署 ingress

kubectl get pods -n ingress-nginx
1

5、创建ingress规则文件

创建ingress规则文件，ingress-rule.yaml

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - host: example.ingredemo.com
    http:
      paths:
      - path: /
        backend:
          serviceName: local-nginx
          servicePort: 80
1
2
3
4
5
6
7
8
9
10
11
12
13

kubectl apply -f ingress-rule.yaml

kubectl get pods -n ingress-nginx -o wide

到节点103上发现可以监听到对应的80端口

添加域名访问规则

在windows 的 hosts文件，添加域名访问规则【因为我们没有域名解析，所以只能这样做】

最后通过域名就能访问

学习路径：https://space.bilibili.com/302417610/，如有侵权，请联系q进行删除：3623472230