Serverless no Kubernetes: Knative ou OpenFaaS

1. Introdução ao Serverless no Kubernetes

O conceito de serverless no Kubernetes representa a evolução natural da computação em nuvem, combinando a flexibilidade do orquestrador de contêineres com a abstração de execução sob demanda. Diferentemente do modelo tradicional de FaaS (Function as a Service) oferecido por AWS Lambda ou Google Cloud Functions, o serverless no Kubernetes permite que funções sejam executadas em contêineres efêmeros dentro do cluster, mantendo controle total sobre infraestrutura e custos.

A principal motivação para rodar serverless no Kubernetes é a capacidade de escalar para zero quando não há demanda, eliminando custos de recursos ociosos. Duas plataformas dominam esse ecossistema: Knative, projeto incubado pelo Google e parte da Cloud Native Computing Foundation (CNCF), e OpenFaaS, solução madura com forte foco em simplicidade e suporte a múltiplas linguagens.

2. Knative: Arquitetura e Componentes Principais

Knative é dividido em dois componentes principais:

Serving gerencia o ciclo de vida de funções e aplicações serverless. Ele cria automaticamente revisões de cada deploy, permite roteamento de tráfego entre versões e escala para zero quando não há requisições. O escalonamento é baseado em métricas de concorrência, utilizando um proxy chamado Queue-Proxy injetado em cada pod.

Eventing fornece integração com fontes de eventos como Apache Kafka, GCP Pub/Sub, cron jobs e webhooks. Ele utiliza triggers e brokers para conectar produtores e consumidores de eventos de forma desacoplada.

A malha de serviço padrão é o Kourier, uma alternativa leve ao Istio, mas este último ainda é suportado para ambientes que exigem controle avançado de tráfego.

3. OpenFaaS: Funcionalidades e Fluxo de Trabalho

OpenFaaS possui arquitetura mais simples, centrada em três componentes:

  • Gateway: ponto único de entrada para invocar funções e gerenciar o sistema.
  • Provedores: conectam o gateway ao cluster (Kubernetes, faasd, etc.).
  • Funções: contêineres que executam código em resposta a requisições HTTP.

O fluxo de trabalho típico envolve criar uma função a partir de um template, escrever o handler e realizar o deploy via CLI. OpenFaaS suporta templates oficiais para Go, Python, Node.js, Ruby e C#, além de templates customizados.

O escalonamento automático é gerenciado pelo faas-idler, que reduz réplicas a zero após período de inatividade configurável. A integração com Prometheus permite escalonamento baseado em métricas de CPU, memória e taxa de requisições.

4. Comparação Técnica: Knative vs. OpenFaaS

Característica Knative OpenFaaS
Modelo de execução Pods efêmeros com proxy Contêineres de função dedicados
Cold start 1-3 segundos com cache 0.5-2 segundos com keep-warm
Suporte a stateful Limitado (via StatefulSet) Não suporta nativamente
Complexidade de setup Alta (depende de Istio/Kourier) Baixa (Helm chart único)
Ecossistema de eventos Nativo (Eventing) Via integrações externas

Knative oferece maior integração com o ecossistema Kubernetes, mas exige mais componentes. OpenFaaS prioriza simplicidade e onboarding rápido.

5. Instalação e Configuração no Cluster K8s

Pré-requisitos para ambos: cluster Kubernetes 1.24+, Ingress Controller (NGINX, Traefik) e métricas do cluster (Metrics Server).

Instalação do Knative (Serving + Eventing):

# Instalar operador Knative
kubectl apply -f https://github.com/knative/operator/releases/download/knative-v1.14.0/operator.yaml

# Configurar Serving com Kourier
kubectl create namespace knative-serving
kubectl apply -f - <<EOF
apiVersion: v1
kind: ConfigMap
metadata:
  name: config-network
  namespace: knative-serving
data:
  ingress-class: kourier.ingress.networking.knative.dev
EOF

kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.14.0/kourier.yaml

Instalação do OpenFaaS via Helm:

# Adicionar repositório e instalar
helm repo add openfaas https://openfaas.github.io/faas-netes/
helm repo update

helm upgrade openfaas --install openfaas/openfaas \
  --namespace openfaas --create-namespace \
  --set functionNamespace=openfaas-fn \
  --set generateBasicAuth=true

6. Exemplos Práticos de Deploy de Funções

Knative: função Go com revisões:

# Criar serviço Knative
kn service create hello-go \
  --image gcr.io/knative-samples/helloworld-go \
  --env TARGET="Knative" \
  --revision-name v1

# Atualizar e criar revisão v2
kn service update hello-go \
  --env TARGET="Knative v2" \
  --revision-name v2

# Roteamento de tráfego: 50% v1, 50% v2
kn service update hello-go \
  --traffic v1=50,v2=50

# Verificar revisões
kn revision list

OpenFaaS: função Python via faas-cli:

# Criar função a partir de template
faas-cli new hello-py --lang python3

# Editar handler (hello-py/handler.py)
def handle(req):
    return f"Hello {req} from OpenFaaS!"

# Deploy
faas-cli build -f hello-py.yml
faas-cli push -f hello-py.yml
faas-cli deploy -f hello-py.yml

# Invocar função
echo "World" | faas-cli invoke hello-py

Monitoramento com Prometheus:

# Ver métricas de requisições no Knative
kubectl -n knative-serving logs -l app=activator

# OpenFaaS: dashboard de métricas
kubectl port-forward -n openfaas svc/gateway 8080:8080
# Acessar http://localhost:8080/ui/ com credenciais

7. Cenários de Uso e Casos Reais

APIs leves e webhooks: OpenFaaS é ideal para equipes que precisam expor funções rapidamente, com mínima configuração. Knative é mais adequado para APIs que exigem roteamento complexo de tráfego e múltiplas versões simultâneas.

Batch processing: Ambos suportam, mas Knative Eventing permite encadeamento sofisticado de eventos. Para processamento de ML, OpenFaaS oferece templates com GPU, enquanto Knative requer configuração adicional de device plugins.

Integração com CI/CD: OpenFaaS possui GitHub Actions e GitLab CI oficiais. Knative se integra nativamente com Tekton e ArgoCD para GitOps, permitindo que funções sejam versionadas como recursos Kubernetes.

8. Conclusão e Próximos Passos

A escolha entre Knative e OpenFaaS depende do contexto do time e da infraestrutura. Knative é a melhor opção para organizações que já investem em Kubernetes e precisam de integração profunda com o ecossistema nativo, incluindo eventos e malha de serviço. OpenFaaS é ideal para quem busca simplicidade, onboarding rápido e suporte a múltiplas linguagens sem complexidade adicional.

Para evoluir no aprendizado, explore tópicos como Operator SDK para criar operadores personalizados, GPU scheduling para workloads de ML e KEDA para escalonamento avançado baseado em eventos externos.

Referências