K8s学习

最新推荐文章于 2024-04-23 16:59:28 发布

巧克力的青春

最新推荐文章于 2024-04-23 16:59:28 发布

阅读量293

点赞数

分类专栏：常用

本文链接：https://blog.csdn.net/qq_38571802/article/details/119892137

版权

常用专栏收录该内容

2 篇文章 0 订阅

订阅专栏

K8s

Service是分布式集群架构的核心，一个Service拥有以下关键特征：

拥有唯一指定的名称
拥有一个虚拟IP和端口号
能够提供某种远程服务能力
被映射到提供这种服务能力的一组容器应用上

K8s 特点

自动装箱
- 基于容器对应用运行环境的资源配置要求自动部署应用容器
自我修复
- 当容器失败时，会对容器进行重启
水平扩展
- 对应用容器进行规模扩大或规模剪裁
服务发现
- 基于 Kubernetes 自身能力实现服务发现和负载均衡
滚动更新
- 对应用容器运行的应用，进行一次性或批量式更新
版本回退
- 对应用容器运行的应用，进行历史版本即时回退
密钥和配置管理
- 在不需要重新构建镜像的情况下，可以部署和更新密钥和应用配置，类似热部署。
存储编排
- 自动实现存储系统挂载及应用
批处理
- 提供一次性任务，定时任务；满足批量数据处理和分析的场景

master组件

apiserver
- 集群统一入口，以restful方式，交给etcd存储
scheduler
- 节点调度，选择node节点应用部署
controller-manager
- 处理集群中常规后台任务，一个资源对应一个控制器
etcd
- 存储系统，用于保存集群相关的数据

node组件

kubeelet
- master排到node节点代表，管理本机容器
kube-proxy
- 提供网络代理，负载均衡等操作

k8s核心概念

pod
- 最小部署单元
- 一组容器的集合
- 共享网络
- 生命周期短暂
controller
- 确保预期的pod副本数量
- 无状态应用部署
- 有状态应用部署
- 确定所有的node运行同一个pod
- 一次性任务和定时任务
Server
- 定义一组pod的访问规则

由server统一入口进行访问，由controller创建pod进行部署

快速部署k8s集群

1. 安装要求

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

一台或多台机器，操作系统 CentOS7.x-86_x64
硬件配置：2GB或更多RAM，2个CPU或更多CPU，硬盘30GB或更多
可以访问外网，需要拉取镜像，如果服务器不能上网，需要提前下载镜像并导入节点
禁止swap分区

2. 准备环境

角色	IP
master	192.168.74.132
node1	192.168.74.131
node2	192.168.74.130

# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

# 关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinux/config  # 永久
setenforce 0  # 临时

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

# 根据规划设置主机名
hostnamectl set-hostname <hostname>

# 在master添加hosts
cat >> /etc/hosts << EOF
192.168.74.132 k8smaster
192.168.74.131 k8snode1
192.168.74.130 k8snode2
EOF

# 将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl --system  # 生效

# 时间同步
yum install ntpdate -y
ntpdate time.windows.com

3. 所有节点安装Docker/kubeadm/kubelet

Kubernetes默认CRI（容器运行时）为Docker，因此先安装Docker。

3.1 安装Docker

$ wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
$ yum -y install docker-ce-18.06.1.ce-3.el7
$ systemctl enable docker && systemctl start docker
$ docker --version
Docker version 18.06.1-ce, build e68fc7a

$ cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF

3.2 添加阿里云YUM软件源

$ cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

3.3 安装kubeadm，kubeelet和kubectl

由于版本更新频繁，这里指定版本号部署：

$ yum install -y kubelet-1.18.0 kubeadm-1.18.0 kubectl-1.18.0
$ systemctl enable kubelet

4. 部署Kubernetes Master

在192.168.47.132（Master）执行。

