OceanBase 데이터를 Apache Doris로 쉽게 마이그레이션하는 방법을 단계별로 가르쳐주세요|실용 가이드

작성자 | SelectDB 기술팀

널리 알려진 분산 데이터베이스인 OceanBase는 많은 기업에 중요한 비즈니스 시스템에서 널리 사용되었습니다. Apache Doris 커뮤니티 에서는 많은 사용자가 OceanBase 및 Apache Doris를 기반으로 강력한 데이터 처리 및 분석 링크를 구축하기로 선택합니다. 이 기사에서는 OceanBase에서 Apache Doris로 데이터를 편리하고 효율적으로 마이그레이션/동기화하는 방법을 자세히 소개합니다.

실용 가이드

00 환경 준비

Docker를 사용하여 Oceanbase 서비스를 시작하세요. OceanBase Docker 환경을 구축하려면 Oceanbase 설명서 - Docker를 사용하여 OceanBase 데이터베이스 배포를 참조하세요.

docker run -p 2881:2881 --name oceanbase -e MINI_MODE=1 -d oceanbase/oceanbase-ce:4.0.0.0

OceanBase에서 테이블 생성 및 데이터 추가

[root@VM-10-6-centos ~]$ mysql -h127.0.0.1 -P2881 -uroot

mysql> CREATE DATABASE ob;                                                                                                                                 
Query OK, 1 row affected (0.01 sec)
                                                                                                                                                           
mysql> use ob;                                                                                                                                             
Database changed  

mysql> CREATE TABLE student (                                                                                                                              
    -> id int,                                                                                                                                     
    -> name varchar(256),                                                                                                                              
    -> age int,                                                                                                                                    
    -> primary key (id)                                                                                                                                  
    -> );                                                                                                                                                  
Query OK, 0 rows affected (0.06 sec)


mysql> insert into student values(1, 'zhangsan01', 18),                                                                                                    
    ->                           (2, 'zhangsan02', 23),                                                                                                    
    ->                           (3, 'zhangsan03', 30),                                                                                                    
    ->                           (4, 'zhangsan04', 35),                                                                                                    
    ->                           (5, 'zhangsan05', 40);                                                                                                    
Query OK, 5 rows affected (0.01 sec)                                                                                                                       
Records: 5  Duplicates: 0  Warnings: 0  

Doris에서 테이블 만들기

[root@VM-10-6-centos ~]$ mysql -h127.0.0.1 -P9030 -uroot -p

mysql> CREATE TABLE `student` (                                                                                                                            
    ->    id int,                                                                                                                                          
    ->   `name` varchar(256),
    ->   `age` int                                                                                                                              
    -> ) ENGINE=OLAP                                                                                                                                       
    -> UNIQUE KEY(`id`)                                                                                                                                    
    -> COMMENT 'OLAP'                                                                                                                                      
    -> DISTRIBUTED BY HASH(`id`) BUCKETS 1                                                                                                                 
    -> PROPERTIES (                                                                                                                                        
    -> "replication_allocation" = "tag.location.default: 1"                                                                                                
    -> );                                                                                                                                                  
Query OK, 0 rows affected (0.06 sec) 

01 DataX를 이용한 동기화

DataX 는 Alibaba Cloud DataWorks 데이터 통합의 오픈 소스 버전으로 OceanBaseReader와 DorisWriter라는 두 가지 구성 요소를 제공하여 OceanBase에서 Doris로 데이터를 쉽게 마이그레이션할 수 있습니다. 구체적인 사용 단계는 다음과 같습니다.

1. DataX 다운로드

2. DataX 구성 파일 쓰기

