raijin-server 0.2.20__py3-none-any.whl → 0.2.22__py3-none-any.whl

raijin_server/modules/kafka.py

@@ -1,28 +1,170 @@
-"""Deploy do Apache Kafka via Helm (Bitnami OCI)."""
+"""Deploy do Apache Kafka via Helm (Bitnami OCI) - production-ready."""
+
+import socket
+import time
+from pathlib import Path
 
 import typer
 
-from raijin_server.utils import ExecutionContext, helm_upgrade_install, require_root
+from raijin_server.utils import ExecutionContext, helm_upgrade_install, require_root, run_cmd, write_file
+
+
+def _detect_node_name(ctx: ExecutionContext) -> str:
+    """Detecta nome do node para nodeSelector."""
+    result = run_cmd(
+        ["kubectl", "get", "nodes", "-o", "jsonpath={.items[0].metadata.name}"],
+        ctx,
+        check=False,
+    )
+    if result.returncode == 0 and (result.stdout or "").strip():
+        return (result.stdout or "").strip()
+    return socket.gethostname()
+
+
+def _check_existing_kafka(ctx: ExecutionContext) -> bool:
+    """Verifica se existe instalacao do Kafka."""
+    result = run_cmd(
+        ["helm", "status", "kafka", "-n", "kafka"],
+        ctx,
+        check=False,
+    )
+    return result.returncode == 0
+
+
+def _uninstall_kafka(ctx: ExecutionContext) -> None:
+    """Remove instalacao anterior do Kafka."""
+    typer.echo("Removendo instalacao anterior do Kafka...")
+    
+    run_cmd(
+        ["helm", "uninstall", "kafka", "-n", "kafka"],
+        ctx,
+        check=False,
+    )
+    
+    remove_data = typer.confirm("Remover PVCs (dados persistentes)?", default=False)
+    if remove_data:
+        run_cmd(
+            ["kubectl", "-n", "kafka", "delete", "pvc", "-l", "app.kubernetes.io/name=kafka"],
+            ctx,
+            check=False,
+        )
+        run_cmd(
+            ["kubectl", "-n", "kafka", "delete", "pvc", "-l", "app.kubernetes.io/name=zookeeper"],
+            ctx,
+            check=False,
+        )
+    
+    time.sleep(5)
+
+
+def _wait_for_kafka_ready(ctx: ExecutionContext, timeout: int = 300) -> bool:
+    """Aguarda pods do Kafka ficarem Ready."""
+    typer.echo("Aguardando pods do Kafka ficarem Ready...")
+    deadline = time.time() + timeout
+    
+    while time.time() < deadline:
+        result = run_cmd(
+            [
+                "kubectl", "-n", "kafka", "get", "pods",
+                "-l", "app.kubernetes.io/name=kafka",
+                "-o", "jsonpath={range .items[*]}{.metadata.name}={.status.phase} {end}",
+            ],
+            ctx,
+            check=False,
+        )
+        
+        if result.returncode == 0:
+            output = (result.stdout or "").strip()
+            if output:
+                pods = []
+                for item in output.split():
+                    if "=" in item:
+                        parts = item.rsplit("=", 1)
+                        if len(parts) == 2:
+                            pods.append((parts[0], parts[1]))
+                
+                if pods and all(phase == "Running" for _, phase in pods):
+                    typer.secho("  Kafka Ready.", fg=typer.colors.GREEN)
+                    return True
+        
+        time.sleep(10)
+    
+    typer.secho("  Timeout aguardando Kafka.", fg=typer.colors.YELLOW)
+    return False
 
 
 def run(ctx: ExecutionContext) -> None:
     require_root(ctx)
     typer.echo("Instalando Kafka (Bitnami) via Helm OCI...")
 