$ kubeadm init \
  --apiserver-advertise-address=192.168.74.132 \
  --image-repository registry.aliyuncs.com/google_containers \
  --kubernetes-version v1.18.0 \
  --service-cidr=10.96.0.0/12 \
  --pod-network-cidr=10.244.0.0/16

由于默认拉取镜像地址k8s.gcr.io国内无法访问，这里指定阿里云镜像仓库地址。

使用kubectl工具：

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

5. 加入Kubernetes Node

在192.168.74.131/130（Node）执行。

向集群添加新节点，执行在kubeadm init输出的kubeadm join命令：

kubeadm join 192.168.74.132:6443 --token 2v5uht.rma5r5ncm0vsqxcs \
    --discovery-token-ca-cert-hash sha256:15672fe323bc36061547c15de022247ffbb99b5c85d79b38247dbe0bbe973b32

默认token有效期为24小时，当过期之后，该token就不可用了。这时就需要重新创建token，操作如下：

kubeadm token create --print-join-command

6. 部署CNI网络插件

kube-flannel.yaml

---
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: lizhenliang/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: lizhenliang/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

默认镜像地址无法访问，sed命令修改为docker hub镜像仓库。

kubectl apply -f kube-flannel.yml

kubectl get pods -n kube-system
NAME                          READY   STATUS    RESTARTS   AGE
kube-flannel-ds-amd64-2pc95   1/1     Running   0          72s

7. 测试kubernetes集群

在Kubernetes集群中创建一个pod，验证是否正常运行：

$ kubectl create deployment nginx --image=nginx
$ kubectl expose deployment nginx --port=80 --type=NodePort
$ kubectl get pod,svc

访问地址：http://192.168.74.131:端口号

Kubectl

集群的命令行工具

对集群本身进行管理，并能在集群上进行容器化应用的安装部署
- ```
kubevtl [command] [TYPE] [NAME] [flags]
```
- command：指定要对资源执行的操作，例如create、get、describe、delete
- TYPE：指定资源类型，资源类型是大小写敏感
- NAME：指定资源的名称
- flags：指定可选的参数，例如-s、-server

Pod

1、基本概念

最小部署的单元
k8s不直接处理容器，而是处理Pod，Pod由一个或多个容器组成
短暂

2、存在意义

创建容器使用docker，一个docker对应一个容器，一个容器有进程，一个容器运行一个应用程序
Pod是多进程护设计，运行多个应用程序
- 一个Pode有多个容器，一个容器里面运行一个应用程序
Pod存在为了亲密性应用
- 两个应用之间进行交互
- 网络之间调用
- 两个应用需要频繁调用

3、实现机制

共享网络
共享存储

创建

kubectl create -f xxx.yaml

查看

kubectl get pod <Pod_name>

删除

kubectl delete -f pod xxx.yaml

controller

1、什么是controller

在集群上管理和运行容器的对象

2、Pod和Controller关系

Pod通过Controller实现应用的运维
- 比如伸缩，滚动升级等等
通过 label 标签建立关系

3、Deployment控制器应用场景

部署无状态应用
管理Pod和ReplicaSet
部署，滚动升级等功能
应用场景：
- web服务
- 微服务

4、yaml文件字段说明

5、Deployment控制器部署应用

导出yaml文件

kubectl create deployment web --image=nginx --dry-run -o yaml > web.yaml

使用yaml部署应用
- ```
kubectl apply -f web.yaml
```

对外发布（暴露对外端口号）

kubectl expose deployment web --port=80 --type=NodePort --target-port=80 --name=web1 -o yaml > web1.yaml

执行发布
- ```
kubectl apply -f web1.yaml
```
查看
- ```
kubectl get pods,svc
```

6、升级回滚

7、弹性伸缩

8、无状态与有状态

无状态
- 认为Pod都一样
- 没有顺序要求
- 不用考虑在哪个node运行
- 随意进行伸缩和扩展
有状态
- 无状态所有因素都需要考虑
- 每个Pod独立，保存启动顺序和唯一性
  - 唯一的网络标识符，持久存储
  - 有序，比如mysql主从

