Configuration MinIO

en utilisant Java
Spring Boot

Par Youssoufou & Abdul

PLAN DE PRÉSENTATION
1. Qu’est-ce que c’est MinIO ?

2. Configurer la dépendance requise et définir les

valeurs des variables dans le fichier
application.properties.

3. Configuration du client MinIO en utilisant Java

4. Présentation de l’interface client MinIO

et de quelques actions possibles sur les dossiers et fichiers
5. Sauvegarde de fichier sur MinIO

6. Récupération de fichier depuis MinIO

Qu’est-ce que c’est MinIO
MinIO est un serveur de stockage d'objets open source
conçu pour stocker de vastes quantités de données non
structurées, y compris des fichiers, des images, des vidéos et
d'autres types de données binaires. Il offre une compatibilité
avec l'API S3 (Amazon Simple Storage Service) et permet de
gérer électroniquement des documents (GED), ce qui en fait
une solution populaire pour le stockage d'objets dans le
cloud et sur site, ainsi que pour la gestion électronique de
documents au sein d'une organisation.
Configuration de la dépendance requise et
définition des valeurs des variables
(application.properties)
Pour commencer, nous allons intégrer la dépendance MinIO
dans le gestionnaire de dépendances de notre projet Java,
que ce soit à travers le fichier Gradle ou le fichier pom.xml
(dans le cas de Maven). En procédant ainsi, nous prendrons
soin d'exclure la dépendance de OkHttp pour éviter tout
conflit avec la version utilisée dans notre application,
garantissant ainsi une intégration harmonieuse de MinIO.

<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
<version>8.5.2</version>
<exclusions>
<exclusion>
<artifactId>okhttp</artifactId>
<groupId>com.squareup.okhttp3</groupId>
</exclusion>
</exclusions>
</dependency>
Nous allons maintenant définir les valeurs des variables
dans le fichier application.properties qui seront utilisées lors
de la configuration du client MinIO.

# Minio Properties

- spring.minio.url: http://localhost:8080
- spring.minio.bucket: my-class-bucket
- spring.minio.access-key: admin
- spring.minio.secret-key: dfhjbgdjghGQ

url : url de la ressource

bucket : dossier principal qui héberge les

fichiers qui seront stockées

access-key : clé de connexion du client

secret-key : pass de connexion du client

NB : L'administrateur système configurera le serveur MinIO et fournira l'URL de la ressource.
Pour obtenir l'access-key et le secret-key, vous devrez les rechercher dans la barre latérale de
l'interface, spécifiquement dans le menu "Access Keys".

Menu Access Keys

Configuration du client MinIO avec
Java
Nous allons créer une classe de configuration qui lira les
valeurs des variables dans le fichier application.properties et
exposera des beans qui seront utilisés lors du démarrage de
notre application Spring Boot.
@Component
public class MinioClientConfig {
@Autowired
private ParamsUtils paramsUtils;

@Bean
public MinioClient getMinioClientVIP() {
log.info(String.format("addresse VIP minio:: %s",
paramsUtils.getEndpoint()));
return MinioClient
.builder()
.endpoint(paramsUtils.getEndpoint())
.credentials(paramsUtils.getAccessKey(),
paramsUtils.getSecretKey())
.build();
}

@Bean
public MinioClient getMinioClientCurrentServer() throws
UnknownHostException {
String localhost = "http://174.18.3.201:8080";
log.info(String.format("addresse local minio:: %s", localhost));
return MinioClient
.builder()
.endpoint(localhost)
.credentials(paramsUtils.getAccessKey(),
paramsUtils.getSecretKey())
.build();
}
}
Présentation de l’interface client
MinIO
et de quelques opérations possibles
sur les dossiers et fichiers
Nous allons présenter l'interface utilisateur de la page
d'accueil, mettant en évidence un répertoire (bucket) spécifique
dédié au projet 'myFacture', ainsi que les objets contenus dans
ses sous-dossiers. Ensuite, nous explorerons un ensemble
d'opérations possibles sur les objets et les dossiers.
chemin d’accès aux
fichiers
Sauvegarde de fichier sur MinIO byte[] bytes =
Base64.getDecoder().decode(dto.getFileToBase64());

Étant donné que MinIO requiert un objet de type InputStream long fileSize = fileInputStream.available();
en entrée, il est essentiel de prendre en compte que le fichier
String mimeType = mediaType.toString();
provenant du frontend est encodé en base 64, quel que soit
String[] fileExtension = mimeType.split("/");
son format (que ce soit xlsx, csv ou autre). Par conséquent, il
est impératif de convertir ce fichier en un InputStream avant if (dto.getExtension() == null) {
if (fileExtension.length == 2) {
d'entreprendre toute opération de sauvegarde vers le serveur dto.setFileName(dto.getFileName() + "." +
MinIO. (Voir l’image à droite) fileExtension[1]);
}
} else {
dto.setFileName(dto.getFileName() + "." +
dto.getExtension());
}

dto.setContentType(mimeType);
dto.setStream(fileInputStream);
dto.setFileSize(fileSize);
MinioClient minioClient = getClientMinio();

String bucketName = Utilities.notBlank(dto.getBucketName()) ? dto.getBucketName() :

paramsUtils.getBucketName();
dto.setBucketName(bucketName);

