Preparando los Archivos Necesarios

Necesitamos generar certificados que utilizaremos en todos los componentes de Kubernetes. Los certificados son usados para identificar quiénes son los componentes, a qué grupos pertenecen para que tengan los permisos adecuados y se autoricen en el kube-apiserver.

Como cada uno tiene un certificado diferente podemos crear diferentes kubeconfigs utilizando esos certificados.

Como los certificados en Kubernetes están en la carpeta /var/lib/kubernetes/pki, vamos a crear una carpeta con el mismo nombre dentro de shared_files con los archivos necesarios.

Es necesario que una CA firme todos esos certificados. Crea y ejecuta el siguiente script dentro de la carpeta shared_files.

Cambia las IPs por las IPs que definiste en tu Vagrantfile.

Si observas, este script será llamado solamente en el master1 para crear los certificados que serán usados por todos. Estarán disponibles dentro de shared_files. Si quieres ejecutar los scripts manualmente hazlo para estudiar.

Crea el script llamándolo 1_generate_certificate_control_plane.sh

#!/bin/bash

mkdir pki
cd pki

############################# CA #############################################
echo -e "\n##### Creando CA ######"
openssl genrsa -out ca.key 2048
openssl req -new -key ca.key -subj "/CN=KUBERNETES-CA/O=Kubernetes" -out ca.csr
openssl x509 -req -in ca.csr -signkey ca.key -CAcreateserial -out ca.crt -days 1000

############################# ADMIN #############################################
echo -e "\n##### Creando el certificado para el admin ######"
openssl genrsa -out admin.key 2048
openssl req -new -key admin.key -subj "/CN=admin/O=system:masters" -out admin.csr
openssl x509 -req -in admin.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out admin.crt -days 1000

############################# CONTROLLER MANAGER #############################################
echo -e "\n##### Creando el certificado para el controller manager ######"
openssl genrsa -out kube-controller-manager.key 2048
openssl req -new -key kube-controller-manager.key -subj "/CN=system:kube-controller-manager/O=system:kube-controller-manager" -out kube-controller-manager.csr
openssl x509 -req -in kube-controller-manager.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out kube-controller-manager.crt -days 1000

############################# SCHEDULER #############################################
echo -e "\n##### Creando el certificado para el scheduler ######"
openssl genrsa -out kube-scheduler.key 2048
openssl req -new -key kube-scheduler.key -subj "/CN=system:kube-scheduler/O=system:kube-scheduler" -out kube-scheduler.csr
openssl x509 -req -in kube-scheduler.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out kube-scheduler.crt -days 1000

############################# KUBE-PROXY #############################################
echo -e "\n##### Creando el certificado para el kube-proxy ######"
openssl genrsa -out kube-proxy.key 2048
openssl req -new -key kube-proxy.key -subj "/CN=system:kube-proxy/O=system:node-proxier" -out kube-proxy.csr
openssl x509 -req -in kube-proxy.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out kube-proxy.crt -days 1000

############################# API SERVER #############################################
echo -e "\n##### Creando el certificado para el Api Server ######"

cat << EOF >> openssl-apiserver.cnf
[req]
req_extensions = v3_req
distinguished_name = req_distinguished_name

[req_distinguished_name]

[v3_req]
basicConstraints = critical, CA:FALSE
keyUsage = critical, nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster.local
IP.1 = 10.96.0.1
IP.2 = 10.0.0.201
IP.3 = 10.0.0.202
IP.4 = 10.0.0.203
IP.5 = 10.0.0.200
IP.6 = 127.0.0.1
EOF

openssl genrsa -out kube-apiserver.key 2048
openssl req -new -key kube-apiserver.key -subj "/CN=kube-apiserver/O=Kubernetes" -out kube-apiserver.csr -config openssl-apiserver.cnf
openssl x509 -req -in kube-apiserver.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out kube-apiserver.crt -extensions v3_req -extfile openssl-apiserver.cnf -days 1000

############################# API SERVER CLIENT #############################################
echo -e "\n##### Creando el certificado para el Api Server como cliente del Kubelet ######"

cat <<EOF >> openssl-kubelet.cnf
[req]
req_extensions = v3_req
distinguished_name = req_distinguished_name
[req_distinguished_name]
[v3_req]
basicConstraints = critical, CA:FALSE
keyUsage = critical, nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth
EOF

openssl genrsa -out apiserver-kubelet-client.key 2048
openssl req -new -key apiserver-kubelet-client.key -subj "/CN=kube-apiserver-kubelet-client/O=system:masters" -out apiserver-kubelet-client.csr -config openssl-kubelet.cnf
openssl x509 -req -in apiserver-kubelet-client.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out apiserver-kubelet-client.crt -extensions v3_req -extfile openssl-kubelet.cnf -days 1000

############################# ETCD SERVER #############################################
echo -e "\n##### Creando el certificado para el ETCD ######"

cat << EOF >> openssl-etcd.cnf
[req]
req_extensions = v3_req
distinguished_name = req_distinguished_name

[req_distinguished_name]

