Instalar k0sctl en ubuntu

Instalar k0sctl en ubuntu usando un entorno virtual con vagrant y virtual box, se crearán dos nodos controller y worker, usaremos kubectl

Escrito por oscar 29 September 2022 972 0

Linux Servidores

Ejercicio a realizar

Se pretende crear un ambiente de pruebas en donde realizaremos la creacion de varias maquinas virtuales y en esta crear un entrono para k0s y poder realizar varios ejercicios.

Infraestructura de pruebas

Descripción de infraestructura

La infraestructura con la que vamos a trabajaron tres maquinas virtuales las cuales tienes la siguiente caracteristica:

PC (host) tiene instalado el sistema operativo Windows

k0s admin: sera la maquina encargada de administrar y controlar el k0s.
k0s controller: Controlador del cluster
k0s worker: maquina de trabajo

Crear maquinas virtuales

Para este ejercicio, y como se menciona en la desaparicion de la arquitectura, se creara tres maquina virtuales con virtual box y vagrant, la principal caracteristica de estas maquinas es que usaran Ubuntu server 2204.

Instalar ubuntu 2004 en virtualbox

Instalar y configurar vagrant con virtualbox

El archivo que vamos a utilizar en estas maquinas es el siguiente:

Vagrant.configure("2") do |config|
  config.vm.define "k0s-admin" do |node|
    node.vm.hostname = "admin"
    node.vm.box = "ubuntu/focal64"
    node.vm.network "private_network", ip: "192.168.33.10"
    node.vm.provider "virtualbox" do |vb|
      vb.memory = "1024"
    end
  end
  
  config.vm.define "k0s-controller" do |node|
    node.vm.hostname = "controller"
    node.vm.box = "ubuntu/focal64"
    node.vm.network "private_network", ip: "192.168.33.20"
    node.vm.provider "virtualbox" do |vb|
      vb.memory = "1024"
    end
  end

  config.vm.define "k0s-worker" do |node|
    node.vm.hostname = "worker"
    node.vm.box = "ubuntu/focal64"
    node.vm.network "private_network", ip: "192.168.33.21"
    node.vm.provider "virtualbox" do |vb|
      vb.memory = "1024"
    end
  end
end

Configurar llaves SSH

Al trabajar con vagrant desde Windows, creará automáticamente las keys privadas y publicas, las cuales copiarlas y pegarlas en un lugar que podamos acceder desde la maquina k0s admin quien la usara para poder acceder a las maquinas k0s master y worker.

La ubicación en windows de estas keys esta en el directorio "k0s-vagrant\.vagrant\machines\k0s-master\virtualbox", al usar vagrant estas llaves se copian automáticamente dentro de los directorios de cada una de las maqunas virtuales.

Vamos a crear las carpetas para copuar las llaves en un lugar donde podamos acceder de forma rapida:

mkdir .ssh/ssh-controller

mkdir .ssh/ssh-worker

Luego copiamos las llaves a las carpetas creadas anteriormente:

cp /vagrant/.vagrant/machines/k0s-worker/virtualbox/private_key .ssh/ssh-worker/

cp /vagrant/.vagrant/machines/k0s-controller/virtualbox/private_key .ssh/ssh-controller/

Damos permisos de lectura u escritura el propietario del archivo, en este caso vagrant, y se los quitamos a los grupos y otros usuarios.

chmod 600 .ssh/ssh-controller/private_key

chmod 600 .ssh/ssh-worker/private_key

Instalar k0sCtl

Descargar el binario manualmente

Realizamos la instalación manualmente GitHub - k0sproject/k0sctl: A bootstrapping and management tool for k0s clusters., vamos a realizar la descarga del archivo k0sctl en el repositorio Release v0.15.4 · k0sproject/k0sctl · GitHub, primero debemos identificar que sistema operativo tenemos y la arquitectura del procesador

uname -m

El resultado retornara la arquitectura del procesador, esto lo vamos a tener en cuenta para descargar el archivo k0s correcto.

Si es "amd64" o "x86_64" el archivo debe ser: amd64
Si es "arm64" o "aarch64" el archivo debe ser: arm64
Si es "armv7l" o "armv8l" o "arm" el archivo debe ser: arm

