k8s实战 - 技术栈

1.为什么需要使用K8s

Kubernetes是一个开源的容器集群管理系统，可以实现容器集群的自动化部署、自动扩缩容、维护等功能。

1.传统物理部署

在很久很久以前（bushi），我们还是将软件直接部署到物理机上，这样的话不需要其他的技术干预，但是呢，关于资源的分配难以控制，因为都在一个物理机上，资源共享，会不可避免的产生资源竞争，程序之间会互相影响。不是说因为资源不隔离嘛，那我就隔离不就好了，所以虚拟化部署就出现了。

2.虚拟化部署

虚拟化部署就是在传统物理机的情况下，将物理机虚拟化成多个虚拟机，这样每个虚拟机的资源就隔离了，问题不就解决了吗，但是随着物联网的发展，虚拟化的技术也开始力不从心，每一个虚拟机都有一个操作系统，这个资源不就浪费了吗，那该怎么办呢？那我所有的运行需要的基本资源比如：操作系统，我全部封装起来共用，这样不就解决浪费问题了吗，所以容器化部署就出现了。

3.容器化部署

可以理解为轻量化的虚拟技术，就是每个容器都有自己的文件系统以及资源，但是共享操作系统。因此效率更高，损耗更少。

好了，我们知道了容器化部署是我们现在的主流，那新的问题就来了，如果我的一个容器挂了，怎么去快速新增一个新的容器来顶替呢？或者，如果我的并发量很大的时候，我怎么横向增加容器呢？

以上这些问题统称为"容器编排 "问题，因为有这些问题，所以就有了容器编排工具，到这里我想你应该知道了，没错，k8s就是目前主流的容器编排工具。

4.k8s可以提供以下一些功能

**自我修复:**一旦某-个容器崩溃，能够在1秒中左右迅速启动新的容器，在k8s集群中如果某个容器宕机了，会迅速启动一台新的nginx容器。
**弹性伸缩：**在k8s集群中有4台nginx容器，总共抗并发4000 如果突然并发量堆积6000-8000 迅速在k8s集群中扩容容器如果流量下降之后就会对我们的容器缩容。
服务发现：服务可以通过自动发现的形式找到它所依赖的服务。
**负载均衡：**在k8s集群中有n多个容器组成集群通过负载均衡策略来实现访问
**版本回退:**如果发现新发布的程序版本有问题,可以立即回退到原来的版本灰度发布
存储编排：可以根据容器自身的需求自动创建存储卷

2.K8s设计原理

k8s组件

我们先通过一个概念来引入k8s集群的组件，首先我想各位学过redis和mysql的话应该都了解"主从"这个概念，就是主节点和从节点，k8s集群也是如此，主节点为"master"，从节点为"node"，master也叫控制节点，node也叫工作节点，其中

master负责集群的控制平面，负责集群的决策 ( 管理 )，而node则负责集群的数据平面，负责为容器提供运行环境 ( 干活 )，这下就清晰多了吧。

master当中几个重要的组件（现在知道有这些组件即可，混个眼熟后续使用之后慢慢就理解了）

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

在node中也有几个对应重要的组件

Kubelet : 负责维护容器的生命周期，即通过控制docker，来创建、更新、销毁容器
KubeProxy : 负责提供集群内部的服务发现和负载均衡（代理肯定跟负载均衡有关系啊）
**Container runtime：**负责镜像管理以及 Pod 和容器的真正运行（CRI）例如（docker）

举一个例子来解释k8s的基本工作机制，该例子来源于阿里云社区中的一篇文章中，例子如下

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

首先要明确，一旦 kubernetes 环境启动之后，master 和 node 都会将自身的信息存储到 etcd 数据库中；
一个 nginx 服务的安装请求会首先被发送到 master 节点的 apiServer 组件；
apiServer 组件会调用 scheduler 组件来决定到底应该把这个服务安装到哪个 node 节点上，在此时，它会从 etcd 中读取各个 node 节点的信息，然后按照一定的算法进行选择，并将结果告知 apiServer；
apiServer 调用 controller-manager 去调度 Node 节点安装 nginx 服务；
kubelet 接收到指令后，会通知 docker，然后由 docker 来启动一个 nginx 的 pod，pod 是 kubernetes 的最小操作单元，容器必须跑在 pod 中；
当Pod启动后，一个 nginx 服务就运行了，如果需要访问 nginx，就需要通过 kube-proxy 来对 pod 产生访问的代理

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