// Vérification de l'existence du bucket sinon création

BucketExistsArgs bucketExistsArgs = BucketExistsArgs.builder()
.bucket(dto.getBucketName())
.build();
boolean isExist = minioClient.bucketExists(bucketExistsArgs); // Vérifie si le bucket existe déjà.
if (!isExist) { // Si le bucket n'existe pas, créez-le.
MakeBucketArgs makeBucketArgs = MakeBucketArgs.builder()
.bucket(dto.getBucketName())
.build();
minioClient.makeBucket(makeBucketArgs);
}
PutObjectArgs putObjectArgs = getFilesPutObjectArgs(dto);
ObjectWriteResponse subResp = minioClient.putObject(putObjectArgs);

L’image ci-dessus présente le processus de sauvegarde d’un

fichier sur MinIO :
- Instanciation du client MinIO (ligne 178) ;
- Vérification de l’existence du bucket sinon on le crée (
ligne 184 - 189) ;
- Création d’un objet de type PutObjectArgs en lui
assignant la valeur que retourne la méthode
getFilesObjectArgs (ligne 190) ;
- Sauvegarde de l’objet à l’aide du client MinIO (ligne 191);
public PutObjectArgs getFilesPutObjectArgs(FilesDto dto) throws IOException {
// Récupérer les objets avec un tag spécifique
return PutObjectArgs.builder()
.bucket(dto.getBucketName())
.object(Utilities.notblank(dto.getFilePath()) ?
dto.getFilePath().concat(dto.getFileName()) : "") // projects/oci/qos.jar
.stream(dto.getStream(), dto.getFileSize(), -1)
.contentType(dto.getContentType())
.build();
}

Cette méthode permet de formater l'objet qui sera utilisé pour stocker nos données
dans notre système de gestion électronique de documents (GED) :

La méthode bucket() prend en paramètre le nom du bucket, qui est configuré dans
notre fichier application.properties.

La méthode object() prend en paramètre le nom du fichier. Il est important de noter

que nous avons la possibilité de créer des sous-dossiers dans notre bucket en utilisant
la méthode object(). Par exemple, pour stocker un fichier appelé
'photodeprofile.jpeg' dans un sous-dossier 'myfacture/momo/' qui stocke
dynamiquement le nom de l'utilisateur et le nom du fichier, nous utilisons :

.bucket("myfacture")
.object("myfacture/momo/photodeprofile.jpeg")

Cela permet de structurer nos données de manière organisée dans notre système de
stockage MinIO.
Illustration lors du run de la méthode
getFilesPutObjectArgs()
Récupération de fichier depuis MinIO
La récupération des fichiers dans le système de gestion
électronique de documents (GED) s'effectue en se basant sur
le chemin relatif depuis le répertoire racine du bucket.

Nous allons maintenant présenter l'illustration du processus

de récupération d'un ensemble de fichiers dans le programme
ci-dessous.
public List<InputStream> getFilesListGetObjectArgs(FilesDto dto, MinioClient minioClient) throws IOException,
ServerException, ErrorResponseException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException,
InternalException {
String fileName = Utilities.notBlank(dto.getFilePath()) ? dto.getFilePath().concat(dto.getFileName()) :
dto.getFileName();
List<InputStream> fileInputStreamList = new ArrayList<>();
ListObjectsArgs listObjectsArgs = ListObjectsArgs.builder()
.bucket(dto.getBucketName())
.prefix(fileName)
.recursive(true)
.build();

Iterable<Result<Item>> results = minioClient.listObjects(listObjectsArgs);

for (Result<Item> result : results) {
Item item = result.get();
// getObject unitary
fileInputStreamList.add(
minioClient.getObject(
GetObjectArgs.builder()
.bucket(dto.getBucketName())
.object(item.objectName())
.build()
)
);
}

return fileInputStreamList;
}
 - ListObjectsArg vous permet de demander la liste des
éléments dans le répertoire de base d'un bucket. Les
fichiers seront retournés sous forme d'InputStream ;

- Avec minio.getObject, vous pouvez obtenir un fichier

individuel du stockage MinIO sous forme d'InputStream ;

NB : Les modifications effectuées à un fichier dans MinIO se font en récupérant le fichier par son
nom. Une fois les modifications effectuées, la sauvegarde se réalise en utilisant le même nom de
fichier, ce qui remplace l'ancienne version par la nouvelle.
Suppression de fichier depuis MinIO
– Tout d'abord, nous préparerons l'objet à supprimer en
utilisant la méthode removeObjectArgs de type
RemoveObjectArgs.

-Enfin, nous supprimerons le fichier en utilisant la méthode

removeFileInMinIO.

public RemoveObjectArgs removeObjectArgs(FilesDto dto) throws IOException {

String _docPath = paramsUtils.getBucketName();

String _fileName = Utilities.notBlank(dto.getFileName()) ? MinioUtilis.getDocumentPath(dto) +
dto.getFileName() : "";
return RemoveObjectArgs.builder()
.bucket(_docPath)
.object(_fileName)
.build();
}

public void removeFileInMinio() throws Exception {

FilesDto dto = new FilesDto();
RemoveObjectArgs removeObjectArgs = removeObjectArgs(dto);
getClientMinio().removeObject(removeObjectArgs);
}