云原生核心内容

云平台核心

语雀链接笔记

1、为什么使用云平台

• 环境统一
• 按需付费
• 即开即用
• 稳定性强
  国内常见云平台
• 阿里云、百度云、腾讯云、青云

公有云

私有云

2、核心框架

electerm:用于连接服务器进行操作
electerm： https://electerm.github.io/electerm/
https://wwa.lanzoui.com/b016k9bha
密码:900h
xshell

注册云平台：
● 阿里云 aliyun.com
● 腾讯云 cloud.tencent.com
● 华为云 cloud.huawei.com
青云 qingcloud.com
百度云 cloud.baidu.com

在阿里云创建一个服务器

点击创建实例就是要购买一个服务器

在上面的地址中下载electerm，连接服务器进行操作

连上以后就可以在服务器上操作了

测试安装nginx并访问

启动nginx

systemctl start nginx
1

服务器安全组设置

nginx 的配置文件在/etc/nginx/nginx.conf
修改配置文件
公网IP不带端口访问其实就是访问80端口

修改原来的80端口让nginx监听88端口

修改完之后重新启动nginx

ststemctl restart nginx
1

访问本机的88端口可以正常显示

但是公网IP带88访问的什么访问不到

这个原因是阿里云的每个服务器中都有安全组这个东西，安全组控制服务器的防火墙：防火墙的端口设置都要设置安全组

手动添加一个所有人（0.0.0.0/0）可以访问88端口


之后访问就生效了

私有云vpc实战

公网IP是为了让外部连接用的，重新启动服务器之后可能就会改变
私有云IP的不变的，同一个集群内不同的服务器之间用私有IP访问，私有ip不用流量，而且速度更快

创建专有网络
/16表示掩码位，转换为二进制之后前16位是不变，后十六位动态变化

还可以创建交换机，即继续创建子网

vpc给我们提供了隔离的环境，即使下面的三个网段一样，但是这个三个vpc里面的服务器使用私网IP是不能互通的
开发环境和生产环境之间是隔离的

创建服务器 的时候可以加入到我们自己创建的vpc中自己的交换机网络域

以前开的私有网络ping不通新的，他们处于不同的专用网络

可以通过远程连接从控制台中登录

Docker基础

以前的虚拟化技术

现在使用容器化技术：总的都是一样的，让每个容器中实现差异化

Docker基本概念

Docker安装

centos下安装docker
参照如下文档
https://docs.docker.com/engine/install/centos/
1、移除以前的docker相关包

移除所有和docker相关的

yum remove docker*
1

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
1
2
3
4
5
6
7
8

2、配置yum源
sudo是管理员用户的意思，现在是root用户所以sudo不用加
安装yum需要的工具包

sudo yum install -y yum-utils  
1

配置docker 的yum 源地址，代码直接粘贴

sudo yum-config-manager \  
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
1
2
3

3、安装docker

#安装最新的docker
sudo yum install -y docker-ce docker-ce-cli containerd.io


#以下是在安装k8s的时候使用
yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7  containerd.io-1.4.6
1
2
3
4
5
6

4、启动

systemctl enable docker --now
1

docker ps 有显示就是启动成功

5、配置加速
这里额外添加了docker的生产环境核心配置cgroup

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://82m9ar63.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在阿里云的容器镜像服务中开通了免费的加速器，把这个加速器配置的代码粘贴执行就行

Docker命令实战

基础实战

1、找镜像

去docker hub找到nginx镜像

docker pull nginx  #下载最新版

镜像名:版本名（标签）

docker pull nginx:1.20.1


docker pull redis  #下载最新
docker pull redis:6.2.4

## 下载来的镜像都在本地
docker images  #查看所有镜像

redis = redis:latest
## 移除镜像
docker rmi 镜像名:版本号/镜像id 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2、启动容器

启动nginx应用容器，并映射88端口，测试访问

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

【docker run  设置项   镜像名  】 镜像启动运行的命令（镜像里面默认有的，一般不会写）

# -d：后台运行（长久运行）
# --restart=always: 开机自启
# -p:port
docker run --name=mynginx   -d  --restart=always -p  88:80   nginx

# 查看正在运行的容器
docker ps
# 查看所有
docker ps -a
# 删除停止的容器
docker rm  容器id/名字
docker rm -f mynginx   #强制删除正在运行中的

#停止容器
docker stop 容器id/名字
#再次启动
docker start 容器id/名字
# 重新启动机器
reboot
#更新容器的设置项  应用开机自启
docker update 容器id/名字 --restart=always
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

每个app里面都有一个完整的虚拟机，虚拟机中安装了nginx,外部访问的时候先访问大主机的88端口，然后通过端口映射到80端口


然后在服务器中的安全组规则中，添加一个规则
源IP不写表示任何主机访问88端口都放行

提交完之后点击应用修改

现在就可以访问到了

3、修改容器内容

修改默认的index.html页面
1、进容器内部修改

# 进入容器内部的系统，修改容器内容
docker exec -it 容器id  /bin/bash
1
2

进入放index.html的页面的目录

  cd /usr/share/nginx/html/
1

然后修改页面

改好之后使用exit命令退出
2、挂载数据到外部修改
把app2里面的目录和主机中的目录建立一个连接，通过修改主机目录中的内容就是修改app2里面某个目录的内容

# -v:挂载
# ro：只读模式，修改只能在外面修改 rw:读写
docker run --name=mynginx   \
-d  --restart=always \
-p  88:80 -v /data/html:/usr/share/nginx/html:ro  \
nginx

# 修改页面只需要去 主机的 /data/html
1
2
3
4
5
6
7
8

4、提交改变

将自己修改好的镜像提交

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

## -a:作者
## -m:哪些改变
docker commit -a "leifengyang"  -m "首页变化" 341d81f7504f guignginx:v1.0

1
2
3
4
5
6

镜像传输

# 将镜像保存成压缩包
docker save -o abc.tar guignginx:v1.0

# 别的机器加载这个镜像
docker load -i abc.tar


# 离线安装
1
2
3
4
5
6
7
8

将镜像的压缩包复制到另外的一台主机

启动这个镜像，因为已经有了88端口所以不能再占用88

5、推送远程仓库

推送镜像到docker hub:应用市场
先在docker hub创建一个仓库

docker tag local-image:tagname new-repo:tagname
docker push new-repo:tagname
1
2

# 把旧镜像的名字，改成仓库要求的新版名字
docker tag guignginx:v1.0 leifengyang/guignginx:v1.0

# 登录到docker hub
docker login       


docker logout（推送完成镜像后退出）

# 推送
docker push leifengyang/guignginx:v1.0


# 别的机器下载
docker pull leifengyang/guignginx:v1.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6、补充命令

docker logs 容器名/id   排错

docker exec -it 容器id /bin/bash  进入容器内部app1


# docker 经常修改nginx配置文件,把配置文件挂载出来
docker run -d -p 80:80 \
-v /data/html:/usr/share/nginx/html:ro \
-v /data/conf/nginx.conf:/etc/nginx/nginx.conf \
--name mynginx-02 \
nginx


#把容器指定位置的东西复制出来 
docker cp 5eff66eec7e1:/etc/nginx/nginx.conf  /data/conf/nginx.conf
#把外面的内容复制到容器里面
docker cp  /data/conf/nginx.conf  5eff66eec7e1:/etc/nginx/nginx.conf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

容器就是一个小型 的Linux系统

进阶实战

1、编写自己的应用

创建一个spirngboot项目
可以在www.start.spring.io创建一个springboot项目然后下载
提交web和redis的依赖

1、然后把文件解压之后拖到idea中
2、编写controller

@RestController
public class CounterController {

//    private int i = 0; //mysql，redis

    @Autowired
    StringRedisTemplate redisTemplate;

