三. 大型分布式k8s集群从入门到精通

课程介绍

​ Kubernetes(K8s)一个用于容器集群的自动化部署、扩容以及运维的开源平台.通过Kubernetes,你可以快速有效地响应用户需求;快速而有预期地部署你的应用;极速地扩展你的应用;无缝对接新应用功能;节省资源,优化硬件资源的使用.为容器编排管理提供了完整的开源方案.

Kubernetes解决了什么问题?

• 服务器环境
• 服务器资源管理
• 服务容灾恢复
• 硬件资源利用
• 服务资源创建
• 可视化管理
• 服务资源监控
• 资源整合管理

Kubernetes在容器编排可谓是做到了淋漓尽致,解决了之前的种种痛点,但是学习成本也相对较高,需要结合一定的实践,踩一定的坑才能形成自己的理解.

目标

• 了解什么是K8s,为什么世界需要它,K8s的工程师又为什么这么抢手.
• K8s企业环境部署捷径,多Master/node快速部署.
• 基于Kubernetes集群管理,kubeadm,kubectl等常见指令使用.
• 基于Kubernetes快速启动集群Web应用.

一、Kubernetes概述

什么是K8s

Kubernetes(K8s)是Google在2014年发布的一个开源项目.

​ 据说Google的数据中心里运行着20多亿个容器,而且Google十年多前就开始使用容器技术.

​ 最初,Google开发了一个叫Borg的系统(现在命名为Omega)来调度如此庞大数量的容器和工作负载.在积累了这么多年的经验后,Google决定重写这个容器管理系统,并将其贡献到开源社区,让全世界都能受益.

​ 这个项目就是Kubernetes.简单地讲,Kubernetes是Google Omega的开源版本.

​ 从2014年第一个版本发布以来,Kubernetes迅速获得开源社区的追捧,包括Red Hat、VMware、Canonical在内的很多有影响力的公司加入到开发和推广的阵营.目前Kubernetes已经成为发展最快、市场占有率最高的容器编排引擎产品.

Kubernetes解决了什么问题

• 通过 Kubernetes,分布式系统工具将拥有网络效应.每当人们为 Kubernetes 制作出的新的工具,都会让所有其他工具更完善.因此,这进一步巩固了 Kubernetes 的标准地位.
• 云提供商并非可替换的商品.不同的云提供的服务会变得越来越独特和不同.如果可以访问不同的云提供商提供的不同服务,那么企业将因此受益.
• 当多节点应用与单节点应用一样可靠时,我们将看到定价模型的变化.
• 这就是为什么我会被 Kubernetes 洗脑的原因,它是跨越异构系统的一个标准层.
• 将来,我们会像讨论编译器和操作系统内核一样讨论 Kubernetes. Kubernetes 将会是低层级的管路系统,而不在普通应用开发人员的视野之内.

Kubernetes 已成为部署分布式应用的标准方式.在不远的将来,任何新成立的互联网公司都将用到 Kubernetes,无论其是否意识到这点.许多旧应用也正在迁移到 Kubernetes.

起因:Docker

单一稳定的一体化模型

微型化的应用部署模型

(微服务、分布式、集群、高可用、负载均衡…)

容器编排?是需要标准的?

如此多的docker该如何管理(通信、负载均衡、资源共享管理、容灾、监控、健康检查….)?

• Mesos

• docker swarm

• kubernetes

自2016年中,K8s表现出明显优势.

二、环境

部署软件环境版本

操作系统: Ubuntu 18.10(本教程采用server版本)

Docker:docker-ce 18.06

Kubernetes: K8s 1.21.8

Ubuntu搭建研发环境

我们直接下载Unbuntu18.10-server版本,server版本的好处是没有Desktop,可以节省资源.

Ubuntu安装过程

创建虚拟机

在VMWare 中启动安装虚拟过程

1. 创建新的虚拟机

2. 选择自定义安装

3. 为此虚拟机选择操作系统 Linux Ubuntu 64位

4. 命名为Master

5. 自定设置 存储为UbuntuMaster 2CPU 2048MB 40GB硬盘

6. 使用ISO镜像

7. 建议移除声卡和打印机

   

图形界面安装方式

1. 选择英文语言

2. 英文键盘

3. 设置您的用户名和密码,下文使用killer killer

4. 系统服务安装清单,一般都是直接选择Done 回车,进入安装模式.

6. 开始安装过程

   

7. 安装结束后点击重启Reboot Now

准备操作

1
2
3
4
5
6
7
8
9

# 修改root密码

# 重新启动后登录 用户名 `killer` 密码: `killer`
# 确认登录成功后输入
sudo passwd root
# 然后输入root用户的密码root

`设置root用户的密码root,是为了教学过程中简单.但是在生产环境下禁止使用弱强度的密码`
# 执行su root使用root用户重新登录

1
2

# 修改主机名称
sudo hostnamectl set-hostname master

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

# 配置静态IP(永久有效)(NAT模式)
sudo vim /etc/netplan/01-netcfg.yaml

# This file describes the network interfaces available on your system
# For more information, see netplan(5).
network:
  version: 2
  renderer: networkd
  ethernets:
    ens33:
      addresses: [192.168.64.120/24]
      dhcp4: false
      gateway4: 192.168.64.2
      nameservers:
        addresses: [192.168.64.2]
      optional: true
             
       
# 保存更改后,应用新的网络配置.可以使用以下命令来应用配置更改:
sudo netplan apply

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

# 换源
# 备份原始源列表文件:使用以下命令备份当前的软件源列表文件,以便恢复到原始状态
sudo mv /etc/apt/sources.list /etc/apt/sources.list.bak

# 编辑源列表文件:使用文本编辑器(如nano或vi)编辑软件源列表文件.

sudo vim /etc/apt/sources.list
# 阿里云源
deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse

