Descripción general de la arquitectura

Gitrust es una plataforma de alojamiento Git autohospedada construida sobre el marco rustwarden-core. La aplicación expone dos puntos de entrada a la red (HTTP + SSH) y conserva sus datos en PostgreSQL.

Descripción general

graph TB
    subgraph Clients
        Browser["Navigateur Web"]
        GitCLI["Git CLI (ssh/https)"]
    end

    subgraph "Gitrust Binary (src/main.rs)"
        Main["main()"]
    end

    subgraph "Crates Gitrust"
        Web["gitrust-web
Routes HTTP, templates,
handlers Axum"]
        SSH["gitrust-ssh
Serveur SSH (russh),
auth par clé, sessions"]
        SshGuard["gitrust-ssh-guard
SecureListener, détecteurs,
BanManager, AuthTracker"]
        Hooks["gitrust-hooks
impl RustwardenHooks
(on_user_registered, ...)"]
        Core["gitrust-core
Models, services, migrations,
rôles, types, DTOs"]
        Git["gitrust-git
Bare repos, tree browser,
pack protocol (git2)"]
    end

    subgraph "Framework"
        RW["rustwarden-core
Auth, users, JWT, sessions,
ResourceService, i18n"]
    end

    subgraph "Stockage"
        PG[(PostgreSQL)]
        FS[("Système de fichiers
bare repos .git")]
    end

    subgraph "CI/CD (optionnel)"
        CiWorker["CiWorker
tokio::spawn, mpsc,
sous-processus Dagger"]
        Dagger["Dagger Engine
Containers isolés,
cache, exécution"]
        CiEngine["ci-engine
Module Dagger Python
(Easy Mode)"]
        Syft["Syft (optionnel)
Génération SBOM
CycloneDX"]
        DTrack["Dependency-Track
(optionnel)
Analyse vulnérabilités"]
    end

    Browser -->|HTTP :4000| Web
    GitCLI -->|SSH :2222| SshGuard
    SshGuard -->|"AcceptOutcome::Accepted"| SSH
    GitCLI -->|HTTPS :4000| Web

    Main --> Web
    Main --> SSH
    Main --> SshGuard
    Main --> Hooks
    Main -.->|"si CI_ENABLED"| CiWorker

    Web --> Core
    Web --> Git
    Web -.->|"admin ACL/ban"| SshGuard
    SSH --> Core
    SSH --> Git
    SSH --> SshGuard
    SshGuard --> Core
    Hooks --> Core

    Core --> RW
    Core --> PG
    Git --> FS

    CiWorker --> Core
    CiWorker -->|"dagger call"| Dagger
    Dagger -->|"Easy Mode"| CiEngine
    Dagger -->|"Power Mode"| FS
    CiWorker -.->|"si CI_SBOM_ENABLED"| Syft
    Syft -.->|"si CI_DTRACK_ENABLED"| DTrack

Iniciando la aplicación

El siguiente diagrama detalla la secuencia de inicialización desde main() hasta el inicio de los servidores HTTP y SSH.

sequenceDiagram
    participant Main as main()
    participant Builder as RustwardenBuilder
    participant App as RustwardenApp
    participant Mig as AppMigrator
    participant DB as PostgreSQL
    participant SMTP as Serveur SMTP

    Main->>Main: GitrustConfig::from_env()
    Main->>Main: Arc (hooks FS)

    Main->>Builder: builder().from_env()
    Note over Builder: Charge .env, init tracing
    Main->>Builder: .headless().auto_migrate(false)
    Main->>Builder: .merge_routes(app_routes(hooks))
    Note over Builder: Routes = framework API
+ pages SSR gitrust
+ Extension(hooks)
    Main->>Builder: .build().await
    Builder->>DB: Connexion pool
    Builder->>DB: Migrations rustwarden-core
    Builder->>SMTP: EmailQueueProcessor.start()
    Note over SMTP: Worker de fond : dépile
email_queue toutes les 30s
    Builder-->>Main: RustwardenApp

    Main->>Mig: run_migrations(app.database())
    Mig->>DB: core_migrations() + gitrust_migrations()
    Note over DB: Tables: users, resources,
repositories, ssh_keys,
teams, team_members,
team_repository_access
    Mig-->>Main: Ok

    Main->>Main: tokio::spawn(SSH server :2222)

    alt CI_ENABLED=true
        Main->>Main: CiWorker::start(config.ci)
        Note over Main: Vérifie dagger dans PATH
Si CI_SBOM_ENABLED: vérifie syft
Si CI_DTRACK_ENABLED: vérifie API DT
        Main->>Main: tokio::spawn(CiWorker loop)
        Note over Main: Écoute mpsc channel
pour les jobs CI
    end

    Main->>App: app.run().await
    Note over App: HTTP :4000 démarre

Principios de diseño

Gitrust marco/separación empresarial

Gitrust está construido sobre Rustwarden-core, un marco de administración de usuarios y autenticación de Rust. Esta separación es intencional:

  • rustwarden-core gestiona: autenticación JWT, sesiones, usuarios, roles genéricos, i18n, SMTP, OAuth, registro de auditoría genérico.
  • gitrust-core gestiona: todo lo específico de Git forge: repositorios, claves SSH, equipos, permisos RBAC de 4 niveles, CI, importación de repositorios.

La regla fundamental: nunca modifiques crates/rustwarden-core/. Cualquier extensión pasa por contenedores, ganchos ("RustwardenHooks") o funciones implementadas en el lado de gitrust.

Modo sin cabeza

gitrust-web opera en modo headless(): las páginas estándar de la interfaz de usuario de Rustwarden (inicio de sesión, registro, configuración) están desactivadas y se reimplementan por completo en gitrust-web/templates/. Esto permite un diseño coherente (barra lateral de Git, DaisyUI) sin comprometer la interfaz de usuario genérica del marco.

SSR + HTMX, cero CDN

La interfaz se representa en el lado del servidor a través de Askama (plantillas de Rust compiladas). HTMX gestiona interacciones dinámicas (actualizaciones parciales de páginas, SSE para notificaciones y registros de CI). Sin activos externos: todo CSS/JS se sirve desde "estático/", impuesto por la Política de seguridad de contenido del marco.

Descanso desnudo en el sistema de archivos

gitrust-git está desacoplado de la base de datos. Las operaciones de Git (navegación de árbol, lectura de blobs, protocolo de paquete) funcionan directamente en repositorios básicos ({GIT_REPOS_BASE_PATH}/{owner}/{slug}.git/) a través de libgit2. La base de datos sólo almacena metadatos (nombre, descripción, visibilidad, propiedad). Este desacoplamiento permite reemplazar o probar gitrust-git de forma independiente.

CI híbrida: Daga como abstracción de ejecución

En lugar de implementar un ejecutor de CI desde cero, gitrust delega la ejecución a Dagger, lo que garantiza aislamiento (contenedores), reproducibilidad (caché) y portabilidad (ejecudor local o remoto a través de SSH+rsync). El CiWorker es una tarea de Tokio en el proceso principal, no un demonio separado, lo que simplifica la implementación (un único binario).

para ir más lejos