9、部署有状态应用

无头service
- ClusterIP：none
SatefulSet 部署有状态应用
deployment和statefulSet区别：有身份（唯一标识）
- 根据主机名 + 按照一定规则生成域名
- 每个Pod有唯一主机名
- 唯一域名：
  - 格式：主机名称.service名称.名称空间.svc.cluster.local

Service

1、service存在意义

防止Pod失联（服务发现）

在这里插入图片描述

定义一组Pod访问策略（负载均衡）

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jotWv8lu-1629792080039)(C:\Users\79845\AppData\Roaming\Typora\typora-user-images\image-20210823110355118.png)]$

2、Pod和service关系

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gei7vMw8-1629792080040)(C:\Users\79845\AppData\Roaming\Typora\typora-user-images\image-20210823111432854.png)]$

通过service实现Pod的负载均衡

3、service常见类型

ClusterIP
- 集群内部使用
NodePort
- 对外访问使用
LoadBalancer
- 对外访问使用，公有云

配置管理

Secret

作用
- 加密数据存在etcd里面，让Pod容器以挂载Volume方式进行访问
场景
- 凭证

ConfigMap

作用
- 存储不加密数据到etcd，让Pod以变量或者Volume挂载到容器中
场景
- 配置文件

集群安全机制（RBAC）

1、概述

访问k8s集群的时候，需要经过三个步骤完成具体操作
- 认证
- 授权
- 准入控制
访问过程中都需要经过apiserver
- 证书
- token
- 用户名+密码

2、RBAC鉴权

基于角色的访问控制
- 角色与主体绑定

污点：是定义在节点上的键值型属性数据，用于让节点拒绝将 Pod 调度运行于其上，除非 Pod 有接纳节点污点的容忍度容忍度 tolerations 是定义在 Pod 上的键值属性数据，用于配置可容忍的污点，且调度器将 Pod 调度至其能容忍该节点污点的节点上或没有污点的节点上

使用 PodToleratesNodeTaints 预选策略和 TaintTolerationPriority 优选函数完成该机制

helm

1、引入

之前部署应用基本过程
- 编写yaml文件
  - deployment
  - Service
  - Ingress

2、介绍

可以解决哪些问题？
- 使用helm可以把所有yaml作为一个整体管理
- 实现yaml高效复用
- 使用helm应用级别的版本管理
helm是一个包管理工具
三个重要概念
- helm：一个命令行客户端工具
- Chart：应用描述，一些列用于描述k8s资源相关文件的集合
- Release：基于Chart的部署实体，一个chart被Helm运行后将会生成对应的一个release；将在k8s中创建出真实运行的资源对象

高可用集群

kubeadm是官方社区推出的一个用于快速部署kubernetes集群的工具。

这个工具能通过两条指令完成一个kubernetes集群的部署：

# 创建一个 Master 节点
$ kubeadm init

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

1. 安装要求

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

一台或多台机器，操作系统 CentOS7.x-86_x64
硬件配置：2GB或更多RAM，2个CPU或更多CPU，硬盘30GB或更多
可以访问外网，需要拉取镜像，如果服务器不能上网，需要提前下载镜像并导入节点
禁止swap分区

2. 准备环境

角色	IP
master1	192.168.74.128
master2	192.168.74.129
node1	192.168.74.130
VIP（虚拟ip）	192.168.74.131

# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

# 关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinux/config  # 永久
setenforce 0  # 临时

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

# 根据规划设置主机名
hostnamectl set-hostname <hostname>

# 在master添加hosts
cat >> /etc/hosts << EOF
192.168.74.131    master.k8s.io   k8s-vip
192.168.74.128    master01.k8s.io master1
192.168.74.129    master02.k8s.io master2
192.168.74.130    node01.k8s.io   node1
EOF

