Centos construye el entorno k8s

---

Prefacio

Este artículo explica cómo construir un entorno k8s en centos. El contenido principal incluye tres partes: entorno acoplable, construcción del almacén de imágenes privadas de Docker y construcción del entorno k8s.

---

1. Preparación ambiental

1.1 Requisitos de instalación

La implementación de un clúster k8s requiere las siguientes condiciones:

• Al menos tres servidores, utilizando sistema operativo versión Centos7.
• La memoria es mayor o igual a 2G, la CPU es mayor o igual a 2 núcleos y el disco duro es mayor o igual a 30G.
• Es necesario descargar la imagen, por lo que la red externa debe ser accesible.
• Deshabilite las particiones de intercambio.

1.2 Preparar el medio ambiente

1. El servidor Centos7.9 recién instalado necesita configurar una red estática:
   abra el archivo de configuración de red:

cd /etc/sysconfig/network-scripts/

Agregue el siguiente contenido, donde BOOTPROTO="static" indica una red estática, y NOMBRE y DISPOSITIVO se 如果没有驱动需要手动安装pueden completar con el controlador de la tarjeta de red; agregue IP, máscara de subred, puerta de enlace, DNS y otro contenido a continuación.

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="enp8s0"
DEVICE="enp8s0"
ONBOOT="yes"
IPADDR="192.168.1.180"
NETMASK="255.255.255.0"
GATEWAY="192.168.1.1"
DNS1="192.168.1.1"

2. Dado que antes ya había tres nombres de host de servidor master, node1 y node2, los tres servidores instalados esta vez son node3, node4 y node5.

Role	nombre	IP
nodo maestro	nodo3	192.168.1.180
Nodo hijo 1	nodo4	192.168.1.181
Nodo hijo 2	nodo5	192.168.1.182

3. Inicialice en el sistema operativo centos7.9 recién construido:

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

#关闭swap
sed -ri 's/.*swap.*/#&/' /etc/fstab

# 三台服务器设置主机名
hostnamectl set-hostname <hostname>

#三台服务器添加hosts
192.168.1.180 node3
192.168.1.181 node4
192.168.1.182 node5

1. Entorno acoplable

Docker es un método de virtualización más nuevo que utiliza tecnología de contenedores para compartir recursos de hardware y sistemas operativos con el host para lograr una asignación dinámica de recursos y ejecutar aplicaciones en recursos aislados. Un contenedor contiene una aplicación y todos sus paquetes dependientes, y todos los contenedores comparten el núcleo del sistema operativo. El uso de contenedores Docker garantiza que las aplicaciones se implementen de manera rápida, confiable y consistente, independientemente del entorno de implementación.

1.1 Instalación de Docker

El contenedor utilizado por k8s es Docker y primero es necesario instalar el entorno Docker.

# 安装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

# 检查Docker是否安装成功
docker --version

# 启动并设置Docker开机自启动
systemctl enable docker && systemctl start docker

# 添加Docker阿里云镜像仓库
cat > /etc/docker/daemon.json << EOF
{
"registry-mirrors": ["https://xigtegnc.mirror.aliyuncs.com"]
}
EOF

1.2 Almacén de imágenes privado de Docker

El almacén de imágenes privadas de Docker se completa utilizando el registro proporcionado oficialmente

# 拉取registry镜像
docker pull registry

# 启动registry镜像，确定启动方式、是否重启、以及挂载目录、容器名字
docker run -itd -p 5000:5000 --restart always -v /opt/data/registry/:/var/lib/registry --name registry registry

# 验证是否搭建成功，浏览器打开网址：http://IP:port/v2/_catalog，成功说明镜像仓库搭建成功。
http://192.168.1.180:5000/v2/_catalog

