raijin-server 0.2.0__tar.gz → 0.2.2__tar.gz

{raijin_server-0.2.0/src/raijin_server.egg-info → raijin_server-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raijin-server
-Version: 0.2.0
+Version: 0.2.2
 Summary: CLI para automacao de setup e hardening de servidores Ubuntu Server.
 Home-page: https://example.com/raijin-server
 Author: Equipe Raijin
@@ -39,11 +39,14 @@ CLI em Python (Typer) para automatizar setup e hardening de servidores Ubuntu Se
 
 ## Destaques
 
-- ✅ **Validações de Pré-requisitos**: OS, espaço em disco, memória, conectividade
+- ✅ **Validações de Pré-requisitos**: OS, espaço em disco, memória, conectividade, ambiente Python (venv)
 - ✅ **Health Checks Automáticos**: Valida serviços após instalação
-- ✅ **Retry Inteligente**: Resistente a falhas temporárias de rede
-- ✅ **Logging Estruturado**: Logs persistentes para auditoria
+- ✅ **Retry Inteligente com Backoff**: Resistente a falhas temporárias de rede (5 tentativas, backoff exponencial)
+- ✅ **Logging Estruturado**: Logs persistentes com rotação (20MB, 5 backups)
 - ✅ **Gestão de Dependências**: Garante ordem correta de execução
+- ✅ **Verificação de Cluster**: Módulos que dependem de K8s verificam disponibilidade antes de executar
+- ✅ **Clean Automático**: Opção de limpar instalação anterior ao re-executar kubernetes
+- ✅ **IPv4 Only**: IPv6 desabilitado por padrão para simplificar rede
 - ✅ **Configuração via Arquivo**: Automação completa com YAML/JSON
 - ✅ **Idempotência**: Re-execução segura sem quebrar o sistema
 - ✅ **Modo Dry-run**: Simula execução sem aplicar mudanças
@@ -180,7 +183,9 @@ se deseja pular. Se executar manualmente, basta responder "não" quando pergunta
 
 ### Comandos Úteis
 ```bash
-# Versão
+# Versão (flag ou comando)
+raijin-server --version
+raijin-server -V
 raijin-server version
 
 # Monitorar logs
@@ -222,9 +227,9 @@ tail -f /var/log/raijin-server/raijin-server.log
 - `network`: Netplan com IP fixo e DNS. **OPCIONAL** se IP já configurado pelo provedor ISP.
 - `firewall`: UFW com regras para SSH/HTTP/HTTPS/K8s.
 - `vpn`: provisiona WireGuard (servidor + cliente inicial) e libera firewall.
-- `kubernetes`: kubeadm init, containerd SystemdCgroup, kubeconfig.
-- `calico`: CNI Calico com CIDR custom, default-deny e opcao de liberar egress rotulado.
-- `cert_manager`: instala cert-manager e ClusterIssuer ACME (HTTP-01/DNS-01).
+- `kubernetes`: kubeadm init, containerd SystemdCgroup, kubeconfig. **Oferece limpeza automática** se detectar instalação anterior. IPv6 desabilitado por padrão.
+- `calico`: CNI Calico com CIDR custom, default-deny e opcao de liberar egress rotulado. **Verifica cluster ativo** antes de aplicar.
+- `cert_manager`: instala cert-manager e ClusterIssuer ACME (HTTP-01/DNS-01). **Verifica cluster ativo** antes de instalar.
 - `secrets`: instala sealed-secrets e external-secrets via Helm.
 - `istio`: istioctl install (perfil raijin) e injeção automática.
 - `traefik`: IngressController com TLS/ACME.

{raijin_server-0.2.0 → raijin_server-0.2.2}/README.md

@@ -6,11 +6,14 @@ CLI em Python (Typer) para automatizar setup e hardening de servidores Ubuntu Se
 
 ## Destaques
 
-- ✅ **Validações de Pré-requisitos**: OS, espaço em disco, memória, conectividade
+- ✅ **Validações de Pré-requisitos**: OS, espaço em disco, memória, conectividade, ambiente Python (venv)
 - ✅ **Health Checks Automáticos**: Valida serviços após instalação
-- ✅ **Retry Inteligente**: Resistente a falhas temporárias de rede
-- ✅ **Logging Estruturado**: Logs persistentes para auditoria
+- ✅ **Retry Inteligente com Backoff**: Resistente a falhas temporárias de rede (5 tentativas, backoff exponencial)
+- ✅ **Logging Estruturado**: Logs persistentes com rotação (20MB, 5 backups)
 - ✅ **Gestão de Dependências**: Garante ordem correta de execução
+- ✅ **Verificação de Cluster**: Módulos que dependem de K8s verificam disponibilidade antes de executar
+- ✅ **Clean Automático**: Opção de limpar instalação anterior ao re-executar kubernetes
+- ✅ **IPv4 Only**: IPv6 desabilitado por padrão para simplificar rede
 - ✅ **Configuração via Arquivo**: Automação completa com YAML/JSON
 - ✅ **Idempotência**: Re-execução segura sem quebrar o sistema
 - ✅ **Modo Dry-run**: Simula execução sem aplicar mudanças
@@ -147,7 +150,9 @@ se deseja pular. Se executar manualmente, basta responder "não" quando pergunta
 
 ### Comandos Úteis
 ```bash
-# Versão
+# Versão (flag ou comando)
+raijin-server --version
+raijin-server -V
 raijin-server version
 
 # Monitorar logs
@@ -189,9 +194,9 @@ tail -f /var/log/raijin-server/raijin-server.log
 - `network`: Netplan com IP fixo e DNS. **OPCIONAL** se IP já configurado pelo provedor ISP.
 - `firewall`: UFW com regras para SSH/HTTP/HTTPS/K8s.
 - `vpn`: provisiona WireGuard (servidor + cliente inicial) e libera firewall.
-- `kubernetes`: kubeadm init, containerd SystemdCgroup, kubeconfig.
-- `calico`: CNI Calico com CIDR custom, default-deny e opcao de liberar egress rotulado.
-- `cert_manager`: instala cert-manager e ClusterIssuer ACME (HTTP-01/DNS-01).
+- `kubernetes`: kubeadm init, containerd SystemdCgroup, kubeconfig. **Oferece limpeza automática** se detectar instalação anterior. IPv6 desabilitado por padrão.
+- `calico`: CNI Calico com CIDR custom, default-deny e opcao de liberar egress rotulado. **Verifica cluster ativo** antes de aplicar.
+- `cert_manager`: instala cert-manager e ClusterIssuer ACME (HTTP-01/DNS-01). **Verifica cluster ativo** antes de instalar.
 - `secrets`: instala sealed-secrets e external-secrets via Helm.
 - `istio`: istioctl install (perfil raijin) e injeção automática.
 - `traefik`: IngressController com TLS/ACME.

{raijin_server-0.2.0 → raijin_server-0.2.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = raijin-server
-version = 0.2.0
+version = 0.2.2
 description = CLI para automacao de setup e hardening de servidores Ubuntu Server.
 long_description = file: README.md
 long_description_content_type = text/markdown

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/__init__.py

@@ -1,5 +1,5 @@
 """Pacote principal do CLI Raijin Server."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = ["__version__"]

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/cli.py

@@ -265,6 +265,14 @@ def _render_menu(dry_run: bool) -> int:
     return exit_idx
 
 
+def _version_callback(value: bool) -> None:
+    """Imprime a versao e encerra imediatamente."""
+
+    if value:
+        typer.echo(f"raijin-server {__version__}")
+        raise typer.Exit()
+
+
 def interactive_menu(ctx: typer.Context) -> None:
     exec_ctx = ctx.obj or ExecutionContext()
     current_dry_run = exec_ctx.dry_run
@@ -315,6 +323,15 @@ def main(
     module: Optional[str] = typer.Option(None, "-m", "--module", help="Modulo a executar"),
     dry_run: bool = typer.Option(False, "-n", "--dry-run", help="Mostra comandos sem executa-los."),
     skip_validation: bool = typer.Option(False, "--skip-validation", help="Pula validacoes de pre-requisitos"),
+    skip_root: bool = typer.Option(False, "--skip-root", help="Permite validar sem exigir root (nao recomendado)"),
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-V",
+        is_eager=True,
+        callback=_version_callback,
+        help="Mostra a versao do CLI e sai",
+    ),
 ) -> None:
     """Mostra um menu simples quando nenhum subcomando e informado."""
 
@@ -322,7 +339,7 @@ def main(
 
     # Executa validacoes de pre-requisitos
     if not skip_validation and not dry_run:
-        if not validate_system_requirements(ctx.obj, skip_root=False):
+        if not validate_system_requirements(ctx.obj, skip_root=skip_root):
             typer.secho("\nAbortando devido a pre-requisitos nao atendidos.", fg=typer.colors.RED)
             typer.echo("Use --skip-validation para pular validacoes (nao recomendado).")
             raise typer.Exit(code=1)

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/modules/bootstrap.py

@@ -87,17 +87,37 @@ def _install_istioctl(ctx: ExecutionContext) -> None:
         return
 
     typer.echo(f"Instalando istioctl v{ISTIOCTL_VERSION}...")
+    
+    # Limpa tentativas anteriores
+    istio_dir = Path(f"/tmp/istio-{ISTIOCTL_VERSION}")
+    if istio_dir.exists() and not ctx.dry_run:
+        run_cmd(["rm", "-rf", str(istio_dir)], ctx, check=False)
+    
+    # Download do Istio
     run_cmd(
         f"curl -L https://istio.io/downloadIstio | ISTIO_VERSION={ISTIOCTL_VERSION} sh -",
         ctx,
         use_shell=True,
         cwd="/tmp",
     )
+    
+    # Verifica se o download foi bem sucedido
+    istioctl_path = Path(f"/tmp/istio-{ISTIOCTL_VERSION}/bin/istioctl")
+    if not ctx.dry_run and not istioctl_path.exists():
+        typer.secho(
+            f"Falha ao baixar istioctl. Arquivo nao encontrado: {istioctl_path}",
+            fg=typer.colors.RED,
+        )
+        typer.secho("Verifique sua conexao de internet e tente novamente.", fg=typer.colors.YELLOW)
+        ctx.warnings.append("istioctl nao instalado - download falhou")
+        return  # Nao falha o modulo inteiro, apenas avisa
+    
     run_cmd(
-        ["mv", f"/tmp/istio-{ISTIOCTL_VERSION}/bin/istioctl", "/usr/local/bin/istioctl"],
+        ["mv", str(istioctl_path), "/usr/local/bin/istioctl"],
         ctx,
     )
     run_cmd(["chmod", "+x", "/usr/local/bin/istioctl"], ctx)
+    typer.secho("✓ istioctl instalado com sucesso.", fg=typer.colors.GREEN)
 
 
 def _install_velero(ctx: ExecutionContext) -> None:

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/modules/calico.py

@@ -62,11 +62,40 @@ def _split_namespaces(raw_value: str) -> Iterable[str]:
     return [ns.strip() for ns in raw_value.split(",") if ns.strip()]
 
 
+def _check_cluster_available(ctx: ExecutionContext) -> bool:
+    """Verifica se o cluster Kubernetes esta acessivel."""
+    if ctx.dry_run:
+        return True
+    try:
+        result = run_cmd(
+            ["kubectl", "cluster-info"],
+            ctx,
+            check=False,
+            retries=1,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
 def run(ctx: ExecutionContext) -> None:
     require_root(ctx)
     ensure_tool("kubectl", ctx, install_hint="Instale kubectl ou habilite dry-run.")
     ensure_tool("curl", ctx, install_hint="Instale curl.")
 
+    # Verifica se cluster esta disponivel antes de aplicar
+    if not _check_cluster_available(ctx):
+        typer.secho(
+            "✗ Cluster Kubernetes nao esta acessivel. Execute o modulo 'kubernetes' primeiro.",
+            fg=typer.colors.RED,
+        )
+        typer.secho(
+            "  Verifique: kubectl cluster-info",
+            fg=typer.colors.YELLOW,
+        )
+        ctx.errors.append("Calico: cluster nao acessivel")
+        raise typer.Exit(code=1)
+
     typer.echo("Aplicando Calico como CNI...")
     pod_cidr = typer.prompt("Pod CIDR (Calico)", default="10.244.0.0/16")
 

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/modules/cert_manager.py

@@ -79,11 +79,40 @@ stringData:
 """
 
 
+def _check_cluster_available(ctx: ExecutionContext) -> bool:
+    """Verifica se o cluster Kubernetes esta acessivel."""
+    if ctx.dry_run:
+        return True
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["kubectl", "cluster-info"],
+            capture_output=True,
+            timeout=30,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
 def run(ctx: ExecutionContext) -> None:
     require_root(ctx)
     ensure_tool("helm", ctx, install_hint="Instale helm ou use --dry-run para simular.")
     ensure_tool("kubectl", ctx, install_hint="Instale kubectl ou use --dry-run para simular.")
 
+    # Verifica se cluster esta disponivel antes de instalar
+    if not _check_cluster_available(ctx):
+        typer.secho(
+            "✗ Cluster Kubernetes nao esta acessivel. Execute o modulo 'kubernetes' primeiro.",
+            fg=typer.colors.RED,
+        )
+        typer.secho(
+            "  Verifique: kubectl cluster-info",
+            fg=typer.colors.YELLOW,
+        )
+        ctx.errors.append("cert-manager: cluster nao acessivel")
+        raise typer.Exit(code=1)
+
     typer.echo("Instalando cert-manager via Helm...")
     email = typer.prompt("Email para ACME (Let's Encrypt)", default="admin@example.com")
     solver = typer.prompt("Tipo de desafio (http01/dns01)", default="http01")

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/modules/kubernetes.py

@@ -35,6 +35,20 @@ def _cleanup_old_repo(ctx: ExecutionContext) -> None:
             typer.echo("Nao foi possivel ler/remover repo antigo apt.kubernetes.io (ok prosseguir).")
 
 
+def _reset_cluster(ctx: ExecutionContext) -> None:
+    """Executa kubeadm reset para limpar instalacao anterior."""
+    typer.secho("Limpando instalacao anterior do Kubernetes...", fg=typer.colors.YELLOW)
+    run_cmd(["kubeadm", "reset", "-f"], ctx, check=False)
+    # Remove configs residuais
+    run_cmd(["rm", "-rf", "/etc/kubernetes/manifests", "/etc/kubernetes/pki"], ctx, check=False)
+    run_cmd(["rm", "-rf", "/var/lib/etcd"], ctx, check=False)
+    run_cmd(["rm", "-rf", "/root/.kube/config"], ctx, check=False)
+    # Remove CNI configs
+    run_cmd(["rm", "-rf", "/etc/cni/net.d"], ctx, check=False)
+    run_cmd(["rm", "-rf", "/var/lib/cni"], ctx, check=False)
+    typer.secho("✓ Limpeza concluida.", fg=typer.colors.GREEN)
+
+
 def run(ctx: ExecutionContext) -> None:
     require_root(ctx)
     typer.echo("Instalando e preparando Kubernetes (kubeadm/kubelet/kubectl)...")
@@ -43,7 +57,10 @@ def run(ctx: ExecutionContext) -> None:
     kubeconfig_exists = Path("/etc/kubernetes/admin.conf").exists()
     if kubeconfig_exists and not ctx.dry_run:
         typer.secho("⚠ Cluster Kubernetes ja parece estar inicializado.", fg=typer.colors.YELLOW)
-        if not typer.confirm("Deseja continuar mesmo assim? (pode causar problemas)"):
+        reset_choice = typer.confirm("Deseja limpar e reinstalar? (recomendado)")
+        if reset_choice:
+            _reset_cluster(ctx)
+        elif not typer.confirm("Deseja continuar sem limpar? (pode causar problemas)"):
             typer.echo("Operacao cancelada pelo usuario.")
             return
 
@@ -130,8 +147,18 @@ def run(ctx: ExecutionContext) -> None:
     enable_service("kubelet", ctx)
 
     # kubeadm exige ip_forward=1; sobrepoe ajuste de hardening para fase de cluster.
-    write_file(Path("/etc/sysctl.d/99-kubernetes.conf"), "net.ipv4.ip_forward=1\n", ctx)
-    run_cmd(["sysctl", "-w", "net.ipv4.ip_forward=1"], ctx, check=False)
+    # Desabilita IPv6 completamente para evitar erros de preflight e simplificar rede
+    sysctl_k8s = """# Kubernetes network settings
+net.ipv4.ip_forward=1
+net.bridge.bridge-nf-call-iptables=1
+net.bridge.bridge-nf-call-ip6tables=1
+# Disable IPv6 completely
+net.ipv6.conf.all.disable_ipv6=1
+net.ipv6.conf.default.disable_ipv6=1
+net.ipv6.conf.lo.disable_ipv6=1
+"""
+    write_file(Path("/etc/sysctl.d/99-kubernetes.conf"), sysctl_k8s, ctx)
+    run_cmd(["sysctl", "--system"], ctx, check=False)
 
     # Prompts de configuracao
     pod_cidr = typer.prompt("Pod CIDR", default="10.244.0.0/16")
@@ -168,7 +195,16 @@ cgroupDriver: systemd
 
     ensure_tool("kubeadm", ctx, install_hint="Instale kubeadm (apt install kubeadm).")
     run_cmd(["kubeadm", "config", "images", "pull"], ctx, check=False)
-    run_cmd(["kubeadm", "init", "--config", str(cfg_path), "--upload-certs"], ctx)
+    # Ignora erros de preflight relacionados a IPv6 (desabilitado)
+    run_cmd(
+        [
+            "kubeadm", "init",
+            "--config", str(cfg_path),
+            "--upload-certs",
+            "--ignore-preflight-errors=FileContent--proc-sys-net-ipv6-conf-default-forwarding",
+        ],
+        ctx,
+    )
 
     # Configura kubeconfig para root e sudoer.
     run_cmd(["mkdir", "-p", "/root/.kube"], ctx)

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/utils.py

@@ -51,9 +51,10 @@ class ExecutionContext:
 
     dry_run: bool = False
     assume_yes: bool = True
-    max_retries: int = 3
-    retry_delay: int = 5
-    timeout: int = 300
+    max_retries: int = 5
+    retry_delay: int = 10
+    retry_backoff: float = 1.5  # Multiplier for exponential backoff
+    timeout: int = 600  # 10 min for slow connections
     errors: list = field(default_factory=list)
     warnings: list = field(default_factory=list)
 
@@ -144,14 +145,24 @@ def run_cmd(
             logger.warning(msg)
             ctx.warnings.append(msg)
             if attempt < max_attempts:
-                time.sleep(ctx.retry_delay)
+                backoff_delay = int(ctx.retry_delay * (ctx.retry_backoff ** (attempt - 1)))
+                typer.secho(
+                    f"Timeout! Aguardando {backoff_delay}s antes de tentar novamente...",
+                    fg=typer.colors.YELLOW,
+                )
+                time.sleep(backoff_delay)
         except subprocess.CalledProcessError as e:
             last_error = e
             msg = f"Comando falhou com codigo {e.returncode} (tentativa {attempt}/{max_attempts})"
             logger.error(f"{msg}: {e.stderr if hasattr(e, 'stderr') else ''}")
             if attempt < max_attempts:
-                typer.secho(f"Tentando novamente em {ctx.retry_delay}s...", fg=typer.colors.YELLOW)
-                time.sleep(ctx.retry_delay)
+                # Exponential backoff: delay * backoff^(attempt-1)
+                backoff_delay = int(ctx.retry_delay * (ctx.retry_backoff ** (attempt - 1)))
+                typer.secho(
+                    f"Tentando novamente em {backoff_delay}s... (possivel instabilidade de rede)",
+                    fg=typer.colors.YELLOW,
+                )
+                time.sleep(backoff_delay)
             else:
                 ctx.errors.append(msg)
                 if check:

{raijin_server-0.2.0 → raijin_server-0.2.2}/src/raijin_server/validators.py

@@ -6,6 +6,8 @@ import os
 import platform
 import shutil
 import subprocess
+import sys
+import urllib.request
 from pathlib import Path
 from typing import List, Tuple
 
@@ -77,10 +79,11 @@ def check_memory(min_gb: int = 4) -> Tuple[bool, str]:
 
 
 def check_connectivity(hosts: List[str] | None = None) -> Tuple[bool, str]:
-    """Verifica conectividade com internet."""
+    """Verifica conectividade com internet via ICMP e HTTP."""
     if hosts is None:
         hosts = ["8.8.8.8", "1.1.1.1"]
 
+    # Primeiro tenta ICMP
     for host in hosts:
         try:
             result = subprocess.run(
@@ -93,7 +96,13 @@ def check_connectivity(hosts: List[str] | None = None) -> Tuple[bool, str]:
         except Exception:
             continue
 
-    return False, "Sem conectividade com internet"
+    # Fallback HTTP (caso ICMP seja bloqueado)
+    try:
+        req = urllib.request.Request("https://www.google.com", method="HEAD")
+        with urllib.request.urlopen(req, timeout=5):
+            return True, "Conectividade HTTP OK (https://www.google.com)"
+    except Exception:
+        return False, "Sem conectividade com internet (ICMP e HTTP falharam)"
 
 
 def check_required_commands(commands: List[str] | None = None) -> Tuple[bool, List[str]]:
@@ -111,11 +120,34 @@ def check_required_commands(commands: List[str] | None = None) -> Tuple[bool, Li
     return True, []
 
 
+def check_virtualenv() -> Tuple[bool, str]:
+    """Valida se a execucao esta dentro de um ambiente isolado (venv/pyenv)."""
+
+    in_venv = sys.prefix != sys.base_prefix or os.environ.get("VIRTUAL_ENV")
+    externally_managed = Path(sys.prefix).joinpath("../EXTERNALLY-MANAGED").resolve()
+
+    if in_venv:
+        return True, "Executando em ambiente virtual"
+
+    if externally_managed.exists():
+        return False, (
+            "Python gerenciado pelo sistema. Crie um venv: "
+            "python3 -m venv .venv && source .venv/bin/activate && pip install -U pip setuptools && "
+            "pip install raijin-server"
+        )
+
+    return False, (
+        "Execucao fora de venv detectada. Crie um venv: "
+        "python3 -m venv .venv && source .venv/bin/activate && pip install -U pip setuptools && "
+        "pip install raijin-server"
+    )
+
+
 def check_is_root() -> Tuple[bool, str]:
     """Verifica se esta executando como root."""
     if os.geteuid() == 0:
         return True, "Executando como root"
-    return False, "Usuario nao e root (use sudo)"
+    return False, "Usuario nao e root (reexecute com: sudo -E raijin-server ...)"
 
 
 def validate_system_requirements(ctx: ExecutionContext, skip_root: bool = False) -> bool:
@@ -128,6 +160,7 @@ def validate_system_requirements(ctx: ExecutionContext, skip_root: bool = False)
     typer.secho("\n=== Validacao de Pre-requisitos ===", fg=typer.colors.CYAN, bold=True)
 
     checks = [
+        ("Ambiente Python", check_virtualenv()),
         ("Sistema Operacional", check_os_version()),
         ("Espaco em Disco", check_disk_space()),
         ("Memoria RAM", check_memory()),
@@ -142,7 +175,8 @@ def validate_system_requirements(ctx: ExecutionContext, skip_root: bool = False)
     if cmd_ok:
         checks.append(("Comandos Essenciais", (True, "Todos os comandos disponiveis")))
     else:
-        checks.append(("Comandos Essenciais", (False, f"Faltando: {', '.join(missing)}")))
+        install_hint = "sudo apt-get update && sudo apt-get install -y " + " ".join(missing)
+        checks.append(("Comandos Essenciais", (False, f"Faltando: {', '.join(missing)} | Sugestao: {install_hint}")))
 
     all_passed = True
     for name, (passed, message) in checks:

{raijin_server-0.2.0 → raijin_server-0.2.2/src/raijin_server.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raijin-server
-Version: 0.2.0
+Version: 0.2.2
 Summary: CLI para automacao de setup e hardening de servidores Ubuntu Server.
 Home-page: https://example.com/raijin-server
 Author: Equipe Raijin
@@ -39,11 +39,14 @@ CLI em Python (Typer) para automatizar setup e hardening de servidores Ubuntu Se
 
 ## Destaques
 
-- ✅ **Validações de Pré-requisitos**: OS, espaço em disco, memória, conectividade
+- ✅ **Validações de Pré-requisitos**: OS, espaço em disco, memória, conectividade, ambiente Python (venv)
 - ✅ **Health Checks Automáticos**: Valida serviços após instalação
-- ✅ **Retry Inteligente**: Resistente a falhas temporárias de rede
-- ✅ **Logging Estruturado**: Logs persistentes para auditoria
+- ✅ **Retry Inteligente com Backoff**: Resistente a falhas temporárias de rede (5 tentativas, backoff exponencial)
+- ✅ **Logging Estruturado**: Logs persistentes com rotação (20MB, 5 backups)
 - ✅ **Gestão de Dependências**: Garante ordem correta de execução
+- ✅ **Verificação de Cluster**: Módulos que dependem de K8s verificam disponibilidade antes de executar
+- ✅ **Clean Automático**: Opção de limpar instalação anterior ao re-executar kubernetes
+- ✅ **IPv4 Only**: IPv6 desabilitado por padrão para simplificar rede
 - ✅ **Configuração via Arquivo**: Automação completa com YAML/JSON
 - ✅ **Idempotência**: Re-execução segura sem quebrar o sistema
 - ✅ **Modo Dry-run**: Simula execução sem aplicar mudanças
@@ -180,7 +183,9 @@ se deseja pular. Se executar manualmente, basta responder "não" quando pergunta
 
 ### Comandos Úteis
 ```bash
-# Versão
+# Versão (flag ou comando)
+raijin-server --version
+raijin-server -V
 raijin-server version
 
 # Monitorar logs
@@ -222,9 +227,9 @@ tail -f /var/log/raijin-server/raijin-server.log
 - `network`: Netplan com IP fixo e DNS. **OPCIONAL** se IP já configurado pelo provedor ISP.
 - `firewall`: UFW com regras para SSH/HTTP/HTTPS/K8s.
 - `vpn`: provisiona WireGuard (servidor + cliente inicial) e libera firewall.
-- `kubernetes`: kubeadm init, containerd SystemdCgroup, kubeconfig.
-- `calico`: CNI Calico com CIDR custom, default-deny e opcao de liberar egress rotulado.
-- `cert_manager`: instala cert-manager e ClusterIssuer ACME (HTTP-01/DNS-01).
+- `kubernetes`: kubeadm init, containerd SystemdCgroup, kubeconfig. **Oferece limpeza automática** se detectar instalação anterior. IPv6 desabilitado por padrão.
+- `calico`: CNI Calico com CIDR custom, default-deny e opcao de liberar egress rotulado. **Verifica cluster ativo** antes de aplicar.
+- `cert_manager`: instala cert-manager e ClusterIssuer ACME (HTTP-01/DNS-01). **Verifica cluster ativo** antes de instalar.
 - `secrets`: instala sealed-secrets e external-secrets via Helm.
 - `istio`: istioctl install (perfil raijin) e injeção automática.
 - `traefik`: IngressController com TLS/ACME.