# 将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl --system  # 生效

# 时间同步
yum install ntpdate -y
ntpdate time.windows.com

3. 所有master节点部署keepalived

3.1 安装相关包和keepalived

yum install -y conntrack-tools libseccomp libtool-ltdl

yum install -y keepalived

3.2配置master节点

master1节点配置

cat > /etc/keepalived/keepalived.conf <<EOF 
! Configuration File for keepalived

global_defs {
   router_id k8s
}

vrrp_script check_haproxy {
    script "killall -0 haproxy"
    interval 3
    weight -2
    fall 10
    rise 2
}

vrrp_instance VI_1 {
    state MASTER 
    interface ens33 
    virtual_router_id 51
    priority 250
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass ceb1b3ec013d66163d6ab
    }
    virtual_ipaddress {
        192.168.74.131
    }
    track_script {
        check_haproxy
    }

}
EOF

master2节点配置

cat > /etc/keepalived/keepalived.conf <<EOF 
! Configuration File for keepalived

global_defs {
   router_id k8s
}

vrrp_script check_haproxy {
    script "killall -0 haproxy"
    interval 3
    weight -2
    fall 10
    rise 2
}

vrrp_instance VI_1 {
    state BACKUP 
    interface ens33 
    virtual_router_id 51
    priority 200
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass ceb1b3ec013d66163d6ab
    }
    virtual_ipaddress {
        192.168.74.131
    }
    track_script {
        check_haproxy
    }

}
EOF

3.3 启动和检查

在两台master节点都执行

# 启动keepalived
$ systemctl start keepalived.service
设置开机启动
$ systemctl enable keepalived.service
# 查看启动状态
$ systemctl status keepalived.service

启动后查看master1的网卡信息

ip a s ens33

4. 部署haproxy

4.1 安装

yum install -y haproxy

4.2 配置

两台master节点的配置均相同，配置中声明了后端代理的两个master节点服务器，指定了haproxy运行的端口为16443等，因此16443端口为集群的入口

cat > /etc/haproxy/haproxy.cfg << EOF
#---------------------------------------------------------------------
# Global settings
#---------------------------------------------------------------------
global
    # to have these messages end up in /var/log/haproxy.log you will
    # need to:
    # 1) configure syslog to accept network log events.  This is done
    #    by adding the '-r' option to the SYSLOGD_OPTIONS in
    #    /etc/sysconfig/syslog
    # 2) configure local2 events to go to the /var/log/haproxy.log
    #   file. A line like the following can be added to
    #   /etc/sysconfig/syslog
    #
    #    local2.*                       /var/log/haproxy.log
    #
    log         127.0.0.1 local2
    
    chroot      /var/lib/haproxy
    pidfile     /var/run/haproxy.pid
    maxconn     4000
    user        haproxy
    group       haproxy
    daemon 
       
    # turn on stats unix socket
    stats socket /var/lib/haproxy/stats
#---------------------------------------------------------------------
# common defaults that all the 'listen' and 'backend' sections will
# use if not designated in their block
#---------------------------------------------------------------------  
defaults
    mode                    http
    log                     global
    option                  httplog
    option                  dontlognull
    option http-server-close
    option forwardfor       except 127.0.0.0/8
    option                  redispatch
    retries                 3
    timeout http-request    10s
    timeout queue           1m
    timeout connect         10s
    timeout client          1m
    timeout server          1m
    timeout http-keep-alive 10s
    timeout check           10s
    maxconn                 3000
#---------------------------------------------------------------------
# kubernetes apiserver frontend which proxys to the backends
#--------------------------------------------------------------------- 
frontend kubernetes-apiserver
    mode                 tcp
    bind                 *:16443
    option               tcplog
    default_backend      kubernetes-apiserver    
