k8s 托管控制层面—— Kamaji

启明真纳

已于 2024-06-16 19:28:02 修改

阅读量551

点赞数 17

分类专栏： k8s 文章标签： kubernetes 容器云原生 devops 云计算 docker etcd

于 2024-06-16 19:19:03 首次发布

本文链接：https://blog.csdn.net/qq_42895490/article/details/139724779

版权

k8s 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

在日常工作中，公司内部的私有环境中免不了为每个团队，在不同的环境创建一个或多个 Kubernetes 集群，每次创建都需要从虚拟机的选型开始准备，然后到操作系统配置，软件安装，最后到集群初始化等等多个步骤。

而如果使用公有云服务，直接使用如像 EKS、ACK、AKS 和 GKE 时，集群可以直接初始化好一个高可用的控制层面，我们只需要添加一个或多个工作节点，用来处理我们业务需要即可。照着这个思路，我们找到了开源项目 Kamaji，一个可以实现 Controller AS Service 的工具。

预准备

本次实验需要用的两台服务器，规格如下：

hostname	os	cpu	mem	disk
controller-manager	Centos7	8C	16G	20G
worker	Centos7	2C	4G	20G

我们将把 controller-mananger 服务器作为 Kubernetes 控制层面的管理集群，把 worker 节点后续将作为工作节点加入新的 Kubernets 集群中。

初始化控制层面的管理集群

我们将使用 controller-manager 初始化一个 Kubernets 集群，并在此集群中国安装以下工具：

OpenEBS
cert-manager
Kamaji

搭建及初始化 Kubernetes 集群

我们可以使用 Kubekey 工具搭建一个 Kubernetes 集群，详情可以参考此链接。

在完成 Kubernetes 集群的搭建后，执行以下命令安装 OpenEBS、cert-manager 和 Kamaji 三个工具：

helm repo add openebs https://openebs.github.io/charts
helm repo update
helm upgrade --install openebs --namespace openebs openebs/openebs --create-namespace

helm repo add jetstack https://charts.jetstack.io
helm repo update
helm upgrade --install  cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --version v1.11.0 --set installCRDs=true

helm repo add clastix https://clastix.github.io/charts
helm repo update
helm upgrade --install kamaji clastix/kamaji -n kamaji-system --create-namespace

验证

执行 kubectl get pod -n kamaji-system，显示以下内容证明安装成功：

NAME                     READY   STATUS    RESTARTS      AGE
etcd-0                   1/1     Running   3 (57s ago)   22h
etcd-1                   1/1     Running   3 (57s ago)   22h
etcd-2                   1/1     Running   3 (57s ago)   22h
kamaji-5fb885b59-jkgcf   1/1     Running   4 (57s ago)   22h

创建 Kubernetes 的控制层面

登录到 controller-manager 将下面的 tenant-00.yaml 文件保存在 /root 目录下面，并执行 kubectl apply -f tenant-00.yaml 命令，创建一个新的 Kubernets 的控制层面。

apiVersion: kamaji.clastix.io/v1alpha1
kind: TenantControlPlane
metadata:
name: tenant-00
namespace: default
labels:
    tenant.clastix.io: tenant-00
