Baremetal Local Multi Master Multi ETCD

Este proyecto es una actualización del proyecto multi master para aumentar la complejidad y alta disponibilidad de nuestro kubernetes local colocando ETCD como un servicio externo al clúster.

Los requisitos necesarios:

• vagrant

sudo apt-get install vagrant

• virtualbox

sudo apt-get install virtualbox

En versiones más recientes de VirtualBox, necesité modificar la configuración para liberar el rango de IPs.

sudo mkdir /etc/vbox
sudo echo "* 10.0.0.0/8 192.168.0.0/16" >> /etc/vbox/networks.conf
sudo echo "* 2001::/64" >> /etc/vbox/networks.conf

La topología propuesta aquí sigue el siguiente proyecto de Kubernetes. https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/ha-topology/

Consulta sobre etcd en https://etcd.io

Observa que el clúster ETCD no posee conexión con el load balancer y la comunicación con los masters es directa. Solamente los masters se comunican con etcd a través del apiserver.

https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/ha-topology/

Para la comunicación entre los nodos del clúster, el puerto utilizado es el 2380. Para la comunicación de los nodos con los masters el puerto es el 2379.

Para esta instalación vamos a configurar 3 nodos masters, 2 nodos workers, 2 load balancers y 3 VMs para formar nuestro clúster ETCD.

El foco de la explicación aquí será sobre el clúster ETCD. Para entender la parte multi master consulta el proyecto MultiMaster.

Generar certificado TLS

Es necesario generar un certificado TLS para que los masters se comuniquen con el clúster etcd de forma cifrada. ¿Es posible ejecutar sin el certificado? sí, pero vamos a hacer las cosas de forma correcta para aprender.

El primer paso es crear los certificados localmente para que estos archivos estén disponibles durante la creación de nuestro entorno completo.

wget -q --show-progress \
  https://storage.googleapis.com/kubernetes-the-hard-way/cfssl/1.4.1/linux/cfssl \
  https://storage.googleapis.com/kubernetes-the-hard-way/cfssl/1.4.1/linux/cfssljson

chmod +x cfssl cfssljson
sudo mv cfssl cfssljson /usr/local/bin/

Ahora que ya tenemos los binarios vamos a crear nuestra Autoridad Certificadora (CA).

La carpeta certs contiene el certificado que ya creé antes, pero para generar uno nuevo borra la carpeta certs y crea una nueva en su lugar.

rm -rf certs
mkdir certs
cd certs

El comando abajo crea la CA basada en el JSON especificado

cat > ca-config.json <<EOF
{
    "signing": {
        "default": {
            "expiry": "8760h"
        },
        "profiles": {
            "etcd": {
                "expiry": "8760h",
                "usages": ["signing","key encipherment","server auth","client auth"]
            }
        }
    }
}
EOF

cat > ca-csr.json <<EOF
{
  "CN": "etcd cluster",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "BR",
      "L": "Vila Velha",
      "O": "Kubernetes",
      "OU": "ETCD-CA",
      "ST": "Espirito Santo"
    }
  ]
}
EOF

cfssl gencert -initca ca-csr.json | cfssljson -bare ca

Ahora vamos a crear un certificado TLS. Este certificado se está creando para las IPs de las máquinas etcd que están declaradas en el vagrantfile, si modificas algo allí necesitarás modificar aquí también.

ETCD1_IP="10.10.10.231"
ETCD2_IP="10.10.10.232"
ETCD3_IP="10.10.10.233"

cat > etcd-csr.json <<EOF
{
  "CN": "etcd",
  "hosts": [
    "localhost",
    "127.0.0.1",
    "${ETCD1_IP}",
    "${ETCD2_IP}",
    "${ETCD3_IP}"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "BR",
      "L": "Vila Velha",
      "O": "Kubernetes",
      "OU": "ETCD-CA",
      "ST": "Brazil"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=etcd etcd-csr.json | cfssljson -bare etcd

Ahora ya tenemos todos los certificados. Estos certificados serán copiados a través de scripts dentro de las instancias de los masters y etcds

El archivo Vagrantfile contiene la configuración de las máquinas y las llamadas de los scripts necesarios para la instalación.

Explicando el Vagrantfile

Primer paso es crear el clúster etcd para cuando se haga el init del clúster ya apuntar hacia él. Segundo paso es levantar el load balancer pues es el enlace entre el master y los workers, será necesario durante el init. Tercer paso es crear los masters siendo que master1 hará el init del clúster y los demás harán un join. Cuarto paso es crear los workers y hacer el join dentro del clúster

Puedes ejecutar estos pasos despacio para ir acompañando cada uno de ellos si quieres, pero si quieres levantar todo solo ejecuta vagrant up sin pasaje de argumentos.

vagrant up etcd1 etcd2 etcd3
vagrant up loadbalancer1 loadbalancer2
vagrant up master1 master2 master3
vagrant up worker1 worker2

Accediendo al clúster etcd desde tu máquina local para pruebas

Si quieres subir solamente el clúster etcd puedes ejecutar

vagrant up etcd1 etcd2 etcd3

Instala en tu máquina etcdctl eligiendo la versión que desees en https://github.com/etcd-io/etcd/releases

# Modifica la versión aquí si es necesario
ETCD_VER=v3.5.4

mkdir -p /tmp/etcd
echo "Descargando y extrayendo a la carpeta /tmp/etcd y removiendo el zip"
curl -L "https://github.com/etcd-io/etcd/releases/download/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz" -o /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
tar xzvf /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz -C /tmp/etcd --strip-components=1
rm -f /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz

echo "Moviendo los binarios a /usr/local/bin y dando permiso a los usuarios"
sudo mv /tmp/etcd/etcdctl /usr/local/bin
sudo chmod 755 /usr/local/bin/etcdctl

echo "Limpiando"
rm -rf /tmp/etcd

Entra en la carpeta certs y copia los certificados a tu máquina local en /etc/etcd/pki con los permisos necesarios.

sudo mkdir -p /etc/etcd/pki
sudo cp *.pem /etc/etcd/pki/
sudo chmod 755 /etc/etcd/pki/*

Ahora solo tienes que cargar las variables de entorno para que etcdctl sepa hacia dónde apuntar y qué certificados usar.

export ETCDCTL_API=3
export ETCDCTL_ENDPOINTS=https://10.10.10.231:2379,https://10.10.10.232:2379,https://10.10.10.233:2379
export ETCDCTL_CACERT=/etc/etcd/pki/ca.pem
export ETCDCTL_CERT=/etc/etcd/pki/etcd.pem
export ETCDCTL_KEY=/etc/etcd/pki/etcd-key.pem

Ejecuta algunos comandos para prueba:

etcdctl member list
etcdctl endpoint status
etcdctl endpoint health

etcdctl put mykey david
etcdctl get mykey
etcdctl del mykey
etcdctl get mykey

Recomendaciones

Creo que lo ideal es entender paso a paso lo que se hizo leyendo los scripts de bootstrap de cada uno de los nodos.