raijin-server 0.1.0__py3-none-any.whl

raijin_server/validators.py

@@ -0,0 +1,230 @@
+"""Validadores de pre-requisitos do sistema."""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Tuple
+
+import typer
+
+from raijin_server.utils import ExecutionContext, logger
+
+
+class ValidationError(Exception):
+    """Erro de validacao de pre-requisitos."""
+
+    pass
+
+
+def check_os_version() -> Tuple[bool, str]:
+    """Valida se o OS e Ubuntu Server 24.04 ou compativel."""
+    try:
+        if platform.system() != "Linux":
+            return False, f"Sistema operacional nao suportado: {platform.system()}"
+
+        # Verifica /etc/os-release
+        os_release = Path("/etc/os-release")
+        if not os_release.exists():
+            return False, "Arquivo /etc/os-release nao encontrado"
+
+        content = os_release.read_text()
+        is_ubuntu = "ubuntu" in content.lower()
+
+        if not is_ubuntu:
+            return False, "Sistema nao e Ubuntu"
+
+        # Extrai versao
+        version_line = [line for line in content.split("\n") if line.startswith("VERSION_ID=")]
+        if version_line:
+            version = version_line[0].split("=")[1].strip('"')
+            version_major = float(version.split(".")[0])
+            if version_major < 20:
+                return False, f"Ubuntu {version} muito antigo (minimo: 20.04)"
+
+        return True, f"Ubuntu detectado: {version if version_line else 'versao desconhecida'}"
+    except Exception as e:
+        return False, f"Erro ao verificar OS: {e}"
+
+
+def check_disk_space(min_gb: int = 20) -> Tuple[bool, str]:
+    """Verifica espaco em disco disponivel."""
+    try:
+        stat = os.statvfs("/")
+        free_gb = (stat.f_bavail * stat.f_frsize) / (1024**3)
+        if free_gb < min_gb:
+            return False, f"Espaco insuficiente: {free_gb:.1f}GB (minimo: {min_gb}GB)"
+        return True, f"Espaco em disco OK: {free_gb:.1f}GB disponiveis"
+    except Exception as e:
+        return False, f"Erro ao verificar disco: {e}"
+
+
+def check_memory(min_gb: int = 4) -> Tuple[bool, str]:
+    """Verifica memoria RAM disponivel."""
+    try:
+        with open("/proc/meminfo") as f:
+            meminfo = f.read()
+        mem_total_kb = int([line for line in meminfo.split("\n") if "MemTotal" in line][0].split()[1])
+        mem_total_gb = mem_total_kb / (1024**2)
+        if mem_total_gb < min_gb:
+            return False, f"Memoria insuficiente: {mem_total_gb:.1f}GB (minimo: {min_gb}GB)"
+        return True, f"Memoria RAM OK: {mem_total_gb:.1f}GB"
+    except Exception as e:
+        return False, f"Erro ao verificar memoria: {e}"
+
+
+def check_connectivity(hosts: List[str] | None = None) -> Tuple[bool, str]:
+    """Verifica conectividade com internet."""
+    if hosts is None:
+        hosts = ["8.8.8.8", "1.1.1.1"]
+
+    for host in hosts:
+        try:
+            result = subprocess.run(
+                ["ping", "-c", "1", "-W", "2", host],
+                capture_output=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                return True, f"Conectividade OK (testado: {host})"
+        except Exception:
+            continue
+
+    return False, "Sem conectividade com internet"
+
+
+def check_required_commands(commands: List[str] | None = None) -> Tuple[bool, List[str]]:
+    """Verifica se comandos essenciais estao disponiveis."""
+    if commands is None:
+        commands = ["curl", "wget", "apt-get", "systemctl"]
+
+    missing = []
+    for cmd in commands:
+        if not shutil.which(cmd):
+            missing.append(cmd)
+
+    if missing:
+        return False, missing
+    return True, []
+
+
+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)"
+
+
+def validate_system_requirements(ctx: ExecutionContext, skip_root: bool = False) -> bool:
+    """Executa todas as validacoes de pre-requisitos.
+
+    Returns:
+        True se todas as validacoes passaram, False caso contrario.
+    """
+    logger.info("Iniciando validacao de pre-requisitos do sistema...")
+    typer.secho("\n=== Validacao de Pre-requisitos ===", fg=typer.colors.CYAN, bold=True)
+
+    checks = [
+        ("Sistema Operacional", check_os_version()),
+        ("Espaco em Disco", check_disk_space()),
+        ("Memoria RAM", check_memory()),
+        ("Conectividade", check_connectivity()),
+    ]
+
+    if not skip_root:
+        checks.insert(0, ("Permissoes Root", check_is_root()))
+
+    # Comandos essenciais
+    cmd_ok, missing = check_required_commands()
+    if cmd_ok:
+        checks.append(("Comandos Essenciais", (True, "Todos os comandos disponiveis")))
+    else:
+        checks.append(("Comandos Essenciais", (False, f"Faltando: {', '.join(missing)}")))
+
+    all_passed = True
+    for name, (passed, message) in checks:
+        icon = "✓" if passed else "✗"
+        color = typer.colors.GREEN if passed else typer.colors.RED
+        typer.secho(f"  {icon} {name}: {message}", fg=color)
+        logger.info(f"Validacao '{name}': {'PASS' if passed else 'FAIL'} - {message}")
+
+        if not passed:
+            all_passed = False
+            ctx.errors.append(f"Validacao falhou: {name} - {message}")
+
+    typer.echo("")
+
+    if not all_passed:
+        if ctx.dry_run:
+            typer.secho("⚠ Validacoes falharam, mas continuando em modo dry-run", fg=typer.colors.YELLOW)
+            return True
+        else:
+            typer.secho("✗ Pre-requisitos nao atendidos. Corrija os problemas acima.", fg=typer.colors.RED, bold=True)
+            logger.error("Pre-requisitos do sistema nao atendidos")
+            return False
+
+    typer.secho("✓ Todos os pre-requisitos atendidos!", fg=typer.colors.GREEN, bold=True)
+    logger.info("Validacao de pre-requisitos concluida com sucesso")
+    return True
+
+
+def check_module_dependencies(module: str, ctx: ExecutionContext) -> bool:
+    """Verifica se os modulos dependentes ja foram executados.
+
+    Args:
+        module: Nome do modulo a ser executado
+        ctx: Contexto de execucao
+
+    Returns:
+        True se todas as dependencias foram satisfeitas
+    """
+    dependencies = {
+        "kubernetes": ["essentials", "network", "firewall"],
+        "calico": ["kubernetes"],
+        "istio": ["kubernetes", "calico"],
+        "traefik": ["kubernetes"],
+        "kong": ["kubernetes"],
+        "minio": ["kubernetes"],
+        "prometheus": ["kubernetes"],
+        "grafana": ["kubernetes", "prometheus"],
+        "loki": ["kubernetes"],
+        "harness": ["kubernetes"],
+        "velero": ["kubernetes"],
+        "kafka": ["kubernetes"],
+    }
+
+    if module not in dependencies:
+        return True
+
+    required = dependencies[module]
+    missing = []
+
+    # Verifica arquivos de estado
+    state_dir = Path(os.environ.get("RAIJIN_STATE_DIR", "/var/lib/raijin-server/state"))
+    if not state_dir.exists():
+        state_dir = Path.home() / ".local/share/raijin-server/state"
+
+    for dep in required:
+        state_file = state_dir / f"{dep}.done"
+        if not state_file.exists():
+            missing.append(dep)
+
+    if missing:
+        if ctx.dry_run:
+            typer.secho(
+                f"⚠ Modulo '{module}' requer: {', '.join(missing)} (ignorado em dry-run)",
+                fg=typer.colors.YELLOW,
+            )
+            return True
+        else:
+            typer.secho(
+                f"✗ Modulo '{module}' requer os seguintes modulos executados primeiro: {', '.join(missing)}",
+                fg=typer.colors.RED,
+            )
+            logger.error(f"Dependencias nao satisfeitas para modulo '{module}': {missing}")
+            return False
+
+    return True

