Kubernetes ~ k8s 从入门到入坑。

置顶 已于 2023-12-25 16:50:04 修改
阅读量4.6k 收藏 61
点赞数 12
分类专栏： k8s。 Linux。 文章标签： Kubernetes k8s
于 2022-12-09 16:01:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyfGeek/article/details/127461391
版权

Kubernetes ~ k8s 从入门到入坑。

文章目录

1. Kubernetes 介绍。

1.1 应用部署方式演变。

在部署应用程序的方式上，主要经历了三个时代。

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

优点：简单，不需要其它技术的参与。

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

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

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

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

  • 容器化部署：与虚拟化类似，但是共享了操作系统。

优点。
可以保证每个容器拥有自己的文件系统、CPU、内存、进程空间等。
运行应用程序所需要的资源都被容器包装，并和底层基础架构解耦。
容器化的应用程序可以跨云服务商、跨 Linux 操作系统发行版进行部署。

在这里插入图片描述

容器化部署方式给带来很多的便利，但是也会出现一些问题，比如说。

  • 一个容器故障停机了，怎么样让另外一个容器立刻启动去替补停机的容器。
  • 当并发访问量变大的时候，怎么样做到横向扩展容器数量。

这些容器管理的问题统称为容器编排问题，为了解决这些容器编排问题，就产生了一些容器编排的软件。

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

1.2 kubernetes 简介。

在这里插入图片描述

kubernetes，是一个全新的基于容器技术的分布式架构领先方案，是谷歌严格保密十几年的秘密武器 —— Borg 系统的一个开源版本，于 2014 年 9 月发布第一个版本，2015 年 7 月发布第一个正式版本。

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

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

1.3 kubernetes 组件。

一个 kubernetes 集群主要是由控制节点（master）、工作节点（node）构成，每个节点上都会安装不同的组件。

master：集群的控制平面，负责集群的决策（管理）。

ApiServer：资源操作的唯一入口，接收用户输入的命令，提供认证、授权、API 注册和发现等机制。
Scheduler：负责集群资源调度，按照预定的调度策略将 Pod 调度到相应的 node 节点上。
ControllerManager：负责维护集群的状态，比如程序部署安排、故障检测、自动扩展、滚动更新等。
Etcd：负责存储集群中各种资源对象的信息。

node：集群的数据平面，负责为容器提供运行环境（干活）。

Kubelet：负责维护容器的生命周期，即通过控制 docker，来创建、更新、销毁容器。
KubeProxy：负责提供集群内部的服务发现和负载均衡。
Docker：负责节点上容器的各种操作。
在这里插入图片描述

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

  • 首先要明确，一旦 kubernetes 环境启动之后，master 和 node 都会将自身的信息存储到 etcd 数据库中。

  • 一个 Nginx 服务的安装请求会首先被发送到 master 节点的 apiServer 组件。

  • apiServer 组件会调用 scheduler 组件来决定到底应该把这个服务安装到哪个 node 节点上。
    在此时，它会从 etcd 中读取各个 node 节点的信息，然后按照一定的算法进行选择，并将结果告知 apiServer。

  • apiServer 调用 controller-manager 去调度 node 节点安装 Nginx 服务。

  • kubelet 接收到指令后，会通知 docker，然后由 docker 来启动一个 Nginx 的 pod。
    pod 是 kubernetes 的最小操作单元，容器必须跑在 pod 中。

  • 至此，一个 Nginx 服务就运行了，如果需要访问 Nginx，就需要通过 kube-proxy 来对 pod 产生访问的代理。
    这样，外界用户就可以访问集群中的 Nginx 服务了。


1.4 kubernetes 概念。

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

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

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

Controller：控制器，通过它来实现对 pod 的管理，比如启动 pod、停止 pod、伸缩 pod 的数量等等。

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

Label：标签，用于对 pod 进行分类，同一类 pod 会拥有相同的标签。（app:tom、app:tomcat）

NameSpace：命名空间，用来隔离 pod 的运行环境。（虚线）。

在这里插入图片描述


2. kubernetes 集群环境搭建。

https://www.yuque.com/fairy-era/yg511q/hg3u04

在这里插入图片描述

2.1 前置知识点。

目前生产部署 Kubernetes 集群主要有：

  • minikube：用于快速搭建单节点 kubernetes 的工具。

  • kubeadm。

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

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

  • 二进制包。

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

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


2.2 kubeadm 部署方式介绍。

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

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

2.3 安装要求。

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

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

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

2.5 准备环境。
角色 IP 地址 组件
master01 192.168.142.150 docker，kubectl，kubeadm，kubelet
node01 192.168.142.151 docker，kubectl，kubeadm，kubelet
node02 192.168.142.152 docker，kubectl，kubeadm，kubelet

2.6 环境初始化。

http://mirrors.163.com/.help/centos.html

2.6.1 检查操作系统的版本。
# 此方式下安装 kubernetes 集群要求 Centos 版本要在 7.5 或之上。
[root@localhost ~]# cat /etc/redhat-release
CentOS Linux release 7.9.2009 (Core)

2.6.2 主机名解析。

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

vim /etc/hosts
# 主机名成解析 编辑三台服务器的 /etc/hosts 文件，添加下面内容。
192.168.142.150 localhost.localdomain.k8s.master
192.168.142.151 localhost.localdomain.k8s.node1
192.168.142.152 localhost.localdomain.k8s.node2

2.6.3 时间同步。

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

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

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

2.6.4 禁用 iptables 和 firewalld 服务。

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

# 关闭 firewalld 服务。
[root@localhost ~]# systemctl stop firewalld
[root@localhost ~]# systemctl disable firewalld
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
[root@localhost ~]# systemctl stop iptables
Failed to stop iptables.service: Unit iptables.service not loaded.
[root@localhost ~]# systemctl disable iptables
Failed to execute operation: No such file or directory

2.6.5 禁用 selinux。

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

[root@localhost ~]# getenforce
Enforcing

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



# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
#     enforcing - SELinux security policy is enforced.
#     permissive - SELinux prints warnings instead of enforcing.
#     disabled - No SELinux policy is loaded.
# SELINUX=enforcing
SELINUX=disabled
# SELINUXTYPE= can take one of three values:
#     targeted - Targeted processes are protected,
#     minimum - Modification of targeted policy. Only selected processes are protected. 
#     mls - Multi Level Security protection.
SELINUXTYPE=targeted


sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

2.6.6 禁用 swap 分区。

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

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

[root@localhost ~]# vim /etc/fstab


#

#
# /etc/fstab
# Created by anaconda on Thu Dec  1 01:25:13 2022

#
# /etc/fstab
# Created by anaconda on Thu Dec  1 01:25:13 2022
#
# Accessible filesystems, by reference, are maintained under '/dev/disk'
# See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info
#
/dev/mapper/centos_localhost-root /                       xfs     defaults        0 0
UUID=c393aaa9-2e37-4fa2-8b32-e8b88af1e576 /boot                   xfs     defaults        0 0
/dev/mapper/centos_localhost-home /home                   xfs     defaults        0 0
#  /dev/mapper/centos_localhost-swap swap                    swap    defaults        0 0


sudo swapoff -a
sudo sed -ri 's/.*swap.*/#&/' /etc/fstab

2.6.7 修改 linux 的内核参数。
vim /etc/sysctl.d/kubernetes.comf

# 修改 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@localhost ~]# lsmod | grep br_netfilter
br_netfilter           22256  0 
bridge                151336  1 br_netfilter

2.6.8 配置 ipvs 功能。

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

# 安装 ipset 和 ipvsadm。
[root@master ~]# yum install ipset ipvsadm -y
# 添加需要加载的模块写入脚本文件。
[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
# 为脚本添加执行权限。
[root@master ~]# chmod +x /etc/sysconfig/modules/ipvs.modules
# 执行脚本文件。
[root@master ~]# /bin/bash /etc/sysconfig/modules/ipvs.modules
# 查看对应的模块是否加载成功。
[root@localhost ~]# lsmod | grep -e ip_vs -e nf_conntrack_ipv4
nf_conntrack_ipv4      15053  0 
nf_defrag_ipv4         12729  1 nf_conntrack_ipv4
ip_vs_sh               12688  0 
ip_vs_wrr              12697  0 
ip_vs_rr               12600  0 
ip_vs                 145458  6 ip_vs_rr,ip_vs_sh,ip_vs_wrr
nf_conntrack          139264  2 ip_vs,nf_conntrack_ipv4
libcrc32c              12644  3 xfs,ip_vs,nf_conntrack

重启。

[root@localhost ~]# getenforce
Disabled
[root@localhost ~]# free -m
              total        used        free      shared  buff/cache   available
Mem:           1819         193        1451           9         174        1476
Swap:             0           0           0
[root@localhost ~]#

* 允许 iptables 检查桥接流量（所有节点）。
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

sudo sysctl --system

2.6.9 安装 docker。

https://docs.docker.com/engine/install/centos/

sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io docker-compose-plugin

18.06.3.ce-3.el7

sudo yum install docker-ce-18.06.3.ce-3.el7 docker-ce-cli-18.06.3.ce-3.el7 containerd.io docker-compose-plugin

yum clean all
yum makecache

# 切换镜像源。
[root@master ~]# wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
# 查看当前镜像源中支持的 docker 版本。
[root@master ~]# yum list docker-ce --showduplicates
# 安装特定版本的 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://***.mirror.aliyuncs.com"]
}
EOF
# 启动 dokcer。
[root@master ~]# systemctl restart docker
[root@master ~]# systemctl enable docker
[root@localhost ~]# sudo systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.


sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": ["https://***.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
sudo systemctl enable docker
[root@localhost ~]# sudo systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

sudo yum install --setopt=obsoletes=0 docker-ce-18.06.3.ce-3.el7 docker-ce-cli containerd.io docker-compose-plugin


2.6.10 安装 Kubernetes 组件。

https://developer.aliyun.com/mirror/kubernetes

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
setenforce 0
# yum install -y kubelet kubeadm kubectl
# systemctl enable kubelet && systemctl start kubelet


# 由于 kubernetes 的镜像在国外，速度比较慢，这里切换成国内的镜像源。
# 编辑 /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

# 安装 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


# 配置 kubelet 的 cgroup。
vim /etc/sysconfig/kubelet
# 编辑 /etc/sysconfig/kubelet, 添加下面的配置。
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"
# 5、设置 kubelet 开机自启。
[root@master ~]# systemctl enable kubelet

2.6.11 准备集群镜像。
# 在安装 kubernetes 集群之前，必须要提前准备好集群需要的镜像，所需镜像可以通过下面命令查看。
[root@localhost ~]# kubeadm config images list
W1201 23:46:05.541002   55376 version.go:101] could not fetch a Kubernetes version from the internet: unable to get URL "https://dl.k8s.io/release/stable-1.txt": Get https://storage.googleapis.com/kubernetes-release/release/stable-1.txt: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
W1201 23:46:05.541156   55376 version.go:102] falling back to the local client version: v1.17.4
W1201 23:46:05.541308   55376 validation.go:28] Cannot validate kube-proxy config - no validator is available
W1201 23:46:05.541316   55376 validation.go:28] Cannot validate kubelet config - no validator is available
k8s.gcr.io/kube-apiserver:v1.17.4
k8s.gcr.io/kube-controller-manager:v1.17.4
k8s.gcr.io/kube-scheduler:v1.17.4
k8s.gcr.io/kube-proxy:v1.17.4
k8s.gcr.io/pause:3.1
k8s.gcr.io/etcd:3.4.3-0
k8s.gcr.io/coredns:1.6.5
[root@localhost ~]# 

# 下载镜像。
# 此镜像 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@localhost ~]# docker images
REPOSITORY                           TAG                 IMAGE ID            CREATED             SIZE
k8s.gcr.io/kube-proxy                v1.17.4             6dec7cfde1e5        2 years ago         116MB
k8s.gcr.io/kube-apiserver            v1.17.4             2e1ba57fe95a        2 years ago         171MB
k8s.gcr.io/kube-controller-manager   v1.17.4             7f997fcf3e94        2 years ago         161MB
k8s.gcr.io/kube-scheduler            v1.17.4             5db16c1c7aff        2 years ago         94.4MB
k8s.gcr.io/coredns                   1.6.5               70f311871ae1        3 years ago         41.6MB
k8s.gcr.io/etcd                      3.4.3-0             303ce5db0e90        3 years ago         288MB
k8s.gcr.io/pause                     3.1                 da86e6ba6ca1        4 years ago         742kB

