Initialisation et Conifguration Pour interagir efficacement avec le service de stockage objet d'Alibaba Cloud, une classe encapsulant les opérations de base est requise. Cette approche centralise la gestion des identifiants d'accès ainsi que la connexion au point de terminaison.

# -*- coding: utf-8 -*-
import os
import oss2
from configparser import ConfigParser

class OssManagement:
    def __init__(self, config_file='settings.ini'):
        self._config_path = config_file
        
        # Chargement des paramètres depuis un fichier ou des variables d'environnement
        parser = ConfigParser()
        parser.read(self._config_path)
        
        self._access_key_id = os.environ.get('OSS_ACCESS_KEY', parser.get('credentials', 'OSS_ACCESS_KEY_ID'))
        self._access_key_secret = os.environ.get('OSS_SECRET_KEY', parser.get('credentials', 'OSS_ACCESS_KEY_SECRET'))
        self._endpoint = os.environ.get('OSS_ENDPOINT', parser.get('storage', 'OSS_ENDPOINT'))
        self._bucket_name = os.environ.get('BUCKET_NAME', parser.get('storage', 'OSS_BUCKET'))

        # Initialisation de l'authentification et du client bucket
        auth_info = oss2.Auth(self._access_key_id, self._access_key_secret)
        self.client = oss2.Bucket(auth_info, self._endpoint, self._bucket_name)

Récupération et Envoi de Données L'envoi d'un fichier stocké localement se fait en utilisant la méthode native qui lit le chemin disque et transfère le contenu vers le blob correspondant dans le bucket.

• Paramètres : Nom local du fichier, nom cible dans OSS.
• Exemple :

# Téléversement d'un fichier local
local_source = './images/photo.jpg'
remote_target = 'albums/summer.jpg'
self.client.put_object_from_file(remote_target, local_source)

Pour transférer du contenu généré dynamiquement ou ne nécessitant pas de passage par le disque, il est possible de travailler directement sur un flux binaire ou une chaîne de caractères.

# Upload via flux mémoire
content_data = b'Contenu texte binarisé'
key_target = 'data/logs.txt'
self.client.put_object(key_target, content_data)

Téléchargement et Vérification d'Existence Le téléchargement permet de récupérer les objets distants vers le système de fichiers local. Il inclut une vérification préalable pour éviter les erreurs sur des clés inexistantes.

def recuperer_fichier(self, key_source, destination_locale=None):
    if not self.verifier_existence(key_source):
        return False
    
    path_final = destination_locale if destination_locale else key_source
    self.client.get_object_to_file(key_source, path_final)
    return True

Afin de s'assurer qu'une ressource est présente avant toute tentative de lecture ou suppression, la vérification d'existence retourne un booléen instantané.

def verifier_existence(self, cle_objet):
    try:
        return self.client.object_exists(cle_objet)
    except oss2.exceptions.NoSuchKey:
        return False

Suppression et URLs Temporaires La suppression définitive des ressources nécessite la confirmation de la clé de l'objet. Elle est irréversible après exécution.

def supprimer_ressource(self, cle_objet):
    self.client.delete_object(cle_objet)

Parfois, il est nécessaire de partager l'accès à un fichier sans divulgation directe des clés API privées. Le système fournit alors une URL signée avec une période d'expiration déterminée.

def generer_lien_signe(self, cle_objet, duree_seconde=3600):
    # Génération de l'URL avec expiration
    url_generée = self.client.sign_url('GET', cle_objet, duree_seconde)
    
    # Nettoyage optionnel : suppression du suffixe interne si utilisé sur VPC
    if '-internal' in url_generée:
        url_generée = url_generée.replace('-internal', '')
        
    return url_generée

Lecture en Flux Pour des traitements où l'on souhaite parcourir le contenu sans charger tout le buffer en mémoire, le client retourne un objet permettant une lecture itérative.

def lire_flux(self, cle_objet):
    if not self.verifier_existence(cle_objet):
        return None
    
    objet_response = self.client.get_object(cle_objet)
    return objet_response

L'utilisation de ce flux permet d'appeler .read() ou de l'itérer ligne par ligne selon les besoins du traitement downstream.