-    replicas = typer.prompt("Numero de brokers", default="3")
+    # Prompt opcional de limpeza
+    if _check_existing_kafka(ctx):
+        cleanup = typer.confirm(
+            "Instalacao anterior do Kafka detectada. Limpar antes de reinstalar?",
+            default=False,
+        )
+        if cleanup:
+            _uninstall_kafka(ctx)
+
+    replicas = typer.prompt("Numero de brokers Kafka", default="1")
+    zk_replicas = typer.prompt("Numero de replicas Zookeeper", default="1")
     disk_size = typer.prompt("Storage por broker", default="20Gi")
+    zk_disk_size = typer.prompt("Storage por Zookeeper", default="10Gi")
+
+    node_name = _detect_node_name(ctx)
+
+    values_yaml = f"""replicaCount: {replicas}
+zookeeper:
+  enabled: true
+  replicaCount: {zk_replicas}
+  persistence:
+    enabled: true
+    size: {zk_disk_size}
+  tolerations:
+    - key: node-role.kubernetes.io/control-plane
+      operator: Exists
+      effect: NoSchedule
+    - key: node-role.kubernetes.io/master
+      operator: Exists
+      effect: NoSchedule
+  nodeSelector:
+    kubernetes.io/hostname: {node_name}
+persistence:
+  enabled: true
+  size: {disk_size}
+tolerations:
+  - key: node-role.kubernetes.io/control-plane
+    operator: Exists
+    effect: NoSchedule
+  - key: node-role.kubernetes.io/master
+    operator: Exists
+    effect: NoSchedule
+nodeSelector:
+  kubernetes.io/hostname: {node_name}
+metrics:
+  kafka:
+    enabled: true
+  jmx:
+    enabled: true
+  serviceMonitor:
+    enabled: true
+    namespace: kafka
+resources:
+  requests:
+    memory: 512Mi
+    cpu: 250m
+  limits:
+    memory: 2Gi
+"""
+
+    values_path = Path("/tmp/raijin-kafka-values.yaml")
+    write_file(values_path, values_yaml, ctx)
+
+    run_cmd(["kubectl", "create", "namespace", "kafka"], ctx, check=False)
 
     # Bitnami charts migraram para OCI. Usamos a referencia OCI diretamente.
     chart_ref = "oci://registry-1.docker.io/bitnamicharts/kafka"
 
-    values = [
-        f"replicaCount={replicas}",
-        "zookeeper.enabled=true",
-        f"persistence.size={disk_size}",
-        "metrics.kafka.enabled=true",
-        "metrics.jmx.enabled=true",
-    ]
-
     helm_upgrade_install(
         release="kafka",
         chart=chart_ref,
@@ -30,5 +172,17 @@ def run(ctx: ExecutionContext) -> None:
         repo=None,
         repo_url=None,
         ctx=ctx,
-        values=values,
+        values=[],
+        extra_args=["-f", str(values_path)],
     )
+
+    if not ctx.dry_run:
+        _wait_for_kafka_ready(ctx)
+
+    typer.secho("\n✓ Kafka instalado com sucesso.", fg=typer.colors.GREEN, bold=True)
+    typer.echo("\nPara conectar ao Kafka de dentro do cluster:")
+    typer.echo("  kafka.kafka.svc.cluster.local:9092")
+    typer.echo("\nPara port-forward local:")
+    typer.echo("  kubectl -n kafka port-forward svc/kafka 9092:9092")
+    typer.echo("\nPara criar um topic de teste:")
+    typer.echo("  kubectl -n kafka exec -it kafka-0 -- kafka-topics.sh --create --topic test --bootstrap-server localhost:9092")

raijin_server/modules/kong.py

@@ -1,13 +1,145 @@
-"""Configuracao do Kong via Helm."""
+"""Configuracao do Kong Gateway via Helm com configuracoes production-ready."""
+
+import socket
+import time
 
 import typer
 
