K8S集群搭建

K8S

一、docker

安装docker

1、卸载docker

remove docker *

2、切换到管理员用户

su do root

3、安装依赖

yun install -y yum-utils

4、配置docker的源地址

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

5、安装docker

sudo yum install -y docker-ce docker-ce-cli containerd.io
#docker-ce是docker的社区版，docker-ee是企业版需要付费
#docker-ce-cli 是docker的脚手架，用于daocker的命令行
#containerd.io是daocker容器的初始化
​
#以下是在安装k8s的时候使用
yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7  containerd.io-1.4.6

###安装指定版本的docker时在docker-ce后边加上-版本号

6、启动docker

systemctl enable docker --now 

7、配置镜像加速的地址（用于快速的拉取docker镜像）

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://o2wpcbk0.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

####至此docker的安装完成，接下来可以从docker的软件市场拉取docker镜像

docker市场拉取软件镜像

网址：hub.docker.com

docker pull nginx   #此种方式拉取的软件是最新版本
#想要找软件的指定版本：去镜像标签下搜索想要的版本号
docker pull nginx：版本号
​
​
#查看所有镜像
docker images
​
#删除镜像
docker rmi 镜像名：版本号

启动容器

Usage:  docker run [OPTIONS] IMAGE [COMMAND] [ARG...]  #run命令的
​
【docker run 设置项 镜像名】 启动命令（一般不会写）
​
#-d 后台运行
#开机自启：--restart=always
#端口映射：-p 88:80 【端口映射之后需要在阿里云服务器上设置防火墙规则】
docker run --name=mynginx -d --restart=always -p 88:80 nginx
​
#删除已经停止的应用
docker rm 容器id
#强制删除命令
docker rm f 容器名
​
#查看所有容器
docker ps -a
​
#停止容器
docker stop 容器id
#再次启动
docker start 容器id
​
#修改容器设置
docker update 容器名 设置项
​

进入容器里边修改内容

docker exec -it 容器id /bin/bash
​
cd 想要的目录
​
#直接修改文件中的内容
echo "
Welcome To M&Ls Home
" >index.html
​
​
​
​
​
#挂载数据到外部修改【挂载之后的数据不能推到远程从仓库】
#在容器外部修改容器内的内容
#需要rm掉正在运行的容器，重新启动时添加设置项【-v 主机目录名:容器中的路径:ro(容器中只读)/rw（读写）】
docker run --name=mynginx -d --restart=always -p 88:80 -v /data/html:/usr/share/nginx/html:ro nginx
#多行命令分割
docker run --name=mynginx \
-d --restart=always \
-p 88:80 -v /data/html:/usr/share/nginx/html:ro \
nginx
######这之后需要保证主机的此目录下有这个文件，如果此目录下是空那么容器下就是空######
#挂在之后想要修改只需要在主机的挂载目录中修改

提交改变

docker commit --help
Usage:  docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
​
docker commit 设置项 -a "作者" -m "改变的内容描述" 容器ID/容器名 hnginx:v1.0
​
#优点：当应用挂掉之后为了找回之前的应用设置，可以直接启动commit之后的容器

镜像传输

#保存成文件设置：-o  默认的是tar文件
docker save -o nginx.tar
#将镜像变成实体文件，进行物理传输
​
#完成两台服务器之间的文件传输
scp nginx.tar 主机名([email protected]:/root/...)
​
#在别的机器加载
docker load -i nginx.tar

传输的远程仓库(docker hub)

#需要先在hub.nginx.com注册自己的nginx账号
docker tag 本地镜像 仓库名:版本
​
#推送之前需要登录
docker login
​
docker push 仓库名:版本
​
#推送完成之后退出（建议）
docker logout

其他常用命令

#查看容器日志
daocker logs 容器id/名称
​
#进入到容器中
docker exec -it 容器名/id /bin/bash
​
#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 \ #【指定名称】
nginx #【启动的是哪一个镜像】
​
​
#####此处会出现问题，解决方法如下#####
#因为容器中已经有了nginx的配置文件nginx.conf，所以我们可以选择将容器中的配置文件先复制到我们想要挂载的文件目录下
#docker cp 容器id:配置文件所在的目录 需要复制到的目录全路径
docker cp 5eff66eec7e1:/etc/nginx/nginx.conf data/conf/nginx.conf

