L'intégration d'Alibaba Cloud Object Storage Service (OSS) dans une application Spring Boot permet de déléguer le stockage de fichiers binaires à une infrastructure cloud robuste. Ce guide détaille la mise en place d'un service de téléversement sécurisé et configurable.

1. Préparation des identifiants cloud

Avant toute chose, assurez-vous de disposer d'un compte Alibaba Cloud actif. Créez un bucket OSS et générez une paire de clés d'accès (AccessKey ID et AccessKey Secret) via la console de gestion des identités et des accès (RAM).

2. Ajout des dépendances Maven

Intégrez le SDK officiel d'Alibaba Cloud OSS dans votre fichier pom.xml :

<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.17.1</version>
</dependency>

3. Externalisation de la configuration

Définissez les paramètres de connexion dans votre fichier application.yml. Il est recommandé d'utiliser des variables d'environnement pour les informations sensibles en production.

cloud:
  storage:
    aliyun:
      endpoint: oss-cn-hangzhou.aliyuncs.com
      access-key: ${ALIYUN_ACCESS_KEY}
      secret-key: ${ALIYUN_SECRET_KEY}
      container: my-application-bucket

4. Modélisation des propriétés de configuration

Créez une classe dédiée pour mapper les propriétés YAML. Cette approche centralise la gestion des paramètres et facilite leur injection dans les composants Spring.

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import lombok.Data;

@Data
@Component
@ConfigurationProperties(prefix = "cloud.storage.aliyun")
public class AliyunStorageSettings {
    private String endpoint;
    private String accessKey;
    private String secretKey;
    private String container;
}

5. Implémentation du service de stockage

Concevez un service métier pour ecnapsuler la logique d'interaction avec l'API OSS. Cette approche améliore la testabilité et rsepecte le principe de responsabilité unique. Les exceptions sont capturées et journalisées proprement plutôt que d'être simplement affichées dans la console.

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.DefaultCredentialProvider;
import com.aliyun.oss.model.PutObjectRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.io.ByteArrayInputStream;

@Slf4j
@Service
@RequiredArgsConstructor
public class CloudStorageService {

    private final AliyunStorageSettings settings;

    public String storeFile(byte[] fileData, String targetPath) {
        DefaultCredentialProvider credentialsProvider = CredentialsProviderFactory
                .newDefaultCredentialProvider(settings.getAccessKey(), settings.getSecretKey());
        
        OSS storageClient = new OSSClientBuilder()
                .build(settings.getEndpoint(), credentialsProvider);

        try {
            PutObjectRequest putRequest = new PutObjectRequest(
                    settings.getContainer(), 
                    targetPath, 
                    new ByteArrayInputStream(fileData)
            );
            storageClient.putObject(putRequest);
            
            // Génération de l'URL publique
            String publicUrl = String.format("https://%s.%s/%s", 
                    settings.getContainer(), 
                    settings.getEndpoint(), 
                    targetPath);
                    
            log.info("Téléversement réussi vers l'URI : {}", publicUrl);
            return publicUrl;
            
        } catch (Exception e) {
            log.error("Échec du téléversement du fichier vers le conteneur cloud : {}", e.getMessage(), e);
            throw new RuntimeException("Erreur lors de l'opération de stockage cloud", e);
        } finally {
            storageClient.shutdown();
        }
    }
}

6. Configuration explicite du Bean (Optionnel)

Si vous préférez ne pas utiliser l'annotation @Service directement sur la classe ci-dessus et souhaitez contrôler finement le cycle de vie du bean, vous pouvez déclarer une classe de configuration Spring. Cette méthode est particulièrement utile pour créer des beans conditionnels.

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class StorageAutoConfiguration {

    @Bean
    @ConditionalOnProperty(prefix = "cloud.storage.aliyun", name = "endpoint")
    public CloudStorageService cloudStorageService(AliyunStorageSettings settings) {
        return new CloudStorageService(settings);
    }
}

7. Utilisation dans un contrôleur REST

Injectez le CloudStorageService dans vos contrôleurs pour traiter les requêtes multipart et exposer un point de terminaison d'API.

import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import lombok.RequiredArgsConstructor;

import java.io.IOException;
import java.util.UUID;

@RestController
@RequestMapping("/api/media")
@RequiredArgsConstructor
public class MediaController {

    private final CloudStorageService storageService;

    @PostMapping("/upload")
    public String handleFileUpload(@RequestParam("file") MultipartFile multipartFile) throws IOException {
        String originalFilename = multipartFile.getOriginalFilename();
        String uniquePath = "uploads/" + UUID.randomUUID() + "_" + originalFilename;
        
        return storageService.storeFile(multipartFile.getBytes(), uniquePath);
    }
}