2.6.12 集群初始化。

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

https://kubernetes.io/zh-cn/docs/reference/setup-tools/kubeadm/kubeadm-init/

k8s 内部网络，可以自己指定。不和宿主机一样。
10.244.0.0/16
10.96.0.0/12

# 创建集群。
[root@master ~]# kubeadm init \
	--apiserver-advertise-address=192.168.142.150 \
	--image-repository=registry.aliyuncs.com/google_containers \
	--kubernetes-version=v1.17.4 \
	--pod-network-cidr=10.244.0.0/16 \
	--service-cidr=10.96.0.0/12
# To start using your cluster, you need to run the following as a regular user:
[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

[root@localhost ~]# kubeadm init \
> --apiserver-advertise-address=192.168.142.150 \
> --image-repository=registry.aliyuncs.com/google_containers \
> --kubernetes-version=v1.17.4 \
> --pod-network-cidr=10.244.0.0/16 \
> --service-cidr=10.96.0.0/12
W1202 00:11:31.437970   57290 validation.go:28] Cannot validate kubelet config - no validator is available
W1202 00:11:31.438028   57290 validation.go:28] Cannot validate kube-proxy config - no validator is available
[init] Using Kubernetes version: v1.17.4
[preflight] Running pre-flight checks
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'

[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Starting the kubelet
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [localhost.localdomain.k8s.master kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 192.168.142.150]
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "front-proxy-ca" certificate and key
[certs] Generating "front-proxy-client" certificate and key
[certs] Generating "etcd/ca" certificate and key
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [localhost.localdomain.k8s.master localhost] and IPs [192.168.142.150 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [localhost.localdomain.k8s.master localhost] and IPs [192.168.142.150 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "sa" key and public key
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "kubelet.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
W1202 00:19:51.720839   57290 manifests.go:214] the default kube-apiserver authorization-mode is "Node,RBAC"; using "Node,RBAC"
[control-plane] Creating static Pod manifest for "kube-scheduler"
W1202 00:19:51.721669   57290 manifests.go:214] the default kube-apiserver authorization-mode is "Node,RBAC"; using "Node,RBAC"
[etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
[wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s
[apiclient] All control plane components are healthy after 23.003244 seconds
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.17" in namespace kube-system with the configuration for the kubelets in the cluster
[upload-certs] Skipping phase. Please see --upload-certs
[mark-control-plane] Marking the node localhost.localdomain.k8s.master as control-plane by adding the label "node-role.kubernetes.io/master=''"
[mark-control-plane] Marking the node localhost.localdomain.k8s.master as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[bootstrap-token] Using token: xs70mz.1j3eaj8unj3g11cp
[bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstrap-token] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstrap-token] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace
[kubelet-finalize] Updating "/etc/kubernetes/kubelet.conf" to point to a rotatable kubelet client certificate and key
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.142.150:6443 --token xs70mz.1j3eaj8unj3g11cp \
    --discovery-token-ca-cert-hash sha256:8cb8adbc0147bc1c15fc689f98ab49e8442d16d28e85062d2db9b8f47225c6cc 
[root@localhost ~]# 


[root@localhost ~]# kubectl get nodes
NAME                               STATUS     ROLES    AGE     VERSION
localhost.localdomain.k8s.master   NotReady   master   4m11s   v1.17.4

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

[root@localhost ~]# kubeadm join 192.168.142.150:6443 --token xs70mz.1j3eaj8unj3g11cp \
>     --discovery-token-ca-cert-hash sha256:8cb8adbc0147bc1c15fc689f98ab49e8442d16d28e85062d2db9b8f47225c6cc 
W1202 00:25:46.290777   86902 join.go:346] [preflight] WARNING: JoinControlPane.controlPlane settings will be ignored when control-plane flag is not set.
[preflight] Running pre-flight checks
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml'
[kubelet-start] Downloading configuration for the kubelet from the "kubelet-config-1.17" ConfigMap in the kube-system namespace
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Starting the kubelet
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

在 master 上查看节点信息。

[root@localhost ~]# kubectl get nodes
NAME                               STATUS     ROLES    AGE     VERSION
localhost.localdomain.k8s.master   NotReady   master   6m31s   v1.17.4
localhost.localdomain.k8s.node1    NotReady   <none>   56s     v1.17.4
localhost.localdomain.k8s.node2    NotReady   <none>   52s     v1.17.4

NotReady

↓ ↓ ↓


2.6.13 安装网络插件，只在 master 节点操作即可。

kubernetes 支持多种网络插件。eg. flannel、calico、canal 等。任选一种使用即可。本次选择 flannel。

下面操作依旧只在 master 节点执行即可，插件使用的是 DaemonSet 的控制器，ta 会在每个节点上都运行。

  • 获取 fannel 的配置文件。

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

《k8s ~ kube-flannel.yml。》

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

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

《k8s ~ kube-flannel.yml。》

修改文件中的 quay.io 仓库为 quay-mirror.qiniu.com。

  • 使用配置文件启动 fannel。

kubectl apply -f kube-flannel.yml

稍等片刻。

[root@localhost k8s]# kubectl apply -f kube-flannel.yml 
namespace/kube-flannel created
clusterrole.rbac.authorization.k8s.io/flannel created
clusterrolebinding.rbac.authorization.k8s.io/flannel created
serviceaccount/flannel created
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds created

[root@localhost k8s]# kubectl get nodes
NAME                               STATUS   ROLES    AGE   VERSION
localhost.localdomain.k8s.master   Ready    master   62m   v1.17.4
localhost.localdomain.k8s.node1    Ready    <none>   57m   v1.17.4
localhost.localdomain.k8s.node2    Ready    <none>   57m   v1.17.4

也可手动拉取指定版本。

# 拉取 flannel 网络，三台主机。
docker pull quay.io/coreos/flannel:v0.14.0
# 查看仓库是否拉去下来。
docker images

若是集群状态一直是 notready，用下面语句查看原因。

journalctl -f -u kubelet.service

若原因是： cni.go:237] Unable to update cni config: no networks found in /etc/cni/net.d