spec:
    dataStore: default
    controlPlane:
        deployment:
        replicas: 3
        additionalMetadata:
            labels:
            tenant.clastix.io: tenant-00
        extraArgs:
            apiServer: []
            controllerManager: []
            scheduler: []
        registrySettings:
            apiServerImage: kube-apiserver
            controllerManagerImage: kube-controller-manager
            registry: registry.cn-hangzhou.aliyuncs.com/google_containers
            schedulerImage: kube-scheduler
        resources:
            apiServer:
            requests:
                cpu: 250m
                memory: 512Mi
            limits: {}
            controllerManager:
            requests:
                cpu: 125m
                memory: 256Mi
            limits: {}
            scheduler:
            requests:
                cpu: 125m
                memory: 256Mi
            limits: {}
        service:
        additionalMetadata:
            labels:
            tenant.clastix.io: tenant-00
        serviceType: NodePort
    kubernetes:
        version: v1.26.0
        kubelet:
        cgroupfs: systemd
        admissionControllers:
        - ResourceQuota
        - LimitRanger
    networkProfile:
        port: 32100
        certSANs:
        - tenant-00.clastix.labs
        serviceCidr: 10.96.0.0/12
        podCidr: 10.244.0.0/16
        allowAddressAsExternalIP: true
        address: '192.168.8.109' ##修改为 controller-manager 服务的 IP 地址
        dnsServiceIPs:
        - 10.96.0.10 
    addons:
        coreDNS: 
        imageRepository: registry.cn-hangzhou.aliyuncs.com/google_containers
        kubeProxy: 
        imageRepository: registry.cn-hangzhou.aliyuncs.com/google_containers
        konnectivity:
        agent:
            image: registry.cn-hangzhou.aliyuncs.com/k8sss212/proxy-agent
            version: v0.0.32
        server:
            image: registry.cn-hangzhou.aliyuncs.com/k8sss212/proxy-server
            port: 32101
            resources:
            requests:
                cpu: 100m
                memory: 128Mi
            limits: {}
---
apiVersion: v1
kind: Service
metadata:
name: tenant-00-public
namespace: default
spec:
ports:
- port: 443
    protocol: TCP
    targetPort: 6443
selector:
    kamaji.clastix.io/name: tenant-00
type: NodePort

在创建完成之后，执行 kubectl get TenantControlPlane，显示如下即代表新的 Kubernetes 的控制节点初始化成功。

NAME        VERSION   STATUS   CONTROL-PLANE ENDPOINT   KUBECONFIG                   DATASTORE   AGE
tenant-00   v1.26.0   Ready    192.168.8.109:32100      tenant-00-admin-kubeconfig   default     24h

同时还可以执行 curl -k https://192.168.8.109:32100/healthz 和 curl -k https://192.168.8.109:32100/version 获取新的 Kubernets 集群的健康状态和版本情况。

添加工作节点

登录到 worker 服务器，我们将把 worker 服务器加入到新的 Kubernetes 集群中。

初始化服务器

初始化操作系统

Kubernets 的每个节点都需在操作系统层面优化内核参数和一些简单的配置，执行以下命令进行操作：

swapoff -a
modprobe  br_netfilter
echo "worker" > /etc/hostname
cat > /etc/hosts <<EOF
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
worker 192.168.8.110
EOF
systemctl stop firewalld
systemctl disable firewalld

接着我们需要优化内核参数，将下面内容添加到 /etc/sysctl.conf 中，然后执行命令 sysctl -p。

net.ipv4.ip_forward = 1
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 0
net.ipv4.tcp_fin_timeout = 300
net.bridge.bridge-nf-call-arptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_local_reserved_ports = 30000-32767
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 65535
net.netfilter.nf_conntrack_tcp_be_liberal=1
net.netfilter.nf_conntrack_tcp_loose=1
net.netfilter.nf_conntrack_max=3200000
net.netfilter.nf_conntrack_tcp_timeout_time_wait=30
net.ipv4.tcp_timestamps=1
net.ipv4.ip_local_port_range=5120 65000
net.ipv4.tcp_fin_timeout=30
net.ipv4.tcp_max_syn_backlog=10240
net.core.somaxconn=10240
net.ipv4.tcp_syncookies=1

安装软件并配置

我们需要在 worker 服务器上面添加以下软件：

containerd
kubeadm-1.26.0
kubelet-1.26.0
kubectl-1.26.0

在安装之前，我们需要配置 docker-ce 和 k8s 相关的两个 yum 仓库，具体操作可以参考这两个文档：

在配置完成之后执行以下命令安装以上软件：

yum install containerd kubelet-1.26.0 kubeadm-1.26.0 kubelet-1.26.0 -y

