Directorio de artículos

1. Inicio rápido de K8
2. Instalación del clúster K8s
3. Primeros pasos con el clúster de kubernetes

1. Inicio rápido de K8

1. Introducción

Kubernetes se conoce como k8s. es una plataforma de código abierto de implementación automatizada, portátil y extensible para administrar cargas de trabajo y servicios en contenedores que facilita la configuración declarativa y la automatización. Kubernetes tiene un ecosistema grande y de rápido crecimiento. Los servicios, el soporte y las herramientas de Kubernetes están ampliamente disponibles.

Sitio web oficial chino: https://kubernetes.io/Zh/Comunidad china: https://www.kubernetes.org.cn/Documento oficial : https://kubernetes.io/zh/docs/home/Documento
de la comunidad : https : //docs.kubernetes.org.cn/

La evolución de los métodos de implementación:

inserte la descripción de la imagen aquí
Para obtener más información, visite la documentación oficial: https://kubernetes.io/zh/docs/concepts/overview/what-is-kubernetes/

2. Arquitectura

Documentación: https://kubernetes.io/en/docs/concepts/overview/components/

inserte la descripción de la imagen aquí

1) arquitectura de nodo maestro

kube-apiserver
- La interfaz API de k8s está expuesta al mundo exterior, que es la única entrada al mundo exterior para las operaciones de recursos.
- Proporciona mecanismos de autenticación, autorización, control de acceso, registro y descubrimiento de API
etcd
- etcdEs una base de datos clave-valor con coherencia y alta disponibilidad, y se puede utilizar como base de datos de fondo para guardar todos los datos del clúster de Kubernetes.
- La base de datos etcd de un clúster de Kubernetes generalmente requiere un plan de respaldo.
kube-scheduler
- Un componente en el nodo maestro responsable de monitorear los Pods recién creados que no especifican un nodo en ejecución (nodo) y seleccionar nodos para ejecutar Pods.
- Todas las operaciones del clúster k8s deben ser programadas por el nodo maestro
kube-controller-manager: el componente que ejecuta el proceso del controlador en el nodo maestro

Estos controladores incluyen:
- Controlador de nodo: responsable de notificar y responder a las fallas de los nodos
- Controlador de trabajo: supervisa los objetos de trabajo que representan trabajos únicos y luego crea pods para ejecutar esos trabajos hasta que finalicen.
- Controlador de puntos finales: complete el objeto Puntos finales (es decir, agregue Servicio y Pod)
- Controladores de tokens y cuentas de servicio: cree cuentas predeterminadas y tokens de acceso a la API para nuevos espacios de nombres

2) Arquitectura de nodo de nodo

kubelet
- Un agente que se ejecuta en todos los nodos del clúster. Se asegura de que los contenedores (contenedores) se estén ejecutando en Pods. El kubelet recibe un conjunto de PodSpecs que se le proporciona a través de varios mecanismos, lo que garantiza que los contenedores descritos en estas PodSpecs estén funcionando y en buen estado. El kubelet no administrará contenedores no creados por Kubernetes.
- Responsable del ciclo de vida de las ventanas de mantenimiento, y también responsable de la gestión de volumen (CSI) y red (CIN)
kube-proxy
- kube-proxy es un proxy de red que se ejecuta en todos los nodos del clúster e implementa parte del concepto de servicio de Kubernetes.
- kube-proxy mantiene reglas de red en los nodos. Estas reglas de red permiten la comunicación de red con pods desde sesiones de red dentro o fuera del clúster.
Tiempo de ejecución del contenedor
- Un tiempo de ejecución de contenedor es el software responsable de ejecutar contenedores.
- Kubernetes admite múltiples tiempos de ejecución de contenedores: Docker, containerd, CRI-O y cualquier implementación que implemente Kubernetes CRI (Container Runtime Interface).
fluido
- es un demonio que ayuda a proporcionar registros a nivel de clúster

3. Concepto

inserte la descripción de la imagen aquí

