[Cloud Native] Kubeadmin installe le cluster k8s

Kubeadm est un outil qui fournit kubeadm init et kubeadm join comme meilleure pratique pour un « moyen rapide » de créer des clusters Kubernetes.

kubeadm effectue les opérations nécessaires pour qu'un cluster minimalement utilisable soit opérationnel . De par sa conception, il se concentre uniquement sur le démarrage et non sur la configuration de la machine. De même, l'installation de diverses extensions « cerise sur le gâteau », telles que les tableaux de bord Kubernetes, les solutions de surveillance et les extensions spécifiques aux plates-formes cloud, n'entre pas dans le cadre de cette discussion. Au lieu de cela, nous espérons créer des outils de niveau supérieur et plus conformes au-dessus de kubeadm. Idéalement, utiliser kubeadm comme référence pour tous les efforts de déploiement facilitera la création de clusters cohérents.

Déploiement dans un seul environnement

1.1 Fonction de déploiement du serveur

rôle du nœud	adresse IP	Service de déploiement
maître (2C4G)	192.168.181.100	docker, kubeadm, kubelet, kubectl, flanelle
nœud01 (2C2G)	192.168.181.101	docker, kubeadm, kubelet, kubectl, flanelle
nœud02(2C2G)	192.168.181.102	docker, kubeadm, kubelet, kubectl, flanelle
Nœud portuaire (hub.lbj.com)	192.168.181.103	docker, docker-Compose, port-hors ligne-v1.2.2

1.2 Préparation de l'environnement (tous les nœuds)

//所有节点，关闭防火墙规则，关闭selinux，关闭swap交换
systemctl stop firewalld
systemctl disable firewalld
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X
swapoff -a						#交换分区必须要关闭
sed -ri 's/.*swap.*/#&/' /etc/fstab		#永久关闭swap分区，&符号在sed命令中代表上次匹配的结果
#加载 ip_vs 模块
for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done

//修改主机名
hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02

//所有节点修改hosts文件
vim /etc/hosts
192.168.181.100 master01
192.168.181.101 node01
192.168.181.102 node02

//调整内核参数
cat > /etc/sysctl.d/kubernetes.conf << EOF
#开启网桥模式，可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables=1
net.bridge.bridge-nf-call-iptables=1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF

//生效参数
sysctl --system

2. Installez Docker (tous les nœuds)

yum install -y yum-utils device-mapper-persistent-data lvm2 
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum install -y docker-ce docker-ce-cli containerd.io

mkdir /etc/docker
cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": ["https://这里我用的是阿里云加速器"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  }
}
EOF
#使用Systemd管理的Cgroup来进行资源控制与管理，因为相对Cgroupfs而言，Systemd限制CPU、内存等资源更加简单和成熟稳定。
#日志使用json-file格式类型存储，大小为100M，保存在/var/log/containers目录下，方便ELK等日志系统收集和管理日志。

systemctl daemon-reload
systemctl restart docker.service
systemctl enable docker.service 

docker info | grep "Cgroup Driver"
Cgroup Driver: systemd

miroirs de registre : configurer l'adresse d'accélération du miroir

Accélération d'image d'Alibaba Cloud : Console---->Recherche du service d'image de conteneur dans Produits et services d'image---->Outil d'image------>Accélérateur d'image

options d'exécution :

Utilisez les Cgroups gérés par Systemd pour le contrôle et la gestion des ressources, car comparé à Cgroupfs, Systemd est plus simple, plus mature et stable pour limiter les ressources telles que le processeur et la mémoire.

draveur ; options de connexion

Les journaux sont stockés au format de fichier json, d'une taille de 100 Mo, et sont enregistrés dans le répertoire /var/log/containers, ce qui est pratique pour les systèmes de journalisation tels que ELK pour collecter et gérer les journaux.

3. Installez kubeadm, kubelet et kubectl sur tous les nœuds

3.1 Définir la source de Kubernetes

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

yum install -y kubelet-1.20.11 kubeadm-1.20.11 kubectl-1.20.11

3.2 Démarrer automatiquement Kubelet au démarrage

systemctl enable kubelet.service
#K8S通过kubeadm安装出来以后都是以Pod方式存在，即底层是以容器方式运行，所以kubelet必须设置开机自启

4. Déployer le cluster K8S

4.1 Afficher les images requises pour l'initialisation

kubeadm config images list

4.2 Le nœud maître télécharge le package compressé

unzip v1.20.11.zip -d /opt/k8s
cd /opt/k8s/v1.20.11
for i in $(ls *.tar); do docker load -i $i; done

4.3 Copier l'image et le script sur le nœud

scp -r /opt/k8s root@node01:/opt
scp -r /opt/k8s root@node02:/opt

#### node节点
cd /opt/k8s/v1.20.11
for i in $(ls *.tar); do docker load -i $i; done

4.4 Initialiser kubeadm

kubeadm config print init-defaults > /opt/kubeadm-config.yaml

