raijin-server 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

raijin_server/modules/harbor.py

@@ -25,6 +25,7 @@ from raijin_server.utils import (
     run_cmd,
     write_file,
 )
+from raijin_server.minio_utils import get_or_create_minio_user
 
 HARBOR_NAMESPACE = "harbor"
 
@@ -65,34 +66,17 @@ def _uninstall_harbor(ctx: ExecutionContext, namespace: str) -> None:
 
 
 def _get_minio_credentials(ctx: ExecutionContext) -> tuple[str, str]:
-    """Obtem credenciais do MinIO do Secret do K8s."""
-    typer.echo("Obtendo credenciais do MinIO...")
+    """Obtem ou cria credenciais específicas do MinIO para Harbor.
     
-    result = run_cmd(
-        ["kubectl", "-n", "minio", "get", "secret", "minio-credentials", "-o", "jsonpath={.data.accesskey}"],
-        ctx,
-        check=False,
+    Esta função cria um usuário MinIO dedicado para o Harbor com acesso
+    restrito apenas aos buckets: harbor-registry, harbor-chartmuseum, harbor-jobservice.
+    """
+    return get_or_create_minio_user(
+        ctx=ctx,
+        app_name="harbor",
+        buckets=["harbor-registry", "harbor-chartmuseum", "harbor-jobservice"],
+        namespace=HARBOR_NAMESPACE,
     )
-    
-    if result.returncode == 0 and result.stdout:
-        access_key = base64.b64decode(result.stdout.strip()).decode("utf-8")
-        
-        result = run_cmd(
-            ["kubectl", "-n", "minio", "get", "secret", "minio-credentials", "-o", "jsonpath={.data.secretkey}"],
-            ctx,
-            check=False,
-        )
-        
-        if result.returncode == 0 and result.stdout:
-            secret_key = base64.b64decode(result.stdout.strip()).decode("utf-8")
-            return access_key, secret_key
-    
-    # Fallback para prompt manual
-    typer.secho("Não foi possível obter credenciais automaticamente.", fg=typer.colors.YELLOW)
-    access_key = typer.prompt("MinIO Access Key", default="thor")
-    secret_key = typer.prompt("MinIO Secret Key", default="rebel1on", hide_input=True)
-    
-    return access_key, secret_key
 
 
 def _wait_for_pods_ready(ctx: ExecutionContext, namespace: str, timeout: int = 300) -> bool:

raijin_server/modules/secrets.py

@@ -24,6 +24,7 @@ from raijin_server.utils import (
     run_cmd,
     write_file,
 )
+from raijin_server.minio_utils import get_or_create_minio_user
 
 VAULT_NAMESPACE = "vault"
 ESO_NAMESPACE = "external-secrets"