#---------------------------------------------------------------------
# round robin balancing between the various backends
#---------------------------------------------------------------------
backend kubernetes-apiserver
    mode        tcp
    balance     roundrobin
    server      master01.k8s.io   192.168.74.128:6443 check
    server      master02.k8s.io   192.168.74.129:6443 check
#---------------------------------------------------------------------
# collection haproxy statistics message
#---------------------------------------------------------------------
listen stats
    bind                 *:1080
    stats auth           admin:awesomePassword
    stats refresh        5s
    stats realm          HAProxy\ Statistics
    stats uri            /admin?stats
EOF

4.3 启动和检查

两台master都启动

# 设置开机启动
$ systemctl enable haproxy
# 开启haproxy
$ systemctl start haproxy
# 查看启动状态
$ systemctl status haproxy

检查端口

netstat -lntup|grep haproxy

5. 所有节点安装Docker/kubeadm/kubelet

Kubernetes默认CRI（容器运行时）为Docker，因此先安装Docker。

5.1 安装Docker

$ wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
$ yum -y install docker-ce-18.06.1.ce-3.el7
$ systemctl enable docker && systemctl start docker
$ docker --version
Docker version 18.06.1-ce, build e68fc7a

$ cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF

5.2 添加阿里云YUM软件源

$ cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

5.3 安装kubeadm，kubelet和kubectl

由于版本更新频繁，这里指定版本号部署：

$ yum install -y kubelet-1.16.3 kubeadm-1.16.3 kubectl-1.16.3
$ systemctl enable kubelet

6. 部署Kubernetes Master

6.1 创建kubeadm配置文件

在具有vip的master上操作，这里为master1

$ mkdir /usr/local/kubernetes/manifests -p

$ cd /usr/local/kubernetes/manifests/

$ vi kubeadm-config.yaml

apiServer:
  certSANs:
    - master1
    - master2
    - master.k8s.io
    - 192.168.74.131
    - 192.168.74.128
    - 192.168.74.129
    - 127.0.0.1
  extraArgs:
    authorization-mode: Node,RBAC
  timeoutForControlPlane: 4m0s
apiVersion: kubeadm.k8s.io/v1beta1
certificatesDir: /etc/kubernetes/pki
clusterName: kubernetes
controlPlaneEndpoint: "master.k8s.io:16443"
controllerManager: {}
dns: 
  type: CoreDNS
etcd:
  local:    
    dataDir: /var/lib/etcd
imageRepository: registry.aliyuncs.com/google_containers
kind: ClusterConfiguration
kubernetesVersion: v1.16.3
networking: 
  dnsDomain: cluster.local  
  podSubnet: 10.244.0.0/16
  serviceSubnet: 10.1.0.0/16
scheduler: {}

6.2 在master1节点执行

$ kubeadm init --config kubeadm-config.yaml

按照提示配置环境变量，使用kubectl工具：

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
$ kubectl get nodes
$ kubectl get pods -n kube-system

按照提示保存以下内容，一会要使用：

# 暂时不用，只是保存，在master2中使用
kubeadm join master.k8s.io:16443 --token becnr2.1jbd0bklsl2j6e3t \
    --discovery-token-ca-cert-hash sha256:5e216e6171eb077e3c5832ca7f0d621acc846c4fd5fb04aad0cd38485ddad170 \
    --control-plane

查看集群状态

kubectl get cs

kubectl get pods -n kube-system

7.安装集群网络

从官方地址获取到flannel的yaml，在master1上执行

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

安装flannel网络

kubectl apply -f kube-flannel.yml

检查

kubectl get pods -n kube-system

8、master2节点加入集群

8.1 复制密钥及相关文件

从master1复制密钥及相关文件到master2

# 在master1中执行
# ssh root@192.168.74.129 mkdir -p /etc/kubernetes/pki/etcd

# scp /etc/kubernetes/admin.conf root@192.168.74.129:/etc/kubernetes
   
# scp /etc/kubernetes/pki/{ca.*,sa.*,front-proxy-ca.*} root@192.168.74.129:/etc/kubernetes/pki
   
