黑马 k8s 笔记

主要经历了三个时代：

• 传统部署：在互联网的早期阶段，应用程序将直接部署在物理机器上

  优点：简单，无需参与其他技术

  缺点：资源使用边界不能为应用程序定义，计算资源难以合理分配，程序之间容易产生影响

• 虚拟化部署：多个虚拟机可以在物理机上运行，每个虚拟机都是一个独立的环境

  优点：程序环境不会相互影响，提供一定程度的安全性

  缺点：增加操作系统，浪费部分资源

• 容器化部署：类似于虚拟化，但共享操作系统

  优点：

  每个容器都有自己的文件系统，CPU、内存、工艺空间等

  操作应用程序所需的资源被容器包装，并与底层基础设施解耦

  容器化的应用程序可以跨云服务商、跨Linux部署操作系统发行版

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-iNv19z2f-1648030297048)(Kubenetes.assets/image-20200505183738289.png)]

容器部署带来了很多便利，但也会出现一些问题，如：

• 如何让另一个容器立即启动替补停机的容器故障停机？
• 当并发访问量增加时，如何水平扩展容器数量？

这些容器管理问题统称为容器编排问题是，为了解决这些容器安排问题，生成了一些容器安排软件：

• Swarm：Docker自己的容器编排工具
• Mesos：Apache统一控制资源的工具需要和谐Marathon结合使用
• Kubernetes：Google开源容器编排工具

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-w66llZ5q-1648030297051)(Kubenetes.assets/image-20200524150339551.png)]

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-gZWN9WTf-1648030297052)(Kubenetes.assets/image-20200406232838722.png)]

kubernetes，基于容器技术的全新分布式架构领先方案是谷歌严格保密十多年的秘密武器----Borg2014年9月本于2014年9月发布，2015年7月发布。

kubernetes的本质是一组服务器集群，它可以在集群的每个节点上运行特定的程序来管理节点中的容器。其目的是实现资源管理的自动化，主要提供以下主要功能：

• 自我修复：一旦某个容器崩溃，新的容器可以在1秒左右快速启动
• 弹性伸缩：集群中正在运行的容器数量可根据需要自动调整
• 服务发现：它所依赖的服务可以通过自动发现的形式找到
• 负载均衡：如果一个服务启动多个容器，请求的负载可以自动平衡
• 版本回退：如果发现新发布的程序版本有问题，可以立即回原版
• 存储编排：存储卷可根据容器本身的需要自动创建

一个kubernetes集群主要由控制节点(master)、**工作节点(node)**不同的组件将安装在每个节点上。

master：集群的控制平面，负责集群的决策 ( 管理 )

ApiServer : 唯一的资源操作入口，接收用户输入命令，提供认证、授权、API注册和发现等机制

Scheduler : 负责集群资源度策略，负责集群资源的调度Pod调度到相应的node节点上

ControllerManager : 负责维护集群的状态，比如程序部署安排、故障检测、自动扩展、滚动更新等

Etcd ：负责存储集群中各种资源对象的信息

node：集群数据平面负责为容器提供运行环境 ( 干活 )

Kubelet : 负责维护容器的生命周期，即通过控制docker，创建、更新和销毁容器

KubeProxy : 负责提供集群内的服务发现和负载平衡

Docker : 负责节点上容器的各种操作

[外链图片存储失败，源站可能有防盗链机制，建议保存图片直接上传(img-HuVFPAZ9-1648030297052)(Kubenetes.assets/image-20200406184656917.png)]

下面，部署一个nginx服务来说明kubernetes系统各组件调用关系：

1. 一旦kubernetes环境启动后，master和node他们将存储自己的信息etcd数据库中

2. 一个nginx将首先发送服务安装请求master节点的apiServer组件

3. apiServer组件会调用scheduler组件决定应该安装哪个服务node节点上

   这时，它会从etcd中读取各个node然后根据一定的算法选择节点的信息，并通知结果apiServer

4. apiServer调用controller-manager去调度Node节点安装nginx服务

5. kubelet接到指令后，通知docker，然后由docker来启动一个nginx的pod

   pod是kubernetes容器必须在最小操作单元中运行pod中至此，