Container: contenedor, que puede ser un contenedor iniciado por docker
Pod：
- k8s usa Pod para organizar un conjunto de contenedores
- Todos los contenedores en un Pod comparten la misma red.
- Pod es la unidad de implementación más pequeña en k8s
Volume：
- Declarar directorios de archivos accesibles en el contenedor Pod
- Se puede montar bajo la ruta especificada de uno o más contenedores en el Pod
- Admite múltiples abstracciones de almacenamiento de back-end (almacenamiento local, almacenamiento distribuido, almacenamiento en la nube)
Controllers: objetos de nivel superior, implementación y gestión de Pods;
- ReplicaSet: Asegurar la cantidad esperada de réplicas de Pod
- Implementación: implementación de aplicaciones sin estado
- StatefulSet: implementación de aplicaciones con estado, como Mysql
- DaemonSet: asegúrese de que todos los nodos estén ejecutando un pod específico
- Trabajo: tarea de una sola vez
- Cronjob: Tareas programadas
Deployment：
- .Define el número de réplicas, versiones, etc. de un conjunto de Pods
- Mantener la cantidad de pods a través del controlador (recuperación automática de pods fallidos)
- Controle las versiones (actualizaciones continuas, reversiones, etc.) a través del controlador con una política específica
Service
- Definir una política de acceso para un conjunto de Pods
- Balanceo de carga de Pods, proporcionando direcciones de acceso estables para uno o más Pods
- Admite múltiples métodos (ClusterlP, NodePort, LoadBalance)
Label: etiquetas, utilizadas para consultar y filtrar recursos de objetos
Namespace: espacio de nombres, aislamiento lógico
- Un mecanismo de aislamiento lógico dentro de un clúster (autenticación. recursos)
- Cada recurso pertenece a un espacio de nombres
- No se pueden repetir todos los nombres de recursos en el mismo espacio de nombres
- Diferentes espacios de nombres pueden tener nombres de recursos duplicados
API: Operamos todo el clúster a través de la API de kubernetes.
- Finalmente, puede enviar solicitudes http+json/yaml al servidor API a través de kubectl, ui y curl, y luego controlar el clúster k8s.Todos los objetos de recursos en k8s se yamlpueden JSONdefinir o describir en archivos en formato o

2. Instalación del clúster K8s

1. Requisitos previos

Prepara una o varias máquinas con el sistema operativo Centos7.x-86_x64. Mi configuración es 3 Centos7
Configuración de hardware: 2 GB o más de RAM, 2 CPU o más, disco duro de 30 GB o más. Mi configuración 2 core 2G 64G
Interconexión de red entre todas las máquinas del clúster
Puede acceder a la red externa, necesita tirar del espejo

2. Configure el entorno Linux (todos los nodos se ejecutan)

desactivar el cortafuegos

systemctl stop firewalld
systemctl disable firewalld

cerrar selinux

sed -i 's/enforcing/disabled/' /etc/selinux/config
setenforce 0

cerrar intercambio

swapoff -a #临时关闭
sed -ri 's/.*swap.*/#&/' /etc/fstab #永久关闭
free -g #验证，swap必须为0

Agregue la correspondencia entre el nombre de host y la IP:

Compruebe el nombre de host:
```
hostname
```
Si el nombre de host es incorrecto, se puede especificar uno nuevo mediante el hostnamectl set-hostname <newhostname>comando hostname. Mis tres nombres de nodo: k8s-node1, k8s-node2, k8s-node3

Configurado en tres máquinas /etc/hostspara que puedan hostnameacceder entre sí a través de
```
vim /etc/hosts
10.211.55.19 k8s-node1	# 这里的IP要修改成hostname对应节点的IP
10.211.55.21 k8s-node2
10.211.55.20 k8s-node3
```

Cadena para pasar tráfico IPv4 en puente a iptables:

cat > /etc/sysctl.d/k8s.conf <<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

Aplicar las reglas:

sysctl --system

dateVer hora (opcional)

yum -y install ntpupdate
ntpupdate time.window.com #同步最新时间

3. Instale docker, kubeadm, kubelet, kubectl en todos los nodos

El CRI (tiempo de ejecución del contenedor) predeterminado de Kubenetes es Docker, así que instale Docker primero.

1) Instalar ventana acoplable

Desinstalar la ventana acoplable anterior

$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

Instalar Docker-CE

$ sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# 设置 docker repo 的 yum 位置
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
    
$ sudo yum -y install docker-ce docker-ce-cli containerd.io

Después de configurar la aceleración de imágenes
registry-mirrors, use su propia dirección de aceleración de imágenes, que se puede obtener de Alibaba Cloud Image Accelerator

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
	"exec-opts": ["native.cgroupdriver=systemd"],
	"log-driver": "json-file",
	"log-opts": {
		"max-size": "100m" 
	},
  	"registry-mirrors": ["https://r1fl0qlt.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

Inicie Docker y configure Docker para que se inicie en el arranque
```
sudo systemctl enable docker
```

2) Agregar fuentes de Ali y Yum

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

3) Instale kubeadm, kubelet y kubectl

Instalar en pc

yum install -y kubelet-1.17.3 kubeadm-1.17.3 kubectl-1.17.3

bota

systemctl enable kubelet && systemctl start kubelet

Compruebe el estado del kubelet:

