This is an automated email from the ASF dual-hosted git repository.
jin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-hugegraph-doc.git
The following commit(s) were added to refs/heads/master by this push:
new 2c19f988 doc: adjust docker related desc in readme (#306)
2c19f988 is described below
commit 2c19f9881ed82f386264a9f43f4d912d236a1788
Author: Dandelion <[email protected]>
AuthorDate: Sun Dec 17 23:15:06 2023 +0800
doc: adjust docker related desc in readme (#306)
---------
Co-authored-by: imbajin <[email protected]>
---
content/cn/docs/quickstart/hugegraph-hubble.md | 69 +++---
content/cn/docs/quickstart/hugegraph-loader.md | 81 ++++---
content/cn/docs/quickstart/hugegraph-server.md | 297 ++++++++++++------------
content/en/docs/quickstart/hugegraph-hubble.md | 70 +++---
content/en/docs/quickstart/hugegraph-loader.md | 79 ++++---
content/en/docs/quickstart/hugegraph-server.md | 302 +++++++++++++------------
6 files changed, 470 insertions(+), 428 deletions(-)
diff --git a/content/cn/docs/quickstart/hugegraph-hubble.md
b/content/cn/docs/quickstart/hugegraph-hubble.md
index 43522ddd..be518913 100644
--- a/content/cn/docs/quickstart/hugegraph-hubble.md
+++ b/content/cn/docs/quickstart/hugegraph-hubble.md
@@ -35,39 +35,12 @@ HugeGraph 是一款面向分析型，支持批量操作的图数据库系统，
### 2 部署
有三种方式可以部署`hugegraph-hubble`
-- 使用 docker (推荐)
+
- 下载 toolchain 二进制包
- 源码编译
+- 使用 docker (便于**测试**)
-#### 2.1 使用 Docker (推荐)
-
-> **特别注意**: docker 模式下，若 hubble 和 server 在同一宿主机，hubble 页面中设置 graph 的
`hostname` **不能设置**为 `localhost/127.0.0.1`，因这会指向 hubble **容器内部**而非宿主机，导致无法连接到
server.
->
-> 若 hubble 和 server 在同一 docker 网络下，**推荐**直接使用`container_name` (如下例的 `graph`)
作为主机名。或者也可以使用 **宿主机 IP** 作为主机名，此时端口号为宿主机给 server 配置的端口
-
-我们可以使用 `docker run -itd --name=hubble -p 8088:8088 hugegraph/hubble` 快速启动
[hubble](https://hub.docker.com/r/hugegraph/hubble).
-
-或者使用 docker-compose 启动 hubble，另外如果 hubble 和 graph 在同一个 docker 网络下，可以使用 graph 的
contain_name 进行访问，而不需要宿主机的 ip
-
-使用`docker-compose up -d`，`docker-compose.yml`如下：
-
-```yaml
-version: '3'
-services:
- server:
- image: hugegraph/hugegraph
- container_name: graph
- ports:
- - 8080:8080
-
- hubble:
- image: hugegraph/hubble
- container_name: hubble
- ports:
- - 8088:8088
-```
-
-#### 2.2 下载 toolchain 二进制包
+#### 2.1 下载 toolchain 二进制包
`hubble`项目在`toolchain`项目中，首先下载`toolchain`的 tar 包
@@ -96,7 +69,7 @@ starting HugeGraphHubble ..............timed out with http
status 502
然后使用浏览器访问 `ip:8088` 可看到`hubble`页面，通过`bin/stop-hubble.sh`则可以停止服务
-#### 2.3 源码编译
+#### 2.2 源码编译
**注意：** 编译 hubble 需要用户本地环境有安装 `Nodejs V16.x` 与 `yarn` 环境
@@ -142,6 +115,40 @@ cd apache-hugegraph-hubble-incubating*
bin/start-hubble.sh -d
```
+#### 2.3 使用 Docker (便于**测试**)
+
+> **特别注意**: docker 模式下，若 hubble 和 server 在同一宿主机，hubble 页面中设置 graph 的
`hostname` **不能设置**为 `localhost/127.0.0.1`，因这会指向 hubble **容器内部**而非宿主机，导致无法连接到
server.
+>
+> 若 hubble 和 server 在同一 docker 网络下，**推荐**直接使用`container_name` (如下例的 `graph`)
作为主机名。或者也可以使用 **宿主机 IP** 作为主机名，此时端口号为宿主机给 server 配置的端口
+
+我们可以使用 `docker run -itd --name=hubble -p 8088:8088 hugegraph/hubble` 快速启动
[hubble](https://hub.docker.com/r/hugegraph/hubble).
+
+或者使用 docker-compose 启动 hubble，另外如果 hubble 和 graph 在同一个 docker 网络下，可以使用 graph 的
contain_name 进行访问，而不需要宿主机的 ip
+
+使用`docker-compose up -d`，`docker-compose.yml`如下：
+
+```yaml
+version: '3'
+services:
+ server:
+ image: hugegraph/hugegraph
+ container_name: graph
+ ports:
+ - 8080:8080
+
+ hubble:
+ image: hugegraph/hubble
+ container_name: hubble
+ ports:
+ - 8088:8088
+```
+
+> 注意：
+>
+> 1. hugegraph-hubble 的 docker 镜像是一个便捷版本，用于快速启动 hubble，并不是**官方发布物料包方式**。你可以从
[ASF Release Distribution
Policy](https://infra.apache.org/release-distribution.html#dockerhub) 中得到更多细节。
+>
+> 2. 推荐使用 `release tag`(如 `1.0.0`) 以获取稳定版。使用 `latest` tag 可以使用开发中的最新功能。
+
### 3 平台使用流程
平台的模块使用流程如下：
diff --git a/content/cn/docs/quickstart/hugegraph-loader.md
b/content/cn/docs/quickstart/hugegraph-loader.md
index 062365b6..d4c36b2a 100644
--- a/content/cn/docs/quickstart/hugegraph-loader.md
+++ b/content/cn/docs/quickstart/hugegraph-loader.md
@@ -24,52 +24,20 @@ HugeGraph-Loader 是 HugeGraph 的数据导入组件，能够将多种数据源
有两种方式可以获取 HugeGraph-Loader：
-- 使用 Docker 镜像 (推荐)
- 下载已编译的压缩包
- 克隆源码编译安装
+- 使用 Docker 镜像 (便于**测试**)
-#### 2.1 使用 Docker 镜像
-
-我们可以使用 `docker run -itd --name loader hugegraph/loader`部署 loader
服务。对于需要加载的数据，则可以通过挂载 `-v /path/to/data/file:/loader/file` 或者`docker
cp`的方式将文件复制到 loader 容器内部。
-
-或者使用 docker-compose 启动 loader, 启动命令为 `docker-compose up -d`, 样例的
docker-compose.yml 如下所示：
-
-```yaml
-version: '3'
-
-services:
- server:
- image: hugegraph/hugegraph
- container_name: graph
- ports:
- - 8080:8080
-
- hubble:
- image: hugegraph/hubble
- container_name: hubble
- ports:
- - 8088:8088
-
- loader:
- image: hugegraph/loader
- container_name: loader
- # mount your own data here
- # volumes:
- # - /path/to/data/file:/loader/file
-```
-
-具体的数据导入流程可以参考 [4.5 使用 docker 导入](#45-使用-docker-导入)
-
-#### 2.2 下载已编译的压缩包
+#### 2.1 下载已编译的压缩包
下载最新版本的 HugeGraph-Toolchain Release 包，里面包含了 loader + tool + hubble
全套工具，如果你已经下载，可跳过重复步骤
```bash
-wget
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-toolchain-incubating-1.0.0.tar.gz
+wget
https://downloads.apache.org/incubator/hugegraph/{version}//apache-hugegraph-toolchain-incubating-{version}.tar.gz
tar zxf *hugegraph*.tar.gz
```
-#### 2.3 克隆源码编译安装
+#### 2.2 克隆源码编译安装
克隆最新版本的 HugeGraph-Loader 源码包：
@@ -78,7 +46,7 @@ tar zxf *hugegraph*.tar.gz
git clone https://github.com/apache/hugegraph-toolchain.git
# 2. get from direct (e.g. here is 1.0.0, please choose the latest version)
-wget
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-toolchain-incubating-1.0.0-src.tar.gz
+wget
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-toolchain-incubating-{version}-src.tar.gz
```
由于 Oracle ojdbc license 的限制，需要手动安装 ojdbc 到本地 maven 仓库。
@@ -98,6 +66,45 @@ cd hugegraph-loader
mvn clean package -DskipTests
```
+#### 2.3 使用 Docker 镜像 (便于**测试**)
+
+我们可以使用 `docker run -itd --name loader hugegraph/loader`部署 loader
服务。对于需要加载的数据，则可以通过挂载 `-v /path/to/data/file:/loader/file` 或者`docker
cp`的方式将文件复制到 loader 容器内部。
+
+或者使用 docker-compose 启动 loader, 启动命令为 `docker-compose up -d`, 样例的
docker-compose.yml 如下所示：
+
+```yaml
+version: '3'
+
+services:
+ server:
+ image: hugegraph/hugegraph
+ container_name: graph
+ ports:
+ - 8080:8080
+
+ hubble:
+ image: hugegraph/hubble
+ container_name: hubble
+ ports:
+ - 8088:8088
+
+ loader:
+ image: hugegraph/loader
+ container_name: loader
+ # mount your own data here
+ # volumes:
+ # - /path/to/data/file:/loader/file
+```
+
+具体的数据导入流程可以参考 [4.5 使用 docker 导入](#45-使用-docker-导入)
+
+
+> 注意：
+>
+> 1. hugegraph-loader 的 docker 镜像是一个便捷版本，用于快速启动 loader，并不是**官方发布物料包方式**。你可以从
[ASF Release Distribution
Policy](https://infra.apache.org/release-distribution.html#dockerhub) 中得到更多细节。
+>
+> 2. 推荐使用 `release tag`(如 `1.0.0`) 以获取稳定版。使用 `latest` tag 可以使用开发中的最新功能。
+
### 3 使用流程
使用 HugeGraph-Loader 的基本流程分为以下几步：
diff --git a/content/cn/docs/quickstart/hugegraph-server.md
b/content/cn/docs/quickstart/hugegraph-server.md
index a144191c..a6753a0f 100644
--- a/content/cn/docs/quickstart/hugegraph-server.md
+++ b/content/cn/docs/quickstart/hugegraph-server.md
@@ -28,45 +28,21 @@ java -version
有四种方式可以部署 HugeGraph-Server 组件：
-- 方式 1：使用 Docker 容器 (推荐)
-- 方式 2：下载 tar 包
-- 方式 3：源码编译
+- 方式 1：下载 tar 包
+- 方式 2：源码编译
+- 方式 3：使用 Docker 容器 (便于**测试**)
- 方式 4：使用 tools 工具部署 (Outdated)
-#### 3.1 使用 Docker 容器 (推荐)
-<!-- 3.1 is linked by other place. if change 3.1's title, please check -->
-可参考 [Docker
部署方式](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/README.md)。
-
-我们可以使用 `docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph`
去快速启动一个内置了 `RocksDB` 的 `Hugegraph server`.
-
-可选项：
-
-1. 可以使用 `docker exec -it graph bash` 进入容器完成一些操作
-2. 可以使用 `docker run -itd --name=graph -p 8080:8080 -e PRELOAD="true"
hugegraph/hugegraph` 在启动的时候预加载一个**内置的**样例图。可以通过 `RESTful API` 进行验证。具体步骤可以参考
[5.1.1](/cn/docs/quickstart/hugegraph-server/#511-%E5%90%AF%E5%8A%A8-server-%E7%9A%84%E6%97%B6%E5%80%99%E5%88%9B%E5%BB%BA%E7%A4%BA%E4%BE%8B%E5%9B%BE)
-
-另外，如果我们希望能够在一个文件中管理除了 `server` 之外的其他 Hugegraph 相关的实例，我们也可以使用
`docker-compose`完成部署，使用命令 `docker-compose up -d`，（当然只配置 `server` 也是可以的）以下是一个样例的
`docker-compose.yml`:
-
-```yaml
-version: '3'
-services:
- graph:
- image: hugegraph/hugegraph
- # environment:
- # - PRELOAD=true
- # PRELOAD 为可选参数，为 True 时可以在启动的时候预加载一个内置的样例图
- ports:
- - 8080:8080
-```
-#### 3.2 下载 tar 包
+#### 3.1 下载 tar 包
```bash
# use the latest version, here is 1.0.0 for example
-wget
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-incubating-1.0.0.tar.gz
+wget
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-incubating-{version}.tar.gz
tar zxf *hugegraph*.tar.gz
```
-#### 3.3 源码编译
+#### 3.2 源码编译
源码编译前请确保安装了 wget 命令
@@ -110,6 +86,37 @@ mvn package -DskipTests
执行成功后，在 hugegraph 目录下生成 `*hugegraph-*.tar.gz` 文件，就是编译生成的 tar 包。
+#### 3.3 使用 Docker 容器 (便于**测试**)
+<!-- 3.1 is linked by other place. if change 3.1's title, please check -->
+
+可参考 [Docker
部署方式](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/README.md)。
+
+我们可以使用 `docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph`
去快速启动一个内置了 `RocksDB` 的 `Hugegraph server`.
+
+可选项：
+
+1. 可以使用 `docker exec -it graph bash` 进入容器完成一些操作
+2. 可以使用 `docker run -itd --name=graph -p 8080:8080 -e PRELOAD="true"
hugegraph/hugegraph` 在启动的时候预加载一个**内置的**样例图。可以通过 `RESTful API` 进行验证。具体步骤可以参考
[5.1.1](/cn/docs/quickstart/hugegraph-server/#511-%E5%90%AF%E5%8A%A8-server-%E7%9A%84%E6%97%B6%E5%80%99%E5%88%9B%E5%BB%BA%E7%A4%BA%E4%BE%8B%E5%9B%BE)
+
+另外，如果我们希望能够在一个文件中管理除了 `server` 之外的其他 Hugegraph 相关的实例，我们也可以使用
`docker-compose`完成部署，使用命令 `docker-compose up -d`，（当然只配置 `server` 也是可以的）以下是一个样例的
`docker-compose.yml`:
+
+```yaml
+version: '3'
+services:
+ graph:
+ image: hugegraph/hugegraph
+ # environment:
+ # - PRELOAD=true
+ # PRELOAD 为可选参数，为 True 时可以在启动的时候预加载一个内置的样例图
+ ports:
+ - 8080:8080
+```
+
+> 注意：
+>
+> 1. hugegraph 的 docker 镜像是一个便捷版本，用于快速启动 hugegraph，并不是**官方发布物料包方式**。你可以从 [ASF
Release Distribution
Policy](https://infra.apache.org/release-distribution.html#dockerhub) 中得到更多细节。
+>
+> 2. 推荐使用 `release tag`(如 `1.0.0`) 以获取稳定版。使用 `latest` tag 可以使用开发中的最新功能。
#### 3.4 使用 tools 工具部署 (Outdated)
@@ -141,114 +148,7 @@ bin/hugegraph deploy -v {hugegraph-version} -p
{install-path} [-u {download-path
### 5 启动
-#### 5.1 使用 Docker
-
-在 [3.1 使用 Docker 容器](#31-使用-docker-容器-推荐)中，我们已经介绍了如何使用 `docker` 部署
`hugegraph-server`, 我们还可以使用其他的后端存储或者设置参数在 sever 启动的时候加载样例图
-
-##### 5.1.1 使用 Cassandra 作为后端
-
-<details>
-<summary>点击展开/折叠 Cassandra 配置及启动方法</summary>
-
-在使用 Docker 的时候，我们可以使用 Cassandra 作为后端存储。我们更加推荐直接使用 docker-compose 来对于 server 以及
Cassandra 进行统一管理
-
-样例的 `docker-compose.yml` 可以在
[github](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/docker/example/docker-compose-cassandra.yml)
中获取，使用 `docker-compose up -d` 启动。(如果使用 cassandra 4.0
版本作为后端存储，则需要大约两个分钟初始化，请耐心等待)
-
-```yaml
-version: "3"
-
-services:
- graph:
- image: hugegraph/hugegraph
- container_name: cas-graph
- ports:
- - 8080:8080
- environment:
- hugegraph.backend: cassandra
- hugegraph.serializer: cassandra
- hugegraph.cassandra.host: cas-cassandra
- hugegraph.cassandra.port: 9042
- networks:
- - ca-network
- depends_on:
- - cassandra
- healthcheck:
- test: ["CMD", "bin/gremlin-console.sh", "--" ,"-e",
"scripts/remote-connect.groovy"]
- interval: 10s
- timeout: 30s
- retries: 3
-
- cassandra:
- image: cassandra:4
- container_name: cas-cassandra
- ports:
- - 7000:7000
- - 9042:9042
- security_opt:
- - seccomp:unconfined
- networks:
- - ca-network
- healthcheck:
- test: ["CMD", "cqlsh", "--execute", "describe keyspaces;"]
- interval: 10s
- timeout: 30s
- retries: 5
-
-networks:
- ca-network:
-
-volumes:
- hugegraph-data:
-```
-
-在这个 yaml 中，需要在环境变量中以 `hugegraph.<parameter_name>`的形式进行参数传递，配置 Cassandra 相关的参数。
-
-具体来说，在 `hugegraph.properties` 配置文件中，提供了 `backend=xxx`, `cassandra.host=xxx`
等配置项，为了配置这些配置项，在传递环境变量的过程之中，我们需要在这些配置项前加上 `hugegrpah.`，即 `hugegraph.backend` 和
`hugegraph.cassandra.host`。
-
-其他配置可以参照 [4 配置](#4-配置)
-
-</details>
-
-##### 5.1.2 启动 server 的时候创建示例图
-
-在 docker 启动的时候设置环境变量 `PRELOAD=true`, 从而实现启动脚本的时候加载数据。
-
-1. 使用`docker run`
-
- 使用 `docker run -itd --name=graph -p 8080:8080 -e PRELOAD=true
hugegraph/hugegraph:latest`
-
-2. 使用`docker-compose`
-
- 创建`docker-compose.yml`，具体文件如下，在环境变量中设置
PRELOAD=true。其中，[`example.groovy`](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/src/assembly/static/scripts/example.groovy)
是一个预定义的脚本，用于预加载样例数据。如果有需要，可以通过挂载新的 `example.groovy` 脚本改变预加载的数据。
-
- ```yaml
- version: '3'
- services:
- graph:
- image: hugegraph/hugegraph:latest
- container_name: graph
- environment:
- - PRELOAD=true
- volumes:
- - /path/to/yourscript:/hugegraph/scripts/example.groovy
- ports:
- - 8080:8080
- ```
-
- 使用命令 `docker-compose up -d` 启动容器
-
-使用 RESTful API 请求 `HugeGraphServer` 得到如下结果：
-
-```javascript
-> curl "http://localhost:8080/graphs/hugegraph/graph/vertices"; | gunzip
-
-{"vertices":[{"id":"2:lop","label":"software","type":"vertex","properties":{"name":"lop","lang":"java","price":328}},{"id":"1:josh","label":"person","type":"vertex","properties":{"name":"josh","age":32,"city":"Beijing"}},{"id":"1:marko","label":"person","type":"vertex","properties":{"name":"marko","age":29,"city":"Beijing"}},{"id":"1:peter","label":"person","type":"vertex","properties":{"name":"peter","age":35,"city":"Shanghai"}},{"id":"1:vadas","label":"person","type":"vertex","properti
[...]
-```
-
-代表创建示例图成功。
-
-
-#### 5.2 使用启动脚本启动
+#### 5.1 使用启动脚本启动
启动分为"首次启动"和"非首次启动"，这么区分是因为在第一次启动前需要初始化后端数据库，然后启动服务。
@@ -260,7 +160,7 @@ HugeGraphServer 启动时会连接后端存储并尝试检查后端存储版本
由于各种后端所需的配置（hugegraph.properties）及启动步骤略有不同，下面逐一对各后端的配置及启动做介绍。
-##### 5.2.1 RocksDB
+##### 5.1.1 RocksDB
<details>
<summary>点击展开/折叠 RocksDB 配置及启动方法</summary>
@@ -296,7 +196,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.2 HBase
+##### 5.1.2 HBase
<details>
<summary>点击展开/折叠 HBase 配置及启动方法</summary>
@@ -338,7 +238,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.3 MySQL
+##### 5.1.3 MySQL
<details>
<summary>点击展开/折叠 MySQL 配置及启动方法</summary>
@@ -382,7 +282,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.4 Cassandra
+##### 5.1.4 Cassandra
<details>
<summary>点击展开/折叠 Cassandra 配置及启动方法</summary>
@@ -441,7 +341,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.5 Memory
+##### 5.1.5 Memory
<details>
<summary>点击展开/折叠 Memory 配置及启动方法</summary>
@@ -467,7 +367,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.6 ScyllaDB
+##### 5.1.6 ScyllaDB
<details>
<summary>点击展开/折叠 ScyllaDB 配置及启动方法</summary>
@@ -511,7 +411,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.7 启动 server 的时候创建示例图
+##### 5.1.7 启动 server 的时候创建示例图
在脚本启动时候携带 `-p true`参数，表示 preload, 即创建示例图图
@@ -531,6 +431,113 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)......OK
代表创建示例图成功。
+#### 5.2 使用 Docker
+
+在 [3.3 使用 Docker 容器](#33-使用-docker-容器)中，我们已经介绍了如何使用 `docker` 部署
`hugegraph-server`, 我们还可以使用其他的后端存储或者设置参数在 sever 启动的时候加载样例图
+
+##### 5.2.1 使用 Cassandra 作为后端
+
+<details>
+<summary>点击展开/折叠 Cassandra 配置及启动方法</summary>
+
+在使用 Docker 的时候，我们可以使用 Cassandra 作为后端存储。我们更加推荐直接使用 docker-compose 来对于 server 以及
Cassandra 进行统一管理
+
+样例的 `docker-compose.yml` 可以在
[github](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/docker/example/docker-compose-cassandra.yml)
中获取，使用 `docker-compose up -d` 启动。(如果使用 cassandra 4.0
版本作为后端存储，则需要大约两个分钟初始化，请耐心等待)
+
+```yaml
+version: "3"
+
+services:
+ graph:
+ image: hugegraph/hugegraph
+ container_name: cas-graph
+ ports:
+ - 8080:8080
+ environment:
+ hugegraph.backend: cassandra
+ hugegraph.serializer: cassandra
+ hugegraph.cassandra.host: cas-cassandra
+ hugegraph.cassandra.port: 9042
+ networks:
+ - ca-network
+ depends_on:
+ - cassandra
+ healthcheck:
+ test: ["CMD", "bin/gremlin-console.sh", "--" ,"-e",
"scripts/remote-connect.groovy"]
+ interval: 10s
+ timeout: 30s
+ retries: 3
+
+ cassandra:
+ image: cassandra:4
+ container_name: cas-cassandra
+ ports:
+ - 7000:7000
+ - 9042:9042
+ security_opt:
+ - seccomp:unconfined
+ networks:
+ - ca-network
+ healthcheck:
+ test: ["CMD", "cqlsh", "--execute", "describe keyspaces;"]
+ interval: 10s
+ timeout: 30s
+ retries: 5
+
+networks:
+ ca-network:
+
+volumes:
+ hugegraph-data:
+```
+
+在这个 yaml 中，需要在环境变量中以 `hugegraph.<parameter_name>`的形式进行参数传递，配置 Cassandra 相关的参数。
+
+具体来说，在 `hugegraph.properties` 配置文件中，提供了 `backend=xxx`, `cassandra.host=xxx`
等配置项，为了配置这些配置项，在传递环境变量的过程之中，我们需要在这些配置项前加上 `hugegrpah.`，即 `hugegraph.backend` 和
`hugegraph.cassandra.host`。
+
+其他配置可以参照 [4 配置](#4-配置)
+
+</details>
+
+##### 5.2.2 启动 server 的时候创建示例图
+
+在 docker 启动的时候设置环境变量 `PRELOAD=true`, 从而实现启动脚本的时候加载数据。
+
+1. 使用`docker run`
+
+ 使用 `docker run -itd --name=graph -p 8080:8080 -e PRELOAD=true
hugegraph/hugegraph:latest`
+
+2. 使用`docker-compose`
+
+ 创建`docker-compose.yml`，具体文件如下，在环境变量中设置
PRELOAD=true。其中，[`example.groovy`](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/src/assembly/static/scripts/example.groovy)
是一个预定义的脚本，用于预加载样例数据。如果有需要，可以通过挂载新的 `example.groovy` 脚本改变预加载的数据。
+
+ ```yaml
+ version: '3'
+ services:
+ graph:
+ image: hugegraph/hugegraph:latest
+ container_name: graph
+ environment:
+ - PRELOAD=true
+ volumes:
+ - /path/to/yourscript:/hugegraph/scripts/example.groovy
+ ports:
+ - 8080:8080
+ ```
+
+ 使用命令 `docker-compose up -d` 启动容器
+
+使用 RESTful API 请求 `HugeGraphServer` 得到如下结果：
+
+```javascript
+> curl "http://localhost:8080/graphs/hugegraph/graph/vertices"; | gunzip
+
+{"vertices":[{"id":"2:lop","label":"software","type":"vertex","properties":{"name":"lop","lang":"java","price":328}},{"id":"1:josh","label":"person","type":"vertex","properties":{"name":"josh","age":32,"city":"Beijing"}},{"id":"1:marko","label":"person","type":"vertex","properties":{"name":"marko","age":29,"city":"Beijing"}},{"id":"1:peter","label":"person","type":"vertex","properties":{"name":"peter","age":35,"city":"Shanghai"}},{"id":"1:vadas","label":"person","type":"vertex","properti
[...]
+```
+
+代表创建示例图成功。
+
+
### 6 访问 Server
#### 6.1 服务启动状态校验
diff --git a/content/en/docs/quickstart/hugegraph-hubble.md
b/content/en/docs/quickstart/hugegraph-hubble.md
index 29576877..c844942d 100644
--- a/content/en/docs/quickstart/hugegraph-hubble.md
+++ b/content/en/docs/quickstart/hugegraph-hubble.md
@@ -35,40 +35,12 @@ For Gremlin tasks that need to traverse the whole graph,
index creation and reco
### 2 Deploy
There are three ways to deplot `hugegraph-hubble`
-- Use Docker (recommended)
+
- Download the Toolchain binary package
- Source code compilation
+- Use Docker (Convenient for Test/Dev)
-#### 2.1 Use docker (recommended)
-
-> **Special Note**: If you are starting `hubble` with Docker, and `hubble` and
the server are on the same host. When configuring the hostname for the graph on
the Hubble web page, please do not directly set it to `localhost/127.0.0.1`.
This will refer to the `hubble` container internally rather than the host
machine, resulting in a connection failure to the server.
->
-> If `hubble` and `server` is in the same docker network, we **recommend**
using the `container_name` (in our example, it is `graph`) as the hostname, and
`8080` as the port. Or you can use the **host IP** as the hostname, and the
port is configured by the host for the server.
-
-We can use `docker run -itd --name=hubble -p 8088:8088 hugegraph/hubble` to
quick start [hubble](https://hub.docker.com/r/hugegraph/hubble).
-
-Alternatively, you can use Docker Compose to start `hubble`. Additionally, if
`hubble` and the graph are in the same Docker network, you can access the graph
using the container name of the graph, eliminating the need for the host
machine's IP address.
-
-Use `docker-compose up -d`，`docker-compose.yml` is following:
-
-```yaml
-version: '3'
-services:
- server:
- image: hugegraph/hugegraph
- container_name: graph
- ports:
- - 8080:8080
-
- hubble:
- image: hugegraph/hubble
- container_name: hubble
- ports:
- - 8088:8088
-```
-
-
-#### 2.2 Download the Toolchain binary package
+#### 2.1 Download the Toolchain binary package
`hubble` is in the `toolchain` project. First, download the binary tar tarball
@@ -97,7 +69,7 @@ starting HugeGraphHubble ..............timed out with http
status 502
Then use a web browser to access `ip:8088` and you can see the `Hubble` page.
You can stop the service using bin/stop-hubble.sh.
-#### 2.3 Source code compilation
+#### 2.2 Source code compilation
**Note**: Compiling Hubble requires the user's local environment to have
Node.js V16.x and yarn installed.
@@ -143,6 +115,40 @@ Run `hubble`
bin/start-hubble.sh -d
```
+#### 2.3 Use docker (Convenient for Test/Dev)
+
+> **Special Note**: If you are starting `hubble` with Docker, and `hubble` and
the server are on the same host. When configuring the hostname for the graph on
the Hubble web page, please do not directly set it to `localhost/127.0.0.1`.
This will refer to the `hubble` container internally rather than the host
machine, resulting in a connection failure to the server.
+>
+> If `hubble` and `server` is in the same docker network, we **recommend**
using the `container_name` (in our example, it is `graph`) as the hostname, and
`8080` as the port. Or you can use the **host IP** as the hostname, and the
port is configured by the host for the server.
+
+We can use `docker run -itd --name=hubble -p 8088:8088 hugegraph/hubble` to
quick start [hubble](https://hub.docker.com/r/hugegraph/hubble).
+
+Alternatively, you can use Docker Compose to start `hubble`. Additionally, if
`hubble` and the graph are in the same Docker network, you can access the graph
using the container name of the graph, eliminating the need for the host
machine's IP address.
+
+Use `docker-compose up -d`，`docker-compose.yml` is following:
+
+```yaml
+version: '3'
+services:
+ server:
+ image: hugegraph/hugegraph
+ container_name: graph
+ ports:
+ - 8080:8080
+
+ hubble:
+ image: hugegraph/hubble
+ container_name: hubble
+ ports:
+ - 8088:8088
+```
+
+> Note:
+>
+> 1. The docker image of hugegraph-hubble is a convenience release to start
hugegraph-hubble quickly, but not **official distribution** artifacts. You can
find more details from [ASF Release Distribution
Policy](https://infra.apache.org/release-distribution.html#dockerhub).
+>
+> 2. Recommand to use `release tag`(like `1.0.0`) for the stable version. Use
`latest` tag to experience the newest functions in development.
+
### 3 Platform Workflow
The module usage process of the platform is as follows:
diff --git a/content/en/docs/quickstart/hugegraph-loader.md
b/content/en/docs/quickstart/hugegraph-loader.md
index 7d3f1e71..bd7ed387 100644
--- a/content/en/docs/quickstart/hugegraph-loader.md
+++ b/content/en/docs/quickstart/hugegraph-loader.md
@@ -23,52 +23,20 @@ It will be explained in detail below.
There are two ways to get HugeGraph-Loader:
-- User docker image (Recommended)
- Download the compiled tarball
- Clone source code then compile and install
+- Use docker image (Convenient for Test/Dev)
-#### 2.1 Use Docker image
-
-We can deploy the loader service using `docker run -itd --name loader
hugegraph/loader`. For the data that needs to be loaded, it can be copied into
the loader container either by mounting `-v /path/to/data/file:/loader/file` or
by using `docker cp`.
-
-Alternatively, to start the loader using docker-compose, the command is
`docker-compose up -d`. An example of the docker-compose.yml is as follows:
-
-```yaml
-version: '3'
-
-services:
- server:
- image: hugegraph/hugegraph
- container_name: graph
- ports:
- - 8080:8080
-
- hubble:
- image: hugegraph/hubble
- container_name: hubble
- ports:
- - 8088:8088
-
- loader:
- image: hugegraph/loader
- container_name: loader
- # mount your own data here
- # volumes:
- # - /path/to/data/file:/loader/file
-```
-
-The specific data loading process can be referenced under [4.5 User Docker to
load data](#45-use-docker-to-load-data)
-
-#### 2.2 Download the compiled archive
+#### 2.1 Download the compiled archive
Download the latest version of the HugeGraph-Toolchain release package:
```bash
-wget
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-toolchain-incubating-1.0.0.tar.gz
+wget
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-toolchain-incubating-{version}.tar.gz
tar zxf *hugegraph*.tar.gz
```
-#### 2.3 Clone source code to compile and install
+#### 2.2 Clone source code to compile and install
Clone the latest version of HugeGraph-Loader source package:
@@ -77,7 +45,7 @@ Clone the latest version of HugeGraph-Loader source package:
git clone https://github.com/apache/hugegraph-toolchain.git
# 2. get from direct (e.g. here is 1.0.0, please choose the latest version)
-wget
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-toolchain-incubating-1.0.0-src.tar.gz
+wget
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-toolchain-incubating-{version}-src.tar.gz
```
Due to the license limitation of the `Oracle OJDBC`, you need to manually
install ojdbc to the local maven repository.
@@ -97,6 +65,43 @@ cd hugegraph-loader
mvn clean package -DskipTests
```
+#### 2.3 Use Docker image (Convenient for Test/Dev)
+
+We can deploy the loader service using `docker run -itd --name loader
hugegraph/loader`. For the data that needs to be loaded, it can be copied into
the loader container either by mounting `-v /path/to/data/file:/loader/file` or
by using `docker cp`.
+
+Alternatively, to start the loader using docker-compose, the command is
`docker-compose up -d`. An example of the docker-compose.yml is as follows:
+
+```yaml
+version: '3'
+
+services:
+ server:
+ image: hugegraph/hugegraph
+ container_name: graph
+ ports:
+ - 8080:8080
+
+ hubble:
+ image: hugegraph/hubble
+ container_name: hubble
+ ports:
+ - 8088:8088
+
+ loader:
+ image: hugegraph/loader
+ container_name: loader
+ # mount your own data here
+ # volumes:
+ # - /path/to/data/file:/loader/file
+```
+
+The specific data loading process can be referenced under [4.5 User Docker to
load data](#45-use-docker-to-load-data)
+
+> Note:
+> 1. The docker image of hugegraph-loader is a convenience release to start
hugegraph-loader quickly, but not **official distribution** artifacts. You can
find more details from [ASF Release Distribution
Policy](https://infra.apache.org/release-distribution.html#dockerhub).
+>
+> 2. Recommand to use `release tag`(like `1.0.0`) for the stable version. Use
`latest` tag to experience the newest functions in development.
+
### 3 How to use
The basic process of using HugeGraph-Loader is divided into the following
steps:
- Write graph schema
diff --git a/content/en/docs/quickstart/hugegraph-server.md
b/content/en/docs/quickstart/hugegraph-server.md
index 241ecbb7..4e14d0dc 100644
--- a/content/en/docs/quickstart/hugegraph-server.md
+++ b/content/en/docs/quickstart/hugegraph-server.md
@@ -24,49 +24,26 @@ Consider use Java 11 to run `HugeGraph-Server` (also
compatible with Java 8 now)
There are four ways to deploy HugeGraph-Server components:
-- Method 1: Use Docker container (recommended)
-- Method 2: Download the binary tarball
-- Method 3: Source code compilation
+- Method 1: Download the binary tarball
+- Method 2: Source code compilation
+- Method 3: Use Docker container (Convenient for Test/Dev)
- Method 4: One-click deployment
-#### 3.1 Use Docker container (recommended)
-<!-- 3.1 is linked by other place. if change 3.1's title, please check -->
-You can refer to [Docker deployment
guide](https://hub.docker.com/r/hugegraph/hugegraph).
-
-We can use `docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph` to
quickly start an inner `HugeGraph server` with `RocksDB` in background.
-
-Optional:
-1. use `docker exec -it graph bash` to enter the container to do some
operations.
-2. use `docker run -itd --name=graph -p 8080:8080 -e PRELOAD="true"
hugegraph/hugegraph` to start with a **built-in** example graph. We can use
`RESTful API` to verify the result. The detailed step can refer to
[5.1.1](http://127.0.0.1:1313/docs/quickstart/hugegraph-server/#511-create-example-graph-when-starting-server)
-
-Also, if we want to manage the other Hugegraph related instances in one file,
we can use `docker-compose` to deploy, with the command `docker-compose up -d`
(you can config only `server`). Here is an example `docker-compose.yml`:
-
-```yaml
-version: '3'
-services:
- graph:
- image: hugegraph/hugegraph
- # environment:
- # - PRELOAD=true
- # PRELOAD is a option to preload a build-in sample graph when initializing.
- ports:
- - 8080:8080
-```
-#### 3.2 Download the binary tar tarball
+#### 3.1 Download the binary tar tarball
You could download the binary tarball from the download page of ASF site like
this:
```bash
# use the latest version, here is 1.0.0 for example
-wget
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-incubating-1.0.0.tar.gz
+wget
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-incubating-{version}.tar.gz
tar zxf *hugegraph*.tar.gz
# (Optional) verify the integrity with SHA512 (recommended)
-shasum -a 512 apache-hugegraph-incubating-1.0.0.tar.gz
-curl
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-incubating-1.0.0.tar.gz.sha512
+shasum -a 512 apache-hugegraph-incubating-{version}.tar.gz
+curl
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-incubating-{version}.tar.gz.sha512
```
-#### 3.3 Source code compilation
+#### 3.2 Source code compilation
Please ensure that the wget command is installed before compiling the source
code
We could get HugeGraph **source code** by 2 ways: (So as the other HugeGraph
repos/modules)
@@ -75,12 +52,12 @@ We could get HugeGraph **source code** by 2 ways: (So as
the other HugeGraph rep
```bash
# Way 1. download release package from the ASF site
-wget
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-incubating-src-1.0.0.tar.gz
+wget
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-incubating-src-{version}.tar.gz
tar zxf *hugegraph*.tar.gz
# (Optional) verify the integrity with SHA512 (recommended)
-shasum -a 512 apache-hugegraph-incubating-src-1.0.0.tar.gz
-curl
https://downloads.apache.org/incubator/hugegraph/1.0.0/apache-hugegraph-incubating-1.0.0-src.tar.gz.sha512
+shasum -a 512 apache-hugegraph-incubating-src-{version}.tar.gz
+curl
https://downloads.apache.org/incubator/hugegraph/{version}/apache-hugegraph-incubating-{version}-src.tar.gz.sha512
# Way2 : clone the latest code by git way (e.g GitHub)
git clone https://github.com/apache/hugegraph.git
@@ -120,6 +97,37 @@ The execution log is as follows:
After successful execution, `*hugegraph-*.tar.gz` files will be generated in
the hugegraph directory, which is the tarball generated by compilation.
+#### 3.3 Use Docker container (Convenient for Test/Dev)
+
+<!-- 3.1 is linked by other place. if change 3.1's title, please check -->
+You can refer to [Docker deployment
guide](https://hub.docker.com/r/hugegraph/hugegraph).
+
+We can use `docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph` to
quickly start an inner `HugeGraph server` with `RocksDB` in background.
+
+Optional:
+1. use `docker exec -it graph bash` to enter the container to do some
operations.
+2. use `docker run -itd --name=graph -p 8080:8080 -e PRELOAD="true"
hugegraph/hugegraph` to start with a **built-in** example graph. We can use
`RESTful API` to verify the result. The detailed step can refer to
[5.1.1](http://127.0.0.1:1313/docs/quickstart/hugegraph-server/#511-create-example-graph-when-starting-server)
+
+Also, if we want to manage the other Hugegraph related instances in one file,
we can use `docker-compose` to deploy, with the command `docker-compose up -d`
(you can config only `server`). Here is an example `docker-compose.yml`:
+
+```yaml
+version: '3'
+services:
+ graph:
+ image: hugegraph/hugegraph
+ # environment:
+ # - PRELOAD=true
+ # PRELOAD is a option to preload a build-in sample graph when initializing.
+ ports:
+ - 8080:8080
+```
+
+> Note:
+>
+> 1. The docker image of hugegraph is a convenience release to start hugegraph
quickly, but not **official distribution** artifacts. You can find more details
from [ASF Release Distribution
Policy](https://infra.apache.org/release-distribution.html#dockerhub).
+>
+> 2. Recommand to use `release tag`(like `1.0.0`) for the stable version. Use
`latest` tag to experience the newest functions in development.
+
#### 3.4 One-click deployment
`HugeGraph-Tools` provides a command-line tool for one-click deployment, users
can use this tool to quickly download, decompress, configure and start
`HugeGraphServer` and `HugeGraph-Hubble` with one click.
@@ -153,111 +161,7 @@ for detailed configuration introduction, please refer to
[configuration document
### 5 Startup
-#### 5.1 Use Docker to startup
-
-In [3.1 Use Docker container](#31-use-docker-container-recommended), we have
introduced how to use docker to deploy `hugegraph-server`. `server` can also
preload an example graph by setting the parameter.
-
-##### 5.1.1 Use Cassandra as the storage
-
-<details>
-<summary> Click to expand/collapse Cassandra configuration and startup
methods</summary>
-
-When using Docker, we can use Cassandra as the backend storage. We highly
recommend using docker-compose directly to manage both the server and Cassandra.
-
-The sample `docker-compose.yml` can be obtained on
[github](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/docker/example/docker-compose-cassandra.yml),
and you can start it with `docker-compose up -d`. (If using Cassandra 4.0 as
the backend storage, it takes approximately two minutes to initialize. Please
be patient.)
-
-```yaml
-version: "3"
-
-services:
- graph:
- image: hugegraph/hugegraph
- container_name: cas-graph
- ports:
- - 8080:8080
- environment:
- hugegraph.backend: cassandra
- hugegraph.serializer: cassandra
- hugegraph.cassandra.host: cas-cassandra
- hugegraph.cassandra.port: 9042
- networks:
- - ca-network
- depends_on:
- - cassandra
- healthcheck:
- test: ["CMD", "bin/gremlin-console.sh", "--" ,"-e",
"scripts/remote-connect.groovy"]
- interval: 10s
- timeout: 30s
- retries: 3
-
- cassandra:
- image: cassandra:4
- container_name: cas-cassandra
- ports:
- - 7000:7000
- - 9042:9042
- security_opt:
- - seccomp:unconfined
- networks:
- - ca-network
- healthcheck:
- test: ["CMD", "cqlsh", "--execute", "describe keyspaces;"]
- interval: 10s
- timeout: 30s
- retries: 5
-
-networks:
- ca-network:
-
-volumes:
- hugegraph-data:
-```
-
-In this yaml file, configuration parameters related to Cassandra need to be
passed as environment variables in the format of `hugegraph.<parameter_name>`.
-
-Specifically, in the configuration file `hugegraph.properties` , there are
settings like `backend=xxx` and `cassandra.host=xxx`. To configure these
settings during the process of passing environment variables, we need to
prepend `hugegraph.` to these configurations, like `hugegraph.backend` and
`hugegraph.cassandra.host`.
-
-The rest of the configurations can be referenced under [4 config](#4-config)
-
-</details>
-
-##### 5.1.2 Create example graph when starting server
-
-Set the environment variable `PRELOAD=true` when starting Docker in order to
load data during the execution of the startup script.
-
-1. Use `docker run`
-
- Use `docker run -itd --name=graph -p 8080:8080 -e PRELOAD=true
hugegraph/hugegraph:latest`
-
-2. Use `docker-compose`
-
- Create `docker-compose.yml` as following. We should set the environment
variable `PRELOAD=true`.
[`example.groovy`](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/src/assembly/static/scripts/example.groovy)
is a predefined script to preload the sample data. If needed, we can mount a
new `example.groovy` to change the preload data.
-
- ```yaml
- version: '3'
- services:
- graph:
- image: hugegraph/hugegraph:latest
- container_name: graph
- environment:
- - PRELOAD=true
- ports:
- - 8080:8080
- ```
-
- Use `docker-compose up -d` to start the container
-
-And use the RESTful API to request `HugeGraphServer` and get the following
result:
-
-```javascript
-> curl "http://localhost:8080/graphs/hugegraph/graph/vertices"; | gunzip
-
-{"vertices":[{"id":"2:lop","label":"software","type":"vertex","properties":{"name":"lop","lang":"java","price":328}},{"id":"1:josh","label":"person","type":"vertex","properties":{"name":"josh","age":32,"city":"Beijing"}},{"id":"1:marko","label":"person","type":"vertex","properties":{"name":"marko","age":29,"city":"Beijing"}},{"id":"1:peter","label":"person","type":"vertex","properties":{"name":"peter","age":35,"city":"Shanghai"}},{"id":"1:vadas","label":"person","type":"vertex","properti
[...]
-```
-
-This indicates the successful creation of the sample graph.
-
-#### 5.2 Use a startup script to startup
+#### 5.1 Use a startup script to startup
The startup is divided into "first startup" and "non-first startup". This
distinction is because the back-end database needs to be initialized before the
first startup, and then the service is started.
after the service is stopped artificially, or when the service needs to be
started again for other reasons, because the backend database is persistent,
you can start the service directly.
@@ -269,7 +173,7 @@ If you need to access HugeGraphServer externally, please
modify the `restserver.
Since the configuration (hugegraph.properties) and startup steps required by
various backends are slightly different, the following will introduce the
configuration and startup of each backend one by one.
-##### 5.2.1 Memory
+##### 5.1.1 Memory
<details>
<summary>Click to expand/collapse Memory configuration and startup
methods</summary>
@@ -295,7 +199,7 @@ The prompted url is the same as the restserver.url
configured in rest-server.pro
</details>
-##### 5.2.2 RocksDB
+##### 5.1.2 RocksDB
<details>
<summary>Click to expand/collapse RocksDB configuration and startup
methods</summary>
@@ -328,7 +232,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.3 Cassandra
+##### 5.1.3 Cassandra
<details>
<summary>Click to expand/collapse Cassandra configuration and startup
methods</summary>
@@ -388,7 +292,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.4 ScyllaDB
+##### 5.1.4 ScyllaDB
<details>
<summary>Click to expand/collapse ScyllaDB configuration and startup
methods</summary>
@@ -432,7 +336,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.5 HBase
+##### 5.1.5 HBase
<details>
<summary>Click to expand/collapse HBase configuration and startup
methods</summary>
@@ -474,7 +378,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.6 MySQL
+##### 5.1.6 MySQL
<details>
<summary>Click to expand/collapse MySQL configuration and startup
methods</summary>
@@ -518,7 +422,7 @@ Connecting to HugeGraphServer
(http://127.0.0.1:8080/graphs)....OK
</details>
-##### 5.2.7 Create an example graph when startup
+##### 5.1.7 Create an example graph when startup
Carry the `-p true` arguments when starting the script, which indicates
`preload`, to create a sample graph.
@@ -538,6 +442,112 @@ And use the RESTful API to request `HugeGraphServer` and
get the following resul
This indicates the successful creation of the sample graph.
+
+#### 5.2 Use Docker to startup
+
+In [3.3 Use Docker container](#33-use-docker-container), we have introduced
how to use docker to deploy `hugegraph-server`. `server` can also preload an
example graph by setting the parameter.
+
+##### 5.2.1 Use Cassandra as the storage
+
+<details>
+<summary> Click to expand/collapse Cassandra configuration and startup
methods</summary>
+
+When using Docker, we can use Cassandra as the backend storage. We highly
recommend using docker-compose directly to manage both the server and Cassandra.
+
+The sample `docker-compose.yml` can be obtained on
[github](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/docker/example/docker-compose-cassandra.yml),
and you can start it with `docker-compose up -d`. (If using Cassandra 4.0 as
the backend storage, it takes approximately two minutes to initialize. Please
be patient.)
+
+```yaml
+version: "3"
+
+services:
+ graph:
+ image: hugegraph/hugegraph
+ container_name: cas-graph
+ ports:
+ - 8080:8080
+ environment:
+ hugegraph.backend: cassandra
+ hugegraph.serializer: cassandra
+ hugegraph.cassandra.host: cas-cassandra
+ hugegraph.cassandra.port: 9042
+ networks:
+ - ca-network
+ depends_on:
+ - cassandra
+ healthcheck:
+ test: ["CMD", "bin/gremlin-console.sh", "--" ,"-e",
"scripts/remote-connect.groovy"]
+ interval: 10s
+ timeout: 30s
+ retries: 3
+
+ cassandra:
+ image: cassandra:4
+ container_name: cas-cassandra
+ ports:
+ - 7000:7000
+ - 9042:9042
+ security_opt:
+ - seccomp:unconfined
+ networks:
+ - ca-network
+ healthcheck:
+ test: ["CMD", "cqlsh", "--execute", "describe keyspaces;"]
+ interval: 10s
+ timeout: 30s
+ retries: 5
+
+networks:
+ ca-network:
+
+volumes:
+ hugegraph-data:
+```
+
+In this yaml file, configuration parameters related to Cassandra need to be
passed as environment variables in the format of `hugegraph.<parameter_name>`.
+
+Specifically, in the configuration file `hugegraph.properties` , there are
settings like `backend=xxx` and `cassandra.host=xxx`. To configure these
settings during the process of passing environment variables, we need to
prepend `hugegraph.` to these configurations, like `hugegraph.backend` and
`hugegraph.cassandra.host`.
+
+The rest of the configurations can be referenced under [4 config](#4-config)
+
+</details>
+
+##### 5.2.2 Create example graph when starting server
+
+Set the environment variable `PRELOAD=true` when starting Docker in order to
load data during the execution of the startup script.
+
+1. Use `docker run`
+
+ Use `docker run -itd --name=graph -p 8080:8080 -e PRELOAD=true
hugegraph/hugegraph:latest`
+
+2. Use `docker-compose`
+
+ Create `docker-compose.yml` as following. We should set the environment
variable `PRELOAD=true`.
[`example.groovy`](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-dist/src/assembly/static/scripts/example.groovy)
is a predefined script to preload the sample data. If needed, we can mount a
new `example.groovy` to change the preload data.
+
+ ```yaml
+ version: '3'
+ services:
+ graph:
+ image: hugegraph/hugegraph:latest
+ container_name: graph
+ environment:
+ - PRELOAD=true
+ ports:
+ - 8080:8080
+ ```
+
+ Use `docker-compose up -d` to start the container
+
+And use the RESTful API to request `HugeGraphServer` and get the following
result:
+
+```javascript
+> curl "http://localhost:8080/graphs/hugegraph/graph/vertices"; | gunzip
+
+{"vertices":[{"id":"2:lop","label":"software","type":"vertex","properties":{"name":"lop","lang":"java","price":328}},{"id":"1:josh","label":"person","type":"vertex","properties":{"name":"josh","age":32,"city":"Beijing"}},{"id":"1:marko","label":"person","type":"vertex","properties":{"name":"marko","age":29,"city":"Beijing"}},{"id":"1:peter","label":"person","type":"vertex","properties":{"name":"peter","age":35,"city":"Shanghai"}},{"id":"1:vadas","label":"person","type":"vertex","properti
[...]
+```
+
+This indicates the successful creation of the sample graph.
+
+
### 6 Access server
#### 6.1 Service startup status check
