![無依賴單機嚐鮮 Nebula Exchange 的 SST 匯入](https://www-cdn.nebula-graph.com.cn/nebula-blog/import-sst-data-without-dependence.jpg)

本文嘗試分享下以最小方式（單機、容器化 Spark、Hadoop、Nebula Graph），快速趟一下 Nebula Exchange 中 SST 寫入方式的步驟。本文適用於 v2.5 以上版本的 Nebula- Exchange。

原文連結：
- 國外訪問：[https://siwei.io/nebula-exchange-sst-2.x/](https://siwei.io/nebula-exchange-sst-2.x/)
- 國內訪問：[https://cn.siwei.io/nebula-exchange-sst-2.x/](https://cn.siwei.io/nebula-exchange-sst-2.x/)

## 什麼是 Nebula Exchange？

之前我在 [Nebula Data Import Options](https://siwei.io/sketches/nebula-data-import-options/) 之中介紹過，[Nebula Exchange](https://github.com/vesoft-inc/nebula-spark-utils/tree/master/nebula-exchange) 是一個 Nebula Graph 社群開源的 Spark Applicaiton，它專門用來支援批次或者流式地把資料匯入 Nebula Graph Database 之中。

Nebula Exchange 支援多種多樣的資料來源（從 Apache Parquet、ORC、JSON、CSV、HBase、Hive MaxCompute 到 Neo4j、MySQL、ClickHouse，再有 Kafka、Pulsar，更多的資料來源也在不斷增加之中）。

![無依賴單機嚐鮮 Nebula Exchange 的 SST 匯入](https://www-cdn.nebula-graph.com.cn/nebula-blog/nebula-exchange-overview.webp)

如上圖所示，在 Exchange 內部，從除了不同 Reader 可以讀取不同資料來源之外，在資料經過 Processor 處理之後透過 Writer寫入（sink） Nebula Graph 圖資料庫的時候，除了走正常的 ServerBaseWriter 的寫入流程之外，它還可以繞過整個寫入流程，利用 Spark 的計算能力並行生成底層 RocksDB 的 SST 檔案，從而實現超高效能的資料匯入，這個 SST 檔案匯入的場景就是本文帶大家上手熟悉的部分。

> 詳細資訊請參閱：[Nebula Graph 手冊:什麼是 Nebula Exchange](https://docs.nebula-graph.com.cn/master/nebula-exchange/about-exchange/ex-ug-what-is-exchange/)
>
> [Nebula Graph 官方部落格](https://nebula-graph.com.cn/posts/)也有更多 Nebula Exchange 的實踐文章

## 步驟概觀

- 實驗環境
- 配置 Exchange
- 生成 SST 檔案
- 寫入 SST 檔案到 Nebula Graph

## 實驗環境準備

為了最小化使用 Nebula Exchange 的 SST 功能，我們需要：

- 搭建一個 Nebula Graph 叢集，建立匯入資料的 Schema，我們選擇使用 Docker-Compose 方式、利用 [Nebula-Up](https://github.com/wey-gu/nebula-up/) 快速部署，並簡單修改其網路，以方便同樣容器化的 Exchange 程式對其訪問。
- 搭建容器化的 Spark 執行環境
- 搭建容器化的 HDFS

### 1. 搭建 Nebula Graph 叢集

藉助於 [Nebula-Up](https://github.com/wey-gu/nebula-up/) 我們可以在 Linux 環境下一鍵部署一套 Nebula Graph 叢集：

```bash
curl -fsSL nebula-up.siwei.io/install.sh | bash
```

![無依賴單機嚐鮮 Nebula Exchange 的 SST 匯入](https://www-cdn.nebula-graph.com.cn/nebula-blog/import-sst-data-01.png)

待部署成功之後，我們需要對環境做一些修改，這裡我做的修改其實就是兩點：

1. 只保留一個 metaD 服務
2. 起用 Docker 的外部網路

詳細修改的部分參考[附錄一](#附錄一)

應用 docker-compose 的修改：

```bash
cd ~/.nebula-up/nebula-docker-compose
vim docker-compose.yaml # 參考附錄一
docker network create nebula-net # 需要建立外部網路
docker-compose up -d --remove-orphans
```

之後，我們來建立要測試的圖空間，並建立圖的 Schema，為此，我們可以利用 nebula-console ，同樣，Nebula-Up 裡自帶了容器化的 nebula-console。

- 進入 Nebula-Console 所在的容器

```bash
~/.nebula-up/console.sh
/ #
```

- 在 console 容器裡發起連結到圖資料庫，其中 `192.168.x.y` 是我所在的 Linux VM 的第一個網路卡地址，請換成您的

```
/ # nebula-console -addr 192.168.x.y -port 9669 -user root -p password
[INFO] connection pool is initialized successfully

Welcome to Nebula Graph!
```

- 建立圖空間（我們起名字叫 `sst` ），以及 schema

```sql
create space sst(partition_num=5,replica_factor=1,vid_type=fixed_string(32));
:sleep 20
use sst
create tag player(name string, age int);
```

示例輸出

```sql
(root@nebula) [(none)]> create space sst(partition_num=5,replica_factor=1,vid_type=fixed_string(32));
Execution succeeded (time spent 1468/1918 us)

(root@nebula) [(none)]> :sleep 20

(root@nebula) [(none)]> use sst
Execution succeeded (time spent 1253/1566 us)

Wed, 18 Aug 2021 08:18:13 UTC

(root@nebula) [sst]> create tag player(name string, age int);
Execution succeeded (time spent 1312/1735 us)

Wed, 18 Aug 2021 08:18:23 UTC
```

### 2. 搭建容器化的 Spark 環境

利用 big data europe 做的工作，這個過程非常容易。

值得注意的是：

- 現在的 Nebula Exchange 對 Spark 的版本有要求，在現在的 2021 年 8 月，我是用了 spark-2.4.5-hadoop-2.7 的版本。
- 為了方便，我讓 Spark 執行在 Nebula Graph 相同的機器上，並且指定了執行在同一個 Docker 網路下

```bash
docker run --name spark-master --network nebula-net \
    -h spark-master -e ENABLE_INIT_DAEMON=false -d \
    bde2020/spark-master:2.4.5-hadoop2.7
```

然後，我們就可以進入到環境中了：

```bash
docker exec -it spark-master bash
```

進到 Spark 容器中之後，可以像這樣安裝 maven:

```bash
export MAVEN_VERSION=3.5.4
export MAVEN_HOME=/usr/lib/mvn
export PATH=$MAVEN_HOME/bin:$PATH

wget http://archive.apache.org/dist/maven/maven-3/$MAVEN_VERSION/binaries/apache-maven-$MAVEN_VERSION-bin.tar.gz && \
  tar -zxvf apache-maven-$MAVEN_VERSION-bin.tar.gz && \
  rm apache-maven-$MAVEN_VERSION-bin.tar.gz && \
  mv apache-maven-$MAVEN_VERSION /usr/lib/mvn
```

還可以這樣在容器裡下載 nebula-exchange 的 `jar` 包：

```bash
cd ~
wget https://repo1.maven.org/maven2/com/vesoft/nebula-exchange/2.1.0/nebula-exchange-2.1.0.jar
```

### 3. 搭建容器化的 HDFS

同樣藉助 big-data-euroupe 的工作，這非常簡單，不過我們要做一點修改，讓它的 `docker-compose.yml` 檔案裡使用 `nebula-net` 這個之前建立的 Docker 網路。

詳細修改的部分參考[附錄二](#附錄二)

```bash
git clone https://github.com/big-data-europe/docker-hadoop.git
cd docker-hadoop
vim docker-compose.yml
docker-compose up -d
```

## 配置 Exchange

這個配置主要填入的資訊就是 Nebula Graph 叢集本身和將要寫入資料的 Space Name，以及資料來源相關的配置（這裡我們用 `csv` 作為例子），最後再配置輸出（sink）為 `sst`

- Nebula Graph
  - GraphD 地址
  - MetaD 地址
  - credential
  - Space Name
- 資料來源
  - `source: csv`
    - `path`
    - `fields` etc.
  - `ink: sst`

詳細的配置參考[附錄二](#附錄二)

注意，這裡 metaD 的地址可以這樣獲取，可以看到 `0.0.0.0:49377->9559` 表示 `49377` 是外部的地址。

```bash
$ docker ps | grep meta
887740c15750   vesoft/nebula-metad:v2.0.0                               "./bin/nebula-metad …"   6 hours ago    Up 6 hours (healthy)    9560/tcp, 0.0.0.0:49377->9559/tcp, :::49377->9559/tcp, 0.0.0.0:49376->19559/tcp, :::49376->19559/tcp, 0.0.0.0:49375->19560/tcp, :::49375->19560/tcp                  nebula-docker-compose_metad0_1
```

## 生成 SST 檔案

### 1. 準備原始檔、配置檔案

```bash
docker cp exchange-sst.conf spark-master:/root/
docker cp player.csv spark-master:/root/
```

其中 `player.csv` 的例子：

```csv
1100,Tim Duncan,42
1101,Tony Parker,36
1102,LaMarcus Aldridge,33
1103,Rudy Gay,32
1104,Marco Belinelli,32
1105,Danny Green,31
1106,Kyle Anderson,25
1107,Aron Baynes,32
1108,Boris Diaw,36
1109,Tiago Splitter,34
1110,Cory Joseph,27
1111,David West,38
```

### 2. 執行 exchange 程式

進入 `spark-master` 容器，提交執行 `exchange` 應用。

```bash
docker exec -it spark-master bash
cd /root/
/spark/bin/spark-submit --master local \
    --class com.vesoft.nebula.exchange.Exchange nebula-exchange-2.1.0.jar\
    -c exchange-sst.conf
```

檢查執行結果：

`spark-submit` 輸出：

```bash
21/08/17 03:37:43 INFO TaskSetManager: Finished task 31.0 in stage 2.0 (TID 33) in 1093 ms on localhost (executor driver) (32/32)
21/08/17 03:37:43 INFO TaskSchedulerImpl: Removed TaskSet 2.0, whose tasks have all completed, from pool
21/08/17 03:37:43 INFO DAGScheduler: ResultStage 2 (foreachPartition at VerticesProcessor.scala:179) finished in 22.336 s
21/08/17 03:37:43 INFO DAGScheduler: Job 1 finished: foreachPartition at VerticesProcessor.scala:179, took 22.500639 s
21/08/17 03:37:43 INFO Exchange$: SST-Import: failure.player: 0
21/08/17 03:37:43 WARN Exchange$: Edge is not defined
21/08/17 03:37:43 INFO SparkUI: Stopped Spark web UI at http://spark-master:4040
21/08/17 03:37:43 INFO MapOutputTrackerMasterEndpoint: MapOutputTrackerMasterEndpoint stopped!
```

驗證 HDFS 上生成的 SST 檔案：

```bash
docker exec -it namenode /bin/bash

root@2db58903fb53:/# hdfs dfs -ls /sst
Found 10 items
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/1
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/10
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/2
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/3
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/4
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/5
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/6
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/7
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/8
drwxr-xr-x   - root supergroup          0 2021-08-17 03:37 /sst/9
```

## 寫入 SST 到 Nebula Graph

這裡的操作實際上都是參考文件：[SST 匯入](https://docs.nebula-graph.com.cn/master/nebula-exchange/use-exchange/ex-ug-import-from-sst/)，得來。其中就是從 console 之中執行了兩步操作：

- Download
- Ingest

其中 Download 實際上是觸發 Nebula Graph 從服務端發起 HDFS Client 的 download，獲取 HDFS 上的 SST 檔案，然後放到 storageD 能訪問的本地路徑下，這裡，需要我們在服務端部署 HDFS 的依賴。因為我們是最小實踐，我就偷懶手動做了這個 Download 的操作。

### 1. 手動下載

這裡邊手動下載我們就要知道 Nebula Graph 服務端下載的路徑，實際上是 `/data/storage/nebula/<space_id>/download/`，這裡的 Space ID 需要手動獲取一下：

這個例子裡，我們的 Space Name 是 `sst`，而 Space ID 是 `49`。

於是，下邊的操作就是手動把 SST 檔案從 HDFS 之中 `get` 下來，再複製到 storageD 之中。

```bash
docker exec -it namenode /bin/bash

$ hdfs dfs -get /sst /sst
exit
docker cp namenode:/sst .
docker exec -it nebula-docker-compose_storaged0_1 mkdir -p /data/storage/nebula/49/download/
docker exec -it nebula-docker-compose_storaged1_1 mkdir -p /data/storage/nebula/49/download/
docker exec -it nebula-docker-compose_storaged2_1 mkdir -p /data/storage/nebula/49/download/
docker cp sst nebula-docker-compose_storaged0_1:/data/storage/nebula/49/download/
docker cp sst nebula-docker-compose_storaged1_1:/data/storage/nebula/49/download/
docker cp sst nebula-docker-compose_storaged2_1:/data/storage/nebula/49/download/
```

### 2. SST 檔案匯入

- 進入 Nebula-Console 所在的容器

```bash
~/.nebula-up/console.sh
/ #
```

- 在 console 容器裡發起連結到圖資料庫，其中 `192.168.x.y` 是我所在的 Linux VM 的第一個網路卡地址，請換成您的

```
/ # nebula-console -addr 192.168.x.y -port 9669 -user root -p password
[INFO] connection pool is initialized successfully

Welcome to Nebula Graph!
```

- 執行 `INGEST` 開始讓 StorageD 讀取 SST 檔案

```bash
(root@nebula) [(none)]> use sst
(root@nebula) [sst]> INGEST;
```

我們可以用如下方法實時檢視 Nebula Graph 服務端的日誌

```bash
tail -f ~/.nebula-up/nebula-docker-compose/logs/*/*
```

成功的 INGEST 日誌：

```bash
I0817 08:03:28.611877   169 EventListner.h:96] Ingest external SST file: column family default, the external file path /data/storage/nebula/49/download/8/8-6.sst, the internal file path /data/storage/nebula/49/data/000023.sst, the properties of the table: # data blocks=1; # entries=1; # deletions=0; # merge operands=0; # range deletions=0; raw key size=48; raw average key size=48.000000; raw value size=40; raw average value size=40.000000; data block size=75; index block size (user-key? 0, delta-value? 0)=66; filter block size=0; (estimated) table size=141; filter policy name=N/A; prefix extractor name=nullptr; column family ID=N/A; column family name=N/A; comparator name=leveldb.BytewiseComparator; merge operator name=nullptr; property collectors names=[]; SST file compression algo=Snappy; SST file compression options=window_bits=-14; level=32767; strategy=0; max_dict_bytes=0; zstd_max_train_bytes=0; enabled=0; ; creation time=0; time stamp of earliest key=0; file creation time=0;
E0817 08:03:28.611912   169 StorageHttpIngestHandler.cpp:63] SSTFile ingest successfully
```

## 附錄

### 附錄一

`docker-compose.yaml`

```diff
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 48854de..cfeaedb 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -6,11 +6,13 @@ services:
       USER: root
       TZ:   "${TZ}"
     command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
+      - --meta_server_addrs=metad0:9559
       - --local_ip=metad0
       - --ws_ip=metad0
       - --port=9559
       - --ws_http_port=19559
+      - --ws_storage_http_port=19779
       - --data_path=/data/meta
       - --log_dir=/logs
       - --v=0
@@ -34,81 +36,14 @@ services:
     cap_add:
       - SYS_PTRACE

-  metad1:
-    image: vesoft/nebula-metad:v2.0.0
-    environment:
-      USER: root
-      TZ:   "${TZ}"
-    command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
-      - --local_ip=metad1
-      - --ws_ip=metad1
-      - --port=9559
-      - --ws_http_port=19559
-      - --data_path=/data/meta
-      - --log_dir=/logs
-      - --v=0
-      - --minloglevel=0
-    healthcheck:
-      test: ["CMD", "curl", "-sf", "http://metad1:19559/status"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 20s
-    ports:
-      - 9559
-      - 19559
-      - 19560
-    volumes:
-      - ./data/meta1:/data/meta
-      - ./logs/meta1:/logs
-    networks:
-      - nebula-net
-    restart: on-failure
-    cap_add:
-      - SYS_PTRACE
-
-  metad2:
-    image: vesoft/nebula-metad:v2.0.0
-    environment:
-      USER: root
-      TZ:   "${TZ}"
-    command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
-      - --local_ip=metad2
-      - --ws_ip=metad2
-      - --port=9559
-      - --ws_http_port=19559
-      - --data_path=/data/meta
-      - --log_dir=/logs
-      - --v=0
-      - --minloglevel=0
-    healthcheck:
-      test: ["CMD", "curl", "-sf", "http://metad2:19559/status"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 20s
-    ports:
-      - 9559
-      - 19559
-      - 19560
-    volumes:
-      - ./data/meta2:/data/meta
-      - ./logs/meta2:/logs
-    networks:
-      - nebula-net
-    restart: on-failure
-    cap_add:
-      - SYS_PTRACE
-
   storaged0:
     image: vesoft/nebula-storaged:v2.0.0
     environment:
       USER: root
       TZ:   "${TZ}"
     command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
+      - --meta_server_addrs=metad0:9559
       - --local_ip=storaged0
       - --ws_ip=storaged0
       - --port=9779
@@ -119,8 +54,8 @@ services:
       - --minloglevel=0
     depends_on:
       - metad0
-      - metad1
-      - metad2
     healthcheck:
       test: ["CMD", "curl", "-sf", "http://storaged0:19779/status"]
       interval: 30s
@@ -146,7 +81,7 @@ services:
       USER: root
       TZ:   "${TZ}"
     command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
+      - --meta_server_addrs=metad0:9559
       - --local_ip=storaged1
       - --ws_ip=storaged1
       - --port=9779
@@ -157,8 +92,8 @@ services:
       - --minloglevel=0
     depends_on:
       - metad0
-      - metad1
-      - metad2
     healthcheck:
       test: ["CMD", "curl", "-sf", "http://storaged1:19779/status"]
       interval: 30s
@@ -184,7 +119,7 @@ services:
       USER: root
       TZ:   "${TZ}"
     command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
+      - --meta_server_addrs=metad0:9559
       - --local_ip=storaged2
       - --ws_ip=storaged2
       - --port=9779
@@ -195,8 +130,8 @@ services:
       - --minloglevel=0
     depends_on:
       - metad0
-      - metad1
-      - metad2
     healthcheck:
       test: ["CMD", "curl", "-sf", "http://storaged2:19779/status"]
       interval: 30s
@@ -222,17 +157,19 @@ services:
       USER: root
       TZ:   "${TZ}"
     command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
+      - --meta_server_addrs=metad0:9559
       - --port=9669
       - --ws_ip=graphd
       - --ws_http_port=19669
+      - --ws_meta_http_port=19559
       - --log_dir=/logs
       - --v=0
       - --minloglevel=0
     depends_on:
       - metad0
-      - metad1
-      - metad2
     healthcheck:
       test: ["CMD", "curl", "-sf", "http://graphd:19669/status"]
       interval: 30s
@@ -257,17 +194,19 @@ services:
       USER: root
       TZ:   "${TZ}"
     command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
+      - --meta_server_addrs=metad0:9559
       - --port=9669
       - --ws_ip=graphd1
       - --ws_http_port=19669
+      - --ws_meta_http_port=19559
       - --log_dir=/logs
       - --v=0
       - --minloglevel=0
     depends_on:
       - metad0
-      - metad1
-      - metad2
     healthcheck:
       test: ["CMD", "curl", "-sf", "http://graphd1:19669/status"]
       interval: 30s
@@ -292,17 +231,21 @@ services:
       USER: root
       TZ:   "${TZ}"
     command:
-      - --meta_server_addrs=metad0:9559,metad1:9559,metad2:9559
+      - --meta_server_addrs=metad0:9559
       - --port=9669
       - --ws_ip=graphd2
       - --ws_http_port=19669
+      - --ws_meta_http_port=19559
       - --log_dir=/logs
       - --v=0
       - --minloglevel=0
+      - --storage_client_timeout_ms=60000
+      - --local_config=true
     depends_on:
       - metad0
-      - metad1
-      - metad2
     healthcheck:
       test: ["CMD", "curl", "-sf", "http://graphd2:19669/status"]
       interval: 30s
@@ -323,3 +266,4 @@ services:

networks:
   nebula-net:
+    external: true
```

### 附錄二

[https://github.com/big-data-europe/docker-hadoop](https://github.com/big-data-europe/docker-hadoop) 的 `docker-compose.yml`

```diff
diff --git a/docker-compose.yml b/docker-compose.yml
index ed40dc6..66ff1f4 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -14,6 +14,8 @@ services:
       - CLUSTER_NAME=test
     env_file:
       - ./hadoop.env
+    networks:
+      - nebula-net

datanode:
     image: bde2020/hadoop-datanode:2.0.0-hadoop3.2.1-java8
@@ -25,6 +27,8 @@ services:
       SERVICE_PRECONDITION: "namenode:9870"
     env_file:
       - ./hadoop.env
+    networks:
+      - nebula-net

resourcemanager:
     image: bde2020/hadoop-resourcemanager:2.0.0-hadoop3.2.1-java8
@@ -34,6 +38,8 @@ services:
       SERVICE_PRECONDITION: "namenode:9000 namenode:9870 datanode:9864"
     env_file:
       - ./hadoop.env
+    networks:
+      - nebula-net

nodemanager1:
     image: bde2020/hadoop-nodemanager:2.0.0-hadoop3.2.1-java8
@@ -43,6 +49,8 @@ services:
       SERVICE_PRECONDITION: "namenode:9000 namenode:9870 datanode:9864 resourcemanager:8088"
     env_file:
       - ./hadoop.env
+    networks:
+      - nebula-net

historyserver:
     image: bde2020/hadoop-historyserver:2.0.0-hadoop3.2.1-java8
@@ -54,8 +62,14 @@ services:
       - hadoop_historyserver:/hadoop/yarn/timeline
     env_file:
       - ./hadoop.env
+    networks:
+      - nebula-net

volumes:
   hadoop_namenode:
   hadoop_datanode:
   hadoop_historyserver:
+
+networks:
+  nebula-net:
+    external: true
```

### 附錄三

`nebula-exchange-sst.conf`

```toml
{
  # Spark relation config
  spark: {
    app: {
      name: Nebula Exchange 2.1
    }

master:local

driver: {
      cores: 1
      maxResultSize: 1G
    }

executor: {
        memory:1G
    }

cores:{
      max: 16
    }
  }

# Nebula Graph relation config
  nebula: {
    address:{
      graph:["192.168.8.128:9669"]
      meta:["192.168.8.128:49377"]
    }
    user: root
    pswd: nebula
    space: sst

# parameters for SST import, not required
    path:{
        local:"/tmp"
        remote:"/sst"
        hdfs.namenode: "hdfs://192.168.8.128:9000"
    }

# nebula client connection parameters
    connection {
      # socket connect & execute timeout, unit: millisecond
      timeout: 30000
    }

error: {
      # max number of failures, if the number of failures is bigger than max, then exit the application.
      max: 32
      # failed import job will be recorded in output path
      output: /tmp/errors
    }

# use google's RateLimiter to limit the requests send to NebulaGraph
    rate: {
      # the stable throughput of RateLimiter
      limit: 1024
      # Acquires a permit from RateLimiter, unit: MILLISECONDS
      # if it can't be obtained within the specified timeout, then give up the request.
      timeout: 1000
    }
  }

# Processing tags
  # There are tag config examples for different dataSources.
  tags: [

# HDFS csv
    # Import mode is sst, just change type.sink to client if you want to use client import mode.
    {
      name: player
      type: {
        source: csv
        sink: sst
      }
      path: "file:///root/player.csv"
      # if your csv file has no header, then use _c0,_c1,_c2,.. to indicate fields
      fields: [_c1, _c2]
      nebula.fields: [name, age]
      vertex: {
        field:_c0
      }
      separator: ","
      header: false
      batch: 256
      partition: 32
    }

]
}
```

本文中如有任何錯誤或疏漏，歡迎去 GitHub：[https://github.com/vesoft-inc/nebula](https://github.com/vesoft-inc/nebula) issue 區向我們提 issue 或者前往官方論壇：[https://discuss.nebula-graph.com.cn/](https://discuss.nebula-graph.com.cn/) 的 `建議反饋` 分類下提建議 ?；交流圖資料庫技術？加入 Nebula 交流群請先[填寫下你的 Nebula 名片](https://wj.qq.com/s2/8321168/8e2f/)，Nebula 小助手會拉你進群~~</space_id>

無依賴單機嚐鮮 Nebula Exchange 的 SST 匯入

相關文章