# scp /etc/kubernetes/pki/etcd/ca.* root@192.168.74.129:/etc/kubernetes/pki/etcd

8.2 master2加入集群

执行在master1上init后输出的join命令,需要带上参数--control-plane表示把master控制节点加入集群

kubeadm join master.k8s.io:16443 --token becnr2.1jbd0bklsl2j6e3t \
    --discovery-token-ca-cert-hash sha256:5e216e6171eb077e3c5832ca7f0d621acc846c4fd5fb04aad0cd38485ddad170 \
    --control-plane

检查状态

kubectl get node

kubectl get pods --all-namespaces

9. 加入Kubernetes Node

在node1上执行

向集群添加新节点，执行在kubeadm init输出的kubeadm join命令：

kubeadm join master.k8s.io:16443 --token becnr2.1jbd0bklsl2j6e3t \
    --discovery-token-ca-cert-hash sha256:5e216e6171eb077e3c5832ca7f0d621acc846c4fd5fb04aad0cd38485ddad170

集群网络重新安装，因为添加了新的node节点

kubectl delete -f kube-flannel.yml
kubectl apply -f kube-flannel.yml

检查状态

kubectl get node

kubectl get pods --all-namespaces

10. 测试kubernetes集群

在Kubernetes集群中创建一个pod，验证是否正常运行：

$ kubectl create deployment nginx --image=nginx
$ kubectl expose deployment nginx --port=80 --type=NodePort
$ kubectl get pod,svc

访问地址：http://NodeIP:Port

部署java项目

1、准备

# 准备springnboot项目
包含jar包和Dockerfile文件

# Dockerfile 文件
FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD ./target/demojenkins.jar demojenkins.jar
ENTRYPOINT ["java","-jar","/demojenkins.jar", "&"]

2、制作镜像

#进入项目执行
docker build -t java-demo-01:lates1 .

# 查看镜像
docker images

#本地启动测试
docker run -d -p 8080:8080java-demo-01:lates1 -t

3、上传镜像到镜像服务器

登录阿里云
容器镜像服务
创建命名空间
创建镜像仓库

进入镜像仓库

# 登录
$ docker login --username=xxx registry.cn-chengdu.aliyuncs.com

# 为镜像添加版本号
$ docker tag [ImageId] registry.cn-chengdu.aliyuncs.com/xxx/java-project-01:[镜像版本号]

# 推送上传
$ docker push registry.cn-chengdu.aliyuncs.com/xxx/java-project-01:[镜像版本号]

# 拉取镜像
$ docker pull registry.cn-chengdu.aliyuncs.com/xxx/java-project-01:[镜像版本号]

# 查看
$ kubectl get svc

4、部署

$ kubectl create deployment javademo01 --image=registry.cn-chengdu.aliyuncs.com/xxx/java-project-01:1.0.0 --dry-run -o yaml >javademo01.yaml

# 创建
$ kubectl apply -f javademo01.yaml 

# 查看
$ kubectl get pods

# 扩容
$ kubectl scale deployment javademo01 --replicas=3

# 对外暴露端口
$kubectl expose deployment javademo01 --port=8080 --target-port=8080 --type=NodePort

# 查看
$ kubectl get svc

# 通过端口访问

巧克力的青春

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
K8s学习

K8sService是分布式集群架构的核心，一个Service拥有以下关键特征：拥有唯一指定的名称拥有一个虚拟IP和端口号能够提供某种远程服务能力被映射到提供这种服务能力的一组容器应用上K8s 特点自动装箱基于容器对应用运行环境的资源配置要求自动部署应用容器自我修复当容器失败时，会对容器进行重启水平扩展对应用容器进行规模扩大或规模剪裁服务发现基于 Kubernetes 自身能力实现服务发现和负载均衡滚动更新对应用容器运行的应用，进行一
复制链接

扫一扫