Edge computing com K3s: Kubernetes leve para dispositivos

1. Introdução ao Edge Computing e K3s

1.1. O que é Edge Computing e por que Kubernetes no edge?

Edge computing é o paradigma de processamento de dados próximo à fonte geradora, em vez de depender exclusivamente de data centers centralizados. Em cenários de IoT, manufatura inteligente e veículos autônomos, a latência de rede e a largura de banda limitada tornam inviável enviar todos os dados para a nuvem. É aqui que o Kubernetes entra: ele oferece orquestração de contêineres, auto-recuperação e escalabilidade, mesmo em ambientes remotos.

1.2. Desafios do Kubernetes tradicional em dispositivos com recursos limitados

Um cluster Kubernetes completo (kubeadm, kubelet, etcd, control plane components) consome facilmente 2-4 GB de RAM e vários núcleos de CPU. Dispositivos como Raspberry Pi 4 (4 GB RAM) ou Jetson Nano (4 GB) simplesmente não conseguem rodar um cluster completo com workloads significativos. Além disso, a complexidade de instalação e manutenção inviabiliza implantações em massa no campo.

1.3. K3s: origem, filosofia e diferenças fundamentais

Criado pela Rancher Labs (agora SUSE), o K3s é uma distribuição certificada do Kubernetes com menos de 100 MB de binário. Sua filosofia é "Kubernetes para qualquer lugar": substitui o etcd por SQLite (ou etcd opcional), remove drivers de cloud desnecessários, empacota tudo em um único binário e reduz o consumo de RAM para ~512 MB para o server node. O nome é uma brincadeira com "K8s" (Kubernetes) — "K3s" seria a metade do tamanho.

2. Arquitetura e Componentes do K3s

2.1. Estrutura do cluster: server e agent nodes

O K3s mantém a arquitetura mestre-escravo do Kubernetes, mas com nomes simplificados:

  • Server node: executa o control plane (API server, controller manager, scheduler) e o kubelet. Por padrão, usa SQLite como banco de dados, mas pode ser configurado para etcd em modo HA.
  • Agent node: executa apenas o kubelet e o kube-proxy, conectando-se ao server via WebSocket.

2.2. Componentes substituídos

Componente K8s padrão Substituído por
etcd SQLite (padrão) ou etcd (HA)
kube-proxy Klipper (proxy leve)
CoreDNS CoreDNS (mantido, mas configurado para baixo consumo)
Ingress Controller Traefik (opcional, habilitado por padrão)
Load Balancer Klipper Load Balancer (svclb)
Network Plugin Flannel (embutido)

2.3. Mecanismos de redução de footprint

O K3s alcança seu tamanho reduzido através de:

  • Binário único comprimido com UPX
  • Remoção de drivers de cloud providers (AWS, GCP, Azure)
  • Substituição de componentes pesados por alternativas leves
  • Desabilitação de funcionalidades não essenciais via flags (--disable-cloud-controller, --disable-servicelb)

3. Instalação e Configuração Básica do K3s

3.1. Pré-requisitos de hardware

Para um cluster funcional, recomenda-se:

  • Server node: Raspberry Pi 4 (4 GB RAM), Jetson Nano (4 GB) ou qualquer x86 com 1 GB RAM mínimo
  • Agent nodes: Raspberry Pi 3/4, Rock64, ou dispositivos ARM/x86 com 512 MB RAM
  • Armazenamento: 16 GB SD card ou SSD via USB
  • Sistema: Ubuntu 20.04+ (ARM64) ou Raspberry Pi OS Lite

3.2. Instalação do server node

No server node, execute:

curl -sfL https://get.k3s.io | sh -s - --write-kubeconfig-mode 644 --node-ip 192.168.1.100

Flags importantes:

  • --write-kubeconfig-mode 644: permite acesso ao kubeconfig por usuários não-root
  • --node-ip: define o IP do nó (útil em redes com múltiplas interfaces)
  • --disable traefik: desabilita o Traefik se você quiser usar outro ingress
  • --disable servicelb: desabilita o load balancer interno

Verifique a instalação:

sudo k3s kubectl get nodes

3.3. Adicionando agent nodes

No agent node, obtenha o token do server:

sudo cat /var/lib/rancher/k3s/server/node-token

Depois, no agent, execute:

curl -sfL https://get.k3s.io | K3S_URL=https://192.168.1.100:6443 K3S_TOKEN=SEU_TOKEN sh -

Verifique no server:

sudo k3s kubectl get nodes

4. Gerenciamento de Recursos em Dispositivos com Restrições

4.1. Configuração de limites de CPU e memória

Em dispositivos edge, cada milissegundo de CPU conta. Exemplo de deployment com limites:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sensor-processor
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sensor
  template:
    metadata:
      labels:
        app: sensor
    spec:
      containers:
      - name: processor
        image: myorg/sensor-processor:latest
        resources:
          requests:
            memory: "128Mi"
            cpu: "250m"
          limits:
            memory: "256Mi"
            cpu: "500m"

