Configurer l'accélérateur OSS avec ossutil, ossfs et les SDK - Object Storage Service

Configurez l'accélérateur OSS à l'aide d'ossutil, d'ossfs, d'OSS Connector for AI/ML ou des SDK OSS pour un accès aux données à faible latence et haut débit.

Solutions

Utilisez ces outils et SDK pour accéder aux données avec une latence de l'ordre de la milliseconde et un débit élevé :

ossutil : ajoutez l'endpoint accéléré au fichier de configuration d'ossutil.
ossfs : spécifiez l'endpoint accéléré dans la commande de montage.
OSS Connector for AI/ML : définissez endpoint sur l'endpoint accéléré lors de la création d'un jeu de données.
SDK OSS : définissez endpoint sur l'endpoint accéléré lors de l'initialisation d'OSSClient. Cet exemple utilise le SDK OSS pour Java.

Important

Utilisez l'endpoint accéléré comme endpoint OSS :

Dans ossutil, définissez endpoint sur l'endpoint accéléré.
Dans ossfs, définissez -ourl sur l'endpoint accéléré.

Prérequis

Vous avez créé un accélérateur. Pour plus d'informations, consultez Créer un accélérateur OSS.

Solution 1 : utiliser l'accélérateur OSS avec ossutil

Utiliser l'accélérateur OSS avec ossutil

Cet exemple utilise ossutil sur Linux x86 64 bits. Pour savoir comment installer ossutil sur d'autres systèmes d'exploitation, consultez Installer ossutil.

Installez ossutil.

Téléchargez le package ossutil.

curl -o ossutil-2.0.3-beta.09261200-linux-amd64.zip https://gosspublic.alicdn.com/ossutil/v2-beta/2.0.3-beta.09261200/ossutil-2.0.3-beta.09261200-linux-amd64.zip

Décompressez le package :

unzip ossutil-2.0.3-beta.09261200-linux-amd64.zip

Rendez le binaire exécutable :
```
chmod 755 ossutil
```

Ajoutez ossutil au PATH système :

sudo mv ossutil /usr/local/bin/ && sudo ln -s /usr/local/bin/ossutil /usr/bin/ossutil

Vérifiez l'installation.
```
ossutil version
```

Configurez ossutil avec l'endpoint accéléré.

Créez un fichier de configuration ossutil.
```
touch ossutilconfig
```

Définissez les paramètres. Pour plus d'informations, consultez Configurer ossutil.

#[profile dev]                  The name of the section. You can specify the name of the section. 
#accessKeyId, accessKeySecret  The AccessKey ID and AccessKey secret of the RAM user.  
#region                        The region in which the bucket is located. 
# buckets=dev-bucket            Use the parameters in the dev-bucket section. 
#[buckets dev-bucket]          The name of the section. You can specify the name of the section. 
#bucketname                    The name of the bucket.  
#endpoint                      The accelerated endpoint of the accelerator.  

[profile dev]
accessKeyId=LTA*********************ICT
accessKeySecret=V0qK**********************OOKp
region=cn-hangzhou
buckets=dev-bucket

[buckets dev-bucket]
bucket-name =
#Specify the endpoint of the accelerator. 
  endpoint=cn-hangzhou-j-internal.oss-data-acc.aliyuncs.com

Utilisez l'accélérateur.

Cet exemple télécharge un objet vers le répertoire test. Pour plus d'informations sur les commandes ossutil, consultez Commandes ossutil.

La commande cp permet de télécharger des objets. L'option -r active les opérations récursives sur le bucket bucket-name. L'option -c spécifie le chemin du fichier de configuration. L'option --profile sélectionne la section dev.
```
ossutil cp -r oss://bucket-name/ ./test/ -c ./ossutilconfig --profile dev
```

Solution 2 : utiliser l'accélérateur OSS avec ossfs

Utiliser l'accélérateur OSS avec ossfs

Cet exemple utilise ossfs sur Ubuntu 16.04 x86. Pour les autres systèmes d'exploitation, consultez Installer ossfs.

Installez ossfs.

sudo wget https://gosspublic.alicdn.com/ossfs/ossfs_1.91.3_ubuntu16.04_amd64.deb
sudo apt-get update
sudo apt-get install gdebi-core
sudo gdebi ossfs_1.91.3_ubuntu16.04_amd64.deb