{                                                                                                                                                          
    "job": {                                                                                                                                               
        "setting": {                                                                                                                                       
            "speed": {                                                                                                                                     
                "channel": 1                                                                                                                               
            }                                                                                                                                              
        },                                                                                                                                                 
        "content": [                                                                                                                                       
            {                                                                                                                                              
                "reader": {                                                                                                                                
                    "name": "oceanbasev10reader",                                                                                                          
                    "parameter": {                                                                                                                         
                        "username": "root",                                                                                                                
                        "password": "123456",                                                                                                              
                        "column": ["*"],                                                                                                                   
                        "connection": [                                                                                                                    
                            {                                                                                                                              
                                "table": ["student"],                                                                                                   
                                "jdbcUrl": ["jdbc:oceanbase://127.0.0.1:2881/ob"]                                                                       
                            }                                                                                                                              
                        ]                                                                                                                                  
                    }                                                                                                                                      
                },                                                                                                                                         
                "writer": {                                                                                                                                
                    "name": "doriswriter",                                                                                                                 
                    "parameter": {                                                                                                                         
                        "loadUrl": ["127.0.0.1:28737"],                                                                                                   
                        "loadProps": {                                                                                                                     
                        },                                                                                                                                 
                        "column": ["*"],                                                                                                                   
                        "username": "root",                                                                                                                
                        "password": "",                                                                                                                    
                        "postSql": [],                                                                                                                     
                        "preSql": [],                                                                                                                      
                        "flushInterval":10000,                                                                                                             
                        "connection": [                                                                                                                    
                          {                                                                                                                                
                            "jdbcUrl": "jdbc:mysql://127.0.0.1:29737/test",                                                                               
                            "selectedDatabase": "test",                                                                                                    
                            "table": ["student"]                                                                                                     
                          }                                                                                                                                
                        ],                                                                                                                                 
                        "loadProps": {                                                                                                                     
                            "format": "json",                                                                                                              
                            "strip_outer_array": true                                                                                                      
                        }                                                                                                                                  
                    }                                                                                                                                      
                }                                                                                                                                          
            }                                                                                                                                              
        ]                                                                                                                                                  
    }                                                                                                                                                      
}        

자세한 구성은 Oceanbasev10readerDorisWriter를 참조하세요 .

3. DataX 스크립트 실행

python2 bin/datax.py oceanbase2doris.json

DataX script.png 실행

4. 완전한 데이터 동기화 Doris의 데이터는 다음과 같습니다.

mysql> select * from student;                                                                                                                              
+------+------------+------+                                                                                                                               
| id   | name       | age  |                                                                                                                               
+------+------------+------+                                                                                                                               
|    1 | zhangsan01 |   18 |                                                                                                                               
|    2 | zhangsan02 |   23 |                                                                                                                               
|    3 | zhangsan03 |   30 |                                                                                                                               
|    4 | zhangsan04 |   35 |                                                                                                                               
|    5 | zhangsan05 |   40 |                                                                                                                               
+------+------------+------+                                                                                                                               
5 rows in set (0.02 sec) 

02 카탈로그 동기화 사용

Apache Doris에서 지원하는 Catalog 기능을 이용하여 Oceanbase의 데이터 테이블을 Doris에 매핑하고, Insert를 통해 해당 데이터를 Doris에 동기화할 수 있습니다.

OceanBase 드라이버 패키지를 FE 및 BE jdbc_drivers디렉터리에 다운로드하고 다음 코드의 작업을 순서대로 실행합니다.

-- 创建catalog
CREATE CATALOG jdbc_oceanbase PROPERTIES (
    "type"="jdbc",
    "user"="root",
    "password"="123456",
    "jdbc_url" = "jdbc:oceanbase://127.0.0.1:2881/ob",
    "driver_url" = "oceanbase-client-2.4.2.jar",
    "driver_class" = "com.oceanbase.jdbc.Driver"
)

-- 在doris中查询oceanbase的表
mysql> select * from jdbc_oceanbase.ob.student;                                                                                                            
+------+------------+------+                                                                                                                               
| id   | name       | age  |                                                                                                                               
+------+------------+------+                                                                                                                               
|    1 | zhangsan01 |   18 |                                                                                                                               
|    2 | zhangsan02 |   23 |                                                                                                                               
|    3 | zhangsan03 |   30 |                                                                                                                               
|    4 | zhangsan04 |   35 |                                                                                                                               
|    5 | zhangsan05 |   40 |                                                                                                                               
+------+------------+------+                                                                                                                               
5 rows in set (0.02 sec)

