Ventajas de la implementación en contenedores: Anteriormente, los proyectos se implementaban de manera común y no podían aislarse entre sí. Si la memoria de un proyecto se filtraba, el servidor no estaría disponible. La administración en contenedores de Docker evita esta situación, y k8s es equivalente. a la gestión en contenedores docker El ecosistema organiza todos los contenedores y gestiona automáticamente los servicios de contenedores
La función principal:
Detección de servidores y equilibrio de carga
Disposición de almacenamiento (cuando la memoria de la aplicación de servicio es administrada por k8s, cuando el servidor no está en uso, se limpiará automáticamente)
Despliegue y reversión automáticos, cálculo de empaquetado automático: si hay un problema con la aplicación, retroceda a la versión anterior y controle la memoria y el tamaño de la CPU que ocupa cada aplicación
Autorreparación: la aplicación en el servidor puede ser monitoreada.Si un servidor se cuelga, se colocará automáticamente en otras máquinas.
Introducción a los componentes de Kubernetes
Un clúster de kubernetes se compone principalmente de nodos de control (maestro) y nodos de trabajo (nodos), y se instalan diferentes componentes en cada nodo.
Nodo de control (maestro): El plano de control del clúster, responsable de la toma de decisiones del clúster.
Servidor API: el único punto de entrada para las operaciones del clúster, recibe comandos ingresados por los usuarios y proporciona mecanismos como autenticación, autorización, registro API y descubrimiento.
Programador: responsable de la programación de recursos del clúster y programa los pods para los nodos correspondientes de acuerdo con una política de programación predeterminada.
ControllerManager: responsable de mantener el estado del clúster, como arreglos de implementación de programas, detección de fallas, escalado automático y actualizaciones continuas.
Etcd: responsable de almacenar información sobre varios objetos de recursos en el clúster.
Worker node (nodo): El plano de datos del clúster, responsable de proporcionar el entorno de ejecución para el contenedor.
Kubelet: Encargado de mantener el ciclo de vida de los contenedores, es decir, mediante el control de Docker, para crear, actualizar y destruir contenedores.
KubeProxy: responsable de proporcionar detección de servicios y equilibrio de carga dentro del clúster.
Docker: Responsable de varias operaciones del contenedor en el nodo.
Flujo de trabajo de componentes
Implemente un servicio Nginx para ilustrar la relación de llamada de cada componente del sistema Kubernetes:
① En primer lugar, debe quedar claro que una vez que se inicie el entorno de Kubernetes, tanto el maestro como el nodo almacenarán su propia información en la base de datos etcd.
② Primero se enviará una solicitud de instalación para un servicio Nginx al componente API Server en el nodo principal.
③ El componente API Server llamará al componente Scheduler para decidir en qué nodo debe instalarse el servicio. En este punto, leerá la información de cada nodo de etcd, luego lo seleccionará de acuerdo con un determinado algoritmo e informará al servidor API del resultado.
④ API Server llama a Controller-Manager para llamar al nodo Node para instalar el servicio Nginx.
⑤ Después de que Kubelet reciba la instrucción, notificará a Docker y luego Docker iniciará un Nginx Pod. Un Pod es la unidad de operación más pequeña en Kubernetes, y un contenedor debe ejecutarse en un Pod.
⑥ Se está ejecutando un servicio Nginx. Si necesita acceder a Nginx, debe usar kube-proxy para acceder al Pod, de modo que los usuarios externos puedan acceder al servicio Nginx en el clúster.
otros nodos
Maestro: Nodo de control del clúster Cada clúster requiere al menos un nodo maestro que se encargue de la gestión y el control del clúster.
Nodo: nodo de carga de trabajo. El maestro asigna contenedores a estos nodos de trabajo del nodo, y luego el Docker en el nodo del nodo es responsable de la ejecución del contenedor.
Pod: La unidad de control más pequeña de Kubernetes. Los contenedores se ejecutan en Pods. Un Pod puede tener uno o más contenedores.
Controlador: el controlador a través del cual se realiza la gestión de Pods, como iniciar Pods, detener Pods, escalar la cantidad de Pods, etc.
Servicio: una entrada unificada para los servicios externos de Pod, bajo la cual se pueden mantener varios Pods de la misma clase.
Etiqueta: Etiqueta, utilizada para clasificar los Pods, el mismo tipo de Pod tendrá la misma etiqueta.
NameSpace: espacio de nombres utilizado para aislar el entorno de ejecución del Pod.
Creación de un entorno de clúster
Verifique la versión de la máquina virtual, preferiblemente 7.5 o superior
gato /etc/redhat-release
Configure la resolución del nombre de host para una fácil referencia
vim /etc/hosts
Agregar análisis
192.168.6.100 maestro
192.168.6.101 nodo1
192.168.6.102 nodo2
ping para ver si puedes ping
Sincronización de tiempo : Kubernetes requiere que el tiempo de nodo en el clúster sea preciso y consistente, así que agregue sincronización de tiempo en cada nodo
systemctl start chronyd
systemctl enable chronyd #boot
fecha de autoinicio #ver hora
El inicio de Docker generará reglas de iptables para evitar la confusión del sistema y debe cerrarse, y no es necesario procesar el sistema.
#Cerrar el firewall
systemctl detener firewalld
systemctl desactivar firewalld #Cerrar
el servicio de iptables
systemctl detener iptables
systemctl desactivar iptables #Desactivar
los servicios de seguridad de Linux para ver si selinux está habilitado
getenforce #Cerrar permanentemente
selinux, necesita reiniciar
vim /etc/selinux/config
SELINUX = deshabilitado #Cerrar
selinux temporalmente, después de reiniciar,
setenforce no válido 0
Cierre la partición de intercambio : partición de memoria virtual, después de que se agote la memoria física, encienda el disco y utilícelo como memoria virtual
vim /etc/fstab #Comenta
la última línea
#/dev/mapper/centos-swap swap swap defaults
Modifique los parámetros del kernel de Linux y cree archivos de configuración
vim /etc/sysctl.d/kubernetes.conf
# Pasar el tráfico IPv4 en puente a la cadena iptables
net.bridge.bridge-nf-call-ip6tables=1
net.bridge.bridge-nf-call-iptables=1
net.ipv4.ip_forward=1
recargar configuración
sysctl-p
Cargue el módulo de filtro puente
modprobe br_netfilter
Comprobar si está cargado
lsmod | agarre br_netfilter
Configurar la función ipvs
Hay dos modelos de proxy para el servicio en k8s, uno es iptables y el otro es ipvs, y ipvs tiene un mayor rendimiento.
Cargue manualmente el módulo ipvs
yum -y instalar ipset ipvsadm
Agregue el archivo de script correspondiente y escriba el contenido correspondiente
cat > /etc/sysconfig/modules/ipvs.modules <<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF
Agregar permiso de ejecución
chmod +x /etc/sysconfig/modules/ipvs.modules
Ejecutar el archivo, cargar el módulo
/bin/bash /etc/sysconfig/modules/ipvs.modules
Comprobar el éxito
lsmod | grep -e ipvs -e nf_conntrack_ipv4
En este punto, el entorno está configurado, reinicie reinicie
Instale Docker, kubeadm, kubelet y kubectl por nodo
instalar ventana acoplable
#Cambiar espejo
wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo #Install yum -y install
docker
-ce-18.06.3.ce-3.el7
Agregue archivos de configuración, docker usa cgroupfs de forma predeterminada, k8s recomienda usar systemd
mkdir /etc/docker
vim daemon.json #Ingrese
lo siguiente
{ "exec-opts":["native.cgroupdriver=systemd"], "registry-mirrors":["https://kn0t2bca.mirror.aliyuncs.com" ] }
desinstalar ventana acoplable
yum lista instalada|grep docker Ver la lista de instalación de docker
yum -y remove xxx Desinstalar el nombre detectado
systemctl habilitar docker auto-start
Instalar componentes k8s
cambiar la fuente del espejo
cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
nombre=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
habilitado=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.
EOF gpg
Instalar
yum install -y --setopt=obsoletos=0 kubeadm-1.17.4-0 kubelet-1.17.4-0 kubectl-1.17.4-0 -y
卸载
rpm -e kubelet-1.18.0 kubelet-1.18.0 kubelet- 1.18.0 --nodeps
Para que el controlador de cgroup utilizado por Docker sea coherente con el controlador de cgroup utilizado por kubelet, el contenido del archivo "/etc/sysconfig/kubelet"
# Cambiar a
KUBELET_EXTRA_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"
Autoencendido
systemctl habilitar kubelet
Configuración de clúster
Debido a que k8s es un sitio web extranjero, la descarga debe configurar el espejo y especificar la versión de descarga.
Ver la imagen deseada
lista de imágenes de configuración de kubeadm
Especificar una versión fija
imágenes = (
apiserver: v1.17.4
al controlador-administrador: v1.17.4
al planificador: v1.17.4
al proxy: v1.17.4
pausa: 3.1
etcd: 3.4.3-0
coredns: 1.6.5
)
recorrer las descargas
para imageName en ${imágenes[@]} ; docker
pull registration.cn-hangzhou.aliyuncs.com/google_containers/$imageName
docker tag registration.cn-hangzhou.aliyuncs.com/google_containers/$imageName k8s.gcr.io/$imageName
docker rmi registration.cn-hangzhou.aliyuncs .com/google_containers/$imageName
hecho
Compruebe si la imagen se ha descargado con éxito imágenes acoplables
Solo implemente el nodo maestro de k8s
kubeadm init \
--kubernetes-version v1.17.4 \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16 \
--apiserver-advertise-address=192.168.6.100
La línea de comando le indicará
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
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.6.101:6443 --token sv5epz.4f8hvj7ukjlrv857 \
--discovery-token-ca-cert-hash sha256:56bc77d7c4c95cc7aca777185e14274e4f99bc8d3b21da65d89ff19987e83554 Luego ingresa
mkdir -p $INICIO/.kube
cp -i /etc/kubernetes/admin.conf $INICIO/.kube/config
chown $(id -u):$(id -g) $INICIO/.kube/config
Entrar en otro servidor
kubeadm unirse a 192.168.6.101:6443 --token sv5epz.4f8hvj7ukjlrv857 \
--discovery-token-ca-cert-hash sha256:56bc77d7c4c95cc7aca777185e14274e4f99bc8d3b21da65d89ff19947e8355
Ver nodos
kubectl obtener nodos
Entonces, el nodo del nodo no se conecta después de la entrada, y la razón es que el nodo del nodo no se puede iniciar automáticamente. Debe copiar el archivo /etc/kubernetes/admin.conf del nodo maestro en el servidor del nodo del nodo.
Instale el complemento de red en el nodo maestro
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
Inicie la franela con el archivo de configuración
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
Vea el progreso de la implementación del complemento de red CNI:
kubectl obtener pods -n sistema kube
Comprobar el estado del clúster:
kubectl obtener cs