Ajoutez le fichier mime.types.

Assurez-vous que les types de contenu correspondent aux extensions de fichier :
```
sudo apt-get install mime-support
```
Configurez ossfs et montez le bucket avec l'endpoint accéléré. Pour plus d'informations sur les opérations de montage avec ossfs, consultez Monter un bucket.
1. Stockez l'ID AccessKey et le secret AccessKey dans /etc/passwd-ossfs.
```
echo bucket-test:LTAI****************2CT:V0************************OKp > /etc/passwd-ossfs
```
2. Définissez les autorisations du fichier de configuration sur 640.
```
chmod 640 /etc/passwd-ossfs 
```
3. Créez un répertoire de montage.
```
mkdir bucket-test
```
4. Montez bucket-test sur /tmp/bucket-test/ avec l'endpoint accéléré.
```
ossfs bucket-test /tmp/bucket-test/ -ourl=cn-hangzhou-j-internal.oss-data-acc.aliyuncs.com
```
Utilisez l'accélérateur.

Les lectures et écritures sur le bucket monté sont désormais accélérées.

Solution 3 : utiliser l'accélérateur OSS avec OSS Connector for AI/ML

Utiliser l'accélérateur OSS avec OSS Connector for AI/ML

Cet exemple utilise Python 3.12. Ajustez le numéro de version pour les autres versions de Python.

Prérequis :

Système d'exploitation : Linux x86 64 bits
glibc : version 2.17 ou ultérieure
Python : versions 3.8 à 3.12
PyTorch : version 2.0 ou ultérieure
Pour utiliser la fonctionnalité de point de contrôle (checkpoint) OSS, le noyau Linux doit prendre en charge userfaultfd.

Remarque
Sur Ubuntu, exécutez sudo grep CONFIG_USERFAULTFD /boot/config-$(uname -r) pour vérifier la prise en charge de userfaultfd. CONFIG_USERFAULTFD=y signifie que la fonction est prise en charge. CONFIG_USERFAULTFD=n signifie qu'elle n'est pas prise en charge et que la fonctionnalité de point de contrôle n'est pas disponible.

Installez OSS Connector for AI/ML.
1. Sur votre système d'exploitation Linux ou dans un conteneur construit à partir d'une image Linux, exécutez la commande pip3.12 install osstorchconnector pour installer OSS Connector for AI/ML.
```
pip3.12 install osstorchconnector
```
2. Exécutez pip3.12 show osstorchconnector pour vérifier l'installation.
```
pip3.12 show osstorchconnector
```
  Une installation réussie affiche les informations de version d'osstorchconnector. Le résultat ressemble à ce qui suit :
```
Name: osstorchconnector
Version: 1.0.0rc1
Summary: OSS connector for AI/ML
Home-page: 
Author: 
Author-email: 
License: 
Location: /usr/local/lib/python3.12/dist-packages
Requires: torch
Required-by:
```
Configurez OSS Connector for AI/ML.
1. Créez un fichier de configuration pour les identifiants d'accès.
```
mkdir -p /root/.alibabacloud && touch /root/.alibabacloud/credentials
```
2. Ajoutez la configuration des identifiants d'accès et enregistrez le fichier.
  
  Remplacez <Access-key-id> et <Access-key-secret> dans l'exemple par l'ID AccessKey et le secret AccessKey d'un utilisateur Resource Access Management (RAM). Pour savoir comment créer un ID AccessKey et un secret AccessKey, consultez Créer un AccessKey. Pour plus d'informations sur les éléments de configuration et l'utilisation d'identifiants d'accès temporaires, consultez Configurer les identifiants d'accès.
```
{
  "AccessKeyId": "LTAI************************",
  "AccessKeySecret": "At32************************"
}
```
3. Créez le fichier de configuration d'OSS Connector.
```
mkdir -p /etc/oss-connector/ && touch /etc/oss-connector/config.json
```
4. Ajoutez la configuration d'OSS Connector et enregistrez le fichier. Pour plus d'informations sur les éléments de configuration, consultez Configurer OSS Connector.
  
  Dans la plupart des cas, vous pouvez utiliser les configurations par défaut suivantes.