cd /opt/
vim kubeadm-config.yaml
......
11 localAPIEndpoint:
12   advertiseAddress: 192.168.181.100		#指定master节点的IP地址
13   bindPort: 6443
......
34 kubernetesVersion: v1.20.11				#指定kubernetes版本号
35 networking:
36   dnsDomain: cluster.local
37   podSubnet: "10.244.0.0/16"				#指定pod网段，10.244.0.0/16用于匹配flannel默认网段
38   serviceSubnet: 10.96.0.0/16			#指定service网段
39 scheduler: {}
#末尾再添加以下内容
--- 
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: ipvs									#把默认的kube-proxy调度方式改为ipvs模式

wq！
###############

kubeadm init --config=kubeadm-config.yaml --upload-certs | tee kubeadm-init.log
#--experimental-upload-certs 参数可以在后续执行加入节点时自动分发证书文件，K8S V1.16版本开始替换为 --upload-certs
#tee kubeadm-init.log 用以输出日志


//查看 kubeadm-init 日志
less kubeadm-init.log

//kubernetes配置文件目录
ls /etc/kubernetes/

//存放ca等证书和密码的目录
ls /etc/kubernetes/pki

4.5 Résultats de la génération de certificat

提示：
......
Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.181.100:6443 --token wfjo7j.baa0aheyw39w3m7h \
    --discovery-token-ca-cert-hash sha256:77100ff66b20100cbd9f1c289788e43aee69c5b4e24cc2c74c2e5d634a074fdc

La clé Token doit être enregistrée, elle sera utilisée à l'étape suivante

4.6 Définir kubectl (nœud maître)

kubectl doit être authentifié et autorisé par le serveur API avant de pouvoir effectuer les opérations de gestion correspondantes. Le cluster déployé par kubeadm génère un fichier de configuration d'authentification /etc/kubernetes/admin.conf avec des droits d'administrateur pour celui-ci, qui peut être utilisé par kubectl via le chemin par défaut "$ HOME/.kube/config" à charger.

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

######### 因为node节点还没加入 所以scheduler和controller-manager会显示unhealthy

如果 kubectl get cs 发现集群不健康，更改以下两个文件
vim /etc/kubernetes/manifests/kube-scheduler.yaml 
vim /etc/kubernetes/manifests/kube-controller-manager.yaml
# 修改如下内容
把--bind-address=127.0.0.1变成--bind-address=192.168.181.100		#修改成k8s的控制节点master01的ip
把httpGet:字段下的hosts由127.0.0.1变成192.168.181.100（有两处）
#- --port=0					# 搜索port=0，把这一行注释掉

systemctl restart kubelet

5. Déployez la flanelle du plug-in réseau sur tous les nœuds

5.1 Déployer la flanelle

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml


//在 node 节点上执行 kubeadm join 命令加入群集
kubeadm join 192.168.181.100:6443 --token rc0kfs.a1sfe3gl4dvopck5 \
    --discovery-token-ca-cert-hash sha256:864fe553c812df2af262b406b707db68b0fd450dc08b34efb73dd5a4771d37a2
 
##########
因为Token密钥因为Token密钥失效时间是24h，如果Token失效，可以使用以下命令重新生成
###########

kubeadm token create  
####生成token密钥

openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'
####生成openssl十六进制密钥

5.2 Vérifier l'état du nœud sur le nœud maître

kubectl get nodes

kubectl get pods -n kube-system

5.3 Création de ressources de module de test

kubectl create deployment nginx --image=nginx

5.4 Exposer les ports pour fournir des services

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

####查看service通信
kubectl get svc

####测试访问
curl http://node01:31044

6. Déployer le tableau de bord

6.1 Le nœud maître télécharge le fichier recommandé.yaml

cd /opt/k8s
vim recommended.yaml
#默认Dashboard只能集群内部访问，修改Service为NodePort类型，暴露到外部：
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30001     #添加
  type: NodePort          #添加
  selector:
    k8s-app: kubernetes-dashboard
	
kubectl apply -f recommended.yaml

6.2 Créer un compte de service et lier le rôle de cluster d'administrateur de cluster par défaut

kubectl create serviceaccount dashboard-admin -n kube-system
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

#使用输出的token登录Dashboard
https://NodeIP:30001

7. Installer l'entrepôt privé Harbour

7.1 Tous les nœuds plus le mappage du nom d'hôte

echo '192.168.181.103 hub.lbj.com' >> /etc/hosts

7.2 Installer le menu fixe

yum install -y yum-utils device-mapper-persistent-data lvm2 
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum install -y docker-ce docker-ce-cli containerd.io


mkdir /etc/docker
cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": ["https://阿里云加速器URL"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "insecure-registries": ["https://hub.lbj.com"]
}
EOF

#####
这里算是个彩蛋吧，网址这里说一下 lbj的全称是Lebron James 本人20年老詹密 lbj一般是我的首选域名~
#####