常见名词

**Master:**集群控制节点，每个集群需要至少一个master节点负责集群的管控
**Node:**工作负载节点，由master分配容器到这些node工作节点上，然后node节点上的docker负责容器的运行
Pod: kubernetes的最小控制单元，容器都是运行在pod中的，-个pod中可以有1个或者多个容器
**Controller:**控制器，通过它来实现对pod的管理，比如启动pod、停止pod、伸缩pod的数量等等
Service: pod对外服务的统一入口，下面可以维护者同一类的多个pod
**Label:**标签,用于对pod进行分类，同一类pod会拥有相同的标签
**NameSpace:**命名空间，用来隔离pod的运行环境

3.kubernetes 环境搭建

1.一主多从: 在学习阶段我们只需要一台Master节点和多台Node节点，搭建简单,有单机发生故障风险，适合用于测试环境

2.多主多从:多台Master节点和多台Node节点，搭建有一些麻烦,安全系数高，适合用于生产环境

4.本地通过虚拟机构建kubernetes 环境

在D:\path\linux 创建三个不同的文件夹

启动虚拟机过程，建议分开的形式启动这三台虚拟机

注意：克隆了之后记得一定要修改该linux服务器 mac地址

环境准备

1.一个主多个工作节点: 一台Master节点和多台Node节点，搭建简单,但是有单机故障风险，适合用于测试环境

2.多主节点多工作节点:多台Master节点和多台Node节点，搭建麻烦,安全性高，适合用于生产环境

程序员初学练习，采用一主多从即可

ip地址	类型	操作系统	服务配置
192.168.200.129	Master	Centos7.6	2核CPU 2G内存 20G硬盘
192.168.200.130	Node1	Centos7.6	2核CPU 2G内存 20G硬盘
192.168.200.131	Node2	Centos7.6	2核CPU 2G内存 20G硬盘

使用 Xshell 远程连接到这三台服务器

初始化环境

需要在这三台服务器上执行以下操作：

1.检查操作系统的版本

#此方式下安装kubernetes集群要求Centos版本要在7.5或之上

#查看linux版本号

cat /etc/redhat-release

2.主机名解析

注意切换成root权限

复制代码

su root

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

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

vi /etc/hosts

复制代码

192.168.186.132  master
192.168.186.133   node1
192.168.186.134   node2

让后节点之间相互ping下

ping master

ping node1

ping node2

3.时间同步

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

企业中建议配置内部的时间同步服务器

复制代码

curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
yum install -y chrony
systemctl start chronyd
systemctl enable chronyd

4.禁用iptables和firewalld服务

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

复制代码

# 1关闭firewalld服务

[root@master ~]# systemctl stop firewalld
[root@master ~]# systemctl disable firewalld

# 2关闭iptables服务

[root@master ~]# systemctl disabled iptables
[root@master ~]# systemctl disable iptables

5.关闭selinux

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

复制代码

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

改成：

6.禁用swap分区

swap分区指的是虚拟内存分区，它的作用是在物理内存使用完之后，将磁盘空间虚拟成内存来使用

启用swap设备会对系统的性能产生非常负面的影响，因此kubernetes要求每个节点都要禁用swap设备

但是如果因为某些原因确实不能关闭swap分区，就需要在集群安装过程中通过明确的参数进行配置说明

plsql 复制代码

#编辑分区配置文件/etc/fstab,注释掉swap分区一行
vi /etc/fstab

7.修改Linux内核参数

plsql 复制代码