raijin_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: raijin-server
+Version: 0.1.0
+Summary: CLI para automacao de setup e hardening de servidores Ubuntu Server.
+Home-page: https://example.com/raijin-server
+Author: Equipe Raijin
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: System Administrators
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.7
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6.0; extra == "yaml"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Provides-Extra: all
+Requires-Dist: pyyaml>=6.0; extra == "all"
+Requires-Dist: pytest>=7.0; extra == "all"
+Requires-Dist: pytest-cov>=4.0; extra == "all"
+Requires-Dist: black>=23.0; extra == "all"
+Requires-Dist: ruff>=0.1; extra == "all"
+Dynamic: license-file
+
+# raijin-server
+
+CLI em Python (Typer) para automatizar setup e hardening de servidores Ubuntu Server em ambientes produtivos. Orquestra rede, firewall, Kubernetes, observabilidade e backups para acelerar a subida de clusters e workloads.
+
+**✨ Versão Auditada e Resiliente para Produção**
+
+## Destaques
+
+- ✅ **Validações de Pré-requisitos**: OS, espaço em disco, memória, conectividade
+- ✅ **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
+- ✅ **Gestão de Dependências**: Garante ordem correta de execução
+- ✅ **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
+
+## Requisitos
+
+- Python >= 3.9
+- Ubuntu Server 20.04+ (testado em 24.04)
+- Permissões root/sudo
+- Conectividade com internet
+- Mínimo 4GB RAM, 20GB disco livre
+- Ferramentas: `curl`, `apt-get`, `systemctl`
+
+Ferramentas adicionais (instaladas pelos módulos quando necessário):
+- `helm` (>=3.8 para OCI)
+- `kubectl`, `kubeadm`
+- `velero`, `istioctl`
+
+## Instalacao
+
+Sem venv (global):
+
+```bash
+python -m pip install .
+```
+
+Com venv (recomendado para desenvolvimento):
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -e .
+```
+
+## Uso rapido
+
+### Validar Sistema
+```bash
+# Verifica se o sistema atende pré-requisitos
+sudo raijin-server validate
+```
+
+### Menu Interativo
+```bash
+# Menu visual com stautils.py`: Funções utilitárias com retry, timeout e logging.
+- `src/raijin_server/validators.py`: Validações de pré-requisitos e dependências.
+- `src/raijin_server/healthchecks.py`: Health checks pós-instalação.
+- `src/raijin_server/config.py`: Gerenciamento de configuração via arquivo.
+- `src/raijin_server/modules/`: Automações por tópico (hardening, network, essentials, firewall, kubernetes, calico, istio, traefik, kong, minio, prometheus, grafana, loki, harness, velero, kafka).
+- `scripts/`: Espaço para shells e templates auxiliares.
+- `ARCHITECTURE.md`: Visão do desenho técnico.
+- `AUDIT.md`: Relatório completo de auditoria e melhorias.
+- `SECURITY.md`: Como reportar vulnerabilidades
+### Execução Direta de Módulos
+```bash
+# Executar módulo específico
+sudo raijin-server kubernetes
+
+# Dry-run (simula sem aplicar)
+sudo raijin-server --dry-run kubernetes
+
+# Pular validações (não recomendado)
+sudo raijin-server --skip-validation kubernetes
+```
+
+### Automação via Arquivo de Configuração
+```bash
+# Gerar template de configuração
+ra✅ Validações de pré-requisitos e health-check por módulo
+- ✅ Gestão automática de dependências entre módulos
+- ✅ Sistema de logging estruturado e persistente
+- ✅ Retry automático e timeouts configuráveis
+- ✅ Configuração via arquivo YAML/JSON
+- ⏳ Provisionar ingress seguro para Grafana/Prometheus/Alertmanager
+- ⏳ Dashboards e alertas opinativos prontos para uso
+- ⏳ Suporte a sealed-secrets/external-secrets para credenciais
+- ⏳ Testes automatizados (pytest) e linters
+- ⏳ Rollback automático em falhas
+- ⏳ Modo de instalação mínima vs completa
+
+## Documentação Adicional
+
+- **[AUDIT.md](AUDIT.md)**: Relatório completo de auditoria e melhorias implementadas
+- **[ARCHITECTURE.md](ARCHITECTURE.md)**: Arquitetura técnica do ambiente
+- **[SECURITY.md](SECURITY.md)**: Políticas de segurança e reporte de vulnerabilidades
+
+## Fluxo de Execução Recomendado
+
+```bash
+# 1. Validar sistema
+sudo raijin-server validate
+
+# 2. Base do sistema
+sudo raijin-server essentials
+sudo raijin-server hardening
+sudo raijin-server network
+sudo raijin-server firewall
+
+# 3. Kubernetes
+sudo raijin-server kubernetes
+sudo raijin-server calico
+
+# 4. Ingress (escolha um)
+sudo raijin-server traefik
+# OU
+sudo raijin-server kong
+
+# 5. Observabilidade
+sudo raijin-server prometheus
+sudo raijin-server grafana
+sudo raijin-server loki
+
+# 6. Storage e Mensageria (opcional)
+sudo raijin-server minio
+sudo raijin-server kafka
+
+# 7. Backup
+sudo raijin-server velero
+
+# 8. Service Mesh (opcional)
+sudo raijin-server istio
+```
+# Executar com configuração
+sudo raijin-server --config production.yaml kubernetes
+```
+
+### Comandos Úteis
+```bash
+# Versão
+raijin-server version
+
+# Monitorar logs
+tail -f /var/log/raijin-server/raijin-server.log
+```
+
+## Estrutura
+
+- `src/raijin_server/cli.py`: CLI principal com Typer, banner e `--dry-run`.
+- `src/raijin_server/modules/`: automacoes por topico (hardening, network, essentials, firewall, kubernetes, calico, istio, traefik, kong, minio, prometheus, grafana, loki, harness, velero, kafka).
+- `scripts/`: espaco para shells e templates.
+- `ARCHITECTURE.md`: visao do desenho atual.
+- `SECURITY.md`: como reportar e pensar seguranca.
+
+## Modulos disponiveis
+
+- `hardening`: fail2ban, unattended-upgrades, sysctl.
+- `essentials`: pacotes base (curl, git, jq, etc.) e NTP.
+- `network`: Netplan com IP fixo e DNS.
+- `firewall`: UFW com regras para SSH/HTTP/HTTPS/K8s.
+- `kubernetes`: kubeadm init, containerd SystemdCgroup, kubeconfig.
+- `calico`: CNI Calico com CIDR custom e policy default-deny.
+- `istio`: istioctl install (perfil raijin) e injeção automática.
+- `traefik`: IngressController com TLS/ACME.
+- `kong`: Ingress/Gateway com Helm.
+- `minio`: armazenamento S3 compatível via Helm.
+- `prometheus`, `grafana`, `loki`: observabilidade, dashboards e persistencia.
+- `harness`: delegate Helm com parametros interativos.
+- `velero`: backup/restore com schedule.
+- `kafka`: deploy Bitnami via OCI.
+
+## Roadmap basico
+
+- Adicionar validacoes de pre-requisitos e health-check por modulo.
+- Provisionar ingress seguro para Grafana/Prometheus/Alertmanager.
+- Dashboards e alertas opinativos prontos para uso.
+- Suporte a sealed-secrets/external-secrets para credenciais.
+- Testes automatizados (pytest) e linters.
+
+## Proximos passos sugeridos
+
+- Substituir os stubs por comandos reais (apt, ufw, helm, kubectl, etc.).
+- Adicionar validacoes e testes (por exemplo, pytest + testcontainers).
+- Empacotar scripts auxiliares em `scripts/` e referencia-los nos modulos.