# 将镜像发布到仓库中
# 1、docker tag命令给镜像打标签：docker tag imageName:version: IP:Port/tagedImageName:tagedVersion
docker tag nginx:latest 192.168.1.180:5000/mynginx:1.0
# 2、将镜像推送至仓库：docker push IP:Port/tagedImageName:tagedVersion
docker push 192.168.1.180:5000/mynginx:1.0
# 3、验证私有仓库是否已经存在该镜像：http://IP:port/v2/_catalog
http://192.168.1.180:5000/v2/_catalog
# 4、从私有仓库拉取镜像：docker pull IP:Port/tagedImageName:tagedVersion

Al publicar imágenes de otros servidores en almacenes privados de Docker, se informa un error: el servidor dio una respuesta HTTP al cliente HTTPS Solución: Configure registros inseguros en el servidor que envía la imagen.

vim /etc/docker/daemon.json

# 添加insecure-registries
{
    
    
"registry-mirrors": ["https://xigtegnc.mirror.aliyuncs.com"],
"insecure-registries": ["192.168.1.180:5000","http://47.104.139.172:5000"]
}

Al extraer una imagen de un repositorio privado, si la versión de Docker es mayor o igual a 1.3.x, habrá un error que indicará que no se puede establecer la conexión. Motivo: después de Docker 1.3.x, el modo predeterminado de interacción del registro de Docker es HTTPS, pero el almacén privado construido usa el servicio HTTP de forma predeterminada. La solución es agregar registro inseguro en el docker.service del servidor donde está la imagen privada. situado:

vi /usr/lib/systemd/system/docker.service
# 找到ExecStart位置，在后面加上  --insecure-registry IP:Port
ExecStart=/usr/bin/dockerd --insecure-registry 192.168.1.180:5000
# 重启服务
systemctl daemon-reload     
systemctl restart docker

En este punto, se han completado el entorno Docker, el entorno de imagen privada de Docker, empujar la imagen a la imagen privada y extraer el contenido de la imagen de la imagen privada. El siguiente paso es implementar el entorno k8s.

2. Implementación del entorno K8S

1. Agregue la fuente del software Alibaba Cloud YUM para acelerar la descarga.

# 添加阿里云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

2. Instalar kubeadm, kubectl y kubelet

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

3. Inicialización del clúster, ejecutada en el maestro.

kubeadm init \
  --apiserver-advertise-address=192.168.1.180 \
  --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

4. Utilice la herramienta kubectl para ejecutar en el maestro

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
# 查看集群所有nodes
kubectl get nodes

5. Agregue un nodo al clúster k8s.
   Ejecute el siguiente comando en el nodo. Debe copiar el comando real generado por la operación del nodo maestro anterior.

kubeadm join 192.168.1.11:6443 --token esce21.q6hetwm8si29qxwn \
    --discovery-token-ca-cert-hash sha256:00603a05805807501d7181c3d60b478788408cfe6cedefedb1f97569708be9c5

6. Implementar el complemento de red CNI

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
# 查看是否部署成功
kubectl get pods -n kube-system

7. Instalar NFS

# 在选定的NFS服务器上执行
yum install nfs-utils -y
# 设置共享目录
/usr/project/data/nfs
# 将共享目录以读写权限暴露给需要使用该NFS的主机
vim /etc/exports
# 加入以下内容
/usr/project/data/nfs 192.168.1.0/24(rw,no_root_squash,no_all_squash,sync)
# 启动NFS服务
systemctl restart nfs

8. Pruebe el clúster k8s.
   Cree un pod nginx en el clúster k8s para su verificación.

kubectl create deployment nginx --image=nginx
kubectl expose deployment nginx --port=80 --type=NodePort
kubectl get pod,svc
# 可通过 http: //NodeIP:Port形式访问

3. Comandos de uso común de Docker

# docker系统操作
# 启动、关闭、重启docker
systemctl start docker
systemctl stop docker
systemctl restart docker
# 设置docker开机自启动
systemctl enable docker
# 查看docker信息
docker version
docker info

