Tous les produits
Search

Ce produit

    MaxCompute:Traiter des données non structurées à l'aide de MaxCompute External Volume

    Centre de documentation

    MaxCompute:Traiter des données non structurées à l'aide de MaxCompute External Volume

    Dernière mise à jour :Aug 10, 2026

    Les volumes externes agissent comme des systèmes de fichiers distribués dans MaxCompute, adossés à Object Storage Service (OSS). Montez un volume externe sur un répertoire OSS : vos tâches Spark on MaxCompute et MapReduce peuvent alors lire et écrire des fichiers via le système d'autorisations de MaxCompute, sans accorder un accès direct à OSS à chaque utilisateur.

    Chaque projet MaxCompute peut comporter plusieurs volumes externes.

    Cas d'utilisation

    Les volumes externes sont utiles pour :

    • Charger les dépendances des tâches au démarrage — téléchargez automatiquement les fichiers JAR, les wheels Python ou les archives de modèles dans le répertoire de travail de la tâche avant le début de l'exécution.

    • Lire et écrire des fichiers OSS dans le code Spark — accédez aux fichiers stockés dans OSS en utilisant directement le schéma de chemin odps:// dans le code de votre tâche Spark.

    • Appliquer un contrôle d'accès granulaire — utilisez le système d'autorisations de MaxCompute pour contrôler qui peut lire ou écrire dans des chemins de volume spécifiques, au lieu de gérer des stratégies de compartiment OSS par utilisateur.

    • Stocker les sorties des tâches de Machine Learning — enregistrez les données d'index ou les fichiers de modèle générés par des moteurs tels que Proxima CE vers OSS via un volume.

    Facturation

    Les données des volumes externes sont stockées dans OSS. Aucun frais de stockage ne vous est facturé au sein de MaxCompute. Des frais de calcul s'appliquent lorsqu'un moteur MaxCompute lit ou traite des données dans un volume externe, par exemple lors de l'exécution d'une tâche Spark on MaxCompute ou MapReduce. Les sorties écrites dans OSS (telles que les données d'index de Proxima CE) sont facturées selon les tarifs standard de stockage OSS.

    Prérequis

    Avant de commencer, assurez-vous d'avoir :

    Démarrage rapide

    Étape 1 : Accorder les autorisations requises

    Pour utiliser les volumes externes, votre compte doit disposer des autorisations suivantes : CreateInstance, CreateVolume, List, Read et Write. Consultez Autorisations MaxCompute.

    1. Vérifiez si votre compte dispose de l'autorisation CreateVolume :

      SHOW GRANTS FOR <user_name>;

    2. Si l'autorisation CreateVolume est manquante, accordez-la :

      GRANT CreateVolume ON project <project_name> TO USER <user_name>;

      Pour révoquer l'autorisation ultérieurement :

      REVOKE CreateVolume ON project <project_name> FROM USER <user_name>;

    3. Exécutez à nouveau SHOW GRANTS pour confirmer que l'autorisation a été accordée.

    Étape 2 : Créer un volume externe

    Exécutez la commande suivante avec le compte disposant de l'autorisation CreateVolume :

    vfs -create <volume_name>
    -storage_provider oss
    -url oss://<oss_endpoint>/<bucket>/<path>
    -acd <true|false>
    -role_arn <arn:aliyun:xxx/aliyunodpsdefaultrole>

    Pour plus de détails sur les paramètres et d'autres opérations relatives aux volumes, consultez Opérations sur les volumes externes.

    Après la création, le chemin du volume est odps://[project_name]/[volume_name]. Utilisez ce chemin dans les tâches Spark on MaxCompute et MapReduce.

    Étape 3 : Vérifier le volume

    Listez tous les volumes du projet actuel pour confirmer la création du volume :

    vfs -ls /;

    Utiliser Spark on MaxCompute avec des volumes externes

    Spark on MaxCompute est compatible avec Spark open source et s'exécute sur les ressources de calcul intégrées, les jeux de données et le système d'autorisations de MaxCompute.

    Il existe deux façons d'accéder aux volumes externes depuis une tâche Spark :

    • Référencer des fichiers au démarrage de la tâche — les fichiers du volume sont téléchargés dans le répertoire de travail de la tâche avant son démarrage.

    • Accéder aux fichiers dans le code — utilisez directement le schéma de chemin odps:// dans votre code Spark pour lire et écrire des fichiers de volume au moment de l'exécution.

    Référencer des fichiers au démarrage de la tâche

    Configurez les paramètres suivants dans la section Parameters du nœud ODPS Spark de DataWorks, ou dans le fichier spark-defaults.conf. Ces paramètres ne peuvent pas être définis dans le code de votre tâche.

    Paramètre Description
    spark.hadoop.odps.cupid.volume.files Fichiers à télécharger dans le répertoire de travail de la tâche avant le démarrage. Séparez plusieurs fichiers par des virgules. Chaque valeur doit inclure le nom complet du fichier.
    spark.hadoop.odps.cupid.volume.archives Fichiers d'archive (.zip, .tar.gz, .tar) à télécharger et décompresser dans le répertoire de travail de la tâche avant le démarrage. Séparez plusieurs archives par des virgules.

    Format de la valeur :

    odps://[project_name]/[volume_name]/[path_to_file]

    Exemple — fichiers :

    spark.hadoop.odps.cupid.volume.files=
odps://mc_project/external_volume/data/mllib/kmeans_data.txt,
odps://mc_project/external_volume/target/PythonKMeansExample/KMeansModel/data/part-00000-a2d44ac5-54f6-49fd-b793-f11e6a189f90-c000.snappy.parquet

    Après le démarrage de la tâche, le répertoire de travail contient kmeans_data.txt et part-00000-a2d44ac5-54f6-49fd-b793-f11e6a189f90-c000.snappy.parquet.

    Exemple — archives :

    spark.hadoop.odps.cupid.volume.archives=
odps://spark_test_wj2/external_volume/pyspark-3.1.1.zip,
odps://spark_test_wj2/external_volume/python-3.7.9-ucs4.tar.gz

    Après le démarrage de la tâche, le répertoire de travail contient le contenu décompressé de pyspark-3.1.1.zip et de python-3.7.9-ucs4.tar.gz.

    Accéder aux fichiers dans le code

    Pour lire et écrire des fichiers de volume externe depuis le code de votre tâche Spark, définissez les paramètres suivants dans le code :

    Paramètre Valeur Description
    spark.hadoop.odps.volume.common.filesystem true Active la reconnaissance des volumes externes. Valeur par défaut : false.
    spark.hadoop.odps.cupid.volume.paths odps://[project_name]/[volume_name]/ Chemin du volume à accéder. Valeur par défaut : vide.
    spark.hadoop.fs.odps.impl org.apache.hadoop.fs.aliyun.volume.OdpsVolumeFileSystem Classe d'implémentation pour l'accès à OSS.
    spark.hadoop.fs.AbstractFileSystem.odps.impl org.apache.hadoop.fs.aliyun.volume.abstractfsimpl.OdpsVolumeFs Classe d'implémentation du système de fichiers abstrait.

    Exemple — Clustering K-means avec volume externe :

    L'exemple suivant utilise l'algorithme K-means. Il lit les données d'entraînement depuis odps://ms_proj1_dev/volume_yyy1/, entraîne un modèle et enregistre la sortie dans le même volume.

    Tous les chemins de fichier dans le code utilisent le schéma odps:// pour lire et écrire dans le volume externe.

    Remarque

    Définissez les quatre paramètres ci-dessus dans spark-defaults.conf ou dans la section Parameters du nœud ODPS Spark de DataWorks avant d'exécuter ce code. L'exemple nécessite également les paramètres supplémentaires suivants pour l'accès à OSS, le SDK JindoFS et l'environnement d'exécution Python :

    -- Parameters
spark.hadoop.odps.cupid.volume.paths=odps://ms_proj1_dev/volume_yyy1/
spark.hadoop.odps.volume.common.filesystem=true
spark.hadoop.fs.odps.impl=org.apache.hadoop.fs.aliyun.volume.OdpsVolumeFileSystem
spark.hadoop.fs.AbstractFileSystem.odps.impl=org.apache.hadoop.fs.aliyun.volume.abstractfsimpl.OdpsVolumeFs

spark.hadoop.odps.access.id=xxxxxxxxx
spark.hadoop.odps.access.key=xxxxxxxxx
spark.hadoop.fs.oss.endpoint=oss-cn-beijing-internal.aliyuncs.com
spark.hadoop.odps.cupid.resources=ms_proj1_dev.jindofs-sdk-3.8.0.jar
spark.hadoop.fs.oss.impl=com.aliyun.emr.fs.oss.JindoOssFileSystem

spark.hadoop.odps.cupid.resources=public.python-2.7.13-ucs4.tar.gz
spark.pyspark.python=./public.python-2.7.13-ucs4.tar.gz/python-2.7.13-ucs4/bin/python
spark.hadoop.odps.spark.version=spark-2.4.5-odps0.34.0

-- Code
    from numpy import array
from math import sqrt

from pyspark import SparkContext
from pyspark.mllib.clustering import KMeans, KMeansModel

if __name__ == "__main__":
    sc = SparkContext(appName="KMeansExample")

    # Read training data from the external volume
    data = sc.textFile("odps://ms_proj1_dev/volume_yyy1/kmeans_data.txt")
    parsedData = data.map(lambda line: array([float(x) for x in line.split(' ')]))

    # Train the K-means model
    clusters = KMeans.train(parsedData, 2, maxIterations=10, initializationMode="random")

    # Evaluate the model
    def error(point):
        center = clusters.centers[clusters.predict(point)]
        return sqrt(sum([x**2 for x in (point - center)]))

    WSSSE = parsedData.map(lambda point: error(point)).reduce(lambda x, y: x + y)
    print("Within Set Sum of Squared Error = " + str(WSSSE))

    # Save the model to the external volume
    clusters.save(sc, "odps://ms_proj1_dev/volume_yyy1/target/PythonKMeansExample/KMeansModel")
    print(parsedData.map(lambda feature: clusters.predict(feature)).collect())

    # Load and use the saved model
    sameModel = KMeansModel.load(sc, "odps://ms_proj1_dev/volume_yyy1/target/PythonKMeansExample/KMeansModel")
    print(parsedData.map(lambda feature: sameModel.predict(feature)).collect())

    sc.stop()

    Une fois la tâche terminée, consultez les fichiers de sortie dans le répertoire OSS mappé au volume.

    Utiliser Proxima CE pour la vectorisation dans MaxCompute

    Proxima CE effectue l'indexation vectorielle et la recherche des plus proches voisins sur les données stockées dans les tables MaxCompute. Les résultats sont enregistrés dans un volume externe sur OSS.

    Limitations

    • Le SDK Proxima pour Java prend en charge uniquement Linux et macOS. Les fichiers JAR contiennent des dépendances spécifiques à Linux et ne peuvent pas s'exécuter sur le client MaxCompute sous Windows.

    • Proxima CE exécute deux types de tâches : les tâches locales (n'impliquant ni SQL, ni MapReduce, ni Graph) et les tâches MaxCompute (exécutées via les moteurs SQL, MapReduce ou Graph). Les deux types s'exécutent alternativement. Au démarrage, Proxima CE tente de charger le noyau Proxima sur la machine locale. Si le chargement du noyau réussit, certains modules s'exécutent localement ; en cas d'échec du chargement, des erreurs sont signalées mais la tâche continue en utilisant des fonctions de secours.

    • Soumettez la tâche en utilisant le client MaxCompute (odpscmd). Les nœuds MapReduce de DataWorks ne sont pas pris en charge car la version sous-jacente du client MaxCompute est en cours de mise à niveau.

    Exécuter une tâche de vectorisation Proxima CE

    Étape 1 : Installez le package de ressources Proxima CE.

    Étape 2 : Préparez les données d'entrée.

    Créez les tables d'entrée et insérez des exemples de données :

    -- Create a base table and a query table
CREATE TABLE doc_table_float_smoke(pk STRING, vector STRING) PARTITIONED BY (pt STRING);
CREATE TABLE query_table_float_smoke(pk STRING, vector STRING) PARTITIONED BY (pt STRING);

-- Insert data into the base table
ALTER TABLE doc_table_float_smoke ADD PARTITION(pt='20230116');
INSERT OVERWRITE TABLE doc_table_float_smoke PARTITION (pt='20230116') VALUES
('1.nid','1~1~1~1~1~1~1~1'),
('2.nid','2~2~2~2~2~2~2~2'),
('3.nid','3~3~3~3~3~3~3~3'),
('4.nid','4~4~4~4~4~4~4~4'),
('5.nid','5~5~5~5~5~5~5~5'),
('6.nid','6~6~6~6~6~6~6~6'),
('7.nid','7~7~7~7~7~7~7~7'),
('8.nid','8~8~8~8~8~8~8~8'),
('9.nid','9~9~9~9~9~9~9~9'),
('10.nid','10~10~10~10~10~10~10~10');

-- Insert data into the query table
ALTER TABLE query_table_float_smoke ADD PARTITION(pt='20230116');
INSERT OVERWRITE TABLE query_table_float_smoke PARTITION (pt='20230116') VALUES
('q1.nid','1~1~1~1~2~2~2~2'),
('q2.nid','4~4~4~4~3~3~3~3'),
('q3.nid','9~9~9~9~5~5~5~5');

    Étape 3 : Soumettez la tâche Proxima CE.

    jar -libjars proxima-ce-aliyun-1.0.0.jar
-classpath proxima-ce-aliyun-1.0.0.jar com.alibaba.proxima2.ce.ProximaCERunner
-doc_table doc_table_float_smoke
-doc_table_partition 20230116
-query_table query_table_float_smoke
-query_table_partition 20230116
-output_table output_table_float_smoke
-output_table_partition 20230116
-data_type float
-dimension 8
-topk 1
-job_mode train:build:seek:recall
-external_volume shanghai_vol_ceshi
-owner_id 1248953xxx
;

    Étape 4 : Vérifiez les résultats.

    Interrogez la table de sortie pour vérifier les résultats de recherche des plus proches voisins :

    SELECT * FROM output_table_float_smoke WHERE pt='20230116';

    Sortie attendue :

    +------------+------------+------------+------------+
| pk         | knn_result | score      | pt         |
+------------+------------+------------+------------+
| q1.nid     | 2.nid      | 4.0        | 20230116   |
| q1.nid     | 1.nid      | 4.0        | 20230116   |
| q1.nid     | 3.nid      | 20.0       | 20230116   |
| q2.nid     | 4.nid      | 4.0        | 20230116   |
| q2.nid     | 3.nid      | 4.0        | 20230116   |
| q2.nid     | 2.nid      | 20.0       | 20230116   |
| q3.nid     | 7.nid      | 32.0       | 20230116   |
| q3.nid     | 8.nid      | 40.0       | 20230116   |
| q3.nid     | 6.nid      | 40.0       | 20230116   |
+------------+------------+------------+------------+

    Étapes suivantes