进阶

部署中间件

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
​
#redis使用自定义配置文件启动
​
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

在使用docker之前打包应用发布到服务器的方式

#1.springboot将应用打成可执行的jar包
#2.把jar包上传给服务
#3.服务器运行java -jar

将自己的应用打包成镜像 ==> dockerfile

在idea中创建一个文件夹dockerfile

FROM openjdk:8-jdk-slim
LABEL maintainer=leifengyang
​
#最重要的一步，此步骤会将自己的java项目拷贝成一个小型的linux
COPY target/*.jar   /app.jar
#镜像的启动命令：ENTRYPOINT/CMD  最后一个引号中写自己要启动的应用
ENTRYPOINT ["java","-jar","/app.jar"]

#格式：docker build -t 镜像名:版本号 -f dockerfile .       .（重要）表明要在当前文件夹下执行
docker build -t 镜像名:版本号 -f .

启动容器

docker run -d -p 8080:8080 --name:myjavaapp 镜像名:版本号

想要将项目部署到别的新的服务器只需要按照之前的方式，将应用上传到远程的docker仓库，再通过docker pull命令将自己的应用镜像拉取到新的服务器

#1.登录远程docker仓库
docker login
​
#2.起一个名字
docker tag 老的镜像名 mataiheng/老的镜像名
​
#3.推送
docker push mataiheng/老的镜像名
​
# 别的机器
docker pull leifengyang/java-demo:v1.0
​
# 别的机器运行
docker run -d -p 8080:8080 --name myjava-app java-demo:v1.0 

#########至此以docker方式部署java应用成功########

此种方式基于docker ，springboot

二、k8s集群

是什么？（大型的容器编排系统）

kubernetes具有以下特性：

• 服务发现和负载均衡 Kubernetes 可以使用 DNS 名称或自己的 IP 地址公开容器，如果进入容器的流量很大， Kubernetes 可以负载均衡并分配网络流量，从而使部署稳定。

• 存储编排 Kubernetes 允许你自动挂载你选择的存储系统，例如本地存储、公共云提供商等。

• 自动部署和回滚 你可以使用 Kubernetes 描述已部署容器的所需状态，它可以以受控的速率将实际状态 更改为期望状态。例如，你可以自动化 Kubernetes 来为你的部署创建新容器， 删除现有容器并将它们的所有资源用于新容器。

• 自动完成装箱计算 Kubernetes 允许你指定每个容器所需 CPU 和内存（RAM）。 当容器指定了资源请求时，Kubernetes 可以做出更好的决策来管理容器的资源。

• 自我修复 Kubernetes 重新启动失败的容器、替换容器、杀死不响应用户定义的 运行状况检查的容器，并且在准备好服务之前不将其通告给客户端。

• 密钥与配置管理 Kubernetes 允许你存储和管理敏感信息，例如密码、OAuth 令牌和 ssh 密钥。 你可以在不重建容器镜像的情况下部署和更新密钥和应用程序配置，也无需在堆栈配置中暴露密钥。

Kubernetes 为你提供了一个可弹性运行分布式系统的框架。 Kubernetes 会满足你的扩展要求、故障转移、部署模式等。 例如，Kubernetes 可以轻松管理系统的 Canary 部署。

kubeadm创建集群

首先需要根据之前的docker安装，提前为所有的机器安装docker

安装kubeadm

基础环境

所有机器执行操作：

#各个机器设置自己的域名
hostnamectl set-hostname xxxx
​
​
# 将 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 < 
  
安装kubelet、kubeadm、kubectl
 
  
cat < 
  
#########kubelet 现在每隔几秒就会重启，因为它陷入了一个等待 kubeadm 指令的死循环#############
 
  
使用kubeadm引导集群
 
  
下载各个机器需要的镜像
 
  
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
 
  
初始化主节点（只在主节点运行此命令）
 
  
#所有机器添加master域名映射，以下需要修改为自己的
ip a  #找到内网的地址
echo "master节点的IP地址  cluster-endpoint（域名的名字）" >> /etc/hosts #添加域名映射
​
echo "172.26.15.251  cluster-endpoint" >> /etc/hosts #每一个节点都要执行此行代码，告诉没一个节点master节点的位置
​
​
​
#主节点初始化
kubeadm init \
--apiserver-advertise-address=172.26.15.251 （此处的ip一定要是master节点的IP地址）\
--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 #不要改
​
#如果想要改变最后两行命令，要保证所有网络范围不重叠
 
  
主节点执行命令成功之后之后：根据提示来操作
 
  
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 y1nt46.fjzoj6jrfoq8l5m7 \
    --discovery-token-ca-cert-hash sha256:d8ccbbd5f70a0549d5b82db6e2335e38f870219ee0ead8fc708a24a343e77db9 \
    --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 y1nt46.fjzoj6jrfoq8l5m7 \
    --discovery-token-ca-cert-hash sha256:d8ccbbd5f70a0549d5b82db6e2335e38f870219ee0ead8fc708a24a343e77db9
​
​
​
​
​
​
​
​
​
​
​
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 
    
#work节点的提示命令
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
 
  
#查看集群所有节点
kubectl get nodes
​
#根据配置文件，给集群创建资源
kubectl apply -f xxxx.yaml
​
#查看集群部署了哪些应用？
docker ps   ===   kubectl get pods -A
# 运行中的应用在docker里面叫容器，在k8s里面叫Pod
kubectl get pods -A
 
  
安装网络插件(在master节点运行命令)
 
  
curl https://docs.projectcalico.org/manifests/calico.yaml -O
​
#运行文件命令
kubectl apply -f calico.yaml
 
  
加入node节点（此命令24小时有效）
 
  
kubeadm join cluster-endpoint:6443 --token x5g4uy.wpjjdbgra92s25pp \
    --discovery-token-ca-cert-hash sha256:6255797916eaee52bf9dda9429db616fcd828436708345a308f4b917d3457a22
 
  
命令无效时执行(master节点下执行)
 
  
#创建新的令牌
kubeadm token create --print-join-command
 
  
 
  
高可用部署方式，也是在这一步的时候，使用添加主节点的命令即可
 
  
 
  
############################至此k8s集群搭建完毕#############################
 
  
 
  
部署k8s可视化界面==>dashboard【后期部署kubesphere之后此部署基本无用】
 
  
部署
 
  
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.3.1/aio/deploy/recommended.yaml
 
  
此步骤有可能会失败手动复制以下yaml代码 (此yaml文件存在于文件夹中)
 
  
vi dashboard.yaml
#将代码复制进去
 
  
 
  
设置访问端口(master节点)
 
  
#第一步
kubectl edit svc kubernetes-dashboard -n kubernetes-dashboard
​
#运行之后敲键盘==>/type：   找到ClusterIP 修改成 NodePort
 
  
type: ClusterIP 改为 type: NodePort
 
  
#第二步 运行以下命令
kubectl get svc -A |grep kubernetes-dashboard
​
​
​
## 找到端口，在安全组放行 （自己服务器的安全组放行端口）
 
  
此处可能存在问题需要手动修改服务器安全组
 
  
访问： https://集群任意IP:端口 https://139.198.165.238:32759
 
  
 
  
创建访问账号(master节点)
 
  
准备dash.yaml
 
  
vi dash.yaml
 
  
 
  
#创建访问账号，准备一个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
 
  
运行yaml文件(master节点)
 
  
kubectl apply -f dash.yaml
 
  
令牌访问(master节点)
 
  
#获取访问令牌
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}}"
 
  
 
  
 
  
 
  
 
  
 
  
Kubernetes核心概念
 
  
pod：运行中的一组容器 （可能存在好几个容器），是应用的最小单位
 
  
#创建一个pod
kubectl run mynginx --image=nginx
​
# 查看default名称空间的Pod
kubectl get pod         /      kubectl get pod -n default
#查看所有名称空间的pod
kubectl get pod -A
​
​
# 查看自己的pod怎么了
kubectl describe pod 你自己的Pod名字
​
# 删除
kubectl delete pod Pod名字
# 查看Pod的运行日志
kubectl logs Pod名字
​
# 每个Pod - k8s都会分配一个ip
kubectl get pod -owide
# 使用Pod的ip+pod里面运行容器的端口
curl 192.168.169.136
​
# 集群中的任意一个机器以及任意的应用都能通过Pod分配的ip来访问这个Pod
 
  
实使用配置文件的方式创建pod
 
  
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: mynginx
  name: mynginx
#  namespace: default
spec:
  containers:
  - image: nginx
    name: mynginx
 
  
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: myapp
  name: myapp
spec:
  containers:
  - image: nginx
    name: nginx
  - image: tomcat:8.5.68
    name: tomcat
 
  
 
  
Deployment（部署）
 
  
控制pod，使pod拥有多副本、自愈、扩容的能力
 
  
# 清除所有Pod，比较下面两个命令有何不同效果？
kubectl run mynginx --image=nginx
​
kubectl create deployment mytomcat --image=tomcat:8.5.68
# 自愈能力
# 使用depolyment部署的应用拥有很强的自愈能力，当一个应用被down掉之后会自动重新的启动一个新的一模一样的应用。
​
​
#关于depolyment的命令
kubectl get depoly
#删除（只有彻底删除了depolyment之后应用才会彻底挂掉）
kubectl delete depoly depoly的名字
 
  
将来想要在多台服务器部署自己的应用的时候可以用到depolyment的多副本能力
 
  
#my-dep:depolyment名字  --replicas=3：想要部署三分
kubectl create deployment my-dep --image=nginx --replicas=3
 
  
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
 
  
缩扩容
 
  
kubectl scale --replicas=5 deployment/my-dep
 
  
#修改 replicas
#会在终端中打开配置文件
kubectl edit deployment my-dep
 
  
滚动更新能力（不停机维护）
 
  
kubectl set image deployment/my-dep nginx=nginx:1.16.1 --record
kubectl rollout status deployment/my-dep
 
  
版本回退
 
  
#历史记录
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
 
  
 
  
核心概念service
 
  
 
  
service是将一组pod公开为网络服务的抽象方法
 
  
pod的服务发现与负载均衡
 
  
将来需要陪之前短的时候只需要将api地址配置成service的地址即可
 
  
#暴露Deploy  my-dep（pod组的名字 即depolyment名字）
#--port=8000 ： 是service的端口
#--target-port=80 ： 目标端口
kubectl expose deployment my-dep --port=8000 --target-port=80
​
#使用标签检索Pod
kubectl get pod -l app=my-dep
 
  
暴露service之后在整个集群中都可以通过所暴露的service IP来访问应用
 
  
#暴露depolyment的yaml写法
apiVersion: v1
kind: Service
metadata:
  labels:
    app: my-dep
  name: my-dep
spec:
  selector:
    app: my-dep
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 80
 
  
既可以使用ip来访问service也可以通过service的名字来访问
 
  
相关linux命令
 
  
curl ip地址
#访问相应的ip地址
​
#删除service
kubectl delete service service名
​
#查看service
kubectl get service
​
#查看pod的标签
kubectl get pod --show-labels
#每一个service中的pod都有相同的标签
​
#部署一个depolyment的命令
kubectl create deploy my-nginx --image=mynginx
 
  
ClusterIP（集群ip的方式：只能从集群内部访问）
 
  
# 等同于没有--type的
kubectl expose deployment my-dep --port=8000 --target-port=80 --type=ClusterIP
 
  
#yaml的方式
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: ClusterIP
 
  
NodePort（可以在公网上访问）
 
  
 
  
kubectl expose deployment my-dep --port=8000 --target-port=80 --type=NodePort
 
  
#yaml的方式
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
​
 
  
NodePort范围在 30000-32767 之间
 
  
Ingress（入口）：成为集群流量的唯一入口
 
  
 
  
###################底层就是nginx负载均衡################
 
  
安装
 
  
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 get pod,svc -n ingress-nginx
​
# 最后别忘记把svc暴露的端口要放行
 
  
 
  
执行deploy.yaml（kubectl apply -f deploy.yaml ）
 
  
###############所有的yaml文件都存在于文件夹中可以直接使用#################