k8s

常用k8s编排架构解释：

[!TIP]

Kuboard：Kuboard 是一款免费的 Kubernetes 管理工具，提供了丰富的功能，结合已有或新建的代码仓库、镜像仓库、CI/CD工具等，可以便捷的搭建一个生产可用的 Kubernetes 容器云平台，轻松管理和运行云原生应用。https://kuboard.cn/

KubeSphere：（推荐）支持多云与多集群管理，提供全栈的 IT 自动化运维的能力，简化企业的 DevOps 工作流。KubeSphere提供了运维友好的向导式操作界面，帮助企业快速构建一个强大和功能丰富的容器云平台。（这里使用KubeSphere搭建）https://kubesphere.io/zh/

KubeOperator：KubeOperator 是一个开源的轻量级Kubernetes发行版，专注于帮助企业规划、部署和运营生产级别的Kubernetes 集群。

Rancher：是一个开源的企业级多集群Kubernetes管理平台，实现了Kubernetes集群在混合云+本地数据中心的集中部署与管理，以确保集群的安全性，加速企业数字化转型。

Minikube：本地快速搭建一个单节点的Kubernetes集群。

k8s名词解释

Pod(容器集)：

[!TIP]

Pod 是包含一个或多个容器的容器组，是 Kubernetes 中创建和管理的最小对象。

Pod 有以下特点：

• Pod是kubernetes中最小的调度单位****（原子单元），Kubernetes直接管理Pod而不是容器。
• 同一个Pod中的容器总是会被自动安排到集群中的同一节点（物理机或虚拟机）上，并且一起调度。
• Pod可以理解为运行特定应用的“逻辑主机”，这些容器共享存储、网络和配置声明(如资源限制)。
• 每个 Pod 有唯一的 IP 地址。 IP地址分配给Pod，在同一个 Pod 内，所有容器共享一个 IP 地址和端口空间，Pod 内的容器可以使用localhost互相通信。

Namespace(命名空间)：

[!TIP]

命名空间：是一种资源隔离机制，将同一集群中的资源划分为相互隔离的组

Kubernetes 会创建四个初始命名空间： ●default 默认的命名空间，不可删除，未指定命名空间的对象都会被分配到default中。 ●kube-system Kubernetes 系统对象(控制平面和Node组件)所使用的命名空间。 ●kube-public 自动创建的公共命名空间，所有用户（包括未经过身份验证的用户）都可以读取它。通常我们约定，将整个集群中公用的可见和可读的资源放在这个空间中。 ●kube-node-lease 租约（Lease）对象使用的命名空间。每个节点都有一个关联的 lease 对象，lease 是一种轻量级资源。lease对象通过发送心跳，检测集群中的每个节点是否发生故障。 使用kubectl get lease -A查看lease对象

Deployment(部署)与ReplicaSet(副本集)

[!TIP]

Deployment是对ReplicaSet和Pod更高级的抽象。 它使Pod拥有多副本，自愈，扩缩容、滚动升级等能力。

ReplicaSet(副本集)是一个Pod的集合。 它可以设置运行Pod的数量，确保任何时间都有指定数量的 Pod 副本在运行。 通常我们不直接使用ReplicaSet，而是在Deployment中声明。

Service(服务)

[!TIP]

Service将运行在一组 Pods 上的应用程序公开为网络服务的抽象方法。 Service为一组 Pod 提供相同的 DNS 名，并且在它们之间进行负载均衡。 Kubernetes 为 Pod 提供分配了IP 地址，但IP地址可能会发生变化。 集群内的容器可以通过service名称访问服务，而不需要担心Pod的IP发生变化。 Kubernetes Service 定义了这样一种抽象： 逻辑上的一组可以互相替换的 Pod，通常称为微服务。 Service 对应的 Pod 集合通常是通过选择算符来确定的。 举个例子，在一个Service中运行了3个nginx的副本。这些副本是可互换的，我们不需要关心它们调用了哪个nginx，也不需要关注 Pod的运行状态，只需要调用这个服务就可以了。

声明式对象配置

云原生的代表技术包括：

• 容器
• 声明式API
• 不可变基础设施
• 微服务
• 服务网格

管理对象

• 命令行指令

例如，使用kubectl命令来创建和管理 Kubernetes 对象。

命令行就好比口头传达，简单、快速、高效。

但它功能有限，不适合复杂场景，操作不容易追溯，多用于开发和调试。

• 声明式配置

kubernetes使用yaml文件来描述 Kubernetes 对象。

声明式配置就好比申请表，学习难度大且配置麻烦。

好处是操作留痕，适合操作复杂的对象，多用于生产。

1. 常用命令缩写

#使用缩写
kubectl create deploy my-deploy --image=nginx:1.22 --replicas=3
kubectl get po 

2.YAML规范

缩进代表上下级关系

缩进时不允许使用Tab键，只允许使用空格，通常缩进2个空格

**:** 键值对，后面必须有空格

**-**列表，后面必须有空格

**[ ]**数组

**#**注释

**|** 多行文本块

---

表示文档的开始，多用于分割多个资源对象

group: 
  name: group-1
  members: 
    - name: "Jack Ma"
      UID: 10001
    - name: "Lei Jun"
      UID: 10002
  words: 
    ["I don't care money","R U OK"]
  # comments
  text: |
    line
    new line
    3rd line

可以使用vscode安装yaml插件 使用ssh连接虚拟机 将yaml文件标准化

3.配置对象

在创建的 Kubernetes 对象所对应的 yaml文件中，需要配置的字段如下： ●apiVersion - Kubernetes API 的版本 ●kind - 对象类别，例如Pod、Deployment、Service、ReplicaSet等 ●metadata - 描述对象的元数据，包括一个 name 字符串、UID 和可选的 namespace ●spec - 对象的配置

使用yaml定义一个Pod

Pod配置模版

apiVersion: v1
kind: Pod
metadata:
  name: my-nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.22
    ports:
    - containerPort: 80

使用yaml文件管理对象

#创建对象
kubectl apply -f my-pod.yaml
#编辑对象
kubectl edit nginx
#删除对象
kubectl delete -f my-pod.yaml

3.标签

标签（Labels） 是附加到对象（比如 Pod）上的键值对，用于补充对象的描述信息。

标签使用户能够以松散的方式管理对象映射，而无需客户端存储这些映射。

由于一个集群中可能管理成千上万个容器，我们可以使用标签高效的进行选择和操作容器集合。

键的格式：

• 前缀(可选)/名称(必须)。

效名称和值：

• 必须为 63 个字符或更少（可以为空）
• 如果不为空，必须以字母数字字符（[a-z0-9A-Z]）开头和结尾
• 包含破折号**-**、下划线**_**、点**.**和字母或数字

apiVersion: v1
kind: Pod
metadata:
  name: label-demo
  labels: #定义Pod标签
    environment: test
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.22
    ports:
    - containerPort: 80

4.选择器

标签选择器 可以识别一组对象。标签不支持唯一性。

标签选择器最常见的用法是为Service选择一组Pod作为后端。

Service配置模版

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  type: NodePort
  selector: #与Pod的标签一致
    environment: test
    app: nginx
  ports:
      # 默认情况下，为了方便起见，`targetPort` 被设置为与 `port` 字段相同的值。
    - port: 80
      targetPort: 80
      # 可选字段
      # 默认情况下，为了方便起见，Kubernetes 控制平面会从某个范围内分配一个端口号（默认：30000-32767）
      nodePort: 30007

目前支持两种类型的选择运算：基于等值的和基于集合的。

多个选择条件使用逗号分隔，相当于**And(&&)**运算。

等值选择

selector:
  matchLabels: # component=redis && version=7.0
    component: redis
    version: 7.0

基于集合

selector:
  matchExpressions: # tier in (cache, backend) && environment not in (dev, prod)
    - {key: tier, operator: In, values: [cache, backend]}
    - {key: environment, operator: NotIn, values: [dev, prod]}

VM虚拟机安装注意事项

vm虚拟机安装

vm的安装直接一路next完成既可，然后破解密钥，网上一堆，随便找一个就可用

安装centOS

1、安装centOS，先新建虚拟机，然后选择自定义安装，选择Linux的系统类型，

设置虚拟机名称：k8s-master 设置安装路径，设置cpu 2c4 8核

然后设置内存18G:18432m , 然后设置nat网络模式，设置硬盘200G

2、点击编辑虚拟机配置，选中镜像

3、启动虚拟机，进行初始化系统，选择时区上海，磁盘直接让他默认分区，然后安装，安装时，填写root的密码，完成安装，重启虚拟机

4、虚拟机时间问题：

方式一：（好使）

在vmware选择对应虚拟机右键 点击设置后，选择选项 VM tools 勾选时间同步 在虚拟中输入如下命令：# sudo cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime 重启虚拟机：# reboot 开机验证: # date

方式二：

同步北京时间 1）首先查看是不是东八区 date -R

