SpringBootFilesUploader

1. Aperçu

Six contrôleurs composent l’API. Les chemins partent de la racine du serveur ; /auth/** et la documentation de l’API sont publics, tout le reste exige un jeton porteur (SecurityConf.kt).

La page OpenAPI est servie par springdoc à /api-docs (application.yml).

3. Parcours d’un envoi

sequenceDiagram
  participant C as Client
  participant F as Filtre JWT
  participant FC as FilesController
  participant FS as FilesService
  participant S3 as FileS3 (S3 / MinIO)
  participant M as FilesMongo (MongoDB)
  C->>F: POST /files/documents, jeton Bearer, multipart "document"
  F->>FC: utilisateur authentifié avec ses rôles
  FC->>FC: @PreAuthorize MODERATOR ou ADMIN, contrôle de l’extension
  FC->>FS: addDocument(octets, nom, ext, contentType, taille)
  FS->>S3: putObject(compartiment "fus", "files/{uuid}/{nom}")
  FS->>M: getNewFileId() = nombre + 1, enregistre FileModel
  FS-->>C: 200 {fileId, fileName}
  C->>FC: GET /files/{fileId}
  FC->>M: getFile(id) → chemin, nom, type, taille
  FC->>S3: getObject(chemin)
  FC-->>C: octets avec Content-Disposition attachment

1. AuthTokenFilter lit le jeton porteur, JwtUtils le valide avec le jwtSecret de la configuration, et les rôles de l’utilisateur viennent de MongoDB.
2. FilesController.addDocument refuse une partie manquante et vérifie le nom de fichier avec DOC_FILE_EXTENSION_REGEX : tableurs, documents Word, PDF, images courantes, MP4, MOV, ZIP, MP3, WAV, ISO et RAR. Seule l’extension est vérifiée, pas le contenu. Le contrôle de taille est en commentaire.
3. FilesService.addDocument construit la clé d’objet files/{UUID aléatoire}/{nom d’origine} et écrit les octets par l’interface FileRepository, implémentée par FileS3 avec le SDK AWS. FileS3 crée le compartiment au démarrage s’il n’existe pas.
4. Le service demande ensuite un identifiant à FilesMongo, qui vaut le nombre de documents de la collection plus un, puis enregistre un FileModel (identifiant, chemin, nom, extension, UUID, type de contenu, taille).
5. Un téléchargement cherche l’identifiant dans MongoDB, lit l’objet à son chemin enregistré et le renvoie avec le type et la longueur conservés.

Les octets sont écrits avant les métadonnées. Si l’enregistrement MongoDB échoue, l’objet reste dans le compartiment sans rien qui pointe vers lui.

4. Structure du projet

Vérifiée sur l’arborescence du dépôt. Tout se trouve sous src/main/kotlin/com/api/project/, y compris deux fichiers Java.

SpringBootFilesUploader/
├── build.gradle.kts, settings.gradle.kts, gradlew   build Gradle en DSL Kotlin (version 0.0.3)
├── Dockerfile                                         image openjdk11 qui lance build/libs/project-0.0.2.jar
├── docker-compose.yml                                 vide
└── src/
    ├── main/kotlin/com/api/project/
    │   ├── Application.kt
    │   ├── config/            S3Config, DockerConfig, WebClientConfig, SpringDocOpenAPI, GeneralConfig
    │   │   └── security/      SecurityConf (filtre JWT, sessions sans état, chemins publics)
    │   ├── constants/         MAX_DOCUMENT_FILE_SIZE, DOC_FILE_EXTENSION_REGEX
    │   ├── controller/        Auth, Files, User, Docker, Caddy, SSH (+ un DockerComposeController.java vide)
    │   │   └── dto/           FileDTO, DockerDTO, SSHDTO, request/ (connexion, inscription), response/ (JWT, message)
    │   ├── exception/         ApiError, BasicException
    │   ├── models/            UserModel, RoleModel, FileModel, DockerModel, SSHModel, enum/ (ERole, DockerStatus, FilesStatus)
    │   ├── repository/
    │   │   ├── file/          FileRepository (interface), FileS3, FilesMongo
    │   │   ├── user/          UserRepository, RoleRepository (Spring Data MongoDB)
    │   │   ├── docker/        DockerClientAPI, DockerMongo, DockerCompose.java (ébauche)
    │   │   ├── caddy/         CaddyMongo
    │   │   └── SSHRepository.kt
    │   └── service/
    │       ├── FilesService, SSHService
    │       ├── docker/        DockerService, DockerComposeService
    │       ├── caddy/         CaddyAPI, CaddyService, conversion de configuration et modèle JSON
    │       └── jwt/           JwtUtils, AuthTokenFilter, AuthEntryPointJwt, UserDetails*
    ├── main/resources/        application.yml, application-local.yml
    └── test/kotlin/.../ApplicationTests.kt   un seul test contextLoads()

5. Services externes

L’application s’attend à joindre ces services, avec les valeurs par défaut de application.yml et application-local.yml :

6. Dépendances

Tirées de build.gradle.kts. Les versions absentes viennent des BOM Spring Boot 2.6.3 et Spring Cloud 2021.0.1.

spring-boot-starter-parent est déclaré comme dépendance implementation alors que c’est un POM parent, et une BOM Testcontainers (1.15.3) est importée sans aucune dépendance Testcontainers.

7. Démarrage

Démarrez MongoDB et MinIO en local (le docker-compose.yml du dépôt est vide), puis lancez l’application avec le profil local, que application.yml active par défaut :

docker run -d -p 27017:27017 mongo
docker run -d -p 9000:9000 -e MINIO_ROOT_USER=minioadmin -e MINIO_ROOT_PASSWORD=minioadmin minio/minio server /data
./gradlew bootRun

Le profil local pointe aussi vers un serveur Spring Cloud Config sur le port 8888. Les rôles sont lus dans la collection de rôles de MongoDB et rien dans le code ne les crée : insérez ROLE_USER, ROLE_MODERATOR et ROLE_ADMIN avant de vous inscrire.

8. Limites

• Rôle de modérateur en libre-service. POST /auth/signup transforme un rôle demandé "mod" en ROLE_MODERATOR : n’importe qui peut créer un compte autorisé à envoyer des fichiers.
• Des noms de rôles qui ne correspondent jamais. DockerController vérifie hasRole('MOD'), mais les rôles sont ROLE_USER, ROLE_MODERATOR et ROLE_ADMIN ; seuls les administrateurs passent ces contrôles.
• Identifiants séquentiels et concurrents. getNewFileId() renvoie le nombre de documents plus un : deux envois simultanés peuvent obtenir le même identifiant, et une suppression fait entrer le suivant en collision.
• Envois sans limite, en mémoire. Les limites multipart sont fixées à 500 000 Mo, le contrôle de taille est en commentaire et document.bytes charge tout le fichier en mémoire avant l’envoi vers S3.
• Exécution de commandes à distance, par conception. /ssh/cli ouvre un shell sur n’importe quel hôte et y exécute la commande donnée pour un administrateur, et /containers parle à un socket TCP Docker sans authentification.
• Valeurs par défaut versionnées. jwtSecret: secret, les clés MinIO minioadmin, un mot de passe du serveur de configuration et une adresse courriel personnelle se trouvent dans les fichiers YAML.
• Build et documentation. Le Dockerfile copie project-0.0.2.jar alors que le build produit la version 0.0.3, le fichier Compose et le README sont vides, et le seul test vérifie que le contexte se charge.

9. Sources

• Dépôt GitHub
• build.gradle.kts
• FilesController.kt
• FilesService.kt
• FileS3.kt
• SecurityConf.kt
• AuthController.kt
• application.yml

flowchart LR
  repo[("Dépôt GitHub")]
  image["Image Docker<br/>FROM adoptopenjdk/openjdk11:alpine"]
  repo -->|"docker build"| image