#修改linux的内核参数，添加网桥过滤和地址转发功能
vi /etc/sysctl.d/kubernetes.conf文件，添加如下配置:
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
#重新加载配置
[root@mayikt ~]# sysctl -p
#加载网桥过滤模块
[root@mayikt ~]# modprobe br_netfilter
#查看网桥过滤模块是否加载成功
[root@mayikt ~]# lsmod  | grep br_netfilter

8.配置ipvs功能

在kubernetes中service有两种代理模型，-种是基于iptables的, - -种是基于ipvs的

两者比较的话，ipvs的性能明显要高一些,但是如果要使用它，需要手动载入ipvs模块

k8s service 会使用 ipvs/iptables

plsql 复制代码

# 备份原有 yum 源配置
mkdir -p /etc/yum.repos.d/bak
mv /etc/yum.repos.d/*.repo /etc/yum.repos.d/bak/

# 下载阿里云 CentOS 7 归档源配置
curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo

# 替换配置中的 $releasever 为 7（避免变量解析问题）
sed -i 's/$releasever/7/g' /etc/yum.repos.d/CentOS-Base.repo

# 清理并重建 yum 缓存
yum clean all
yum makecache

# 1安装ipset和ipvsadm
[root@mayikt ~]# yum install ipset ipvsadm -y

# 检查 ipvsadm 版本
ipvsadm -v

# 2添加需要加载的模块写入脚本文件
[ root@mayikt ~]# cat <<EOF > /etc/sysconfig/modules/ipvs.modules
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF

# 3为脚本文件添加执行权限
[root@mayikt ~]# chmod +x /etc/sysconfig/modules/ipvs.modules

# 4执行脚本文件
[root@mayikt ~]# sh +x /etc/sysconfig/modules/ipvs.modules

# 5查看对应的模块是否加载成功
[root@mayikt ~]# lsmod | grep -e ip_vs -e nf_conntrack_ipv4

9.重启Linux系统

安装kubernetes

安装docker

复制代码

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

如果报错 -bash: wget: 未找到命令
则执行： yum -y install wget
# 2查看当前镜像源中支持的docker版本
[root@master ~]# yum list docker-ce --showduplicates

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

# 4添加一个配置文件 阿里云加速镜像
[root@master ~]# mkdir /etc/docker
[ root@master ~]# cat <<EOF > /etc/docker/daemon.json
{
"exec-opts": ["native.cgroupdriver=systemd"],
"registry-mirrors": [ "https://66mzqrih.mirror.aliyuncs.com"]
}
EOF

# 5启动docker
[root@master ~]# systemctl start docker
[root@master ~]# systemctl enable docker

# 6检查docker状态和版本
[root@master ~]# docker --version

安装kubernetes组件

复制代码

#由于kubernetes的镜像源在国外，速度比较慢，这里切换成国内的镜像源
# 使用命令:  vi  /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

#3.安装kubeadm、kubelet和kubectl
[root@master ~]# yum install --setopt=obsoletes=0 kubeadm-1.17.4-0 kubelet-1.17.4-0 kubectl-1.17.4-0 -y
#4.配置kubelet的cgroup
#vi /etc/sysconfig/kubelet,添加下面的配置
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"

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

准备集群镜像

在阿里云仓库中存在该镜像在更改为k8s 官方的名称,同时需要在所有节点操作

复制代码

#在安装k8s集群之前，必须要提前准备好集群需要的镜像，所需镜像可以通过下面命令查看
1.kubeadm config images list
k8s.gcr.io/kube-apiserver:v1.17.17
k8s.gcr.io/kube-controller-manager:v1.17.17
k8s.gcr.io/kube-scheduler:v1.17.17
k8s.gcr.io/kube-proxy:v1.17.17
k8s.gcr.io/pause:3.1
k8s.gcr.io/etcd:3.4.3-0
k8s.gcr.io/coredns:1.6.5
2.下载镜像
#此镜像在k8s的仓库中,由于网络原因,无法连接，下面提供了-种替代方案
images=(
kube-apiserver:v1.17.4
kube-controller-manager:v1.17.4
kube-scheduler:v1.17.4
kube-proxy:v1.17.4
pause:3.1
etcd:3.4.3-0 
coredns:1.6.5
)

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

集群初始化

只需要在master节点上执行即可

复制代码

#1. 初始化一个 Kubernetes 集群的控制平面节点（Master 节点）是搭建 K8s 集群的核心步骤。执行成功后，你的服务器会成为集群的第一个节点，并生成加入集群所需的配置信息。
kubeadm init \
--kubernetes-version=v1.17.4 \
--pod-network-cidr=10.244.0.0/16 \
--image-repository registry.aliyuncs.com/google_containers \
--service-cidr=10.96.0.0/12 \
--apiserver-advertise-address=192.168.186.132

注意：--image-repository 需要更改为阿里云加速镜像 
--apiserver-advertise-address=192.168.75.152  修改为自己的 master的ip。
初始化大概需要花费1分钟左右

#2.查看日志
journalctl -xeu kubelet 

#2.创建必要文件
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

3.拷贝该到其他两个节点执行加入 k8s集群环境

复制代码

kubeadm join 192.168.186.132:6443 --token gq1xr2.qvxt4zkrvkvsfuiw \
    --discovery-token-ca-cert-hash sha256:27cd7d274448ebede6b2fae94ca69686177d2400422a18ffeaf6efe9aa9a6055

4.执行 kubectl get nodes

网络插件的安装

kube-flannel.yml 上传到Master节点任意位置修改文件中quay.io仓库为quay-mirror.qiniu.com

复制代码

apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
  name: psp.flannel.unprivileged
  annotations:
    seccomp.security.alpha.kubernetes.io/allowedProfileNames: docker/default
    seccomp.security.alpha.kubernetes.io/defaultProfileName: docker/default
    apparmor.security.beta.kubernetes.io/allowedProfileNames: runtime/default
    apparmor.security.beta.kubernetes.io/defaultProfileName: runtime/default
spec:
  privileged: false
  volumes:
    - configMap
    - secret
    - emptyDir
    - hostPath
  allowedHostPaths:
    - pathPrefix: "/etc/cni/net.d"
    - pathPrefix: "/etc/kube-flannel"
    - pathPrefix: "/run/flannel"
  readOnlyRootFilesystem: false
  # Users and groups
  runAsUser:
    rule: RunAsAny
  supplementalGroups:
    rule: RunAsAny
  fsGroup:
    rule: RunAsAny
  # Privilege Escalation
  allowPrivilegeEscalation: false
  defaultAllowPrivilegeEscalation: false
  # Capabilities
  allowedCapabilities: ['NET_ADMIN']
  defaultAddCapabilities: []
  requiredDropCapabilities: []
  # Host namespaces
  hostPID: false
  hostIPC: false
  hostNetwork: true
  hostPorts:
  - min: 0
    max: 65535
  # SELinux
  seLinux:
    # SELinux is unsed in CaaSP
    rule: 'RunAsAny'
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: flannel
rules:
  - apiGroups: ['extensions']
    resources: ['podsecuritypolicies']
    verbs: ['use']
    resourceNames: ['psp.flannel.unprivileged']
  - apiGroups:
      - ""
    resources:
      - pods
    verbs:
      - get
  - apiGroups:
      - ""
    resources:
      - nodes
    verbs:
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - nodes/status
    verbs:
      - patch
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: flannel
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: flannel
subjects:
- kind: ServiceAccount
  name: flannel
  namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: flannel
  namespace: kube-system
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: kube-flannel-cfg
  namespace: kube-system
  labels:
    tier: node
    app: flannel
data:
  cni-conf.json: |
    {
      "cniVersion": "0.2.0",
      "name": "cbr0",
      "plugins": [
        {
          "type": "flannel",
          "delegate": {
            "hairpinMode": true,
            "isDefaultGateway": true
          }
        },
        {
          "type": "portmap",
          "capabilities": {
            "portMappings": true
          }
        }
      ]
    }
  net-conf.json: |
    {
      "Network": "10.244.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-amd64
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: beta.kubernetes.io/os
                    operator: In
                    values:
                      - linux
                  - key: beta.kubernetes.io/arch
                    operator: In
                    values:
                      - amd64
      hostNetwork: true
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-amd64
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-amd64
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
             add: ["NET_ADMIN"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run/flannel
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-arm64
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: beta.kubernetes.io/os
                    operator: In
                    values:
                      - linux
                  - key: beta.kubernetes.io/arch
                    operator: In
                    values:
                      - arm64
      hostNetwork: true
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-arm64
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-arm64
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
             add: ["NET_ADMIN"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run/flannel
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-arm
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: beta.kubernetes.io/os
                    operator: In
                    values:
                      - linux
                  - key: beta.kubernetes.io/arch
                    operator: In
                    values:
                      - arm
      hostNetwork: true
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-arm
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-arm
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
             add: ["NET_ADMIN"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run/flannel
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-ppc64le
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: beta.kubernetes.io/os
                    operator: In
                    values:
                      - linux
                  - key: beta.kubernetes.io/arch
                    operator: In
                    values:
                      - ppc64le
      hostNetwork: true
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-ppc64le
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-ppc64le
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
             add: ["NET_ADMIN"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run/flannel
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-s390x
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: beta.kubernetes.io/os
                    operator: In
                    values:
                      - linux
                  - key: beta.kubernetes.io/arch
                    operator: In
                    values:
                      - s390x
      hostNetwork: true
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-s390x
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay-mirror.qiniu.com/coreos/flannel:v0.11.0-s390x
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
             add: ["NET_ADMIN"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run/flannel
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg

#所有主机尽量都pull一下也是可以的（先执行这个，三台机器都要有这个镜像）

复制代码

docker pull quay.io/coreos/flannel:v0.12.0-amd64

#在master节点执行：(注意路径)

复制代码

 kubectl apply -f kube-flannel.yml

修改 每台节点的： vi /var/lib/kubelet/kubeadm-flags.env   # 删除--network-plugin=cni

#重新启动
则需要修改 每台节点的 
systemctl daemon-reload

systemctl restart kubelet

整个k8s集群环境就搭建成功啦!

5.kubernetes部署nginx

复制代码

#在Master节点上执行
#1.在 Kubernetes 集群中创建一个名为 nginx 的 Deployment 资源，用于管理运行 Nginx 容器的 Pod。
kubectl create deployment nginx --image=nginx:1.14-alpine
#2.为刚才创建的 nginx Deployment 暴露一个服务（Service），让集群外能访问到 Nginx Pod
kubectl expose deployment nginx --port=80 --type=NodePort
#3.查看集群中当前的 Pod 和 Service 资源的状态，验证前面的命令是否执行成功
kubectl get pods,service

每台服务器执行docker ps 查看nginx 运行具体在那一台

192.168.75.154:31347

复制代码

        name: kube-flannel-cfg


\#所有主机尽量都pull一下也是可以的（先执行这个，三台机器都要有这个镜像）

docker pull quay.io/coreos/flannel:v0.12.0-amd64

复制代码

\#在master节点执行：(注意路径)

kubectl apply -f kube-flannel.yml

修改每台节点的： vi /var/lib/kubelet/kubeadm-flags.env # 删除--network-plugin=cni

#重新启动

则需要修改每台节点的

systemctl daemon-reload

systemctl restart kubelet

复制代码

[外链图片转存中...(img-5w3VRLZe-1772977939779)]

整个k8s集群环境就搭建成功啦!

# 5.kubernetes部署nginx

#在Master节点上执行

#1.在 Kubernetes 集群中创建一个名为 nginx 的 Deployment 资源，用于管理运行 Nginx 容器的 Pod。

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

#2.为刚才创建的 nginx Deployment 暴露一个服务（Service），让集群外能访问到 Nginx Pod

kubectl expose deployment nginx --port=80 --type=NodePort

#3.查看集群中当前的 Pod 和 Service 资源的状态，验证前面的命令是否执行成功

kubectl get pods,service

复制代码

每台服务器执行docker ps 查看nginx 运行具体在那一台

192.168.75.154:31347