```
{
    "logLevel": 1,
    "logPath": "/var/log/oss-connector/connector.log",
    "auditPath": "/var/log/oss-connector/audit.log",
    "datasetConfig": {
        "prefetchConcurrency": 24,
        "prefetchWorker": 2
    },
    "checkpointConfig": {
        "prefetchConcurrency": 24,
        "prefetchWorker": 4,
        "uploadConcurrency": 64
    }
}
```

Utilisez l'accélérateur.

Créez un jeu de données avec OssMapDataset.from_prefix et définissez Endpoint sur l'endpoint accéléré.

from osstorchconnector import OssMapDataset

# Replace ENDPOINT with the accelerated endpoint of the accelerator. 
ENDPOINT = "cn-hangzhou-j-internal.oss-data-acc.aliyuncs.com"
# Specify the path of the OSS Connector for AI/ML configuration file. 
CONFIG_PATH = "/etc/oss-connector/config.json"
# Specify the path of the access credential configuration file. 
CRED_PATH = "/root/.alibabacloud/credentials"
# Specify the path of the directory of the bucket. 
OSS_URI = "oss://ai-testset/EnglistImg/Img/BadImag/Bmp/Sample001/"

# Use the from_prefix method of OssMapDataset to build a dataset.
map_dataset = OssMapDataset.from_prefix(oss_uri=OSS_URI, endpoint=ENDPOINT, cred_path=CRED_PATH, config_path=CONFIG_PATH)

# Access objects in the created dataset at random.
item = map_dataset[0]
print(item.key)
content = item.read()
print(item.size)
print(len(content))

# Traverse the objects in the dataset.
for item in map_dataset:
    print(item.key)
    print(item.size)
    content = item.read()
    print(len(content))

Solution 4 : utiliser l'accélérateur OSS avec les SDK OSS

Utiliser l'accélérateur OSS avec les SDK OSS

Cet exemple utilise le SDK OSS pour Java. Pour les autres SDK, définissez l'endpoint accéléré lors de l'initialisation d'OSSClient.

Prérequis :
- Java 1.7.0 ou version ultérieure est installé.
- Exécutez java -version pour vérifier.

Ajoutez la dépendance du SDK OSS pour Java à votre projet Maven (Installation).

Ajoutez ces dépendances au fichier pom.xml (SDK OSS pour Java 3.17.4) :

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

Si vous utilisez Java 9 ou une version ultérieure, ajoutez ces dépendances JAXB :

<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.1</version>
</dependency>
<dependency>
    <groupId>javax.activation</groupId>
    <artifactId>activation</artifactId>
    <version>1.1.1</version>
</dependency>
<!-- no more than 2.3.3-->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.3</version>
</dependency>

Utilisez l'accélérateur.

Téléchargez un objet en définissant endpoint sur l'endpoint accéléré.

import com.aliyun.oss.ClientBuilderConfiguration;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.common.comm.SignVersion;

import java.io.ByteArrayInputStream;

public class OssCliectTest {
    public static void main(String[] args) throws Exception {
        // Specify the accelerated endpoint of the accelerator. 
        String endpoint = "cn-hangzhou-j-internal.oss-data-acc.aliyuncs.com";
        // Specify the ID of the region that maps to the endpoint. Example: cn-hangzhou.
        String region = "cn-hangzhou";

        // Specify access credentials.
        String alibaba_cloud_access_key_id = "LT********************CT";
        String alibaba_cloud_access_key_secret = "V0q***************************OKp";

        // Specify the name of the bucket. Example: examplebucket. 
        String bucketName = "BucketName";
        // Specify the full path of the object. Example: exampledir/exampleobject.txt. Do not include the bucket name in the full path. 
        String objectName = "Test.txt";

        // Create an OSSClient instance.
        // Call the shutdown method to release resources when the OSSClient is no longer in use. 
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        // Explicitly declare the use of the V4 signature algorithm.
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();
        
        String content = "##################";
        // Upload the configurations of the content variable to the Test.txt file in the bucket.
        ossClient.putObject(bucketName,objectName,new ByteArrayInputStream(content.getBytes()));
        
        // Shut down the OSSClient instance. 
        ossClient.shutdown();
    }
}