# 镜像
# 从镜像仓库拉取镜像
docker pull IP:Port/imageName:imageTag
docker pull 192.168.1.180:5000/aengus/flow:v1.0
# 如果不使用IP:Port,默认从docker官方仓库拉取
docker pull nginx
# 查看所有镜像
docker images
# 删除镜像（不被任何容器使用方可删除）
docker rmi imageName
# 强制删除镜像
docker image rm imageName
# 使用Dockerfile制作镜像
docker build -t imageName:imageTag .
# 为镜像打标签
docker tag imageName:imageTag IP:Port/tagedImageName:tagedImageTag
# 向私有仓库推送镜像
docker push IP:Port/tagedImageName:tagedImageTag

# 容器
# 查看正在运行的容器
docker ps
# 查看所有容器
docker ps -a
# 进入容器（只能进入正在运行的容器，-it后面跟容器id）
docker exec -it b648cde72e9c /bin/bash
# 如果上条命令不能进入，可以尝试
docker exec -it b648cde72e9c /bin/sh
# 查看容器日志
docker logs -f containerId
# 启动容器
docker run -itd -p 5000:5000 --restart always -v /opt/data/registry/:/var/lib/registry --name registry registry 
# -i： 以交互模式运行容器； -t： 为容器重新分配一个伪输入终端 -it通常连用。 -d：后台运行容器； -p：指定端口映射 宿主机端口:容器端口； --restart always：在容器退出时总是重启； -v:目录映射 宿主机目录:容器目录； --name：容器名字 最后的registry指定使用的镜像为registry
# 停止容器
docker stop containerId
# 删除容器
docker rm -f containerId
# 启动容器
docker start containerId
# 重启容器
docker restart containerId
#  删除异常停止的容器
docker rm `docker ps -a | grep Exited | awk '{print $1}'`
# 清除所有无容器使用的镜像和容器，包括容器临时停止。此命令会删除无用容器，再删除无用镜像，需慎用
docker system prune -a

4. Comandos comunes de K8S

# 查看命名空间
kubectl get ns
# 创建命名空间
kubectl create namespace heu

# kubectl语法
kubectl [command] [TYPE] [NAME] [flags]
# command：指定要在资源上执行的操作例如create、get、describe、delete、apply等； type：指定资源类型（pod、node、services、deployment）； name： 指定资源名称； flags：可选参数，例如使用-n指定命名空间

# 以下命令均为操作某一命名空间下的资源
# 查看资源命令 get
# 查看指定命名空间下的pod
kubectl get pod -n heu
# 查看指定命名空间下的deployment
kubectl get deployment-n heu
# 查看指定命名空间下的service
kubectl get service -n heu
# 查看指定命名空间下的configMap
kubectl get configmap -n heu
# 查看指定命名空间下的secret
kubectl get secret -n heu

# 查看资源详细信息 describe
kubectl describe pod mynginx -n heu  #查看pod的具体运行情况
kubectl describe deployment mynginx -n heu   #了解deployment的详细信息
kubectl describe replicaset mynginx -n heu  #了解replicaset的详细信息
kubectl describe secret mynginx -n heu    #查看secret信息
kubectl describe configmap mynginx -n heu  #查看configmap信息

# 通过配置文件部署资源
kubectl apply -f gateway.yaml
# 查看pod日志：
kubectl logs podId -n heu
# 进入容器
kubectl exec -it podId -n heu /bin/bash
# 缩放副本数量
kubectl scale deployment mynginx --replicas=2

# 删除资源 delete 
kubectl delete podmynginx -n heu # 单纯删除pod可能无法删除，原因是deployment会维持重复数量
kubectl delete deployment mynginx -n heu
kubectl delete service mynginx -n heu
kubectl delete configmap mynginx -n heu
# 删除所有
kubectl delete deployment --all -n heu
kubectl delete service --all -n heu
kubectl delete configmap --all -n heu

---

Resumir

El artículo describe la construcción del entorno K8s, brinda los pasos para construir Docker, el almacén Docker y el entorno k8s, y brinda errores y soluciones comunes.