# 更新软件包列表:使用以下命令更新新的软件源列表.
sudo apt update

三、Docker-CE安装及配置

基础准备

1. Docker 要求 Ubuntu 系统的内核版本高于 3.10 ,查看本页面的前提条件来验证你的 Ubuntu 版本是否支持 Docker.

1
2

sudo uname -r 
4.18.0-10-generic

2. 安装curl

1

sudo apt-get update && sudo apt-get install -y curl telnet wget man apt-transport-https ca-certificates software-properties-common vim 

在线安装Docker-ce

1
2
3
4
5
6
7

# 添加USTC镜像源的GPG密钥
sudo curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
# 添加USTC的Docker存储库
sudo echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 更新apt软件包索引并安装 Docker 引擎指定版本 20.10
sudo apt update && sudo apt-get install docker-ce=5:19.03.6~3-0~ubuntu-cosmic

启动Docker-ce

1
2
3
4
5
6
7

# 开机并启动docker
sudo systemctl enable docker 
sudo systemctl start docker 

# 确认docker已经运行
sudo docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES

申请阿里云镜像加速器

申请步骤如下

在阿里云注册自己账户

找到容器镜像服务,参考网址如下

点开左侧菜单镜像中心->镜像加速器

右侧加速器地址,即使私人专属的镜像加速器地址,点击复制

Docker配置国内镜像加速器

目的 : 为了下载docker镜像更快

您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器.

创建/etc/docker/daemon.json文件,内容如下:

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

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://lwczusv2c.mirror.aliyuncs.com"]
}
{
  "exec-opts": ["native.cgroupdriver=systemd"]
}
EOF
# 重载所有修改过的配置文件
sudo systemctl daemon-reload
# 重启Docker服务
sudo systemctl restart docker

四、Kubernetes 安装及部署

K8s安装环境准备

配置并安装K8s国内源

1. 创建配置文件sudo touch /etc/apt/sources.list.d/kubernetes.list

2. 添加写权限

   1	sudo chmod 666 /etc/apt/sources.list.d/kubernetes.list

   再添加,内容如下:

   1	sudo echo "deb http://mirrors.ustc.edu.cn/kubernetes/apt kubernetes-xenial main" >> /etc/apt/sources.list.d/kubernetes.list

3. 执行sudo apt update 更新操作系统源,开始会遇见如下错误

   1 2 3 4 5 6 7

   sudo apt update W: GPG error: http://mirrors.ustc.edu.cn/kubernetes/apt kubernetes-xenial InRelease: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY B53DC80D13EDEF05 E: The repository 'http://mirrors.ustc.edu.cn/kubernetes/apt kubernetes-xenial InRelease' is not signed. N: Updating from such a repository can't be done securely, and is therefore disabled by default. N: See apt-secure(8) manpage for repository creation and user configuration details.

   其中:

   1	The following signatures couldn't be verified because the public key is not available: NO_PUBKEY B53DC80D13EDEF05

   签名认证失败,需要重新生成.记住上面的NO_PUBKEY B53DC80D13EDEF05

4. 添加认证key

   运行如下命令,添加错误中对应的key(错误中NO_PUBKEY后面的key的后8位)

   1	sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 13EDEF05

   接着运行如下命令说明成功,之后进行安装:

   1	sudo gpg --export --armor 13EDEF05 | sudo apt-key add -

5. 再次重新sudo apt update更新系统下载源数据列表

禁止基础设施

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

# 禁止防火墙
sudo ufw disable
# 永久关闭swap分区
sudo sed -i 's/.*swap.*/#&/' /etc/fstab
# 禁止Selinux
# 安装操控selinux的命令
sudo apt install -y selinux-utils
# 禁止selinux
sudo setenforce 0
# 重启操作系统
sudo shutdown -r now
# 查看selinux是否已经关闭
sudo getenforce
# Disabled(表示已经关闭)

K8s系统网络配置

1
2
3
4
5
6
7
8
9
10

# 配置内核参数,将桥接的IPv4流量传递到iptables的链
sudo vim /etc/sysctl.d/K8s.conf
# 添加内容如下
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
vm.swappiness = 0

# 执行命令使修改生效
sudo modprobe br_netfilter
sudo sysctl -p /etc/sysctl.d/K8s.conf

安装K8s

1. 安装Kubernetes 目前安装版本 v1.21.8

   1	sudo apt update && sudo apt-get install -y kubelet=1.21.8-00 kubeadm=1.21.8-00 kubectl=1.21.8-00

2. 设置为开机重启

   1 2	# 如果是单机部署k8s就需要执行:kubeadm init sudo systemctl enable kubelet && sudo systemctl start kubelet

验证K8s

1
2
3
4
5
6

# 查看当前K8s版本 
sudo kubectl version

# 因为咱们是集群环境,没有单机部署,所以没执行kubeadm init导致以下报错
# Client Version: version.Info{Major:"1", Minor:"21", GitVersion:"v1.21.8", GitCommit:"4a3b558c52eb6995b3c5c1db5e54111bd0645a64", GitTreeState:"clean", BuildDate:"2021-12-15T14:52:11Z", GoVersion:"go1.16.12", Compiler:"gc", Platform:"linux/amd64"}
# The connection to the server localhost:8080 was refused - did you specify the right host or port?

五、创建企业Kubernetes多主机集群环境

创建两个节点(两个虚拟机)

1. 在VMWare中创建完整克隆,分别命名为UbuntuNode1和UbuntuNode2

   1. 选择Master虚拟机快照,点击第一份快照,选择克隆

      

   2. 选择完整克隆

      

分别对两个完整克隆的虚拟机进行如下操作,修改主机名称和静态IP

