Despliegue de Kubernetes mediante archivos binarios

Configuración inicial del sistema operativo

Antes de instalar Kubernetes, es necesario preparar el entorno del sistema oeprativo. A continuación se detallan los pasos clave:

# Desactivar el firewall
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X

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

# Desactivar swap
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab 

# Establecer nombres de host según el plan
hostnamectl set-hostname control-plane-01
hostnamectl set-hostname worker-node-01
hostnamectl set-hostname worker-node-02

# Agregar entradas al archivo hosts en el nodo de control
cat >> /etc/hosts << EOF
10.0.1.10 control-plane-01
10.0.1.11 control-plane-02
10.0.1.20 worker-node-01
10.0.1.21 worker-node-02
EOF

# Ajustar parámetros del kernel
cat > /etc/sysctl.d/kube.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF

sysctl --system

# Sincronizar la hora
yum install ntpdate -y
ntpdate ntp.ubuntu.com

Implementación del motor de contenedores

En todos los nodos trabajadores, se instala Docker como motor de contenedores:

# Instalar dependencias y repositorio de Docker
yum install -y yum-utils device-mapper-persistent-data lvm2 
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum install -y docker-ce docker-ce-cli containerd.io

# Iniciar y habilitar Docker
systemctl start docker.service
systemctl enable docker.service

Despleigue del clúster etcd

etcd es un almacén de datos clave-valor distribuido y de alta disponibilidad, diseñado para configuraciones críticas. Utiliza el algoritmo Raft para el consenso y es esencial en Kubernetes. Ofrece características como simplicidad en su API HTTP, seguridad mediante TLS y rendimiento rápido con miles de operaciones por segundo. En producción, se recomienda un clúster impar de al menos tres nodos, usando los puertos 2379 para comunicación con clientes y 2380 para la comunicación entre pares.

Preparación del entorno para certificados

CFSSL es una herramienta de PKI/TLS de código abierto para generar y gestionar certificados. Soporta la creación de certificados de tipo cliente, servidor y par, que se utilizan para la autenticación segura en componentes como etcd y kube-apiserver. Primero, se descargan las herramientas necesarias:

# Descargar y configurar CFSSL en el nodo control-plane-01
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo

chmod +x /usr/local/bin/cfssl*

# Crear directorios y generar certificados para etcd
mkdir -p /kube-setup/etcd-certs
cd /kube-setup/etcd-certs

# Supongamos que se proporciona un script para generar certificados
chmod +x generate-etcd-certs.sh
./generate-etcd-certs.sh

# Los archivos generados incluyen certificados CA y de servidor
ls *pem

# Descargar binarios de etcd
cd /kube-setup
tar -zxvf etcd-v3.5.0-linux-amd64.tar.gz
mv etcd-v3.5.0-linux-amd64/etcd /usr/local/bin/
mv etcd-v3.5.0-linux-amd64/etcdctl /usr/local/bin/