mysql> CREATE TABLE internal.test.student                                                                                                                  
    -> PROPERTIES("replication_num" = "1")                                                                                                                 
    -> AS SELECT * FROM jdbc_oceanbase.ob.student;                                                                                                         
Query OK, 5 rows affected (0.07 sec)                                                                                                                       
{'label':'label_139f7d7f13ba491b_85038d67c9e3ae32', 'status':'VISIBLE', 'txnId':'12014'}


mysql> select * from internal.test.student;                                                                                                                
+------+------------+------+                                                                                                                               
| id   | name       | age  |                                                                                                                               
+------+------------+------+                                                                                                                               
|    5 | zhangsan05 |   40 |                                                                                                                               
|    1 | zhangsan01 |   18 |                                                                                                                               
|    2 | zhangsan02 |   23 |                                                                                                                               
|    4 | zhangsan04 |   35 |                                                                                                                               
|    3 | zhangsan03 |   30 |                                                                                                                               
+------+------------+------+                                                                                                                               
5 rows in set (0.03 sec) 

03 Flink CDC 동기화 사용

Flink CDC는 OceanBase CDC 커넥터를 제공하여 OceanBase에서 스냅샷 데이터와 증분 데이터를 읽을 수 있습니다. 구체적인 단계는 다음과 같습니다:

1. 환경 준비

OceanBase 및 OBLogProxy 시작

docker pull oceanbase/oceanbase-ce:4.0.0.0
docker run --name oceanbase --network=host -e MINI_MODE=1 -d oceanbase/oceanbase-ce:4.0.0.0

docker pull whhe/oblogproxy:1.1.0_4x
docker run --network=host --name oceanbase_proxy -e OB_SYS_USERNAME=root -e OB_SYS_PASSWORD=123456 -d whhe/oblogproxy:1.1.0_4x

2. 비밀번호 설정

OceanBase에서 루트 사용자에게는 기본적으로 비밀번호가 없습니다. OBLogProxy에는 비어 있지 않은 비밀번호를 가진 시스템 테넌트 사용자가 필요하므로 먼저 루트 @sys 사용자에 대한 비밀번호를 설정 해야 합니다.

-- 登陆root用户的sys租户,
mysql -h127.0.0.1 -P2881 -uroot@sys 

-- 设置密码为上面的OB_SYS_PASSWORD
MySQL [(none)]> ALTER USER root IDENTIFIED BY '123456';                                                                                                    
Query OK, 0 rows affected (0.02 sec)    

-- 进入root用户的test租户,单独设置密码test
mysql -h127.0.0.1 -P2881 -uroot@test 
MySQL [(none)]> ALTER USER root IDENTIFIED BY 'test';
Query OK, 0 rows affected (0.02 sec)

-- 创建数据库表和数据
mysql> CREATE DATABASE ob;
mysql> USE ob;
mysql> CREATE TABLE student (                                                                                                                              
    -> id int,                                                                                                                                     
    -> name varchar(256),                                                                                                                              
    -> age int,                                                                                                                                    
    -> primary key (id)                                                                                                                                  
    -> );                                                                                                                                                  
Query OK, 0 rows affected (0.06 sec)

mysql> insert into student values(1, 'zhangsan01', 18),                                                                                                    
    ->                           (2, 'zhangsan02', 23),                                                                                                    
    ->                           (3, 'zhangsan03', 30),                                                                                                    
    ->                           (4, 'zhangsan04', 35),                                                                                                    
    ->                           (5, 'zhangsan05', 40);                                                                                                    
Query OK, 5 rows affected (0.01 sec)                                                                                                                       
Records: 5  Duplicates: 0  Warnings: 0  

3. Flink 환경 구성

OceanBase CDC jar 패키지와 Doris Connector를FLINK_HOME/lib 디렉터리 배치 하고 Flink 클러스터를 다시 시작합니다.

4. Flink SQL 작업 실행

SET 'execution.checkpointing.interval' = '3s';