1. UbuntuNode1

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

   # 配置静态IP(永久有效)(NAT模式) sudo vim /etc/netplan/01-netcfg.yaml # This file describes the network interfaces available on your system # For more information, see netplan(5). network: version: 2 renderer: networkd ethernets: ens33: addresses: [192.168.64.121/24] dhcp4: false gateway4: 192.168.64.2 nameservers: addresses: [192.168.64.2] optional: true # 保存更改后,应用新的网络配置.可以使用以下命令来应用配置更改: sudo netplan apply # 修改主机名 sudo hostnamectl set-hostname node1 # su 用户名 su killer

2. UbuntuNode2

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

   # 配置静态IP(永久有效)(NAT模式) sudo vim /etc/netplan/01-netcfg.yaml # This file describes the network interfaces available on your system # For more information, see netplan(5). network: version: 2 renderer: networkd ethernets: ens33: addresses: [192.168.64.122/24] dhcp4: false gateway4: 192.168.64.2 nameservers: addresses: [192.168.64.2] optional: true # 保存更改后,应用新的网络配置.可以使用以下命令来应用配置更改: sudo netplan apply # 修改主机名 sudo hostnamectl set-hostname node2 # su 用户名 su killer

Master和Node基础配置

修改hosts文件

使用root用户登录

1. 打开hosts文件 sudo vim /etc/hosts

2. 输入如下内容

   1 2 3

   192.168.64.120 master 192.168.64.121 node1 192.168.64.122 node2

   
   
   

3. 重启机器sudo shutdown -r now

配置Master节点

创建工作目录

1
2

mkdir /home/killer/working
cd /home/killer/working/

创建kubeadm.conf配置文件

1. 创建K8s的管理工具kubeadm对应的配置文件,候选操作在home/killer/working/目录下

   1 2 3

   # 使用kubeadm配置文件,通过在配置文件中指定docker仓库地址,便于内网快速部署. # 生成配置文件 sudo kubeadm config print init-defaults --component-configs KubeletConfiguration > kubeadm.conf

   

2. 修改kubeadm.conf 中的如下两项:

   1 2 3 4 5 6

   # - imageRepository # - kubernetesVersion vi kubeadm.conf # 修改 imageRepository: K8s.gcr.io # 改为 registry.aliyuncs.com/google_containers imageRepository:registry.aliyuncs.com/google_containers

3. 修改kubeadm.conf中的API服务器地址,后面会频繁使用这个地址.

   1 2 3 4

   # localAPIEndpoint: localAPIEndpoint: advertiseAddress: 192.168.64.120 bindPort: 6443

   注意: 192.168.64.120是master主机的ip地址

   

4. 配置子网网络

   1 2 3 4 5

   networking: dnsDomain: cluster.local podSubnet: 10.244.0.0/16 serviceSubnet: 10.96.0.0/12 scheduler: {}

   这里的10.244.0.0/16 和 10.96.0.0/12分别是K8s内部pods和services的子网网络,最好使用这个地址,后续flannel网络需要用到.

   

拉取K8s必备的模块镜像

1. 查看一下都需要哪些镜像文件需要拉取

   1 2 3 4 5 6 7 8 9

   sudo kubeadm config images list --config ./kubeadm.conf # registry.cn-beijing.aliyuncs.com/imcto/kube-apiserver:v1.21.0 # registry.cn-beijing.aliyuncs.com/imcto/kube-controller-manager:v1.21.0 # registry.cn-beijing.aliyuncs.com/imcto/kube-scheduler:v1.21.0 # registry.cn-beijing.aliyuncs.com/imcto/kube-proxy:v1.21.0 # registry.cn-beijing.aliyuncs.com/imcto/pause:3.4.1 # registry.cn-beijing.aliyuncs.com/imcto/etcd:3.4.13-0 # registry.cn-beijing.aliyuncs.com/imcto/coredns/coredns:v1.8.0

2. 拉取镜像

   1 2 3 4 5 6 7 8 9 10 11

   # 下载全部当前版本的K8s所关联的镜像 sudo kubeadm config images pull --config ./kubeadm.conf # 对images重命名 这里要注意重命名的版本号有的是带v的,有的是不带的 注意看清楚 sudo docker tag registry.aliyuncs.com/google_containers/kube-apiserver:v1.21.0 registry.K8s.io/kube-apiserver:v1.21.0 sudo docker tag registry.aliyuncs.com/google_containers/kube-controller-manager:v1.21.0 registry.K8s.io/kube-controller-manager:v1.21.0 sudo docker tag registry.aliyuncs.com/google_containers/kube-scheduler:v1.21.0 registry.K8s.io/kube-scheduler:v1.21.0 sudo docker tag registry.aliyuncs.com/google_containers/kube-proxy:v1.21.0 registry.K8s.io/kube-proxy:v1.21.0 sudo docker tag registry.aliyuncs.com/google_containers/pause:3.4.1 registry.K8s.io/pause:3.4.1 sudo docker tag registry.aliyuncs.com/google_containers/etcd:3.4.13-0 registry.K8s.io/etcd:3.4.13-0 sudo docker tag registry.aliyuncs.com/google_containers/coredns:v1.8.0 registry.K8s.io/coredns/coredns:v1.8.0

初始化kubernetes环境

1
2

# 初始化并且启动
sudo kubeadm init --config ./kubeadm.conf

更多kubeadm配置文件参数详见

1

sudo kubeadm config print-defaults

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

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/

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

kubeadm join 192.168.64.120:6443 --token abcdef.0123456789abcdef \
        --discovery-token-ca-cert-hash sha256:dc94fc0dc028e01532b82fe99ec94ad2841a6c9a8873d496714fbc3f4147fc66 

按照官方提示,执行以下操作.

1. 执行如下命令

   1 2 3

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

   

2. 创建系统服务并启动

   1 2 3 4

   # 启动kubelet 设置为开机自启动 sudo systemctl enable kubelet # 启动K8s服务程序 sudo systemctl start kubelet

验证kubernetes启动结果