systemctl status kubelet

Compruebe la versión de kubelet:

> kubelet --version
Kubernetes v1.17.3

4) Implementar k8s-maestro

(1) Inicialización del nodo maestro

Para inicializar kubeadm, el siguiente comando descargará la imagen del componente k8s:

$ kubeadm init \
--apiserver-advertise-address=10.211.55.19 \
--image-repository registry.cn-hangzhou.aliyuncs.com/google_containers \
--kubernetes-version v1.17.3 \
--service-cidr=10.96.0.0/16  \
--pod-network-cidr=10.244.0.0/16

Descripción de parámetros:

--apiserver-advertise-address: La dirección IP aquí debe cambiarse a la dirección de su propio masterservidor , yo uso la primera de las tres máquinas k8s-node1;
--kubernetes-version: Configure la versión instalada por usted mismo, que es la misma que la versión en el kubeadmpaso , kubelet --versionverifique la versión

Aviso: Si se informa un error al ejecutar el comando de inicialización anterior, antes de ejecutar el comando de inicialización la próxima vez, ejecute elkubeadm reset -f

Resultado de la ejecución:
si ve la siguiente página, la inicialización es exitosa
inserte la descripción de la imagen aquí

Después de inicializar el nodo, ejecute estos tres comandos de acuerdo con las indicaciones del registro:

# 这个目录会保存连接配置
mkdir -p $HOME/.kube

# 认证文件保存到这个目录下
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

(2) Instalar franela

Instale el complemento de red CNI, instálelo aquíflannel

Crear un directorio de franela,

Descargue el archivo yml:
```
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
```
Si la URL anterior no se puede descargar, vaya a Code Cloud Flannel y copie o descargue el archivo yml
crear franela
```
kubectl create -f kube-flannel.yml
```

Compruebe si se ejecuta correctamente y
puede ver que se kube-flannelestá ejecutando:

[root@k8s-node1 flannel]# kubectl get pods --all-namespaces
NAMESPACE     NAME                                READY   STATUS    RESTARTS   AGE
kube-system   coredns-7d89d9b6b8-bjmsp            1/1     Running   0          36m
kube-system   coredns-7d89d9b6b8-z46zp            1/1     Running   0          36m
kube-system   etcd-k8s-node1                      1/1     Running   1          37m
kube-system   kube-apiserver-k8s-node1            1/1     Running   1          37m
kube-system   kube-controller-manager-k8s-node1   1/1     Running   1          37m
kube-system   kube-flannel-ds-srf9w               1/1     Running   0          65s
kube-system   kube-proxy-n64fp                    1/1     Running   0          36m
kube-system   kube-scheduler-k8s-node1            1/1     Running   1          37m

5) Agregar nodo esclavo

Ver todos los nodos (nodo principal en ejecución)

#获取所有节点
$ kubectl get nodes
NAME        STATUS   ROLES                  AGE   VERSION
k8s-node1   Ready    control-plane,master   40m   v1.22.2

Obtener el comando de unión de nodos Node

$ kubeadm token create --print-join-command
kubeadm join 10.37.132.5:6443 --token yzd8bg.mzdp8ua5cyuggpdp --discovery-token-ca-cert-hash sha256:71216e7189e48bfedac9fce79c9dd6920b3354ff62023e7ea069848fa84a3861

Ejecutando el comando de salida en el nodo esclavo

$ kubeadm join 10.37.132.5:6443 --token yzd8bg.mzdp8ua5cyuggpdp --discovery-token-ca-cert-hash sha256:71216e7189e48bfedac9fce79c9dd6920b3354ff62023e7ea069848fa84a3861

Ver el estado del nodo

$ kubectl get nodes
NAME        STATUS   ROLES                  AGE     VERSION
k8s-node1   Ready    control-plane,master   68m     v1.22.2
k8s-node2   Ready    <none>                 4m16s   v1.22.2
k8s-node3   Ready    <none>                 4m12s   v1.22.2

$ journalctl -u kubelet #查看kubelet日志

Supervisar el progreso del pod

watch kubectl get pod -n kube-system -o wide

Después de que todos los estados se ejecuten, verifique la información del nodo nuevamente:

[root@k8s-node1 ~]#  kubectl get nodes;                         NAME        STATUS   ROLES    AGE     VERSIONk8s-node1   Ready    master   3h50m   v1.17.3k8s-node2   Ready    <none>   3h3m    v1.17.3k8s-node3   Ready    <none>   3h3m    v1.17.3[root@k8s-node1 ~]#

3. Primeros pasos con el clúster de kubernetes

1. Implementar un tomcat en k8s