@@ -124,43 +125,30 @@ def _wait_for_pods_ready(ctx: ExecutionContext, namespace: str, label: str, time
 
 
 def _get_minio_credentials(ctx: ExecutionContext) -> tuple[str, str]:
-    """Obtem credenciais do MinIO do Secret do K8s."""
-    typer.echo("Obtendo credenciais do MinIO...")
-    
-    # Tenta obter do secret minio-credentials no namespace minio
-    result = run_cmd(
-        ["kubectl", "-n", "minio", "get", "secret", "minio-credentials", "-o", "jsonpath={.data.accesskey}"],
-        ctx,
-        check=False,
+    """Obtem ou cria credenciais específicas do MinIO para Vault.
+    
+    Esta função cria um usuário MinIO dedicado para o Vault com acesso
+    restrito apenas ao bucket 'vault-storage'.
+    """
+    return get_or_create_minio_user(
+        ctx=ctx,
+        app_name="vault",
+        buckets=["vault-storage"],
+        namespace=VAULT_NAMESPACE,
     )
-    
-    if result.returncode == 0 and result.stdout:
-        access_key = base64.b64decode(result.stdout.strip()).decode("utf-8")
-        
-        result = run_cmd(
-            ["kubectl", "-n", "minio", "get", "secret", "minio-credentials", "-o", "jsonpath={.data.secretkey}"],
-            ctx,
-            check=False,
-        )
-        
-        if result.returncode == 0 and result.stdout:
-            secret_key = base64.b64decode(result.stdout.strip()).decode("utf-8")
-            return access_key, secret_key
-    
-    # Fallback para prompt manual
-    typer.secho("Não foi possível obter credenciais automaticamente.", fg=typer.colors.YELLOW)
-    access_key = typer.prompt("MinIO Access Key", default="thor")
-    secret_key = typer.prompt("MinIO Secret Key", default="rebel1on", hide_input=True)
-    
-    return access_key, secret_key
 
 
-def _initialize_vault(ctx: ExecutionContext, vault_ns: str, node_ip: str) -> tuple[str, list[str]]:
-    """Inicializa o Vault e retorna root token e unseal keys."""
-    typer.echo("\n Inicializando Vault...")
+def _initialize_vault(ctx: ExecutionContext, vault_ns: str, node_ip: str) -> tuple[str, str]:
+    """Inicializa o Vault com 1 key/1 threshold e retorna root token e unseal key."""
+    typer.echo("\nInicializando Vault...")
     
+    # Usa 1 key com threshold 1 para simplificar (produção pode usar 5/3)
     result = run_cmd(
-        ["kubectl", "-n", vault_ns, "exec", "vault-0", "--", "vault", "operator", "init", "-format=json"],
+        [
+            "kubectl", "-n", vault_ns, "exec", "vault-0", "--", 
+            "vault", "operator", "init", 
+            "-key-shares=1", "-key-threshold=1", "-format=json"
+        ],
         ctx,
         check=False,
     )
@@ -172,28 +160,60 @@ def _initialize_vault(ctx: ExecutionContext, vault_ns: str, node_ip: str) -> tup
     import json
     init_data = json.loads(result.stdout)
     root_token = init_data["root_token"]
-    unseal_keys = init_data["unseal_keys_b64"]
+    unseal_key = init_data["unseal_keys_b64"][0]
     
     # Salva keys localmente
     vault_keys_path = Path("/etc/vault/keys.json")
     vault_keys_path.parent.mkdir(parents=True, exist_ok=True)
     vault_keys_path.write_text(json.dumps(init_data, indent=2))
     typer.secho(f"\n✓ Vault keys salvas em {vault_keys_path}", fg=typer.colors.GREEN)
+    
+    # Salva credenciais em secret K8s para uso do ESO
+    _save_vault_credentials_to_k8s(ctx, vault_ns, root_token, unseal_key)
+    
     typer.secho("⚠️  IMPORTANTE: Guarde essas keys em local seguro!", fg=typer.colors.YELLOW, bold=True)
     
-    return root_token, unseal_keys
+    return root_token, unseal_key
+
+
+def _save_vault_credentials_to_k8s(ctx: ExecutionContext, vault_ns: str, root_token: str, unseal_key: str) -> None:
+    """Salva credenciais do Vault em secret K8s."""
+    typer.echo("Salvando credenciais do Vault em secret K8s...")
+    
+    # Codifica em base64
+    token_b64 = base64.b64encode(root_token.encode()).decode()
+    key_b64 = base64.b64encode(unseal_key.encode()).decode()
+    
+    secret_yaml = f"""apiVersion: v1
+kind: Secret
+metadata:
+  name: vault-init-credentials
+  namespace: {vault_ns}
+type: Opaque
+data:
+  root-token: {token_b64}
+  unseal-key: {key_b64}
+"""
+    
+    secret_path = Path("/tmp/raijin-vault-credentials.yaml")
+    write_file(secret_path, secret_yaml, ctx)
+    
+    run_cmd(
+        ["kubectl", "apply", "-f", str(secret_path)],
+        ctx,
+    )
+    
+    typer.secho("✓ Credenciais salvas em secret vault-init-credentials.", fg=typer.colors.GREEN)
 
 
-def _unseal_vault(ctx: ExecutionContext, vault_ns: str, unseal_keys: list[str]) -> None:
-    """Destrava o Vault usando as unseal keys."""
+def _unseal_vault(ctx: ExecutionContext, vault_ns: str, unseal_key: str) -> None:
+    """Destrava o Vault usando a unseal key."""
     typer.echo("\nDesbloqueando Vault...")
     
-    # Precisa de 3 keys das 5 geradas (threshold padrão)
-    for i in range(3):
-        run_cmd(
-            ["kubectl", "-n", vault_ns, "exec", "vault-0", "--", "vault", "operator", "unseal", unseal_keys[i]],
-            ctx,
-        )
+    run_cmd(
+        ["kubectl", "-n", vault_ns, "exec", "vault-0", "--", "vault", "operator", "unseal", unseal_key],
+        ctx,
+    )
     
     typer.secho("✓ Vault desbloqueado.", fg=typer.colors.GREEN)
 
@@ -279,23 +299,21 @@ def _create_secretstore_example(ctx: ExecutionContext, vault_ns: str, eso_ns: st
     """Cria exemplo de ClusterSecretStore e ExternalSecret."""
     typer.echo("\nCriando exemplo de ClusterSecretStore...")
     
-    secretstore_yaml = f"""apiVersion: external-secrets.io/v1beta1
+    secretstore_yaml = f"""apiVersion: external-secrets.io/v1
 kind: ClusterSecretStore
 metadata:
   name: vault-backend
 spec:
   provider:
     vault:
-      server: "http://vault.{vault_ns}.svc.cluster.local:8200"
+      server: "http://vault.{vault_ns}.svc:8200"
       path: "secret"
       version: "v2"
       auth:
-        kubernetes:
-          mountPath: "kubernetes"
-          role: "eso-role"
-          serviceAccountRef:
-            name: "external-secrets"
-            namespace: "{eso_ns}"
+        tokenSecretRef:
+          namespace: "{vault_ns}"
+          name: "vault-init-credentials"
+          key: "root-token"
 """
     
     secretstore_path = Path("/tmp/raijin-vault-secretstore.yaml")
@@ -327,7 +345,7 @@ def _create_example_secret(ctx: ExecutionContext, vault_ns: str, root_token: str
     typer.secho("✓ Secret 'secret/example' criado no Vault.", fg=typer.colors.GREEN)
     
     # Cria ExternalSecret de exemplo
-    external_secret_yaml = """apiVersion: external-secrets.io/v1beta1
+    external_secret_yaml = """apiVersion: external-secrets.io/v1
 kind: ExternalSecret
 metadata:
   name: example-secret
@@ -396,7 +414,7 @@ def run(ctx: ExecutionContext) -> None:
     )
     node_ip = result.stdout.strip() if result.returncode == 0 else "192.168.1.81"
     
-    minio_host = typer.prompt("MinIO host", default=f"{node_ip}:30900")
+    minio_host = typer.prompt("MinIO host (interno)", default="minio.minio.svc:9000")
     access_key, secret_key = _get_minio_credentials(ctx)
 
     # ========== HashiCorp Vault ==========
@@ -410,16 +428,8 @@ def run(ctx: ExecutionContext) -> None:
         if cleanup:
             _uninstall_vault(ctx, vault_ns)
 
-    # Cria bucket no MinIO para Vault storage
-    typer.echo("\nCriando bucket 'vault-storage' no MinIO...")
-    run_cmd(
-        [
-            "mc", "mb", "--ignore-existing", 
-            f"minio/vault-storage"
-        ],
-        ctx,
-        check=False,
-    )
+    # Credenciais são obtidas automaticamente via get_or_create_minio_user
+    # que já cria o bucket 'vault-storage' e o usuário 'vault-user'
 
     vault_values_yaml = f"""server:
   ha:
@@ -494,15 +504,14 @@ injector:
     if not ctx.dry_run:
         _wait_for_pods_ready(ctx, vault_ns, "app.kubernetes.io/name=vault", timeout=180)
         
-        # Inicializa Vault
-        root_token, unseal_keys = _initialize_vault(ctx, vault_ns, node_ip)
+        # Inicializa Vault (retorna root_token e unseal_key)
+        root_token, unseal_key = _initialize_vault(ctx, vault_ns, node_ip)
         
         # Destrava Vault
-        _unseal_vault(ctx, vault_ns, unseal_keys)
+        _unseal_vault(ctx, vault_ns, unseal_key)
         
         # Configura Vault
         _enable_kv_secrets(ctx, vault_ns, root_token)
-        _configure_kubernetes_auth(ctx, vault_ns, root_token)
 
     # ========== External Secrets Operator ==========
     typer.secho("\n== External Secrets Operator ==", fg=typer.colors.CYAN, bold=True)
@@ -570,8 +579,7 @@ resources:
     if not ctx.dry_run:
         _wait_for_pods_ready(ctx, eso_ns, "app.kubernetes.io/name=external-secrets", timeout=120)
         
-        # Configura integração Vault + ESO
-        _create_eso_policy_and_role(ctx, vault_ns, root_token, eso_ns)
+        # Cria ClusterSecretStore (usa tokenSecretRef, não precisa de Kubernetes auth)
         _create_secretstore_example(ctx, vault_ns, eso_ns, node_ip)
         _create_example_secret(ctx, vault_ns, root_token)
 
@@ -587,7 +595,7 @@ resources:
     
     typer.echo("\n2. Criar ExternalSecret:")
     typer.echo("   kubectl apply -f - <<EOF")
-    typer.echo("   apiVersion: external-secrets.io/v1beta1")
+    typer.echo("   apiVersion: external-secrets.io/v1")
     typer.echo("   kind: ExternalSecret")
     typer.echo("   metadata:")
     typer.echo("     name: myapp-secret")
@@ -607,8 +615,14 @@ resources:
     typer.echo("\n3. Secret será sincronizado automaticamente!")
     typer.echo("   kubectl get secret myapp-secret -o yaml")
     
+    typer.secho("\n=== Recuperar Credenciais ===", fg=typer.colors.CYAN)
+    typer.echo("Via arquivo local:")
+    typer.echo("  cat /etc/vault/keys.json")
+    typer.echo("\nVia Kubernetes Secret:")
+    typer.echo(f"  kubectl -n {vault_ns} get secret vault-init-credentials -o jsonpath='{{.data.root-token}}' | base64 -d")
+    typer.echo(f"  kubectl -n {vault_ns} get secret vault-init-credentials -o jsonpath='{{.data.unseal-key}}' | base64 -d")
+    
     typer.secho("\n⚠️  IMPORTANTE:", fg=typer.colors.YELLOW, bold=True)
-    typer.echo(f"- Root token e unseal keys salvos em: /etc/vault/keys.json")
-    typer.echo("- Faça backup dessas keys em local seguro!")
-    typer.echo("- Após reboot do Vault, use: kubectl -n vault exec vault-0 -- vault operator unseal")
+    typer.echo("- Faça backup das credenciais em local seguro!")
+    typer.echo(f"- Após reboot do Vault, use: kubectl -n {vault_ns} exec vault-0 -- vault operator unseal <unseal-key>")
 

raijin_server/modules/velero.py

@@ -1,10 +1,46 @@
 """Backup e restore com Velero (production-ready)."""
 
 import time
+from pathlib import Path
 
 import typer
 
 from raijin_server.utils import ExecutionContext, ensure_tool, require_root, run_cmd
+from raijin_server.minio_utils import get_or_create_minio_user
+
+
+def _create_velero_credentials_file(ctx: ExecutionContext) -> str:
+    """Cria arquivo de credenciais para Velero com usuário MinIO dedicado.
+    
+    Returns:
+        Caminho para o arquivo de credenciais
+    """
+    typer.echo("\nConfigurando credenciais MinIO para Velero...")
+    
+    # Cria usuário MinIO específico para Velero
+    access_key, secret_key = get_or_create_minio_user(
+        ctx=ctx,
+        app_name="velero",
+        buckets=["velero-backups"],
+        namespace="velero",
+    )
+    
+    # Cria arquivo de credenciais no formato esperado pelo Velero
+    credentials_path = Path("/etc/velero/credentials")
+    credentials_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    credentials_content = f"""[default]
+aws_access_key_id = {access_key}
+aws_secret_access_key = {secret_key}
+"""
+    
+    if not ctx.dry_run:
+        credentials_path.write_text(credentials_content)
+        # Protege o arquivo
+        credentials_path.chmod(0o600)
+        typer.secho(f"  ✓ Credenciais salvas em {credentials_path}", fg=typer.colors.GREEN)
+    
+    return str(credentials_path)
 
 
 def _check_existing_velero(ctx: ExecutionContext) -> bool:
@@ -91,8 +127,19 @@ def run(ctx: ExecutionContext) -> None:
     provider = typer.prompt("Provider (aws, azure, gcp)", default="aws")
     bucket = typer.prompt("Bucket para backups", default="velero-backups")
     region = typer.prompt("Region", default="us-east-1")
-    s3_url = typer.prompt("S3 URL (para MinIO usar http://minio.minio.svc:9000)", default="https://s3.amazonaws.com")
-    secret_file = typer.prompt("Arquivo de credenciais (secret-file)", default="/etc/velero/credentials")
+    s3_url = typer.prompt("S3 URL (para MinIO usar http://minio.minio.svc:9000)", default="http://minio.minio.svc:9000")
+    
+    # Cria credenciais automaticamente usando usuário MinIO dedicado
+    use_auto_credentials = typer.confirm(
+        "Criar credenciais MinIO automaticamente (usuário dedicado)?",
+        default=True,
+    )
+    
+    if use_auto_credentials:
+        secret_file = _create_velero_credentials_file(ctx)
+    else:
+        secret_file = typer.prompt("Arquivo de credenciais (secret-file)", default="/etc/velero/credentials")
+    
     use_restic = typer.confirm("Habilitar Restic/Kopia para backups de PV?", default=True)
     schedule = typer.prompt("Schedule cron para backups (ex: '0 2 * * *')", default="0 2 * * *")
 

raijin_server/validators.py

@@ -34,7 +34,7 @@ MODULE_DEPENDENCIES = {
     "kafka": ["kubernetes"],
     "observability_ingress": ["traefik", "prometheus", "grafana"],
     "observability_dashboards": ["prometheus", "grafana"],
-    "apokolips_demo": ["kubernetes", "traefik"],
+
 }
 
 

{raijin_server-0.3.6.dist-info → raijin_server-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raijin-server
-Version: 0.3.6
+Version: 0.3.8
 Summary: CLI para automacao de setup e hardening de servidores Ubuntu Server.
 Home-page: https://example.com/raijin-server
 Author: Equipe Raijin

{raijin_server-0.3.6.dist-info → raijin_server-0.3.8.dist-info}/RECORD

@@ -1,12 +1,12 @@
-raijin_server/__init__.py,sha256=DizNqR7krrm4UEAK6a2xeOG3wuV7xlSekBC-mCSHadw,94
-raijin_server/cli.py,sha256=74ZqEPhg9R9jxNFZRV37CHrwm-dBKmYdT_MxdK4FKKA,37585
+raijin_server/__init__.py,sha256=IWpKGUd_KknUfa2XJ_Xu7M_xVWCdNyixW7AMO96xWkY,94
+raijin_server/cli.py,sha256=WvZaPJ5AVjhzzs_jLLe2QGvVEH_VphRwnUkTMEgycbI,37320
 raijin_server/config.py,sha256=QNiEVvrbW56XgvNn5-h3bkJm46Xc8mjNqPbvixXD8N0,4829
-raijin_server/healthchecks.py,sha256=lzXdFw6S0hOYbUKbqksh4phb04lXgXdTspP1Dsz4dx8,15401
+raijin_server/healthchecks.py,sha256=UHSRyeKTsCGeL_4dxDSGZ1t8164Q7wYTi1c3ZiU0cro,13536
+raijin_server/minio_utils.py,sha256=NQxIGoVf4-eM8rNwEHdd4QFnEIh2OxY3DyOiFkznsYs,18299
 raijin_server/module_manager.py,sha256=Wmhj603CN0XGUVr7_Fo8CHzKd9yIbS9x5BJLqDj78kw,10259
 raijin_server/utils.py,sha256=9RnGnPoUTYOpMVRLNa4P4lIQrJNQLkSkPUxycZRGv78,20827
-raijin_server/validators.py,sha256=EATYPy2pllAb6IX4gUZKnELvospWwyGV3DHrzxb_RMg,11761
-raijin_server/modules/__init__.py,sha256=BCTLuNtmvn8IWqGNQZQBRokqAv-KwUZP4_kyxkyHyN4,896
-raijin_server/modules/apokolips_demo.py,sha256=8ltsXRbVDwlDwLMIvh02NG-FeAfBWw_v6lh7IGOyNqs,13725
+raijin_server/validators.py,sha256=LvxAIq7F8CSIihdfCCDlDtVd6WPBBntiBHuD8fuM2kg,11713
+raijin_server/modules/__init__.py,sha256=UOv7c7UpxZq-JRZM0i55LGfI3LyucZhTL4lypeHs2Jw,858
 raijin_server/modules/bootstrap.py,sha256=oVIGNRW_JbgY8zXNHGAIP0vGbbHNHyQexthxo5zhbcw,9762
 raijin_server/modules/calico.py,sha256=TTPF1bLFdAKb3IVOqFqRxNblULkRmMMRylsIBp4w8I8,6700
 raijin_server/modules/cert_manager.py,sha256=XkFlXJjiP4_9It_PJaFcVYMS-QKTzzFAt839QQ9qNsg,50223
@@ -14,7 +14,7 @@ raijin_server/modules/essentials.py,sha256=2xUXCyCQtFGd2DnCKV81N1R6bEJqH8zaet8mL
 raijin_server/modules/firewall.py,sha256=h6AISqiZeTinVT7BjmQIS872qRAFZJLg7meqlth3cfw,757
 raijin_server/modules/full_install.py,sha256=M4SV4OA-r41xhpMmZQvUieRugiq0faLa4f0N499ksd4,15035
 raijin_server/modules/grafana.py,sha256=8YbKG-UL19lwTkH1-ZxpUetOZd-CLI4_kPsuZblNaWI,18080
-raijin_server/modules/harbor.py,sha256=ix0qnu_FugzbFnnTRZ3Dyy6UmKdm3nD0ubZ4SZYHkWE,21940
+raijin_server/modules/harbor.py,sha256=hFD8x5K4m0unzVBiDOT_yBzDDfbuPW_2SNVrjSCXhGc,21324
 raijin_server/modules/hardening.py,sha256=4hz3ifkMhPlXa2n7gPxN0gitQgzALZ-073vuU3LM4RI,1616
 raijin_server/modules/harness.py,sha256=uWTxTVJlY_VB6xi4ftMtTSaIb96HA8WJQS-RbyxU45M,5391
 raijin_server/modules/internal_dns.py,sha256=Jynngq0TEEUo3jkAR4m8F1ihF10rkQuKHVP-gZYyDFY,15191
@@ -28,10 +28,10 @@ raijin_server/modules/minio.py,sha256=ZoxugJvvuGLzViDfEzrVCRZUevoiFwcEy0PNyn0My4
 raijin_server/modules/network.py,sha256=QRlYdcryCCPAWG3QQ_W7ld9gJgETI7H8gwntOU7UqFE,4818
 raijin_server/modules/prometheus.py,sha256=lyhaqLIfMl0GtQ2b2Hre7_A47HrHBB5gspmnWtwXZ4Y,21880
 raijin_server/modules/sanitize.py,sha256=_RnWn1DUuNrzx3NnKEbMvf5iicgjiN_ubwT59e0rYWY,6040
-raijin_server/modules/secrets.py,sha256=C5k10ODo6Ai_e6Ei-JiWTOa-cOh-5d2__PhTQA0UmjI,19452
+raijin_server/modules/secrets.py,sha256=3QzvFd4qH1hyOtbu3Cxyu4JUaYgWssxI-oZ4gS3HIP4,19924
 raijin_server/modules/ssh_hardening.py,sha256=Zd0dlylUBr01SkrI1CS05-0DB9xIto5rWH1bUVs80ow,5422
 raijin_server/modules/traefik.py,sha256=omziywss4o-8t64Kj-upLqbXdFYm2JwqOoOukDUmqxY,5008
-raijin_server/modules/velero.py,sha256=yDtqd6yUu0L5wzLCjYXqvvxB_RyaAoZtntb6HoHVAOo,5642
+raijin_server/modules/velero.py,sha256=nH7WI145OOK-DZo_ZjNegEnwkppi8h98DeQaB5A_kVg,7161
 raijin_server/modules/vpn.py,sha256=qWyROiHx2-FzMqhfpmzslrdfRBTewd53ylUq90wR7SQ,9149
 raijin_server/modules/vpn_client.py,sha256=SjWzSQKLSJCpjz7Y1i1dFaNfPOVIQXFwgD9uM3GYaIY,30035
 raijin_server/scripts/__init__.py,sha256=deduGfHf8BMVWred4ux5LfBDT2NJ5XYeJAt2sDEU4qs,53
@@ -39,9 +39,9 @@ raijin_server/scripts/checklist.sh,sha256=j6E0Kmk1EfjLvKK1VpCqzXJAXI_7Bm67LK4ndy
 raijin_server/scripts/install.sh,sha256=Y1ickbQ4siQ0NIPs6UgrqUr8WWy7U0LHmaTQbEgavoI,3949
 raijin_server/scripts/log_size_metric.sh,sha256=Iv4SsX8AuCYRou-klYn32mX41xB6j0xJGLBO6riw4rU,1208
 raijin_server/scripts/pre-deploy-check.sh,sha256=XqMo7IMIpwUHF17YEmU0-cVmTDMoCGMBFnmS39FidI4,4912
-raijin_server-0.3.6.dist-info/licenses/LICENSE,sha256=kJsMCjOiRZE0AQNtxWqBa32z9kMAaF4EUxyHj3hKaJo,1105
-raijin_server-0.3.6.dist-info/METADATA,sha256=egpj4eEFQ3JJAA-bT3Iz5ebOc57e5JpyuQ2a8-ruAD4,8829
-raijin_server-0.3.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-raijin_server-0.3.6.dist-info/entry_points.txt,sha256=3ZvxDX4pvcjkIRsXAJ69wIfVmKa78LKo-C3QhqN2KVM,56
-raijin_server-0.3.6.dist-info/top_level.txt,sha256=Yz1xneCRtsZOzbPIcTAcrSxd-1p80pohMXYAZ74dpok,14
-raijin_server-0.3.6.dist-info/RECORD,,
+raijin_server-0.3.8.dist-info/licenses/LICENSE,sha256=kJsMCjOiRZE0AQNtxWqBa32z9kMAaF4EUxyHj3hKaJo,1105
+raijin_server-0.3.8.dist-info/METADATA,sha256=5QdtvUtfp7Qq_OaevRKA2WoU7i6NViAOG58h3wI5vmw,8829
+raijin_server-0.3.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+raijin_server-0.3.8.dist-info/entry_points.txt,sha256=3ZvxDX4pvcjkIRsXAJ69wIfVmKa78LKo-C3QhqN2KVM,56
+raijin_server-0.3.8.dist-info/top_level.txt,sha256=Yz1xneCRtsZOzbPIcTAcrSxd-1p80pohMXYAZ74dpok,14
+raijin_server-0.3.8.dist-info/RECORD,,