2）删除自带的localtime rm -rf -- /etc/localtime

3）创建软链接到localtime ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

4）安装ntpdate yum install -y ntpdate

5）同步北京时间 ntpdate -u ntp.api.bz

​ ntpdate ntp1.aliyun.com

5、如果要创建多节点怎么办呢，安装完成一个虚拟机后，剩下的节点可以使用完整克隆直接完成。

虚拟机网络

如果xshell连接不上虚拟机，是需要开启防火墙里，应用规则里，开放打印机的ip4和ip6的4条规则

以及外部需要访问虚拟机内部的资源，也是需要开启防火墙

如果局域网远程桌面连接也连接不上也是需要增加远程连接的应用到白名单里

注意：防火墙不要改变状态或者重启，会导致以上配置的内容失效，重置（暂时不知道原因，我觉得直接整体关闭得了）

xshell连接vm虚拟机

1、选择nat模式：查看虚拟网卡的网段属于哪个网段，以及点聚nat设置里查看该网关是多少

2、将 虚拟网卡 高级网络设置里vm8，ipv4设置个该网段的固定ip，不要与虚拟机设置的重复，255.255.255.0

3、参考下面k8s安装第一步，将三台虚拟机设置固定的静态ip，重启网卡，ip与虚拟网卡需要处于同一网段

其他局域网电脑连接该电脑的虚拟机

k8s部署

安装步骤

准备VM虚拟机，三台linux环境，内存4G以上，cup4核以上

注意：需要先将虚拟机的ip固定，否则，虚拟网络坏境变更后虚拟机的ip一旦变更，整个k8s环境都得重装，也有不重装的方式，但是该方式需要调整各个证书，迁移各个镜像

# 安装完成centOS，如何让xshell连接到虚拟机，需要设置下面的静态ip
cd /etc/sysconfig/network-scripts/
# 编辑该文件
vi ifcfg-ens33
# 修改：
BOOTPROTO=static
IPV4_FAILURE_FATAL=yes
ONBOOT=yes
IPADDR=192.168.146.11
NETMASK=255.255.255.0
GATEWAY=192.168.146.2
DNS1=8.8.8.8
DNS2=114.114.114.114

# 列如：以下是一个修改后的文件样板
TYPE="Ethernet"
PROXY_METHOD="none"
BROWSER_ONLY="no"
BOOTPROTO="static"
DEFROUTE="yes"
IPV4_FAILURE_FATAL="no"
IPV6INIT="yes"
IPV6_AUTOCONF="yes"
IPV6_DEFROUTE="yes"
IPV6_FAILURE_FATAL="no"
IPV6_ADDR_GEN_MODE="stable-privacy"
NAME="ens33"
UUID="bd95d1ef-f738-496a-bce9-c4646678a38d"
DEVICE="ens33"
ONBOOT="yes"
IPADDR="192.168.182.129"# 设置一个和虚拟网卡在同一子网的IP
NETMASK="255.255.255.0"
GATEWAY="192.168.182.2"
DNS1="8.8.8.8"
DNS1="114.114.114.114.8.8"


# 修改后重启网络服务
service network restart

# 可以 ip addr 或者  ifconfig查看

1、安装前准备

# 校准时间
date

# 设置主机名 这一步可以省略 kubeSphere安装时会自动安装hosts
hostnamectl set-hostname k8s-master
hostnamectl set-hostname k8s-node1
hostnamectl set-hostname k8s-node2

# 调整host
cat /etc/hosts
自己的IP k8s-master
自己的IP k8s-node1
自己的IP k8s-node2
# 列如：
192.168.182.128 k8s-master
192.168.182.129 k8s-node-1
192.168.182.130 k8s-node-2

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

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

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


# 让设置生效
sysctl --system

# 换yum源
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
# 重启
reboot
# 安装环境依赖
yum install -y socat conntrack ebtables ipset vim net-tools wget

2、正式安装

24年安装方式：

#设置下载区域
export KKZONE=cn
#下载 KubeKey 最新版本
curl -sfL https://get-kk.kubesphere.io | sh -
#为 KubeKey 二进制文件 kk 添加执行权限
sudo chmod +x kk
#执行以下命令创建安装配置文件 config-sample.yaml：
./kk create config --with-kubernetes 1.28.12
#安装完成后，请勿删除安装配置文件 config-sample.yaml，后续进行节点添加等操作时仍需要使用该文件。如果该文件丢失，您需要重新创建安装配置文件
# 配置文件containerManager: containerd可以指定容器运行时是docker还是containerd
# 编辑配置文件 registry离线安装的时候可以指定安装私有仓库harbor
vi config-sample.yaml
# 执行创建k8s集群
./kk create cluster -f config-sample.yaml
./kk create cluster -f config-sample.yaml –with-local-storage可以创建本地存储（未使用过）
#如果显示如下信息，则表明 Kubernetes 集群创建成功
Pipeline[CreateclusterPipeline] execute successfully
# 这个时候检查k8s状态是否正常
kubectl get nodes
# 这里我安装了两次都遇到了 node节点（这个后来看了，node节点本身不需要有执行指令的功能，如果需要，建议安装三主三从方式，下面的方式是属于多此一举）
couldn't get current server API group list: Get "http://localhost:8080/api?timeout=32s": dial tcp [::1]:8080: connect: connection refused
# 这个问题的处理方式是 集群除了master以外的所有机器都执行以下命令
echo "export KUBECONFIG=/etc/kubernetes/kubelet.conf" >> /etc/profile
source /etc/profile
sudo chmod 777 /etc/kubernetes/kubelet.conf
sudo chmod 777 /var/lib/kubelet/pki/kubelet-client-current.pem

##安装kubeSphere
#需要提前安装 Helm （默认上面安装后存在）
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
#执行以下命令安装 KubeSphere Core（网络不好会有问题，建议换比较好的网络安装）
helm upgrade --install -n kubesphere-system --create-namespace ks-core https://charts.kubesphere.io/main/ks-core-1.1.3.tgz --debug --wait --set global.imageRegistry=swr.cn-southwest-2.myhuaweicloud.com/ks --set extension.imageRegistry=swr.cn-southwest-2.myhuaweicloud.com/ks

# 这一步有可能遇到一个问题 kubectl get deployment会异常（没遇到无需处理）
helm执行提示：helm.go:84: [debug] secrets is forbidden: User "system:node:k8s-master" cannot list resource "secrets" in API group "" in the namespace "kube-system": No Object name found
# 这个问题是说该用户无权限查看deployment，使用kubectl get deployment一试便知，处理方式
export KUBECONFIG=/root/.kube/config
chmod g-r /root/.kube/config
#如果显示如下信息，则表明 ks-core 安装成功
3. Login to KubeSphere Console

    Use the following credentials to log in:

    Account: admin
    Password: P@88w0rd
# 如果需要局域网访问该虚拟机的kubeSphere，需要防火墙开放，增加规则，入站规则，增加端口30880保存后生效

devops插件安装时，资源不足要调整yaml配置文件，调整安装资源参数

23年实验方式：

# 确保您从正确的区域下载 KubeKey，即在国内下载速度更快
export KKZONE=cn
# 下载kubekey
curl -sfL https://get-kk.kubesphere.io | sh 
# 可以查看下支持的k8s版本
./kk version --show-supported-k8s
# 使用KubeKey生成一个k8s集群启动模板k8s.yaml，编辑好账号密码后保存
./kk create config --with-kubernetes v1.24.3 --with-kubesphere v3.3.1 -f k8s.init.yaml
# 普通节点配置文件不需要kubesphere
./kk create config --with-kubernetes v1.24.3 -f k8s.init.yaml

# 注意：主节点安装周期会很长，如果网络不行的情况下，会长达一个多小时到，只要脚本没有中途退出，那就是正常的安装中

# 模板内容如下 start
apiVersion: kubekey.kubesphere.io/v1alpha2
kind: Cluster
metadata:
  name: sample
spec:
  hosts:
  - {name: k8s-master, address: 192.168.182.128, internalAddress: 192.168.182.128, user: root, password: "root123456"}
  - {name: k8s-node-1, address: 192.168.182.129, internalAddress: 192.168.182.129, user: root, password: "root123456"}
  - {name: k8s-node-2, address: 192.168.182.130, internalAddress: 192.168.182.130, user: root, password: "root123456"}
  roleGroups:
    etcd:
    - k8s-master
    control-plane: 
    - k8s-master
    worker:
    - k8s-node-1
    - k8s-node-2
  controlPlaneEndpoint:
    ## Internal loadbalancer for apiservers 
    # internalLoadbalancer: haproxy

    domain: lb.kubesphere.local
    address: ""
    port: 6443
  kubernetes:
    version: v1.24.3
    clusterName: cluster.local
    autoRenewCerts: true
    containerManager: containerd
  etcd:
    type: kubekey
  network:
    plugin: calico
    kubePodsCIDR: 10.233.64.0/18
    kubeServiceCIDR: 10.233.0.0/18
    ## multus support. https://github.com/k8snetworkplumbingwg/multus-cni
    multusCNI:
      enabled: false
  registry:
    privateRegistry: ""
    namespaceOverride: ""
    registryMirrors: []
    insecureRegistries: []
  addons: []