mkdir -p /etc/cni/net.d
vim /etc/cni/net.d/10-flannel.conf


{
   
 "name":"cbr0",
 "cniVersion":"0.3.1",
 "type":"flannel",
 "deledate":{
   
    "hairpinMode":true,
    "isDefaultGateway":true
  }

}

2.6.14 使用 kubeadm reset 重置集群。
# 在 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

2.6.15 重启 kubelet 和 docker。
# 重启 kubelet
systemctl restart kubelet
# 重启 docker
systemctl restart docker

使用配置文件启动 fannel。

kubectl apply -f kube-flannel.yml

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


2.6.16 kubeadm 中的命令。
# 生成新的 token。
[root@master ~]# kubeadm token create --print-join-command

2.7 集群测试。
2.7.1 创建一个 nginx 服务。
[root@localhost k8s]# kubectl create deployment nginx --image=nginx:1.14-alpine
deployment.apps/nginx created

2.7.2 暴露端口。
[root@localhost k8s]# kubectl expose deploy nginx --port=80 --target-port=80 --type=NodePort
service/nginx exposed

2.7.3 查看服务。
2.7.4 查看 pod。
[root@localhost k8s]# kubectl get pod
NAME                     READY   STATUS              RESTARTS   AGE
nginx-6867cdf567-5p8k4   0/1     ContainerCreating   0          83s


[root@localhost k8s]# kubectl get pod
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6867cdf567-5p8k4   1/1     Running   0          2m47s


[root@localhost k8s]# kubectl get svc
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1      <none>        443/TCP        71m
nginx        NodePort    10.107.6.137   <none>        80:31567/TCP   67s

在这里插入图片描述


3. 资源管理。

3.1 资源管理介绍。

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

kubernetes 的本质上就是一个集群系统，用户可以在集群中部署各种服务，所谓的部署服务，其实就是在 kubernetes 集群中运行一个个的容器，并将指定的程序跑在容器中。
kubernetes 的最小管理单元是 pod 而不是容器，所以只能将容器放在Pod中，而 kubernetes 一般也不会直接管理 Pod，而是通过Pod 控制器来管理 Pod 的。
Pod 可以提供服务之后，就要考虑如何访问 Pod 中服务，kubernetes 提供了 Service 资源实现这个功能。
当然，如果 Pod 中程序的数据需要持久化，kubernetes 还提供了各种存储系统。

在这里插入图片描述

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


3.2 YAML 语言介绍。

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

<geek>
    <age>15</age>
    <address>Beijing</address>
</geek>

geek:
  age: 15
  address: Beijing

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

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

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

  • 纯量：单个的、不可再分的值。
  • 对象：键值对的集合，又称为映射（mapping）/哈希（hash）/字典（dictionary）。
  • 数组：一组按次序排列的值，又称为序列（sequence）/列表（list）。
# 纯量, 就是指的一个简单的值，字符串、布尔值、整数、浮点数、Null、时间、日期。
# 布尔类型。
eg. true (或者 True)
# 整型。
eg. 234
# 浮点型。
eg. 3.14
# null 类型。 
eg. ~  # 使用 ~ 表示 null。
# 日期类型。
eg. 2018-02-17  # 日期必须使用 ISO 8601 格式，即 yyyy-MM-dd。
# 时间类型。
eg. 2018-02-17T15:02:31+08:00  # 时间使用 ISO 8601 格式，时间和日期之间使用 T 连接，最后使用 + 代表时区。
# 字符串类型。
eg. geek  # 简单写法，直接写值，如果字符串中间有特殊字符，必须使用双引号或者单引号包裹。 
eg. line1
    line2  # 字符串过多的情况可以拆成多行，每一行会被转化成一个空格。

# 对象。
# 形式一（推荐）。
geek:
  age: 15
  address: Beijing
# 形式二（了解）。
geek: {
   age: 15, address: Beijing}

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

tips

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

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

  • 下面是一个 yaml 转 json 的网站，可以通过它验证 yaml 是否书写正确。
    https://www.json2yaml.com/convert-yaml-to-json。


3.3 资源管理方式。
  • 命令式对象管理：直接使用命令去操作 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
# 创建 or 更新。
类型 操作对象 适用环境 优点 缺点
命令式对象管理 对象 测试 简单 只能操作活动对象，无法审计、跟踪
命令式对象配置 文件 开发 可以审计、跟踪 项目大时，配置文件多，操作麻烦
声明式对象配置 目录 开发 支持目录操作 意外情况下难以调试

3.3.1 命令式对象管理。

kubectl 命令。

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

  • kubectl 命令的语法。
kubectl [command] [type] [name] [flags]

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

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

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

flags：指定额外的可选参数。

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