6. 一个nginx如果需要访问，服务就会运行。nginx，就需要通过kube-proxy来对pod代理产生访问

这样，外部用户就可以访问集群nginx服务了

Master：每个集群至少需要一个集群控制节点master节点负责集群控制

Node：工作负载节点，由master这些分配容器node然后在工作节点上node节点上的docker负责容器的运行

Pod：kubernetes最小控制单元，容器运行pod中的，一个pod可以有一个或多个容器

Controller：通过控制器实现对pod开始等管理pod、停止pod、伸缩pod的数量等等

Service：pod统一的外部服务入口，以下可以维护同一类的多个pod

目前的生产部署Kubernetes 集群主要有两种方式：

kubeadm

Kubeadm 是一个K8s 提供部署工具kubeadm init 和kubeadm join，用于快速部署Kubernetes 集群。

官方地址：https://kubernetes.io/docs/reference/setup-tools/kubeadmkubeadm/

二进制包

从github 下载发行版的二进制包，手动部署每个组件，组成Kubernetes 集群。

Kubeadm 降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进制包部署Kubernetes 集群，虽然手动部署麻烦点，期间可以学习很多工作原理，也利于后期维护。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r2u0wI3T-1648030297052)(Kubenetes.assets/image-20200404094800622.png)]

kubeadm 是官方社区推出的一个用于快速部署kubernetes 集群的工具，这个工具能通过两条指令完成一个kubernetes 集群的部署：

• 创建一个Master 节点kubeadm init
• 将Node 节点加入到当前集群中$ kubeadm join <Master 节点的IP 和端口>

在开始之前，部署Kubernetes 集群机器需要满足以下几个条件：

• 一台或多台机器，操作系统CentOS7.x-86_x64
• 硬件配置：2GB 或更多RAM，2 个CPU 或更多CPU，硬盘30GB 或更多
• 集群中所有机器之间网络互通
• 可以访问外网，需要拉取镜像
• 禁止swap 分区

• 在所有节点上安装Docker 和kubeadm
• 部署Kubernetes Master
• 部署容器网络插件
• 部署Kubernetes Node，将节点加入Kubernetes 集群中
• 部署Dashboard Web 页面，可视化查看Kubernetes 资源

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SjvAMiiM-1648030297053)(Kubenetes.assets/image-20210609000002940.png)]

# 此方式下安装kubernetes集群要求Centos版本要在7.5或之上
[root@master ~]# cat /etc/redhat-release
Centos Linux 7.5.1804 (Core)

为了方便集群节点间的直接调用，在这个配置一下主机名解析，企业中推荐使用内部DNS服务器

# 主机名成解析 编辑三台服务器的/etc/hosts文件，添加下面内容
192.168.90.100 master
192.168.90.106 node1
192.168.90.107 node2

kubernetes要求集群中的节点时间必须精确一直，这里使用chronyd服务从网络同步时间

企业中建议配置内部的会见同步服务器

# 启动chronyd服务
[root@master ~]# systemctl start chronyd
[root@master ~]# systemctl enable chronyd
[root@master ~]# date

kubernetes和docker 在运行的中会产生大量的iptables规则，为了不让系统规则跟它们混淆，直接关闭系统的规则

# 1 关闭firewalld服务
[root@master ~]# systemctl stop firewalld
[root@master ~]# systemctl disable firewalld
# 2 关闭iptables服务
[root@master ~]# systemctl stop iptables
[root@master ~]# systemctl disable iptables

selinux是linux系统下的一个安全服务，如果不关闭它，在安装集群中会产生各种各样的奇葩问题

# 编辑 /etc/selinux/config 文件，修改SELINUX的值为disable
# 注意修改完毕之后需要重启linux服务
SELINUX=disabled

swap分区指的是虚拟内存分区，它的作用是物理内存使用完，之后将磁盘空间虚拟成内存来使用，启用swap设备会对系统的性能产生非常负面的影响，因此kubernetes要求每个节点都要禁用swap设备，但是如果因为某些原因确实不能关闭swap分区，就需要在集群安装过程中通过明确的参数进行配置说明

