Comment résoudre les augmentations inattendues des frais de paiement à l'utilisation - MaxCompute

L'utilisation de MaxCompute engendre des frais. Si vos dépenses quotidiennes, généralement stables, augmentent soudainement sans lien avec une croissance normale de l'activité, effectuez une analyse des coûts pour identifier les projets et les tâches responsables de ce pic. Vous pourrez ainsi optimiser et ajuster rapidement vos tâches pour maîtriser vos dépenses. Cette rubrique explique comment diagnostiquer une hausse inattendue des frais MaxCompute en paiement à l'utilisation en vous appuyant sur les détails de facturation et le service de métadonnées MaxCompute (Information Schema).

Contexte

Pour diagnostiquer une augmentation inattendue des frais MaxCompute en paiement à l'utilisation, suivez la procédure ci-dessous :

Dans la console Expenses and Costs, identifiez la date de la hausse inattendue des coûts. Déterminez ensuite quel projet et quel élément facturable ont généré ces frais élevés ce jour-là.
Analysez la cause précise de cette augmentation :
- Si les frais de calcul dépassent vos prévisions, utilisez la vue TASKS_HISTORY d'Information Schema pour analyser le volume des tâches et identifier celles qui coûtent le plus cher.
- Si les frais de stockage sont supérieurs à la normale, téléchargez un relevé d'utilisation pour analyser l'évolution des coûts de stockage.
- Si les frais de trafic sortant sur le réseau public sont anormalement élevés, servez-vous de la vue TUNNELS_HISTORY d'Information Schema pour suivre l'évolution des frais de téléchargement.

Étape 1 : Obtenir Information Schema

Depuis le 1er mars 2024, MaxCompute n'installe plus automatiquement Information Schema au niveau du projet pour les nouveaux projets. Pour interroger les métadonnées, utilisez Information Schema au niveau du tenant afin d'obtenir des informations plus complètes. Pour plus de détails sur l'utilisation d'Information Schema au niveau du tenant, consultez Information Schema au niveau du tenant.

Pour les projets MaxCompute existants, effectuez les opérations suivantes avant d'utiliser le service Information Schema :

En tant que propriétaire du projet ou utilisateur RAM disposant du rôle de gestion Super_Administrator, installez le package d'autorisations Information Schema pour accéder aux métadonnées du projet. Pour plus d'informations sur l'attribution de rôles aux utilisateurs, consultez Attribuer des rôles aux utilisateurs.
Choisissez l'une des méthodes d'installation suivantes. Pour plus d'informations sur les fonctionnalités et les limites d'Information Schema, consultez Présentation d'Information Schema.
- Méthode 1 : Connectez-vous au client MaxCompute et exécutez la commande suivante :
```
install package Information_Schema.systables;
```
- Méthode 2 : Connectez-vous à la console DataWorks et accédez à la page ad hoc query. Pour plus d'informations sur l'exécution de requêtes ad hoc, consultez Exécuter des instructions SQL dans une requête ad hoc (facultatif). Exécutez ensuite la commande suivante :
```
install package Information_Schema.systables;
```
Pour analyser les métadonnées de plusieurs projets MaxCompute, installez le package d'autorisations Information Schema séparément pour chaque projet. Insérez ensuite les sauvegardes de métadonnées de chaque projet dans une table unique pour une analyse centralisée.
Nous recommandons d'utiliser Information Schema au niveau du tenant. Celui-ci permet d'interroger les métadonnées et l'historique d'utilisation de tous les projets accessibles à l'utilisateur actuel.

(Facultatif) Étape 2 : Accorder des autorisations à des utilisateurs autres que le propriétaire du projet

Les vues Information Schema contiennent toutes les données utilisateur au niveau du projet. Par défaut, seul le propriétaire du projet peut y accéder. Si d'autres utilisateurs ou rôles du projet doivent consulter ces données, accordez-leur les autorisations nécessaires. Pour plus d'informations, consultez Accéder aux ressources entre projets via des packages.

Syntaxe pour accorder des autorisations :

grant <actions> on package Information_Schema.systables to user <user_name>;
grant <actions> on package Information_Schema.systables to role <role_name>;

actions : Autorisation d'opération à accorder. La valeur est Read.
user_name : Compte Alibaba Cloud ou utilisateur RAM ajouté au projet.

Exécutez la commande list users; dans le client MaxCompute pour obtenir les comptes utilisateur.
role_name : Rôle ajouté au projet.

Exécutez la commande list roles; dans le client MaxCompute pour obtenir le nom du rôle.

Exemple :

grant read on package Information_Schema.systables to user RAM$Bob@aliyun.com:user01;

(Facultatif) Étape 3 : Télécharger et sauvegarder les métadonnées

MaxCompute conserve l'historique des tâches terminées d'un projet pendant les 14 derniers jours. Si vous devez fréquemment interroger des données datant de plus de 14 jours, nous vous recommandons de configurer une sauvegarde planifiée de vos métadonnées dans une table de projet. Ignorez cette étape si vous n'avez besoin d'exécuter que des requêtes ad hoc sur l'historique des tâches des 14 derniers jours.

Connectez-vous au client MaxCompute et exécutez la commande suivante pour créer les tables de sauvegarde des métadonnées.

Commande pour créer les tables de sauvegarde des métadonnées

-- <project_name> is the name of your MaxCompute project.
-- Create the tasks_history backup table.
CREATE TABLE IF NOT EXISTS <project_name>.tasks_history
(
    task_catalog STRING
    ,task_schema STRING
    ,task_name STRING
    ,task_type STRING
    ,inst_id STRING
    ,status STRING
    ,owner_id STRING
    ,owner_name STRING
    ,result STRING
    ,start_time DATETIME
    ,end_time DATETIME
    ,input_records BIGINT
    ,output_records BIGINT
    ,input_bytes BIGINT
    ,output_bytes BIGINT
    ,input_tables STRING
    ,output_tables STRING
    ,operation_text STRING
    ,signature STRING
    ,complexity DOUBLE
    ,cost_cpu DOUBLE
    ,cost_mem DOUBLE
    ,settings STRING
    ,ds STRING
);
-- Create the tunnels_history backup table.
CREATE TABLE IF NOT EXISTS <project_name>.tunnels_history
(
tunnel_catalog  STRING
,tunnel_schema   STRING
,session_id      STRING
,operate_type    STRING
,tunnel_type     STRING
,request_id      STRING
,object_name     STRING
,partition_spec  STRING
,data_size       BIGINT
,block_id        BIGINT
,offset          BIGINT
,length          BIGINT
,owner_id        STRING 
,owner_name      STRING 
,start_time      DATETIME
,end_time        DATETIME 
,client_ip       STRING 
,user_agent      STRING 
,object_type     STRING 
,columns         STRING 
,ds  STRING
);

Dans la console DataWorks, accédez à la page DataStudio, créez un nœud ODPS SQL nommé history_backup, puis configurez une planification pour écrire périodiquement des données dans les tables de sauvegarde tasks_history et tunnels_history. Une fois la configuration terminée, cliquez sur l'icône dans le coin supérieur gauche pour enregistrer.

Les commandes d'exemple suivantes sont exécutées dans le nœud ODPS SQL :

-- <project_name> is the name of your MaxCompute project.
USE <project_name>; 
-- Back up tasks_history.
INSERT INTO TABLE <project_name>.tasks_history 
SELECT task_catalog,task_schema ,task_name,task_type STRING,inst_id,`status`,owner_id,owner_name,result
  ,start_time,end_time,input_records,output_records,input_bytes,output_bytes
  ,input_tables,output_tables,operation_text,signature,complexity,cost_cpu,cost_mem,settings,ds 
  FROM information_schema.tasks_history WHERE ds ='${datetime1}';
-- Back up tunnels_history.
INSERT INTO TABLE <project_name>.tunnels_history 
SELECT tunnel_catalog,tunnel_schema,session_id,operate_type,tunnel_type,request_id,object_name
  ,partition_spec,data_size,block_id,offset,length,owner_id,owner_name,start_time,end_time
  ,client_ip,user_agent,object_type,columns,ds 
  FROM information_schema.tunnels_history WHERE ds ='${datetime1}';

La variable ${datetime1} est un paramètre de planification dans DataWorks. Sur le côté droit du nœud ODPS SQL, cliquez sur l'onglet Properties. Dans la section Basic Properties, définissez le paramètre Parameters sur datetime1=${yyyymmdd}.

Remarque

Pour analyser les métadonnées de plusieurs projets MaxCompute, créez plusieurs nœuds ODPS SQL et écrivez les métadonnées de chaque projet dans la même table de sauvegarde.

Étape 4 : Analyser les projets et éléments à coûts élevés

Connectez-vous à la console Expenses and Costs. Utilisez les méthodes suivantes pour analyser les projets et les éléments facturables générant des coûts élevés. Pour plus de détails, consultez Consulter les détails de la facture.

Dans le volet de navigation de gauche, choisissez Billing > bill details. Définissez Statistic Item sur Instance et Statistical Period sur Day.
- Méthode 1 : Identifiez le projet (ID d'instance) ayant engendré des frais élevés. Si le coût d'un projet dépasse significativement vos prévisions, concentrez votre analyse sur ce projet.
- Méthode 2 : Identifiez l'élément facturable responsable des frais élevés. Recherchez un projet spécifique à l'aide du champ Resource Instance Name/ID et analysez ses éléments facturables les plus coûteux.
Dans le volet de navigation de gauche, sélectionnez Cost Analysis. La page Cost Analysis offre une visualisation permettant d'identifier les éléments facturables dont les coûts augmentent.

Étape 5 : Rechercher la cause racine

Analysez les projets et les éléments facturables à coûts élevés pour déterminer la raison de l'augmentation des dépenses.

Frais de calcul SQL élevés

Un coût global élevé pour les tâches SQL, y compris les tâches sur tables externes, peut provenir d'une seule tâche coûteuse, d'exécutions répétées ou d'une mauvaise configuration des propriétés de planification.

Interrogez l'ID d'instance (inst_id) de la tâche coûteuse pour afficher ses détails d'exécution.
1. Connectez-vous au client MaxCompute , utilisez la commande use pour basculer vers le projet à consommation élevée identifié à l'Étape 4, puis interrogez les détails de consommation des tâches depuis TASKS_HISTORY. Voici un exemple de commande.
```
-- Enable the MaxCompute V2.0 data type edition. For more information, see MaxCompute V2.0 data types.
SET odps.sql.decimal.odps2=true;
SELECT  
inst_id --- Instance ID
,input_bytes --- Data input size
,complexity
,CAST(input_bytes/1024/1024/1024 * complexity * 0.3 AS DECIMAL(18,5) ) cost_sum
,GET_JSON_OBJECT(settings, "$.SKYNET_ID") SKYNET_ID --- DataWorks scheduling task ID
FROM    information_schema.tasks_history 
-- If you are querying metadata older than 14 days, query the backup table created in Step 3, which is named <project_name>.tasks_history
WHERE   task_type = 'SQL' OR task_type = 'SQLRT'
AND ds = 'date_partition_to_query'
ORDER BY cost_sum DESC
LIMIT 10000
;
```
  Remarque
  - Les frais de calcul d'une tâche SQL unique se calculent comme suit : Taille des données d'entrée × Complexité SQL × Prix unitaire (0,0438 USD par Go).
  - Dans cet exemple, task_type = 'SQL' désigne une tâche SQL standard, tandis que task_type = 'SQLRT' correspond à une tâche d'accélération de requête SQL.
2. Consultez le SKYNET_ID (ID de tâche de planification DataWorks) des tâches SQL à forte consommation.
  - Si un ID existe, vérifiez les détails d'exécution du nœud dans DataWorks.
  - En l'absence d'ID, cela signifie que la tâche n'a pas été lancée par un nœud de planification DataWorks. Consultez les informations d'exécution spécifiques à partir de l'inst_id, comme illustré dans l'exemple de commande suivant.
```
SELECT operation_text 
  FROM information_schema.tasks_history 
 WHERE ds='<date_partition_of_job_execution>' AND inst_id='<instance_id>';
```

Recherchez les tâches qui se répètent fréquemment.

Connectez-vous au client MaxCompute, utilisez la commande use pour basculer vers le projet à coûts élevés identifié à l'Étape 4, puis recherchez les tâches s'exécutant de manière répétée à l'aide de TASKS_HISTORY. Voici un exemple de commande.

-- Analyze the job growth trend.
SELECT  signature
        ,ds
        ,COUNT(*) AS tasknum
FROM    information_schema.tasks_history 
--If you are querying metadata older than 14 days, query the backup table created in Step 3, which is named <project_name>.tasks_history.
where   task_type = 'SQL' OR task_type = 'SQLRT'
AND ds >= 'date_partition_to_query'
GROUP BY ds
         ,signature
ORDER BY tasknum DESC
LIMIT   10000
;
-- After identifying an abnormal signature, view the recent execution history of the corresponding SQL job.
SELECT  *
FROM    information_schema.tasks_history 
--If you are querying metadata older than 14 days, query the backup table created in Step 3, which is named <project_name>.tasks_history.
where   signature = 'abnormal_signature'
AND ds >= 'date_partition_to_query'
;

Frais de calcul Spark élevés

Les tâches Spark pouvant entraîner une consommation globale importante, interrogez l'inst_id des tâches présentant une consommation anormale pour afficher leurs informations d'exécution détaillées.

Connectez-vous au client MaxCompute , utilisez la commande use pour basculer vers le projet à consommation élevée identifié à l'Étape 4, puis interrogez les détails de consommation des tâches à l'aide de TASKS_HISTORY. Voici un exemple de commande.

-- Enable the MaxCompute V2.0 data type edition. For more information, see MaxCompute V2.0 data types.
SET odps.sql.decimal.odps2=true;
SELECT  inst_id -- Instance ID
,cost_cpu -- CPU consumption of the job (100 indicates 1 core-second. For example, if 10 cores run for 5s, cost_cpu is 10 * 100 * 5 = 5000).
,CAST(cost_cpu/100/3600 * 0.36 AS DECIMAL(18,5) ) cost_sum
FROM  information_schema.tasks_history 
-- If you are querying metadata older than 14 days, query the backup table created in Step 3, which is named <project_name>.tasks_history.
WHERE   task_type = 'CUPID' AND status='Terminated'
AND ds = 'date_partition_to_query'
ORDER BY cost_sum DESC
LIMIT 10000
;

Remarque

Les frais de calcul quotidiens d'une tâche Spark se calculent comme suit : Nombre total d'heures de calcul par jour × Prix unitaire (0,1041 USD par heure et par tâche).
task_type = 'CUPID' indique une tâche Spark.

L'exemple suivant montre la commande permettant d'afficher les informations d'exécution détaillées pour un inst_id spécifique.

SELECT operation_text 
  FROM information_schema.tasks_history 
WHERE ds='date_partition_of_job_execution' AND inst_id='<instance_id>';

Coûts élevés des tâches MapReduce

Les tâches MapReduce pouvant entraîner une consommation globale importante, interrogez l'inst_id d'une tâche présentant une consommation anormale pour afficher ses informations d'exécution détaillées.

Connectez-vous au client MaxCompute . Utilisez la commande use pour basculer vers le projet à consommation élevée identifié à l'Étape 4, puis interrogez la consommation des tâches à l'aide de TASKS_HISTORY. Voici un exemple de commande.

-- Enable the MaxCompute V2.0 data type edition. For more information, see MaxCompute V2.0 data types.
SET odps.sql.decimal.odps2=true;
SELECT  inst_id -- Instance ID
,cost_cpu -- CPU consumption of the job (100 indicates 1 core-second. For example, if 10 cores run for 5s, cost_cpu is 10 * 100 * 5 = 5000).
,CAST(cost_cpu/100/3600 * 0.36 AS DECIMAL(18,5) ) cost_sum
FROM    information_schema.tasks_history 
-- If you are querying metadata older than 14 days, query the backup table created in Step 3, which is named <project_name>.tasks_history.
WHERE   task_type = 'LOT' AND status='Terminated'
AND ds = 'date_partition_to_query'
ORDER BY cost_sum DESC
LIMIT 10000
;

L'exemple suivant montre la commande permettant d'afficher les informations d'exécution détaillées pour un inst_id spécifique.

SELECT operation_text 
  FROM information_schema.tasks_history 
WHERE ds='date_partition_of_job_execution' AND inst_id='<instance_id>';

Frais de stockage élevés

Utilisez la page des relevés d'utilisation pour interroger les frais de stockage.

Téléchargez le relevé d'utilisation. Pour plus d'informations, consultez Télécharger les relevés d'utilisation.
Importez le relevé d'utilisation. Pour plus d'informations, consultez Importer les données de relevé d'utilisation dans MaxCompute.
Analysez les données à l'aide de SQL. Pour plus d'informations, consultez Analyser les détails d'utilisation de la facture MaxCompute.

Frais de trafic sortant élevés

Si le coût global du trafic sortant sur le réseau public est élevé, suivez les étapes ci-dessous pour analyser quelle catégorie de téléchargement engendre des frais importants et à quel moment.

Connectez-vous au client MaxCompute , utilisez la commande use pour basculer vers le projet à coûts élevés identifié à l'Étape 4, puis interrogez les coûts de téléchargement à l'aide de TUNNELS_HISTORY. Voici un exemple de commande.

-- Enable the MaxCompute V2.0 data type edition. For more information, see MaxCompute V2.0 data types.
set odps.sql.decimal.odps2=true;
SELECT  ds
        ,operate_type
        ,SUM(CAST(data_size / 1024 / 1024 / 1024 * 0.8 AS DECIMAL(18,5))) download_fee
FROM    information_schema.tunnels_history
WHERE   operate_type = 'DOWNLOADLOG'
OR      operate_type = 'DOWNLOADINSTANCELOG'
AND     ds >= 'date_partition_to_query'
GROUP BY ds
         ,operate_type
ORDER BY download_fee DESC
;

Remarque

Les frais d'un téléchargement unique se calculent comme suit : Taille des données téléchargées × Prix unitaire (0,1166 USD par Go).

Vous pouvez analyser la tendance des coûts de téléchargement sur une période donnée à partir des résultats d'exécution. Utilisez également la commande tunnel show history pour afficher l'historique détaillé. Pour plus d'informations, consultez Commande Tunnel.
```
odps@ sz_mc>tunnel show history;
20xxx                success 'download inttable inttable.txt'
20xxx                success 'upload /Users/xxx.csv maxcomputefee -c "UTF-8" -h "true" -dfp "yyyy-MM-dd HH:mm:ss"'
```

Informations complémentaires

Pour consulter d'autres articles sur l'optimisation des coûts, reportez-vous à la Présentation de l'optimisation des coûts.