[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names

[alt_names]
IP.1 = 10.0.0.201
IP.2 = 10.0.0.202
IP.3 = 10.0.0.203
IP.4 = 127.0.0.1

[req_distinguished_name]
EOF

openssl genrsa -out etcd-server.key 2048
openssl req -new -key etcd-server.key -subj "/CN=etcd-server/O=Kubernetes" -out etcd-server.csr -config openssl-etcd.cnf
openssl x509 -req -in etcd-server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out etcd-server.crt -extensions v3_req -extfile openssl-etcd.cnf -days 1000

############################# SERVICE ACCOUNT #############################################
echo -e "\n##### Creando el certificado para el service-account ######"
openssl genrsa -out service-account.key 2048
openssl req -new -key service-account.key -subj "/CN=service-accounts/O=Kubernetes" -out service-account.csr
openssl x509 -req -in service-account.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out service-account.crt -days 1000

echo -e "\n##### Eliminando archivos innecesarios .csr y .cnf ######"
rm -rf *.csr
rm -rf *.cnf

La segunda etapa es crear los archivos kubeconfig. Todos los archivos .kubeconfig generados apuntarán a los archivos de los certificados que estarán en la carpeta correcta después. El único caso en que el contenido del certificado queda en muestra es el del admin.

Crea el script abajo dentro de shared_files con el nombre 3_generate_kubeconfigs_control_plane.sh. Por una cuestión de organización vamos a colocar en la carpeta creada kubeconfigs para después ser movido al lugar correcto.

#!/bin/bash

mkdir kubeconfigs
cd kubeconfigs

echo -e "\n##### Generando el kubeconfig para el kube-proxy #####"
kubectl config set-cluster kubernetes-the-hard-way \
  --certificate-authority=/var/lib/kubernetes/pki/ca.crt \
  --server=https://10.0.0.200:6443 \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials system:kube-proxy \
  --client-certificate=/var/lib/kubernetes/pki/kube-proxy.crt \
  --client-key=/var/lib/kubernetes/pki/kube-proxy.key \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-context default \
  --cluster=kubernetes-the-hard-way \
  --user=system:kube-proxy \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

echo -e "\n##### Generando el kubeconfig para el controller-manager #####"
kubectl config set-cluster kubernetes-the-hard-way \
  --certificate-authority=/var/lib/kubernetes/pki/ca.crt \
  --server=https://127.0.0.1:6443 \
  --kubeconfig=kube-controller-manager.kubeconfig

kubectl config set-credentials system:kube-controller-manager \
  --client-certificate=/var/lib/kubernetes/pki/kube-controller-manager.crt \
  --client-key=/var/lib/kubernetes/pki/kube-controller-manager.key \
  --kubeconfig=kube-controller-manager.kubeconfig

kubectl config set-context default \
  --cluster=kubernetes-the-hard-way \
  --user=system:kube-controller-manager \
  --kubeconfig=kube-controller-manager.kubeconfig

kubectl config use-context default --kubeconfig=kube-controller-manager.kubeconfig

echo -e "\n##### Generando el kubeconfig para el scheduler #####"
kubectl config set-cluster kubernetes-the-hard-way \
  --certificate-authority=/var/lib/kubernetes/pki/ca.crt \
  --server=https://127.0.0.1:6443 \
  --kubeconfig=kube-scheduler.kubeconfig

kubectl config set-credentials system:kube-scheduler \
  --client-certificate=/var/lib/kubernetes/pki/kube-scheduler.crt \
  --client-key=/var/lib/kubernetes/pki/kube-scheduler.key \
  --kubeconfig=kube-scheduler.kubeconfig

kubectl config set-context default \
  --cluster=kubernetes-the-hard-way \
  --user=system:kube-scheduler \
  --kubeconfig=kube-scheduler.kubeconfig

kubectl config use-context default --kubeconfig=kube-scheduler.kubeconfig

echo -e "\n##### Generando el kubeconfig para el admin #####"
kubectl config set-cluster kubernetes-the-hard-way \
  --certificate-authority=../pki/ca.crt \
  --embed-certs=true \
  --server=https://127.0.0.1:6443 \
  --kubeconfig=admin.kubeconfig

kubectl config set-credentials admin \
  --client-certificate=../pki/admin.crt \
  --client-key=../pki/admin.key \
  --embed-certs=true \
  --kubeconfig=admin.kubeconfig

kubectl config set-context default \
  --cluster=kubernetes-the-hard-way \
  --user=admin \
  --kubeconfig=admin.kubeconfig

kubectl config use-context default --kubeconfig=admin.kubeconfig

Otro archivo que necesitamos tener es un objeto en kubernetes que hará la encriptación de los secrets y otros componentes que queramos. Es necesario generar una key, luego haremos eso antes de crear el objeto que el kube-apiserver usará.

Crea el script abajo en la carpeta shared_files con el nombre que quieras y ejecuta el script. La salida será solamente el objeto que necesitamos llamado encryption-config.yaml.

#!/bin/bash

ENCRYPTION_KEY=$(head -c 32 /dev/urandom | base64)
echo -e "\n##### Generando método de encriptación que será usado en el clúster #####"

# Mover para /var/lib/kubernetes
cat > encryption-config.yaml <<EOF
apiVersion: v1
kind: EncryptionConfig
resources:
  - resources:
      - secrets
      - configmaps
    providers:
      - aescbc:
          keys:
            - name: key1
              secret: ${ENCRYPTION_KEY}
      - identity: {}
EOF