CREATE TABLE student (
    id INT,
    name STRING,
    age INT,
    PRIMARY KEY (id) NOT ENFORCED
  ) WITH (
    'connector' = 'oceanbase-cdc',
    'scan.startup.mode' = 'initial',
    'username' = 'root@test',
    'password' = 'test',
    'tenant-name' = 'test',
    'database-name' = 'ob',
    'table-name' = 'student',
    'hostname' = 'localhost',
    'port' = '2881',
    'rootserver-list' = '127.0.0.1:2882:2881',
    'logproxy.host' = 'localhost',
    'logproxy.port' = '2983',
    'working-mode' = 'memory'
  );
 
CREATE TABLE doris_sink (
    id INT,
    name STRING,
    age INT
)
WITH (
'connector' = 'doris',
'fenodes' = '10.16.10.6:28737',
'table.identifier' = 'test.student',
'username' = 'root',
'password' = ''
);
  
INSERT into doris_sink select * from student;

작업을 제출한 후 Doris에서 동기화된 데이터의 전체 양을 쿼리할 수 있습니다.

mysql> select * from  student;                                                                                                                             
+------+------------+------+                                                                                                                               
| id   | name       | age  |                                                                                                                               
+------+------------+------+                                                                                                                               
|    1 | zhangsan01 |   18 |                                                                                                                               
|    2 | zhangsan02 |   23 |                                                                                                                               
|    3 | zhangsan03 |   30 |                                                                                                                               
|    4 | zhangsan04 |   35 |                                                                                                                               
|    5 | zhangsan05 |   40 |                                                                                                                               
+------+------------+------+                                                                                                                               
5 rows in set (0.01 sec)  

다음으로 OceanBase에서 새 데이터를 시뮬레이션합니다.

MySQL [ob]> insert into student values(6, 'zhangsan06', 48)                                                                                                
    -> ;                                                                                                                                                   
Query OK, 1 row affected (0.13 sec)  

작업을 제출한 후 Doris에서 동기화된 새 데이터를 쿼리할 수 있습니다.

mysql> select * from  student;                                                                                                                             
+------+------------+------+                                                                                                                               
| id   | name       | age  |                                                                                                                               
+------+------------+------+                                                                                                                               
|    1 | zhangsan01 |   18 |                                                                                                                               
|    2 | zhangsan02 |   23 |                                                                                                                               
|    3 | zhangsan03 |   30 |                                                                                                                               
|    4 | zhangsan04 |   35 |                                                                                                                               
|    5 | zhangsan05 |   40 |                                                                                                                               
|    6 | zhangsan06 |   48 |                                                                                                                               
+------+------------+------+                                                                                                                               
6 rows in set (0.02 sec) 

참고: OceanBase 3.x 및 4.x 버전이 지원됩니다. OBLogProxy와 OceanBase 간의 버전 일치 관계에 주의해야 합니다. 자세한 내용은 GitHub 릴리스 를 참조하세요.

04 Outfile을 사용하여 내보내기

또한 Oceanbase의 Outfile 기능을 사용 하여 데이터를 로컬 또는 OSS로 내보내고 Doris의 스트림 로드/S3 로드 기능을 기반으로 Doris로 데이터를 가져올 수 있습니다. 다음은 로컬 파일의 예입니다.

MySQL [ob]> select * from student;                                                                                                                         
+----+------------+------+                                                                                                                                 
| id | name       | age  |                                                                                                                                 
+----+------------+------+                                                                                                                                 
|  1 | zhangsan01 |   18 |                                                                                                                                 
|  2 | zhangsan02 |   23 |                                                                                                                                 
|  3 | zhangsan03 |   30 |                                                                                                                                 
|  4 | zhangsan04 |   35 |                                                                                                                                 
|  5 | zhangsan05 |   40 |                                                                                                                                 
|  6 | zhangsan06 |   48 |                                                                                                                                 
+----+------------+------+                                                                                                                                 
6 rows in set (0.00 sec)   