-from raijin_server.utils import ExecutionContext, helm_upgrade_install, require_root
+from raijin_server.utils import ExecutionContext, helm_upgrade_install, require_root, run_cmd
+
+
+def _detect_node_name(ctx: ExecutionContext) -> str:
+    """Detecta nome do node para nodeSelector."""
+    result = run_cmd(
+        ["kubectl", "get", "nodes", "-o", "jsonpath={.items[0].metadata.name}"],
+        ctx,
+        check=False,
+    )
+    if result.returncode == 0 and (result.stdout or "").strip():
+        return (result.stdout or "").strip()
+    return socket.gethostname()
+
+
+def _check_existing_kong(ctx: ExecutionContext) -> bool:
+    """Verifica se existe instalacao do Kong."""
+    result = run_cmd(
+        ["helm", "status", "kong", "-n", "kong"],
+        ctx,
+        check=False,
+    )
+    return result.returncode == 0
+
+
+def _uninstall_kong(ctx: ExecutionContext) -> None:
+    """Remove instalacao anterior do Kong."""
+    typer.echo("Removendo instalacao anterior do Kong...")
+    
+    run_cmd(
+        ["helm", "uninstall", "kong", "-n", "kong"],
+        ctx,
+        check=False,
+    )
+    
+    run_cmd(
+        ["kubectl", "delete", "namespace", "kong", "--ignore-not-found"],
+        ctx,
+        check=False,
+    )
+    
+    time.sleep(5)
+
+
+def _wait_for_kong_ready(ctx: ExecutionContext, timeout: int = 180) -> bool:
+    """Aguarda pods do Kong ficarem Ready."""
+    typer.echo("Aguardando pods do Kong ficarem Ready...")
+    deadline = time.time() + timeout
+    
+    while time.time() < deadline:
+        result = run_cmd(
+            [
+                "kubectl", "-n", "kong", "get", "pods",
+                "-o", "jsonpath={range .items[*]}{.metadata.name}={.status.phase} {end}",
+            ],
+            ctx,
+            check=False,
+        )
+        
+        if result.returncode == 0:
+            output = (result.stdout or "").strip()
+            if output:
+                pods = []
+                for item in output.split():
+                    if "=" in item:
+                        parts = item.rsplit("=", 1)
+                        if len(parts) == 2:
+                            pods.append((parts[0], parts[1]))
+                
+                if pods and all(phase == "Running" for _, phase in pods):
+                    typer.secho(f"  Todos os {len(pods)} pods Running.", fg=typer.colors.GREEN)
+                    return True
+                
+                pending = [name for name, phase in pods if phase != "Running"]
+                if pending:
+                    typer.echo(f"  Aguardando: {', '.join(pending[:3])}...")
+        
+        time.sleep(10)
+    
+    typer.secho("  Timeout aguardando pods do Kong.", fg=typer.colors.YELLOW)
+    return False
 
 
 def run(ctx: ExecutionContext) -> None:
     require_root(ctx)