---
apiVersion: installer.kubesphere.io/v1alpha1
kind: ClusterConfiguration
metadata:
  name: ks-installer
  namespace: kubesphere-system
  labels:
    version: v3.3.1
spec:
  persistence:
    storageClass: ""
  authentication:
    jwtSecret: ""
  zone: ""
  local_registry: ""
  namespace_override: ""
  # dev_tag: ""
  etcd:
    monitoring: false
    endpointIps: localhost
    port: 2379
    tlsEnable: true
  common:
    core:
      console:
        enableMultiLogin: true
        port: 30880
        type: NodePort
    # apiserver:
    #  resources: {}
    # controllerManager:
    #  resources: {}
    redis:
      enabled: false
      volumeSize: 2Gi
    openldap:
      enabled: false
      volumeSize: 2Gi
    minio:
      volumeSize: 20Gi
    monitoring:
      # type: external
      endpoint: http://prometheus-operated.kubesphere-monitoring-system.svc:9090
      GPUMonitoring:
        enabled: false
    gpu:
      kinds:
      - resourceName: "nvidia.com/gpu"
        resourceType: "GPU"
        default: true
    es:
      # master:
      #   volumeSize: 4Gi
      #   replicas: 1
      #   resources: {}
      # data:
      #   volumeSize: 20Gi
      #   replicas: 1
      #   resources: {}
      logMaxAge: 7
      elkPrefix: logstash
      basicAuth:
        enabled: false
        username: ""
        password: ""
      externalElasticsearchHost: ""
      externalElasticsearchPort: ""
  alerting:
    enabled: false
    # thanosruler:
    #   replicas: 1
    #   resources: {}
  auditing:
    enabled: false
    # operator:
    #   resources: {}
    # webhook:
    #   resources: {}
  devops:
    enabled: true
    # resources: {}
    jenkinsMemoryLim: 2Gi
    jenkinsMemoryReq: 1500Mi
    jenkinsVolumeSize: 8Gi
    jenkinsJavaOpts_Xms: 512m
    jenkinsJavaOpts_Xmx: 512m
    jenkinsJavaOpts_MaxRAM: 2g
  events:
    enabled: false
    # operator:
    #   resources: {}
    # exporter:
    #   resources: {}
    # ruler:
    #   enabled: true
    #   replicas: 2
    #   resources: {}
  logging:
    enabled: false
    logsidecar:
      enabled: true
      replicas: 2
      # resources: {}
  metrics_server:
    enabled: false
  monitoring:
    storageClass: ""
    node_exporter:
      port: 9100
      # resources: {}
    # kube_rbac_proxy:
    #   resources: {}
    # kube_state_metrics:
    #   resources: {}
    # prometheus:
    #   replicas: 1
    #   volumeSize: 20Gi
    #   resources: {}
    #   operator:
    #     resources: {}
    # alertmanager:
    #   replicas: 1
    #   resources: {}
    # notification_manager:
    #   resources: {}
    #   operator:
    #     resources: {}
    #   proxy:
    #     resources: {}
    gpu:
      nvidia_dcgm_exporter:
        enabled: false
        # resources: {}
  multicluster:
    clusterRole: none
  network:
    networkpolicy:
      enabled: false
    ippool:
      type: none
    topology:
      type: none
  openpitrix:
    store:
      enabled: false
  servicemesh:
    enabled: false
    istio:
      components:
        ingressGateways:
        - name: istio-ingressgateway
          enabled: false
        cni:
          enabled: false
  edgeruntime:
    enabled: false
    kubeedge:
      enabled: false
      cloudCore:
        cloudHub:
          advertiseAddress:
            - ""
        service:
          cloudhubNodePort: "30000"
          cloudhubQuicNodePort: "30001"
          cloudhubHttpsNodePort: "30002"
          cloudstreamNodePort: "30003"
          tunnelNodePort: "30004"
        # resources: {}
        # hostNetWork: false
      iptables-manager:
        enabled: true
        mode: "external"
        # resources: {}
      # edgeService:
      #   resources: {}
  terminal:
    timeout: 600

# 模板内容如下 end


# 根据配置文件生成k8s
./kk create cluster -f k8s.init.yaml

# 查看所有pod
kubectl get pods -A
#获取全部节点
kubectl get nodes

如果，遇到其他节点使用命令，报curl localhost异常的，需要重新载入配置文件，csdn有解决方案。

kubectl 常用命令

#查看所有pod,服务
kubectl get pods,svc -A

# 查看各个节点资源情况
kubectl describe nodes

# 进入容器
kubectl exec -it <pod-name> -n <name-space> bash

# 查看某个节点资源使用情况
kubectl describe node
 
#获取所有的pod
kubectl get pods --all-namespaces -o wide
 
#使用yaml文件创建pod
kubectl create -f YAML_FILE.yaml
 
#使用yaml文件删除pod
kubectl delete -f YAML_FILE.yaml
 
#显示指定命名空间的pod的日志
kubectl logs POD_NAME -n kube-system

# 从 pod <pod-name> 开始显示流式传输日志
kubectl logs -f <pod-name>
 
#获取集群状态
kubectl get cs
 
#获取指定命名空间的服务
kubectl get svc -n kube-system
 
#获取集群信息
kubectl cluster-info
 
#获取集群节点信息
kubectl get nodes

#查看deployment
kubectl get deploy

#删除节点
kubectl delete node 192.168.2.152
 
#删除节点中的node
#1： 在master节点上执行
kubectl drain NODE_NAME --delete-local-data --force --ignore-daemonsets
kubectl delete node node2
 
#2： 在node节点上执行
kubeadm reset
ifconfig cni0 down
ip link delete cni0
ifconfig flannel.1 down
ip link delete flannel.1
rm -rf /var/lib/cni/

# 添加新节点
yum install -y socat conntrack ebtables ipset vim
# 然后再回到主节点，修改第3步的 k8s.init.yml 文件，增加node节点，再执行
./kk add nodes -f  k8s.init.yaml

# 启动一个 Nginx 实例。
kubectl run nginx --image=nginx
# 示例，运行一个名称为nginx，副本数为3，标签为app=example，镜像为nginx:1.10，端口为80的容器实例
kubectl run nginx --replicas=3 --labels="app=example" --image=nginx:1.10 --port=80
# 示例，运行一个名称为nginx，副本数为3，标签为app=example，镜像为nginx:1.10，端口为80的容器实例，并绑定到k8s-node1上
kubectl run nginx --image=nginx:1.10 --replicas=3 --labels="app=example" --port=80 --overrides='{"apiVersion":"apps/v1","spec":{"template":{"spec":{"nodeSelector":{"kubernetes.io/hostname":"k8s-node1"}}}}}'
# 将deployment中的nginx容器镜像设置为“nginx：1.9.1”
kubectl set image deployment/nginx busybox=busybox nginx=nginx:1.9.1

安装 kubeSphere

如果是普通安装

# 快速安装
./kk create cluster --with-kubesphere v3.3.1 --container-manager containerd

如果是高级安装，比如，需要部署devops流水线功能实现CICD

# 生成
./kk create config --with-kubesphere v3.3.1 -f kubesphere.init.yaml

# kubesphere.init.yaml搜索 devops，并将 enabled 的 false 改为 true
devops:
enabled: true 

# 安装 kubesphere ( 理论可行 这个测试失败了 建议这种模式的话 连k8s一起安装或许会成功）
./kk create cluster -f kubesphere.init.yaml
# 或者 更新kubesphere配置，下面这条命令是用来更新配置的，注意yaml文件不能包含k8s的模板，只能是kubesphere组件模板，否则会失败
kubectl apply -f cluster-configuration.yaml # 失败了不好使，暂时不清楚原因

# 安装完成后验证 devops 是否安装成功
kubectl get pod -n kubesphere-devops-system
# 正常输出结果如下：
NAME                          READY   STATUS    RESTARTS   AGE
devops-jenkins-5cbbfbb975-hjnll   1/1     Running   0          40m
s2ioperator-0                 1/1     Running   0          41m

# 第二种方式 可以在kubesphere安装后启用插拔式组件（尝试多次，系统硬件不达标会失败）
# 1、以 admin 用户登录控制台，点击左上角的平台管理，选择集群管理
# 2、点击定制资源定义，在搜索栏中输入 clusterconfiguration，点击搜索结果查看其详细页面
# 3、在自定义资源中，点击 ks-installer 右侧的 ，选择编辑 YAML
# 4、在该 YAML 文件中，搜索 devops，将 enabled 的 false 改为 true。完成后，点击右下角的确定，保存配置
#   可以调整下参数，避免容器建立失败
	devops:
enabled: false
jenkinsJavaOpts_MaxRAM: 2g
jenkinsJavaOpts_Xms: 1200m
jenkinsJavaOpts_Xmx: 1600m
jenkinsMemoryLim: 2Gi
jenkinsMemoryReq: 1500Mi
jenkinsVolumeSize: 8Gi
kubectl describe查看pod的详细事件信息
# 5、在 kubectl 中执行以下命令检查安装过程
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l 'app in (ks-install, ks-installer)' -o jsonpath='{.items[0].metadata.name}') -f

安装完成后出现如下

#####################################################
###              Welcome to KubeSphere!           ###
#####################################################
Console: http://192.168.182.128:30880
Account: admin
Password: P@88w0rd
NOTES：
  1. After you log into the console, please check the
     monitoring status of service components in
     the "Cluster Management". If any service is not
     ready, please wait patiently until all components
     are up and running.
  2. Please change the default password after login.
#####################################################
https://kubesphere.io             20xx-xx-xx xx:xx:xx
#####################################################

注意事项

如果是采用是docker做容器的话，若拉取镜像失败，可以改一下对应节点上的镜像改为国内源

# 编辑或新建配置文件 /etc/docker/daemon.json
{
 "registry-mirrors": ["https://registry.docker-cn.com","http://hub-mirror.c.163.com"],
 "live-restore": true
}
# 重新启动docker服务
systemctl restart docker

卸载 KubeSphere 和 Kubernetes（没试过，自行尝试）

# 如果是按照快速入门 (All-in-One) 安装的 KubeSphere：
./kk delete cluster
# 如果是使用高级模式安装的 KubeSphere（使用配置文件创建）：
./kk delete cluster [-f config-sample.yaml]

修改Containerd镜像源(加速)

# 1
[plugins.cri.registry.mirrors]
  [plugins.cri.registry.mirrors."docker.io"]
    endpoint = ["https://vcw3fe1o.mirror.aliyuncs.com"] #镜像加速地址