[root@localhost ~]# kubectl version
Client Version: version.Info{
   Major:"1", Minor:"17", GitVersion:"v1.17.4", GitCommit:"8d8aa39598534325ad77120c120a22b3a990b5ea", GitTreeState:"clean", BuildDate:"2020-03-12T21:03:42Z", GoVersion:"go1.13.8", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{
   Major:"1", Minor:"17", GitVersion:"v1.17.4", GitCommit:"8d8aa39598534325ad77120c120a22b3a990b5ea", GitTreeState:"clean", BuildDate:"2020-03-12T20:55:23Z", GoVersion:"go1.13.8", Compiler:"gc", Platform:"linux/amd64"}

[root@localhost ~]# kubectl cluster-info
Kubernetes master is running at https://192.168.142.150:6443
KubeDNS is running at https://192.168.142.150:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

资源类型。

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

kubectl api-resources

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

资源分类 资源名称 缩写 资源作用
集群级别资源 nodes no 集群组成部分
namespaces ns 隔离 Pod
pod 资源 pods po 装载容器
pod 资源控制器 replicationcontrollers rc 控制 pod 资源
replicasets rs 控制 pod 资源
deployments deploy 控制 pod 资源
daemonsets ds 控制 pod 资源
jobs 控制 pod 资源
cronjobs cj 控制 pod 资源
horizontalpodautoscalers hpa 控制 pod 资源
statefulsets sts 控制 pod 资源
服务发现资源 services svc 统一 pod 对外接口
ingress ing 统一 pod 对外接口
存储资源 volumeattachments 存储
persistentvolumes pv 存储
persistentvolumeclaims pvc 存储
配置资源 configmaps cm 配置
secrets 配置

操作。

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

kubectl --help

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

命令分类 命令 翻译 命令作用
基本命令 create 创建 创建一个资源
edit 编辑 编辑一个资源
get 获取 获取一个资源
patch 更新 更新一个资源
delete 删除 删除一个资源
explain 解释 展示资源文档
运行和调试 run 运行 在集群中运行一个指定的镜像
expose 暴露 暴露资源为 Service
describe 描述 显示资源内部信息
logs 日志输出容器在 pod 中的日志 输出容器在 pod 中的日志
attach 缠绕进入运行中的容器 进入运行中的容器
exec 执行容器中的一个命令 执行容器中的一个命令
cp 复制 在 Pod 内外复制文件
rollout 首次展示 管理资源的发布
scale 规模 扩(缩)容 Pod 的数量
autoscale 自动调整 自动调整 Pod 的数量
高级命令 apply rc 通过文件对资源进行配置
label 标签 更新资源上的标签
其他命令 cluster-info 集群信息 显示集群
version 版本 显示当前 Server 和 Client 的版本

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

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

# 获取 namespace。
[root@localhost ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   13h
dev               Active   17s
kube-flannel      Active   12h
kube-node-lease   Active   13h
kube-public       Active   13h
kube-system       Active   13h

# 在此 namespace 下创建并运行一个 nginx 的 Pod。
[root@localhost ~]# kubectl run pod --image=nginx:1.17.1 -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。不加 -n dev 默认查 default。
[root@localhost ~]# kubectl get pod -n dev
NAME                   READY   STATUS    RESTARTS   AGE
pod-644584df94-5gx6f   1/1     Running   0          3m33s
[root@localhost ~]# kubectl get pod
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6867cdf567-tlmw5   1/1     Running   0          25m
[root@localhost ~]# kubectl get pod -n default
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6867cdf567-tlmw5   1/1     Running   0          26m

# 删除指定的 pod。
[root@localhost ~]# kubectl delete pods pod-644584df94-5gx6f -n dev
pod "pod-644584df94-5gx6f" deleted
[root@localhost ~]# kubectl get pod -n dev
NAME                   READY   STATUS              RESTARTS   AGE
pod-644584df94-wzzcv   0/1     ContainerCreating   0          40s

# 删除后又生成了一个。控制器，后面讲解。

# 删除指定的 namespace。
[root@localhost ~]# kubectl delete ns dev
namespace "dev" deleted
[root@localhost ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   13h
kube-flannel      Active   12h
kube-node-lease   Active   13h
kube-public       Active   13h
kube-system       Active   13h
[root@localhost ~]# kubectl get pod -n dev
No resources found in dev namespace.

[root@localhost ~]# kubectl get pod -n dev


[root@localhost ~]# kubectl describe pods pod-644584df94-5gx6f -n dev
Name:         pod-644584df94-5gx6f
Namespace:    dev
Priority:     0
Node:         localhost.localdomain.k8s.node2/192.168.142.152
Start Time:   Fri, 02 Dec 2022 13:35:27 +0800
Labels:       pod-template-hash=644584df94
              run=pod
Annotations:  <none>
Status:       Running
IP:           10.244.2.3
IPs:
  IP:           10.244.2.3
Controlled By:  ReplicaSet/pod-644584df94
Containers:
  pod:
    Container ID:   docker://26a71073d6b9f116bd7411aacdf862f77c1d1f485844e33a55aa2590edeb8614
    Image:          nginx:1.17.1
    Image ID:       docker-pullable://nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
    Port:           <none>
    Host Port:      <none>
    State:          Running
      Started:      Fri, 02 Dec 2022 13:36:34 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-khzf8 (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-khzf8:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-khzf8
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
  Type    Reason     Age    From                                      Message
  ----    ------     ----   ----                                      -------
  Normal  Scheduled  5m24s  default-scheduler                         Successfully assigned dev/pod-644584df94-5gx6f to localhost.localdomain.k8s.node2
  Normal  Pulling    5m23s  kubelet, localhost.localdomain.k8s.node2  Pulling image "nginx:1.17.1"
  Normal  Pulled     4m19s  kubelet, localhost.localdomain.k8s.node2  Successfully pulled image "nginx:1.17.1"
  Normal  Created    4m18s  kubelet, localhost.localdomain.k8s.node2  Created container pod
  Normal  Started    4m17s  kubelet, localhost.localdomain.k8s.node2  Started container pod

3.3.2 命令式对象配置。

命令式对象配置就是使用命令配合配置文件一起来操作 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:1.17.1

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

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

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

[root@localhost k8s]# kubectl get ns dev
NAME   STATUS   AGE
dev    Active   37s
[root@localhost k8s]# kubectl get pod -n dev
NAME       READY   STATUS              RESTARTS   AGE
nginxpod   0/1     ContainerCreating   0          43s
[root@localhost k8s]# kubectl get pods -n dev
NAME       READY   STATUS    RESTARTS   AGE
nginxpod   1/1     Running   0          90s

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

[root@localhost k8s]# kubectl get -f nginxpod.yaml
NAME            STATUS   AGE
namespace/dev   Active   2m15s

NAME           READY   STATUS    RESTARTS   AGE
pod/nginxpod   1/1     Running   0          2m14s

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

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

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

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

  • 总结。

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


3.3.3 声明式对象配置。

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

# 首先执行一次 kubectl apply -f yaml 文件，发现创建了资源。
[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev created
pod/nginxpod created
# 再次执行一次 kubectl apply -f yaml 文件，发现说资源没有变动。
[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev unchanged
pod/nginxpod unchanged

[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev unchanged
pod/nginxpod unchanged
[root@localhost k8s]# !vim
vim nginxpod.yaml
[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev unchanged
pod/nginxpod configured
[root@localhost k8s]# kubectl describe pods nginxpod -n dev
Name:         nginxpod
Namespace:    dev
Priority:     0
Node:         localhost.localdomain.k8s.node2/192.168.142.152
Start Time:   Fri, 02 Dec 2022 13:52:33 +0800
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {
   "apiVersion":"v1","kind":"Pod","metadata":{
   "annotations":{
   },"name":"nginxpod","namespace":"dev"},"spec":{
   "containers":[{
   "image":"nginx:1....
Status:       Running
IP:           10.244.2.6
IPs:
  IP:  10.244.2.6
Containers:
  nginx-containers:
    Container ID:   docker://37a117c2d9d75053ce590c9d1fc306d5c90053960258891fff5bf0c046840089
    Image:          nginx:1.17.1
    Image ID:       docker-pullable://nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
    Port:           <none>
    Host Port:      <none>
    State:          Running
      Started:      Fri, 02 Dec 2022 13:53:30 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-5ksc8 (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-5ksc8:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-5ksc8
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
  Type    Reason     Age    From                                      Message
  ----    ------     ----   ----                                      -------
  Normal  Scheduled  3m     default-scheduler                         Successfully assigned dev/nginxpod to localhost.localdomain.k8s.node2
  Normal  Pulling    2m59s  kubelet, localhost.localdomain.k8s.node2  Pulling image "nginx:1.17.1"
  Normal  Pulled     2m3s   kubelet, localhost.localdomain.k8s.node2  Successfully pulled image "nginx:1.17.1"
  Normal  Created    2m3s   kubelet, localhost.localdomain.k8s.node2  Created container nginx-containers
  Normal  Started    2m3s   kubelet, localhost.localdomain.k8s.node2  Started container nginx-containers
  Normal  Killing    52s    kubelet, localhost.localdomain.k8s.node2  Container nginx-containers definition changed, will be restarted
  Normal  Pulling    52s    kubelet, localhost.localdomain.k8s.node2  Pulling image "nginx:1.17.1"


[root@localhost k8s]# kubectl create -f nginxpod.yaml
Error from server (AlreadyExists): error when creating "nginxpod.yaml": namespaces "dev" already exists
Error from server (AlreadyExists): error when creating "nginxpod.yaml": pods "nginxpod" already exists
  • 总结。

其实声明式对象配置就是使用 apply 描述一个资源最终的状态（在 yaml 中定义状态）。

使用 apply 操作资源。

如果资源不存在，就创建，相当于 kubectl create。
如果资源已存在，就更新，相当于 kubectl patch。

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

[root@localhost ~]# kubectl get nodes
The connection to the server localhost:8080 was refused - did you specify the right host or port?

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

scp -r $HOME/.kube localhost.localdomain.k8s.node1:$HOME/

[root@localhost ~]# ls .kube/
cache  config  http-cache

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

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

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

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


4. 实战入门。

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

4.1 Namespace。

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

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

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

在这里插入图片描述
kubernetes 在集群启动之后，会默认创建几个 namespace。

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

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


4.1.1 查看。
# 查看所有的 ns。命令：kubectl get ns
[root@localhost ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   13h
dev               Active   23m
kube-flannel      Active   12h
kube-node-lease   Active   13h
kube-public       Active   13h
kube-system       Active   13h

[root@localhost ~]# kubectl get pods -n kube-system
NAME                                                       READY   STATUS    RESTARTS   AGE
coredns-9d85f5447-5959v                                    1/1     Running   0          13h
coredns-9d85f5447-gvqxh                                    1/1     Running   0          13h
etcd-localhost.localdomain.k8s.master                      1/1     Running   0          13h
kube-apiserver-localhost.localdomain.k8s.master            1/1     Running   0          13h
kube-controller-manager-localhost.localdomain.k8s.master   1/1     Running   0          13h
kube-proxy-7dc95                                           1/1     Running   1          13h
kube-proxy-7hss2                                           1/1     Running   0          13h
kube-proxy-rpnvx                                           1/1     Running   0          13h
kube-scheduler-localhost.localdomain.k8s.master            1/1     Running   0          13h


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

# 指定输出格式。命令：kubectl get ns ns 名称 -o 格式参数
# kubernetes 支持的格式有很多，比较常见的是 wide、json、yaml
[root@localhost ~]# kubectl get ns default -o yaml
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: "2022-12-01T16:20:14Z"
  name: default
  resourceVersion: "146"
  selfLink: /api/v1/namespaces/default
  uid: 11fb6c7d-f67f-4d9e-8e2b-66621c0d5d08
spec:
  finalizers:
  - kubernetes
status:
  phase: Active

# 查看 ns 详情。命令：kubectl describe ns ns 名称
[root@localhost ~]# kubectl describe ns default
Name:         default
Labels:       <none>
Annotations:  <none>
Status:       Active

No resource quota.

No LimitRange resource.

# status
# Active 命名空间正在使用中 Terminating 正在删除命名空间。
# ResourceQuota 针对 namespace 做的资源限制。
# LimitRange 针对 namespace 中的每个组件做的资源限制。

4.1.2 创建。
# 创建 namespace。
[root@master ~]# kubectl create ns dev
namespace/dev created

4.1.3 删除。
# 删除 namespace。
[root@master ~]# kubectl delete ns dev
namespace "dev" deleted

4.1.4 配置方式。

首先准备一个 yaml 文件：ns-dev.yaml。

apiVersion: v1
kind: Namespace
metadata:
  name: dev

然后就可以执行对应的创建和删除命令了：

创建：kubectl create -f ns-dev.yaml。

删除：kubectl delete -f ns-dev.yaml。

[root@localhost k8s]# vim ns-dev.yaml
[root@localhost k8s]# kubectl create -f ns-dev.yaml
Error from server (AlreadyExists): error when creating "ns-dev.yaml": namespaces "dev" already exists
[root@localhost k8s]# kubectl delete -f ns-dev.yaml
namespace "dev" deleted
[root@localhost k8s]# kubectl create -f ns-dev.yaml
namespace/dev created

4.2 Pod。

Pod 是 kubernetes 集群进行管理的最小单元，程序要运行必须部署在容器中，而容器必须存在于 Pod 中。

Pod 可以认为是容器的封装，一个 Pod 中可以存在一个或者多个容器。

在这里插入图片描述

kubernetes 在集群启动之后，集群中的各个组件也都是以 Pod 方式运行的。可以通过下面命令查看。

[root@localhost k8s]# kubectl get pod -n kube-system
NAME                                                       READY   STATUS    RESTARTS   AGE
coredns-9d85f5447-5959v                                    1/1     Running   0          14h
coredns-9d85f5447-gvqxh                                    1/1     Running   0          14h
etcd-localhost.localdomain.k8s.master                      1/1     Running   0          14h
kube-apiserver-localhost.localdomain.k8s.master            1/1     Running   0          14h
kube-controller-manager-localhost.localdomain.k8s.master   1/1     Running   0          14h
kube-proxy-7dc95                                           1/1     Running   1          14h
kube-proxy-7hss2                                           1/1     Running   0          14h
kube-proxy-rpnvx                                           1/1     Running   0          14h
kube-scheduler-localhost.localdomain.k8s.master            1/1     Running   0          14h

4.2.1 创建并运行。

kubernetes 没有提供单独运行 Pod 的命令，都是通过 Pod 控制器来实现的。

# 命令格式：kubectl run (pod 控制器名称) [参数] 
# --image  指定 Pod 的镜像。
# --port   指定端口。
# --namespace  指定 namespace。
[root@localhost k8s]# kubectl run nginx --image=nginx:1.17.1 --port=80 --namespace 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/nginx created


[root@localhost k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-kwbhk   1/1     Running   0          2m8s
[root@localhost k8s]# kubectl get pod -n dev -o wide
NAME                     READY   STATUS    RESTARTS   AGE     IP           NODE                              NOMINATED NODE   READINESS GATES
nginx-64777cd554-kwbhk   1/1     Running   0          2m13s   10.244.2.7   localhost.localdomain.k8s.node2   <none>           <none>

# READY ~ pod 中容器数量。

4.2.2 查看 pod 信息。
# 查看 Pod 基本信息。
[root@localhost k8s]# kubectl get pods -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-kwbhk   1/1     Running   0          4m26s

# 查看 Pod 的详细信息。
[root@localhost k8s]# kubectl describe pod nginx -n dev
Name:         nginx-64777cd554-kwbhk
Namespace:    dev
Priority:     0
Node:         localhost.localdomain.k8s.node2/192.168.142.152
Start Time:   Fri, 02 Dec 2022 14:41:15 +0800
Labels:       pod-template-hash=64777cd554
              run=nginx
Annotations:  <none>
Status:       Running
IP:           10.244.2.7
IPs:
  IP:           10.244.2.7
Controlled By:  ReplicaSet/nginx-64777cd554
Containers:
  nginx:
    Container ID:   docker://f96e2bc540280474d7e6f7942ae42c08b485b86e18c090152d0bcdf6ea6fed21
    Image:          nginx:1.17.1
    Image ID:       docker-pullable://nginx@sha256:b4b9b3eee194703fc2fa8afa5b7510c77ae70cfba567af1376a573a967c03dbb
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 02 Dec 2022 14:41:17 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-z9vht (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-z9vht:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-z9vht
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
  Type    Reason     Age    From                                      Message
  ----    ------     ----   ----                                      -------
  Normal  Scheduled  4m37s  default-scheduler                         Successfully assigned dev/nginx-64777cd554-kwbhk to localhost.localdomain.k8s.node2
  Normal  Pulled     4m36s  kubelet, localhost.localdomain.k8s.node2  Container image "nginx:1.17.1" already present on machine
  Normal  Created    4m36s  kubelet, localhost.localdomain.k8s.node2  Created container nginx
  Normal  Started    4m35s  kubelet, localhost.localdomain.k8s.node2  Started container nginx

4.2.3 访问 Pod。
# 获取 pod IP。
[root@localhost k8s]# kubectl get pods -n dev -o wide
NAME                     READY   STATUS    RESTARTS   AGE     IP           NODE                              NOMINATED NODE   READINESS GATES
nginx-64777cd554-kwbhk   1/1     Running   0          8m32s   10.244.2.7   localhost.localdomain.k8s.node2   <none>           <none>

# 访问 POD。
[root@localhost k8s]# curl http://10.244.2.7:80
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
   
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

4.2.4 删除指定 Pod。
# 删除指定 Pod。
[root@localhost k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-kwbhk   1/1     Running   0          11m

# 此时，显示删除 Pod 成功，但是再查询，发现又新产生了一个。 
[root@localhost k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-xwknq   1/1     Running   0          26s

# kubectl run (pod 控制器名称) [参数] 
# 这是因为当前 Pod 是由 Pod 控制器创建的，控制器会监控 Pod 状况，一旦发现 Pod 死亡，会立即重建。
# 此时要想删除 Pod，必须删除 Pod 控制器。
# 先来查询一下当前 namespace 下的 Pod 控制器。
[root@localhost k8s]# kubectl get deploy -n dev
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nginx   1/1     1            1           12m

# 接下来，删除此 Pod 控制器。
[root@localhost k8s]# kubectl delete deploy nginx -n dev
deployment.apps "nginx" deleted

# 稍等片刻，再查询 Pod，发现 Pod 被删除了。
[root@localhost k8s]# kubectl get pods -n dev
No resources found in dev namespace.

4.2.5 配置操作。

创建一个 pod-nginx.yaml，内容如下。

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  namespace: dev
spec:
  containers:
  - image: nginx:1.17.1
    name: pod
    ports:
    - name: nginx-port
      containerPort: 80
      protocol: TCP

然后就可以执行对应的创建和删除命令了。

[root@localhost k8s]# vim pod-nginx.yaml
[root@localhost k8s]# kubectl create -f pod-nginx.yaml
pod/nginx created
[root@localhost k8s]# kubectl delete -f pod-nginx.yaml
pod "nginx" deleted

4.3 Label。

Label 是 kubernetes 系统中的一个重要概念。它的作用就是在资源上添加标识，用来对它们进行区分和选择。

Label 的特点。

  • 一个 Label 会以 key/value 键值对的形式附加到各种对象上，如 Node、Pod、Service 等等。
  • 一个资源对象可以定义任意数量的 Label，同一个 Label 也可以被添加到任意数量的资源对象上去。
  • Label 通常在资源对象定义时确定，当然也可以在对象创建后动态添加或者删除。

可以通过 Label 实现资源的多维度分组，以便灵活、方便地进行资源分配、调度、配置、部署等管理工作。

一些常用的 Label 示例如下：

  • 版本标签：“version”:“release”, “version”:“stable”…
  • 环境标签：“environment”:“dev”，“environment”:“test”，“environment”:“pro”
  • 架构标签：“tier”:“frontend”，“tier”:“backend”。

标签定义完毕之后，还要考虑到标签的选择，这就要使用到 Label Selector，即：

Label 用于给某个资源对象定义标识。
Label Selector 用于查询和筛选拥有某些标签的资源对象。

当前有两种 Label Selector。

  • 基于等式的 Label Selector。

name = slave: 选择所有包含 Label 中 key=“name” 且 value=“slave” 的对象。
env != production: 选择所有包括 Label 中的 key=“env” 且 value 不等于 “production” 的对象。

  • 基于集合的 Label Selector。

name in (master, slave): 选择所有包含 Label 中的 key=“name” 且 value=“master” 或 “slave” 的对象。
name not in (frontend): 选择所有包含 Label 中的 key=“name” 且 value 不等于 “frontend” 的对象。

标签的选择条件可以使用多个，此时将多个 Label Selector 进行组合，使用逗号","进行分隔即可。例如：

name=slave，env!=production
name not in (frontend)，env!=production


4.3.1 命令方式。
[root@localhost k8s]# kubectl create -f pod-nginx.yaml 
pod/nginx created
# 查看标签。
[root@localhost k8s]# kubectl get pod -n dev --show-labels
NAME    READY   STATUS    RESTARTS   AGE   LABELS
nginx   1/1     Running   0          69s   <none>
# 为 pod 资源打标签。
[root@localhost k8s]# kubectl label pod nginx version=1.0 -n dev
pod/nginx labeled
# 查看标签。
[root@localhost k8s]# kubectl get pod -n dev --show-labels
NAME    READY   STATUS    RESTARTS   AGE     LABELS
nginx   1/1     Running
最低0.47元/天 解锁文章
容灾恢复 | 记一次K8S集群中etcd数据快照的备份恢复实践
WeiyiGeek 唯一极客IT知识分享
03-09 702
在 Kubernetes 集群中所有操作的资源数据都是存储在 etcd 数据库上, 所以防止集群节点瘫痪未正常工作或在集群迁移时，以及在出现异常的情况下能尽快的恢复集群数据，则我们需要定期针对etcd集群数据进行相应的容灾操作。
手把手带你玩转k8s-集群创建和Hello World
mldong的博客
05-11 799
前言 因为公司业务发展需要，现在开始陆陆续续将swarm上的服务转到k8s了。而我也终于有机会开始k8s的学习(caikeng)之旅。这里不会对swarm和k8s进行对比，反正知道k8s比swarm更香就对了。本系列教程主要是面向想入门k8s但又无门的开发小伙伴。 环境搭建 本文的环境搭建并不是真的亲手去搭建，而是使用云平台的容器服务去创建k8s集群。目地很简单，专业的事就让专业的人去做。我们能把k8s使用得顺手就可以了，维护就让云平台帮做吧。当然主要原因还是想让大家能更快的上手使用k8s。云供应商很多，下
kubernetes
04-12
k8s 知识总结 自动化安装，日志收集，监控报警，ceph存储，动态pv ，应用部署等，欢迎大家学习使用
Kubernetes详细教程（一）：入门、架构及基本概念
最新发布
晓风残月淡的博客
04-06 1236
随着Docker等容器技术的流行，越来越多的企业开始采用容器来打包和部署应用程序。 随着容器数量的增加，确保所有服务能够正确地找到并通信变得更加困难。 当某个容器由于软件错误或硬件故障而崩溃时，如果没有自动化的监控和恢复机制，运维人员需要手动重启或重新部署受影响的服务。 面对这一挑战，企业迫切需要一种能够自动化管理大规模容器集群的解决方案。 为了填补这一市场空白并分享其宝贵经验，谷歌在2015年决定将Borg的设计理念与最佳实践开源，推出了Kubernetes项目。
Kubernetes（k8s）入门到实战教程笔记总结
Cyber
03-24 4181
一、k8s概念和架构 2.1 k8s概述 k8s 是 2014 年 Google 开源的一款容器化集群管理系统，使用 golang 实现 可使用 k8s 进行容器化应用部署，使部署更加方便 使用 k8s 利于应用扩展和维护 k8s 的目标是让部署容器化应用更加简洁高效 2.2 k8s特性 2.3 k8s中的架构组件 k8s 中有哪些组件： 二、从零搭建k8s集群 搭建 硬件要求 测试环境： master 节点：CPU：至少 2 核 | 内存：至少 4 G | 硬盘：至少 20 G node 节点：
Kubernetes
05-28 426
follow-me-install-kubernetes-cluster更新到Kubernetes1.14了：https://github.com/opsnull/follow-me-install-kubernetes-cluster对Kubernetes开发感兴趣的，可以参考我写的、较为完整和系统的client-go源码解析：https://github.com/o...
K8S
weixin_34315485的博客
04-01 344
Kubernetes 编排系统 分类:容器/虚拟化 1.1Kubernetes简介 1.1.1什么是Kubernetes Kubernetes (通常称为K8s，K8s是将8个字母“ubernete”替换为“8”的缩写)是用于自动部署、扩展和管理容器化（containerized）应用程序的开源系统。Google设计并捐赠给C...
【Kubernetes】k8s的安全管理详细说明【k8s框架说明、token验证和kubeconfig验证详细说明】
2301_82056337的博客
04-27 1162
–server=https://192.168.59.142:6443——masterIP替换。
k8s学习-网络策略NetworkPolicy（概念、模版、创建、删除等）(1)
2401_84253380的博客
04-28 971
Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，不要看完；在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。恭喜你，如果学到这里，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web 渗透、安全服务、安全分析等岗位；k8s的Pod是没有隔离行的，任意命名空间下的Pod可以访问任意命名空间下的Pod。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lyfGeek

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值