# 编辑分区配置文件/etc/fstab，注释掉swap分区一行
# 注意修改完毕之后需要重启linux服务
vim /etc/fstab
注释掉 /dev/mapper/centos-swap swap
# /dev/mapper/centos-swap swap

# 修改linux的内核采纳数，添加网桥过滤和地址转发功能
# 编辑/etc/sysctl.d/kubernetes.conf文件，添加如下配置：
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1

# 重新加载配置
[root@master ~]# sysctl -p
# 加载网桥过滤模块
[root@master ~]# modprobe br_netfilter
# 查看网桥过滤模块是否加载成功
[root@master ~]# lsmod | grep br_netfilter

在Kubernetes中Service有两种带来模型，一种是基于iptables的，一种是基于ipvs的两者比较的话，ipvs的性能明显要高一些，但是如果要使用它，需要手动载入ipvs模块

# 1.安装ipset和ipvsadm
[root@master ~]# yum install ipset ipvsadmin -y
# 2.添加需要加载的模块写入脚本文件
[root@master ~]# cat <<EOF> /etc/sysconfig/modules/ipvs.modules
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF
# 3.为脚本添加执行权限
[root@master ~]# chmod +x /etc/sysconfig/modules/ipvs.modules
# 4.执行脚本文件
[root@master ~]# /bin/bash /etc/sysconfig/modules/ipvs.modules
# 5.查看对应的模块是否加载成功
[root@master ~]# lsmod | grep -e ip_vs -e nf_conntrack_ipv4

# 1、切换镜像源
[root@master ~]# wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo

# 2、查看当前镜像源中支持的docker版本
[root@master ~]# yum list docker-ce --showduplicates

# 3、安装特定版本的docker-ce
# 必须制定--setopt=obsoletes=0，否则yum会自动安装更高版本
[root@master ~]# yum install --setopt=obsoletes=0 docker-ce-18.06.3.ce-3.el7 -y

# 4、添加一个配置文件
#Docker 在默认情况下使用Vgroup Driver为cgroupfs，而Kubernetes推荐使用systemd来替代cgroupfs
[root@master ~]# mkdir /etc/docker
[root@master ~]# cat <<EOF> /etc/docker/daemon.json
{ 
        
	"exec-opts": ["native.cgroupdriver=systemd"],
	"registry-mirrors": ["https://kn0t2bca.mirror.aliyuncs.com"]
}
EOF

# 5、启动dokcer
[root@master ~]# systemctl restart docker
[root@master ~]# systemctl enable docker

# 1、由于kubernetes的镜像在国外，速度比较慢，这里切换成国内的镜像源
# 2、编辑/etc/yum.repos.d/kubernetes.repo,添加下面的配置
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgchech=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
			http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg

# 3、安装kubeadm、kubelet和kubectl
[root@master ~]# yum install --setopt=obsoletes=0 kubeadm-1.17.4-0 kubelet-1.17.4-0 kubectl-1.17.4-0 -y

# 4、配置kubelet的cgroup
#编辑/etc/sysconfig/kubelet, 添加下面的配置
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"

# 5、设置kubelet开机自启
[root@master ~]# systemctl enable kubelet

# 在安装kubernetes集群之前，必须要提前准备好集群需要的镜像，所需镜像可以通过下面命令查看
[root@master ~]# kubeadm config images list

# 下载镜像
# 此镜像kubernetes的仓库中，由于网络原因，无法连接，下面提供了一种替换方案
images=(
	kube-apiserver:v1.17.4
	kube-controller-manager:v1.17.4
	kube-scheduler:v1.17.4
	kube-proxy:v1.17.4
	pause:3.1
	etcd:3.4.3-0
	coredns:1.6.5
)

for imageName in ${ 
        images[@]};do
	docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName
	docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName k8s.gcr.io/$imageName
	docker rmi registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName 
done

# 重启
[root@master ~]# reboot

下面的操作只需要在master节点上执行即可

# 创建集群
[root@master ~]# kubeadm init \
	--apiserver-advertise-address=192.168.90.100 \
	--image-repository registry.aliyuncs.com/google_containers \
	--kubernetes-version=v1.17.4 \
	--service-cidr=10.96.0.0/12 \
	--pod-network-cidr=10.244.0.0/16