-    typer.echo("Instalando Kong via Helm...")
+    typer.echo("Instalando Kong Gateway via Helm...")
+
+    # Prompt opcional de limpeza
+    if _check_existing_kong(ctx):
+        cleanup = typer.confirm(
+            "Instalacao anterior do Kong detectada. Limpar antes de reinstalar?",
+            default=False,
+        )
+        if cleanup:
+            _uninstall_kong(ctx)
+
+    # Configuracoes interativas
+    enable_admin = typer.confirm("Habilitar Admin API (para gerenciamento)?", default=True)
+    db_mode = typer.prompt(
+        "Modo de banco de dados (dbless/postgres)",
+        default="dbless",
+    )
+    
+    node_name = _detect_node_name(ctx)
+    
+    values = [
+        # Modo de operacao
+        f"env.database={db_mode}",
+        # Ingress Controller
+        "ingressController.installCRDs=true",
+        "ingressController.enabled=true",
+        # Proxy service
+        "proxy.enabled=true",
+        "proxy.type=LoadBalancer",
+        # Tolerations para control-plane
+        "tolerations[0].key=node-role.kubernetes.io/control-plane",
+        "tolerations[0].operator=Exists",
+        "tolerations[0].effect=NoSchedule",
+        "tolerations[1].key=node-role.kubernetes.io/master",
+        "tolerations[1].operator=Exists",
+        "tolerations[1].effect=NoSchedule",
+        # NodeSelector
+        f"nodeSelector.kubernetes\\.io/hostname={node_name}",
+    ]
+    
+    # Admin API
+    if enable_admin:
+        values.extend([
+            "admin.enabled=true",
+            "admin.type=ClusterIP",
+            "admin.http.enabled=true",
+        ])
+    else:
+        values.append("admin.enabled=false")
+    
     helm_upgrade_install(
         release="kong",
         chart="kong",
@@ -15,5 +147,17 @@ def run(ctx: ExecutionContext) -> None:
         repo="kong",
         repo_url="https://charts.konghq.com",
         ctx=ctx,
-        values=["ingressController.installCRDs=false"],
+        values=values,
     )
+    
+    # Aguarda pods ficarem prontos
+    if not ctx.dry_run:
+        _wait_for_kong_ready(ctx)
+    
+    # Mostra informacoes uteis
+    typer.secho("\n✓ Kong instalado com sucesso.", fg=typer.colors.GREEN, bold=True)
+    typer.echo("\nPara verificar o servico:")
+    typer.echo("  kubectl -n kong get svc kong-kong-proxy")
+    if enable_admin:
+        typer.echo("\nPara acessar Admin API (port-forward):")
+        typer.echo("  kubectl -n kong port-forward svc/kong-kong-admin 8001:8001")

raijin_server/modules/loki.py

@@ -1,20 +1,156 @@
-"""Configuracao do Loki via Helm."""
+"""Configuracao do Loki Stack via Helm (production-ready)."""
+
+import socket
+import time
+from pathlib import Path
 
 import typer
 
-from raijin_server.utils import ExecutionContext, helm_upgrade_install, require_root
+from raijin_server.utils import ExecutionContext, helm_upgrade_install, require_root, run_cmd, write_file
+
+
+def _detect_node_name(ctx: ExecutionContext) -> str:
+    """Detecta nome do node para nodeSelector."""
+    result = run_cmd(
+        ["kubectl", "get", "nodes", "-o", "jsonpath={.items[0].metadata.name}"],
+        ctx,
+        check=False,
+    )
+    if result.returncode == 0 and (result.stdout or "").strip():
+        return (result.stdout or "").strip()
+    return socket.gethostname()
+
+
+def _check_existing_loki(ctx: ExecutionContext) -> bool:
+    """Verifica se existe instalacao do Loki."""
+    result = run_cmd(
+        ["helm", "status", "loki", "-n", "observability"],
+        ctx,
+        check=False,
+    )
+    return result.returncode == 0
+
+
+def _uninstall_loki(ctx: ExecutionContext) -> None:
+    """Remove instalacao anterior do Loki."""
+    typer.echo("Removendo instalacao anterior do Loki...")
+    
+    run_cmd(
+        ["helm", "uninstall", "loki", "-n", "observability"],
+        ctx,
+        check=False,
+    )
+    
+    remove_data = typer.confirm("Remover PVCs (dados persistentes)?", default=False)
+    if remove_data:
+        run_cmd(
+            ["kubectl", "-n", "observability", "delete", "pvc", "-l", "app=loki"],
+            ctx,
+            check=False,
+        )
+    
+    time.sleep(5)
+
+
+def _wait_for_loki_ready(ctx: ExecutionContext, timeout: int = 180) -> bool:
+    """Aguarda pods do Loki ficarem Ready."""
+    typer.echo("Aguardando pods do Loki ficarem Ready...")
+    deadline = time.time() + timeout
+    
+    while time.time() < deadline:
+        result = run_cmd(
+            [
+                "kubectl", "-n", "observability", "get", "pods",
+                "-l", "app=loki",
+                "-o", "jsonpath={range .items[*]}{.metadata.name}={.status.phase} {end}",
+            ],
+            ctx,
+            check=False,
+        )
+        
+        if result.returncode == 0:
+            output = (result.stdout or "").strip()
+            if output:
+                pods = []
+                for item in output.split():
+                    if "=" in item:
+                        parts = item.rsplit("=", 1)
+                        if len(parts) == 2:
+                            pods.append((parts[0], parts[1]))
+                
+                if pods and all(phase == "Running" for _, phase in pods):
+                    typer.secho("  Loki Ready.", fg=typer.colors.GREEN)
+                    return True
+        
+        time.sleep(10)
+    
+    typer.secho("  Timeout aguardando Loki.", fg=typer.colors.YELLOW)
+    return False
 
 
 def run(ctx: ExecutionContext) -> None:
     require_root(ctx)
     typer.echo("Instalando Loki Stack via Helm...")
 
