Tous les produits
Search
Centre de documentation

Realtime Compute for Apache Flink:Traitement par lots Flink

Dernière mise à jour :Aug 09, 2026

Ce tutoriel présente un exemple concret illustrant l'utilisation des fonctionnalités clés de Realtime Compute for Apache Flink pour le traitement par lots.

Fonctionnalités

Realtime Compute for Apache Flink propose les fonctionnalités clés suivantes pour prendre en charge le traitement par lots Flink :

  • Cartographie du développement de jobs : Dans l'onglet Drafts de la page SQL Editor, créez un brouillon par lot, puis déployez-le et exécutez-le en tant que déploiement par lot.

  • Gestion des déploiements : Sur la page Deployments, déployez directement des déploiements par lot JAR ou Python. Sélectionnez BATCH dans la liste déroulante en haut de la page pour afficher les déploiements par lot. Développez un déploiement par lot cible pour consulter sa liste d'instances de job. En général, les différentes instances de job d'un même déploiement par lot partagent la même logique de traitement, mais utilisent des paramètres distincts, tels que la date des données traitées.

  • Requête de données : Dans l'onglet Scripts de la page SQL Editor, exécutez des instructions DDL ou des requêtes courtes pour gérer et explorer rapidement vos données. Ces requêtes courtes s'exécutent au sein d'une session Flink précréée, ce qui permet une exécution à faible latence des requêtes simples grâce à la réutilisation des ressources.

  • Gestion des données : Sur la page Catalogs, créez et consultez les catalogues, ainsi que les bases de données et tables qu'ils contiennent. Vous pouvez également les afficher dans l'onglet Catalogs de la page SQL Editor pour améliorer l'efficacité du développement.

  • Orchestration des tâches (Aperçu public) : Sur la page Workflows, définissez visuellement un workflow orchestrant les dépendances entre les déploiements par lots. Déclenchez le workflow manuellement ou planifiez son exécution périodique.

  • Gérer les files d'attente de ressources : Sur la page Queue Management, partitionnez les ressources au sein d'un espace de travail afin d'éviter toute contention entre les déploiements de flux et par lots, ainsi qu'entre les déploiements de priorités différentes.

Prérequis

  • Vous avez créé un espace de travail Realtime Compute for Apache Flink. Pour plus d'informations, consultez la rubrique Activation de Realtime Compute for Apache Flink.

  • Vous avez activé Object Storage Service (OSS). Pour plus d'informations, consultez la rubrique Démarrage rapide via la console. La classe de stockage du bucket OSS doit être Standard. Pour plus d'informations, consultez la rubrique Classes de stockage.

  • Ce tutoriel utilise Apache Paimon pour stocker les données et nécessite Ververica Runtime (VVR) 8.0.5 ou une version ultérieure.

Exemple de scénario

Ce tutoriel s'appuie sur l'exemple d'une plateforme de commerce électronique, où les données sont stockées au format lakehouse Apache Paimon. Il simule une structure d'entrepôt de données multicouche : Operational Data Store (ODS), Data Warehouse Detail (DWD) et Data Warehouse Service (DWS). Vous utiliserez les capacités de traitement par lots de Flink pour traiter et nettoyer les données avant de les écrire dans des tables Paimon, afin de construire une structure de données en couches.

image

