Kubernetes helper scripts: kubectl wrappers úteis

1. Introdução aos Wrappers de kubectl

O kubectl é a ferramenta de linha de comando essencial para interagir com clusters Kubernetes, mas seus comandos podem se tornar longos e repetitivos. Wrappers são scripts que encapsulam comandos complexos em funções simples, reduzindo digitação e padronizando operações entre equipes.

A estrutura básica de um wrapper consiste em funções shell, aliases e variáveis de ambiente. Boas práticas incluem nomes descritivos (prefixo k para kubectl), tratamento de erros com set -e e documentação inline com comentários.

# Estrutura básica de um wrapper
function kstatus() {
    local deployment=$1
    kubectl rollout status deployment/"$deployment" --watch
}

2. Wrappers para Gerenciamento de Namespaces e Contextos

Função kns() - Troca rápida de namespace

function kns() {
    if [ -z "$1" ]; then
        kubectl config view --minify -o jsonpath='{..namespace}'
    else
        kubectl config set-context --current --namespace="$1"
    fi
}

Função kctx() - Seleção interativa de contextos

function kctx() {
    local ctx
    ctx=$(kubectl config get-contexts -o name | fzf --prompt="Select context: ")
    if [ -n "$ctx" ]; then
        kubectl config use-context "$ctx"
    fi
}

Script de validação de contexto

function kcheck() {
    echo "Context: $(kubectl config current-context)"
    echo "Namespace: $(kubectl config view --minify -o jsonpath='{..namespace}')"
    kubectl cluster-info 2>/dev/null || echo "ERROR: Cluster unreachable"
    kubectl auth can-i list pods --all-namespaces 2>/dev/null || echo "WARN: Limited permissions"
}

3. Wrappers para Diagnóstico e Troubleshooting

Função klog() - Tail de logs com filtros

function klog() {
    local pod=$1
    local container=$2
    if [ -n "$container" ]; then
        kubectl logs -f "$pod" -c "$container"
    else
        kubectl logs -f "$pod"
    fi
}

Função kexec() - Acesso shell interativo

function kexec() {
    local pod=$1
    local container=${2:-}
    local cmd=${3:-/bin/sh}

    if [ -n "$container" ]; then
        kubectl exec -it "$pod" -c "$container" -- "$cmd"
    else
        kubectl exec -it "$pod" -- "$cmd"
    fi
}

Função kdesc() - Descrição resumida

function kdesc() {
    local resource=$1
    local name=$2
    kubectl describe "$resource" "$name" | head -50
}

4. Wrappers para Deploy e Rollback

Função kroll() - Rollback com confirmação

function kroll() {
    local deployment=$1
    local revision=${2:-1}

    echo "Rollback deployment/$deployment to revision $revision?"
    read -p "Confirm (y/N): " confirm
    if [ "$confirm" = "y" ]; then
        kubectl rollout undo deployment/"$deployment" --to-revision="$revision"
    fi
}

Função kdeploy() - Apply com validação

function kdeploy() {
    local manifest=$1
    echo "Validating $manifest..."
    kubectl apply --dry-run=client -f "$manifest" || return 1
    echo "Applying $manifest..."
    kubectl apply -f "$manifest"
}

Função kstatus() - Monitoramento visual

function kstatus() {
    local deployment=$1
    kubectl rollout status deployment/"$deployment" --watch &
    local pid=$!

    while kill -0 $pid 2>/dev/null; do
        kubectl get pods -l app="$deployment" --no-headers
        sleep 2
    done
}

5. Wrappers para Gerenciamento de Recursos

Função kgetall() - Listagem completa

function kgetall() {
    local ns=${1:-default}
    echo "=== Resources in namespace: $ns ==="
    for resource in pods services deployments configmaps secrets ingress; do
        echo "--- $resource ---"
        kubectl get "$resource" -n "$ns" 2>/dev/null
    done
}

Função kclean() - Limpeza de pods

function kclean() {
    echo "Removing Evicted pods..."
    kubectl delete pod --field-selector=status.phase=Failed --all-namespaces
    echo "Removing Completed pods..."
    kubectl delete pod --field-selector=status.phase=Succeeded --all-namespaces
}

Função kscale() - Scale com verificação

function kscale() {
    local deployment=$1
    local replicas=$2

    kubectl scale deployment/"$deployment" --replicas="$replicas"
    echo "Waiting for $replicas replicas..."
    while [ "$(kubectl get deployment "$deployment" -o jsonpath='{.status.readyReplicas}')" != "$replicas" ]; do
        sleep 2
    done
    echo "Scale completed"
}

6. Wrappers para Port-Forward e Proxy

Função kpf() - Port-forward inteligente

function kpf() {
    local service=$1
    local local_port=${2:-8080}
    local remote_port=${3:-80}

    kubectl port-forward service/"$service" "$local_port:$remote_port" &
    echo "Forwarding localhost:$local_port -> $service:$remote_port"
    echo "PID: $!"
}

Função kproxy() - Dashboard proxy

function kproxy() {
    local port=${1:-8001}
    echo "Starting kubectl proxy on port $port..."
    kubectl proxy --port="$port" --accept-hosts='^localhost$,^127\.0\.0\.1$'
}

Script de segurança para port-forwards

function kpf-timeout() {
    local service=$1
    local timeout=${2:-300}

    kubectl port-forward service/"$service" 8080:80 &
    local pid=$!

    (sleep "$timeout" && kill $pid 2>/dev/null) &
    wait $pid 2>/dev/null
    echo "Port-forward closed after $timeout seconds"
}

7. Wrappers para Backup e Exportação de Configuração

Função kbackup() - Exportação de recursos

function kbackup() {
    local ns=$1
    local dir="backup-${ns}-$(date +%Y%m%d)"

    mkdir -p "$dir"
    for resource in pods services deployments configmaps secrets; do
        kubectl get "$resource" -n "$ns" -o yaml > "$dir/${resource}.yaml"
    done
    echo "Backup saved to $dir"
}

Função kdiff() - Comparação de manifestos

function kdiff() {
    local manifest=$1
    local resource=$(basename "$manifest" .yaml)
    local name=$(yq eval '.metadata.name' "$manifest")
    local kind=$(yq eval '.kind' "$manifest")

    kubectl get "$kind" "$name" -o yaml > /tmp/current.yaml
    diff <(kubectl get "$kind" "$name" -o yaml) "$manifest"
}

Script de restauração segura

function krestore() {
    local backup_dir=$1

    for file in "$backup_dir"/*.yaml; do
        echo "Validating $file..."
        kubectl apply --dry-run=client -f "$file" || continue
        echo "Apply $file? (y/N)"
        read confirm
        [ "$confirm" = "y" ] && kubectl apply -f "$file"
    done
}

8. Considerações Finais e Boas Práticas

Organize todos os wrappers em um único arquivo ~/.kube/helpers.sh:

# ~/.kube/helpers.sh
source ~/.kube/helpers.sh  # Adicione ao .bashrc ou .zshrc

Para carregamento automático, adicione ao seu shellrc:

# .bashrc
if [ -f ~/.kube/helpers.sh ]; then
    source ~/.kube/helpers.sh
fi

Sugestões de extensão incluem integração com fzf para seleção fuzzy, logging centralizado com logger e validação de sintaxe com shellcheck. Mantenha os scripts versionados e documentados para facilitar a colaboração em equipe.

Referências