4.2. Uso de taints, tolerations e nodeSelector

Para isolar workloads críticos em nós específicos:

# Adicionar taint ao nó GPU
kubectl taint nodes jetson-nano gpu=true:NoSchedule

# Deployment tolerando o taint
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-inference
spec:
  template:
    spec:
      tolerations:
      - key: "gpu"
        operator: "Equal"
        value: "true"
        effect: "NoSchedule"
      nodeSelector:
        device-type: "gpu"

4.3. Monitoramento leve

Para monitoramento em recursos limitados, use:

# Instalar kube-prometheus-stack com recursos reduzidos
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm upgrade --install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --set prometheus.resources.requests.memory=256Mi \
  --set prometheus.resources.limits.memory=512Mi \
  --set grafana.enabled=false

Para logs, utilize o fluent-bit:

kubectl apply -f https://raw.githubusercontent.com/fluent/fluent-bit-kubernetes-logging/master/fluent-bit-ds.yaml

5. Armazenamento e Rede para Edge

5.1. Armazenamento local com local-path-provisioner

O K3s já inclui o local-path-provisioner. Para criar um PVC:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: local-pvc
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: local-path
  resources:
    requests:
      storage: 1Gi

5.2. Rede simplificada

O service load balancer (svclb) do K3s expõe serviços diretamente no IP do nó:

apiVersion: v1
kind: Service
metadata:
  name: web-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: web

5.3. Integração com armazenamento remoto

Para sincronizar dados com a nuvem, configure um volume NFS:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteMany
  nfs:
    server: 192.168.1.200
    path: "/exports/data"

6. Casos de Uso e Aplicações Típicas

6.1. Processamento de dados em tempo real

Sensores IoT geram milhares de leituras por segundo. Com K3s, você pode processar localmente e enviar apenas sumarizações para a nuvem:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mqtt-broker
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mqtt
  template:
    metadata:
      labels:
        app: mqtt
    spec:
      containers:
      - name: mosquitto
        image: eclipse-mosquitto:latest
        ports:
        - containerPort: 1883

6.2. Aplicações de baixa latência

Gateways MQTT e servidores web leves (Nginx, Caddy) rodam perfeitamente em clusters K3s:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gateway
spec:
  template:
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        resources:
          limits:
            memory: "64Mi"
            cpu: "100m"

6.3. Exemplo prático: pipeline de inferência de ML com TensorFlow Lite

Para dispositivos com GPU (Jetson Nano), utilize device plugins:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tflite-inference
spec:
  template:
    spec:
      containers:
      - name: inference
        image: nvcr.io/nvidia/l4t-tensorflow:r32.7.1-tf2.7-py3
        command: ["python3", "-c", "import tensorflow as tf; print('GPU Available:', tf.test.is_gpu_available())"]
        resources:
          limits:
            nvidia.com/gpu: 1

7. Manutenção, Atualizações e Segurança

7.1. Atualização do K3s sem downtime

Para atualizar um nó sem interrupção:

# Drenar o nó
kubectl drain <node-name> --ignore-daemonsets --delete-emptydir-data

# Atualizar o K3s no nó
curl -sfL https://get.k3s.io | sh -s - --write-kubeconfig-mode 644

# Descordonar o nó
kubectl uncordon <node-name>

7.2. Backup e restore do cluster

Faça snapshots regulares do etcd (ou SQLite):

# Backup (SQLite)
sudo k3s etcd-snapshot save --name pre-upgrade-snapshot

# Restore
sudo k3s server --cluster-reset --cluster-reset-restore-path=/var/lib/rancher/k3s/server/db/snapshots/pre-upgrade-snapshot

7.3. Segurança no edge

O K3s já gera certificados TLS automáticos. Para gerenciamento de segredos:

# Usar SealedSecrets para criptografar secrets
kubectl create secret generic my-secret --dry-run=client -o yaml | \
  kubeseal --controller-name=sealed-secrets --controller-namespace=kube-system \
  --format yaml > sealed-secret.yaml

8. Considerações Finais e Próximos Passos

8.1. Limitações do K3s

O K3s não é indicado para clusters com mais de 100 nós ou workloads que exigem features avançadas do Kubernetes (como CRDs complexos ou policy engines). Para esses casos, considere KubeEdge ou K8s completo.

8.2. Integração com cloud híbrida

Use ArgoCD para GitOps e sincronização de estado entre edge e cloud:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

8.3. Tendências

O K3s está sendo adotado em veículos autônomos (RoboKube), drones de entrega e dispositivos médicos portáteis. A combinação de baixo footprint com certificação Kubernetes oficial torna o K3s a escolha natural para edge computing em produção.

Referências