Préparatifs

  1. Créez un script.

    Dans l'onglet Scripts, vous pouvez créer un catalogue contenant des bases de données et des tables, puis insérer des exemples de données dans ces tables.

  2. Créez un catalogue Paimon.

    1. Dans l'éditeur de l'onglet Scripts, saisissez l'instruction SQL suivante.

      CREATE CATALOG `my_catalog` WITH (
        'type' = 'paimon',
        'metastore' = 'filesystem',
        'warehouse' = '<warehouse>',
        'fs.oss.endpoint' = '<fs.oss.endpoint>',
        'fs.oss.accessKeyId' = '<fs.oss.accessKeyId>',
        'fs.oss.accessKeySecret' = '<fs.oss.accessKeySecret>'
      );

      Le tableau suivant décrit les paramètres.

      Paramètre

      Description

      Obligatoire

      Remarques

      type

      Type du catalogue.

      Oui

      Définissez la valeur sur paimon.

      metastore

      Type de metastore.

      Oui

      Dans ce tutoriel, définissez la valeur sur filesystem. Pour plus d'informations sur les autres types, consultez la rubrique Gestion des catalogues Paimon.

      warehouse

      Répertoire de l'entrepôt de données dans Object Storage Service (OSS).

      Oui

      Le format est oss://<bucket>/<object>, où :

      • bucket : Nom de votre bucket OSS.

      • object : Chemin où vos données sont stockées.

      Vous pouvez trouver le bucket et le chemin de l'objet dans la console OSS.

      fs.oss.endpoint

      Endpoint d'Object Storage Service (OSS).

      Non

      Obligatoire si le bucket OSS spécifié par warehouse se trouve dans une région différente de celle de votre espace de travail Flink, ou s'il appartient à un autre compte Alibaba Cloud.

      Pour plus d'informations, consultez la rubrique Régions et endpoints.

      fs.oss.accessKeyId

      AccessKey ID d'un compte Alibaba Cloud ou d'un utilisateur RAM disposant des autorisations de lecture et d'écriture sur le bucket OSS.

      Non

      Obligatoire si le bucket OSS spécifié par warehouse se trouve dans une région différente de celle de votre espace de travail Flink, ou s'il appartient à un autre compte Alibaba Cloud. Pour savoir comment obtenir une paire de clés AccessKey, consultez la rubrique Création d'une paire de clés AccessKey.

      fs.oss.accessKeySecret

      AccessKey Secret correspondant à l'AccessKey ID.

      Non

    2. Sélectionnez le code et cliquez sur Run à gauche.

      Le message The following statement has been executed successfully! indique que le catalogue a été créé avec succès. Vous pouvez désormais afficher le catalogue sur la page Catalogs ou dans l'onglet Catalogs de la page SQL Editor.

Procédure

Étape 1 : Créer des tables ODS et insérer des données de test

Remarque