kubectl create deployment tomcat6 --image=tomcat:6.0.53-jre8

Otros comandos:

# 获取所有的资源
$ kubectl get all

# 获取所有资源的详细信息
$ kubectl get all -o wide

# 获取 pods 的信息
kubectl get pods

2. Exponer el puerto al exterior

ejecutar en maestro

kubectl expose deployment tomcat6 --port=80 --target-port=8080 --type=NodePort

--port=80: mapeo del puerto 80 en el pod; el servidor traerá el 80 del pod
--target-port=8080: puerto 8080 en el contenedor, que se asignará al 80 en el pod
--type=NodePort: Un tipo de Servicio, que vincula un puerto en cada máquina para el Servicio, de modo que se NodeIp:NodePortpueda

Vea el servicio, acceda k8s-node1:30916(30916 es asignado automáticamente por el servicio, puerto 30916 del servidor, puerto 80 en el pod de mapeo), puede acceder a Tomcat:

# 查看 service 的信息
$ kubectl get svc
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP        91m
tomcat6      NodePort    10.96.96.4   <none>        80:30916/TCP   12s

3. Prueba de expansión dinámica

# 查看deployment，只有一个副本
$ kubectl get deployment
NAME      READY   UP-TO-DATE   AVAILABLE   AGE
tomcat6   1/1     1            1           8m44s

# 扩容成3个副本
$ kubectl scale --replicas=3 deployment tomcat6
deployment.apps/tomcat6 scaled

# 可以看到正在扩容中
$ kubectl get deployment
NAME      READY   UP-TO-DATE   AVAILABLE   AGE
tomcat6   2/3     3            2           9m35s

4. Eliminar

$ kubectl get deployment
NAME      READY   UP-TO-DATE   AVAILABLE   AGE
tomcat6   3/3     3            3           12m

$ kubectl delete deployment tomcat6
deployment.apps "tomcat6" deleted

$ kubectl get svc
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP        91m
tomcat6      NodePort    10.96.96.4   <none>        80:30916/TCP   12s

$ kubectl delete service tomcat6
service "tomcat6" deleted

5. Formatea el yaml de salida

# 打印前面部署 Tomcat 时使用的命令对应的 yaml
$ kubectl create deployment tomcat6 --image=tomcat:6.0.53-jre8 --dry-run='client' -o=yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: tomcat6
  name: tomcat6
spec:
  replicas: 1
  selector:
    matchLabels:
      app: tomcat6
  strategy: {
    
    }
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: tomcat6
    spec:
      containers:
      - image: tomcat:6.0.53-jre8
        name: tomcat
        resources: {
    
    }
status: {
    
    }

--dry-run: El valor debe ser none(predeterminado) servero client. Si es una clientpolítica , simplemente imprima el objeto de envío, pero no lo envíe. Si es una serverpolítica , envíe la solicitud del lado del servidor sin conservar el recurso.
-o: El formato de salida, que puede ser json, yaml, wideetc.

6. Implementar Tomcat usando yaml

Use lo que se imprimió en el paso anterior yaml, elimine algunas configuraciones inútiles, replicascambie a , use la plataforma de implementación 3de yamlarchivos3Tomcat

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: tomcat6
  name: tomcat6
spec:
  replicas: 3
  selector:
    matchLabels:
      app: tomcat6
  template:
    metadata:
      labels:
        app: tomcat6
    spec:
      containers:
      - image: tomcat:6.0.53-jre8
        name: tomcat

Guarde el yaml anterior en un archivotomcat6.yaml

$ kubectl apply -f tomcat6.yaml

apply: Indica para crear o actualizar un recurso, eliminarlo condelete
-f: especifica el archivo yaml especificado

Ver el yaml del pod:

# 查看 pod
$ kubectl get pods
NAME                       READY   STATUS    RESTARTS   AGE
tomcat6-56fcc999cb-b4nt7   1/1     Running   0          2m49s
tomcat6-56fcc999cb-pncn9   1/1     Running   0          2m49s
tomcat6-56fcc999cb-wczpj   1/1     Running   0          2m49s

# 查看 pod 的 yaml
$ kubectl get pods tomcat6-56fcc999cb-b4nt7 -o yaml

Eliminar el Tomcat yamlcreado con
```
$ kubectl delete -f tomcat6.yaml
```

7. Algunos documentos oficiales

1) documentación de la operación de kubectl

https://kubernetes.io/zh/docs/reference/kubectl/overview/

2) Tipo de recurso

https://kubernetes.io/zh/docs/reference/kubectl/overview/#%e8%b5%84%e6%ba%90%e7%b1%bb%e5%9e%8b

Instalación de K8S, inicio rápido