MySQL [ob]> SELECT id,name,age INTO OUTFILE '/home/student.csv' 
            FIELDS TERMINATED BY ','
            LINES TERMINATED BY '\n' FROM student;
Query OK, 3 rows affected (0.01 sec)


#cat student.csv
1,zhangsan01,18
2,zhangsan02,23
3,zhangsan03,30
4,zhangsan04,35
5,zhangsan05,40
6,zhangsan06,48

Doris에서 스트림 로드를 실행하고 로컬 파일을 Doris로 가져옵니다.

curl  --location-trusted -u root:  -H "column_separator:," -T student.csv http://127.0.0.1:28737/api/test/student/_stream_load

가져오기가 완료되면 가져온 데이터를 Doris에서 쿼리할 수 있습니다.

mysql> select * from student;                                                                                                                              
+------+------------+------+                                                                                                                               
| id   | name       | age  |                                                                                                                               
+------+------------+------+                                                                                                                               
|    1 | zhangsan01 |   18 |                                                                                                                               
|    2 | zhangsan02 |   23 |                                                                                                                               
|    3 | zhangsan03 |   30 |                                                                                                                               
|    4 | zhangsan04 |   35 |                                                                                                                               
|    5 | zhangsan05 |   40 |                                                                                                                               
|    6 | zhangsan06 |   48 |                                                                                                                               
+------+------------+------+                                                                                                                               
6 rows in set (0.05 sec)    

데이터 유형 매핑

OceanBase 데이터베이스는 동일한 시스템에서 MySQL과 Oracle 모드를 모두 지원할 수 있으므로 Apache Doris 유형 매핑도 MySQL 및 Oracle과 동일합니다. 이는 OceanBase가 Apache Doris와 매핑 관계를 설정할 때 아래 표에 따라 테이블과 열을 정의하여 원활한 데이터 마이그레이션/동기화 작업을 생성할 수 있음을 의미합니다.

01 MySQL 스키마 유형 매핑

MySQL 스키마 유형 매핑.png

자세한 내용은 JDBC 카탈로그 - MySQL 설명서를 참조하세요.

02 Oracle 스키마 유형 매핑

Oracle 스키마 유형 매핑.png

자세한 내용은 JDBC 카탈로그 - Oracle 설명서를 참조하십시오.

결론

이 기사에서는 다양한 시나리오의 동기화 요구 사항을 충족할 수 있는 OceanBase 데이터를 Doris와 동기화하는 다양한 방법을 소개합니다. 오프라인 데이터를 동기화해야 하는 경우 DataX/Catalog/Outfile 방법을 선택할 수 있으며, 실시간 데이터를 동기화해야 하는 경우 Flink CDC 방법을 직접 선택할 수 있습니다. 또한 Flink CDC를 통해 전체 데이터와 증분 데이터 동기화를 모두 완료할 수 있습니다.

Linus는 커널 개발자가 탭을 공백으로 대체하는 것을 막기 위해 스스로 노력했습니다. 그의 아버지는 코드를 작성할 수 있는 몇 안되는 리더 중 한 명이고, 둘째 아들은 오픈 소스 기술 부서의 책임자이며, 막내 아들은 오픈 소스 코어입니다. 기고자 Robin Li: 자연 언어 새로운 범용 프로그래밍 언어가 될 것입니다. 오픈 소스 모델은 Huawei에 비해 점점 더 뒤쳐질 것입니다 . 일반적으로 사용되는 5,000개의 모바일 애플리케이션을 Hongmeng으로 완전히 마이그레이션하는 데 1년이 걸릴 것입니다. 타사 취약점. 기능, 안정성 및 개발자의 경험이 크게 개선된 Quill 2.0 출시되었습니다. Ma Huateng과 Zhou Hongyi는 "원한을 제거하기 위해" 공식적으로 출시되었습니다. Laoxiangji의 소스는 코드가 아닙니다. Google이 대규모 구조 조정을 발표한 이유는 매우 훈훈합니다.
{{o.이름}}
{{이름}}

추천

출처my.oschina.net/selectdb/blog/11053991