Pour simplifier ce tutoriel, nous insérons directement des données de test dans les tables ODS afin d'alimenter les tables DWD et DWS suivantes. Dans un environnement de production, vous utilisez généralement le traitement de flux Flink pour lire les données depuis des sources externes et les écrire dans le lac de données en tant que couche ODS. Pour plus d'informations, consultez la rubrique Prise en main de Paimon : Fonctionnalités de base.

  1. Dans l'éditeur de l'onglet Scripts, saisissez les instructions SQL suivantes et cliquez sur Run à gauche.

    CREATE DATABASE `my_catalog`.`order_dw`;
    
    USE `my_catalog`.`order_dw`;
    
    CREATE TABLE orders (
      order_id BIGINT,
      user_id STRING,
      shop_id BIGINT,
      product_id BIGINT,
      buy_fee BIGINT,   
      create_time TIMESTAMP,
      update_time TIMESTAMP,
      state INT
    );
    
    CREATE TABLE orders_pay (
      pay_id BIGINT,
      order_id BIGINT,
      pay_platform INT, 
      create_time TIMESTAMP
    );
    
    CREATE TABLE product_catalog (
      product_id BIGINT,
      catalog_name STRING
    );
    
    -- Insert test data
    
    INSERT INTO orders VALUES
    (100001, 'user_001', 12345, 1, 5000, TO_TIMESTAMP('2023-02-15 16:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
    (100002, 'user_002', 12346, 2, 4000, TO_TIMESTAMP('2023-02-15 15:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
    (100003, 'user_003', 12347, 3, 3000, TO_TIMESTAMP('2023-02-15 14:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
    (100004, 'user_001', 12347, 4, 2000, TO_TIMESTAMP('2023-02-15 13:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
    (100005, 'user_002', 12348, 5, 1000, TO_TIMESTAMP('2023-02-15 12:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
    (100006, 'user_001', 12348, 1, 1000, TO_TIMESTAMP('2023-02-15 11:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
    (100007, 'user_003', 12347, 4, 2000, TO_TIMESTAMP('2023-02-15 10:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1);
    
    INSERT INTO orders_pay VALUES
    (2001, 100001, 1, TO_TIMESTAMP('2023-02-15 17:40:56')),
    (2002, 100002, 1, TO_TIMESTAMP('2023-02-15 17:40:56')),
    (2003, 100003, 0, TO_TIMESTAMP('2023-02-15 17:40:56')),
    (2004, 100004, 0, TO_TIMESTAMP('2023-02-15 17:40:56')),
    (2005, 100005, 0, TO_TIMESTAMP('2023-02-15 18:40:56')),
    (2006, 100006, 0, TO_TIMESTAMP('2023-02-15 18:40:56')),
    (2007, 100007, 0, TO_TIMESTAMP('2023-02-15 18:40:56'));
    
    INSERT INTO product_catalog VALUES
      (1, 'phone_aaa'),
      (2, 'phone_bbb'),
      (3, 'phone_ccc'),
      (4, 'phone_ddd'),
      (5, 'phone_eee');
    Remarque

    Les tables créées dans ce tutoriel sont des tables Paimon en ajout seul (append-only), sans clé primaire. Elles offrent de meilleures performances d'écriture par lot que les tables à clé primaire, mais ne prennent pas en charge les opérations de mise à jour basées sur les clés.

    Le résultat de l'exécution contient plusieurs sous-onglets. Le message The following statement has been executed successfully! indique que l'instruction DDL correspondante a été exécutée avec succès.

    Les instructions DML telles que INSERT renvoient un JobId, ce qui signifie qu'un job Flink est en cours d'exécution dans la session Flink. Cliquez sur Flink UI à gauche de l'onglet Results pour afficher l'état d'exécution de ces instructions SQL. Attendez quelques secondes qu'elles se terminent.

  2. Explorez les données de la table ODS.

    Dans l'éditeur de l'onglet Scripts, saisissez les instructions SQL suivantes et cliquez sur Run à gauche.

    SELECT count(*) as order_count FROM `my_catalog`.`order_dw`.`orders`;
    SELECT count(*) as pay_count FROM `my_catalog`.`order_dw`.`orders_pay`;
    SELECT * FROM `my_catalog`.`order_dw`.`product_catalog`;

    Ces instructions SQL s'exécutent également dans la session Flink. Vous pouvez afficher les résultats sur leurs pages de résultats respectives.

    La valeur order_count pour la table orders est 7. La valeur pay_count pour la table orders_pay est 7. La table product_catalog contient 5 enregistrements avec des product_id allant de 1 à 5 et des valeurs catalog_name respectivement phone_aaa, phone_bbb, phone_ccc, phone_ddd et phone_eee.

Étape 2 : Créer des tables DWD et DWS

Dans l'éditeur de l'onglet Scripts, saisissez les instructions SQL suivantes et cliquez sur Run à gauche.

USE `my_catalog`.`order_dw`;

CREATE TABLE dwd_orders (
    order_id BIGINT,
    order_user_id STRING,
    order_shop_id BIGINT,
    order_product_id BIGINT,
    order_product_catalog_name STRING,
    order_fee BIGINT,
    order_create_time TIMESTAMP,
    order_update_time TIMESTAMP,
    order_state INT,
    pay_id BIGINT,
    pay_platform INT COMMENT 'platform 0: phone, 1: pc',
    pay_create_time TIMESTAMP
) WITH (
    'sink.parallelism' = '2'
);

CREATE TABLE dws_users (
    user_id STRING,
    ds STRING,
    total_fee BIGINT COMMENT 'Total amount paid on the current day'
) WITH (
    'sink.parallelism' = '2'
);

CREATE TABLE dws_shops (
    shop_id BIGINT,
    ds STRING,
    total_fee BIGINT COMMENT 'Total amount paid on the current day'
) WITH (
    'sink.parallelism' = '2'
);
Remarque

Les tables créées ici sont également des tables Paimon en ajout seul. Lorsqu'une table Paimon est utilisée comme sink Flink, Flink ne déduit pas automatiquement le parallélisme. Vous devez définir explicitement le parallélisme pour éviter d'éventuelles erreurs.

Étape 3 : Créer et déployer des déploiements DWD et DWS

  1. Créez et déployez le déploiement DWD.

    1. Créez le déploiement de mise à jour de la table DWD.

      Sur la page Development > ETL, créez un blank batch draft nommé dwd_orders. Nous vous recommandons de sélectionner une version du moteur portant le tag recommandé. Utilisez le dialecte Flink SQL par défaut. Copiez l'instruction SQL suivante dans l'éditeur. Étant donné que la table DWD est une table Paimon en ajout seul, utilisez une instruction INSERT OVERWRITE pour écraser l'intégralité de la table.

      INSERT OVERWRITE my_catalog.order_dw.dwd_orders
      SELECT 
          o.order_id,
          o.user_id,
          o.shop_id,
          o.product_id,
          c.catalog_name,
          o.buy_fee,
          o.create_time,
          o.update_time,
          o.state,
          p.pay_id,
          p.pay_platform,
          p.create_time
      FROM 
          my_catalog.order_dw.orders as o, 
          my_catalog.order_dw.product_catalog as c, 
          my_catalog.order_dw.orders_pay as p
      WHERE o.product_id = c.product_id AND o.order_id = p.order_id
    2. Dans le coin supérieur droit de la page, cliquez sur Deploy, puis sur OK pour déployer le déploiement dwd_orders.

  2. Créez et déployez les déploiements DWS.

    1. Créez les déploiements de mise à jour des tables DWS.

      En suivant les mêmes étapes que pour la création du déploiement de mise à jour de la table DWD, créez deux brouillons par lots nommés dws_shops et dws_users. Copiez les instructions SQL suivantes dans leurs éditeurs respectifs.

      INSERT OVERWRITE my_catalog.order_dw.dws_shops
      SELECT 
          order_shop_id,
          DATE_FORMAT(pay_create_time, 'yyyyMMdd') as ds,
          SUM(order_fee) as total_fee
      FROM my_catalog.order_dw.dwd_orders
      WHERE pay_id IS NOT NULL AND order_fee IS NOT NULL
      GROUP BY order_shop_id, DATE_FORMAT(pay_create_time, 'yyyyMMdd');
      INSERT OVERWRITE my_catalog.order_dw.dws_users
      SELECT 
          order_user_id,
          DATE_FORMAT(pay_create_time, 'yyyyMMdd') as ds,
          SUM(order_fee) as total_fee
      FROM my_catalog.order_dw.dwd_orders
      WHERE pay_id IS NOT NULL AND order_fee IS NOT NULL
      GROUP BY order_user_id, DATE_FORMAT(pay_create_time, 'yyyyMMdd');
    2. Dans le coin supérieur droit de la page, cliquez sur Deploy, puis sur OK pour déployer les déploiements dws_shops et dws_users.

Étape 4 : Démarrer et afficher les déploiements DWD et DWS

  • Démarrez le déploiement DWD et affichez ses données.

    1. Accédez à la page O&M > Deployments. Sélectionnez BATCH dans la liste déroulante. Recherchez le déploiement dwd_orders et cliquez sur Start dans la colonne Actions.

      Une instance de job dont l'état est STARTING apparaît dans la liste des instances de jobs par lots.

      Lorsque l'état de l'instance de job passe à FINISHED, le traitement des données est terminé.

    2. Explorez les résultats des données.

      Dans l'éditeur de l'onglet Scripts, saisissez l'instruction SQL suivante et cliquez sur Run à gauche pour interroger les données de la table DWD.

      SELECT * FROM `my_catalog`.`order_dw`.`dwd_orders`;

      Le résultat est illustré dans la figure suivante.

      image

  • Démarrez les déploiements DWS et affichez leurs données.

    1. Sur la page O&M > Deployments, sélectionnez BATCH dans la liste déroulante. Recherchez les déploiements dws_shops et dws_users et cliquez sur Start dans la colonne Actions pour chacun d'eux.

    2. Dans l'éditeur de l'onglet Scripts, saisissez les instructions SQL suivantes et cliquez sur Run à gauche pour interroger les données des tables DWS.

      SELECT * FROM `my_catalog`.`order_dw`.`dws_shops`;
      SELECT * FROM `my_catalog`.`order_dw`.`dws_users`;

      Les résultats sont illustrés dans les figures suivantes.

      image.png image.png

Étape 5 : Construire un pipeline par lots avec l'orchestration des tâches

À cette étape, vous orchestrez les déploiements au sein d'un workflow, ce qui permet de les déclencher ensemble et de les exécuter séquentiellement.

  1. Créez un workflow.

    1. Dans le volet de navigation de gauche, choisissez O&M > Workflows, puis cliquez sur Create Workflow.

    2. Dans le panneau qui s'affiche, saisissez wf_orders comme nom. Conservez le type de planification par défaut (Manual Scheduling), sélectionnez default-queue pour la Resource Queue, puis cliquez sur Create pour ouvrir l'éditeur de workflow.

    3. Modifiez le workflow.

      1. Cliquez sur le nœud initial, nommez-le v_dwd_orders et sélectionnez le déploiement dwd_orders pour celui-ci.

      2. Cliquez sur Add Task pour créer un nœud nommé v_dws_shops. Sélectionnez le déploiement dws_shops pour celui-ci et définissez v_dwd_orders comme nœud amont.

      3. Cliquez à nouveau sur Add Task pour créer un nœud nommé v_dws_users. Sélectionnez le déploiement dws_users pour celui-ci et définissez v_dwd_orders comme nœud amont.

      4. Dans le coin supérieur droit, cliquez sur Save puis sur OK.

  2. Déclenchez manuellement le workflow.

    Remarque

    Vous pouvez également configurer le workflow pour qu'il s'exécute selon une planification périodique. Sur la page Workflows, cliquez sur Edit Workflow à droite du workflow et modifiez le mode de planification en Periodic Scheduling. Pour plus d'informations, consultez la rubrique Orchestration des tâches (Aperçu public).

    1. Avant de déclencher le workflow, insérez de nouvelles données dans les tables ODS pour vérifier les résultats d'exécution du workflow.

      Dans l'éditeur de l'onglet Scripts, saisissez les instructions SQL suivantes et cliquez sur Run à gauche.

      USE `my_catalog`.`order_dw`;
      
      INSERT INTO orders VALUES
      (100008, 'user_001', 12346, 1, 10000, TO_TIMESTAMP('2023-02-15 17:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
      (100009, 'user_002', 12347, 2, 20000, TO_TIMESTAMP('2023-02-15 18:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1),
      (100010, 'user_003', 12348, 3, 30000, TO_TIMESTAMP('2023-02-15 19:40:56'), TO_TIMESTAMP('2023-02-15 18:42:56'), 1);
      
      INSERT INTO orders_pay VALUES
      (2008, 100008, 1, TO_TIMESTAMP('2023-02-15 20:40:56')),
      (2009, 100009, 1, TO_TIMESTAMP('2023-02-15 20:40:56')),
      (2010, 100010, 1, TO_TIMESTAMP('2023-02-15 20:40:56'));

      Cliquez sur Flink UI à gauche de l'onglet Results pour surveiller l'état du job.

    2. Sur la page O&M > Workflows, recherchez le workflow créé à l'étape précédente, cliquez sur Execute dans la colonne Actions, puis sur OK pour déclencher le workflow.

      Cliquez sur le nom du workflow pour accéder à la page Overview, où vous pouvez afficher la liste des instances de workflow.

      Cliquez sur l'ID de l'instance de workflow en cours d'exécution pour accéder à sa page de détails d'exécution et observer l'état de chaque nœud. Attendez que l'ensemble du workflow soit terminé.

  3. Affichez les résultats d'exécution du workflow.

    1. Dans l'éditeur de l'onglet Scripts, saisissez les instructions SQL suivantes et cliquez sur Run à gauche.

      SELECT * FROM `my_catalog`.`order_dw`.`dws_shops`;
      SELECT * FROM `my_catalog`.`order_dw`.`dws_users`;
    2. Consultez les résultats d'exécution du workflow.

      Vous constatez que le workflow a traité les nouvelles données de la couche ODS et les a écrites dans les tables DWS.

      image.png image.png

Documents connexes