    @GetMapping("/hello")
    public String count(){

        Long increment = redisTemplate.opsForValue().increment("count-people");
        return "有 【"+ increment +"】 人访问了这个页面";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、配置redis

2、将应用打包

以前clean compile package，打成一个jar包上传给服务器然后服务器运行jar包

缺点：每个服务器都要重新安装环境
现在使用docker
只安装一个环境，所以应用都是镜像，所有机器都可以运行

3、怎么打包-Dockerfile

将应用打包成镜像
在最外层目录创建一个Dockerfile
FROM安装环境
labal 作者
COPY 复制target中的jar到容器中
ENTRYPOINT 执行命令：启动java的jar包
把Dockerfile和jar包上传到服务器中

上传到服务器中后构建镜像

# 最后的.点表示以当前文件夹aaa为基准（copy时候不会出错）
# java-demo:v1.0 构建镜像的名字
docker build -t java-demo:v1.0 .
1
2
3

生成了镜像

4、启动容器

# myjava-app容器名
docker run -d -p 8080:8080 --name myjava-app java-demo:v1.0 
1
2

然后创建8080的安全组

通过docker logs 容器id查看日志

5、部署中间件-redis

下载redis

docker pull redis
1

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

#redis使用自定义配置文件启动
# 把主机的redis文件挂在到容器里的redis配置文件，data目录也挂载一下
# -p：为了对外开发放端口
docker run -v /data/redis/redis.conf:/etc/redis/redis.conf \
-v /data/redis/data:/data \
-d --name myredis \
-p 6379:6379 \
redis:latest  redis-server /etc/redis/redis.conf
#redis-server 启动自定义配置文件，只能找到容器里的文件，不能写主机的redis配置文件

1
2
3
4
5
6
7
8
9
10
11
12

要想使用redis记得配置安全组规则放行6379

然后点应用修改

然后就可以连接redis使用

redi设置账号密码访问

修改外部的redis配置文件就行

修改完配置文件重新启动redis

docker restart myredis
1

再连接的时候就需要密码了

7、应用分享和启动

先登录到docker hub

# 登录docker hub
docker login

#给旧镜像起名
docker tag java-demo:v1.0  leifengyang/java-demo:v1.0

# 推送到docker hub
docker push leifengyang/java-demo:v1.0

# 别的机器
docker pull leifengyang/java-demo:v1.0

# 别的机器运行
docker run -d -p 8080:8080 --name myjava-app java-demo:v1.0 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Kubernetes

基础概念

是什么

我们急需一个大规模容器编排系统

架构

都是通过集群安装

1 工作方式

Kubernetes Cluster = N Master Node + N Worker Node：N主节点+N工作节点； N>=1

2 组件架构

1、控制平面组件（Control Plane Components）
控制平面的组件对集群做出全局决策(比如调度)，以及检测和响应集群事件（例如，当不满足部署的 replicas 字段时，启动新的 pod）。
控制平面组件可以在集群中的任何节点上运行。 然而，为了简单起见，设置脚本通常会在同一个计算机上启动所有控制平面组件， 并且不会在此计算机上运行用户容器。 请参阅使用 kubeadm 构建高可用性集群 中关于多 VM 控制平面设置的示例。
kube-apiserver
API 服务器是 Kubernetes 控制面的组件， 该组件公开了 Kubernetes API。 API 服务器是 Kubernetes 控制面的前端。
Kubernetes API 服务器的主要实现是 kube-apiserver。 kube-apiserver 设计上考虑了水平伸缩，也就是说，它可通过部署多个实例进行伸缩。 你可以运行 kube-apiserver 的多个实例，并在这些实例之间平衡流量。
etcd
etcd 是兼具一致性和高可用性的键值数据库，可以作为保存 Kubernetes 所有集群数据的后台数据库。
您的 Kubernetes 集群的 etcd 数据库通常需要有个备份计划。
要了解 etcd 更深层次的信息，请参考 etcd 文档。
kube-scheduler
控制平面组件，负责监视新创建的、未指定运行节点（node）的 Pods，选择节点让 Pod 在上面运行。
调度决策考虑的因素包括单个 Pod 和 Pod 集合的资源需求、硬件/软件/策略约束、亲和性和反亲和性规范、数据位置、工作负载间的干扰和最后时限。
kube-controller-manager
在主节点上运行 控制器 的组件。
从逻辑上讲，每个控制器都是一个单独的进程， 但是为了降低复杂性，它们都被编译到同一个可执行文件，并在一个进程中运行。
这些控制器包括:
● 节点控制器（Node Controller）: 负责在节点出现故障时进行通知和响应
● 任务控制器（Job controller）: 监测代表一次性任务的 Job 对象，然后创建 Pods 来运行这些任务直至完成
● 端点控制器（Endpoints Controller）: 填充端点(Endpoints)对象(即加入 Service 与 Pod)
● 服务帐户和令牌控制器（Service Account & Token Controllers）: 为新的命名空间创建默认帐户和 API 访问令牌
cloud-controller-manager
云控制器管理器是指嵌入特定云的控制逻辑的 控制平面组件。 云控制器管理器允许您链接集群到云提供商的应用编程接口中， 并把和该云平台交互的组件与只和您的集群交互的组件分离开。
cloud-controller-manager 仅运行特定于云平台的控制回路。 如果你在自己的环境中运行 Kubernetes，或者在本地计算机中运行学习环境， 所部署的环境中不需要云控制器管理器。
与 kube-controller-manager 类似，cloud-controller-manager 将若干逻辑上独立的 控制回路组合到同一个可执行文件中，供你以同一进程的方式运行。 你可以对其执行水平扩容（运行不止一个副本）以提升性能或者增强容错能力。
下面的控制器都包含对云平台驱动的依赖：
● 节点控制器（Node Controller）: 用于在节点终止响应后检查云提供商以确定节点是否已被删除
● 路由控制器（Route Controller）: 用于在底层云基础架构中设置路由
● 服务控制器（Service Controller）: 用于创建、更新和删除云提供商负载均衡器
2、Node 组件
节点组件在每个节点上运行，维护运行的 Pod 并提供 Kubernetes 运行环境。
kubelet
一个在集群中每个节点（node）上运行的代理。 它保证容器（containers）都 运行在 Pod 中。
kubelet 接收一组通过各类机制提供给它的 PodSpecs，确保这些 PodSpecs 中描述的容器处于运行状态且健康。 kubelet 不会管理不是由 Kubernetes 创建的容器。
kube-proxy
kube-proxy 是集群中每个节点上运行的网络代理， 实现 Kubernetes 服务（Service） 概念的一部分。
kube-proxy 维护节点上的网络规则。这些网络规则允许从集群内部或外部的网络会话与 Pod 进行网络通信。
如果操作系统提供了数据包过滤层并可用的话，kube-proxy 会通过它来实现网络规则。否则， kube-proxy 仅转发流量本身。

kubeadm创建集群

安装前的准备工作

先给每个机器都安装kubeadm,kubefctl(为了方便程序员操作集群),kubelet(厂长),然后挑一台机器设置为主节点,使用kubeadm工具调用kubeadm init命令初始化一个主节点,只有主节点才有c-m.ccm,api,etcd,sched这些东西,然后厂长(kubelet)把主节点需要的东西通过下镜像下载安装.工作节点使用kubeadm join加入集群,然后厂长会安装kube-proxy

一 先开通三台服务器

安全组设置防火墙,开通组内通信防火墙不开通,局域网内的三个服务器也能相互访问

二 连接三台服务器任何给服务器起名字

三 查看是否可以连接
ping 连接eth0的inet这个私网地址

创建集群

安装kubeadm

一 安装docker
参照之前的安装
二 安装kubeadm

1、基础环境
所有机器执行以下操作

#各个机器设置自己的域名
hostnamectl set-hostname k8s-master


# 将 SELinux 设置为 permissive 模式（相当于将其禁用）liux的安全设置禁用了
# 临时禁用和永久禁用都禁用
sudo setenforce 0    
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config  

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

#允许 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
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

2、安装kubelet、kubeadm、kubectl

# 配置yum源
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=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
exclude=kubelet kubeadm kubectl
EOF

# 安装三大件
sudo yum install -y kubelet-1.20.9 kubeadm-1.20.9 kubectl-1.20.9 --disableexcludes=kubernetes

#启动kubelet(厂长)
sudo systemctl enable --now kubelet

# 查看kubelet的状态
systemctl status kubelet
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

kubelet 现在每隔几秒就会重启，因为它陷入了一个等待 kubeadm 指令的死循环

使用kubeadm引导集群

1、下载各个机器需要的镜像
主节点需要的镜像都是在容器中运行的,因为怕在下载镜像的时候出现中断,不知道中断在那所以提前使用命令下载好镜像

# 只需要在master节点执行
sudo tee ./images.sh <<-'EOF'
#!/bin/bash
images=(
kube-apiserver:v1.20.9
kube-proxy:v1.20.9
kube-controller-manager:v1.20.9
kube-scheduler:v1.20.9
coredns:1.7.0
etcd:3.4.13-0
pause:3.2
)
for imageName in ${images[@]} ; do
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/$imageName
done
EOF
#给下载镜像给脚本一个权限,任何启动脚本
chmod +x ./images.sh && ./images.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

其他节点只需要kube-proxy镜像,但是怕节点需要更多的镜像,所以把上面的所有镜像在其他节点也都下载了

2、初始化主节点

#所有机器添加master域名映射，以下需要修改为自己的
# 让所有节点都知道master节点在哪,给每个节点都执行下面的话 
echo "172.31.0.4  cluster-endpoint" >> /etc/hosts
# ping cluster-endpoint 能连接上就行


#主节点初始化 ip和主节点映射改为自己的
kubeadm init \
--apiserver-advertise-address=172.31.0.4 \
--control-plane-endpoint=cluster-endpoint \
--image-repository registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images \
--kubernetes-version v1.20.9 \
--service-cidr=10.96.0.0/16 \
--pod-network-cidr=192.168.0.0/16
# pod-network-cidr是未来给每个应用分配网络的时候应该在那个范围里分配网络IP.所以之后创建#  mynginx这个Pod的时候发现分配给它的IP就是192.168开始的
#所有网络范围不重叠 不能再用172. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3 根据提示继续执行
初始化主节点之后会出现这些提示接下来该如何操作

初始化主节点之后的提示的代码

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

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

# 你需要部署一个网络插件
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/

You can now join any number of control-plane nodes by copying certificate authorities
and service account keys on each node and then running the following as root:

  kubeadm join cluster-endpoint:6443 --token hums8f.vyx71prsg74ofce7 \
    --discovery-token-ca-cert-hash sha256:a394d059dd51d68bb007a532a037d0a477131480ae95f75840c461e85e2c6ae3 \
    --control-plane 

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

kubeadm join cluster-endpoint:6443 --token hums8f.vyx71prsg74ofce7 \
    --discovery-token-ca-cert-hash sha256:a394d059dd51d68bb007a532a037d0a477131480ae95f75840c461e85e2c6ae3
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

3.1 设置.kube/config
将上面提示的代码中的代码复制然后执行

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

现在集群主节点已经初始化了,但是通过kubectl get nodes查看节点的时候发现节点的状态还没有Ready这是因为还没有部署网络插件

集群的命令总结

#查看集群所有节点
kubectl get nodes

#根据配置文件，给集群创建资源
kubectl apply -f xxxx.yaml

#查看集群部署了哪些应用 ？
# 在docker里面把运行中的应用叫容器,在k8s里面叫pod
docker ps   相当于  kubectl get pods -A
# 获取集群中有哪些运行的应用
kubectl get pods -A
1
2
3
4
5
6
7
8
9
10
11

3.2 安装网络组件

# 下载curl的配置文件
curl https://docs.projectcalico.org/manifests/calico.yaml -O
# 应用配置文件的东西
kubectl apply -f calico.yaml
1
2
3
4

4 加入node节点
在所有worker节点执行下面的代码
这个代码是初始化主节点之后提示里面的代码

kubeadm join cluster-endpoint:6443 --token x5g4uy.wpjjdbgra92s25pp \
	--discovery-token-ca-cert-hash sha256:6255797916eaee52bf9dda9429db616fcd828436708345a308f4b917d3457a22
1
2

补充:上面的令牌是24小时过期
可以在主节点master创建新的令牌

新令牌
kubeadm token create --print-join-command
1
2

在主节点查看worker节点状态
kubectl get pod -A
等所有节点初始化结束都Running了就是启动好了(需要一会时间)

验证集群

至此k8s的集群准备就绪
机器宕机重启之后集群会自己重新启动
6、部署dashboard
安装k8s的可视化界面
6.1、部署

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.3.1/aio/deploy/recommended.yaml
1

如果下载不下来就先安装wegt,然后使用这个命令进行安装

yum install -y wget

wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.3.1/aio/deploy/recommended.yaml
1
2
3

如果还下载不下来就直接复制文件的内容在语雀的课件里有
然后创建这个文件,把复制的内容放到里面

vi dashboard.yaml
然后执行这个文件创建相应的应用
kubectl apply -f dashboard.yaml
1
2
3

6.2、设置访问端口
修改集群中的文件

这一步是把web访问的端口暴露到机器上

kubectl edit svc kubernetes-dashboard -n kubernetes-dashboard

## 然后在文件中找到type:ClusterIP改为type:NodePort

kubectl get svc -A |grep kubernetes-dashboard
## 找到端口，在安全组放行
1
2
3
4
5
6

30753 端口是未来访问k8s控制台的端口
然后要想访问这个端口就要在云服务器中开放这个端口

要是还是访问不同就看每个机器使用的安全组是不是同一个
访问： https://集群任意IP:端口 https://139.198.165.238:30753


登录需要令牌
6.3、创建访问账号
准备一个文件,将下面的代码全部粘贴进去

vi dash-usr.yaml
1

#创建访问账号，准备一个yaml文件； vi dash.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

然后应用这个配置

kubectl apply -f dash.yaml
1

6.4、令牌访问

#获取访问令牌
kubectl -n kubernetes-dashboard get secret $(kubectl -n kubernetes-dashboard get sa/admin-user -o jsonpath="{.secrets[0].name}") -o go-template="{{.data.token | base64decode}}"
1
2

然后会返回一个令牌,复制这个令牌去网站访问

6.5 k8s控制台的可视化界面

k8s核心实战

资源创建方式

• 命令行
• yaml
  
  可视化界面里面左边这些都是一个个的资源
  可视化界面创建pod的时候使用那个名称空间,可以切到对应的名称空间或者在配置文件中添加要创建到的名称空间
  

NameSpace

名称(命名)空间,用来对集群资源进行隔离划分,默认只隔离资源,不隔离网络

# 查看名称空间ns 就是namespace简写
kubectl get ns
# 删除名称空间,会把名称空间里部署的应用也删除
kubectl deelte ns hello
#创建名称空间
kubectl create ns hello
1
2
3
4
5
6

使用配置文件来创建ns
vi hello.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: hello
1
2
3
4

然后应用配置文件

kubectl apply -f hello.yaml

# 删除的话也可以通过删除配置文件来删除ns
kubectl delte -f hello.yaml
1
2
3
4
5

Pod

pod概念
Pod:运行中的一组容器,pod是kubernetes 中应用 的最小单位
pod里面可以有多个容器

READY前一位表示pod多少个应用正常启动,所有都正常启动pod才是正常的,后一位表示pod里面一共有几个应用

使用命令创建pod

# 创建一个pod,给个名字mynginx指定使用的镜像nginx
kubectl run mynginx --image=nginx

# 查看default名称空间的Pod
kubectl get pod 
# 描述
kubectl describe pod 你自己的Pod名字
# 删除(-n xxx 指定名称空间的,不加就删除默认名称空间的)
kubectl delete pod Pod名字 -n xxx
# 查看Pod的运行日志
kubectl logs Pod名字

# 每个Pod - k8s都会分配一个ip
kubectl get pod -owide
# 使用Pod的ip+pod里面运行容器的端口,不写端口默认就是80端口
curl 192.168.169.136

# 集群中的任意一个机器以及任意的应用都能通过Pod分配的ip来访问这个Pod

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mynginx 这个pod中有一个容器,0个容器就绪,容器创建中是因为pod里面会起一个容器,正在创建中是nginx镜像正在下载,下载完才会启动这个容器,等一会之后容器就准备就绪了

查看pod描述

虽然是pod但是底层还是容器方式运行的,只不过k8s封装了一下
所以还是可以使用docker命令查看mynginx这个容器是否运行
在三个服务器都使用下面的命令

docker ps|grep mynginx
1

而只在node2节点服务器打印了,说明master节点把mynginx这个pod交给了node2节点

通过配置文件创建pod
vi pod.xml

apiVersion: v1
kind: Pod
metadata:
  labels:
    run: mynginx
  name: mynginx
#  namespace: default
spec:
  containers:
  - image: nginx
    name: mynginx
1
2
3
4
5
6
7
8
9
10
11

执行配置文件
kubectl apply -f pod.xml

删除的时候同样是删除配置文件的方式就可以删除pod
kubectl delete -f pod.yaml

修改nginx页面

以前使用docker部署nginx,想要修改nginx的页面
docker exec -it mynginx
使用k8s部署修改nginx页面,进入到mynginx里面，里面目录结构还是小Linux
kubectl exec -it mynginx -- /bin/bash
# 进入mynginx里面控制台之后进入index所在文件将index.html的内容替换
1
2
3
4
5

使用exit离开mynginx控制台
在可视化界面修改mynginx的页面,点击执行,就会到mynginx的控制台

在集群内任意机器访问nginx的IP地址都可以

现在在集群外还访问不到,因为我们还没有暴露端口给外部访问

多容器Pod细节
pod里面有一个正在运行的容器,这个容器是我们使用nginx镜像启动的docker容器.而在k8s底层呢还要再把这个容器封装一遍,这个就是pod.pod封装了一个容器,但是pod是k8s里面最小的单位.容器是打工人那么pod 就是给容器分配的宿舍,
每个pod都有一个IP可以访问,pod是一组运行中的容器

使用配置文件在pod中部署多个容器

apiVersion: v1
kind: Pod
metadata:
  labels:
    run: myapp
  name: myapp
spec:
  containers:
  - image: nginx
    name: nginx
  - image: tomcat:8.5.68
    name: tomcat
1
2
3
4
5
6
7
8
9
10
11
12

两个容器使用不同的端口访问

要是nginx想要访问tomcat只需要
访问本机的8080端口就行,不用带着自己的IP访问

同一个pod内共享网络空间,共享存储
在同一个pod里面创建两个一样的镜像就会出错,端口被占用

Deployment(部署)

控制Pod,使Pod拥有多副本,自愈,扩缩容等能力

# 清除所有Pod
kubectl delete pod myapp mynginx -n default
#比较下面两个命令有何不同效果？
普通方式
kubectl run mynginx --image=nginx
使用deployment部署应用
kubectl create deployment mytomcat --image=tomcat:8.5.68
# 自愈能力

# 想要删除这个应用就要删除部署
kubectl detlete deploy mytomcat
1
2
3
4
5
6
7
8
9
10
11

删除普通方式创建的pod就是真删除了
删除使用deployment创建pod,删除之后会新启动一个应用,这就是自愈 能力
真的想要删除这个应用,就要把这个部署删除了

1.多副本
部署三份,一个机器的应用炸了,还能在其他的机器拉起一份

kubectl create deployment my-dep --image=nginx --replicas=3
1

使用配置文件

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: my-dep
  name: my-dep
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-dep
  template:
    metadata:
      labels:
        app: my-dep
    spec:
      containers:
      - image: nginx
        name: nginx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 扩缩容

# 扩缩容 5是想要几分(包括之前的),
kubectl scale --replicas=5 deployment/my-dep
# 通过修改配置文件实现扩缩容 
kubectl edit deployment my-dep

#修改 replicas
1
2
3
4
5
6

3.自愈&故障转移
自愈:pod出现错误的时候先尝试重启这个pod进行修复
故障转移:没有办法修复的,整个机器宕机,没有办法提供服务了,这个机器下线之后,把这个机器中的pod转移到其他机器
● 停机
● 删除Pod
● 容器崩溃

4.滚动更新
想要将一个pod 升级为v2版本,那就先启动一个v2版本的pod,等启动成功之后将v1的pod下线使用v2的pod,之后的其他pod的更新都是这样以此滚动更新,不停机维护

# 更新就是更新image,mydep的部署的nginx镜像换成nginx:1.16.1   --record是记录下这次版本更新
kubectl set image deployment/my-dep nginx=nginx:1.16.1 --record
# 回滚(版本回退)
kubectl rollout status deployment/my-dep
1
2
3
4

5.版本回退

# 查看部署的历史记录
kubectl rollout history deployment/my-dep


#查看某个历史详情
kubectl rollout history deployment/my-dep --revision=2

#回滚(回到上次)
kubectl rollout undo deployment/my-dep

#回滚(回到指定版本)
kubectl rollout undo deployment/my-dep --to-revision=2
1
2
3
4
5
6
7
8
9
10
11
12

更多：
除了Deployment，k8s还有 StatefulSet 、DaemonSet 、Job  等 类型资源。我们都称为 工作负载。
有状态应用使用  StatefulSet  部署，无状态应用使用 Deployment 部署

1
2
3
4

Service

Service:Pod的服务发现和负载均衡，是将一组pod抽象为网络服务的抽象方法


前端调用后台系统的地址要是写死，后台的pod挂机之后就用不了了，现在的三个pod有三个不同 的ip所以希望使用service统一为三个pod暴露一个地址，将三个pod抽象为一组服务

测试前先将三个nginx的页面改了

将mydep的部署里面的80端口（目标端口）暴露成service的8000端口
访问service的8000端口负载均衡到pod的80端口

#暴露Deploy 后面省略了--type=CluseterIP(集群ip只能在集群内部使用)默认的
kubectl expose deployment my-dep --port=8000 --target-port=80
# 要想让集群外访问就要使用NodePort访问 
kubectl expose deployment my-dep --port=8000 --target-port=80 --type=NodePort

#使用标签检索Pod
kubectl get pod -l app=my-dep
1
2
3
4
5
6
7

NodePort范围在 30000-32767 之间

使用配置文件

apiVersion: v1
kind: Service
metadata:
  labels:
    app: my-dep
  name: my-dep
spec:
  selector:
    app: my-dep
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 80
1
2
3
4
5
6
7
8
9
10
11
12
13

Service服务暴露NodePort方式

kubectl expose deployment my-dep --port=8000 --target-port=80 --type=NodePort
1

apiVersion: v1
kind: Service
metadata:
  labels:
    app: my-dep
  name: my-dep
spec:
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 80
  selector:
    app: my-dep
  type: NodePort

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

NodePort范围在 30000-32767 之间

然后在云上把NodePort在每个节点开的端口的范围放开

访问每个服务器IP+ 端口80948都会访问到这个应用

Ingress

是Service的统一网关人口
k8s希望Ingress成为整个集群流量的唯一入口
官网地址：https://kubernetes.github.io/ingress-nginx/
就是nginx做的

# 下载yaml
wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v0.47.0/deploy/static/provider/baremetal/deploy.yaml

#修改镜像
vi deploy.yaml
#将image的值改为如下值：
registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/ingress-nginx-controller:v0.46.0

# 应用配置
kubectl apply -f deploy.yaml
# 检查安装的结果
kubectl get pod,svc -n ingress-nginx

# 最后别忘记把svc暴露的端口安全组要放行
1
2
3
4
5
6
7
8
9
10
11
12
13
14

访问31405是http的80端口，
访问32401是https的443端口

如果yaml下载不下来就去语雀里面复制
二、测试
测试环境

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-server
  template:
    metadata:
      labels:
        app: hello-server
    spec:
      containers:
      - name: hello-server
        image: registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/hello-server
        ports:
        - containerPort: 9000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: nginx-demo
  name: nginx-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-demo
  template:
    metadata:
      labels:
        app: nginx-demo
    spec:
      containers:
      - image: nginx
        name: nginx
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: nginx-demo
  name: nginx-demo
spec:
  selector:
    app: nginx-demo
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 80
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: hello-server
  name: hello-server
spec:
  selector:
    app: hello-server
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 9000
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

1、域名访问

apiVersion: networking.k8s.io/v1
kind: Ingress  
metadata:
  name: ingress-host-bar
spec:
  ingressClassName: nginx
  rules:
  - host: "hello.atguigu.com"
    http:
      paths:
      - pathType: Prefix  #前缀是hello.atguigu.com/之后的请求都转给hello-server
        path: "/"
        backend:
          service:
            name: hello-server
            port:
              number: 8000
  - host: "demo.atguigu.com"
    http:
      paths:
      - pathType: Prefix
        path: "/nginx"  # 把请求会转给下面的服务，下面的服务一定要能处理这个路径，不能处理就是404
        backend:
          service:
            name: nginx-demo  ## java，比如使用路径重写，去掉前缀nginx
            port:
              number: 8000
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

不买域名就使用域名工具将IP映射到对应的域名


问题： path: “/nginx” 与 path: “/” 为什么会有不同的效果？


带了版本号的是部署的pod里面的nginx，/nginx是Ingress层交给了pod里面处理，然后pod就要找/nginx

2、路径重写

apiVersion: networking.k8s.io/v1
kind: Ingress  
metadata:
# 路径重写第一步
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
  name: ingress-host-bar
spec:
  ingressClassName: nginx
  rules:
  - host: "hello.atguigu.com"
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: hello-server
            port:
              number: 8000
  - host: "demo.atguigu.com"
    http:
      paths:
      - pathType: Prefix
        path: "/nginx(/|$)(.*)"  # 路径重写第二步
        backend:
          service:
            name: nginx-demo 
            port:
              number: 8000
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

可以通过这种方式修改
ing是ingress的缩写

或者修改之前的配置文件ingress-rule.yaml
然后应用配置文件
现在访问访问/nginx然后转给pod的时候就会把nginx截取掉，然后这些pod访问nginx的根路径
3、流量限制
配置文件中加

#每秒放一个
  annotations:
    nginx.ingress.kubernetes.io/limit-rps: "1"
1
2
3

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-limit-rate
  annotations:
    nginx.ingress.kubernetes.io/limit-rps: "1"
spec:
  ingressClassName: nginx
  rules:
  - host: "haha.atguigu.com"
    http:
      paths:
      - pathType: Exact #精确模式 / 到nginx-demo ,/aaa就不到了
        path: "/"
        backend:
          service:
            name: nginx-demo
            port:
              number: 8000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

超过对应的流量会出现503

存储抽象

每个机器都抽象一个文件夹放到存储层，这三个文件夹里面 的内容是同步的一个服务器挂了，重新拉起一个服务可以从其他的文件夹中恢复数据。

环境准备

1、所有节点安装nfs的utis

#所有机器安装
yum install -y nfs-utils
1
2

2、主节点

#nfs主节点 准备暴露/nsf/data 所有人可以同步 以非安全 读写的方式
echo "/nfs/data/ *(insecure,rw,sync,no_root_squash)" > /etc/exports
# 给master节点创建这个文件夹
mkdir -p /nfs/data
# 启动rpcbind远程绑定，绑定文件夹
systemctl enable rpcbind --now
# 启动nsf-server 开机启动
systemctl enable nfs-server --now
#配置生效
exportfs -r
1
2
3
4
5
6
7
8
9
10

查看文件夹是否暴露在外面

3、从节点

#查看这个ip的目录有哪些是可以挂载的
showmount -e 172.31.0.4 #改成自己的master的IP地址，通过ip a 查看eth0的linet

#执行以下命令挂载 nfs 服务器上的共享目录到本机路径 /root/nfsmount
#给每个从节点也创建这个目录，这个目录名字无所谓
mkdir -p /root/nfsmount

mount -t nfs 172.31.0.4:/nfs/data /root/nfsmount
# 写入一个测试文件
echo "hello nfs server" > /root/nfsmount/test.txt
1
2
3
4
5
6
7
8
9
10

4、原生方式数据挂载

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: nginx-pv-demo
  name: nginx-pv-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-pv-demo
  template:
    metadata:
      labels:
        app: nginx-pv-demo
    spec:
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: html
          mountPath: /usr/share/nginx/html
      volumes:
        - name: html
          nfs:
            server: 172.31.0.4  #主节点
            path: /nfs/data/nginx-pv
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

将/usr/share/nginx/html挂载到外面是名字是html
挂载一直不成功的然后查看事件，发现是主节点没有nginx-pv这个文件夹，只能挂载已经创建好的文件夹。

PV&PVC的使用

之前的模式下删除这次配置但是挂载的文件夹没有删除,对每个应用没有容量上的限制
PV：持久卷（Persistent Volume），将应用需要持久化的数据保存到指定位置
PVC：持久卷申明（Persistent Volume Claim），申明需要使用的持久卷规格
两个是配合使用的

1、创建pv池
静态供应

#nfs主节点
mkdir -p /nfs/data/01
mkdir -p /nfs/data/02
mkdir -p /nfs/data/03
1
2
3
4

创建PV（只需要改IP）

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv01-10m
spec:
  capacity:
    storage: 10M
  accessModes:
    - ReadWriteMany
  storageClassName: nfs
  nfs:
    path: /nfs/data/01
    server: 172.31.0.4
---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv02-1gi
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteMany
  storageClassName: nfs
  nfs:
    path: /nfs/data/02
    server: 172.31.0.4
---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv03-3gi
spec:
  capacity:
    storage: 3Gi
  accessModes:
    - ReadWriteMany
  storageClassName: nfs
  nfs:
    path: /nfs/data/03
    server: 172.31.0.4
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
34
35
36
37
38
39
40
41

2、PVC创建与绑定
创建PVC

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: nginx-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 200Mi
  storageClassName: nfs #要和之前创建存储空间的stroageClassName对应
1
2
3
4
5
6
7
8
9
10
11

创建Pod绑定PVC

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: nginx-deploy-pvc
  name: nginx-deploy-pvc
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-deploy-pvc
  template:
    metadata:
      labels:
        app: nginx-deploy-pvc
    spec:
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: html
          mountPath: /usr/share/nginx/html
      volumes:
        - name: html
          persistentVolumeClaim:  # 挂载到申请书申请的空间
            claimName: nginx-pvc
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

使用ConfigMap抽取配置

抽取应用配置，并且可以自动更新
redis示例
1、把之前的配置文件创建为配置集

# 把reids.conf文件创建为ConfigMap（配置集）名字叫redis-conf,cm是ConfigMap的简称
# 创建配置，redis保存到k8s的etcd（档案库）；
kubectl create cm redis-conf --from-file=redis.conf
1
2
3

使用yaml

apiVersion: v1
data:    #data是所有真正的数据，key：默认是文件名   value：配置文件的内容
  redis.conf: |
    appendonly yes
kind: ConfigMap
metadata:
  name: redis-conf
  namespace: default
1
2
3
4
5
6
7
8

2、创建Pod

apiVersion: v1
kind: Pod
metadata:
  name: redis
spec:
  containers:
  - name: redis
    image: redis
    command:
      - redis-server
      - "/redis-master/redis.conf"  #指的是redis容器内部的位置
    ports:
    - containerPort: 6379
    volumeMounts:
    - mountPath: /data
      name: data
    - mountPath: /redis-master
      name: config
  volumes:
    - name: data
      emptyDir: {}
    - name: config
      configMap:
        name: redis-conf
        items:
        - key: redis.conf
          path: redis.conf
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

3、检查默认配置

kubectl exec -it redis -- redis-cli

127.0.0.1:6379> CONFIG GET appendonly
127.0.0.1:6379> CONFIG GET requirepass
1
2
3
4

4、修改ConfigMap

apiVersion: v1
kind: ConfigMap
metadata:
  name: example-redis-config
data:
  redis-config: |
    maxmemory 2mb
    maxmemory-policy allkeys-lru 
1
2
3
4
5
6
7
8

5、检查配置是否更新

kubectl exec -it redis -- redis-cli

127.0.0.1:6379> CONFIG GET maxmemory
127.0.0.1:6379> CONFIG GET maxmemory-policy
1
2
3
4

检查指定文件内容是否已经更新
修改了CM。Pod里面的配置文件会跟着变
配置值未更改，因为需要重新启动 Pod 才能从关联的 ConfigMap 中获取更新的值。
原因：我们的Pod部署的中间件自己本身没有热更新能力

总结：挂载目录使用PV&PVC
挂载配置文件使用ConfigMap

Secret

Secret 对象类型用来保存敏感信息，例如密码、OAuth 令牌和 SSH 密钥。 将这些信息放在 secret 中比放在 Pod 的定义或者 容器镜像 中来说更加安全和灵活。

kubectl create secret docker-registry leifengyang-docker \
--docker-username=leifengyang \
--docker-password=Lfy123456 \
--docker-email=534096094@qq.com

##命令格式
kubectl create secret docker-registry regcred \
  --docker-server=<你的镜像仓库服务器> \
  --docker-username=<你的用户名> \
  --docker-password=<你的密码> \
  --docker-email=<你的邮箱地址>
1
2
3
4
5
6
7
8
9
10
11

apiVersion: v1
kind: Pod
metadata:
  name: private-nginx
spec:
  containers:
  - name: private-nginx
    image: leifengyang/guignginx:v1.0
  imagePullSecrets:
  - name: leifengyang-docker
1
2
3
4
5
6
7
8
9
10

KubeSphere

KubeSphere的安装

官方网址

Kubernetes上安装KubeSphere

假如只有三台linux服务器,里面什么也没有

安装Docker

给三个服务器复制所有代码直接粘贴就行

sudo yum remove docker*
sudo yum install -y yum-utils

#配置docker的yum地址
sudo yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo


#安装指定版本
sudo yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7 containerd.io-1.4.6

#	启动&开机启动docker
systemctl enable docker --now

# docker加速配置
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://82m9ar63.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
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

安装Kubernetes

1、基本环境
每个机器使用内网ip互通
每个机器配置自己的hostname，不能用localhost

#设置每个机器自己的hostname
hostnamectl set-hostname xxx   # k8s-master,node1,node2
# 接下来的所有代码给每个机器都一起执行
# 将 SELinux 设置为 permissive 模式（相当于将其禁用）
sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

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

#允许 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2、安装kubelet、kubeadm、kubectl
要变的就是k8s的IP地址,找到自己master的IP地址

#配置k8s的yum源地址
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=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
EOF


#安装 kubelet，kubeadm，kubectl
sudo yum install -y kubelet-1.20.9 kubeadm-1.20.9 kubectl-1.20.9

#启动kubelet
sudo systemctl enable --now kubelet

#所有机器配置master域名
echo "172.31.0.4  k8s-master" >> /etc/hosts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

查看每个节点是否可以ping通ip地址
ping k8s-master
3、初始化master节点
初始化,修改主节点ip地址

kubeadm init \
--apiserver-advertise-address=172.31.0.4 \
--control-plane-endpoint=k8s-master \
--image-repository registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images \
--kubernetes-version v1.20.9 \
--service-cidr=10.96.0.0/16 \
--pod-network-cidr=192.168.0.0/16
1
2
3
4
5
6
7

记录关键信息
记录master执行完成后的日志
在自己的日志里面复制执行关键的三步

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:
# 第一步 移动配置文件目录,这样就可以随时使用kubectl命令了
  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

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/

# 第二步安装网络组件 执行这个外面下面的那个代码 curl .......
You can now join any number of control-plane nodes by copying certificate authorities
and service account keys on each node and then running the following as root:
# 需要多个领导人的话
  kubeadm join k8s-master:6443 --token 3vckmv.lvrl05xpyftbs177 \
    --discovery-token-ca-cert-hash sha256:1dc274fed24778f5c284229d9fcba44a5df11efba018f9664cf5e8ff77907240 \
    --control-plane 

Then you can join any number of worker nodes by running the following on each as root:
#第三步 作为工作节点加入主节点(在从节点执行)
kubeadm join k8s-master:6443 --token 3vckmv.lvrl05xpyftbs177 \
    --discovery-token-ca-cert-hash sha256:1dc274fed24778f5c284229d9fcba44a5df11efba018f9664cf5e8ff77907240
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

第二步:安装Calico网络插件

curl https://docs.projectcalico.org/manifests/calico.yaml -O

kubectl apply -f calico.yaml
1
2
3

安装KubeSphere前置环境

1、nfs文件系统
安装nfs-server

# 在每个机器。执行安装工具类
yum install -y nfs-utils


# 在master 执行以下所有命令 
echo "/nfs/data/ *(insecure,rw,sync,no_root_squash)" > /etc/exports


# 执行以下命令，启动 nfs 服务;创建共享目录
mkdir -p /nfs/data


# 在master执行
systemctl enable rpcbind
systemctl enable nfs-server
systemctl start rpcbind
systemctl start nfs-server

# 使配置生效
exportfs -r


#检查配置是否生效
exportfs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

配置nfs-client（选做）
同步主节点的文件夹要修改为自己的ip地址

showmount -e 172.31.0.4

mkdir -p /nfs/data

mount -t nfs 172.31.0.4:/nfs/data /nfs/data
1
2
3
4
5

配置默认存储
配置动态供应的默认存储类
里面有两处ip地址要改

## 创建了一个存储类
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-storage
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner
parameters:
  archiveOnDelete: "true"  ## 删除pv的时候，pv的内容是否要备份

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nfs-client-provisioner
  labels:
    app: nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nfs-client-provisioner
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      serviceAccountName: nfs-client-provisioner
      containers:
        - name: nfs-client-provisioner
          image: registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/nfs-subdir-external-provisioner:v4.0.2
          # resources:
          #    limits:
          #      cpu: 10m
          #    requests:
          #      cpu: 10m
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME
              value: k8s-sigs.io/nfs-subdir-external-provisioner
            - name: NFS_SERVER
              value: 172.31.0.4 ## 指定自己nfs服务器地址
            - name: NFS_PATH  
              value: /nfs/data  ## nfs服务器共享的目录
      volumes:
        - name: nfs-client-root
          nfs:
            server: 172.31.0.4
            path: /nfs/data
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: nfs-client-provisioner-runner
rules:
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["persistentvolumes"]
    verbs: ["get", "list", "watch", "create", "delete"]
  - apiGroups: [""]
    resources: ["persistentvolumeclaims"]
    verbs: ["get", "list", "watch", "update"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["storageclasses"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["events"]
    verbs: ["create", "update", "patch"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: run-nfs-client-provisioner
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    # replace with namespace where provisioner is deployed
    namespace: default
roleRef:
  kind: ClusterRole
  name: nfs-client-provisioner-runner
  apiGroup: rbac.authorization.k8s.io
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
rules:
  - apiGroups: [""]
    resources: ["endpoints"]
    verbs: ["get", "list", "watch", "create", "update", "patch"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    # replace with namespace where provisioner is deployed
    namespace: default
roleRef:
  kind: Role
  name: leader-locking-nfs-client-provisioner
  apiGroup: rbac.authorization.k8s.io
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#确认配置是否生效
kubectl get sc
1
2

nfs动态供应,会自动分配空间,不用提前创建好文件
测试一下,不要复制最下面的,下面相当于指定一个存储类的名,但是系统默认不叫nfs,系统默认叫nfs-storage

nginx-pvc是一个申请书是绑定状态,绑定了一个pv,这个pv之前没有创建过,申请书需要多大,这个pv就有多大,这是默认创建好的,这就是动态供应能力

2、metrics-server
集群指标监控组件

apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    k8s-app: metrics-server
  name: metrics-server
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    k8s-app: metrics-server
    rbac.authorization.k8s.io/aggregate-to-admin: "true"
    rbac.authorization.k8s.io/aggregate-to-edit: "true"
    rbac.authorization.k8s.io/aggregate-to-view: "true"
  name: system:aggregated-metrics-reader
rules:
- apiGroups:
  - metrics.k8s.io
  resources:
  - pods
  - nodes
  verbs:
  - get
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    k8s-app: metrics-server
  name: system:metrics-server
rules:
- apiGroups:
  - ""
  resources:
  - pods
  - nodes
  - nodes/stats
  - namespaces
  - configmaps
  verbs:
  - get
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  labels:
    k8s-app: metrics-server
  name: metrics-server-auth-reader
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: extension-apiserver-authentication-reader
subjects:
- kind: ServiceAccount
  name: metrics-server
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  labels:
    k8s-app: metrics-server
  name: metrics-server:system:auth-delegator
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:auth-delegator
subjects:
- kind: ServiceAccount
  name: metrics-server
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  labels:
    k8s-app: metrics-server
  name: system:metrics-server
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:metrics-server
subjects:
- kind: ServiceAccount
  name: metrics-server
  namespace: kube-system
---
apiVersion: v1
kind: Service
metadata:
  labels:
    k8s-app: metrics-server
  name: metrics-server
  namespace: kube-system
spec:
  ports:
  - name: https
    port: 443
    protocol: TCP
    targetPort: https
  selector:
    k8s-app: metrics-server
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    k8s-app: metrics-server
  name: metrics-server
  namespace: kube-system
spec:
  selector:
    matchLabels:
      k8s-app: metrics-server
  strategy:
    rollingUpdate:
      maxUnavailable: 0
  template:
    metadata:
      labels:
        k8s-app: metrics-server
    spec:
      containers:
      - args:
        - --cert-dir=/tmp
        - --kubelet-insecure-tls
        - --secure-port=4443
        - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
        - --kubelet-use-node-status-port
        image: registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/metrics-server:v0.4.3
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 3
          httpGet:
            path: /livez
            port: https
            scheme: HTTPS
          periodSeconds: 10
        name: metrics-server
        ports:
        - containerPort: 4443
          name: https
          protocol: TCP
        readinessProbe:
          failureThreshold: 3
          httpGet:
            path: /readyz
            port: https
            scheme: HTTPS
          periodSeconds: 10
        securityContext:
          readOnlyRootFilesystem: true
          runAsNonRoot: true
          runAsUser: 1000
        volumeMounts:
        - mountPath: /tmp
          name: tmp-dir
      nodeSelector:
        kubernetes.io/os: linux
      priorityClassName: system-cluster-critical
      serviceAccountName: metrics-server
      volumes:
      - emptyDir: {}
        name: tmp-dir
---
apiVersion: apiregistration.k8s.io/v1
kind: APIService
metadata:
  labels:
    k8s-app: metrics-server
  name: v1beta1.metrics.k8s.io
spec:
  group: metrics.k8s.io
  groupPriorityMinimum: 100
  insecureSkipTLSVerify: true
  service:
    name: metrics-server
    namespace: kube-system
  version: v1beta1
  versionPriority: 100
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

安装完之后使用命令可以看到每个nodes内存占用

安装KubeSphere

1、下载核心文件

yum install -y wget

wget https://github.com/kubesphere/ks-installer/releases/download/v3.1.1/kubesphere-installer.yaml

wget https://github.com/kubesphere/ks-installer/releases/download/v3.1.1/cluster-configuration.yaml
1
2
3
4
5

2、修改cluster-configuration

yum installl -y vim

vim cluster-configuration.yaml
1
2
3

将false改为true

这个false不用改，因为之前已经下过metrics了，不用再自动下了


3、执行安装

kubectl apply -f kubesphere-installer.yaml

kubectl apply -f cluster-configuration.yaml


1
2
3
4
5

4、查看安装进度

kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f

1
2

访问任意机器的 30880端口
账号 ： admin
密码 ： P@88w0rd

解决etcd监控证书找不到问题

kubectl -n kubesphere-monitoring-system create secret generic kube-etcd-client-certs  --from-file=etcd-client-ca.crt=/etc/kubernetes/pki/etcd/ca.crt  --from-file=etcd-client.crt=/etc/kubernetes/pki/apiserver-etcd-client.crt  --from-file=etcd-client.key=/etc/kubernetes/pki/apiserver-etcd-client.key
1

Linux单节点安装KubeSphere

一、开通服务器
4c8g；centos7.9；防火墙放行 30000~32767；指定hostname

hostnamectl set-hostname node1
1

二、安装
1、准备KubeKey

export KKZONE=cn


curl -sfL https://get-kk.kubesphere.io | VERSION=v1.1.1 sh -

chmod +x kk
1
2
3
4
5
6

2、使用KubeKey引导安装集群

#可能需要下面命令
yum install -y conntrack

./kk create cluster --with-kubernetes v1.20.4 --with-kubesphere v3.1.1
1
2
3
4

安装后开启功能

Linux多节点部署KubeSphere

二、使用KubeKey创建集群
1、下载KubeKey

export KKZONE=cn


curl -sfL https://get-kk.kubesphere.io | VERSION=v1.1.1 sh -

chmod +x kk
1
2
3
4
5
6

2、创建集群配置文件

./kk create config --with-kubernetes v1.20.4 --with-kubesphere v3.1.1

1
2

会生成一个配置文件
使用vim config-sample.yaml修改配置文件

3、创建集群

#安装conntrack命令
yum install -y conntrack

./kk create cluster -f config-sample.yaml
1
2
3
4

4、查看进度

kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
1

前提是安全组得放行

KubeSphere实战

多租户实战

创建项目在项目里部署中间件和相关应用
在每个项目里可以再邀请其他开发来加入项目

创建 的his项目在k8s相当于名称空间

中间件部署

应用部署需要关注的信息【应用部署三要素】
1、应用的部署方式
2、应用的数据挂载（数据，配置文件）
3、应用的可访问性

部署MySql有状态副本集

1、mysql容器启动
以前使用命令行创建mysql

docker run -p 3306:3306 --name mysql-01 \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql/conf.d \
-e MYSQL_ROOT_PASSWORD=root \
--restart=always \
-d mysql:5.7 
1
2
3
4
5
6
7

2、mysql配置示例

[client]
default-character-set=utf8mb4
 
[mysql]
default-character-set=utf8mb4
 
[mysqld]
init_connect='SET collation_connection = utf8mb4_unicode_ci'
init_connect='SET NAMES utf8mb4'
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
1
2
3
4
5
6
7
8
9
10
11
12
13

3、mysql部署分析

部署之前
1、先将mysql配置文件提取成ConfigMap

配置内容是第2步mysql配置示例的

2、准备一个pvc(存储卷）


开始部署MYsql
1、在工作负载中先创建一个有状态副本集





挂载存储


相当于



然后挂载配置文件到指定位置

创建完成在这个文件夹下就有了my.cof配置文件

修改了配置信息之后会自动更新到容器中，然后使用重新部署使用新 的配置文件

在集群内部通过这个命令访问其他机器的mysql

mysql -uroot -hhis-mysql-glgf.his -p
1

想要让MySQL被外部访问就先删除之前自动创建的服务，不用删除his-mysql，只删除服务

删除之后自己创建服务


指定一个工作负载

31840就是暴露给外部的端口

部署Redis

1、redis容器启动

#创建配置文件
## 1、准备redis配置文件内容
mkdir -p /mydata/redis/conf && vim /mydata/redis/conf/redis.conf


##配置示例（配置文件的内容）
appendonly yes
port 6379
bind 0.0.0.0


#docker启动redis
docker run -d -p 6379:6379 --restart=always \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-v  /mydata/redis-01/data:/data \
 --name redis-01 redis:6.2.5 \
 redis-server /etc/redis/redis.conf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2、redis部署分析

创建一个reids的配置

工作负载里创建redis有状态副本集

选择镜像

挂载存储
使用模板的方式

挂载配置文件

创建好之后也自动给我们创建了一个redis的服务
同样把这个服务删除

自己再创建一个service

应用商店

应用商店中可以一键部署

应用仓库

使用企业空间管理员（wuhan-boss）登录，设置应用仓库
学习Helm即可，去helm的应用市场添加一个仓库地址，比如：bitnami

Ruoyi-Cloud部署

1、项目
https://gitee.com/y_project/RuoYi-Cloud
2、架构

本地怎么启动项目

一、先改nacos的配置
nacos持久化需要数据库
然后在数据库中创建nacos数据库
然后在nacos中创建表结构


使用启动命令启动nacos后面加-m standalone以单节点方式启动

nacos数据库的用户信息表中存 的账号密码


2、数据库中添加数据

nacos配置文件中修改数据库库名

然后重新启动nacos
；里面就是项目的配置

创建ry-cloud库
在里面创建表
修改线上应用数据库的配置

redis的配置也要修改

云上怎么部署

之前已经部署过redis和MySQL

将数据库中数据迁移到云上

本地的mysql

云上的数据库

选择要导哪些数据库

一直下一步

部署nacos

上云之后使用集群部署模式

pod有故障转移能力，一个服务器炸了之后，它在其他服务器起起来它的IP地址就可能变化
使用有状态部署部署nacos,虽然不能保证IP地址不变，但是可以保证有一个稳定的服务域名，每个nacos都有一个固定的域名，即使在其他的机器重新拉起一份使用固定的域名也可以访问
之后部署写的部署IP地址，写的是每个nacos的固定域名

开始部署
1、直接创建有状态服务，

添加镜像从dockerhub中选版本

nacos不需要存储，都是在mysql中存储所以不需要挂载存储，配置文件也先不挂载

将nacos创建两个副本

通过访问固定的域名就可以访问到nacos

2、创建配置


cluster.conf里面的配置

3、创建有状态服务
把以前的nacos服务删除了，重新创建

三副本

添加nacos镜像


同步主机时区

挂载配置文件

创建完成

出现错误

因为挂载的时候/home/nacps/conf下有很多的配置文件，application.properties和cluster.con只是里面的两个核心配置文件，使用以前的方式直接挂载会把里面的所有内容都覆盖
所以修改一下部署模板





修改完成

4、创建一个指定工作负载，将nacos以节点方式暴露出去






访问的时候有问题，是因为nacos的配置文件直接粘贴，里面的mysql地址没有改成服务器的mysql地址

修改applocation.properties

然后将副本运行状态减为0降完之后再重新加为3启动

云上环境Dockerfile配置

./表示同级目录
项目生成的jar包放到jar文件夹下面

FROM openjdk:8-jdk
LABEL maintainer=leifengyang


#docker run -e PARAMS="--server.port 9090"
# 用8080端口启动，不管项目的配置文件怎么写docker打包的时候优先用dockerfile中的
# his-nacos.his:8848 是指定的nacos地址要改为自己的
ENV PARAMS="--server.port=8080 --spring.profiles.active=prod --spring.cloud.nacos.discovery.server-addr=his-nacos.his:8848 --spring.cloud.nacos.config.server-addr=his-nacos.his:8848 --spring.cloud.nacos.config.namespace=prod --spring.cloud.nacos.config.file-extension=yml"
# 镜像的时间是上海
RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone

COPY target/*.jar /app.jar
# 暴露8080端口
EXPOSE 8080

#启动命令 ${PARAMS}把上面的PARAMS取出来
ENTRYPOINT ["/bin/sh","-c","java -Dfile.encoding=utf8 -Djava.security.egd=file:/dev/./urandom -jar app.jar ${PARAMS}"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

规则：
1、容器默认以8080端口启动
2、时间为CST
3、环境变量 PARAMS 可以动态指定配置文件中任意的值
4、nacos集群内地址为 his-nacos.his:8848
5、微服务默认启动加载 nacos中 服务名-激活的环境.yml 文件，所以线上的配置可以全部写在nacos中。

每个微服务都暴露8080端口是否会冲突？
不会，上面图中有这么多端口是因为在同一台电脑中要避免端口冲突，但是上线到生成环境k8s中，每个应用都是在一个pod中，每个pod有自己的IP所以端口不会冲突

所以就要在nacos中进行配置抽离，首先创建命名空间prod

把之前的配置全部克隆到prod里面后缀的dev改为prod

上云的过程

项目打包到服务器上

从若以的根目录进行打包

将打包好的jar包和DockerFile文件放在一个文件夹中先在本地启动一下项目，


出错可能是字符集编码不对

以指定的字符集启动，nacos也启动测试成功
按每个微服务分类，target里面放jar包

其他的微服务也这么分类
然后将文件上传给服务器根目录，在根目录也创建一个docker


上传完成
镜像推送
进入到文件夹里面使用docker命令制作镜像，最后面的这个点 . 表示当前目录
接下来进入每个文件夹执行同样的命令，命令中的文件名要改
镜像构建完成

镜像推送

镜像不能只在master，所以要把制作好的镜像推送到镜像仓库
先在阿里云中创建镜像仓库，个人实例中创建命名空间

然后创建访问凭证：四个*是自己的用户名

# 登录到镜像仓库 四个*是自己的用户名  lfy_ruoyi是名称空间
$ docker login --username=forsum**** registry.cn-hangzhou.aliyuncs.com

#把本地镜像，改名，成符合阿里云名字规范的镜像。
$ docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/镜像名:[镜像版本号]
## docker tag 461955fe1e57 registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-visual-monitor:v1
# 将镜像推送上去
$ docker push registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/镜像名:[镜像版本号]
## docker push registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-visual-monitor:v1
1
2
3
4
5
6
7
8
9

将每个服务都推送上去

通过KubSphere部署微服务应用

部署微服务和网关

在另外两个从节点的机器中下载好所有镜像‘

1、创建无状态服务


不需要挂载也不需要外网访问，点击创建就完成了
部署规则
● 应用一启动会获取到 “应用名-激活的环境标识.yml”
● 每次部署应用的时候，需要提前修改nacos线上配置，确认好每个中间件的连接地址是否正确
查看容器日志，报错了nacos了，nacos地址没有改掉

因为bootstrap.yml中服务注册地址和配置中心地址分开写了，但是dockerfile文件中只写了一个地址没有将两个地址覆盖掉


现在就改dockerfile不改bootstrap.yml ,将配置文件中的两个nacos地址精确覆盖

之后把监控系统重新部署一下服务，用新的镜像v2的

查看容器日志出错显示目前运行的是nacosv1版本的

所以先将nacos缩一下。然后单节点启动


单节点要加一个环境变量（根据nacos的文档）

配置好之后让它只启动一份就行

把工作负载的监控服务也重新启动一下先缩为0然后再加为1
现在查看日志就没有什么问题
部署其他微服务和这个是一样的
部署的时候所有微服务都选tcp 8080

部署后台管理系统
部署之后查看镜像发现报错是和数据库相关
redis: his-redis.his
mysql: his-mysql.his
在nacos中将nacos中的配置中的redis和MySQL连接地址改为服务器里内部的地址

启动成功之后在nacos中可以看到

job上云
数据库中没有QRTZ_LOCKS这个表，但是打开数据库发现数据库中这个表是小写的所以要修改数据库的配置不要区分大小写

在kubsphere中修改数据库服务的配置，忽略大小写


然后将MySQL手动重启一下

部署网关

容器报错

每个应用上云之前不要忘记修改nacos中的配置文件

这块做流量保护的IP地址连接的是本地的

把sentiel放到cloud下面，把sentiel抽取到线上配置之后，就会把项目中配置中相关配置覆盖


重新启动服务

所有微服务和网关部署完成
现在开始部署前端

部署前端ruoyi-ui

使用命令npm run build:prod
打包之前需要修改一下vue.config.js中的配置
以前项目启动前端服务8080网关，所以要改为集群内的网关地址





然后进行打包

打包之后把这个放到nginx里面

在若以项目nginx的文件夹里面有html/dist
把打包生成的项目放到这个文件夹下

修改一下conf文件里的配置文件
要是写localhost只出来本服务器的请求，没有上云在本机跑项目的时候，这样可以但是上云之后nginx以pod方式不知道跑在那个机器中，写localhost的话其他机器发来的请求没办法处理，所以写_表示浏览器无论写什么地址来到nginx都可以处理

然后把nginx 压缩之后传给服务器

# 安装解压缩命令
yum install -y unzip zip

unzip nginx.zip

1
2
3
4
5

解压之后进入nginx目录开始构建镜像


然后在云上部署

这个要选择暴露给外网访问

暴露端口30842

然后通过IP加端口就可以访问了

补充:在关机又开机之后，之前部署的一些应用出现问题，ruoyi的微服务报错

因为nacos要连接数据库，在关机又开机之后，nacos准备就绪去找数据库，但是数据库服务可能重新启动还没有准备就绪，所以nacos找不见数据库就开始报错
，并且不会在数据库准备就绪之后再重新连接上
解决方法：让k8s做健康检查，k8s起的pod，不停检查起的pod如果有问题就不断的重新启动
nacos要是启动成功访问这个地址不会报错

检察8848端口是否存活

Devops

DevOps简介

DevOps 是一系列做法和工具，可以使 IT 和软件开发团队之间的流程实现自动化。其中，随着敏捷软件开发日趋流行，持续集成 (CI) 和持续交付 (CD) 已经成为该领域一个理想的解决方案。在 CI/CD 工作流中，每次集成都通过自动化构建来验证，包括编码、发布和测试，从而帮助开发者提前发现集成错误，团队也可以快速、安全、可靠地将内部软件交付到生产环境。

DevOps落地

内置的Agent

尚医通项目上云

项目架构

yygh-parent
|---common                                  //通用模块
|---hospital-manage                         //医院后台				[9999]   
|---model																		//数据模型
|---server-gateway													//网关    				[80]
|---service																	//微服务层
|-------service-cmn													//公共服务				[8202]
|-------service-hosp												//医院数据服务		[8201]
|-------service-order												//预约下单服务		[8206]
|-------service-oss													//对象存储服务		[8205]
|-------service-sms													//短信服务				[8204]
|-------service-statistics									//统计服务				[8208]
|-------service-task												//定时服务				[8207]
|-------service-user												//会员服务				[8203]


====================================================================

yygh-admin																	//医院管理后台		[9528]
yygh-site																		//挂号平台				[3000]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2、中间件

创建sertinel服务（自己放到镜像库中）


指定工作负载创建服务将sentinel(流量控制台)暴露给外部访问

启动成功

账号密码都是sentinel

在应用商店中添加应用mongodb

是有状态服务所以有挂载卷

为了方便访问把mongdb也挂载出去




使用mongoDB compass 软件连接测试

3、流水线
项目后台
后台管理端
用户端
2、项目默认规则
● 每个微服务项目，在生产环境时，会自动获取 微服务名-prod.yml 作为自己的核心配置文件
● 每个微服务项目，在生产环境时，默认都是使用 8080 端口
3、生产与开发配置隔离
生产环境会加载服务名-prod.yml配置


都要改成集群内的IP和端口地址

其他所有微服务的生产环境配置文件都是这样配置

部署上云

先将数据库中的数据导入到云上的数据库
连上线上的mysql然后执行sql语句

创建devops工程&Jenkins可视化

想要创建流水线工程需要创建Devops工程，这个需要开发人员的上级来创建

在devops工程里面可以邀请成员到项目中

创建流水线就是一个深度整合Jkines的过程

拉取代码

第一个步骤先指定容器

然后在这个容器内部可以添加嵌套步骤





再添加一个嵌套步骤在拉起完之后打印一下文件夹里所有内容

点击运行出现问题

将base容器指定为maven

再运行日志还是出现问题 ll命令没有找到，在最纯净的linux系统中是没有的所以可以使用ls


第一步拉起代码成功了

项目编译

项目编译要使用maven,所以要指定maven 容器

先确定代码长什么样

再添加一个命令clean 清理以前的打包，然后package打包并且跳过测试

编译的时候发现maven依赖可能是从mavne中央仓库下载不是去阿里云
可以使用admin命令登录然后在集群管理中

修改这个配置

再次启动

构建镜像

指定容器，容器只要可以运行docker命令就行

然后添加步骤先看一下项目中是否有打包好的jar文件
ls hospital-manager
运行先看一下

继续添加步骤将hospital-manage构建成镜像
工作目录是./hospital-manage/

然后运行一下流水线，构建镜像

构建镜像的时候报错target里面没有jar包
pom文件中的打包工具打包的项目名字不对

修改一下

现在就能打包成功了

重新把代码推送到git上
然后流水线再执行一下流水线的构建镜像成功 了
细化构建镜像，因为每个微服务项目都要构建镜像所以在第三步可以添加并阶段
每个阶段构建一个镜像

一个一个点太慢所以可以直接编辑Jenkinfile
复制stage

然后修改成每个微服务的名字

保存之后

执行流水线

推送到镜像仓库

先创建命名空间

镜像仓库需要登录





再修改一下先登录然后修改名字然后推送


并发推送其他的镜像到镜像仓库

然后编辑Jenkinsfile

保存之后运行一下流水线

部署到dev环境

公司中可能有dev集群和生产prod集群
先部署到dev通过了再部署到prod集群
审核：流水线执行到这会先暂停，dev-liu确认之后才继续执行流水线

给每个微服务准备一个deploy.yml(k8s的部署配置文件)

不仅会部署pod还会产生负载均衡网络

执行这个步骤，传入部署文件的位置

想要使用kubectl命令需要权限，在master节点可以用这个命令，但是其他节点使用不了

然后添加并行将其他微服务部署到dev环境
然后编辑Jenkinsfile


部署的话需要从私有仓库中下载镜像

下载需要的账号密码提前要配置一下
在工程管理里配置一个阿里云仓库凭证

因为部署的每个项目都在尚医通这个项目中，在这个项目中我们应该配置一个密钥

每个项目都是部署到his这个项目里面


部署到dev各种问题的解决
没有动态取出，而是当成字符串了

原来没有ALYUNHUB_NAMESPACE

在nacos中给每个服务的配置都加redis的配置让每个服务都连上线上的nacos

解决 部署内存不足的问题

显示内存不足

查看内存占用

是够的就先把流水线先停了
然后把之前部署失败的服务都删除了

重新启动流水线
服务准备就绪


有服务启动失败日志打印的很少

所有微服务的日志文件中改prod
然后提交代码
解决文件编码问题

先将健康检查取消

通过终端进入这个容器内找到放日志的文件夹

C;是因为之前的配置文件中写了

在nacos里面配的东西有非法字符

检查和nacos有关的配置文件
在dockerfile中强制所有项目都使用utf8了

查看项目的编码发现工程和每个微服务的编码不对应

都改为utf-8


在每个微服务的pom 中添加config的配置

同时给每个项目的日志文件中添加控制台日志输出

然后项目重新推送

就绪探针的问题
服务启动超时

访问的时候是downm,actuator/health是查看服务健康状况的接口，

本地启动的也是访问这个接口

给每个微服务的配置都加上这段配置

然后重新启动微服务

之后发现容器还是没有准备就绪
但是当我们访问一下这个服务之后它才启动成功

这是因为springboot默认启动，里面的线程池连接池都是没有初始化好，只有等我们第一次处理请求初始化之后才算启动成功
2.3. 2.4.版本的springboot开始支持整合k8s
低版本的2.2.1的就先把deploy.yml里面的就绪探针注释了，这样它启动就是启动了，不用等就绪探针就绪才算启动

系统邮件功能

最后一步项目发布成功之后邮件通知一下


在jenkijs的配置文件里面把这改为双引号就能取出

要想让系统发邮件要先配置一下全系统邮件
用admin账号登入kubesphere

在邮件账户

开启邮件发送服务POP/SMTP


同时还要配置ks-jenkins的配置文件里面的邮件的地址端口等信息

部署完成 数据验证

因为所有都要先发给网关，让网关暴露给外网访问



访问k8s内的任何机器的这个端口都是访问网关

返回的是网关返回的404就是访问成功
测试
在前端项目中配置

测试前台用户前端

把mondoDB的数据导入进去，

部署vue-admin 项目

前端要使用的Dockerfile

修改前端代码之后先推送到git

git add .
git status 
git commit -m "修改部分内容"
git push 
1
2
3
4

部署之前修改生产环境网关地址

创建流水线

构建镜像失败是因为没有找到yygh-admin是因为拉代码拉下来里面的所有文件都是在当前文件夹里面，dockerfile是在当前文件夹下面

修改完之后


任何把流水线的修改提交到git

重新启动流水线

部署nuxt-site项目（用户端）

nuxt是一个服务端渲染技术,不能想vue那样一打包放到nginx里面就可以了
Dockerfile

相当于nuxt以服务的方式在3000端口启动 的，
在vue项目里面我们进行查询是从我们电脑端给服务器发送请求，服务的地址只能暴露给外网我们才能访问。
用服务端渲染技术，nuxt就是一个服务器和我们其他网关，微服务都在一个集群里面，那么就可以通过集群内的地址来服务提高访问的速度。

创建流水线

先复制一下webhook

创建好流水线之后根据项目里面 的jenkines自动创建流水线

服务创建好之后暴露32455给外部访问

无法访问，请求被拒绝

在容器内部访问3000端口有返回，说明服务是已经正常启动的

原因是;再在本机启动一下nuxt项目，发现项目启动默认只监听localhost的3000端口，而我们现在是用集群的任何一个IP加暴露出来的端口访问最终转到我们的内部的3000端口
修改为让nuxt不仅监听localhost而是0.0.0.0任何IP的3000都可以监听


再次启动就不是本机而是任意的

提交代码重新启动流水线之后
成功访问

调用的接口的地址

问题解决：浏览器自己解析server-gatway.his了

所以还是改为网关暴露的接口

有时候访问重新启动之后我们配置的端口暴露就要重新配置了
所以当我们决定哪个服务的端口要暴露出去之后就要把deplpoy.yml里面的ClusterIP改为NodePort,同时定死暴露出去的端口

思考为什么admin 和 site的镜像大小差距这么大？

前端项目也要暴露指定的端口？


以后就能用固定的地址访问前端项目了

webhook

1、先来到码云添加webhook


密码不用填
提交代码之后自动触发流水线进行发布
要想使用webhook就要在创建流水线的时候添加代码地址，项目里面也要有Jenkinsfile文件