在安装好之后，我们需要配置 containerd 和 kubelet 的一些参数，先执行 containerd config default > /etc/containerd/config.toml，然后修改 config.toml 中的以下字段：

[grpc]
  address = "/var/run/containerd/containerd.sock"

[plugins]
  
  [plugins."io.containerd.grpc.v1.cri"]
     ....
     sandbox_image = "registry.aliyuncs.com/google_containers/pause:3.9"
     ....

然后我们需要修改 kubelet 的一些配置参数，将 /var/lib/kubelet/kubeadm-flags.env 修改为以下内容：

KUBELET_KUBEADM_ARGS="--container-runtime-endpoint=unix:///var/run/containerd/containerd.sock   --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.9"

在修改完成之后执行，以下命令启动 containerd 和 kubelet:

systemctl start containerd
systemctl enable containerd
systemctl start kubelet
systemctl enable kubelet

集群添加新节点

在 controller-manager 服务器上执行，以下命令获得 kubeconfig 文件：

kubectl get secrets  tenant-00-admin-kubeconfig -o json \
  | jq -r '.data["admin.conf"]' \
  | base64 --decode \
  > tenant-00-config

!!! note
如果没有 jq 命令，可以执行命令 yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm -y && yum install jq -y 进行安装。

拿到 kubeconfig 文件之后，执行 kubeadm --kubeconfig=tenant-00-config token create --print-join-command 获得加入 kubernetes 集群的命令，显示输出如下：

kubeadm join 192.168.8.109:32100 --token 8yoojw.yhu45tqh00tw3ype --discovery-token-ca-cert-hash sha256:1f4fc8b9c358b7d046d9a1faed1e70640290af1bef2eaaea4bc4611773cd6573

在 worker 节点上执行以下命令，即可加入新的 Kubernets 集群:

kubeadm join 192.168.8.109:32100 --token 8yoojw.yhu45tqh00tw3ype --discovery-token-ca-cert-hash sha256:1f4fc8b9c358b7d046d9a1faed1e70640290af1bef2eaaea4bc4611773cd6573

在 controller-manager 服务器上执行命令 kubectl --kubeconfig=tenant-00-config get node 显示如下：

NAME     STATUS     ROLES    AGE    VERSION
worker   NotReady   <none>   112s   v1.26.0

在新的 k8s 节点上安装 calico 网络插件，在 controller-manager 服务器上执行以下命令：

kubectl  --kubeconfig=tenant-00-config apply  -f  https://raw.githubusercontent.com/projectcalico/calico/v3.24.1/manifests/calico.yaml

安装完成执行之后，执行 kubectl --kubeconfig=tenant-00-config get pod -A 进行验证，输出如下则代表当前 Kubernetes 集群已经正常：

NAMESPACE     NAME                                       READY   STATUS    RESTARTS      AGE
kube-system   calico-kube-controllers-5f94594857-jpcl9   1/1     Running   1 (71m ago)   19h
kube-system   calico-node-j7wcl                          1/1     Running   1 (71m ago)   19h
kube-system   coredns-6f44f86fd8-jzlwp                   1/1     Running   0             32m
kube-system   konnectivity-agent-nlhr6                   1/1     Running   1 (71m ago)   19h
kube-system   kube-proxy-99vrf                           1/1     Running   1 (71m ago)   19h

启明真纳

关注

17
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
k8s 托管控制层面—— Kamaji

在日常工作中，公司内部的私有环境中免不了为每个团队，在不同的环境创建一个或多个 Kubernetes 集群，每次创建都需要从虚拟机的选型开始准备，然后到操作系统配置，软件安装，最后到集群初始化等等多个步骤。而如果使用公有云服务，直接使用如像 EKS、ACK、AKS 和 GKE 时，集群可以直接初始化好一个高可用的控制层面，我们只需要添加一个或多个工作节点，用来处理我们业务需要即可。照着这个思路，我们找到了开源项目 Kamaji，一个可以实现 Controller AS Service 的工具。
复制链接

扫一扫