# 创建必要文件
[root@master ~]# mkdir -p $HOME/.kube
[root@master ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[root@master ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config

下面的操作只需要在node节点上执行即可

kubeadm join 192.168.0.100:6443 --token awk15p.t6bamck54w69u4s8 \
    --discovery-token-ca-cert-hash sha256:a94fa09562466d32d29523ab6cff122186f1127599fa4dcd5fa0152694f17117 

在master上查看节点信息

[root@master ~]# kubectl get nodes
NAME    STATUS   ROLES     AGE   VERSION
master  NotReady  master   6m    v1.17.4
node1   NotReady   <none>  22s   v1.17.4
node2   NotReady   <none>  19s   v1.17.4

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

由于外网不好访问，如果出现无法访问的情况，可以直接用下面的 记得文件名是kube-flannel.yml，位置：/root/kube-flannel.yml内容：

https://github.com/flannel-io/flannel/tree/master/Documentation/kube-flannel.yml

使用配置文件启动fannel

kubectl apply -f kube-flannel.yml

#在master节点之外的节点进行操作
kubeadm reset
systemctl stop kubelet
systemctl stop docker
rm -rf /var/lib/cni/
rm -rf /var/lib/kubelet/*
rm -rf /etc/cni/
ifconfig cni0 down
ifconfig flannel.1 down
ifconfig docker0 down
ip link delete cni0
ip link delete flannel.1
##重启kubelet
systemctl restart kubelet
##重启docker
systemctl restart docker

# 重启kubelet
systemctl restart kubelet
# 重启docker
systemctl restart docker

等待它安装完毕 发现已经是 集群的状态已经是Ready

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bUYobp8A-1648030297054)(images/2232696-20210621233106024-1676033717.png)]

# 生成 新的token
[root@master ~]# kubeadm token create --print-join-command

kubectl create deployment nginx  --image=nginx:1.14-alpine

kubectl expose deploy nginx  --port=80 --target-port=80  --type=NodePort

kubectl get pod,svc

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aJGGoCzn-1648030297054)(images/2232696-20210621233130477-111035427.png)]

浏览器测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cfevOLsI-1648030297055)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220307173915622.png)]

在kubernetes中，所有的内容都抽象为资源，用户需要通过操作资源来管理kubernetes。

kubernetes的本质上就是一个集群系统，用户可以在集群中部署各种服务，所谓的部署服务，其实就是在kubernetes集群中运行一个个的容器，并将指定的程序跑在容器中。

kubernetes的最小管理单元是pod而不是容器，所以只能将容器放在Pod中，而kubernetes一般也不会直接管理Pod，而是通过Pod控制器来管理Pod的。

Pod可以提供服务之后，就要考虑如何访问Pod中服务，kubernetes提供了Service资源实现这个功能。

当然，如果Pod中程序的数据需要持久化，kubernetes还提供了各种存储系统。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZC9WiYrh-1648030297055)(Kubenetes.assets/image-20200406225334627.png)]

学习kubernetes的核心，就是学习如何对集群上的Pod、Pod控制器、Service、存储等各种资源进行操作

YAML是一个类似 XML、JSON 的标记性语言。它强调以数据为中心，并不是以标识语言为重点。因而YAML本身的定义比较简单，号称"一种人性化的数据格式语言"。

<heima>
    <age>15</age>
    <address>Beijing</address>
</heima>

heima:
  age: 15
  address: Beijing

YAML的语法比较简单，主要有下面几个：

• 大小写敏感
• 使用缩进表示层级关系
• 缩进不允许使用tab，只允许空格( 低版本限制 )
• 缩进的空格数不重要，只要相同层级的元素左对齐即可
• '#'表示注释

YAML支持以下几种数据类型：

• 纯量：单个的、不可再分的值
• 对象：键值对的集合，又称为映射（mapping）/ 哈希（hash） / 字典（dictionary）
• 数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）

# 纯量, 就是指的一个简单的值，字符串、布尔值、整数、浮点数、Null、时间、日期
# 1 布尔类型
c1: true (或者True)
# 2 整型
c2: 234
# 3 浮点型
c3: 3.14
# 4 null类型 
c4: ~  # 使用~表示null
# 5 日期类型
c5: 2018-02-17    # 日期必须使用ISO 8601格式，即yyyy-MM-dd
# 6 时间类型
c6: 2018-02-17T15:02:31+08:00  # 时间使用ISO 8601格式，时间和日期之间使用T连接，最后使用+代表时区
# 7 字符串类型
c7: heima     # 简单写法，直接写值 , 如果字符串中间有特殊字符，必须使用双引号或者单引号包裹 
c8: line1
    line2     # 字符串过多的情况可以拆成多行，每一行会被转化成一个空格

# 对象
# 形式一(推荐):
heima:
  age: 15
  address: Beijing
# 形式二(了解):
heima: { 
        age: 15,address: Beijing}

# 数组
# 形式一(推荐):
address:
  - 顺义
  - 昌平  
# 形式二(了解):
address: [顺义,昌平]

小提示：

1 书写yaml切记: 后面要加一个空格

2 如果需要将多段yaml配置放在一个文件中，中间要使用---分隔

3 下面是一个yaml转json的网站，可以通过它验证yaml是否书写正确

https://www.json2yaml.com/convert-yaml-to-json

• 命令式对象管理：直接使用命令去操作kubernetes资源

  kubectl run nginx-pod --image=nginx:1.17.1 --port=80
  

• 命令式对象配置：通过命令配置和配置文件去操作kubernetes资源

  kubectl create/patch -f nginx-pod.yaml
  

• 声明式对象配置：通过apply命令和配置文件去操作kubernetes资源

  kubectl apply -f nginx-pod.yaml
  

kubectl命令

kubectl是kubernetes集群的命令行工具，通过它能够对集群本身进行管理，并能够在集群上进行容器化应用的安装部署。kubectl命令的语法如下：

kubectl [command] [type] [name] [flags]

comand：指定要对资源执行的操作，例如create、get、delete

type：指定资源类型，比如deployment、pod、service

name：指定资源的名称，名称大小写敏感

flags：指定额外的可选参数

# 查看所有pod
kubectl get pod 

# 查看某个pod
kubectl get pod pod_name

# 查看某个pod,以yaml格式展示结果
kubectl get pod pod_name -o yaml

资源类型

kubernetes中所有的内容都抽象为资源，可以通过下面的命令进行查看:

kubectl api-resources

经常使用的资源有下面这些：

操作

kubernetes允许对资源进行多种操作，可以通过–help查看详细的操作命令

kubectl --help

经常使用的操作有下面这些：

下面以一个namespace / pod的创建和删除简单演示下命令的使用：

# 创建一个namespace
[root@master ~]# kubectl create namespace dev
namespace/dev created

# 获取namespace
[root@master ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   21h
dev               Active   21s
kube-node-lease   Active   21h
kube-public       Active   21h
kube-system       Active   21h

# 在此namespace下创建并运行一个nginx的Pod
[root@master ~]# kubectl run pod --image=nginx:latest -n dev
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/pod created

# 查看新创建的pod
[root@master ~]# kubectl get pod -n dev
NAME  READY   STATUS    RESTARTS   AGE
pod   1/1     Running   0          21s

# 删除指定的pod
[root@master ~]# kubectl delete pod pod-864f9875b9-pcw7x
pod "pod" deleted

# 删除指定的namespace
[root@master ~]# kubectl delete ns dev
namespace "dev" deleted

命令式对象配置就是使用命令配合配置文件一起来操作kubernetes资源。

1） 创建一个nginxpod.yaml，内容如下：

apiVersion: v1
kind: Namespace
metadata:
  name: dev

---

apiVersion: v1
kind: Pod
metadata:
  name: nginxpod
  namespace: dev
spec:
  containers:
  - name: nginx-containers
    image: nginx:latest

2）执行create命令，创建资源：

[root@master ~]# kubectl create -f nginxpod.yaml
namespace/dev created
pod/nginxpod created

此时发现创建了两个资源对象，分别是namespace和pod

3）执行get命令，查看资源：

[root@master ~]# kubectl get -f nginxpod.yaml
NAME            STATUS   AGE
namespace/dev   Active   18s

NAME            READY   STATUS    RESTARTS   AGE
pod/nginxpod    1/1     Running   0          17s

这样就显示了两个资源对象的信息

4）执行delete命令，删除资源：

[root@master ~]# kubectl delete -f nginxpod.yaml
namespace "dev" deleted
pod "nginxpod" deleted

此时发现两个资源对象被删除了

总结:
    命令式对象配置的方式操作资源，可以简单的认为：命令  +  yaml配置文件（里面是命令需要的各种参数）

声明式对象配置跟命令式对象配置很相似，但是它只有一个命令apply。

# 首先执行一次kubectl apply -f yaml文件，发现创建了资源
[root@master ~]# kubectl apply -f nginxpod.yaml
namespace/dev created
pod/nginxpod created

# 再次执行一次kubectl apply -f yaml文件，发现说资源没有变动
[root@master ~]# kubectl apply -f nginxpod.yaml
namespace/dev unchanged
pod/nginxpod unchanged

总结:
    其实声明式对象配置就是使用apply描述一个资源最终的状态（在yaml中定义状态）
    使用apply操作资源：
        如果资源不存在，就创建，相当于 kubectl create
        如果资源已存在，就更新，相当于 kubectl patch

扩展：kubectl可以在node节点上运行吗 ?

kubectl的运行是需要进行配置的，它的配置文件是$HOME/.kube，如果想要在node节点运行此命令，需要将master上的.kube文件复制到node节点上，即在master节点上执行下面操作：

scp  -r  HOME/.kube   node1: HOME/

使用推荐: 三种方式应该怎么用 ?

创建/更新资源 使用声明式对象配置 kubectl apply -f XXX.yaml

删除资源 使用命令式对象配置 kubectl delete -f XXX.yaml

查询资源 使用命令式对象管理 kubectl get(describe) 资源名称

本章节将介绍如何在kubernetes集群中部署一个nginx服务，并且能够对其进行访问。

Namespace是kubernetes系统中的一种非常重要资源，它的主要作用是用来实现多套环境的资源隔离或者多租户的资源隔离。

默认情况下，kubernetes集群中的所有的Pod都是可以相互访问的。但是在实际中，可能不想让两个Pod之间进行互相的访问，那此时就可以将两个Pod划分到不同的namespace下。kubernetes通过将集群内部的资源分配到不同的Namespace中，可以形成逻辑上的"组"，以方便不同的组的资源进行隔离使用和管理。

可以通过kubernetes的授权机制，将不同的namespace交给不同租户进行管理，这样就实现了多租户的资源隔离。此时还能结合kubernetes的资源配额机制，限定不同租户能占用的资源，例如CPU使用量、内存使用量等等，来实现租户可用资源的管理。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7eXBdo4Y-1648030297056)(Kubenetes.assets/image-20200407100850484.png)]

kubernetes在集群启动之后，会默认创建几个namespace

[root@master ~]# kubectl get namespace
NAME              STATUS   AGE
default           Active   45h     # 所有未指定Namespace的对象都会被分配在default命名空间
kube-node-lease   Active   45h     # 集群节点之间的心跳维护，v1.13开始引入
kube-public       Active   45h     # 此命名空间下的资源可以被所有人访问（包括未认证用户）
kube-system       Active   45h     # 所有由Kubernetes系统创建的资源都处于这个命名空间

下面来看namespace资源的具体操作：

# 1 查看所有的ns 命令：kubectl get ns
[root@master ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   45h
kube-node-lease   Active   45h
kube-public       Active   45h     
kube-system       Active   45h     

# 2 查看指定的ns 命令：kubectl get ns ns名称
[root@master ~]# kubectl get ns default
NAME      STATUS   AGE
default   Active   45h

# 3 指定输出格式 命令：kubectl get ns ns名称 -o 格式参数
# kubernetes支持的格式有很多，比较常见的是wide、json、yaml
[root@master ~]# kubectl get ns default -o yaml
apiVersion: v1
kind: Namespace
metadata: