Tous les produits
Search

Ce produit

    MaxCompute:Tâches périodiques (aperçu sur invitation)

    Centre de documentation

    MaxCompute:Tâches périodiques (aperçu sur invitation)

    Dernière mise à jour :Aug 10, 2026
    Cette fonctionnalité est en aperçu sur invitation. Pour savoir comment accéder aux fonctionnalités en aperçu sur invitation, consultez les Instructions .

    Sans planificateur intégré, les pipelines de données récurrents nécessitent des outils d'orchestration externes, ce qui augmente les coûts et la charge opérationnelle. Les tâches périodiques MaxCompute vous permettent de définir et d'exécuter des pipelines de données SQL selon une planification récurrente, toutes les 10 à 59 minutes, en utilisant uniquement des instructions SQL. Aucun planificateur externe n'est nécessaire.

    Aperçu du flux de travail

    Flux de travail typique de bout en bout :

    1. Activez les tâches périodiques pour la session en définissant odps.sql.periodic.task.enabled=true.

    2. Créez les objets requis (Delta Tables et streams) si votre tâche lit depuis un stream.

    3. Créez la tâche avec CREATE TASK en spécifiant la planification, la condition WHEN (facultative) et la stratégie de nouvelle tentative.

    4. Vérifiez que le statut de la tâche est ACTIVE à l'aide de DESC TASK.

    5. Surveillez l'historique d'exécution avec SHOW HISTORY FOR TASK.

    6. Modifiez, suspendez ou supprimez la tâche selon vos besoins avec ALTER TASK ou DROP TASK.

    Fonctionnement

    Chaque tâche périodique exécute une instruction SQL à intervalle fixe. Avant chaque exécution, la tâche évalue une condition WHEN facultative. Si la condition renvoie FALSE, l'exécution est ignorée : la tâche n'exécute pas le corps SQL, mais reste planifiée et réévalue la condition lors du prochain intervalle.

    Ce modèle est utile pour créer des pipelines de données qui ne traitent les informations que lorsque de nouvelles données sont disponibles. Par exemple, utilisez WHEN stream_has_data('my_stream') pour ignorer les exécutions lorsque le stream est vide, évitant ainsi des calculs inutiles. Par défaut, la tâche génère automatiquement des données CDC incrémentielles en arrière-plan.

    Comportements clés :

    • WHEN agit comme une porte, non comme un déclencheur. La tâche se lance toujours selon sa planification fixe ; WHEN contrôle l'exécution du corps SQL.

    • Une tâche périodique démarre automatiquement après sa création. Son statut initial est ACTIVE.

    • Pour suspendre ou reprendre une tâche, utilisez ALTER TASK ... suspend ou ALTER TASK ... resume.

    Prérequis

    Avant de commencer, assurez-vous de disposer des éléments suivants :

    • Un projet MaxCompute avec la fonctionnalité de tâche périodique activée (aperçu sur invitation)

    • Les autorisations nécessaires pour créer et gérer des tâches dans le projet

    • (Pour l'accès à la console) La politique AliyunMaxComputeReadOnlyAccess attribuée à votre utilisateur RAM. Pour plus de détails, consultez les autorisations RAM

    Notes d'utilisation

    Définissez le paramètre suivant au niveau de la session avant de créer ou de supprimer des tâches périodiques. Sans ce paramètre, CREATE TASK et DROP TASK renvoient une erreur.

    SET odps.sql.periodic.task.enabled=true;

    Créer une tâche périodique

    Syntaxe

    CREATE TASK [IF NOT EXISTS] <task_name>
    SCHEDULE = "<num> [minute|minutes] | [second|seconds]"
    [TASKPROPERTIES("schedule_strategy"="<retries>",
                   "odps.namespace.schema"="true" ...)]
    [COMMENT task_comment]
    [WHEN <bool_expr>]
    AS <taskBody>;

    Paramètres

    |
    **Paramètre**
    |
    **Obligatoire**
    |
    **Description**
    | | --- | --- | --- | |
    `IF NOT EXISTS`
    |
    Non
    |
    Si une tâche portant le même nom existe déjà, l'opération réussit et la tâche existante n'est pas modifiée. Sans cette option, la création d'une tâche avec un nom dupliqué renvoie une erreur.
    | |
    `task_name`
    |
    Oui
    |
    Nom de la tâche périodique.
    | |
    `SCHEDULE`
    |
    Oui
    |
    Intervalle d'exécution. Unités prises en charge : `second`/`seconds` (valeur : 10–59) et `minute`/`minutes`. Pour les intervalles de 60 secondes ou plus, utilisez les minutes. Plage de valeurs : 10 à 3 540 secondes.
    | |
    `TASKPROPERTIES`
    |
    Non
    |
    Paramètres d'exécution pour le corps SQL. Paramètres courants : `schedule_strategy` (nombre de nouvelles tentatives en cas d'échec), `odps.stage.reducer.num` (nombre d'instances Reduce Task), `odps.sql.reducer.memory` (mémoire par instance Reduce Task, en Mo).
    | |
    `COMMENT`
    |
    Non
    |
    Commentaire pour la tâche. Longueur maximale : 1 024 octets.
    | |
    `WHEN`
    |
    Non
    |
    Expression booléenne évaluée avant chaque exécution planifiée. Le corps de la tâche s'exécute uniquement lorsque cette expression renvoie TRUE. La valeur par défaut est TRUE si omise. Seules les fonctions scalaires sont prises en charge : les fonctions de fenêtrage, les fonctions d'agrégation et les sous-requêtes imbriquées ne sont pas prises en charge. Pour la liste complète des fonctions prises en charge, consultez la [liste blanche des fonctions](#0f912056318vw).
    | |
    `AS `
    |
    Oui
    |
    Instruction SQL à exécuter. Prend en charge le langage de manipulation de données (DML) et le langage de requête de données (DQL). Le langage de définition de données (DDL) et les instructions SQL exécutées depuis l'éditeur de code ne sont pas pris en charge.
    |















































    Exemple : créer une tâche avec une condition de stream

    Cet exemple crée une tâche qui lit les nouvelles lignes d'un stream Delta Table et les insère dans une table de destination toutes les 5 minutes. Le corps de la tâche s'exécute uniquement lorsque le stream contient de nouvelles données.

    Étape 1 : Créez la table Delta de destination.

    CREATE TABLE acid2_table_dest (
  pk BIGINT NOT NULL PRIMARY KEY,
  val BIGINT
) tblproperties ("transactional"="true");

    Étape 2 : Créez la table Delta source et un stream associé.

    -- Source Delta Table
CREATE TABLE delta_table_src (
  pk BIGINT NOT NULL PRIMARY KEY,
  val BIGINT
) tblproperties ("transactional"="true");

-- Stream on the source table (append mode, starting from version 1)
CREATE STREAM delta_table_stream
ON TABLE delta_table_src version as of 1
strmproperties('read_mode'='append')
comment 'stream demo';

    Étape 3 : Créez la tâche périodique.

    SET odps.sql.periodic.task.enabled=true;

CREATE TASK IF NOT EXISTS periodic_task1
  SCHEDULE = '5 minutes'
  TASKPROPERTIES('schedule_strategy'='3')
  COMMENT 'task_comment'
  WHEN stream_has_data('delta_table_stream')
  AS INSERT INTO acid2_table_dest SELECT pk, val FROM delta_table_stream;
    stream_has_data('delta_table_stream') équivaut à exécuter SELECT stream_has_data('delta_table_stream'); dans MaxCompute. Avec schedule_strategy=3 , la tâche effectue jusqu'à 3 nouvelles tentatives si une exécution planifiée échoue.

    Étape 4 : Insérez des données de test et vérifiez le résultat.

    -- Insert test data into the source table
INSERT INTO delta_table_src VALUES (1, 1), (2, 2);

-- After the next scheduled run, query the destination table
SELECT * FROM acid2_table_dest;

    Sortie attendue :

    +------------+------------+
| pk         | val        |
+------------+------------+
| 1          | 1          |
| 2          | 2          |
+------------+------------+

    Modifier une tâche périodique

    Utilisez ALTER TASK pour mettre à jour la planification, les propriétés d'exécution, le commentaire ou la condition WHEN d'une tâche existante, ou pour la suspendre et la reprendre.

    Une tâche périodique démarre automatiquement après sa création avec le statut ACTIVE. Pour la mettre en pause, utilisez ALTER TASK ... suspend . Pour la remettre au statut ACTIVE, utilisez ALTER TASK ... resume . Vérifiez le statut actuel avec DESC TASK .

    Syntaxe

    Modifier la planification, les propriétés ou le commentaire :

    ALTER TASK [IF EXISTS] <task_name>
    SET SCHEDULE = "<num> [minute|minutes] | [second|seconds]"
    [TASKPROPERTIES("schedule_strategy"="<retries>", ...)]
    [COMMENT task_comment];

    Suspendre ou reprendre :

    ALTER TASK [IF EXISTS] <task_name> resume | suspend;

    Modifier la condition WHEN :

    ALTER TASK [IF EXISTS] <task_name> MODIFY WHEN <boolean_expr>;

    Paramètres

    |
    **Paramètre**
    |
    **Obligatoire**
    |
    **Description**
    | | --- | --- | --- | |
    `IF EXISTS`
    |
    Non
    |
    Si la tâche n'existe pas, l'opération est ignorée et un message de réussite est renvoyé. Sans cette option, la modification d'une tâche inexistante renvoie une erreur.
    | |
    `boolean_expr`
    |
    Oui (pour `MODIFY WHEN`)
    |
    Nouvelle expression booléenne pour la condition de déclenchement de la tâche.
    |

    Pour SCHEDULE et TASKPROPERTIES, consultez les Paramètres dans la section Create a periodic task.



















    Scénarios courants

    Suspendre une tâche, mettre à jour sa planification et son nombre de nouvelles tentatives, puis la reprendre :

    ALTER TASK periodic_task1 suspend;
ALTER TASK IF EXISTS periodic_task1 SET SCHEDULE = '6 minute';
ALTER TASK IF EXISTS periodic_task1 SET TASKPROPERTIES('schedule_strategy'='5');
ALTER TASK periodic_task1 resume;

    Mettre à jour la condition WHEN :

    ALTER TASK IF EXISTS periodic_task1 MODIFY WHEN 1=1;

    Ajouter ou mettre à jour un commentaire :

    ALTER TASK IF EXISTS periodic_task1 SET COMMENT 'comment2';

    Supprimer une tâche périodique

    Syntaxe

    SET odps.sql.periodic.task.enabled=true;

DROP TASK [IF EXISTS] <task_name>;

    Paramètres

    |
    **Paramètre**
    |
    **Obligatoire**
    |
    **Description**
    | | --- | --- | --- | |
    `IF EXISTS`
    |
    Non
    |
    Si la tâche n'existe pas, l'opération est ignorée et un message de réussite est renvoyé. Sans cette option, la suppression d'une tâche inexistante renvoie une erreur.
    | |
    `task_name`
    |
    Oui
    |
    Nom de la tâche périodique à supprimer.
    |

















    Exemple

    SET odps.sql.periodic.task.enabled=true;

DROP TASK periodic_task1;

    Afficher les informations sur la tâche

    Utiliser des commandes

    Afficher les informations de base :

    DESC TASK <task_name>;

    Afficher les informations étendues :

    DESC EXTENDED TASK <task_name>;

    Exemple de sortie pour DESC TASK periodic_task1 :

    +------------------------------------------------------------------------------------+
| Owner:                    ALIYUN$odps****@aliyun.com                               |
| Project:                  sql_odps2                                                |
| Schema:                                                                            |
| Task:                     periodic_task1                                           |
+------------------------------------------------------------------------------------+
| CreateTime:               2024-08-23 11:05:46                                      |
| LastModifiedTime:         2024-08-23 11:05:46                                      |
+------------------------------------------------------------------------------------+
| ScheduleText:             '5 minute'                                               |
| TaskType:                 SQL                                                      |
| Query:                    insert into acid2_table_dest select pk, val from acid_stream; |
| Condition:                stream_has_data('acid_stream')                           |
| Status:                   ACTIVE                                                   |
| Comment:                                                                           |
+------------------------------------------------------------------------------------+

    Utiliser la console

    1. Connectez-vous à la console MaxCompute et sélectionnez une région.Console MaxCompute

    2. Dans le volet de navigation de gauche, choisissez Manage Configurations > Projects.

    3. Sur la page Projects, recherchez le projet cible et cliquez sur Manage dans la colonne Actions.

    4. Sur la page Project Settings, sélectionnez l'onglet Periodic Task pour afficher toutes les tâches périodiques du projet.

    5. Cliquez sur Details dans la colonne Actions de la tâche cible.

    6. Dans la boîte de dialogue View Periodic Task, examinez le Task Name, le Task Status, le Scheduling Cycle et le Execution Log.

    7. Cliquez sur un Instance ID pour ouvrir la page Job Insights et afficher les journaux d'exécution détaillés.

    Lister toutes les tâches périodiques

    SHOW TASKS;

    Exemple de sortie :

    +--------------------------------------------------------------------------------------------------------------------------------+
| Project:                  openmronlot_daily_arm_src3_xr                                                                        |
| Schema:                                                                                                                        |
+--------------------------------------------------------------------------------------------------------------------------------+
| Tasks:                                                                                                                         |
+--------------------------------------------------------------------------------------------------------------------------------+
| Name                      | Owner                             | CreateTime             | LastModifiedTime       | Status       |
+--------------------------------------------------------------------------------------------------------------------------------+
| periodic_task1            | ALIYUN$odpst****@aliyun.com       | 2024-07-26 16:19:06    | 2024-07-26 16:19:06    | ACTIVE       |
| periodic_task2            | ALIYUN$odpst****@aliyun.com       | 2024-07-26 16:19:28    | 2024-07-26 16:19:28    | ACTIVE       |
| periodic_task3            | ALIYUN$odpst****@aliyun.com       | 2024-07-26 16:20:45    | 2024-07-26 16:20:45    | ACTIVE       |
| periodic_task6            | ALIYUN$odpst****@aliyun.com       | 2024-08-15 11:09:55    | 2024-08-15 11:09:55    | ACTIVE       |
| periodic_task_alter1      | ALIYUN$odpst****@aliyun.com       | 2024-07-26 16:17:40    | 2024-07-26 16:17:40    | ACTIVE       |
+--------------------------------------------------------------------------------------------------------------------------------+
    SHOW TASKS liste toutes les tâches du projet actuel. Pour filtrer par nom de tâche, utilisez l'onglet Periodic Task de la console MaxCompute.

    Afficher l'historique d'exécution

    SHOW HISTORY FOR TASK renvoie l'InstanceId, le CreateTime, l'EndTime et le Status de chaque exécution planifiée.

    Pour afficher les journaux détaillés d'une exécution spécifique, utilisez WAIT pour obtenir l'URL Logview, puis ouvrez-la dans un navigateur :

    WAIT <InstanceId>;
-- Example: WAIT 2024082309000177gq71ut9****;

    Syntaxe

    SHOW HISTORY FOR TASK <task_name> [[LIMIT <limit_value>] OFFSET <offset_value>];

    Paramètres

    |
    **Paramètre**
    |
    **Obligatoire**
    |
    **Description**
    | | --- | --- | --- | |
    `task_name`
    |
    Oui
    |
    Nom de la tâche périodique.
    | |
    `limit_value`
    |
    Non
    |
    Nombre d'enregistrements à renvoyer. Doit être supérieur à 0. Si omis, renvoie autant d'enregistrements que possible. Exemple : `LIMIT 50` renvoie 50 enregistrements.
    | |
    `offset_value`
    |
    Non
    |
    Nombre d'enregistrements à ignorer à partir du plus récent. `OFFSET 0` commence par l'enregistrement le plus récent.
    |























    Exemples

    Afficher tout l'historique de periodic_task1 :

    SHOW HISTORY FOR TASK periodic_task1;

    Sortie :

    +---------------------------------------------------------------------------------------------------+
| Project:                  muze_demo                                                               |
| Schema:                                                                                           |
| Task:                     periodic_task1                                                          |
+---------------------------------------------------------------------------------------------------+
| History:                                                                                          |
+---------------------------------------------------------------------------------------------------+
| InstanceId                       | CreateTime             | EndTime                | Status       |
+---------------------------------------------------------------------------------------------------+
| 202506130710002599mhgq4****      | 2025-06-13 15:10:00    | 2025-06-13 15:10:00    | Terminated   |
| 2025061307050039g47jzzs1****     | 2025-06-13 15:05:00    | 2025-06-13 15:05:00    | Terminated   |
| 2025061307000030o9vh1l1****      | 2025-06-13 15:00:00    | 2025-06-13 15:00:00    | Terminated   |
| 2025061306550032l84ahcr4****     | 2025-06-13 14:55:00    | 2025-06-13 14:55:00    | Terminated   |
| 2025061306500043cthoc62****      | 2025-06-13 14:50:00    | 2025-06-13 14:50:00    | Terminated   |
| 20250613064500324fkhaz1****      | 2025-06-13 14:45:00    | 2025-06-13 14:45:00    | Terminated   |
| 2025061306400048194cx8g****      | 2025-06-13 14:40:00    | 2025-06-13 14:40:00    | Terminated   |
| 20250613063500351g99kf2****      | 2025-06-13 14:35:00    | 2025-06-13 14:35:00    | Terminated   |
| 2025061306300084qkbtk9****       | 2025-06-13 14:30:00    | 2025-06-13 14:30:00    | Terminated   |
| 20250613062501711nswoio****      | 2025-06-13 14:25:01    | 2025-06-13 14:25:01    | Terminated   |
| 2025061306200129vln5ncr4****     | 2025-06-13 14:20:01    | 2025-06-13 14:20:01    | Terminated   |
| 2025061306150119yhlkmbo****      | 2025-06-13 14:15:00    | 2025-06-13 14:15:01    | Terminated   |
| 2025061306100139uemvy7r6****     | 2025-06-13 14:10:00    | 2025-06-13 14:10:01    | Terminated   |
+---------------------------------------------------------------------------------------------------+

    Afficher les 6 exécutions les plus récentes :

    SHOW HISTORY FOR TASK periodic_task1 LIMIT 6 OFFSET 0;

    Ignorer les 5 exécutions les plus récentes et afficher le reste :

    SHOW HISTORY FOR TASK periodic_task1 OFFSET 5;

    Liste blanche des fonctions

    La condition WHEN prend en charge uniquement les fonctions scalaires. Les fonctions de fenêtrage, les fonctions d'agrégation et les sous-requêtes imbriquées ne sont pas prises en charge. Les fonctions suivantes sont disponibles. Pour plus de détails sur chaque fonction, consultez les Fonctions intégrées (ordre alphabétique).

    Date et heure

    DATEADD, DATEDIFF, DATEPART, DATETRUNC, DATE_FORMAT, FROM_UNIXTIME, GETDATE, ISDATE, LASTDAY, LAST_DAY, UNIX_TIMESTAMP, WEEKDAY, WEEKOFYEAR, TO_DATE, TO_CHAR, YEAR, QUARTER, MONTH, DAY, DAYOFMONTH, HOUR, MINUTE, SECOND, CURRENT_TIMESTAMP, FROM_UTC_TIMESTAMP, ADD_MONTHS, NEXT_DAY, MONTHS_BETWEEN, TO_MILLIS

    Mathématiques

    ABS, ROUND

    Chaîne

    CONCAT, CONCAT_WS, GET_JSON_OBJECT, INSTR, LENGTH, LENGTHB, REGEXP_EXTRACT, REGEXP_REPLACE, REGEXP_INSTR, REGEXP_SUBSTR, REGEXP_COUNT, REVERSE, SUBSTR, TOLOWER, TOUPPER, TRIM, LTRIM, RTRIM, REPLACE, SIZE, FIELD

    Conditionnel et JSON

    COALESCE, IF, SPLIT, SPLIT_PART, FROM_JSON

    Table et partition

    MAX_PT, TABLE_EXISTS, PARTITION_EXISTS, GET_LATEST_VERSION, GET_LATEST_TIMESTAMP, STREAM_HAS_DATA, TABLE_NEED_CDC_BUILD