raijin_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+raijin_server/__init__.py,sha256=JtoND-o0nm6bupzu-VJPw5itxg6wM-OlvlNI1RNU4Ao,94
+raijin_server/cli.py,sha256=WMPxcVqbedP-HEpdflV9nqsVr5UytZT6TuZIu9uvuR0,14448
+raijin_server/config.py,sha256=Dta2CS1d6RgNiQ84P6dTXk98boFrjzuvhs_fCdlm0I4,4810
+raijin_server/healthchecks.py,sha256=IA7HOvDnN9Qhq8q26eAnWXeiIj0VpEOJGDIU4Qq9DQs,9879
+raijin_server/utils.py,sha256=XQJxyzo5Edxtapf-n5SSpEmJvkkfrE7p8VZcWyapll8,7477
+raijin_server/validators.py,sha256=z7CIMzDH6Aczvqz7Mb8ICzEud6KTsh7_2Q_pP6wDQkc,7691
+raijin_server/modules/__init__.py,sha256=uQkNtU7rmYAKBrAlrVQGySuoSBW68lTmKd5YaLl2Zn0,603
+raijin_server/modules/bootstrap.py,sha256=pMgtNb9a6wPFK7L16kQoQ-v1oB8-l7C9lrEZ6IqDtm4,6723
+raijin_server/modules/calico.py,sha256=mWbmFixkebdDK0cIHAg-WR2i8zBHA49Nr_pm7dbeYOQ,1281
+raijin_server/modules/essentials.py,sha256=2xUXCyCQtFGd2DnCKV81N1R6bEJqH8zaet8mLovtQ1I,689
+raijin_server/modules/firewall.py,sha256=h6AISqiZeTinVT7BjmQIS872qRAFZJLg7meqlth3cfw,757
+raijin_server/modules/full_install.py,sha256=vN4H46Oyt_MAGMrO_AzcMNtRaJK3IQcSTRgs52gU0zc,4237
+raijin_server/modules/grafana.py,sha256=zxYpWBM-fD8vTgoJ2Hmb9P66wz_JuiidO6_cGK3jG30,1809
+raijin_server/modules/hardening.py,sha256=4hz3ifkMhPlXa2n7gPxN0gitQgzALZ-073vuU3LM4RI,1616
+raijin_server/modules/harness.py,sha256=dhZ89YIhlkuxiRU1deN6wXVWnXm0xeI03PwYf_qgfak,1527
+raijin_server/modules/istio.py,sha256=761FOGEzEXWlTLYApQxUWY8l4cnEbnIXbIHK3itk_AQ,522
+raijin_server/modules/kafka.py,sha256=bp8k_IhuAIO6dL0IpK1UxxLZoGih6nJp0ZnzwmiZEj8,950
+raijin_server/modules/kong.py,sha256=2EZKYBmBhm_7Nduw9PWrvrekp0VCxQbc2gElpAJqKfg,491
+raijin_server/modules/kubernetes.py,sha256=B_J2mHLjMNglksnZk08HSK3z55kNytuq5sVBbjAXbLY,6846
+raijin_server/modules/loki.py,sha256=erwFfSiSFOv-Ul3nFdrI2RElPYuqqBPBBa_MJAwyLys,676
+raijin_server/modules/minio.py,sha256=BVvsEaJlJUV92_ep7pKsBhSYPjWZrDOB3J6XAWYAHYg,486
+raijin_server/modules/network.py,sha256=aGHAOMfjhk4HhNRy50fAvU-Gseabsgh0t7xLfSK2tJ0,1651
+raijin_server/modules/prometheus.py,sha256=Et-Tj6LrM7WDyoYRSY464E67TrEHbRe2G8T8obagC48,1066
+raijin_server/modules/traefik.py,sha256=iA_ke9w7DSFMB5a6VUuNrWRF1kCeJRBRWqMwE9ER_NQ,1413
+raijin_server/modules/velero.py,sha256=_CV0QQnWr5L-CWXDOiD9Ef4J7GaQT-s9yNBwqp_FLOY,1395
+raijin_server/modules/vpn.py,sha256=uUmto0HSovjwR_6DtRi7dDtZDuFvzb9xiM7uZMKAJzA,6127
+raijin_server-0.1.0.dist-info/licenses/LICENSE,sha256=kJsMCjOiRZE0AQNtxWqBa32z9kMAaF4EUxyHj3hKaJo,1105
+raijin_server-0.1.0.dist-info/METADATA,sha256=-7O6WoyOjUFSIq0fN9An1yygk6g_rpPaNjEG4r7VFVE,7386
+raijin_server-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+raijin_server-0.1.0.dist-info/entry_points.txt,sha256=3ZvxDX4pvcjkIRsXAJ69wIfVmKa78LKo-C3QhqN2KVM,56
+raijin_server-0.1.0.dist-info/top_level.txt,sha256=Yz1xneCRtsZOzbPIcTAcrSxd-1p80pohMXYAZ74dpok,14
+raijin_server-0.1.0.dist-info/RECORD,,

raijin_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

raijin_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+raijin-server = raijin_server.cli:app

raijin_server-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rafael Luis da Costa Coelho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

raijin_server-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+raijin_server