# 2 本人的实践
[plugins."io.containerd.grpc.v1.cri".registry.mirrors]
        [plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"]
          endpoint = ["https://registry.aliyuncs.com"]
# 重启Containerd
systemctl restart containerd
crictl images list # 列出镜像
crictl ps # 查看运行中的容器

解决服务器节点磁盘问题

#驱逐节点并迁移容器到可用节点
kubectl drain nodename  --ignore-daemonsets
#停止调度
kubectl  cordon nodename  
#允许调度
# kubectl uncordon nodename
#删除节点
kubectl delete node nodename
#创建加入节点token
kubeadm token  create --print-join-co

安装镜像与导入镜像

######### docker容器时###########
# 使用Dockerfile制作docker镜像
docker build -t 38-springboot-k8s-1.0.0-jar
# Dockerfile内容举例
```
FROM xiaotiejiang_jdk1.8.0_341
MAINTAINER xiaotiejiang
ADD 38-springboot-k8s-1.0.0.jar /opt
RUN chmod +x /opt/38-springboot-k8s-1.0.0.jar
CMD java -jar /opt/38-springboot-k8s-1.0.0.jar
```
# 生成部署的资源清单文件
kubectl create deployment springboot-k8s --image=38-springboot-k8s-1.0.0-jar --dry-run -o yaml > boot-deploy.yaml
# 导出镜像
docker save 38-springboot-k8s-1.0.0-jar:latest > 38-springboot-k8s-1.0.0-jar.tar
# 导入镜像
docker load -i 38-springboot-k8s-1.0.0-jar.tar
# 部署镜像
kubectl apply -f boot-deploy.yaml
# 通过仓库上传拉取镜像
docker login --username=用户名 registry.cn-hangzhou.aliyuncs.com
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/sanchar/kubectl:v1.20.1
docker push registry.cn-hangzhou.aliyuncs.com/sanchar/kubectl:v1.20.1
# 从Registry中拉取镜像
docker pull registry.cn-hangzhou.aliyuncs.com/sanchar/kubectl:v1.20.1

########### Containerd 时 ########
#拉取镜像
crictl pull mysql:5.7-debian
#查看镜像
crictl images
#导出镜像
ctr -n k8s.io images export mysql.tar docker.io/library/mysql:5.7-debian --platform linux/amd64
#导入tar镜像
ctr -n k8s.io images import mysql.tar
# 导入tar kubernetes 使用的镜像都在k8s.io命名空间中-n指定命名空间 --platform指定平台
ctr -n k8s.io images import alpine.tar --platform linux/amd64

k8s常见问题排查

kubeSphere安装devops提示资源不足

kubectl describe pod pod名称 -n 命名空间名称
# 执行后，可以查看pod安装时候的事件信息
# Event中：FailedScheduling（调度失败）并且message中包含Insufficient cpu字样，这表明没有足够的 CPU 资源来调度该容器。类似地，看到FailedScheduling消息中包含Insufficient memory字样，就表示内存资源不足。pod has unbound immediate PersistentVolumeClaims表示存储的pvc没有绑定的pv
# 使用kubectl get pod devops-jenkins-c74cf4fc6-62jj5 -n kubesphere-devops-system -o yaml命令获取容器的详细配置信息（以 YAML 格式呈现）
spec:
  containers:
  - name: devops - jenkins
    resources:
      requests:
        cpu: "0.5"
        memory: "2Gi"
      limits:
        cpu: "1"
        memory: "4Gi"
这里requests表示容器运行所需的最小资源量，limits表示容器可使用的最大资源量。记录下这些资源请求和限制的值，特别是 CPU（如0.5）和内存（如2Gi）的请求值。
kubectl top nodes 可以查看资源信息
# 查看是否k8s有pv
kubectl get pv
# 查看安装时pvc的状态
kubectl get pvc -n kubesphere-devops-system
# 如果是pading说明有问题
# 如何创建一个pv（本地存储）
# 首先需要创建一个storageclass-local.yaml（静态pv不需要创建了。devops的问题这里不需要创建）
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer
# apply
kubectl apply -f storageclass-local.yaml
# 新建一个本地10g的pv以下是配置文件pv-local.yaml
# /mnt/data1文件夹也就是下面指定的存储文件夹，需要手动创建以下
apiVersion: v1
kind: PersistentVolume
metadata:
  name: local-pv-1
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: ""
  local:
    path: /mnt/data1
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - k8s-master
# apply          
kubectl apply -f pv-local.yaml
# kubectl get pv 可以查看创建的pv信息
# 第二次安装时，查看pvc的详细信息
kubectl describe pvc devops-jenkins -n kubesphere-devops-system
# 查看正在运行pod的yaml文件
kubectl get pod my-pod -n my-namespace -o yaml


# pv使用第二次时依旧提示有问题，删除pv的命令是
kubectl delete pv local-pv-1
# kubeSphere安装时，还可以kk create cluster xxxxx –with-local-storage安装存储

# 如果kubeSphere 安装devops因为异常情况卡住了可以执行以下命令恢复状态
kubectl patch installplan devops --type=merge -p '{"status":null}'
# 查看所有的插件
kubectl get installplan
kubectl patch installplan whizard-monitoring --type=merge -p '{"status":"true"}'

kubeSphere服务异常：

查看pod的日志:

kubectl logs ks-controller-manager-cd7c86879-sgbhl -n kubesphere-system

最重要的：如果重新执行安装k8s其他组件要切换源

export KKZONE=cn

要不然k8s大多数pod会拉取不到镜像而导致失败

通过删除并重新创建Pod

kubectl delete pod <pod-name>

也可以重启deployment实现滚动重启

kubectl rollout restart deployment <deployment-name> -n <namespace>

kubectl describe pod <pod-name> -n <namespace>命令查看Pod的详细描述

k8s部署Harbor的镜像

1、准备工作

确保 Kubernetes 集群已安装并配置好。 确保 kubectl 命令行工具已安装并配置好。 确保 Harbor 已部署并可以访问。 确保你有权限访问 Harbor 仓库。

已经在 Harbor 中推送镜像，如果是更新容器版本，镜像的tag每次的版本需要不一样

2、配置 Docker Registry Secret

#在 Kubernetes 中配置 Docker Registry Secret 以便 Kubernetes 能够从 Harbor 拉取镜像。
#创建 Secret：
    kubectl create secret docker-registry harbor-secret \
      --docker-server=https://your-harbor-domain.com \
      --docker-username=your-harbor-username \
      --docker-password=your-harbor-password \
      --docker-email=your-email@example.com \
      --namespace=your-namespace
#列如
    kubectl create secret docker-registry harbor-secret \
      --docker-server=https://harbor.example.com \
      --docker-username=admin \
      --docker-password=Harbor12345 \
      --docker-email=admin@example.com \
      --namespace=default
    

4、创建命名空间

#如果你还没有命名空间，可以创建一个新的命名空间。
#创建命名空间：
kubectl create namespace your-namespace
#列如：
kubectl create namespace mdm-apps

5、编写 Deployment YAML 文件

#创建一个 Deployment YAML 文件来定义你的应用部署。
#创建 deployment.yaml 文件：

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: mdm-data-processor
      namespace: your-namespace
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: mdm-data-processor
      template:
        metadata:
          labels:
            app: mdm-data-processor
        spec:
          containers:
          - name: mdm-data-processor
            image: your-harbor-domain.com/project-name/your-image:tag
            ports:
            - containerPort: 9999
            env:
            - name: SPRING_PROFILES_ACTIVE
              value: "test"
          imagePullSecrets:
          - name: harbor-secret

示例：

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: mdm-data-processor
      namespace: mdm-apps
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: mdm-data-processor
      template:
        metadata:
          labels:
            app: mdm-data-processor
        spec:
          containers:
          - name: mdm-data-processor
            image: harbor.example.com/library/mdm-data-processor:latest
            ports:
            - containerPort: 9999
            env:
            - name: SPRING_PROFILES_ACTIVE
              value: "test"
          imagePullSecrets:
          - name: harbor-secret

使用过实际项目的一个yml示例：

---
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations: {}
  labels:
    app: mdm-app
    type: backend
  name: mdm-app
  namespace: seeyon-dev
  resourceVersion: '22168956'
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: mdm-app
      type: backend
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: mdm-app
        type: backend
    spec:
      containers:
        - name: mdm-app
          image: '10.242.56.29/seeyon-dev/mdm-app:arm-latest'
          imagePullPolicy: IfNotPresent
          lifecycle:
            preStop:
              httpGet:
                path: /deregisterInstance
                port: appport
                scheme: HTTP
          livenessProbe:
            failureThreshold: 30
            initialDelaySeconds: 600
            periodSeconds: 10
            successThreshold: 1
            tcpSocket:
              port: 9999
            timeoutSeconds: 1
          ports:
            - containerPort: 9999
              hostPort: 9999 #service时候不用分配，service可以做到自动负载，否则，该容器分布的集群node节点是随机的
              protocol: TCP
          readinessProbe:
            failureThreshold: 30
            httpGet:
              path: /mdm/check
              port: 9999
              scheme: HTTP
            initialDelaySeconds: 10
            periodSeconds: 10
            successThreshold: 1
            timeoutSeconds: 1
          resources:
            limits:
              cpu: '2'
              memory: 5Gi
            requests:
              cpu: 500m
              memory: 3Gi
          terminationMessagePath: /dev/termination-log
          terminationMessagePolicy: File
          volumeMounts:
            - mountPath: /app/logs
              name: log
      dnsPolicy: Default
      imagePullSecrets:
        - name: harbor
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
      tolerations:
        - effect: NoSchedule
          key: group
          operator: Equal
          value: bip
      volumes:
        - name: log
          nfs:
            path: /data/logs
            server: 10.242.56.32

6、编写 Service YAML 文件

创建一个 Service YAML 文件来暴露你的应用。 创建 service.yaml 文件

    apiVersion: v1
    kind: Service
    metadata:
      name: mdm-data-processor-service # 命名成一样，可以在看板上一起展示
      namespace: your-namespace
    spec:
      type: NodePort
      selector:
        app: mdm-data-processor #selector 匹配具有标签 app=my-app 的 Pod
      ports:
      - protocol: TCP 
        port: 9999 #虚拟端口
        targetPort: 9999 #是 Pod 上的端口（与 Deployment 中定义的 containerPort 对应）
        nodePort: 30001 #是集群节点上的端口（范围通常是 30000-32767）
    

示例：

    apiVersion: v1
    kind: Service
    metadata:
      name: mdm-data-processor-service
      namespace: mdm-apps
    spec:
      type: NodePort
      selector:
        app: mdm-data-processor
      ports:
      - protocol: TCP
        port: 9999
        targetPort: 9999
        nodePort: 30001

7、应用 Deployment 和 Service 配置

# 应用 Deployment 配置：    
kubectl apply -f deployment.yaml
# 应用 Service 配置
kubectl apply -f service.yaml

8、验证部署

# 检查 Pod 状态
kubectl get pods -n your-namespace
# 例如
kubectl get pods -n mdm-apps
# 检查 Service 状态
kubectl get svc -n your-namespace
# 例如
kubectl get svc -n mdm-apps

访问应用： 如果使用 NodePort，可以通过节点 IP 和 NodePort 访问应用，例如 http://node-ip:30001。 如果使用 LoadBalancer，可以通过 LoadBalancer 的外部 IP 访问应用，例如 http://load-balancer-ip:9999。

9、监控和日志

监控： 使用 Kubernetes 的监控工具（如 Prometheus、Grafana）来监控 Pod 的资源使用情况。 日志： 查看 Pod 日志以进行故障排除：

kubectl logs <pod-name> -n your-namespace
# 示例
kubectl logs mdm-data-processor-<pod-hash> -n mdm-apps

k8s如何更新Harbor的镜像

Harbor 刚推送上去的新镜像tag需要与之前的tag不一样，用来更新

前置条件，推送新镜像到Harbor

1、更新 Deployment YAML 文件

编辑 deployment.yaml 文件： 将 image 字段中的标签更新为新的标签。 例如，将：

image: your-harbor-domain.com/project-name/your-image:old-tag
# 更新为：
image: your-harbor-domain.com/project-name/your-image:new-tag

完整的 deployment.yaml 文件示例：

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: mdm-data-processor
      namespace: your-namespace
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: mdm-data-processor
      template:
        metadata:
          labels:
            app: mdm-data-processor
        spec:
          containers:
          - name: mdm-data-processor
            image: your-harbor-domain.com/project-name/your-image:new-tag
            ports:
            - containerPort: 9999
            env:
            - name: SPRING_PROFILES_ACTIVE
              value: "test"
          imagePullSecrets:
          - name: harbor-secret

2、应用更新后的 Deployment 配值

kubectl apply -f deployment.yaml
# 验证更新,检查 Pod 状态
kubectl get pods -n mdm-apps
# 检查 Deployment 状态
kubectl rollout status deployment/mdm-data-processor -n your-namespac

3、访问应用：

如果使用 NodePort，可以通过节点 IP 和 NodePort 访问应用，例如 http://node-ip:30001。 如果使用 LoadBalancer，可以通过 LoadBalancer 的外部 IP 访问应用，例如 http://load-balancer-ip:9999。

4、回滚更新（如有必要）

如果更新后发现有问题，可以回滚到之前的版本。 回滚到上一个版本：

kubectl rollout undo deployment/mdm-data-processor -n your-namespace

k8s yml文件的用法

文件示例

---
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations: {}
  labels:
    app: mdm-app
    type: backend
  name: mdm-app
  namespace: seeyon-dev
  resourceVersion: '22168956'
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: mdm-app
      type: backend
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: mdm-app
        type: backend
    spec:
      containers:
        - name: mdm-app
          image: '10.242.56.29/seeyon-dev/mdm-app:arm-latest'
          imagePullPolicy: IfNotPresent
          lifecycle:
            preStop:
              httpGet:
                path: /deregisterInstance
                port: appport
                scheme: HTTP
          livenessProbe:
            failureThreshold: 30
            initialDelaySeconds: 600
            periodSeconds: 10
            successThreshold: 1
            tcpSocket:
              port: 9999
            timeoutSeconds: 1
          ports:
            - containerPort: 9999
              hostPort: 9999
              protocol: TCP
          readinessProbe:
            failureThreshold: 30
            httpGet:
              path: /mdm/check
              port: 9999
              scheme: HTTP
            initialDelaySeconds: 10
            periodSeconds: 10
            successThreshold: 1
            timeoutSeconds: 1
          resources:
            limits:
              cpu: '2'
              memory: 5Gi
            requests:
              cpu: 500m
              memory: 3Gi
          terminationMessagePath: /dev/termination-log
          terminationMessagePolicy: File
          volumeMounts:
            - mountPath: /app/logs
              name: log
      dnsPolicy: Default
      imagePullSecrets:
        - name: harbor
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
      tolerations:
        - effect: NoSchedule
          key: group
          operator: Equal
          value: bip
      volumes:
        - name: log
          nfs:
            path: /data/logs
            server: 10.242.56.32

主要为apiVersion，kind，metadata，spec四部分

apiVersion

指定api版本，目前大部分都是写v1，这个值不是写死的，这个值可以在本机上执行kubectl api-versions命令查看 只要记住6个常用的apiversion，一般就够了:

• v1： Kubernetes 稳定版API包含许多核心对象：pod、service等。
• apps/v1： api组合包含一些通用应用层，如：Deployments, RollingUpdates, and ReplicaSets。
• batch/v1： 包括与批处理和类似操作相关的对象，如：job、cronjob。
• autoscaling/v1： 容器可根据不同的资源使用指标自动调整。
• networking.k8s.io/v1： 用于Ingress。
• rbac.authorization.k8s.io/v1：用于RBAC。

kind

表示yaml定义的资源类型，k8s中有很多种资源，包括Pod，Deployment，Job，Services等等

Deployment：声明式更新用于定义应用程序。

StatefulSet：声明更新和管理有状态应用程序。

DaemonSet：用于在集群中运行pod的声明更新和管理。

Job：声明更新和管理用于在集群上运行一次性任务。

CronJob：声明更新和管理用于在集群上运行定期操作。

Service：用于定义一组pod的逻辑集合，并访问这些pod。

Pod：Kubernetes中最基本的资源类型，用于定义一个或多个容器的共同运行环境。

ReplicaSet：声明式更新和管理，用于确保指定数量的pod在集群中运行。

ConfigMap：声明更新和管理用于存储非敏感数据(如配置文件)。

Secret：声明更新和管理用于存储敏感数据(如密码和密钥)。

ServiceAccount：用于定义pod的身份验证信息，以及与Kubernetess API Server交互的权限。

Ingress：定义从外部访问Kubernetes集群中服务的方式。

PersistentVolume：用于定义持久存储卷，并在Kubernetes集群中使用。

StorageClass：用于定义云存储、本地存储等不同类型的存储，并为这些存储类型指定默认参数和策略。

Namespace：用于在Kubernetes集群中创建逻辑分区，从而隔离资源，提高安全性和可维护性。

ServiceMonitor：在Kubernetes集群中自动发现和监控运行的服务。

HorizontalPodAutoscaler：自动调整Kubernetes集群中的pod副本数量，根据当前负载需求实现自动扩展或收缩。 NetworkPolicy：用于定义网络访问策略，控制pod之间的网络流量。

CustomResourceDefinition：定义自定义资源，扩展Kuberneteses API和CRD操作。

PodDisruptionBudget：为保证Kubernetes集群的高可用性，定义维护期间可以安全中断的pod的最小数量。 Role：定义Kubernetes资源的操作权限，如阅读、写作、更新、删除等。

ClusterRole：类似Role，但可用于整个Kubernetes集群

metadata

一些元数据表示创建的资源，这是一种包含名称的对象类型namespace、标签等信息

name: nginx-demo1 #定义资源的名称，在同一个namespace空间中必须是唯一的

labels: #定义资源标签(Pod的标签)

spec

包括container，storage，volume

spec:  #定义deployment资源需要的参数属性，诸如是否在容器失败时重新启动容器的属性
  replicas: 3       #定义副本数量
  selector:         #定义标签选择器
    matchLabels :   #定义匹配标签
      app: nginx    #匹配上面的标签，需与上面的标签定义的app保持一致
  template:         #【定义业务模板】，如果有多个副本，所有副本的属性会按照模板的相关配置进行匹配
    metadata:
      labels:
        app: nginx
    spec:
      containers:       #定义容器属性
        - name: nginx   #定义一个容器名，一个- name:定义一个容器
        image: nginx:1.15.4   #定义容器使用的镜像以及版本
        imagePullPolicy: IfNotPresent #镜像拉取策略
        ports:
        - containerPort: 80   #定义容器的对外的端口

deployment.yaml 文件详解

deployment.yaml文件详解

apiVersion: extensions/v1beta1   #接口版本
kind: Deployment                 #接口类型
metadata:
  name: cango-demo               #Deployment名称
  namespace: cango-prd           #命名空间
  labels:
    app: cango-demo              #标签
spec:
  replicas: 3
  strategy:
    rollingUpdate:  ##由于replicas为3,则整个升级,pod个数在2-4个之间
      maxSurge: 1      #滚动升级时会先启动1个pod
      maxUnavailable: 1 #滚动升级时允许的最大Unavailable的pod个数
  template:         
    metadata:
      labels:
        app: cango-demo  #模板名称必填
    sepc: #定义容器模板，该模板可以包含多个容器
      containers:                                                                   
        - name: cango-demo                                                           #镜像名称
          image: swr.cn-east-2.myhuaweicloud.com/cango-prd/cango-demo:0.0.1-SNAPSHOT #镜像地址
          command: [ "/bin/sh","-c","cat /etc/config/path/to/special-key" ]    #启动命令
          args:                                                                #启动参数
            - '-storage.local.retention=$(STORAGE_RETENTION)'
            - '-storage.local.memory-chunks=$(STORAGE_MEMORY_CHUNKS)'
            - '-config.file=/etc/prometheus/prometheus.yml'
            - '-alertmanager.url=http://alertmanager:9093/alertmanager'
            - '-web.external-url=$(EXTERNAL_URL)'
    #如果command和args均没有写，那么用Docker默认的配置。
    #如果command写了，但args没有写，那么Docker默认的配置会被忽略而且仅仅执行.yaml文件的command（不带任何参数的）。
    #如果command没写，但args写了，那么Docker默认配置的ENTRYPOINT的命令行会被执行，但是调用的参数是.yaml中的args。
    #如果如果command和args都写了，那么Docker默认的配置被忽略，使用.yaml的配置。
          imagePullPolicy: IfNotPresent  #如果不存在则拉取
          livenessProbe:       #表示container是否处于live状态。如果LivenessProbe失败，LivenessProbe将会通知kubelet对应的container不健康了。随后kubelet将kill掉container，并根据RestarPolicy进行进一步的操作。默认情况下LivenessProbe在第一次检测之前初始化值为Success，如果container没有提供LivenessProbe，则也认为是Success；
            httpGet:
              path: /health #如果没有心跳检测接口就为/
              port: 8080
              scheme: HTTP
            initialDelaySeconds: 60 ##启动后延时多久开始运行检测
            timeoutSeconds: 5
            successThreshold: 1
            failureThreshold: 5
          readinessProbe:
            httpGet:
              path: /health #如果没有心跳检测接口就为/
              port: 8080
              scheme: HTTP
            initialDelaySeconds: 30 ##启动后延时多久开始运行检测
            timeoutSeconds: 5
            successThreshold: 1
            failureThreshold: 5
          resources:              ##CPU内存限制
            requests:
              cpu: 2
              memory: 2048Mi
            limits:
              cpu: 2
              memory: 2048Mi
          env:                    ##通过环境变量的方式，直接传递pod=自定义Linux OS环境变量
            - name: LOCAL_KEY     #本地Key
              value: value
            - name: CONFIG_MAP_KEY  #局策略可使用configMap的配置Key，
              valueFrom:
                configMapKeyRef:
                  name: special-config   #configmap中找到name为special-config
                  key: special.type      #找到name为special-config里data下的key
          ports:
            - name: http
              containerPort: 8080 #对service暴露端口
          volumeMounts:     #挂载volumes中定义的磁盘
          - name: log-cache
            mount: /tmp/log
          - name: sdb       #普通用法，该卷跟随容器销毁，挂载一个目录
            mountPath: /data/media    
          - name: nfs-client-root    #直接挂载硬盘方法，如挂载下面的nfs目录到/mnt/nfs
            mountPath: /mnt/nfs
          - name: example-volume-config  #高级用法第1种，将ConfigMap的log-script,backup-script分别挂载到/etc/config目录下的一个相对路径path/to/...下，如果存在同名文件，直接覆盖。
            mountPath: /etc/config       
          - name: rbd-pvc                #高级用法第2中，挂载PVC(PresistentVolumeClaim)
 
#使用volume将ConfigMap作为文件或目录直接挂载，其中每一个key-value键值对都会生成一个文件，key为文件名，value为内容，
  volumes:  # 定义磁盘给上面volumeMounts挂载
  - name: log-cache
    emptyDir: {}
  - name: sdb  #挂载宿主机上面的目录
    hostPath:
      path: /any/path/it/will/be/replaced
  - name: example-volume-config  # 供ConfigMap文件内容到指定路径使用
    configMap:
      name: example-volume-config  #ConfigMap中名称
      items:
      - key: log-script           #ConfigMap中的Key
        path: path/to/log-script  #指定目录下的一个相对路径path/to/log-script
      - key: backup-script        #ConfigMap中的Key
        path: path/to/backup-script  #指定目录下的一个相对路径path/to/backup-script
  - name: nfs-client-root         #供挂载NFS存储类型
    nfs:
      server: 10.42.0.55          #NFS服务器地址
      path: /opt/public           #showmount -e 看一下路径
  - name: rbd-pvc                 #挂载PVC磁盘
    persistentVolumeClaim:
      claimName: rbd-pvc1         #挂载已经申请的pvc磁盘

Service yaml 文件详解

Service yaml文件详解

apiVersion: v1
kind: Service
matadata:                                #元数据
  name: string                           #service的名称
  namespace: string                      #命名空间  
  labels:                                #自定义标签属性列表
    - name: string
  annotations:                           #自定义注解属性列表  
    - name: string
spec:                                    #详细描述
  selector: []                           #label selector配置，将选择具有label标签的Pod作为管理 
                                         #范围
  type: string                           #service的类型，指定service的访问方式，默认为 
                                         #clusterIp
  clusterIP: string                      #虚拟服务地址      
  sessionAffinity: string                #是否支持session
  ports:                                 #service需要暴露的端口列表
  - name: string                         #端口名称
    protocol: string                     #端口协议，支持TCP和UDP，默认TCP
    port: int                            #服务监听的端口号
    targetPort: int                      #需要转发到后端Pod的端口号
    nodePort: int                        #当type = NodePort时，指定映射到物理机的端口号
  status:                                #当spce.type=LoadBalancer时，设置外部负载均衡器的地址
    loadBalancer:                        #外部负载均衡器    
      ingress:                           #外部负载均衡器 
        ip: string                       #外部负载均衡器的Ip地址值
        hostname: string                 #外部负载均衡器的主机名

控制端口映射的配置参数

在 Deployment 或 StatefulSet 中配置端口映射

# 端口映射是在 spec.template.spec.containers[].ports 字段中配置的
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: MyApp
  template:
    metadata:
      labels:
        app: MyApp
    spec:
      containers:
      - name: my-container
        image: my-image:latest
        ports:
        - containerPort: 9376 #这是容器监听的端口
          hostPort: 9999 # 会占用主机的端口，建议使用 Kubernetes 的 Service,会自动负载
          protocol: TCP #可以是 TCP 或 UDP，默认是 TCP

在 Service 中配置端口映射

Service 用于暴露应用的网络服务，可以通过 spec.ports 字段来配置端口映射。

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP # 可以是 TCP 或 UDP，默认是 TCP
      port: 80 #这是 Service 的端口，其他服务或外部流量将通过这个端口访问 Service
      targetPort: 9376 #这是 Pod 上的端口，Service 将流量转发到这个端口

控制挂载文件映射的配置参数

主要字段 volumes: 定义存储卷，这些卷可以被 Pod 中的一个或多个容器挂载。 volumeMounts: 在容器内挂载存储卷，指定挂载路径。 支持的卷类型： emptyDir hostPath configMap secret persistentVolumeClaim nfs awsElasticBlockStore gcePersistentDisk

apiVersion: v1
kind: Pod
metadata:
  name: test-pd
spec:
  containers:
  - image: k8s.gcr.io/test-webserver
    name: test-container
    volumeMounts:
    - mountPath: /app/logs # 挂载时容器内部的路径
      name: logs # 和volumes.name 对应
  volumes:
  - name: logs # 和volumeMounts.name 对应
    nfs:
      path: /data/logs #网络挂在路径
      server: 10.242.56.00 #挂载nfs的ip
    #-------------emptyDir
    emptyDir: {}
    #-------------hostPath
    hostPath:
      path: /data
      type: Directory
    #-------------configMap
    configMap:
      name: example-config
    #-------------secret
    secret:
      secretName: example-secret

控制容器是否就绪的配置参数

apiVersion: v1
kind: Pod
metadata:
  name: liveness-readiness-example
spec:
  containers:
  - name: liveness-readiness-example
    image: k8s.gcr.io/busybox
    readinessProbe: #就绪探针 控制容器是否就绪
      exec: #使用 exec 命令检查 /tmp/healthy 文件是否存在
        command:
        - cat
        - /tmp/healthy
      tcpSocket: # tcp检查是否就绪
         port: 8080 # tcp端口
      httpGet: # 使用接口探测和上面挑一个使用即可
         path: /healthz
         port: 8080 # 接口端口
      initialDelaySeconds: 5 #容器启动后启动后等待 5 秒开始检查
      periodSeconds: 10 #每 10 秒检查一次
      timeoutSeconds: 5 #检查超时时间为 5 秒
      failureThreshold: 3 #连续失败 3 次认为容器未就绪
      successThreshold: 1 #连续成功 1 次认为容器已就绪
    livenessProbe: #存活探针 用于确定容器是否仍在运行
      exec: #使用 exec 命令检查 /tmp/healthy 文件是否存在
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5 #容器启动后启动后等待 5 秒开始检查
      periodSeconds: 10 #每 10 秒检查一次
      timeoutSeconds: 5 #检查超时时间为 5 秒
      failureThreshold: 3 #连续失败 3 次认为容器不健康，Kubernetes 会重启容器

向私有云k8s推送的脚本

以下脚本实际项目采用过

@echo off
set ENVIRONMENT=test
set IMAGE_NAME=mdm-app
set VERSION=arm-004
set HARBOR_URL=HARBOR的ip
set HARBOR_PROJECT=seeyon-dev
set HARBOR_USERNAME=admin
set HARBOR_PASSWORD=HARBOR的密码


docker build --platform linux/arm64 --build-arg MY_ARG=%ENVIRONMENT% -t %IMAGE_NAME% .
if %errorlevel% neq 0 (
    echo build error
    exit /b %errorlevel%
)
echo dockerimg build success

echo login Harbor...
docker login %HARBOR_URL% -u %HARBOR_USERNAME% -p %HARBOR_PASSWORD%
if %errorlevel% neq 0 (
    echo login Harbor error
    exit /b %errorlevel%
)
echo login Harbor success

REM build tag image...
set FULL_IMAGE_NAME=%HARBOR_URL%/%HARBOR_PROJECT%/%IMAGE_NAME%:%VERSION%
echo build image: %FULL_IMAGE_NAME%
docker tag %IMAGE_NAME% %FULL_IMAGE_NAME%
if %errorlevel% neq 0 (
    echo build tag error
    exit /b %errorlevel%
)
echo build tag success

echo push image to Harbor...
docker push %FULL_IMAGE_NAME%
if %errorlevel% neq 0 (
    echo push image to Harbor error
    exit /b %errorlevel%
)
echo push image to Harbor success

k8s Windos远程连接部署

1. ‌准备多个kubeconfig文件‌：
   • 为每个k8s集群准备一个kubeconfig文件，这些文件可以包含集群的API Server地址、认证数据等信息‌1。
   • 你可以将这些文件保存在一个文件夹中，方便管理‌2。
   • Windows要访问K8s，通常需要开通K8s API Server的端口，即6443端口‌
2. ‌查看和切换上下文‌：
   • 使用kubectl config view命令可以查看当前kubeconfig文件中的所有上下文（即集群、用户和命名空间的组合）‌3。
   • 使用kubectl config use-context <context-name>命令可以切换到不同的上下文，从而连接到不同的集群‌13。
3. ‌通过环境变量指定kubeconfig文件‌：
   • 如果你不想每次都指定kubeconfig文件的位置，可以通过设置KUBECONFIG环境变量来指定kubectl应该使用的配置文件‌45。
   • 例如，你可以使用export KUBECONFIG=/path/to/your/kubeconfig-file命令来设置环境变量‌5。
4. ‌合并kubeconfig文件‌：
   • 如果你有多个kubeconfig文件，也可以将它们合并成一个文件，这样在一个文件中就可以管理多个集群的上下文‌45。
   • 合并可以使用文本编辑器手动进行，或者使用一些工具（如kubecm）来自动化这个过程‌5。
5. ‌验证连接‌：
   • 切换完上下文或指定完kubeconfig文件后，你可以使用kubectl get nodes或kubectl get pods等命令来验证你是否已经成功连接到了目标集群‌3。

通过以上步骤，可以轻松地在多个k8s集群之间进行切换和管理。

Harbor

介绍：docker私有化镜像仓库

Harbor 基本名词解释

Registry：

定义：Registry 是 Docker 容器镜像的存储库，用于存储和分发容器镜像。 作用：Harbor 是一个企业级的私有 Registry，提供了更多的安全性和管理功能。

Repository：

定义：Repository 是一个包含多个镜像版本的集合，通常对应于一个特定的项目或应用。 作用：用户可以通过 Repository 名称来拉取或推送特定版本的镜像。

Project：

定义：Project 是 Harbor 中的一个逻辑分组，用于组织和管理多个 Repository。 作用：通过 Project，可以实现权限管理和资源隔离。

Tag：

定义：Tag 是镜像的标识符，用于区分同一 Repository 中的不同版本。 作用：用户可以通过 Tag 来指定要使用的镜像版本，例如 myapp:1.0 和 myapp:1.1。

User：

定义：User 是 Harbor 中的用户账户，用于身份验证和权限管理。 作用：用户可以拥有不同的角色（如管理员、开发人员等），并根据角色获得相应的权限。

Role：

定义：Role 是一组预定义的权限集合，用于控制用户对资源的访问。 作用：常见的角色包括管理员、开发者和访客等，每个角色有不同的权限。

Policy：

定义：Policy 是 Harbor 中的策略配置，用于自动化操作，如镜像复制、扫描和清理等。 作用：通过 Policy，可以实现镜像的自动同步和安全扫描。

Harbor 基本使用方式

安装和启动 Harbor

1、下载 Harbor 安装包：

wget https://github.com/goharbor/harbor/releases/download/v2.5.0/harbor-offline-installer-v2.5.0.tgz
tar xvf harbor-offline-installer-v2.5.0.tgz
cd harbor   

2、配置 Harbor： 编辑 harbor.yml 文件，配置 Harbor 的基本信息，如域名、数据库、存储等。 例如：

hostname: registry.yourdomain.com
http:
  port: 80
admin_password: YourAdminPassword
database:
  password: YourDBPassword
     

3、运行 Harbor： ./install.sh

4、登录 Harbor 打开浏览器，访问 http://registry.yourdomain.com，使用管理员账号登录。 创建用户：进入 "用户管理" 页面，创建新的用户账户。 创建项目：进入 "项目管理" 页面，创建新的项目。

推送镜像到 Harbor

#登录 Harbor
docker login registry.yourdomain.com -u yourUsername -p yourPassword
#标记镜像：
docker tag mdmApp.jar:latest registry.yourdomain.com/yourProject/mdmApp:latest
#推送镜像
docker push registry.yourdomain.com/yourProject/mdmApp:latest

######拉取镜像
docker login registry.yourdomain.com -u yourUsername -p yourPassword
docker pull registry.yourdomain.com/yourProject/mdmApp:latest
   

docker推送到Harbor

#  示例，开发环境推送脚本：
# 如果Harbor是http的，需要docker开启 daemon.json 文件：
#     在 Linux 上，编辑 /etc/docker/daemon.json 文件。
#     在 Windows 上，编辑 %ProgramData%\Docker\config\daemon.json 文件。
{
	"insecure-registries" : ["registry.yourdomain.com"]
}

# 登录
docker login 10.242.56.29 -u admin -p jkGAh28191721!!
#在项目中标记镜像：
docker tag mdm-app:latest 10.242.56.29/seeyon-dev/mdm-app:latest
docker tag mdm-app:arm-latest 10.242.56.29/seeyon-dev/mdm-app:arm-latest
# 推送镜像到当前项目：
docker push 10.242.56.29/seeyon-dev/mdm-app:latest
docker push 10.242.56.29/seeyon-dev/mdm-app:arm-latest

Harbor推送镜像到k8s

1、配置 Docker 凭证： 在 Kubernetes 集群中配置 Docker 凭证，以便能够从私有的 Harbor 仓库拉取镜像。 使用 kubectl create secret docker-registry 命令创建一个 Secret 来存储 Harbor 的认证信息。

   kubectl create secret docker-registry regcred \
     --docker-server=<your-harbor-domain> \
     --docker-username=<your-username> \
     --docker-password=<your-password> \
     --docker-email=<your-email>
   

2、编写 Deployment 或 Pod YAML 文件： 创建一个 Kubernetes Deployment 或 Pod 的 YAML 文件，在其中指定要使用的 Harbor 镜像，并引用上面创建的 Secret。

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-app-deployment
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: my-app-container
           image: <your-harbor-domain>/<project-name>/<image-name>:<tag>
           ports:
           - containerPort: 80
         imagePullSecrets:
         - name: regcred
   

3、应用 YAML 文件： 使用 kubectl apply -f <filename>.yaml命令将 Deployment 或 Pod 应用到 Kubernetes 集群中。

   kubectl apply -f deployment.yaml

4、验证部署： 使用 kubectl get pods 查看 Pod 是否成功启动。 使用 kubectl describe pod <pod-name>查看 Pod 的详细信息，确保没有错误。

Kuboard部署Deployment/Pod

1、登录 Kuboard： 打开浏览器，访问 Kuboard 的 URL。 配置命名空间： 2、进入 命名空间 页面。 如果还没有命名空间，点击 创建命名空间，输入命名空间名称，例如 harbor-apps。 3、配置 Secret： 进入 命名空间 -> Secret 页面。 点击 创建 Secret。 选择 Docker Registry 类型。 填写以下信息： 名称：例如 harbor-secret。 Docker Registry Server：https://your-harbor-domain.com。 用户名：你的 Harbor 用户名。 密码：你的 Harbor 密码。 邮箱：可选。 点击 保存。

4、创建 Deployment 进入命名空间： 进入 命名空间 -> harbor-apps 页面。 创建 Deployment： 点击 创建工作负载 -> Deployment。 填写以下信息： 名称：例如 harbor-deployment。 镜像：your-harbor-domain.com/project-name/your-image:tag。 副本数：根据需求设置，例如 3。 容器端口：根据你的应用配置，例如 9999。 环境变量：根据需求设置。 卷：根据需求设置。 Secrets：选择之前创建的 harbor-secret。 点击 保存。

5、创建 Service 进入命名空间： 进入 命名空间 -> harbor-apps 页面。 创建 Service： 点击 创建服务 -> Service。 填写以下信息： 名称：例如 harbor-service。 类型：选择 NodePort 或 LoadBalancer 根据需求。 选择工作负载：选择之前创建的 harbor-deployment。 端口映射：根据需求设置，例如 9999:9999。 点击 保存。

6、验证部署 检查 Pod 状态： 进入 命名空间 -> harbor-apps -> Pods 页面。 确认所有 Pod 都处于 Running 状态。 访问应用： 如果使用 NodePort，可以通过节点 IP 和 NodePort 访问应用，例如 http://node-ip:node-port。 如果使用 LoadBalancer，可以通过 LoadBalancer 的外部 IP 访问应用，例如 http://load-balancer-ip。

7、监控和日志 监控： 使用 Kuboard 提供的监控功能，查看 Pod 的资源使用情况。 日志： 进入 命名空间 -> harbor-apps -> Pods 页面。 选择一个 Pod，点击 日志 查看应用日志。

Docker buildx跨环境构建镜像

在Windows和macOs上，Docker Desktop已经包含了Docker Buildx，无需额外安装，可通过命令docker buildx version 确认其是否安装成功。

docker buildx build --platform linux/arm64 -t your-dockerhub-username/your-repo-name:tag --push .

docker buildx 将 Dockerfile 构建成适用于 ARM 架构的镜像

1、安装并启用 Docker Buildx

#查看是否有buildx
docker buildx version
# 创建构建实例
docker buildx create --use --name mybuilder
#列出所有构建器实例
docker buildx ls
#安装 QEMU
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
#构建适用于 ARM 架构的镜像
docker build --platform linux/arm64 -t mdm-app:arm-latest .
docker build --platform linux/amd64,linux/arm64 -t mdm-app:arm-latest .



docker buildx build --platform linux/arm64 -t mdm-app:arm-latest .
docker buildx build --platform linux/arm64 -t yourusername/yourimage:arm-latest .
# 加推送
docker buildx build --platform linux/amd64,linux/arm64 --push -t repo/hello .


docker buildx build --platform linux/arm64 -t yourusername/yourimage:arm-latest -f C:\Users\wuchaozhi\Desktop\中建\MDM_Data_Processor\Dockerfile C:\Users\wuchaozhi\Desktop\中建\MDM_Data_Processor
#解释
--platform linux/arm64：指定要构建的目标平台为 ARM 64 位。
-t yourusername/yourimage:arm-latest：指定构建的镜像标签。
-f C:\Users\wuchaozhi\Desktop\中建\MDM_Data_Processor\Dockerfile：指定 Dockerfile 的路径。
C:\Users\wuchaozhi\Desktop\中建\MDM_Data_Processor：指定构建上下文的路径。

云原生基础设施

GitLab:

可以考虑部署在Kubernetes上，利用其弹性伸缩的能力来应对不同时间点的访问压力。

Kafka:

部署在Kubernetes上可以利用其水平扩展能力，但需要注意的是，Kafka对存储有较高要求，确保Kubernetes的存储解决方案能满足需求。

Harbor:

作为私有Docker Registry，部署在Kubernetes上可以方便地与其他Kubernetes应用集成。

ClickHouse:

虽然可以部署在Kubernetes上，但由于其对性能的要求较高，有时直接在高性能独立服务器上部署可能会有更好的表现。

Elasticsearch (ES):

ES同样适合部署在Kubernetes上，尤其是当需要动态调整节点数量时。但是，需要注意数据持久化和备份策略。

Nacos:

作为服务发现和配置管理工具，非常适合部署在Kubernetes上，以便于与其他微服务应用集成。

Redis:

可以部署在Kubernetes上，特别是当使用Redis Cluster模式时。但需要注意网络延迟和数据持久化问题。

Nginx:

既可以作为Ingress Controller部署在Kubernetes上，也可以作为独立的反向代理服务器部署在独立服务器上。

Nexus:

作为私有仓库，部署在Kubernetes上可以方便地进行版本管理和备份。

数据库：

建议独立部署

Kuboard：

Kuboard和kubeSphere任选其一可视化安装即可，Kuboard比较轻量，kubeSphere比较重量级

COP记录

常用命令