Skip to content

Instalación de un ambiente de Kubernetes Community

  1. Ingresar al ambiente de laboratorio con la información proporcionada y remover el paquete de Podman instalado anteriormente: 
    sudo dnf remove podman
  2. Al siguiente mensaje responder con la letra y para confirmar: 
    Is this ok [y/N]: y
  3. Configurar los parámetros del kernel con los siguientes comandos: 
    sudo modprobe overlay

    sudo modprobe br_netfilter

    cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

    cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

    sudo sysctl --system
  4. Agregar el repositorio de Docker CE, instalar y configurar ContainerD: 
    sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

    sudo dnf install -y containerd.io

    sudo mkdir -p /etc/containerd

    sudo containerd config default | sudo tee /etc/containerd/config.toml
  5. Configurar SystemdCgroup = true en /etc/containerd/config.toml 
    sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
  6. Iniciar los servicios de ContainerD 
    sudo systemctl enable --now containerd
  7. Configurar SELinux en permissive mode 
    sudo setenforce 0

    sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
  8. Agregar el repositorio de Kubernetes en /etc/yum.repos.d/kubernetes.repo 
    cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.33/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.33/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF
  9. Instalar software de Kubernetes 
    sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

    sudo systemctl enable --now kubelet
  10. Cambiarse como usuario root e inicializar el cluster de Kubernetes: 
    sudo -i

    kubeadm init
  11. Configurar el acceso al cluster de Kubernetes: 
    mkdir -p $HOME/.kube

    cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

    chown $(id -u):$(id -g) $HOME/.kube/config

    export KUBECONFIG=/etc/kubernetes/admin.conf
  12. Validar el acceso y recursos creados 
    kubectl get nodes

    kubectl get pods -A
  13. Instalar el CNI (cilium en este ejemplo) 
    CILIUM_CLI_VERSION=$(curl -s https://raw.githubusercontent.com/cilium/cilium-cli/main/stable.txt)
CLI_ARCH=amd64
if [ "$(uname -m)" = "aarch64" ]; then CLI_ARCH=arm64; fi
curl -L --fail --remote-name-all https://github.com/cilium/cilium-cli/releases/download/${CILIUM_CLI_VERSION}/cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}
sha256sum --check cilium-linux-${CLI_ARCH}.tar.gz.sha256sum
sudo tar xzvfC cilium-linux-${CLI_ARCH}.tar.gz /usr/local/sbin/
rm -f cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}

    cilium install --version 1.18.0

    cilium status --wait
  14. Validar los recursos Pods y Nodes del cluster. 
    kubectl get pods -A

    kubectl get nodes
  15. Permitir que se aprovisione carga de trabajo de aplicaciones en el mismo servidor (All In One) 
    kubectl taint nodes --all node-role.kubernetes.io/control-plane-
  16. Descargar plantilla de instalación de un Ingress Controller (NGINX Ingress Controller) 
    wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.3/deploy/static/provider/baremetal/deploy.yaml
  17. Editar el archivo deploy.yaml y agregar hostNetwork: true como se muestra el siguiente ejemplo: 
    spec:
  template:
    spec:
      hostNetwork: true

    kubectl apply -f deploy.yaml
  18. Validar los Pods de NGINX Ingress Controller 
    kubectl get pods --namespace=ingress-nginx
  19. Desplegar y exponer un aplicativo de ejemplo. Reemplazar podinfo.34-145-118-204.nip.io por el correspondiente según su ambiente de laboratorio: 
    kubectl create ns ns-demo

    kubectl create deployment podinfo --image=stefanprodan/podinfo --port=9898 -n ns-demo

    kubectl get pods -n ns-demo

    kubectl expose deployment podinfo -n ns-demo

    kubectl create ingress ing-podinfo --class=nginx \
  --rule="podinfo.34-145-118-204.nip.io/*=podinfo:9898" -n ns-demo
  20. Extraer el FQDN del Ingress y comprobar el acceso en un navegador web 
    kubectl get ing -n ns-demo
    Debe mostrar una un resultado como el siguiente: k8s
  21. Instalar herramienta HELM 
    export HELM_VERSION=v3.16.2

    cd ~ && mkdir bin

    curl -LO https://get.helm.sh/helm-${HELM_VERSION}-linux-amd64.tar.gz

    tar -xvzf helm-v3.16.2-linux-amd64.tar.gz -C bin/ linux-amd64/helm --strip-components=1

    helm version
  22. Instalar Dashboard de Kubernetes Community. Reemplazar podinfo.34-145-118-204.nip.io por el correspondiente según su ambiente de laboratorio: 
    helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/

    helm upgrade --install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --create-namespace --namespace kubernetes-dashboard
  23. Exponer el Dashboard, creando un archivo llamado ingress.yaml con el siguiente contenido: 
    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: k8sdash
  namespace: kubernetes-dashboard
  annotations:
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
spec:
  ingressClassName: nginx
  rules:
    - host: k8sdash.34-145-118-204.nip.io
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: kubernetes-dashboard-kong-proxy
                port:
                  number: 443
  24. Ejecutar el siguiente comando para crear el recurso tipo ingress 
    kubectl apply -f ingress.yaml
  25. Configurar el acceso, creando un archivo llamado access.yaml con el siguiente contenido: 
    apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard
  26. Ejecutar el siguiente comando para crear los recursos de ServiceAccount y ClusterRoleBinding. 
    kubectl apply -f access.yaml
  27. Generar un token de acceso con el siguiente comando: 
    kubectl -n kubernetes-dashboard create token admin-user
  28. Extraer el FQDN del Dashboard y comprobar el acceso en un navegador web 
    kubectl get ing -n kubernetes-dashboard
  29. Entrar con un navegador web al FQDN obtenido utilizando HTTPS y colocar el token obtenido anteriormente, el resultado debe ser similar al siguiente cuando esta seleccionado All namespaces: k8s