-    values = [
-        "promtail.enabled=true",
-        "loki.persistence.enabled=true",
-        "loki.persistence.size=20Gi",
-        "loki.retentionPeriod=168h",  # 7 dias
-    ]
+    # Prompt opcional de limpeza
+    if _check_existing_loki(ctx):
+        cleanup = typer.confirm(
+            "Instalacao anterior do Loki detectada. Limpar antes de reinstalar?",
+            default=False,
+        )
+        if cleanup:
+            _uninstall_loki(ctx)
+
+    retention_hours = typer.prompt("Retencao de logs em horas", default="168")
+    persistence_size = typer.prompt("Tamanho do storage", default="20Gi")
+
+    node_name = _detect_node_name(ctx)
+
+    values_yaml = f"""loki:
+  persistence:
+    enabled: true
+    size: {persistence_size}
+  config:
+    table_manager:
+      retention_deletes_enabled: true
+      retention_period: {retention_hours}h
+  tolerations:
+    - key: node-role.kubernetes.io/control-plane
+      operator: Exists
+      effect: NoSchedule
+    - key: node-role.kubernetes.io/master
+      operator: Exists
+      effect: NoSchedule
+  nodeSelector:
+    kubernetes.io/hostname: {node_name}
+  resources:
+    requests:
+      memory: 256Mi
+      cpu: 100m
+    limits:
+      memory: 512Mi
+
+promtail:
+  enabled: true
+  tolerations:
+    - key: node-role.kubernetes.io/control-plane
+      operator: Exists
+      effect: NoSchedule
+    - key: node-role.kubernetes.io/master
+      operator: Exists
+      effect: NoSchedule
+  resources:
+    requests:
+      memory: 128Mi
+      cpu: 50m
+    limits:
+      memory: 256Mi
+"""
+
+    values_path = Path("/tmp/raijin-loki-values.yaml")
+    write_file(values_path, values_yaml, ctx)
+
+    run_cmd(["kubectl", "create", "namespace", "observability"], ctx, check=False)
 
     helm_upgrade_install(
         release="loki",
@@ -23,5 +159,15 @@ def run(ctx: ExecutionContext) -> None:
         repo="grafana",
         repo_url="https://grafana.github.io/helm-charts",
         ctx=ctx,
-        values=values,
+        values=[],
+        extra_args=["-f", str(values_path)],
     )
+
+    if not ctx.dry_run:
+        _wait_for_loki_ready(ctx)
+
+    typer.secho("\n✓ Loki Stack instalado com sucesso.", fg=typer.colors.GREEN, bold=True)
+    typer.echo("\nPara acessar Loki via port-forward:")
+    typer.echo("  kubectl -n observability port-forward svc/loki 3100:3100")
+    typer.echo("\nPara verificar logs:")
+    typer.echo("  curl http://localhost:3100/ready")