Kubernetes k0s: leve, simples e tudo empacotado com HA Control Plane
k0s é a distribuição do Kubernetes criada pela Mirantis com todos os recursos necessários em um único e pequeno binário, que proporciona uma simplicidade na implementação e operação. Tem por definição eliminar o desgaste, que é a razão do seu nome “Zero Friction”.
As principais característica são:
- Empacotado como um único binário estático.
- Control Plane isolado e auto-hospedado.
- Variedade de back-ends de armazenamento: etcd, SQLite, MySQL e PostgreSQL.
- Control Plane elástico.
- Vanilla upstream Kubernetes.
- Utiliza como container runtimes padrão o containerd, mas permitindo outros como o Docker.
- Suporte a diversos Container Network Interface (CNI) (calico é o padrão)
- Suporta x86_64 e arm64.
Durante a sua instalação, através de um script, ele procura instalar as versões mais recentes dos componentes do Kubernetes, como por exemplo a versão 1.20.4, mas podendo alterar facilmente em seu arquivo de configuração.
Mão na Massa:
Vamos ver agora como usar k0s para implementar um cluster Kubernetes em HA Control Plane utilizando como load balancer o haproxy e com dois worker nodes.
Não falaremos aqui da instalação e configuração do haproxy, mas podemos falar em outro material.
Instalação e Configuração:
As etapas 1 a 2 devem ser executadas em todos os controllers e workers do cluster.
- Download do binário do k0s:
$ sudo curl -sSLf https://get.k0s.sh | sudo sh$ k0s version
v0.11.0
2. Criando o arquivo de configuração padrão do k0s:
$ mkdir -p ${HOME}/.k0s
$ k0s default-config | tee ${HOME}/.k0s/k0s.yamlA partir dessa etapa, iniciar através do Controller 1.
3. Alterando o arquivo de configuração.
Importante: As linhas em negrito devem ser iguais em todos os controllers nodes.
$ vim .k0s/k0s.yaml
apiVersion: k0s.k0sproject.io/v1beta1
images:
konnectivity:
image: us.gcr.io/k8s-artifacts-prod/kas-network-proxy/proxy-agent
version: v0.0.13
metricsserver:
image: gcr.io/k8s-staging-metrics-server/metrics-server
version: v0.3.7
kubeproxy:
image: k8s.gcr.io/kube-proxy
version: v1.20.4
coredns:
image: docker.io/coredns/coredns
version: 1.7.0
calico:
cni:
image: calico/cni
version: v3.16.2
flexvolume:
image: calico/pod2daemon-flexvol
version: v3.16.2
node:
image: calico/node
version: v3.16.2
kubecontrollers:
image: calico/kube-controllers
version: v3.16.2
installConfig:
users:
etcdUser: etcd
kineUser: kube-apiserver
konnectivityUser: konnectivity-server
kubeAPIserverUser: kube-apiserver
kubeSchedulerUser: kube-scheduler
kind: Cluster
metadata:
name: k0s
spec:
api:
externalAddress: k0s-haproxy #LB_IP
address: 192.168.15.241 #Controller
sans:
- 192.168.15.241 #Controller1
- 192.168.15.242 #Controller2
- 192.168.15.243 #Controller3
storage:
type: etcd
etcd:
peerAddress: 192.168.15.241 #Controller
network:
podCIDR: 10.244.0.0/16
serviceCIDR: 10.96.0.0/12
provider: calico
calico:
mode: vxlan
vxlanPort: 4789
vxlanVNI: 4096
mtu: 1450
wireguard: false
flexVolumeDriverPath: /usr/libexec/k0s/kubelet- plugins/volume/exec/nodeagent~uds
withWindowsNodes: false
overlay: Always
podSecurityPolicy:
defaultPolicy: 00-k0s-privileged
telemetry:
interval: 10m0s
enabled: true4. Fazendo a instalação do serviço:
$ sudo k0s install controller -c ${HOME}/.k0s/k0s.yaml5. Iniciando o k0s:
$ sudo systemctl start k0scontrollerAdicionando o controller 2
- Através do controller 1, crie o token do cluster:
$ sudo k0s token create --role=controller --expiry=1h > /tmp/controller.token2. Através do controller 2 , transfira o token criado na etapa anterior:
$ scp user@node01:/tmp/controller.token /tmp/3. Agora vamos adicionar o controller 2 ao cluster:
$ sudo k0s install controller -c ${HOME}/.k0s/k0s.yaml --token-file /tmp/controller.token$ sudo systemctl start k0scontroller
Adicionando o controller 3
- Como já temos o token criado, vamos somente transferir para o controller 3 :
$ scp user@node01:/tmp/controller.token /tmp/2. Agora vamos adicionar o controller 3 ao cluster:
$ sudo k0s install controller -c ${HOME}/.k0s/k0s.yaml --token-file /tmp/controller.token$ sudo systemctl start k0scontroller
Neste momento já temos os 3 controllers sendo balanceados pelo haproxy:
Adicionando os workers nodes no cluster:
O arquivo de configuração do k0s para os workers nodes deve ser usado o padrão, sem nenhuma alteração.
Adicionando o worker 1
- Através do node01 crie o token para os workers nodes:
$ k0s token create --role=worker --expiry=1h > /tmp/worker.token2. Copie o arquivo com o token para o worker 1 (node04):
$ scp root@192.168.15.241:/tmp/worker.token /tmp/3. Agora vamos adicionar o worker 1 (node04) ao cluster.
$ k0s install worker -c ${HOME}/.k0s/k0s.yaml --token-file /tmp/worker.token$ systemctl start k0sworker
Adicionando o worker 2
- Copie o arquivo criado com o token para o worker 2 (node05):
$ scp root@192.168.15.241:/tmp/worker.token /tmp/2. Agora vamos adicionar o segundo worker 2 (node05) ao cluster.
$ k0s install worker -c ${HOME}/.k0s/k0s.yaml --token-file /tmp/worker.token$ systemctl start k0sworker
Operação:
1. Grave o kubeconfig para o usuário:
$ cat /var/lib/k0s/pki/admin.conf | tee ~/.k0s/kubeconfigVocê pode também enviar para o seu .kube/ :
$ cp /var/lib/k0s/pki/admin.conf .kube/config2. Defina o KUBECONFIG variável de ambiente.
$ export KUBECONFIG=”${HOME}/.k0s/kubeconfig”3. Verifique todos os pods do cluster:
$ kubectl get pods --all-namespacesConferindo
Para verificar os serviços do k0s em cada node:
$ ps aux | awk ‘{print $11}’ | grep k0s/usr/bin/k0s
/var/lib/k0s/bin/etcd
/var/lib/k0s/bin/kube-apiserver
/var/lib/k0s/bin/konnectivity-server
/var/lib/k0s/bin/kube-scheduler
/var/lib/k0s/bin/kube-controller-manager
/usr/bin/k0s
Importante: Caso seja necessário refazer o cluster durante sua experiência, por qualquer motivo, você pode fazer:
$ systemctl stop k0scontroller e $ systemctl stop k0sworker
$ k0s resetMais informações sobre o k0s podem ser encontradas em: https://docs.k0sproject.io/
http://blog.aeciopires.com/instalando-o-k0s-distribuicao-kubernetes-all-inclusive/