# Preparar configuración y iniciar etcd
mkdir -p /etc/etcd/ssl
cp etcd-certs/*.pem /etc/etcd/ssl/

# Crear archivo de configuración para etcd
cat > /etc/etcd/etcd.conf << EOF
ETCD_NAME="etcd-node-1"
ETCD_DATA_DIR="/var/lib/etcd"
ETCD_LISTEN_CLIENT_URLS="https://10.0.1.10:2379"
ETCD_ADVERTISE_CLIENT_URLS="https://10.0.1.10:2379"
ETCD_LISTEN_PEER_URLS="https://10.0.1.10:2380"
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.0.1.10:2380"
ETCD_INITIAL_CLUSTER="etcd-node-1=https://10.0.1.10:2380,etcd-node-2=https://10.0.1.20:2380,etcd-node-3=https://10.0.1.21:2380"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

# Iniciar etcd (repetir para otros nodos con configuración adecuada)
systemctl start etcd
systemctl enable etcd

Despliegue de componentes del plano de control

Los componentes del plano de control incluyen kube-apiserver, kube-scheduler y kube-controller-manager. Se configuran con certificados y tokens para la autenticación. A continuación, los pasos para el nodo control-plane-01:

# Preparar directorios y descargar binarios de Kubernetes
mkdir -p /kubernetes/{bin,cfg,ssl,logs}
cd /kube-setup
tar -zxvf kubernetes-server-linux-amd64.tar.gz
cp kubernetes/server/bin/kube-apiserver /kubernetes/bin/
cp kubernetes/server/bin/kubectl /kubernetes/bin/
cp kubernetes/server/bin/kube-controller-manager /kubernetes/bin/
cp kubernetes/server/bin/kube-scheduler /kubernetes/bin/

# Generar token para bootstrapping
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
cat > /kubernetes/cfg/token.csv <<eof ajustados="" cat="" con="" eof="" iniciar="" kube-apiserver="" par=""> /etc/systemd/system/kube-apiserver.service << EOF
[Unit]
Description=Kubernetes API Server
After=network.target
[Service]
ExecStart=/kubernetes/bin/kube-apiserver \\
  --etcd-servers=https://10.0.1.10:2379,https://10.0.1.20:2379,https://10.0.1.21:2379 \\
  --bind-address=10.0.1.10 \\
  --secure-port=6443 \\
  --advertise-address=10.0.1.10 \\
  --client-ca-file=/kubernetes/ssl/ca.pem \\
  --tls-cert-file=/kubernetes/ssl/apiserver.pem \\
  --tls-private-key-file=/kubernetes/ssl/apiserver-key.pem \\
  --token-auth-file=/kubernetes/cfg/token.csv \\
  --service-cluster-ip-range=10.96.0.0/12 \\
  --allow-privileged=true
Restart=always
[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl start kube-apiserver
systemctl enable kube-apiserver

# Iniciar kube-scheduler y kube-controller-manager con configuración similar
# Luego, verificar el estado con kubectl
</eof>

Despliegue de nodos trabajadores

Los nodos trabajadores ejecutan kubelet y kube-proxy. Utilizan el mecanismo de TLS Bootstrapping para registrarse de forma segura en el plano de control. Después de la configuración inicial, se aprueban las solicitudes de certificados CSR desde el nodo de control:

# En nodos trabajadores, configurar kubelet y kube-proxy
# Copiar archivos de configuración desde el nodo de control
scp /kubernetes/cfg/bootstrap.kubeconfig worker-node-01:/kubernetes/cfg/
scp /kubernetes/cfg/kube-proxy.kubeconfig worker-node-01:/kubernetes/cfg/

# Iniciar kubelet
systemctl start kubelet
systemctl enable kubelet

# En el nodo de control, aprobar solicitudes CSR
kubectl get csr
kubectl certificate approve <nombre-csr>

# Cargar módulos IPVS y iniciar kube-proxy
modprobe ip_vs
systemctl start kube-proxy
systemctl enable kube-proxy

Despliegue de la red CNI

Para la comunicación entre pods, se puede elegir entre diferentes plugins CNI como Flannel o Calico. Flannel es más simple y usa overlay networks (por ejemplo, VXLAN), mientras que Calico ofrece más control con políticas de red basadas en BGP. La elección depende de los requisitos del clúster.

# Ejemplo de despliegue de Flannel
# En el nodo de control, aplicar manifiesto de Flannel
kubectl apply -f kube-flannel.yml

# Verificar pods de Flannel
kubectl get pods -n kube-system

# Opcionalmente, desplegar Calico en lugar de Flannel
# kubectl apply -f calico.yaml

Despliegue de CoreDNS

CoreDNS proporciona resolcuión DNS para servicios dentro del clúster. Se despliega como un servicio estándar de Kubernetes:

# En nodos trabajadores, cargar imágenes de CoreDNS
docker load -i coredns.tar

# En el nodo de control, desplegar CoreDNS
kubectl apply -f coredns.yaml

# Probar la resolución DNS
kubectl run -it --rm dns-test --image=busybox:1.28.4 --restart=Never -- nslookup kubernetes

Despliegue de balanceadores de carga

Para la alta disponibilidad del plano de control, se configuran balanceadores de carga con Nginx y Keepalived. Nginx actúa como proxy inverso para kube-apiserver, y Keepalived proporciona una IP virtual (VIP) para conmutación por error:

# En nodos de balanceo (por ejemplo, lb01 y lb02)
yum install nginx -y

# Configurar Nginx para balanceo de carga de kube-apiserver
cat > /etc/nginx/nginx.conf << EOF
stream {
    upstream k8s-api {
        server 10.0.1.10:6443;
        server 10.0.1.11:6443;
    }
    server {
        listen 6443;
        proxy_pass k8s-api;
    }
}
EOF

systemctl start nginx
systemctl enable nginx

# Instalar y configurar Keepalived para VIP
yum install keepalived -y
# Configurar archivo keepalived.conf con prioridades diferentes para lb01 y lb02
# Crear script para monitorear Nginx

systemctl start keepalived
systemctl enable keepalived

# Actualizar configuraciones de nodos trabajadores para apuntar a la VIP
# Por ejemplo, modificar kubeconfig para usar https://VIP:6443

Despliegue de Dashboard

Dashboard es una interfaz web para gestionar el clúster de Kubernetes. Se expone mediante un servicio NodePort para acceso externo:

# En el nodo de control, aplicar manifiesto de Dashboard
kubectl apply -f recommended.yaml

# Modificar el servicio para usar NodePort (por ejemplo, puerto 30001)
# Crear cuenta de servicio y vincular a rol cluster-admin
kubectl create serviceaccount dashboard-admin -n kube-system
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin

# Obtener token para iniciar sesión
kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

# Acceder a Dashboard en https://NodoIP:30001

Etiquetas: Kubernetes etcd CFSSL flannel calico

Publicado el 7-1 22:01

Friki Work

Despliegue de Kubernetes mediante archivos binarios

Etiquetas populares