Con el resultado anterior debemos descarar el siguiente archivo

https://github.com/k0sproject/k0sctl/releases/download/v0.15.4/k0sctl-linux-x64

Abrimos la consola y descargamos el archivo, ademas de ejecutar las siguientes instrucciones

wget https://github.com/k0sproject/k0sctl/releases/download/v0.15.4/k0sctl-linux-x64

Luego vamos a mover y renombrar el binario k0sctl-linux-x64 a /usr/local/bin/

sudo mv k0sctl-linux-x64 /usr/local/bin/k0sctl

Damos permisos de lectura y escritura a los usuarios y grupos sobre el archivo binario

sudo chmod 777 /usr/local/bin/k0sctl

Nota: Podemos ejecutar todas las instrucciones al tiempo como se observa en la siguiente imagen:

Una ves realizado los los pasos anterios probamos si k0sctl funciona correctamente:

vagrant@admin:~$ k0sctl version
version: v0.15.4
commit: dd78048

Instalar kubectl

Instalar herramientas | Kubernetes, kubectl es una herramienta de línea de comandos para interactuar con clústeres de Kubernetes, una plataforma que automatiza la administración de aplicaciones en contenedores. Permite desplegar, escalar y actualizar aplicaciones, así como acceder a registros y recursos del clúster. Es esencial para desarrolladores y administradores que trabajan con Kubernetes.

Procedemos a descargar el binario de kubectl en su versión ma estable que se contiene de https://dl.k8s.io/release/stable.txt.

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Ahora, al binario descargado le damos permisos de ejecución:

chmod +x kubectl

Procedemos a mover el archivo a la ruta "/usr/local/bin/", almacenar archivos ejecutables que no son parte del sistema operativo principal.

sudo mv kubectl /usr/local/bin/

Por ultimo, verificamos la instalación de kubectl.

kubectl version --client

Respuesta

WARNING: This version information is deprecated and will be replaced with the output from kubectl version --short.  Use --output=yaml|json to get the full version.
Client Version: version.Info{Major:"1", Minor:"27", GitVersion:"v1.27.4", GitCommit:"fa3d7990104d7c1f16943a67f11b154b71f6a132", GitTreeState:"clean", BuildDate:"2023-07-19T12:20:54Z", GoVersion:"go1.20.6", Compiler:"gc", Platform:"linux/amd64"}
Kustomize Version: v5.0.1

Crear cluster con k0sctl

Procedemos a crear y configurar los clusters, para ellos usaremos el comando k0sctl:

El archivo de configuración se obtiene con la siguiente comando:

k0sctl init

El resultado lo guardamos en el archivo k0sConfig

k0sctl init > k0sConfig.yaml

Realizamos la modificacion del archivo k0sConfig.yaml de la siguiente forma:

nano k0sConfig.yaml

Donde vamos a dejar la siguiente configuración:

apiVersion: k0sctl.k0sproject.io/v1beta1
kind: Cluster
metadata:
  name: k0s-cluster
spec:
  hosts:
  - ssh:
      address: 192.168.33.20
      user: vagrant
      port: 22
      keyPath: /home/vagrant/.ssh/ssh-controller/private_key
    role: controller+worker
    privateInterface: eth1
  - ssh:
      address: 192.168.33.21
      user: vagrant
      port: 22
      keyPath: /home/vagrant/.ssh/ssh-worker/private_key
    role: worker
    privateInterface: eth1
  k0s:
    version: 1.27.4+k0s.0
    dynamicConfig: false

Luego ejecutamos los cambios

k0sctl apply --config k0sConfig.yaml

kubeconfig

Una vez creado los clusters con k0sctl e instalado kubectl, procedemos a crear el archivo kubeconfig para poder usar kubernetes con los clusters, primero vamos a generar este archivo con el siguiente comando.

k0sctl kubeconfig --config k0sConfig.yaml > kubeconfig.config

Una ves generado el archivo, procedemos a realizar una prueba para obtener información de los clustres de la siguiente forma.

kubectl get node --kubeconfig kubeconfig.config