1. 验证输入,注意显示master状态是NotReady,证明初始化服务器成功

   1 2 3

   kubectl get nodes # NAME STATUS ROLES AGE VERSION # node NotReady control-plane,master 86s v1.21.8

2. 注释相关信息

   1 2 3 4 5 6 7 8

   sudo vim /etc/kubernetes/manifests/kube-controller-manager.yaml # 注释掉第26行 #- --port=0 sudo vim /etc/kubernetes/manifests/kube-scheduler.yaml # 注释到第19行 #- --port=0 # 重启kubelet sudo systemctl restart kubelet.service

3. 查看当前K8s集群状态

1
2
3

kubectl get nodes
# NAME   STATUS     ROLES                  AGE   VERSION
# node   NotReady   control-plane,master   14m   v1.21.8

目前只有一个master,还没有node,而且是NotReady状态,那么我们需要将node加入到master管理的集群中来

部署集群内部通信flannel网络

1
2

cd $HOME/working
wget https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

编辑这个文件,确保flannel网络是对的,找到sudo vim kube-flannel.yml标记的内容是否正确.

1
2
3
4
5
6

net-conf.json: |
   {
     "Network": "10.244.0.0/16",
     "Backend": {
       "Type": "vxlan"
     }

应用当前flannel配置文件

1

sudo kubectl apply -f kube-flannel.yml 

输出结果如下

1
2
3
4
5
6

namespace/kube-flannel created
serviceaccount/flannel created
clusterrole.rbac.authorization.K8s.io/flannel configured
clusterrolebinding.rbac.authorization.K8s.io/flannel configured
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds created

安装flannel网络后 执行kubectl get nodes输出结果如下

1
2
3

kubectl get nodes
# NAME   STATUS   ROLES                  AGE   VERSION
# node   Ready    control-plane,master   52m   v1.21.8

此时master已经是Ready状态了,表示已经配置成功了,那么我们就需要配置node来加入这个集群.

配置Node

配置K8s集群的Node主机环境

1. 启动K8s后台服务

   1 2	# 启动kubelet 设置为开机自启动 sudo systemctl enable kubelet

2. 将master机器的/etc/kubernetes/admin.conf传到到node1和node2

   登录master终端

   1 2 3 4

   # 将admin.conf传递给node1 sudo scp /etc/kubernetes/admin.conf killer@192.168.64.121:/home/killer/ # 将admin.conf传递给node2 sudo scp /etc/kubernetes/admin.conf killer@192.168.64.122:/home/killer/

3. 登录node1终端,创建基础kube配置文件环境

   1 2 3

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

4. 登录node2终端,创建基础kube配置文件环境

   1 2 3

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

5. node1和node2分别连接master加入master集群.这里用的是kubeadm join指令

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

   sudo kubeadm join 192.168.64.120:6443 --token abcdef.0123456789abcdef --discovery-token-ca-cert-hash sha256:dc94fc0dc028e01532b82fe99ec94ad2841a6c9a8873d496714fbc3f4147fc66 # [preflight] Running pre-flight checks # [WARNING IsDockerSystemdCheck]: detected "cgroupfs" as the Docker cgroup driver. The recommended driver is "systemd". Please follow the guide at https://kubernetes.io/docs/setup/cri/ # [preflight] Reading configuration from the cluster... # [preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -o yaml' # [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.

​ 这里要注意,使用的hash应该是master主机 kubeadm init成功之后生成的hash码.

6. 应用两个node主机分别应用flannel网络
   将master中的kube-flannel.yml分别传递给两个node节点.

   1 2 3 4

   #将kube-flannel.yml传递给node1 sudo scp $HOME/working/kube-flannel.yml killer@192.168.64.121:/home/killer/ #将kube-flannel.yml传递给node2 sudo scp $HOME/working/kube-flannel.yml killer@192.168.64.122:/home/killer/

   分别启动flannel网络

   1	killer@node1:~$ kubectl apply -f kube-flannel.yml

   1	killer@node2:~$ kubectl apply -f kube-flannel.yml

7. 查看node是否已经加入到K8s集群中(需要等一段时间才能ready)

   1 2 3 4 5

   killer@master:~$ kubectl get nodes # NAME STATUS ROLES AGE VERSION # node Ready control-plane,master 87m v1.21.8 # node1 Ready <none> 3m52s v1.21.8 # node2 Ready <none> 2m46s v1.21.8

K8s 图形化管理界面

只需在Master机器上装就可以了

Dashboard

1. 下载yaml,并运行Dashboard

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

   # 下载yaml wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0/aio/deploy/recommended.yaml vim recommended.yaml # 修改kubernetes-dashboard的Service类型 kind: Service apiVersion: v1 metadata: labels: k8s-app: kubernetes-dashboard name: kubernetes-dashboard namespace: kubernetes-dashboard spec: type: NodePort # 新增 ports: - port: 443 targetPort: 8443 nodePort: 30009 # 新增 selector: k8s-app: kubernetes-dashboard

2. 部署并查看

   1 2 3 4 5 6 7 8 9

   # 部署 kubectl apply -f recommended.yaml # 查看是否启动成功 kubectl get pods -n kubernetes-dashboard # NAME READY STATUS RESTARTS AGE # dashboard-metrics-scraper-5594697f48-7r297 1/1 Running 0 4m42s # kubernetes-dashboard-57c9bfc8c8-gvwf5 1/1 Running 0 4m42s

3. 创建账户并授权

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

   # 创建账号 kubectl create serviceaccount dashboard-admin -n kubernetes-dashboard # 授权 kubectl create clusterrolebinding dashboard-admin-rb --clusterrole=cluster-admin --serviceaccount=kubernetes-dashboard:dashboard-admin 4. 获取账户token ```bash kubectl -n kubernetes-dashboard describe secret $(kubectl -n kubernetes-dashboard get secret | grep dashboard-admin | awk '{print $1}') # token: eyJhbGciOiJSUzI1NiIsImtpZCI6IjJtWEhoU3kwZjZzM2FkdUIwaDFwbE16Xy1YUWZGckVYOVdTdWFEWFdfMkUifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlcm5ldGVzLWRhc2hib2FyZCIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJrdWJlcm5ldGVzLWRhc2hib2FyZC10b2tlbi1sbnd6OSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50Lm5hbWUiOiJrdWJlcm5ldGVzLWRhc2hib2FyZCIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6ImIzZTg0NGNiLWNmMWEtNGQxZC1hN2JmLTY5YzkzMzgwYWU5NCIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDprdWJlcm5ldGVzLWRhc2hib2FyZDprdWJlcm5ldGVzLWRhc2hib2FyZCJ9.K78S-Q0HriBPGa4pQXQQXntLzJwj8qKbBnpOFbpIn6FkZ0TN5lt7rpJ8l1dwFdM2ijvlIvRVc6Kn65RBZml2gOugE2KkUTep6mxyxxz89vzc6WoOfv2f65fd14NWx9pDx8nuNpchOH1PCRbsgiQv36Pwo-HumDVFL30q5RKt8iylt8AacFGLmgdMJbZlZ6q6FR7gcX7QdqmvlNySgyPhVtHrxZMlahbbzarl2Dulq6bREBhAuoWI_4okFMlk0fDKS6GoM582DoGQPUnQbPsyupvy9EBozKS7D5fFoPzN5fZOMYzAc9fCbKRjPq5w9IDpKYsBzdpYaL9qSO5IUPe7yg

4. 通过浏览器访问Dashboard的UI并在登录页面上输入上面的token

   1 2	# 注意是https协议,Chrome访问不了,可以用火狐 https://192.168.64.120:30009/

   
   
   

   等你们完成了应用实例,上图中的pods就会出现

Kuboard

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

# Master上执行
sudo docker run -d \
  --restart=unless-stopped \
  --name=kuboard \
  -p 80:80/tcp \
  -p 10081:10081/udp \
  -p 10081:10081/tcp \
  -e KUBOARD_ENDPOINT="http://192.168.64.120:80" \
  -e KUBOARD_AGENT_SERVER_UDP_PORT="10081" \
  -e KUBOARD_AGENT_SERVER_TCP_PORT="10081" \
  -v /root/kuboard-data:/data \
  eipwork/kuboard:v3.5.2.4

# KUBOARD_ENDPOINT="http://192.168.64.120:8091" :http://ip:prot,根据自己主机修改
# 浏览器输入 http://192.168.64.120:8091,可见打开了 UI 界面. 初始用户密码,admin Kuboard123 

1. 点击添加集群,输入名称信息,按照图中选择,点击确认
2. 复制粘贴下载 yaml 文件命令,在 master执行,即可完成导入等待一会!!!

六、应用实例

创建MySQL实例

定义描述文件

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

sudo tee mysql-rc.yaml <<-'EOF'
apiVersion: v1
kind: ReplicationController                            #副本控制器RC
metadata:
  name: mysql                                          #RC的名称,全局唯一
spec:
  replicas: 3                                          #Pod副本的期待数量
  selector:
    app: mysql                                         #符合目标的Pod拥有此标签
  template:                                            #根据此模板创建Pod的副本(实例)
    metadata:
      labels:
        app: mysql                                     #Pod副本拥有的标签,对应RC的Selector
    spec:
      containers:                                      #Pod内容器的定义部分
      - name: mysql                                    #容器的名称
        image: hub.c.163.com/library/mysql              #容器对应的Docker image
        ports: 
        - containerPort: 3306                          #容器应用监听的端口号
        env:                                           #注入容器内的环境变量
        - name: MYSQL_ROOT_PASSWORD 
          value: "123456"
EOF

加载ReplicationController副本控制器描述文件

创建好mysql-rc.yaml后,在master节点使用kubectl命令将它发布到K8s集群中.

1
2
3
4

# 创建
kubectl create -f mysql-rc.yaml
# 移除
kubectl delete -f mysql-rc.yaml

查看启动状态

通过查看当前的pods列表,是否已经启动成功

1

kubectl get pods --all-namespaces

创建Tomcat实例

定义描述文件

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

sudo tee myweb-rc.yaml <<-'EOF'
apiVersion: v1
kind: ReplicationController
metadata:
  name: myweb
spec:
  replicas: 5
  selector:
    app: myweb
  template:
    metadata:
      labels:
        app: myweb
    spec:
      containers:
      - name: myweb
        image: docker.io/kubeguide/tomcat-app:v1
        ports: 
        - containerPort: 8080
        env:
        - name: MYSQL_SERVICE_HOST
          value: "mysql"
        - name: MYSQL_SERVICE_PORT
          value: "3306"
EOF

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

apiVersion: v1                                           # 使用的 Kubernetes API 版本为 v1
kind: ReplicationController                             # 定义一个 ReplicationController 对象
metadata:
  name: myweb                                                # ReplicationController 的名称为 "myweb"
spec:
  replicas: 5                                                     # Pod 副本期望数量为 5
  selector:
    app: myweb                                                # 标签选择器,选择匹配标签 app=myweb 的 Pod 进行管理
  template:
    metadata:
      labels:
        app: myweb                                            # Pod 模板的标签为 app=myweb
    spec:
      containers:                                               # 定义容器配置
      - name: myweb                                          # 容器名称为 "myweb"
        image: docker.io/kubeguide/tomcat-app:v1   # 容器使用的镜像为 docker.io/kubeguide/tomcat-app:v1
        ports: 
        - containerPort: 8080                          # 容器监听的端口号为 8080
        env:                                                        # 容器的环境变量配置
        - name: MYSQL_SERVICE_HOST              # 环境变量 MYSQL_SERVICE_HOST 的名称
          value: "mysql"                                          # 环境变量 MYSQL_SERVICE_HOST 的值为 "mysql"
        - name: MYSQL_SERVICE_PORT              # 环境变量 MYSQL_SERVICE_PORT 的名称
          value: "3306"                                              # 环境变量 MYSQL_SERVICE_PORT 的值为 "3306"

加载RC副本描述文件

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

kubectl create -f myweb-rc.yaml
# replicationcontroller/myweb created

kubectl get rc
# NAME    DESIRED   CURRENT   READY   AGE
# mysql   3         3         3       40s
# myweb   5         5         0       5s


kubectl get pods
# NAME          READY   STATUS    RESTARTS   AGE
# mysql-mvx5c   1/1     Running   0          13h
# myweb-2c756   1/1     Running   0          72s
# myweb-8757q   1/1     Running   0          72s
# myweb-g4dpr   1/1     Running   0          72s
# myweb-mfcdk   1/1     Running   0          72s
# myweb-xr4vq   1/1     Running   0          72s

注意mysql实例 状态 Running

myweb实例状态 ContainerCreating

过几分钟myweb实例状态变成 Running

创建服务副本

在master服务器

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

sudo tee myweb-svc.yaml <<-'EOF'
apiVersion: v1
kind: Service
metadata:
  name: myweb
spec:
  type: NodePort
  ports:
    - port: 8080
      nodePort: 30001
  selector:
    app: myweb 
EOF

1
2
3
4
5
6
7
8
9
10
11

- apiVersion: v1 # 指定使用的 Kubernetes API 版本.
- kind: Service # 定义了一个 Service 对象.
- metadata: # Service 元数据,包括名称等信息.
  - name: myweb # Service 的名称为 "myweb".
- spec: # Service 的规格说明.
  - type: NodePort # 指定 Service 的类型为 NodePort,表示使用节点的 IP 地址和端口访问 Service.
  - ports:# 定义 Service 的端口配置.
    - port: 8080 # Service 的端口号为 8080.
    - nodePort: 30001 # 将该 Service 的端口映射到节点的端口 30001 上.
  - selector # 用于标识 Service 要路由到哪些 Pod 上的标签选择器.
    - app: myweb # 指定匹配标签 `app=myweb` 的 Pod.

部署服务

1

kubectl create -f myweb-svc.yaml

验证

1
2
3
4
5
6
7
8
9
10

kubectl get pods
# NAME          READY   STATUS    RESTARTS   AGE
# mysql-gxmhx   1/1     Running   0          9m50s
# mysql-sncqg   1/1     Running   0          9m50s
# mysql-xqwbt   1/1     Running   0          9m50s
# myweb-2c756   1/1     Running   0          3m26s
# myweb-8757q   1/1     Running   0          3m26s
# myweb-g4dpr   1/1     Running   0          3m26s
# myweb-mfcdk   1/1     Running   0          3m26s
# myweb-xr4vq   1/1     Running   0          3m26s

1
2
3
4

kubectl get service     
# NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
# kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP          15h
# myweb        NodePort    10.105.73.151   <none>        8080:30001/TCP   58s

已经看到已经有一个myweb服务已经启动

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

kubectl describe service myweb

# Name:                     myweb
# Namespace:                default
# Labels:                   <none>
# Annotations:              <none>
# Selector:                 app=myweb
# Type:                     NodePort
# IP Family Policy:         SingleStack
# IP Families:              IPv4
# IP:                       10.105.73.151
# IPs:                      10.105.73.151
# Port:                     <unset>  8080/TCP
# TargetPort:               8080/TCP
# NodePort:                 <unset>  30001/TCP
# Endpoints:                10.244.104.1:8080,10.244.104.2:8080,10.244.104.3:8080 + 2 more...
# Session Affinity:         None
# External Traffic Policy:  Cluster
# Events:                   <none>

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

Name:                     myweb                        # Service 的名称为 "myweb"
Namespace:                default                      # Service 所在的命名空间为 "default"
Labels:                   <none>                       # Service 没有标签
Annotations:              <none>                       # Service 没有注释
Selector:                 app=myweb                  # 匹配标签 app=myweb 的 Pod 作为后端服务
Type:                     NodePort                    # Service 的类型为 NodePort
IP Family Policy:         SingleStack               # IP 地址族策略为单栈模式
IP Families:              IPv4                            # 使用 IPv4 地址族
IP:                       10.105.73.151           # Service 的 IP 地址为 10.105.73.151
IPs:                      10.105.73.151           # Service 的 IP 地址列表为 10.105.73.151
Port:                     <unset>  8080/TCP   # Service 监听的端口为 8080/TCP
TargetPort:               8080/TCP                 # Service 转发流量到后端 Pod 的端口为 8080/TCP
NodePort:                 <unset>  30001/TCP  # 映射到节点的端口为 30001/TCP
Endpoints:                10.244.104.1:8080,10.244.104.2:8080,10.244.104.3:8080 + 2 more...    # Service 后端的实际 Pod 终端点的 IP 地址和端口信息
Session Affinity:         None                            # 会话亲和性设置为无
External Traffic Policy:  Cluster                       # 外部流量策略为集群模式
Events:                   <none>                         # 相关事件信息(无)

验证端口号

1
2

sudo netstat -tlp|grep 30001
# tcp        0      0 0.0.0.0:30001           0.0.0.0:*               LISTEN      94185/kube-proxy   

我们可以打开浏览器,输入master/node1/node2任何一个地址+30001端口都可以,访问tomcat服务.

1
2
3

http://192.168.64.120:30001
http://192.168.64.121:30001
http://192.168.64.122:30001

创建自定义的Beego 应用Web程序集群

初始化Mysql

1. 找到我们之前创建好的Mysql的pod的NAME

   1 2 3 4 5 6 7 8 9 10

   kubectl get pods # NAME READY STATUS RESTARTS AGE # mysql-gxmhx 1/1 Running 0 9m50s # mysql-sncqg 1/1 Running 0 9m50s # mysql-xqwbt 1/1 Running 0 9m50s # myweb-2c756 1/1 Running 0 12m # myweb-8757q 1/1 Running 0 12m # myweb-g4dpr 1/1 Running 0 12m # myweb-mfcdk 1/1 Running 0 12m # myweb-xr4vq 1/1 Running 0 12m

2. 查看当前pod的详细信息

   1	kubectl describe pod mysql-mvx5c

   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

   Name: mysql-mvx5c # Pod 的名称为 "mysql-mvx5c" Namespace: default # Pod 所在的命名空间为 "default" Priority: 0 # Pod 的优先级为 0 Node: node1/192.168.64.121 # Pod 分配到的节点为 "node1",节点的 IP 地址为 "192.168.64.121" Start Time: Thu, 13 Jul 2023 19:26:56 +0800 # Pod 启动的时间为 "2023年7月13日19:26:56" Labels: app=mysql # Pod 的标签为 "app=mysql" Annotations: cni.projectcalico.org/podIP: 10.244.166.129/32 # Pod 的注释信息,表示分配给 Pod 的 IP 地址 cni.projectcalico.org/podIPs: 10.244.166.129/32 # Pod 的注释信息,表示分配给 Pod 的 IP 地址 Status: Running # Pod 的状态为运行中 IP: 10.244.166.129 # Pod 的 IP 地址为 10.244.166.129 IPs: IP: 10.244.166.129 # Pod 的 IP 地址为 10.244.166.129 Controlled By: ReplicationController/mysql # 控制该 Pod 的 ReplicationController 的名称为 "mysql" Containers: mysql: Container ID: docker://9a9d27ad8b79ebb51439d315425a24da2994527783bb355bfaa2446d4d100099 # 容器的 ID Image: hub.c.163.com/library/mysql # 容器使用的镜像为 "hub.c.163.com/library/mysql" Image ID: docker-pullable://hub.c.163.com/library/mysql@sha256:b2bce1a792237ac5df78877d583f34b09ab023a77130921a6bcce67ce2d24ff0 # 镜像的 ID Port: 3306/TCP # 容器监听的端口为 3306/TCP Host Port: 0/TCP # 宿主机映射的端口为 0/TCP(随机端口) State: Running # 容器的状态为运行中 Started: Thu, 13 Jul 2023 19:27:28 +0800 # 容器启动的时间为 "2023年7月13日19:27:28" Ready: True # 容器是否就绪为 True Restart Count: 0 # 容器重启的次数为 0 Environment: MYSQL_ROOT_PASSWORD: 123456 # 容器环境变量 MYSQL_ROOT_PASSWORD 的值为 "123456" Mounts: /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-qt6gb (ro) # 挂载到容器的目录"/var/run/secrets/kubernetes.io/serviceaccount",来源为名为 "kube-api-access-qt6gb" 的卷 Conditions: Type Status Initialized True # Pod 初始化状态为 True Ready True # Pod 就绪状态为 True ContainersReady True # 所有容器就绪状态为 True PodScheduled True # Pod 被成功调度到节点上 Volumes: kube-api-access-qt6gb: Type: Projected (a volume that contains injected data from multiple sources) # 卷的类型为 Projected,用于存储从多个来源注入的数据 TokenExpirationSeconds: 3607 # 令牌过期时间为 3607 秒 ConfigMapName: kube-root-ca.crt # 关联的 ConfigMap 的名称为 "kube-root-ca.crt" ConfigMapOptional: <nil> # ConfigMap 可选关联为 nil DownwardAPI: true # 向容器提供自身的相关信息(如标签、注解等) QoS Class: BestEffort # Pod 的 QoS 类型为 BestEffort Node-Selectors: <none> # 没有指定节点选择器 Tolerations: node.kubernetes.io/not-ready:NoExecute op=Exists for 300s # 对于节点的 "not-ready" 状态,允许 Pod 在 300 秒内不可执行操作 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s # 对于节点的 "unreachable" 状态,允许 Pod 在 300 秒内不可执行操作 Events: <none> # 相关事件信息(无)

3. 得到Mysql在Subnet内网的IP地址10.244.166.129 和登录密码

   1 2 3 4

   IP: 10.244.166.129 ... Environment: MYSQL_ROOT_PASSWORD: 123456

4. 登录Mysql实例,创建数据库

   1	kubectl exec -it mysql-mvx5c -- bash

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

   root@mysql-mvx5c:/# mysql -u root --password=123456 --default-character-set=utf8 # 创建数据库,注意大小写 CREATE DATABASE IF NOT EXISTS newsWeb default charset utf8 COLLATE utf8_general_ci; # 使用数据库 use newsWeb # 退出数据库及docker exit exit

下载自定义的Beego-Docker 镜像

1
2
3

sudo docker pull registry.cn-shanghai.aliyuncs.com/itcast-golang/beego-microservices:v4
# 查看docker镜像是否已经下载成功
sudo docker images

创建Beego的RC副本文件

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

sudo tee golang-beego.yaml <<-'EOF'
apiVersion: v1                              # 使用的 Kubernetes API 版本为 v1
kind: ReplicationController                 # 资源类型为 ReplicationController
metadata:
  name: beego                               # ReplicationController 的名称为 "beego"
spec:
  replicas: 5                              # Pod 的副本数为 5
  selector:
    app: beego                             # 根据标签选择器 "app=beego" 来管理 Pod
  template:
    metadata:
      labels:
        app: beego                         # Pod 的标签为 "app=beego"
    spec:
      containers:
      - name: beego                        # 容器的名称为 "beego"
        image: registry.cn-shanghai.aliyuncs.com/itcast-golang/beego-microservices:v4
                                           # 容器使用的镜像为 "registry.cn-shanghai.aliyuncs.com/itcast-golang/beego-microservices:v4"
        ports:
        - containerPort: 8080               # 容器监听的端口为 8080
        env:
        - name: MYSQL_SERVICE_HOST          # 容器环境变量 MYSQL_SERVICE_HOST 的值为 "10.244.1.8"
          value: "10.244.166.129"
        - name: MYSQL_SERVICE_PORT          # 容器环境变量 MYSQL_SERVICE_PORT 的值为 "3306"
          value: "3306"
        - name: MYSQL_SERVICE_USER          # 容器环境变量 MYSQL_SERVICE_USER 的值为 "root"
          value: "root"
        - name: MYSQL_SERVICE_PASSWORD      # 容器环境变量 MYSQL_SERVICE_PASSWORD 的值为 "123456"
          value: "123456"
        - name: MYSQL_SERVICE_DATABASE      # 容器环境变量 MYSQL_SERVICE_DATABASE 的值为 "newsWeb"
          value: "newsWeb"
---
apiVersion: v1                              # 使用的 Kubernetes API 版本为 v1
kind: Service                               # 资源类型为 Service
metadata:
  name: beego                               # Service 的名称为 "beego"
spec:
  type: NodePort                            # Service 类型为 NodePort
  ports:
    - port: 8080                            # Service 监听的端口为 8080
      nodePort: 30080                       # 通过节点的 30080 端口访问 Service
  selector:
    app: beego                              # 根据标签选择器 "app=beego" 来匹配关联的 Pod
EOF

这里要注意,里面的Mysql环境变量IP、端口、数据库用户名密码等,都是我们上面实例获取到的.

这里实际上是在我们创建一个pods容器的时候,指定的一些环境变量.然后Beego的应用程序会从系统中这些环境变量去取数据.

目前建立了NodePort端口映射,BeegoWeb应用在内网的端口是8080,对外的映射端口是30080.那么30080就是我们外网可以访问的端口号.

装载RC副本文件,创建Beego集群实例

1

kubectl apply -f golang-beego.yaml

查看Beego的web程序pods是否已经正常启动

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

kubectl get pods


# NAME          READY   STATUS    RESTARTS   AGE
# beego-9rczj   1/1     Running   0          10s
# beego-bckx9   1/1     Running   0          10s
# beego-crgsz   1/1     Running   0          10s
# beego-m6v94   1/1     Running   0          10s
# beego-q2c6m   1/1     Running   0          10s
# mysql-gxmhx   1/1     Running   0          9m50s
# mysql-sncqg   1/1     Running   0          9m50s
# mysql-xqwbt   1/1     Running   0          9m50s
# myweb-2c756   1/1     Running   0          33m
# myweb-8757q   1/1     Running   0          33m
# myweb-g4dpr   1/1     Running   0          33m
# myweb-mfcdk   1/1     Running   0          33m
# myweb-xr4vq   1/1     Running   0          33m

也可以查看Beego程序的pods的正常输出日志

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

kubectl logs beego-9rczj     

create table `article_users` 
    -- --------------------------------------------------
    --  Table Structure for `code2/newsWeb/models.ArticleUsers`
    -- --------------------------------------------------
    CREATE TABLE IF NOT EXISTS `article_users` (
        `id` bigint AUTO_INCREMENT NOT NULL PRIMARY KEY,
        `article_id` integer NOT NULL,
        `user_id` integer NOT NULL
    ) ENGINE=InnoDB;

2023/07/14 01:53:12.584 [I] [asm_amd64.s:1337]  http server Running on http://:8080

进入其中一个Beego容器,查看环境变量是否和我们配置的一致

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

kubectl  exec -it beego-9rczj -- sh

env

# KUBERNETES_PORT=tcp://10.96.0.1:443
# KUBERNETES_SERVICE_PORT=443
# BEEGO_PORT_8080_TCP=tcp://10.105.211.185:8080
# HOSTNAME=beego-9rczj
# MYWEB_PORT_8080_TCP_ADDR=10.105.73.151
# MYWEB_SERVICE_HOST=10.105.73.151
# SHLVL=1
# HOME=/root
# MYWEB_PORT_8080_TCP_PORT=8080
# MYWEB_PORT_8080_TCP_PROTO=tcp
# MYWEB_PORT=tcp://10.105.73.151:8080
# MYWEB_SERVICE_PORT=8080
# MYWEB_PORT_8080_TCP=tcp://10.105.73.151:8080
# TERM=xterm
# KUBERNETES_PORT_443_TCP_ADDR=10.96.0.1
# MYSQL_SERVICE_PASSWORD=123456
# PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
# KUBERNETES_PORT_443_TCP_PORT=443
# MYSQL_SERVICE_HOST=10.244.166.129
# KUBERNETES_PORT_443_TCP_PROTO=tcp
# MYSQL_SERVICE_USER=root
# BEEGO_SERVICE_HOST=10.105.211.185
# BEEGO_PORT_8080_TCP_ADDR=10.105.211.185
# MYSQL_SERVICE_PORT=3306
# KUBERNETES_SERVICE_PORT_HTTPS=443
# KUBERNETES_PORT_443_TCP=tcp://10.96.0.1:443
# BEEGO_PORT_8080_TCP_PORT=8080
# KUBERNETES_SERVICE_HOST=10.96.0.1
# BEEGO_PORT_8080_TCP_PROTO=tcp
# PWD=/app
# MYSQL_SERVICE_DATABASE=newsWeb
# BEEGO_PORT=tcp://10.105.211.185:8080
# BEEGO_SERVICE_PORT=8080

验证集群是否成功

• 注册界面:http://192.168.64.121:30080/register 自己注册,后面才能登录

• 登陆界面:http://192.168.64.121:30080/login

• 后端界面

七、K8s架构图