systemctl start docker
systemctl enable docker

8 Installer le port

8.1 Télécharger et décompresser le fichier de configuration modifié

//上传 harbor-offline-installer-v1.2.2.tgz 和 docker-compose 文件到 /opt 目录
cd /opt
cp docker-compose /usr/local/bin/
chmod +x /usr/local/bin/docker-compose

tar zxvf harbor-offline-installer-v1.2.2.tgz
cd harbor/



vim harbor.cfg
5  hostname = hub.kgc.com
9  ui_url_protocol = https
24 ssl_cert = /data/cert/server.crt
25 ssl_cert_key = /data/cert/server.key
59 harbor_admin_password = Harbor12345

8.2 Générer un certificat

mkdir -p /data/cert
cd /data/cert
#生成私钥
openssl genrsa -des3 -out server.key 2048
输入两遍密码：123456

8.3 Générer un fichier de demande de signature de certificat

openssl req -new -key server.key -out server.csr
输入私钥密码：123456
输入国家名：CN
输入省名：BJ
输入市名：BJ
输入组织名：LBJ
输入机构名：LBJ
输入域名：hub.lbj.com
输入管理员邮箱：[email protected]
其它跳过 直接回车（两次）

8.4 Sauvegarder la clé privée

cp server.key server.key.org

8.5 Effacer le mot de passe de la clé privée

openssl rsa -in server.key.org -out server.key
输入私钥密码：123456

8.6 Certificat de signature

openssl x509 -req -days 1000 -in server.csr -signkey server.key -out server.crt

chmod +x /data/cert/*

cd /opt/harbor/
./install.sh

在本地使用火狐浏览器访问：https://hub.lbj.com
添加例外 -> 确认安全例外
用户名：admin
密码：Harbor12345

8.7 Connectez-vous au port sur un nœud

docker login -u admin -p Harbor12345 https://hub.lbj.com

8.9 Téléchargez l'image et testez-la

//上传镜像
docker tag nginx:latest hub.kgc.com/library/nginx:v1
docker push hub.kgc.com/library/nginx:v1

//在master节点上删除之前创建的nginx资源
kubectl delete deployment nginx

kubectl create deployment nginx-deployment --image=hub.lbj.com/library/nginx:v1 --port=80 --replicas=3

kubectl expose deployment nginx-deployment --port=30000 --target-port=80

kubectl get svc,pods
NAME                       TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)     AGE
service/kubernetes         ClusterIP   10.96.0.1       <none>        443/TCP     10m
service/nginx-deployment   ClusterIP   10.96.222.161   <none>        30000/TCP   3m15s

NAME                                    READY   STATUS    RESTARTS   AGE
pod/nginx-deployment-77bcbfbfdc-bv5bz   1/1     Running   0          16s
pod/nginx-deployment-77bcbfbfdc-fq8wr   1/1     Running   0          16s
pod/nginx-deployment-77bcbfbfdc-xrg45   1/1     Running   0          3m39s


yum install ipvsadm -y
ipvsadm -Ln

curl 10.96.222.161:30000


kubectl edit svc nginx-deployment
25   type: NodePort						#把调度策略改成NodePort

kubectl get svc
NAME                       TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)           AGE
service/kubernetes         ClusterIP   10.96.0.1       <none>        443/TCP           29m
service/nginx-deployment   NodePort    10.96.222.161   <none>        30000:32340/TCP   22m

浏览器访问：
192.168.181.100:32340
192.168.181.101:32340
192.168.181.102:32340


#将cluster-admin角色权限授予用户system:anonymous
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

10. Plan d'optimisation des paramètres du noyau

cat > /etc/sysctl.d/kubernetes.conf <<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
net.ipv4.tcp_tw_recycle=0
vm.swappiness=0									#禁止使用 swap 空间，只有当系统内存不足（OOM）时才允许使用它
vm.overcommit_memory=1							#不检查物理内存是否够用
vm.panic_on_oom=0								#开启 OOM
fs.inotify.max_user_instances=8192
fs.inotify.max_user_watches=1048576
fs.file-max=52706963							#指定最大文件句柄数
fs.nr_open=52706963								#仅4.4以上版本支持
net.ipv6.conf.all.disable_ipv6=1
net.netfilter.nf_conntrack_max=2310720
EOF

Onze résumés et revues de processus

1. Installez Docker et kubeadm sur tous les nœuds
2. Déployez Kubernetes Master
3. Déployez le plug-in de réseau de conteneurs
4. Déployez le nœud Kubernetes et ajoutez le nœud au cluster Kubernetes
5. Déployez la page Web du tableau de bord pour afficher visuellement les ressources Kubernetes
6. Déployez Harbor entrepôt privé, stocker les ressources miroir

(Merci d'avoir lu ~ Il y a des œufs de Pâques dans l'article, tout le monde est invité à interagir avec moi dans la zone de commentaires ~~)