+
+你可以通过[快速开始 Demo](https://github.com/GreptimeTeam/greptimedb-ingester-go/tree/main/examples) 来了解如何使用 GreptimeDB Go SDK。
+
+
使用下方的命令安装 Go Ingest SDK:
```shell
-go get -u github.com/GreptimeTeam/greptimedb-ingester-go@v0.5.0
+go get -u github.com/GreptimeTeam/greptimedb-ingester-go@VAR::goSdkVersion
```
引入到代码中:
@@ -24,6 +34,7 @@ go get -u github.com/GreptimeTeam/greptimedb-ingester-go@v0.5.0
```go
import (
greptime "github.com/GreptimeTeam/greptimedb-ingester-go"
+ ingesterContext "github.com/GreptimeTeam/greptimedb-ingester-go/context"
"github.com/GreptimeTeam/greptimedb-ingester-go/table"
"github.com/GreptimeTeam/greptimedb-ingester-go/table/types"
)
@@ -42,12 +53,38 @@ cfg := greptime.NewConfig("127.0.0.1").
// 如果服务配置了 TLS ,设置 TLS 选项来启用安全连接
// WithInsecure(false).
// 设置鉴权信息
+ // 如果数据库不需要鉴权,移除 WithAuth 方法即可
WithAuth("username", "password")
cli, _ := greptime.NewClient(cfg)
```
+
+
+你可以使用 `ingesterContext` 设置表选项。
+例如设置 `ttl` 选项:
+
+```go
+hints := []*ingesterContext.Hint{
+ {
+ Key: "ttl",
+ Value: "3d",
+ },
+}
+
+ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
+ctx = ingesterContext.New(ctx, ingesterContext.WithHints(hints))
+// 使用 ingesterContext写入数据到 GreptimeDB
+// `data` 对象在之后的章节中描述
+resp, err := c.client.Write(ctx, data)
+if err != nil {
+ return err
+}
+```
+
+
+
```go
@@ -149,7 +186,7 @@ type CpuMetric struct {
}
func (CpuMetric) TableName() string {
- return "cpu_metric"
+ return "cpu_metric"
}
cpuMetrics := []CpuMetric{
@@ -162,26 +199,6 @@ cpuMetrics := []CpuMetric{
}
```
-
-
-
-有关更多可运行的代码片段和常用方法的解释,请参阅[示例](https://github.com/GreptimeTeam/greptimedb-ingester-go/tree/main/examples)。
-
-
-
-
-
-- [API 文档](https://pkg.go.dev/github.com/GreptimeTeam/greptimedb-ingester-go)
-
-
-
-
-
-
-使用下方的命令安装 GORM:
-
-```shell
-go get -u gorm.io/gorm
-```
-
-以 MySQL 为例安装 driver:
-
-```shell
-go get -u gorm.io/driver/mysql
-```
-
-引入到代码中:
-
-```go
-import (
- "gorm.io/gorm"
- "gorm.io/driver/mysql"
-)
-```
-
-
-
+
-
+在[低层级 API](#低层级-api) 中,
+你可以使用 `AddFieldColumn` 方法将列类型指定为 `types.JSON` 来添加 JSON 列。
+然后使用 `struct` 或 `map` 插入 JSON 数据。
```go
-type Mysql struct {
- Host string
- Port string
- User string
- Password string
- Database string
-
- DB *gorm.DB
-}
-
-m := &Mysql{
- Host: "127.0.0.1",
- Port: "4002", // MySQL 协议的默认端口
- User: "username",
- Password: "password",
- Database: "public",
+sensorReadings, err := table.New("sensor_readings")
+// 此处省略了创建其他列的代码
+// ...
+// 将列类型指定为 JSON
+sensorReadings.AddFieldColumn("attributes", types.JSON)
+
+// 使用 struct 插入 JSON 数据
+type Attributes struct {
+ Location string `json:"location"`
+ Action string `json:"action"`
}
+attributes := Attributes{ Location: "factory-1" }
+sensorReadings.AddRow(... , attributes)
-dsn := fmt.Sprintf("tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
- m.Host, m.Port, m.Database)
-dsn = fmt.Sprintf("%s:%s@%s", m.User, m.Password, dsn)
-db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
-if err != nil {
- // 错误处理
-}
-m.DB = db
+// 以下省略了写入数据的代码
+// ...
```
-
-
-
-下方的代码声明了一个 GORM 对象模型:
+在[高层级 API](#高层级-api) 中,你可以使用 `greptime:"field;column:details;type:json"` 标签将列类型指定为 JSON。
```go
-type CpuMetric struct {
- Host string `gorm:"column:host;primaryKey"`
- Ts time.Time `gorm:"column:ts;primaryKey"`
- CpuUser float64 `gorm:"column:cpu_user"`
- CpuSys float64 `gorm:"column:cpu_sys"`
+type SensorReadings struct {
+ // 此处省略了创建其他列的代码
+ // ...
+ // 将列类型指定为 JSON
+ Attributes string `greptime:"field;column:details;type:json"`
+ // ...
}
-```
-
-如果你正在使用 [ORM API](#orm-api) 来插入数据,你可以在模型中同时声明 GORM 和 Greptime 标签。
-```go
-type CpuMetric struct {
- Host string `gorm:"column:host;primaryKey" greptime:"tag;column:host;type:string"`
- Ts time.Time `gorm:"column:ts;primaryKey" greptime:"timestamp;column:ts;type:timestamp;precision:millisecond"`
- CpuUser float64 `gorm:"column:cpu_user" greptime:"field;column:cpu_user;type:float64"`
- CpuSys float64 `gorm:"column:cpu_sys" greptime:"field;column:cpu_sys;type:float64"`
+// 使用 struct 插入 JSON 数据
+type Attributes struct {
+ Location string `json:"location"`
+ Action string `json:"action"`
}
-```
-
-声明表名:
-
-```go
-func (CpuMetric) TableName() string {
- return "cpu_metric"
+attributes := Attributes{ Action: "running" }
+sensor := SensorReadings{
+ // ...
+ Attributes: attributes,
}
-```
-
-使用原始 SQL 查询数据:
-
-```go
-var cpuMetric CpuMetric
-db.Raw("SELECT * FROM cpu_metric LIMIT 10").Scan(&result)
+// 以下省略了写入数据的代码
+// ...
```
+请参考 SDK 仓库中的[示例](https://github.com/GreptimeTeam/greptimedb-ingester-go/tree/main/examples/jsondata) 获取插入 JSON 数据的可执行代码。
+
-
+
-[GORM](https://gorm.io/docs/index.html)
+- [API 文档](https://pkg.go.dev/github.com/GreptimeTeam/greptimedb-ingester-go)
-
-
\ No newline at end of file
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.7/user-guide/client-libraries/java.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/java.md
similarity index 60%
rename from i18n/zh/docusaurus-plugin-content-docs/version-0.7/user-guide/client-libraries/java.md
rename to i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/java.md
index 64c3100a6..7a538124e 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/version-0.7/user-guide/client-libraries/java.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/java.md
@@ -1,3 +1,8 @@
+---
+keywords: [Java SDK, 数据写入, 安装 JDK, 连接数据库, 插入数据, 调试日志, 性能指标]
+description: 介绍如何使用 GreptimeDB 提供的 Java ingester SDK 写入数据,包括安装、连接、插入数据和调试日志等内容。
+---
+
import DocTemplate from './template.md'
# Java
@@ -15,6 +20,12 @@ GreptimeDB 提供的 Java ingester SDK 是一个轻量级库,具有以下特
+
+
+你可以通过[快速开始 Demo](https://github.com/GreptimeTeam/greptimedb-ingester-java/tree/main/ingester-example/src/main/java/io/greptime) 来了解如何使用 GreptimeDB Java SDK。
+
+
+
1. 安装 Java 开发工具包(JDK)
@@ -29,7 +40,7 @@ GreptimeDB 提供的 Java ingester SDK 是一个轻量级库,具有以下特
io.greptime
ingester-all
- 0.7.3
+ VAR::javaSdkVersion
```
@@ -69,6 +80,21 @@ GreptimeDB client = GreptimeDB.create(opts);
+
+
+你可以使用 `Context` 设置表选项。
+例如,使用以下代码设置 `ttl` 选项:
+
+```java
+Context ctx = Context.newDefault();
+ctx.withHint("ttl", "3d");
+// 使用 ctx 对象写入数据
+// `cpuMetric` 和 `memMetric` 是定义的数据对象,之后的章节中有详细描述
+CompletableFuture> future = greptimeDB.write(Arrays.asList(cpuMetric, memMetric), WriteOp.Insert, ctx);
+```
+
+
+
```java
@@ -183,35 +209,6 @@ LOG.info("Write result: {}", result);
-
-
-#### 更新数据
-
-关于更新机制,请参考 [更新数据](/user-guide/write-data/overview.md#更新数据)。
-下方代码首先保存了一行数据,然后使用相同的标签和时间索引来更新特定的行数据。
-
-```java
-Table cpuMetric = Table.from(myMetricCpuSchema);
-// 插入一行数据
-long ts = 1703832681000L;
-cpuMetric.addRow("host1", ts, 0.23, 0.12);
-Result putResult = greptimeDB.write(cpuMetric).get();
-
-// 更新行数据
-Table newCpuMetric = Table.from(myMetricCpuSchema);
-// 相同的标签 `host1`
-// 相同的时间索引 `1703832681000`
-// 新的值:cpu_user = `0.80`, cpu_sys = `0.11`
-long ts = 1703832681000L;
-myMetricCpuSchema.addRow("host1", ts, 0.80, 0.11);
-
-// 覆盖现有数据
-CompletableFuture> future = greptimeDB.write(myMetricCpuSchema);
-Result result = future.get();
-```
-
-
-
@@ -318,172 +315,69 @@ LOG.info("Write result: {}", result);
-
-
-#### 更新数据
+
-关于更新机制,请参考 [更新数据](/user-guide/write-data/overview.md#更新数据)。
-下方代码首先保存了一行数据,然后使用相同的标签和时间索引来更新特定的行数据。
+在[低层级 API](#低层级-api) 中,
+你可以使用 `addField` 方法将列类型指定为 `DataType.Json` 来添加 JSON 列,
+然后使用 Map 对象添加 JSON 数据。
```java
-Cpu cpu = new Cpu();
-cpu.setHost("host1");
-cpu.setTs(1703832681000L);
-cpu.setCpuUser(0.23);
-cpu.setCpuSys(0.12);
-
-// 插入一行数据
-Result putResult = greptimeDB.writePOJOs(cpu).get();
-
-// 更新该行数据
-Cpu newCpu = new Cpu();
-// 相同的标签 `host1`
-newCpu.setHost("host1");
-// 相同的时间索引 `1703832681000`
-newCpu.setTs(1703832681000L);
-// 新的值: cpu_user = `0.80`, cpu_sys = `0.11`
-cpu.setCpuUser(0.80);
-cpu.setCpuSys(0.11);
-
-// 覆盖现有数据
-Result updateResult = greptimeDB.writePOJOs(newCpu).get();
-```
-
-请参考[此处](https://github.com/GreptimeTeam/greptimedb-ingester-java/tree/main/ingester-example/src/main/java/io/greptime)获取更多代码示例。
-
-
-
-
-
-
-### 调试日志
-
-ingester SDK 提供了用于调试的指标和日志。
-请参考 [Metrics & Display](https://github.com/GreptimeTeam/greptimedb-ingester-java/blob/main/docs/metrics-display.md) 和 [Magic Tools](https://github.com/GreptimeTeam/greptimedb-ingester-java/blob/main/docs/magic-tools.md) 了解如何启用或禁用日志。
-
-
-
-
-
-请参考[示例](https://github.com/GreptimeTeam/greptimedb-ingester-java/tree/main/ingester-example/src/main/java/io/greptime)获取更多完全可运行的代码片段和常用方法的解释。
-
-
-
-
-
-- [API 文档](https://javadoc.io/doc/io.greptime/ingester-protocol/latest/index.html)
-
-
-
-
-
-Java 数据库连接(JDBC)是 JavaSoft 规范的标准应用程序编程接口(API),它允许 Java 程序访问数据库管理系统。
-
-许多数据库,如 MySQL 或 PostgreSQL,都已经基于 JDBC API 实现了自己的驱动程序。
-由于 GreptimeDB [支持多种协议](/user-guide/clients/overview.md),这里我们使用 MySQL 协议作为示例来演示如何使用 JDBC。
-如果你希望使用其他协议,只需要将 MySQL 驱动程序替换为相应的驱动程序。
-
-
+// 为 sensor_readings 表构建表结构
+TableSchema sensorReadings = TableSchema.newBuilder("sensor_readings")
+ // 此处省略了创建其他列的代码
+ // ...
+ // 将列类型指定为 JSON
+ .addField("attributes", DataType.Json)
+ .build();
-
+// ...
+// 使用 map 添加 JSON 数据
+Map
attr = new HashMap<>();
+attr.put("location", "factory-1");
+sensorReadings.addRow(... , attr);
-如果你使用的是 [Maven](https://maven.apache.org/),请将以下内容添加到 pom.xml 的依赖项列表中:
-
-```xml
-
-
- mysql
- mysql-connector-java
- 8.0.33
-
+// 以下省略了写入数据的代码
+// ...
```
-
-
-
-
-这里我们使用 MySQL 作为示例来演示如何连接到 GreptimeDB。
+在[高层级 API](#高层级-api) 中,你可以在 POJO 对象中指定列类型为 `DataType.Json`。
```java
-
-public static Connection getConnection() throws IOException, ClassNotFoundException, SQLException {
- Properties prop = new Properties();
- prop.load(QueryJDBC.class.getResourceAsStream("/db-connection.properties"));
-
- String dbName = (String) prop.get("db.database-driver");
-
- String dbConnUrl = (String) prop.get("db.url");
- String dbUserName = (String) prop.get("db.username");
- String dbPassword = (String) prop.get("db.password");
-
- Class.forName(dbName);
- Connection dbConn = DriverManager.getConnection(dbConnUrl, dbUserName, dbPassword);
-
- return Objects.requireNonNull(dbConn, "Failed to make connection!");
+@Metric(name = "sensor_readings")
+public class Sensor {
+ // 此处省略了创建其他列的代码
+ // ...
+ // 将列类型指定为 JSON
+ @Column(name = "attributes", dataType = DataType.Json)
+ private Map attributes;
+ // ...
}
-```
-
-你需要一个 properties 文件来存储数据库连接信息,将其放在 Resources 目录中并命名为 `db-connection.properties`。文件内容如下:
+Sensor sensor = new Sensor();
+// ...
+// 使用 map 添加 JSON 数据
+Map attr = new HashMap<>();
+attr.put("action", "running");
+sensor.setAttributes(attr);
-```txt
-# DataSource
-db.database-driver=com.mysql.cj.jdbc.Driver
-db.url=jdbc:mysql://localhost:4002/public
-db.username=
-db.password=
+// 以下省略了写入数据的代码
+// ...
```
-或者你可以从[这里](https://github.com/GreptimeTeam/greptimedb-ingester-java/blob/main/ingester-example/src/main/resources/db-connection.properties)获取文件。
-
-
+
-```java
-try (Connection conn = getConnection()) {
- Statement statement = conn.createStatement();
-
- // DESC table;
- ResultSet rs = statement.executeQuery("DESC cpu_metric");
- LOG.info("Column | Type | Key | Null | Default | Semantic Type ");
- while (rs.next()) {
- LOG.info("{} | {} | {} | {} | {} | {}",
- rs.getString(1),
- rs.getString(2),
- rs.getString(3),
- rs.getString(4),
- rs.getString(5),
- rs.getString(6));
- }
-
- // SELECT COUNT(*) FROM cpu_metric;
- rs = statement.executeQuery("SELECT COUNT(*) FROM cpu_metric");
- while (rs.next()) {
- LOG.info("Count: {}", rs.getInt(1));
- }
-
- // SELECT * FROM cpu_metric ORDER BY ts DESC LIMIT 5;
- rs = statement.executeQuery("SELECT * FROM cpu_metric ORDER BY ts DESC LIMIT 5");
- LOG.info("host | ts | cpu_user | cpu_sys");
- while (rs.next()) {
- LOG.info("{} | {} | {} | {}",
- rs.getString("host"),
- rs.getTimestamp("ts"),
- rs.getDouble("cpu_user"),
- rs.getDouble("cpu_sys"));
- }
-}
+## 调试日志
-```
-
-请参考[此处](https://github.com/GreptimeTeam/greptimedb-ingester-java/blob/main/ingester-example/src/main/java/io/greptime/QueryJDBC.java)获取更多可执行代码。
+Java SDK 提供了用于调试的指标和日志。
+请参考 [Metrics & Display](https://github.com/GreptimeTeam/greptimedb-ingester-java/blob/main/docs/metrics-display.md) 和 [Magic Tools](https://github.com/GreptimeTeam/greptimedb-ingester-java/blob/main/docs/magic-tools.md) 了解如何启用或禁用日志。
-
+
-- [JDBC 在线教程](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html)
+- [API 文档](https://javadoc.io/doc/io.greptime/ingester-protocol/latest/index.html)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/overview.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/overview.md
new file mode 100644
index 000000000..bcaee1db8
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/overview.md
@@ -0,0 +1,12 @@
+---
+keywords: [SDK, 数据写入, Go 示例, Java 示例, 数据库连接, 数据插入, 调试日志]
+description: 演示如何使用 SDK 在 GreptimeDB 中写入数据,提供 Go 和 Java 的示例。
+---
+
+# 概述
+
+本指南将演示如何使用 SDK 在 GreptimeDB 中写入数据。
+
+- [Go](go.md)
+- [Java](java.md)
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.7/user-guide/client-libraries/template.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/template.md
similarity index 56%
rename from i18n/zh/docusaurus-plugin-content-docs/version-0.7/user-guide/client-libraries/template.md
rename to i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/template.md
index ae5fdf333..8c06f02cf 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/version-0.7/user-guide/client-libraries/template.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/grpc-sdks/template.md
@@ -1,37 +1,48 @@
-GreptimeDB 使用不同的客户端库来写入和查询数据。
-你根据需求可以选择合适的客户端库。
-
-## 写入数据
-
-GreptimeDB 提供了一个 ingester 库来帮助你写入数据。
+GreptimeDB 提供了用于高吞吐量数据写入的 ingester 库。
它使用 gRPC 协议,支持自动生成表结构,无需在写入数据前创建表。
-更多信息请参考 [自动生成表结构](/user-guide/write-data/overview.md#自动生成表结构)。
+更多信息请参考 [自动生成表结构](/user-guide/ingest-data/overview.md#自动生成表结构)。
-### 安装
+## 快速开始 Demo
+
+
+
+## 安装
-### 连接数据库
+## 连接数据库
-连接 GreptimeDB 时,通常需要用户名和密码。
-关于如何设置 GreptimeDB 的鉴权方式,请参考[鉴权](/user-guide/clients/authentication.md)。
-这里我们在使用 ingester 库连接 GreptimeDB 时设置用户名和密码。
+如果你在启动 GreptimeDB 时设置了 [`--user-provider`](/user-guide/deployments/authentication/overview.md),
+则需要提供用户名和密码才能连接到 GreptimeDB。
+以下示例显示了使用 SDK 连接到 GreptimeDB 时如何设置用户名和密码。
-### 数据模型
+## 数据模型
表中的每条行数据包含三种类型的列:`Tag`、`Timestamp` 和 `Field`。更多信息请参考 [数据模型](/user-guide/concepts/data-model.md)。
-列值的类型可以是 `String`、`Float`、`Int`、`Timestamp` 等。更多信息请参考 [数据类型](/reference/sql/data-types.md)。
+列值的类型可以是 `String`、`Float`、`Int`、`JSON`, `Timestamp` 等。更多信息请参考 [数据类型](/reference/sql/data-types.md)。
+
+## 设置表选项
+
+虽然在通过 SDK 向 GreptimeDB 写入数据时会自动创建时间序列表,但你仍然可以配置表选项。
+SDK 支持以下表选项:
-### 低层级 API
+- `auto_create_table`:默认值为 `True`。如果设置为 `False`,则表示表已经存在且不需要自动创建,这可以提高写入性能。
+- `ttl`、`append_mode`、`merge_mode`:更多详情请参考[表选项](/reference/sql/create.md#table-options)。
+
+
+
+关于如何向 GreptimeDB 写入数据,请参考以下各节。
+
+## 低层级 API
GreptimeDB 的低层级 API 通过向具有预定义模式的 `table` 对象添加 `row` 来写入数据。
-#### 创建行数据
+### 创建行数据
以下代码片段首先构建了一个名为 `cpu_metric` 的表,其中包括 `host`、`cpu_user`、`cpu_sys` 和 `ts` 列。
随后,它向表中插入了一行数据。
@@ -48,13 +59,13 @@ GreptimeDB 的低层级 API 通过向具有预定义模式的 `table` 对象添
-#### 插入数据
+### 插入数据
下方示例展示了如何向 GreptimeDB 的表中插入行数据。
-#### 流式插入
+### 流式插入
当你需要插入大量数据时,例如导入历史数据,流式插入是非常有用的。
@@ -64,22 +75,22 @@ GreptimeDB 的低层级 API 通过向具有预定义模式的 `table` 对象添
-### 高层级 API
+## 高层级 API
SDK 的高层级 API 使用 ORM 风格的对象写入数据,
它允许你以更面向对象的方式创建、插入和更新数据,为开发者提供了更友好的体验。
然而,高层级 API 不如低层级 API 高效。
这是因为 ORM 风格的对象在转换对象时可能会消耗更多的资源和时间。
-#### 创建行数据
+### 创建行数据
-#### 插入数据
+### 插入数据
-#### 流式插入
+### 流式插入
当你需要插入大量数据时,例如导入历史数据,流式插入是非常有用的。
@@ -87,44 +98,19 @@ SDK 的高层级 API 使用 ORM 风格的对象写入数据,
-### 更多示例
+## 插入 JSON 类型的数据
-
+GreptimeDB 支持使用 [JSON 类型数据](/reference/sql/data-types.md#json-类型) 存储复杂的数据结构。
+使用此 ingester 库,你可以通过字符串值插入 JSON 数据。
+假如你有一个名为 `sensor_readings` 的表,并希望添加一个名为 `attributes` 的 JSON 列,
+请参考以下代码片段。
+
+
-### Ingester 库参考
+## Ingester 库参考
-## 查询数据
-
-GreptimeDB 使用 SQL 作为主要查询语言,兼容 MySQL 和 PostgreSQL。
-因此,我们推荐使用成熟的 SQL 驱动来查询数据。
-
-### 推荐的查询库
-
-
-
-### 安装
-
-
-
-### 连接数据库
-
-下方的例子展示了如何连接到 GreptimeDB:
-
-
-
-### Raw SQL
-
-我们推荐使用 Raw SQL 来体验 GreptimeDB 的全部功能。
-下面的例子展示了如何使用 Raw SQL 查询数据:
-
-
-
-### 查询库参考
-
-有关如何使用查询库的更多信息,请参考相应库的文档:
-
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/influxdb-line-protocol.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/influxdb-line-protocol.md
new file mode 100644
index 000000000..c2b340b16
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/influxdb-line-protocol.md
@@ -0,0 +1,206 @@
+---
+keywords: [InfluxDB Line Protocol, 数据写入, Telegraf 集成, 数据模型, 鉴权]
+description: 详细介绍如何使用 InfluxDB Line Protocol 将数据写入 GreptimeDB,包括协议、鉴权、Telegraf 集成和数据模型映射。
+---
+
+# InfluxDB Line Protocol
+
+GreptimeDB 支持 HTTP InfluxDB Line 协议。
+
+## 写入新数据
+
+### 协议
+
+#### Post 指标
+
+你可以通过 `/influxdb/write` API 写入数据。
+以下是一个示例:
+
+
+
+
+
+```shell
+curl -i -XPOST "http://localhost:4000/v1/influxdb/api/v2/write?db=public&precision=ms" \
+--data-binary \
+'monitor,host=127.0.0.1 cpu=0.1,memory=0.4 1667446797450
+ monitor,host=127.0.0.2 cpu=0.2,memory=0.3 1667446798450
+ monitor,host=127.0.0.1 cpu=0.5,memory=0.2 1667446798450'
+```
+
+
+
+
+```shell
+curl -i -XPOST "http://localhost:4000/v1/influxdb/write?db=public&precision=ms" \
+--data-binary \
+'monitor,host=127.0.0.1 cpu=0.1,memory=0.4 1667446797450
+ monitor,host=127.0.0.2 cpu=0.2,memory=0.3 1667446798450
+ monitor,host=127.0.0.1 cpu=0.5,memory=0.2 1667446798450'
+```
+
+
+
+
+`/influxdb/write` 支持查询参数,包括:
+
+* `db`:指定要写入的数据库。默认值为 `public`。
+* `precision`:定义请求体中提供的时间戳的精度,可接受的值为 `ns`(纳秒)、`us`(微秒)、`ms`(毫秒)和 `s`(秒),默认值为 `ns`(纳秒)。该 API 写入的时间戳类型为 `TimestampNanosecond`,因此默认精度为 `ns`(纳秒)。如果你在请求体中使用了其他精度的的时间戳,需要使用此参数指定精度。该参数确保时间戳能够被准确解释并以纳秒精度存储。
+
+你还可以在发送请求时省略 timestamp,GreptimeDB 将使用主机机器的当前系统时间(UTC 时间)作为 timestamp。例如:
+
+
+
+
+
+```shell
+curl -i -XPOST "http://localhost:4000/v1/influxdb/api/v2/write?db=public" \
+--data-binary \
+'monitor,host=127.0.0.1 cpu=0.1,memory=0.4
+ monitor,host=127.0.0.2 cpu=0.2,memory=0.3
+ monitor,host=127.0.0.1 cpu=0.5,memory=0.2'
+```
+
+
+
+
+```shell
+curl -i -XPOST "http://localhost:4000/v1/influxdb/write?db=public" \
+--data-binary \
+'monitor,host=127.0.0.1 cpu=0.1,memory=0.4
+ monitor,host=127.0.0.2 cpu=0.2,memory=0.3
+ monitor,host=127.0.0.1 cpu=0.5,memory=0.2'
+```
+
+
+
+
+#### 鉴权
+
+GreptimeDB 与 InfluxDB 的行协议鉴权格式兼容,包括 V1 和 V2。
+如果你在 GreptimeDB 中[配置了鉴权](/user-guide/deployments/authentication/overview.md),需要在 HTTP 请求中提供用户名和密码。
+
+
+
+
+
+InfluxDB 的 [V2 协议](https://docs.influxdata.com/influxdb/v1.8/tools/api/?t=Auth+Enabled#apiv2query-http-endpoint) 使用了类似 HTTP 标准 basic 认证方案的格式。
+
+```shell
+curl 'http://localhost:4000/v1/influxdb/api/v2/write?db=public' \
+ -H 'authorization: token :' \
+ -d 'monitor,host=127.0.0.1 cpu=0.1,memory=0.4'
+```
+
+
+
+
+
+对于 InfluxDB 的 [V1 协议](https://docs.influxdata.com/influxdb/v1.8/tools/api/?t=Auth+Enabled#query-string-parameters-1) 的鉴权格式。在 HTTP 查询字符串中添加 `u` 作为用户和 `p` 作为密码,如下所示:
+
+```shell
+curl 'http://localhost:4000/v1/influxdb/write?db=public&u=&p=' \
+ -d 'monitor,host=127.0.0.1 cpu=0.1,memory=0.4'
+```
+
+
+
+
+### Telegraf
+
+GreptimeDB 支持 [InfluxDB 行协议](../for-iot/influxdb-line-protocol.md)也意味着 GreptimeDB 与 Telegraf 兼容。
+要配置 Telegraf,只需将 GreptimeDB 的 URL 添加到 Telegraf 配置中:
+
+
+
+
+
+```toml
+[[outputs.influxdb_v2]]
+ urls = ["http://:4000/v1/influxdb"]
+ token = ":"
+ bucket = ""
+ ## Leave empty
+ organization = ""
+```
+
+
+
+
+
+```toml
+[[outputs.influxdb]]
+ urls = ["http://:4000/v1/influxdb"]
+ database = ""
+ username = ""
+ password = ""
+```
+
+
+
+
+
+## 数据模型
+
+你可能已经熟悉了 [InfluxDB 的关键概念](https://docs.influxdata.com/influxdb/v2/reference/key-concepts/),
+GreptimeDB 的[数据模型](/user-guide/concepts/data-model.md) 是值得了解的新事物。
+下方解释了 GreptimeDB 和 InfluxDB 数据模型的相似和不同之处:
+
+- 两者都是 [schemaless 写入](/user-guide/ingest-data/overview.md#自动生成表结构)的解决方案,这意味着在写入数据之前无需定义表结构。
+- GreptimeDB 的表在自动创建时会设置表选项 [`merge_mode`](/reference/sql/create.md#创建带有-merge-模式的表)为 `last_non_null`。
+ 这意味着表会通过保留每个字段的最新值来合并具有相同主键和时间戳的行,该行为与 InfluxDB 相同。
+- 在 InfluxDB 中,一个点代表一条数据记录,包含一个 measurement、tag 集、field 集和时间戳。
+ 在 GreptimeDB 中,它被表示为时间序列表中的一行数据。
+ 表名对应于 measurement,列由三种类型组成:Tag、Field 和 Timestamp。
+- GreptimeDB 使用 `TimestampNanosecond` 作为来自 [InfluxDB 行协议 API](/user-guide/ingest-data/for-iot/influxdb-line-protocol.md) 的时间戳数据类型。
+- GreptimeDB 使用 `Float64` 作为来自 InfluxDB 行协议 API 的数值数据类型。
+
+以 InfluxDB 文档中的[示例数据](https://docs.influxdata.com/influxdb/v2/reference/key-concepts/data-elements/#sample-data)为例:
+
+|_time|_measurement|location|scientist|_field|_value|
+|---|---|---|---|---|---|
+|2019-08-18T00:00:00Z|census|klamath|anderson|bees|23|
+|2019-08-18T00:00:00Z|census|portland|mullen|ants|30|
+|2019-08-18T00:06:00Z|census|klamath|anderson|bees|28|
+|2019-08-18T00:06:00Z|census|portland|mullen|ants|32|
+
+上述数据的 InfluxDB 行协议格式为:
+
+```shell
+census,location=klamath,scientist=anderson bees=23 1566086400000000000
+census,location=portland,scientist=mullen ants=30 1566086400000000000
+census,location=klamath,scientist=anderson bees=28 1566086760000000000
+census,location=portland,scientist=mullen ants=32 1566086760000000000
+```
+
+在 GreptimeDB 数据模型中,上述数据将被表示为 `census` 表中的以下内容:
+
+```sql
++---------------------+----------+-----------+------+------+
+| ts | location | scientist | bees | ants |
++---------------------+----------+-----------+------+------+
+| 2019-08-18 00:00:00 | klamath | anderson | 23 | NULL |
+| 2019-08-18 00:06:00 | klamath | anderson | 28 | NULL |
+| 2019-08-18 00:00:00 | portland | mullen | NULL | 30 |
+| 2019-08-18 00:06:00 | portland | mullen | NULL | 32 |
++---------------------+----------+-----------+------+------+
+```
+
+`census` 表结构如下:
+
+```sql
++-----------+----------------------+------+------+---------+---------------+
+| Column | Type | Key | Null | Default | Semantic Type |
++-----------+----------------------+------+------+---------+---------------+
+| location | String | PRI | YES | | TAG |
+| scientist | String | PRI | YES | | TAG |
+| bees | Float64 | | YES | | FIELD |
+| ts | TimestampNanosecond | PRI | NO | | TIMESTAMP |
+| ants | Float64 | | YES | | FIELD |
++-----------+----------------------+------+------+---------+---------------+
+```
+
+## 参考
+
+- [InfluxDB Line protocol](https://docs.influxdata.com/influxdb/v2.7/reference/syntax/line-protocol/)
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/kafka.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/kafka.md
new file mode 100644
index 000000000..bde191ee7
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/kafka.md
@@ -0,0 +1,9 @@
+---
+keywords: [Kafka, 数据写入]
+description: 将数据从 Kafka 写入到 GreptimeDB.
+---
+
+# Kafka
+
+请参考 [Kafka 文档](/user-guide/ingest-data/for-observerbility/kafka.md)了解如何将数据从 Kafka 写入到 GreptimeDB。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/opentsdb.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/opentsdb.md
new file mode 100644
index 000000000..3cf67ebd0
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/opentsdb.md
@@ -0,0 +1,61 @@
+---
+keywords: [OpenTSDB, HTTP API, 数据写入, 示例代码, 注意事项]
+description: 介绍如何使用 OpenTSDB 协议通过 HTTP API 将数据写入 GreptimeDB,包括示例代码和注意事项。
+---
+
+# OpenTSDB
+
+GreptimeDB支持通过 HTTP API 使用 OpenTSDB 协议。
+
+## 写入新数据
+
+### HTTP API
+
+GreptimeDB 还支持通过 HTTP 接口插入 OpenTSDB 数据,接口是 `/opentsdb/api/put`,使用的请求和响应格式与 OpenTSDB 的 `/api/put` 接口相同。
+
+GreptimeDB 的 HTTP Server 默认监听 `4000` 端口。例如使用 curl 写入一个指标数据:
+
+```shell
+curl -X POST http://127.0.0.1:4000/v1/opentsdb/api/put -d '
+{
+ "metric": "sys.cpu.nice",
+ "timestamp": 1667898896,
+ "value": 18,
+ "tags": {
+ "host": "web01",
+ "dc": "hz"
+ }
+}
+'
+```
+
+插入多个指标数据:
+
+```shell
+curl -X POST http://127.0.0.1:4000/v1/opentsdb/api/put -d '
+[
+ {
+ "metric": "sys.cpu.nice",
+ "timestamp": 1667898896,
+ "value": 1,
+ "tags": {
+ "host": "web02",
+ "dc": "hz"
+ }
+ },
+ {
+ "metric": "sys.cpu.nice",
+ "timestamp": 1667898897,
+ "value": 9,
+ "tags": {
+ "host": "web03",
+ "dc": "sh"
+ }
+ }
+]
+'
+```
+
+:::tip 注意
+记得在路径前加上 GreptimeDB 的 HTTP API 版本 `v1`。
+:::
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/overview.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/overview.md
new file mode 100644
index 000000000..69714baf4
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/overview.md
@@ -0,0 +1,20 @@
+---
+keywords: [物联网, 数据写入, SQL, gRPC SDK, InfluxDB Line Protocol, EMQX, OpenTSDB]
+description: 概述 GreptimeDB 支持的各种数据写入方法,包括 SQL、gRPC SDK、InfluxDB Line Protocol、EMQX 和 OpenTSDB。
+---
+
+# 概述
+
+数据的写入是物联网数据流程的关键部分。
+它从各种来源(如传感器、设备和应用程序)收集数据并将其存储在中央位置以供进一步处理和分析。
+数据写入过程对于确保数据的准确性、可靠性和安全性至关重要。
+
+GreptimeDB 可处理并存储超大规模量级的数据以供分析,
+支持各种数据格式、协议和接口,以便集成不同的物联网设备和系统。
+
+- [SQL INSERT](sql.md):简单直接的数据插入方法。
+- [gRPC SDK](./grpc-sdks/overview.md):提供高效、高性能的数据写入,特别适用于实时数据和复杂的物联网基础设施。
+- [InfluxDB Line Protocol](influxdb-line-protocol.md):一种广泛使用的时间序列数据协议,便于从 InfluxDB 迁移到 GreptimeDB。该文档同样介绍了 Telegraf 的集成方式。
+- [EMQX](emqx.md):支持大规模设备连接的 MQTT 代理,可直接将数据写入到 GreptimeDB。
+- [OpenTSDB](opentsdb.md):使用 OpenTSDB 协议将数据写入到 GreptimeDB。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/sql.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/sql.md
new file mode 100644
index 000000000..fc66f8916
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-iot/sql.md
@@ -0,0 +1,119 @@
+---
+keywords: [SQL, 数据写入, 创建表, 插入数据, 时区设置]
+description: 介绍如何使用 SQL 将数据写入 GreptimeDB,包括创建表、插入数据和时区设置等内容。
+---
+
+# SQL
+
+你可以使用 [MySQL](/user-guide/protocols/mysql.md) 或 [PostgreSQL](/user-guide/protocols/postgresql.md) 客户端执行 SQL 语句,
+使用任何你喜欢的编程语言(如Java JDBC)通过 MySQL 或 PostgreSQL 协议访问 GreptimeDB。
+
+我们将使用 `monitor` 表作为示例来展示如何写入数据。有关如何创建 `monitor` 表的 SQL 示例,请参见[表管理](/user-guide/administration/manage-data/basic-table-operations.md#创建表)。
+
+## 创建表
+
+在插入数据之前,你需要创建一个表。例如,创建一个名为 `monitor` 的表:
+
+```sql
+CREATE TABLE monitor (
+ host STRING,
+ ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP() TIME INDEX,
+ cpu FLOAT64 DEFAULT 0,
+ memory FLOAT64,
+ PRIMARY KEY(host));
+```
+
+上述语句将创建一个具有以下 schema 的表:
+
+```sql
++--------+----------------------+------+------+---------------------+---------------+
+| Column | Type | Key | Null | Default | Semantic Type |
++--------+----------------------+------+------+---------------------+---------------+
+| host | String | PRI | YES | | TAG |
+| ts | TimestampMillisecond | PRI | NO | current_timestamp() | TIMESTAMP |
+| cpu | Float64 | | YES | 0 | FIELD |
+| memory | Float64 | | YES | | FIELD |
++--------+----------------------+------+------+---------------------+---------------+
+4 rows in set (0.01 sec)
+```
+
+有关 `CREATE TABLE` 语句的更多信息,请参阅[表管理](/user-guide/administration/manage-data/basic-table-operations.md#create-a-table)。
+
+## 插入数据
+
+让我们向 `monitor` 表中插入一些测试数据。你可以使用 `INSERT INTO` 语句:
+
+```sql
+INSERT INTO monitor
+VALUES
+ ("127.0.0.1", 1702433141000, 0.5, 0.2),
+ ("127.0.0.2", 1702433141000, 0.3, 0.1),
+ ("127.0.0.1", 1702433146000, 0.3, 0.2),
+ ("127.0.0.2", 1702433146000, 0.2, 0.4),
+ ("127.0.0.1", 1702433151000, 0.4, 0.3),
+ ("127.0.0.2", 1702433151000, 0.2, 0.4);
+```
+
+```sql
+Query OK, 6 rows affected (0.01 sec)
+```
+
+你还可以插入数据时指定列名:
+
+```sql
+INSERT INTO monitor (host, ts, cpu, memory)
+VALUES
+ ("127.0.0.1", 1702433141000, 0.5, 0.2),
+ ("127.0.0.2", 1702433141000, 0.3, 0.1),
+ ("127.0.0.1", 1702433146000, 0.3, 0.2),
+ ("127.0.0.2", 1702433146000, 0.2, 0.4),
+ ("127.0.0.1", 1702433151000, 0.4, 0.3),
+ ("127.0.0.2", 1702433151000, 0.2, 0.4);
+```
+
+通过上面的语句,我们成功的向 `monitor` 表中插入了六条数据。请参考 [`INSERT`](/reference/sql/insert.md) 获得更多写入数据的相关信息。
+
+## 时区
+
+SQL 客户端中指定的时区将影响没有时区信息的字符串格式的时间戳。
+该时间戳值将会自动添加客户端的时区信息。
+
+例如,下面的 SQL 将时区设置为 `+8:00`:
+
+```sql
+SET time_zone = '+8:00';
+```
+
+然后向 `monitor` 表中插入值:
+
+```sql
+INSERT INTO monitor (host, ts, cpu, memory)
+VALUES
+ ("127.0.0.1", "2024-01-01 00:00:00", 0.4, 0.1),
+ ("127.0.0.2", "2024-01-01 00:00:00+08:00", 0.5, 0.1);
+```
+
+第一个时间戳值 `2024-01-01 00:00:00` 没有时区信息,因此它将自动添加客户端的时区信息。
+在插入数据后,它将等同于第二个值 `2024-01-01 00:00:00+08:00`。
+
+`+8:00` 时区下的结果如下:
+
+```sql
++-----------+---------------------+------+--------+
+| host | ts | cpu | memory |
++-----------+---------------------+------+--------+
+| 127.0.0.1 | 2024-01-01 00:00:00 | 0.4 | 0.1 |
+| 127.0.0.2 | 2024-01-01 00:00:00 | 0.5 | 0.1 |
++-----------+---------------------+------+--------+
+```
+
+`UTC` 时区下的结果如下:
+
+```sql
++-----------+---------------------+------+--------+
+| host | ts | cpu | memory |
++-----------+---------------------+------+--------+
+| 127.0.0.1 | 2023-12-31 16:00:00 | 0.4 | 0.1 |
+| 127.0.0.2 | 2023-12-31 16:00:00 | 0.5 | 0.1 |
++-----------+---------------------+------+--------+
+```
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/alloy.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/alloy.md
new file mode 100644
index 000000000..7b33a5999
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/alloy.md
@@ -0,0 +1,120 @@
+---
+keywords: [Grafana Alloy, Prometheus Remote Write, OpenTelemetry, 数据管道]
+description: 绍了如何将 GreptimeDB 配置为 Grafana Alloy 的数据接收端,包括 Prometheus Remote Write 和 OpenTelemetry 的配置示例。通过这些配置,你可以将 GreptimeDB 集成到可观测性数据管道中,实现对指标和日志的高效管理和分析。
+---
+
+# Grafana Alloy
+
+[Grafana Alloy](https://grafana.com/docs/alloy/latest/) 是一个用于 OpenTelemetry (OTel)、Prometheus、Pyroscope、Loki 等其他指标、日志、追踪和分析工具的可观测性数据管道。
+你可以将 GreptimeDB 集成为 Alloy 的数据接收端。
+
+## Prometheus Remote Write
+
+将 GreptimeDB 配置为远程写入目标:
+
+```hcl
+prometheus.remote_write "greptimedb" {
+ endpoint {
+ url = "${GREPTIME_SCHEME:=http}://${GREPTIME_HOST:=greptimedb}:${GREPTIME_PORT:=4000}/v1/prometheus/write?db=${GREPTIME_DB:=public}"
+
+ basic_auth {
+ username = "${GREPTIME_USERNAME}"
+ password = "${GREPTIME_PASSWORD}"
+ }
+ }
+}
+```
+
+- `GREPTIME_HOST`: GreptimeDB 主机地址,例如 `localhost`。
+- `GREPTIME_DB`: GreptimeDB 数据库名称,默认是 `public`。
+- `GREPTIME_USERNAME` 和 `GREPTIME_PASSWORD`: GreptimeDB的[鉴权认证信息](/user-guide/deployments/authentication/static.md)。
+
+有关从 Prometheus 到 GreptimeDB 的数据模型转换的详细信息,请参阅 Prometheus Remote Write 指南中的[数据模型](/user-guide/ingest-data/for-observerbility/prometheus.md#数据模型)部分。
+
+## OpenTelemetry
+
+GreptimeDB 也可以配置为 OpenTelemetry Collector 的目标。
+
+### 指标
+
+```hcl
+otelcol.exporter.otlphttp "greptimedb" {
+ client {
+ endpoint = "${GREPTIME_SCHEME:=http}://${GREPTIME_HOST:=greptimedb}:${GREPTIME_PORT:=4000}/v1/otlp/"
+ headers = {
+ "X-Greptime-DB-Name" = "${GREPTIME_DB:=public}",
+ }
+ auth = otelcol.auth.basic.credentials.handler
+ }
+}
+
+otelcol.auth.basic "credentials" {
+ username = "${GREPTIME_USERNAME}"
+ password = "${GREPTIME_PASSWORD}"
+}
+```
+
+- `GREPTIME_HOST`: GreptimeDB 主机地址,例如 `localhost`。
+- `GREPTIME_DB`: GreptimeDB 数据库名称,默认是 `public`。
+- `GREPTIME_USERNAME` 和 `GREPTIME_PASSWORD`: GreptimeDB 的[鉴权认证信息](/user-guide/deployments/authentication/static.md)。
+
+有关从 OpenTelemetry 到 GreptimeDB 的指标数据模型转换的详细信息,请参阅 OpenTelemetry 指南中的[数据模型](/user-guide/ingest-data/for-observerbility/opentelemetry.md#数据模型)部分。
+
+### 日志
+
+以下示例设置了一个使用 Loki 和 OpenTelemetry Collector (otelcol) 的日志管道,将日志转发到 GreptimeDB:
+
+```hcl
+loki.source.file "greptime" {
+ targets = [
+ {__path__ = "/tmp/foo.txt"},
+ ]
+ forward_to = [otelcol.receiver.loki.greptime.receiver]
+}
+
+otelcol.receiver.loki "greptime" {
+ output {
+ logs = [otelcol.exporter.otlphttp.greptimedb_logs.input]
+ }
+}
+
+otelcol.auth.basic "credentials" {
+ username = "${GREPTIME_USERNAME}"
+ password = "${GREPTIME_PASSWORD}"
+}
+
+otelcol.exporter.otlphttp "greptimedb_logs" {
+ client {
+ endpoint = "${GREPTIME_SCHEME:=http}://${GREPTIME_HOST:=greptimedb}:${GREPTIME_PORT:=4000}/v1/otlp/"
+ headers = {
+ "X-Greptime-DB-Name" = "${GREPTIME_DB:=public}",
+ "X-Greptime-Log-Table-Name" = "${LOG_TABLE_NAME}",
+ "X-Greptime-Gog-Extract-Keys" = "${EXTRACT_KEYS}",
+ }
+ auth = otelcol.auth.basic.credentials.handler
+ }
+}
+```
+
+- Loki source 配置
+ - `loki.source.file "greptime"` 块定义了 source,用于 Loki 从位于 `/tmp/foo.txt` 的文件中读取日志。
+ - `forward_to` 数组指示从该文件读取的日志应转发到 `otelcol.receiver.loki.greptime.receiver`。
+- OpenTelemetry Collector Receiver 配置:
+ - `otelcol.receiver.loki "greptime"` 在 OpenTelemetry Collector 中设置了一个 receiver,以接收来自 Loki 的日志。
+ - `output` 指定接收到的日志应转发到 `otelcol.exporter.otlphttp.greptimedb_logs.input`。
+- OpenTelemetry Collector Exporter 配置:
+ - `otelcol.exporter.otlphttp "greptimedb_logs"` 块配置了一个 HTTP Exporter,将日志发送到 GreptimeDB。
+ - `GREPTIME_HOST`: GreptimeDB 主机地址,例如 `localhost`。
+ - `GREPTIME_DB`: GreptimeDB 数据库名称,默认是 `public`。
+ - `GREPTIME_USERNAME` 和 `GREPTIME_PASSWORD`: GreptimeDB 的[鉴权认证信息](/user-guide/deployments/authentication/static.md)。
+ - `LOG_TABLE_NAME`: 存储日志的表名,默认表名为 `opentelemetry_logs`。
+ - `EXTRACT_KEYS`: 从属性中提取对应 key 的值到表的顶级字段,用逗号分隔,例如 `filename,log.file.name,loki.attribute.labels`,详情请看 [HTTP API 文档](opentelemetry.md#otlphttp-api-1)。
+
+有关从 OpenTelemetry 到 GreptimeDB 的日志数据模型转换的详细信息,请参阅 OpenTelemetry 指南中的[数据模型](/user-guide/ingest-data/for-observerbility/opentelemetry.md#数据模型-1)部分。
+
+:::tip 提示
+上述示例代码可能会过时,请参考 OpenTelemetry 和 Grafana Alloy 的官方文档以获取最新信息。
+:::
+
+有关示例代码的更多信息,请参阅你首选编程语言的官方文档。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/influxdb-line-protocol.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/influxdb-line-protocol.md
new file mode 100644
index 000000000..c353085db
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/influxdb-line-protocol.md
@@ -0,0 +1,4 @@
+# InfluxDB Line Protocol
+
+
+请参考 [InfluxDB Line Protocol 文档](../for-iot/influxdb-line-protocol.md) 了解如何使用 InfluxDB Line Protocol 将数据写入到 GreptimeDB。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/kafka.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/kafka.md
new file mode 100644
index 000000000..1cd1a3667
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/kafka.md
@@ -0,0 +1,170 @@
+---
+keywords: [Kafka, 数据提取, 可观察性, 指标, 日志, JSON 日志, 文本日志, Vector, InfluxDB 行协议]
+description: 了解如何使用 Vector 将可观察性数据从 Kafka 写入到 GreptimeDB。本指南涵盖指标和日志提取,包括 JSON 和文本日志格式,并附有详细的配置示例。
+---
+
+# Kafka
+
+如果你使用 Kafka 或兼容 Kafka 的消息队列进行可观测性数据传输,可以直接将数据写入到 GreptimeDB 中。
+
+这里我们使用 Vector 作为工具将数据从 Kafka 传输到 GreptimeDB。
+
+## 指标
+
+从 Kafka 写入指标到 GreptimeDB 时,消息应采用 InfluxDB 行协议格式。例如:
+
+```txt
+census,location=klamath,scientist=anderson bees=23 1566086400000000000
+```
+
+然后配置 Vector 使用 `influxdb` 解码器来处理这些消息。
+
+```toml
+[sources.metrics_mq]
+# 指定源类型为 Kafka
+type = "kafka"
+# Kafka 的消费者组 ID
+group_id = "vector0"
+# 要消费消息的 Kafka 主题列表
+topics = ["test_metric_topic"]
+# 要连接的 Kafka 地址
+bootstrap_servers = "kafka:9092"
+# `influxdb` 表示消息应采用 InfluxDB 行协议格式
+decoding.codec = "influxdb"
+
+[sinks.metrics_in]
+inputs = ["metrics_mq"]
+# 指定接收器类型为 `greptimedb_metrics`
+type = "greptimedb_metrics"
+# GreptimeDB 服务器的端点
+# 将 替换为实际的主机名或 IP 地址
+endpoint = ":4001"
+dbname = ""
+username = ""
+password = ""
+tls = {}
+```
+
+有关 InfluxDB 行协议指标如何映射到 GreptimeDB 数据的详细信息,请参阅 InfluxDB 行协议文档中的[数据模型](/user-guide/ingest-data/for-iot/influxdb-line-protocol.md#数据模型)部分。
+
+## 日志
+
+开发人员通常处理两种类型的日志:JSON 日志和纯文本日志。
+例如以下从 Kafka 发送的日志示例。
+
+纯文本日志:
+
+```txt
+127.0.0.1 - - [25/May/2024:20:16:37 +0000] "GET /index.html HTTP/1.1" 200 612 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+```
+
+或 JSON 日志:
+
+```json
+{
+ "timestamp": "2024-12-23T10:00:00Z",
+ "level": "INFO",
+ "message": "Service started"
+}
+```
+
+GreptimeDB 将这些日志转换为具有多个列的结构化数据,并自动创建必要的表。
+Pipeline 在写入到 GreptimeDB 之前将日志处理为结构化数据。
+不同的日志格式需要不同的 [Pipeline](/user-guide/logs/quick-start.md#write-logs-by-pipeline) 来解析,详情请继续阅读下面的内容。
+
+### JSON 格式的日志
+
+对于 JSON 格式的日志(例如 `{"timestamp": "2024-12-23T10:00:00Z", "level": "INFO", "message": "Service started"}`),
+你可以使用内置的 [`greptime_identity`](/user-guide/logs/manage-pipelines.md#greptime_identity) pipeline 直接写入日志。
+此 pipeline 根据 JSON 日志消息中的字段自动创建列。
+
+你只需要配置 Vector 的 `transforms` 设置以解析 JSON 消息,并使用 `greptime_identity` pipeline,如以下示例所示:
+
+```toml
+[sources.logs_in]
+type = "kafka"
+# Kafka 的消费者组 ID
+group_id = "vector0"
+# 要消费消息的 Kafka 主题列表
+topics = ["test_log_topic"]
+# 要连接的 Kafka 代理地址
+bootstrap_servers = "kafka:9092"
+
+# 将日志转换为 JSON 格式
+[transforms.logs_json]
+type = "remap"
+inputs = ["logs_in"]
+source = '''
+. = parse_json!(.message)
+'''
+
+[sinks.logs_out]
+# 指定此接收器将接收来自 `logs_json` 源的数据
+inputs = ["logs_json"]
+# 指定接收器类型为 `greptimedb_logs`
+type = "greptimedb_logs"
+# GreptimeDB 服务器的端点
+endpoint = "http://:4000"
+compression = "gzip"
+# 将 、 和 替换为实际值
+dbname = ""
+username = ""
+password = ""
+# GreptimeDB 中的表名,如果不存在,将自动创建
+table = "demo_logs"
+# 使用内置的 `greptime_identity` 管道
+pipeline_name = "greptime_identity"
+```
+
+### 文本格式的日志
+
+对于文本格式的日志,例如下面的访问日志格式,你需要创建自定义 pipeline 来解析它们:
+
+```
+127.0.0.1 - - [25/May/2024:20:16:37 +0000] "GET /index.html HTTP/1.1" 200 612 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+```
+
+#### 创建 pipeline
+
+要创建自定义 pipeline,
+请参阅[创建 pipeline](/user-guide/logs/quick-start.md#创建-pipeline) 和 [pipeline 配置](/user-guide/logs/pipeline-config.md)文档获取详细说明。
+
+#### 写入数据
+
+创建 pipeline 后,将其配置到 Vector 配置文件中的 `pipeline_name` 字段。
+
+```toml
+# sample.toml
+[sources.log_mq]
+# 指定源类型为 Kafka
+type = "kafka"
+# Kafka 的消费者组 ID
+group_id = "vector0"
+# 要消费消息的 Kafka 主题列表
+topics = ["test_log_topic"]
+# 要连接的 Kafka 地址
+bootstrap_servers = "kafka:9092"
+
+[sinks.sink_greptime_logs]
+# 指定接收器类型为 `greptimedb_logs`
+type = "greptimedb_logs"
+# 指定此接收器将接收来自 `log_mq` 源的数据
+inputs = [ "log_mq" ]
+# 使用 `gzip` 压缩以节省带宽
+compression = "gzip"
+# GreptimeDB 服务器的端点
+# 将 替换为实际的主机名或 IP 地址
+endpoint = "http://:4000"
+dbname = ""
+username = ""
+password = ""
+# GreptimeDB 中的表名,如果不存在,将自动创建
+table = "demo_logs"
+# 你创建的自定义管道名称
+pipeline_name = "your_custom_pipeline"
+```
+
+## Demo
+
+有关数据转换和写入的可运行演示,请参阅 [Kafka Ingestion Demo](https://github.com/GreptimeTeam/demo-scene/tree/main/kafka-ingestion)。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/loki.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/loki.md
new file mode 100644
index 000000000..cc52bcd03
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/loki.md
@@ -0,0 +1,127 @@
+---
+keywords: [Loki, 日志数据, API 信息, 示例代码, 数据模型]
+description: 介绍如何使用 Loki 将日志数据发送到 GreptimeDB,包括 API 信息、示例代码和数据模型映射。
+---
+
+# Loki
+
+## 使用方法
+
+### API
+
+要通过原始 HTTP API 将日志发送到 GreptimeDB,请使用以下信息:
+
+* URL: `http{s}:///v1/loki/api/v1/push`
+* Headers:
+ * `X-Greptime-DB-Name`: ``
+ * `Authorization`: `Basic` 认证,这是一个 Base64 编码的 `:` 字符串。更多信息,请参考 [认证](https://docs.greptime.com/user-guide/deployments/authentication/static/) 和 [HTTP API](https://docs.greptime.com/user-guide/protocols/http#authentication)。
+ * `X-Greptime-Log-Table-Name`: ``(可选)- 存储日志的表名。如果未提供,默认表名为 `loki_logs`。
+
+请求使用二进制 protobuf 编码负载,定义的格式与 [logproto.proto](https://github.com/grafana/loki/blob/main/pkg/logproto/logproto.proto) 相同。
+
+### 示例代码
+
+[Grafana Alloy](https://grafana.com/docs/alloy/latest/) 是一个供应商中立的 OpenTelemetry (OTel) Collector 发行版。Alloy 独特地结合了社区中最好的开源可观测性信号。
+
+它提供了一个 Loki 导出器,可以用来将日志发送到 GreptimeDB。以下是一个配置示例:
+
+```hcl
+loki.source.file "greptime" {
+ targets = [
+ {__path__ = "/tmp/foo.txt"},
+ ]
+ forward_to = [loki.write.greptime_loki.receiver]
+}
+
+loki.write "greptime_loki" {
+ endpoint {
+ url = "${GREPTIME_SCHEME:=http}://${GREPTIME_HOST:=greptimedb}:${GREPTIME_PORT:=4000}/v1/loki/api/v1/push"
+ headers = {
+ "x-greptime-db-name" = "${GREPTIME_DB:=public}",
+ "x-greptime-log-table-name" = "${GREPTIME_LOG_TABLE_NAME:=loki_demo_logs}",
+ }
+ }
+ external_labels = {
+ "job" = "greptime"
+ "from" = "alloy"
+ }
+}
+```
+
+我们监听文件 `/tmp/foo.txt` 并将日志发送到 GreptimeDB。日志存储在表 `loki_demo_logs` 中,并带有 label `job` 和 `from`。
+
+更多信息,请参考 [Grafana Alloy loki.write 文档](https://grafana.com/docs/alloy/latest/reference/components/loki/loki.write/)。
+
+你可以运行以下命令来检查表中的数据:
+
+```sql
+SELECT * FROM loki_demo_logs;
++----------------------------+------------------------+--------------+-------+----------+
+| greptime_timestamp | line | filename | from | job |
++----------------------------+------------------------+--------------+-------+----------+
+| 2024-11-25 11:02:31.256251 | Greptime is very cool! | /tmp/foo.txt | alloy | greptime |
++----------------------------+------------------------+--------------+-------+----------+
+1 row in set (0.01 sec)
+```
+
+## 数据模型
+
+Loki 日志数据模型根据以下规则映射到 GreptimeDB 数据模型:
+
+没有 label 的默认表结构:
+
+```sql
+DESC loki_demo_logs;
++--------------------+---------------------+------+------+---------+---------------+
+| Column | Type | Key | Null | Default | Semantic Type |
++--------------------+---------------------+------+------+---------+---------------+
+| greptime_timestamp | TimestampNanosecond | PRI | NO | | TIMESTAMP |
+| line | String | | YES | | FIELD |
++--------------------+---------------------+------+------+---------+---------------+
+5 rows in set (0.00 sec)
+```
+
+- greptime_timestamp: 日志的时间戳。
+- line: 日志消息。
+
+如果你指定了外部 label,我们会将它们添加为表结构中的 tag。例如上面的 `job` 和 `from`。
+在这种写入方式下不能手动指定,所有 label 都被视为 tag 并且类型为字符串。请不要尝试使用 SQL 提前创建表来指定 tag 列,这会导致类型不匹配而写入失败。
+
+### 示例
+
+以下是表结构的示例:
+
+```sql
+DESC loki_demo_logs;
++--------------------+---------------------+------+------+---------+---------------+
+| Column | Type | Key | Null | Default | Semantic Type |
++--------------------+---------------------+------+------+---------+---------------+
+| greptime_timestamp | TimestampNanosecond | PRI | NO | | TIMESTAMP |
+| line | String | | YES | | FIELD |
+| filename | String | PRI | YES | | TAG |
+| from | String | PRI | YES | | TAG |
+| job | String | PRI | YES | | TAG |
++--------------------+---------------------+------+------+---------+---------------+
+5 rows in set (0.00 sec)
+```
+
+```sql
+SHOW CREATE TABLE loki_demo_logs\G
+*************************** 1. row ***************************
+ Table: loki_demo_logs
+Create Table: CREATE TABLE IF NOT EXISTS `loki_demo_logs` (
+ `greptime_timestamp` TIMESTAMP(9) NOT NULL,
+ `line` STRING NULL,
+ `filename` STRING NULL,
+ `from` STRING NULL,
+ `job` STRING NULL,
+ TIME INDEX (`greptime_timestamp`),
+ PRIMARY KEY (`filename`, `from`, `job`)
+)
+
+ENGINE=mito
+WITH(
+ append_mode = 'true'
+)
+1 row in set (0.00 sec)
+```
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/opentelemetry.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/opentelemetry.md
new file mode 100644
index 000000000..f3b5e5b64
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/opentelemetry.md
@@ -0,0 +1,188 @@
+---
+keywords: [OpenTelemetry, OTLP, metrics, logs, 数据模型]
+description: 介绍如何使用 OpenTelemetry Protocol (OTLP) 将观测数据(如 metrics 和 logs)导出到 GreptimeDB,包括示例代码和数据模型的映射规则。
+---
+
+# OpenTelemetry Protocol (OTLP)
+
+[OpenTelemetry](https://opentelemetry.io/) 是一个供应商中立的开源可观测性框架,用于检测、生成、收集和导出观测数据,例如 traces, metrics 和 logs。
+OpenTelemetry Protocol (OTLP) 定义了观测数据在观测源和中间进程(例如收集器和观测后端)之间的编码、传输机制。
+
+## OpenTelemetry Collectors
+
+你可以很简单地将 GreptimeDB 配置为 OpenTelemetry Collector 的目标。
+有关更多信息,请参阅 [Grafana Alloy](alloy.md) 示例。
+
+## Metrics
+
+GreptimeDB 通过原生支持 [OTLP/HTTP](https://opentelemetry.io/docs/specs/otlp/#otlphttp) 协议,可以作为后端存储服务来接收 OpenTelemetry 指标数据。
+
+### OTLP/HTTP API
+
+使用下面的信息通过 Opentelemetry SDK 库发送 Metrics 到 GreptimeDB:
+
+* URL: `https:///v1/otlp/v1/metrics`
+* Headers:
+ * `X-Greptime-DB-Name`: ``
+* `Authorization`: `Basic` 认证,是 `:` 的 Base64 编码字符串。更多信息请参考 [鉴权](https://docs.greptime.cn/user-guide/deployments/authentication/static/) 和 [HTTP API](https://docs.greptime.cn/user-guide/protocols/http#authentication)。
+
+请求中使用 binary protobuf 编码 payload,因此你需要使用支持 `HTTP/protobuf` 的包。例如,在 Node.js 中,可以使用 [`exporter-trace-otlp-proto`](https://www.npmjs.com/package/@opentelemetry/exporter-trace-otlp-proto);在 Go 中,可以使用 [`go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp);在 Java 中,可以使用 [`io.opentelemetry:opentelemetry-exporter-otlp`](https://mvnrepository.com/artifact/io.opentelemetry/opentelemetry-exporter-otlp);在 Python 中,可以使用 [`opentelemetry-exporter-otlp-proto-http`](https://pypi.org/project/opentelemetry-exporter-otlp-proto-http/)。
+
+:::tip 注意
+包名可能会根据 OpenTelemetry 的发展发生变化,因此建议你参考 OpenTelemetry 官方文档以获取最新信息。
+:::
+
+请参考 Opentelementry 的官方文档获取它所支持的编程语言的更多信息。
+
+### 示例代码
+
+下面是一些编程语言设置请求的示例代码:
+
+
+
+
+
+```ts
+const auth = Buffer.from(`${username}:${password}`).toString('base64')
+const exporter = new OTLPMetricExporter({
+ url: `https://${dbHost}/v1/otlp/v1/metrics`,
+ headers: {
+ Authorization: `Basic ${auth}`,
+ "X-Greptime-DB-Name": db,
+ },
+ timeoutMillis: 5000,
+})
+```
+
+
+
+
+
+```Go
+auth := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", *username, *password)))
+exporter, err := otlpmetrichttp.New(
+ context.Background(),
+ otlpmetrichttp.WithEndpoint(*dbHost),
+ otlpmetrichttp.WithURLPath("/v1/otlp/v1/metrics"),
+ otlpmetrichttp.WithHeaders(map[string]string{
+ "X-Greptime-DB-Name": *dbName,
+ "Authorization": "Basic " + auth,
+ }),
+ otlpmetrichttp.WithTimeout(time.Second*5),
+)
+```
+
+
+
+
+
+```Java
+String endpoint = String.format("https://%s/v1/otlp/v1/metrics", dbHost);
+String auth = username + ":" + password;
+String b64Auth = new String(Base64.getEncoder().encode(auth.getBytes()));
+OtlpHttpMetricExporter exporter = OtlpHttpMetricExporter.builder()
+ .setEndpoint(endpoint)
+ .addHeader("X-Greptime-DB-Name", db)
+ .addHeader("Authorization", String.format("Basic %s", b64Auth))
+ .setTimeout(Duration.ofSeconds(5))
+ .build();
+```
+
+
+
+
+
+```python
+auth = f"{username}:{password}"
+b64_auth = base64.b64encode(auth.encode()).decode("ascii")
+endpoint = f"https://{host}/v1/otlp/v1/metrics"
+exporter = OTLPMetricExporter(
+ endpoint=endpoint,
+ headers={"Authorization": f"Basic {b64_auth}", "X-Greptime-DB-Name": db},
+ timeout=5)
+```
+
+
+
+
+
+你可以在 Github 中找到可执行的 Demo:[Go](https://github.com/GreptimeCloudStarters/quick-start-go), [Java](https://github.com/GreptimeCloudStarters/quick-start-java), [Python](https://github.com/GreptimeCloudStarters/quick-start-python), and [Node.js](https://github.com/GreptimeCloudStarters/quick-start-node-js).
+
+:::tip 注意
+示例代码可能会根据 OpenTelemetry 的发展发生变化,因此建议你参考 OpenTelemetry 官方文档以获取最新信息。
+:::
+
+关于示例代码,请参考 Opentelementry 的官方文档获取它所支持的编程语言获取更多信息。
+
+### 数据模型
+
+OTLP 指标数据模型按照下方的规则被映射到 GreptimeDB 数据模型中:
+
+- Metric 的名称将被作为 GreptimeDB 表的名称,当表不存在时会自动创建。
+- 所有的 Attribute ,包含 resource 级别、scope 级别和 data_point 级别,都被作为 GreptimeDB 表的 tag 列。
+- 数据点的时间戳被作为 GreptimeDB 的时间戳索引,列名 `greptime_timestamp`。
+- Gauge/Sum 两种类型的数据点数据被作为 field 列,列名 `greptime_value`。
+- Summary 类型的每个 quantile 被作为单独的数据列,列名 `greptime_pxx`,其中 xx 是 quantile 的数据,如 90 / 99 等。
+- Histogram 和 ExponentialHistogram 暂时未被支持,我们可能在后续版本中推出 Histogram 数据类型来原生支持这两种类型。
+
+## Logs
+
+GreptimeDB 是能够通过 [OTLP/HTTP](https://opentelemetry.io/docs/specs/otlp/#otlphttp) 协议原生地消费 OpenTelemetry 日志。
+
+### OTLP/HTTP API
+
+要通过 OpenTelemetry SDK 库将 OpenTelemetry 日志发送到 GreptimeDB,请使用以下信息:
+
+* **URL:** `https:///v1/otlp/v1/logs`
+* **Headers:**
+ * `X-Greptime-DB-Name`: ``
+ * `Authorization`: `Basic` 认证,这是一个 Base64 编码的 `:` 字符串。更多信息,请参考 [鉴权](/user-guide/deployments/authentication/static.md) 和 [HTTP API](/user-guide/protocols/http.md#鉴权)。
+ * `X-Greptime-Log-Table-Name`: ``(可选)- 存储日志的表名。如果未提供,默认表名为 `opentelemetry_logs`。
+ * `X-Greptime-Log-Extract-Keys`: ``(可选)- 从属性中提取对应 key 的值到表的顶级字段。key 应以逗号(`,`)分隔。例如,`key1,key2,key3` 将从属性中提取 `key1`、`key2` 和 `key3`,并将它们提升到日志的顶层,设置为标签。如果提取的字段类型是数组、浮点数或对象,将返回错误。如果提供了 pipeline name,此设置将被忽略。
+ * `X-Greptime-Log-Pipeline-Name`: ``(可选)- 处理日志的 pipeline 名称。如果未提供,将使用 `X-Greptime-Log-Extract-Keys` 来处理日志。
+ * `X-Greptime-Log-Pipeline-Version`: ``(可选)- 处理日志的 pipeline 的版本。如果未提供,将使用 pipeline 的最新版本。
+
+请求使用二进制 protobuf 编码负载,因此您需要使用支持 `HTTP/protobuf` 的包。
+
+:::tip 提示
+包名可能会根据 OpenTelemetry 的更新而变化,因此我们建议您参考官方 OpenTelemetry 文档以获取最新信息。
+:::
+
+有关 OpenTelemetry SDK 的更多信息,请参考您首选编程语言的官方文档。
+
+### 示例代码
+
+请参考 [Alloy 文档](alloy.md#日志)中的示例代码,了解如何将 OpenTelemetry 日志发送到 GreptimeDB。
+
+### 数据模型
+
+OTLP 日志数据模型根据以下规则映射到 GreptimeDB 数据模型:
+
+默认表结构:
+
+```sql
++-----------------------+---------------------+------+------+---------+---------------+
+| Column | Type | Key | Null | Default | Semantic Type |
++-----------------------+---------------------+------+------+---------+---------------+
+| timestamp | TimestampNanosecond | PRI | NO | | TIMESTAMP |
+| trace_id | String | | YES | | FIELD |
+| span_id | String | | YES | | FIELD |
+| severity_text | String | | YES | | FIELD |
+| severity_number | Int32 | | YES | | FIELD |
+| body | String | | YES | | FIELD |
+| log_attributes | Json | | YES | | FIELD |
+| trace_flags | UInt32 | | YES | | FIELD |
+| scope_name | String | PRI | YES | | TAG |
+| scope_version | String | | YES | | FIELD |
+| scope_attributes | Json | | YES | | FIELD |
+| scope_schema_url | String | | YES | | FIELD |
+| resource_attributes | Json | | YES | | FIELD |
+| resource_schema_url | String | | YES | | FIELD |
++-----------------------+---------------------+------+------+---------+---------------+
+17 rows in set (0.00 sec)
+```
+
+- 您可以使用 `X-Greptime-Log-Table-Name` 指定存储日志的表名。如果未提供,默认表名为 `opentelemetry_logs`。
+- 所有属性,包括资源属性、范围属性和日志属性,将作为 JSON 列存储在 GreptimeDB 表中。
+- 日志的时间戳将用作 GreptimeDB 中的时间戳索引,列名为 `timestamp`。建议使用 `time_unix_nano` 作为时间戳列。如果未提供 `time_unix_nano`,将使用 `observed_time_unix_nano`。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/overview.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/overview.md
new file mode 100644
index 000000000..d640e4de5
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/overview.md
@@ -0,0 +1,16 @@
+---
+keywords: [可观测性, Prometheus, Vector, OpenTelemetry, InfluxDB Line Protocol]
+description: 介绍 GreptimeDB 在可观测性场景中的应用,包括与 Prometheus、Vector、OpenTelemetry 和 InfluxDB Line Protocol 的集成。
+---
+
+# 概述
+
+在可观测性场景中,实时监控和分析系统性能的能力至关重要。
+GreptimeDB 与领先的可观测性工具无缝集成,为你提供系统健康和性能指标的全面视图。
+
+- [Prometheus Remote Write](prometheus.md):将 GreptimeDB 作为 Prometheus 的远程存储,适用于实时监控和警报。
+- [Vector](vector.md):将 GreptimeDB 用作 Vector 的接收端,适用于复杂的数据流水线和多样化的数据源。
+- [OpenTelemetry](opentelemetry.md):将 telemetry 数据收集并导出到 GreptimeDB,以获取详细的可观测性洞察。
+- [InfluxDB Line Protocol](influxdb-line-protocol.md):一种广泛使用的时间序列数据协议,便于从 InfluxDB 迁移到 GreptimeDB。该文档同样介绍了 Telegraf 的集成方式。
+- [Loki](loki.md):一种广泛使用的日志写入协议,便于从 Loki 迁移到 GreptimeDB。本文档还介绍了 Alloy 集成方法。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/prometheus.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/prometheus.md
new file mode 100644
index 000000000..184744eac
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/prometheus.md
@@ -0,0 +1,161 @@
+---
+keywords: [Prometheus, 长期存储, Remote Write, 数据模型, 配置示例]
+description: 介绍如何将 GreptimeDB 作为 Prometheus 的长期存储解决方案,包括配置 Remote Write 和数据模型的映射规则。
+---
+
+# Prometheus
+
+GreptimeDB 可以作为 Prometheus 的长期存储解决方案,提供无缝集成体验。
+
+## 配置 Remote Write
+
+### Prometheus 配置文件
+
+要将 GreptimeDB 集成到 Prometheus 中,
+请按照以下步骤更新你的 [Prometheus 配置文件](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#configuration-file)(`prometheus.yml`):
+
+```yaml
+remote_write:
+- url: http://localhost:4000/v1/prometheus/write?db=public
+# 如果启用了身份验证,请取消注释并设置鉴权信息
+# basic_auth:
+# username: greptime_user
+# password: greptime_pwd
+
+remote_read:
+- url: http://localhost:4000/v1/prometheus/read?db=public
+# 如果启用了身份验证,请取消注释并设置鉴权信息
+# basic_auth:
+# username: greptime_user
+# password: greptime_pwd
+```
+
+- URL 中的 host 和 port 表示 GreptimeDB 服务器。在此示例中,服务器运行在 `localhost:4000` 上。你可以将其替换为你自己的服务器地址。有关 GreptimeDB 中 HTTP 协议的配置,请参阅 [协议选项](/user-guide/deployments/configuration.md#protocol-options)。
+- URL 中的 `db` 参数表示要写入的数据库。它是可选的。默认情况下,数据库设置为 `public`。
+- `basic_auth` 是身份鉴权配置。如果 GreptimeDB 启用了鉴权,请填写用户名和密码。请参阅 [鉴权认证文档](/user-guide/deployments/authentication/overview.md)。
+
+### Grafana Alloy 配置文件
+
+如果你使用 Grafana Alloy,请在 Alloy 配置文件(`config.alloy`)中配置 Remote Write。有关更多信息,请参阅 [Alloy 文档](alloy.md#prometheus-remote-write)。
+
+## 数据模型
+
+在 GreptimeDB 的[数据模型](/user-guide/concepts/data-model.md)中,数据被组织成具有 tag、time index 和 field 的表。
+GreptimeDB 可以被视为多值数据模型,自动将多个 Prometheus 指标分组到相应的表中。
+这样可以实现高效的数据管理和查询。
+
+![数据模型](/PromQL-multi-value-data-model.png)
+
+当指标通过远程写入端点写入 GreptimeDB 时,它们将被转换为以下形式:
+
+| Sample Metrics | In GreptimeDB | GreptimeDB Data Types |
+|----------------|---------------------------|-----------------------|
+| Name | Table (Auto-created) Name | String |
+| Value | Column (Field) | Double |
+| Timestamp | Column (Time Index) | Timestamp |
+| Label | Column (Tag) | String |
+
+例如,以下 Prometheus 指标:
+
+```txt
+prometheus_remote_storage_samples_total{instance="localhost:9090", job="prometheus",
+remote_name="648f0c", url="http://localhost:4000/v1/prometheus/write"} 500
+```
+
+将被转换为表 `prometheus_remote_storage_samples_total` 中的一行:
+
+| Column | Value | Column Data Type |
+| :----------------- | :------------------------------------------ | :----------------- |
+| instance | localhost:9090 | String |
+| job | prometheus | String |
+| remote_name | 648f0c | String |
+| url | `http://localhost:4000/v1/prometheus/write` | String |
+| greptime_value | 500 | Double |
+| greptime_timestamp | The sample's unix timestamp | Timestamp |
+
+
+## 通过使用 metric engine 提高效率
+
+Prometheus Remote Write 写入数据的方式经常会创建大量的小表,这些表在 GreptimeDB 中被归类为逻辑表。
+然而,拥有大量的小表对于数据存储和查询性能来说是低效的。
+为了解决这个问题,GreptimeDB 引入了 [metric engine](/contributor-guide/datanode/metric-engine.md) 功能,将逻辑表表示的数据存储在单个物理表中。
+这种方法减少了存储开销并提高了列式压缩效率。
+
+GreptimeDB 默认启用 metric engine,你不需要指定任何额外的配置。
+默认情况下,使用的物理表为 `greptime_physical_table`。
+如果你想使用特定的物理表,可以在 Remote Write URL 中指定 `physical_table` 参数。
+如果指定的物理表不存在,它将被自动创建。
+
+```yaml
+remote_write:
+- url: http://localhost:4000/v1/prometheus/write?db=public&physical_table=greptime_physical_table
+```
+
+虽然数据被存储在物理表中,但查询可以在逻辑表上执行以提供从指标角度的直观视角。
+例如,当成功写入数据时,你可以使用以下命令显示逻辑表:
+
+```sql
+show tables;
+```
+
+```sql
++---------------------------------------------------------------+
+| Tables |
++---------------------------------------------------------------+
+| prometheus_remote_storage_enqueue_retries_total |
+| prometheus_remote_storage_exemplars_pending |
+| prometheus_remote_storage_read_request_duration_seconds_count |
+| prometheus_rule_group_duration_seconds |
+| ...... |
++---------------------------------------------------------------+
+```
+
+物理表本身也可以进行查询。
+它包含了所有逻辑表的列,方便进行多表连接分析和计算。
+
+要查看物理表的 schema,请使用 `DESC TABLE` 命令:
+
+```sql
+DESC TABLE greptime_physical_table;
+```
+
+物理表包含了所有逻辑表的列:
+
+```sql
++--------------------+----------------------+------+------+---------+---------------+
+| Column | Type | Key | Null | Default | Semantic Type |
++--------------------+----------------------+------+------+---------+---------------+
+| greptime_timestamp | TimestampMillisecond | PRI | NO | | TIMESTAMP |
+| greptime_value | Float64 | | YES | | FIELD |
+| __table_id | UInt32 | PRI | NO | | TAG |
+| __tsid | UInt64 | PRI | NO | | TAG |
+| device | String | PRI | YES | | TAG |
+| instance | String | PRI | YES | | TAG |
+| job | String | PRI | YES | | TAG |
+| error | String | PRI | YES | | TAG |
+...
+```
+
+你可以使用 `SELECT` 语句根据需要从物理表中过滤数据。
+例如,根据逻辑表 A 的 `device` 条件和逻辑表 B 的 `job` 条件来过滤数据:
+
+```sql
+SELECT *
+FROM greptime_physical_table
+WHERE greptime_timestamp > "2024-08-07 03:27:26.964000"
+ AND device = "device1"
+ AND job = "job1";
+```
+
+## VictoriaMetrics Remote Write
+
+VictoriaMetrics 对 Prometheus 远程写入协议进行了轻微修改,以实现更好的压缩效果。
+当你使用 `vmagent` 将数据发送到兼容的后端时,该协议会被自动启用。
+
+GreptimeDB 也支持这个变种。只需将 GreptimeDB 的 Remote Write URL 配置为 `vmagent`。
+例如,如果你在本地安装了 GreptimeDB:
+
+```shell
+vmagent -remoteWrite.url=http://localhost:4000/v1/prometheus/write
+```
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/vector.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/vector.md
new file mode 100644
index 000000000..f987406ab
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/for-observerbility/vector.md
@@ -0,0 +1,69 @@
+---
+keywords: [Vector, 数据写入, gRPC 通信, 数据模型, 配置示例]
+description: 介绍如何使用 Vector 将数据写入 GreptimeDB,包括最小配置示例和数据模型的映射规则。
+---
+
+# Vector
+
+Vector 是高性能的可观测数据管道。
+它原生支持 GreptimeDB 指标数据接收端。
+通过 Vector,你可以从各种来源接收指标数据,包括 Prometheus、OpenTelemetry、StatsD 等。
+GreptimeDB 可以作为 Vector 的 Sink 组件来接收指标数据。
+
+## 收集主机指标
+
+### 配置
+
+使用 GreptimeDB 的 Vector 集成的最小配置如下:
+
+```toml
+# sample.toml
+
+[sources.in]
+type = "host_metrics"
+
+[sinks.my_sink_id]
+inputs = ["in"]
+type = "greptimedb_metrics"
+endpoint = ":4001"
+dbname = ""
+username = ""
+password = ""
+new_naming = true
+```
+
+GreptimeDB 使用 gRPC 与 Vector 进行通信,因此 Vector sink 的默认端口是 `4001`。
+如果你在使用 [自定义配置](/user-guide/deployments/configuration.md#configuration-file) 启动 GreptimeDB 时更改了默认的 gRPC 端口,请使用你自己的端口。
+
+启动 Vector:
+
+```
+vector -c sample.toml
+```
+
+请前往 [Vector GreptimeDB Configuration](https://vector.dev/docs/reference/configuration/sinks/greptimedb_metrics/) 查看更多配置项。
+
+### 数据模型
+
+我们使用这样的规则将 Vector 指标存入 GreptimeDB:
+
+- 使用 `_` 作为 GreptimeDB 的表名,例如 `host_cpu_seconds_total`;
+- 将指标中的时间戳作为 GreptimeDB 的时间索引,默认列名 `ts`;
+- 指标所关联的 tag 列将被作为 GreptimeDB 的 tag 字段;
+- Vector 的指标,和其他指标类似,有多种子类型:
+ - Counter 和 Gauge 类型的指标,数值直接被存入 `val` 列;
+ - Set 类型,我们将集合的数据个数存入 `val` 列;
+ - Distribution 类型,各个百分位数值点分别存入 `pxx` 列,其中 xx 是 quantile 数值,此外我们还会记录 `min/max/avg/sum/count` 列;
+ - AggregatedHistoragm 类型,每个 bucket 的数值将被存入 `bxx` 列,其中 xx 是 bucket 数值的上限,此外我们还会记录 `sum/count` 列;
+ - AggregatedSummary 类型,各个百分位数值点分别存入 `pxx` 列,其中 xx 是 quantile 数值,此外我们还会记录 `sum/count` 列;
+ - Sketch 类型,各个百分位数值点分别存入 `pxx` 列,其中 xx 是 quantile 数值,此外我们还会记录 `min/max/avg/sum` 列;
+
+## 收集 InfluxDB 行协议格式的指标
+
+Vector 可以收集 InfluxDB 行协议格式的指标并将其发送到 GreptimeDB。更多信息请参考 [Kafka 指南](/user-guide/ingest-data/for-observerbility/kafka.md#指标)。
+
+
+## 收集日志
+
+Vector 可以收集日志并发送到 GreptimeDB。更多信息请参考 [Kafka 指南](/user-guide/ingest-data/for-observerbility/kafka.md#日志)。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/overview.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/overview.md
new file mode 100644
index 000000000..b2a1d266e
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/ingest-data/overview.md
@@ -0,0 +1,26 @@
+---
+keywords: [自动生成表结构, schema 写入, 数据写入方法, 数据管理, 数据集成]
+description: 介绍 GreptimeDB 的自动生成表结构功能和推荐的数据写入方法,并提供下一步学习的链接。
+---
+
+# 概述
+
+## 自动生成表结构
+
+GreptimeDB 支持无 schema 写入,即在数据写入时自动创建表格并添加必要的列。
+这种能力确保你无需事先手动定义 schema,从而更容易管理和集成各种数据源。
+
+此功能适用于所有协议和集成,除了 [SQL](./for-iot/sql.md)。
+
+## 推荐的数据写入方法
+
+GreptimeDB 支持针对特定场景的各种数据写入方法,以确保最佳性能和集成灵活性。
+
+- [可观测场景](./for-observerbility/overview.md):适用于实时监控和警报。
+- [物联网场景](./for-iot/overview.md):适用于实时数据和复杂的物联网基础设施。
+
+## 下一步
+
+- [查询数据](/user-guide/query-data/overview.md): 学习如何通过查询 GreptimeDB 数据库来探索数据。
+- [管理数据](/user-guide/manage-data/overview.md): 学习如何更新和删除数据等,确保数据完整性和高效的数据管理。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/alloy.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/alloy.md
new file mode 100644
index 000000000..40c3acc57
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/alloy.md
@@ -0,0 +1,9 @@
+---
+keywords: [Alloy, Grafana Alloy, GreptimeDB]
+description: 将 GreptimeDB 与 Grafana Alloy 集成。
+---
+
+# Grafana Alloy
+
+你可以将 GreptimeDB 设置为 Grafana Alloy 的数据接收端。
+更多信息,请参考[通过 Grafana Alloy 写入数据](/user-guide/ingest-data/for-observerbility/alloy.md)指南。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/dbeaver.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/dbeaver.md
new file mode 100644
index 000000000..d0600fd3d
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/dbeaver.md
@@ -0,0 +1,27 @@
+---
+keywords: [DBeaver, MySQL Driver, 数据库工具, 连接 GreptimeDB, 配置连接, 数据库管理]
+description: 介绍如何使用 DBeaver 通过 MySQL Driver 连接到 GreptimeDB,包括配置连接的详细步骤。
+---
+
+# DBeaver
+
+[DBeaver](https://dbeaver.io/) 是一个免费、开源且跨平台的数据库工具,支持所有流行的数据库。
+由于其易用性和丰富的功能集,它在开发人员和数据库管理员中非常受欢迎。
+你可以使用 DBeaver 通过 MySQL Driver 连接到 GreptimeDB。
+
+点击 DBeaver 工具栏中的 “New Database Connection” 按钮,以创建 GreptimeDB 的新连接。
+
+选择 MySQL 并点击“下一步”以配置连接。
+如果你还没有安装 MySQL Driver,请先安装。
+接下来输入以下连接信息:
+
+- Connect by Host
+- Host:如果 GreptimeDB 运行在本机,则为 `localhost`
+- Port:如果使用默认的 GreptimeDB 配置,则为 `4002`
+- Database:`public`,你也可以使用你创建的其他数据库名称
+- 如果你的 GreptimeDB 启用了身份验证,请输入 username 和 password,否则留空
+
+点击 “Test Connection” 以验证连接设置,然后点击 “Finish” 以保存连接。
+
+有关 MySQL 与 GreptimeDB 交互的更多信息,请参阅 [MySQL 协议文档](/user-guide/protocols/mysql.md)。
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/emqx.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/emqx.md
new file mode 100644
index 000000000..c25768dbc
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/emqx.md
@@ -0,0 +1,4 @@
+# EMQX
+
+GreptimeDB 可以作为 EMQX 的数据系统。
+更多信息请参考 [通过 EMQX 写入数据](/user-guide/ingest-data/for-iot/emqx.md) 指南。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/grafana.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/grafana.md
new file mode 100644
index 000000000..5278bdc9c
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/grafana.md
@@ -0,0 +1,139 @@
+---
+keywords: [Grafana, 数据源, GreptimeDB 插件, Prometheus 数据源, MySQL 数据源, 仪表盘, 数据可视化]
+description: 介绍如何将 GreptimeDB 配置为 Grafana 数据源,包括使用 GreptimeDB 数据源插件、Prometheus 数据源和 MySQL 数据源的方法。
+---
+
+# Grafana
+
+GreptimeDB 服务可以配置为 [Grafana 数据源](https://grafana.com/docs/grafana/latest/datasources/add-a-data-source/)。
+你可以选择使用以下三个数据源之一连接 GreptimeDB 与 Grafana:GreptimeDB、Prometheus 或 MySQL。
+
+## GreptimeDB 数据源插件
+
+GreptimeDB 数据源插件基于 Prometheus 数据源开发并附加了特定于 GreptimeDB 的功能。
+该插件完美适配了 GreptimeDB 的数据模型,
+从而提供了更好的用户体验。
+此外,和直接使用 Prometheus 数据源相比,它还解决了一些兼容性问题。
+
+### 安装
+
+GreptimeDB 数据源插件目前仅支持在本地 Grafana 中的安装,
+在安装插件前请确保 Grafana 已经安装并运行。
+
+你可以任选以下一种安装方式:
+
+- 下载安装包并解压到相关目录:从[发布页面](https://github.com/GreptimeTeam/greptimedb-grafana-datasource/releases/latest/)获取最新版本,解压文件到你的 [grafana 插件目录](https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#plugins)。
+- 使用 Grafana Cli 下载并安装:
+ ```shell
+ grafana cli --pluginUrl https://github.com/GreptimeTeam/greptimedb-grafana-datasource/releases/latest/download/info8fcc-greptimedb-datasource.zip plugins install info8fcc
+ ```
+- 使用我们 [预构建的 Grafana 镜
+ 像](https://hub.docker.com/r/greptime/grafana-greptimedb),已经提前包含了
+ GreptimeDB 数据源插件 `docker run -p 3000:3000
+ greptime/grafana-greptimedb:latest`
+
+注意,安装插件后可能需要重新启动 Grafana 服务器。
+
+### 使用 Docker 快速预览
+
+Greptime 提供了一个 docker compose 文件,
+将 GreptimeDB、Prometheus、Prometheus Node Exporter、Grafana 和该插件集成在一起,
+以便你能够快速体验 GreptimeDB 数据源插件。
+
+```shell
+git clone https://github.com/GreptimeTeam/greptimedb-grafana-datasource.git
+cd docker
+docker compose up
+```
+
+你也可以从 Grafana 的 docker 镜像中试用此插件:
+
+```shell
+docker run -d -p 3000:3000 --name=grafana --rm \
+ -e "GF_INSTALL_PLUGINS=https://github.com/GreptimeTeam/greptimedb-grafana-datasource/releases/latest/download/info8fcc-greptimedb-datasource.zip;info8fcc" \
+ grafana/grafana-oss
+```
+
+### Connection 配置
+
+在 Grafana 中单击 Add data source 按钮,选择 GreptimeDB 作为类型。
+
+![grafana-add-greptimedb-data-source](/grafana-add-greptimedb-data-source.png)
+
+
+在 GreptimeDB server URL 中填写以下地址:
+
+```txt
+http://:4000
+```
+
+接下来做如下配置:
+
+- Database Name:填写数据库名称 ``,留空则使用默认数据库 `public`
+- 在 Auth 部分中单击 basic auth,并在 Basic Auth Details 中填写 GreptimeDB 的用户名和密码。未设置可留空:
+
+ - User: ``
+ - Password: ``
+
+然后单击 Save & Test 按钮以测试连接。
+
+### 创建仪表盘
+
+在 Grafana 中创建一个新的仪表盘,点击 `Create your first dashboard` 按钮。
+然后,点击 `Add visualization`,选择 `GreptimeDB` 作为数据源。
+
+在 `Metric` 下拉列表中选择一个指标,然后点击 `Run query` 查看指标数据。
+当你查看数据并确认无误后,点击 `Save` 保存面板。
+
+![grafana-create-panel-with-selecting-metric](/create-panel-with-selecting-metric-greptimedb.png)
+
+你还可以使用 PromQL 创建面板。
+点击 `Query` 标签页右侧的 `code` 按钮,切换到 PromQL 编辑器。
+然后输入一个 PromQL 语句,例如 `system_memory_usage{state="used"}`,点击 `Run queries` 查看指标数据。
+
+![grafana-create-panel-with-promql](/grafana-create-panel-with-promql.png)
+
+:::tip 注意
+GreptimeDB 兼容大部分 PromQL,但是有一些限制。请参考 [PromQL 限制](/user-guide/query-data/promql.md#局限) 文档获取更多信息。
+:::
+
+## Prometheus 数据源
+
+单击 Add data source 按钮,然后选择 Prometheus 作为类型。
+
+在 HTTP 中填写 Prometheus server URL
+
+```txt
+http://:4000/v1/prometheus
+```
+
+在 Auth 部分中单击 basic auth,并在 Basic Auth Details 中填写 GreptimeDB 的用户名和密码:
+
+- User: ``
+- Password: ``
+
+在 Custom HTTP Headers 部分中点击 Add header:
+
+- Header: `x-greptime-db-name`
+- Value: ``
+
+然后单击 Save & Test 按钮以测试连接。
+
+有关如何使用 PromQL 查询数据,请参阅 [Prometheus 查询语言](/user-guide/query-data/promql.md)文档。
+
+## MySQL 数据源
+
+单击 Add data source 按钮,然后选择 MySQL 作为类型。在 MySQL Connection 中填写以下信息:
+
+- Host: `:4002`
+- Database: ``
+- User: ``
+- Password: ``
+- Session timezone: `UTC`
+
+然后单击 Save & Test 按钮以测试连接。
+
+注意目前我们只能使用 raw SQL 创建 Grafana Panel。由于时间戳数据类型的区别,Grafana
+的 SQL Builder 暂时无法选择时间戳字段。
+
+关于如何用 SQL 查询数据,请参考[使用 SQL 查询数据](/user-guide/query-data/sql.md)文档。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/kafka.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/kafka.md
new file mode 100644
index 000000000..c3eacdc5c
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/kafka.md
@@ -0,0 +1,9 @@
+---
+keywords: [Kafka, 数据传输, 可观测性, 指标, 日志]
+description: 从 Kafka 写入数据到 GreptimeDB。
+---
+
+# Kafka
+
+你可以使用 Vector 作为从 Kafka 到 GreptimeDB 的数据传输工具。
+请前往[通过 Kafka 写入数据](/user-guide/ingest-data/for-observerbility/kafka.md)了解更多信息。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/metabase.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/metabase.md
new file mode 100644
index 000000000..5f1073ea2
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/metabase.md
@@ -0,0 +1,30 @@
+---
+keywords: [Metabase, 数据源, 安装 Driver, 添加数据库, BI 工具, 数据分析]
+description: 介绍如何将 GreptimeDB 添加到 Metabase 作为数据源,包括安装 Driver 和添加 GreptimeDB 数据库的方法。
+---
+
+# Metabase
+
+[Metabase](https://github.com/metabase/metabase) 是一个用 Clojure 编写的开源 BI
+工具,可以通过社区维护的数据库驱动将 GreptimeDB 添加到 Metabase。
+
+## 安装
+
+从 [发布
+页](https://github.com/greptimeteam/greptimedb-metabase-driver/releases/latest/)
+下载最新的驱动插件文件 `greptimedb.metabase-driver.jar`,并将文件拷贝到 Metabase
+的工作目录下 `plugins/` 目录中(如果不存在需要创建 `plugins/`)。当 Metabase 启
+动时,会自动检测到插件。
+
+## 添加 GreptimeDB 数据库
+
+选择 *设置* / *管理员设置* / *数据库*, 点击 *添加数据库* 按钮并选择 GreptimeDB
+作为 *数据库类型*.
+
+进一步添加其他数据库信息:
+
+- 端口请填写 GreptimeDB 的 Postgres 协议端口 `4003`。
+- 如果没有开启[认证](/user-guide/deployments/authentication/overview.md),用户名和密码字段
+ 是可选的。
+- 默认填写 `public` 作为 *数据库名*。如果是使用 GreptimeCloud 的实例,可以从控制
+ 台复制数据库名称。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/overview.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/overview.md
new file mode 100644
index 000000000..0f8c22182
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/overview.md
@@ -0,0 +1,11 @@
+# 概述
+
+GreptimeDB 可以与流行的数据写入、查询和可视化工具无缝集成。
+本章节提供了将 GreptimeDB 与以下工具集成的指导:
+
+- [Prometheus](./prometheus.md)
+- [Vector](./vector.md)
+- [Grafana](./grafana.md)
+- [Superset](./superset.md)
+- [Metabase](./metabase.md)
+- [EMQX](./emqx.md)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/prometheus.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/prometheus.md
new file mode 100644
index 000000000..79c2ca55d
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/prometheus.md
@@ -0,0 +1,16 @@
+---
+keywords: [Prometheus, 远程存储, PromQL, 查询数据, 数据写入, 监控工具]
+description: 介绍如何将 GreptimeDB 作为 Prometheus 的远程存储后端,并支持使用 Prometheus 查询语言 (PromQL) 查询数据。
+---
+
+# Prometheus
+
+## Remote Write
+
+GreptimeDB 可以用作 Prometheus 的远程存储后端。
+详细信息请参考[使用 Prometheus Remote Write 写入数据](/user-guide/ingest-data/for-observerbility/prometheus.md)。
+
+## Prometheus Query Language (PromQL)
+
+GreptimeDB 支持使用 Prometheus 查询语言 (PromQL) 来查询数据。
+更多信息请参考[使用 PromeQL 查询数据](/user-guide/query-data/promql.md)。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/superset.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/superset.md
new file mode 100644
index 000000000..0a3d81750
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/superset.md
@@ -0,0 +1,56 @@
+---
+keywords: [Superset, 数据源, Docker Compose, 本地运行, 添加数据库, SQLAlchemy URI, BI 工具]
+description: 介绍如何将 GreptimeDB 作为 Apache Superset 的数据源,包括使用 Docker Compose 和本地运行 Superset 的安装步骤,以及添加 GreptimeDB 数据库的方法。
+---
+
+# Superset
+
+[Apache Superset](https://superset.apache.org) 是开源的 BI 工具,用 Python 编写。
+以下内容可以帮助你把 GreptimeDB 作为 Superset 的数据源。
+
+## 安装
+
+### 用 Docker Compose 运行 Superset
+
+[Docker compose](https://superset.apache.org/docs/installation/docker-compose)
+是 Superset 的推荐使用方式。在这种运行方式下,需要在 Superset 代码目录下的
+`docker/` 中添加一个 `requirements-local.txt`。
+
+并将 GreptimeDB 依赖加入到 `requirements-local.txt`:
+
+```txt
+greptimedb-sqlalchemy
+```
+
+启动 Supertset 服务:
+
+```bash
+docker compose -f docker-compose-non-dev.yml up
+```
+
+### 本地运行 Superset
+
+假如你通过 [Pypi 包安装和运行
+Superset](https://superset.apache.org/docs/installation/pypi),需要将 GreptimeDB
+的依赖安装到相同的 Python 环境。
+
+```bash
+pip install greptimedb-sqlalchemy
+```
+
+## 添加 GreptimeDB 数据库
+
+准备添加,选择 *设置* / *数据库连接*.
+
+添加数据库,并在支持的数据库列表中选择 *GreptimeDB*。
+
+根据 SQLAlchemy URI 的规范,填写以下格式的数据库连接地址。
+
+```
+greptimedb://:@:/
+```
+
+- 如果没有启动[认证](/user-guide/deployments/authentication/overview.md),可以忽略
+ `:@` 部分。
+- 默认端口 `4003` (我们用 PostgresSQL 协议通信)。
+- 默认数据库 `public`。如果是使用 GreptimeCloud 实例,可以从控制台复制数据库名称。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/vector.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/vector.md
new file mode 100644
index 000000000..a2d70436c
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/integrations/vector.md
@@ -0,0 +1,3 @@
+# Vector
+
+请前往[使用 Vector 写入数据](/user-guide/ingest-data/for-observerbility/vector.md)查看如何使用 Vector 将数据传输到 GreptimeDB。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/manage-pipelines.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/manage-pipelines.md
new file mode 100644
index 000000000..01461ed67
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/manage-pipelines.md
@@ -0,0 +1,297 @@
+---
+keywords: [管理 Pipeline, 创建 Pipeline, 删除 Pipeline, 查询 Pipeline, 内置 Pipeline, 数据处理, 日志解析, 日志转换]
+description: 介绍如何在 GreptimeDB 中管理 Pipeline,包括创建、删除和查询 Pipeline 的方法,以及内置 Pipeline 的使用。
+---
+
+# 管理 Pipeline
+
+在 GreptimeDB 中,每个 `pipeline` 是一个数据处理单元集合,用于解析和转换写入的日志内容。本文档旨在指导您如何创建和删除 Pipeline,以便高效地管理日志数据的处理流程。
+
+
+有关 Pipeline 的具体配置,请阅读 [Pipeline 配置](pipeline-config.md)。
+
+## 内置 Pipeline
+
+GreptimeDB 提供了常见日志格式的内置 Pipeline,允许您直接使用而无需创建新的 Pipeline。
+
+请注意,内置 Pipeline 的名称以 "greptime_" 为前缀,不可编辑。
+
+### `greptime_identity`
+
+`greptime_identity` Pipeline 适用于写入 JSON 日志,并自动为 JSON 日志中的每个字段创建列。
+
+- JSON 日志中的第一层级的 key 是表中的列名。
+- 如果相同字段包含不同类型的数据,则会返回错误。
+- 值为 `null` 的字段将被忽略。
+- 作为时间索引的额外列 `greptime_timestamp` 将被添加到表中,以指示日志写入的时间。
+
+#### 类型转换规则
+
+- `string` -> `string`
+- `number` -> `int64` 或 `float64`
+- `boolean` -> `bool`
+- `null` -> 忽略
+- `array` -> `json`
+- `object` -> `json`
+
+例如,如果我们有以下 JSON 数据:
+
+```json
+[
+ {"name": "Alice", "age": 20, "is_student": true, "score": 90.5,"object": {"a":1,"b":2}},
+ {"age": 21, "is_student": false, "score": 85.5, "company": "A" ,"whatever": null},
+ {"name": "Charlie", "age": 22, "is_student": true, "score": 95.5,"array":[1,2,3]}
+]
+```
+
+我们将合并每个批次的行结构以获得最终 schema。表 schema 如下所示:
+
+```sql
+mysql> desc pipeline_logs;
++--------------------+---------------------+------+------+---------+---------------+
+| Column | Type | Key | Null | Default | Semantic Type |
++--------------------+---------------------+------+------+---------+---------------+
+| age | Int64 | | YES | | FIELD |
+| is_student | Boolean | | YES | | FIELD |
+| name | String | | YES | | FIELD |
+| object | Json | | YES | | FIELD |
+| score | Float64 | | YES | | FIELD |
+| company | String | | YES | | FIELD |
+| array | Json | | YES | | FIELD |
+| greptime_timestamp | TimestampNanosecond | PRI | NO | | TIMESTAMP |
++--------------------+---------------------+------+------+---------+---------------+
+8 rows in set (0.00 sec)
+```
+
+数据将存储在表中,如下所示:
+
+```sql
+mysql> select * from pipeline_logs;
++------+------------+---------+---------------+-------+---------+---------+----------------------------+
+| age | is_student | name | object | score | company | array | greptime_timestamp |
++------+------------+---------+---------------+-------+---------+---------+----------------------------+
+| 22 | 1 | Charlie | NULL | 95.5 | NULL | [1,2,3] | 2024-10-18 09:35:48.333020 |
+| 21 | 0 | NULL | NULL | 85.5 | A | NULL | 2024-10-18 09:35:48.333020 |
+| 20 | 1 | Alice | {"a":1,"b":2} | 90.5 | NULL | NULL | 2024-10-18 09:35:48.333020 |
++------+------------+---------+---------------+-------+---------+---------+----------------------------+
+3 rows in set (0.01 sec)
+```
+
+## 创建 Pipeline
+
+GreptimeDB 提供了专用的 HTTP 接口用于创建 Pipeline。
+假设你已经准备好了一个 Pipeline 配置文件 pipeline.yaml,使用以下命令上传配置文件,其中 `test` 是你指定的 Pipeline 的名称:
+
+```shell
+## 上传 pipeline 文件。test 为 Pipeline 的名称
+curl -X "POST" "http://localhost:4000/v1/events/pipelines/test?db=public" -F "file=@pipeline.yaml"
+```
+
+创建的 Pipeline 会关联到一个 database,可通过 URL 参数 `db` 来指定,默认为 `public`。
+在将日志写入到数据库中时,所使用的 Pipeline 必须和写入的表在同一个 database 下。
+
+## 删除 Pipeline
+
+可以使用以下 HTTP 接口删除 Pipeline:
+
+```shell
+## test 为 Pipeline 的名称
+curl -X "DELETE" "http://localhost:4000/v1/events/pipelines/test?db=public&version=2024-06-27%2012%3A02%3A34.257312110Z"
+```
+
+上面的例子中,我们删除了一个在 `public` database 下名为 `test` 的 Pipeline。`version` 参数是必须的,用于指定要删除的 Pipeline 的版本号。
+
+## 查询 Pipeline
+
+目前可以使用 SQL 来查询 Pipeline 的信息。
+
+```sql
+SELECT * FROM greptime_private.pipelines;
+```
+
+请注意,如果您使用 MySQL 或者 PostgreSQL 协议作为连接 GreptimeDB 的方式,查询出来的 Pipeline 时间信息精度可能有所不同,可能会丢失纳秒级别的精度。
+
+为了解决这个问题,可以将 `created_at` 字段强制转换为 timestamp 来查看 Pipeline 的创建时间。例如,下面的查询将 `created_at` 以 `bigint` 的格式展示:
+
+```sql
+SELECT name, pipeline, created_at::bigint FROM greptime_private.pipelines;
+```
+
+查询结果如下:
+
+```
+ name | pipeline | greptime_private.pipelines.created_at
+------+-----------------------------------+---------------------------------------
+ test | processors: +| 1719489754257312110
+ | - date: +|
+ | field: time +|
+ | formats: +|
+ | - "%Y-%m-%d %H:%M:%S%.3f"+|
+ | ignore_missing: true +|
+ | +|
+ | transform: +|
+ | - fields: +|
+ | - id1 +|
+ | - id2 +|
+ | type: int32 +|
+ | - fields: +|
+ | - type +|
+ | - logger +|
+ | type: string +|
+ | index: tag +|
+ | - fields: +|
+ | - log +|
+ | type: string +|
+ | index: fulltext +|
+ | - field: time +|
+ | type: time +|
+ | index: timestamp +|
+ | |
+(1 row)
+```
+
+然后可以使用程序将 SQL 结果中的 bigint 类型的时间戳转换为时间字符串。
+
+```shell
+timestamp_ns="1719489754257312110"; readable_timestamp=$(TZ=UTC date -d @$((${timestamp_ns:0:10}+0)) +"%Y-%m-%d %H:%M:%S").${timestamp_ns:10}Z; echo "Readable timestamp (UTC): $readable_timestamp"
+```
+
+输出:
+
+```shell
+Readable timestamp (UTC): 2024-06-27 12:02:34.257312110Z
+```
+
+输出的 `Readable timestamp (UTC)` 即为 Pipeline 的创建时间同时也是版本号。
+
+## 问题调试
+
+首先,请参考 [快速入门示例](/user-guide/logs/quick-start.md#使用-pipeline-写入日志)来查看 Pipeline 正确的执行情况。
+
+### 调试创建 Pipeline
+
+在创建 Pipeline 的时候你可能会遇到错误,例如使用如下配置创建 Pipeline:
+
+```bash
+curl -X "POST" "http://localhost:4000/v1/events/pipelines/test" \
+ -H 'Content-Type: application/x-yaml' \
+ -d $'processors:
+ - date:
+ field: time
+ formats:
+ - "%Y-%m-%d %H:%M:%S%.3f"
+ ignore_missing: true
+ - gsub:
+ fields:
+ - message
+ pattern: "\\\."
+ replacement:
+ - "-"
+ ignore_missing: true
+
+transform:
+ - fields:
+ - message
+ type: string
+ - field: time
+ type: time
+ index: timestamp'
+```
+
+Pipeline 配置存在错误。`gsub` processor 期望 `replacement` 字段为字符串,但当前配置提供了一个数组。因此,该 Pipeline 创建失败,并显示以下错误消息:
+
+
+```json
+{"error":"Failed to parse pipeline: 'replacement' must be a string"}
+```
+
+因此,你需要修改 `gsub` processor 的配置,将 `replacement` 字段的值更改为字符串类型。
+
+```bash
+curl -X "POST" "http://localhost:4000/v1/events/pipelines/test" \
+ -H 'Content-Type: application/x-yaml' \
+ -d $'processors:
+ - date:
+ field: time
+ formats:
+ - "%Y-%m-%d %H:%M:%S%.3f"
+ ignore_missing: true
+ - gsub:
+ fields:
+ - message
+ pattern: "\\\."
+ replacement: "-"
+ ignore_missing: true
+
+transform:
+ - fields:
+ - message
+ type: string
+ - field: time
+ type: time
+ index: timestamp'
+```
+
+此时 Pipeline 创建成功,可以使用 `dryrun` 接口测试该 Pipeline。
+
+### 调试日志写入
+
+我们可以使用 `dryrun` 接口测试 Pipeline。我们将使用错误的日志数据对其进行测试,其中消息字段的值为数字格式,会导致 Pipeline 在处理过程中失败。
+
+**此接口仅仅用于测试 Pipeline 的处理结果,不会将日志写入到 GreptimeDB 中。**
+
+```bash
+curl -X "POST" "http://localhost:4000/v1/events/pipelines/dryrun?pipeline_name=test" \
+ -H 'Content-Type: application/json' \
+ -d $'{"message": 1998.08,"time":"2024-05-25 20:16:37.217"}'
+
+{"error":"Failed to execute pipeline, reason: gsub processor: expect string or array string, but got Float64(1998.08)"}
+```
+
+输出显示 Pipeline 处理失败,因为 `gsub` Processor 期望的是字符串类型,而不是浮点数类型。我们需要修改日志数据的格式,确保 Pipeline 能够正确处理。
+我们再将 message 字段的值修改为字符串类型,然后再次测试该 Pipeline。
+
+```bash
+curl -X "POST" "http://localhost:4000/v1/events/pipelines/dryrun?pipeline_name=test" \
+ -H 'Content-Type: application/json' \
+ -d $'{"message": "1998.08","time":"2024-05-25 20:16:37.217"}'
+```
+
+此时 Pipeline 处理成功,输出如下:
+
+```json
+{
+ "rows": [
+ [
+ {
+ "data_type": "STRING",
+ "key": "message",
+ "semantic_type": "FIELD",
+ "value": "1998-08"
+ },
+ {
+ "data_type": "TIMESTAMP_NANOSECOND",
+ "key": "time",
+ "semantic_type": "TIMESTAMP",
+ "value": "2024-05-25 20:16:37.217+0000"
+ }
+ ]
+ ],
+ "schema": [
+ {
+ "colume_type": "FIELD",
+ "data_type": "STRING",
+ "fulltext": false,
+ "name": "message"
+ },
+ {
+ "colume_type": "TIMESTAMP",
+ "data_type": "TIMESTAMP_NANOSECOND",
+ "fulltext": false,
+ "name": "time"
+ }
+ ]
+}
+```
+
+可以看到,`1998.08` 字符串中的 `.` 已经被替换为 `-`,Pipeline 处理成功。
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/overview.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/overview.md
new file mode 100644
index 000000000..2496ee4a4
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/overview.md
@@ -0,0 +1,7 @@
+# 概述
+
+- [快速开始](./quick-start.md):介绍了如何快速开始使用 GreptimeDB 日志服务。
+- [Pipeline 配置](./pipeline-config.md):深入介绍 GreptimeDB 中的 Pipeline 的每项具体配置。
+- [管理 Pipeline](./manage-pipelines.md):介绍了如何创建、删除 Pipeline。
+- [配合 Pipeline 写入日志](./write-logs.md): 详细说明了如何结合 Pipeline 机制高效写入日志数据。
+- [查询日志](./query-logs.md):描述了如何使用 GreptimeDB SQL 接口查询日志。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/pipeline-config.md b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/pipeline-config.md
new file mode 100644
index 000000000..f5fc00ffb
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/version-0.12/user-guide/logs/pipeline-config.md
@@ -0,0 +1,599 @@
+---
+keywords: [Pipeline 配置, Processor, Transform, 解析日志, 转换日志, YAML 配置, 数据处理, 时间字段解析, 字段拆分]
+description: 介绍 GreptimeDB 中 Pipeline 的配置,包括 Processor 和 Transform 的使用方法,以及各种 Processor 的详细配置示例。
+---
+
+# Pipeline 配置
+
+Pipeline 是 GreptimeDB 中对 log 数据进行解析和转换的一种机制, 由一个唯一的名称和一组配置规则组成,这些规则定义了如何对日志数据进行格式化、拆分和转换。目前我们支持 JSON(`application/json`)和纯文本(`text/plain`)格式的日志数据作为输入。
+
+这些配置以 YAML 格式提供,使得 Pipeline 能够在日志写入过程中,根据设定的规则对数据进行处理,并将处理后的数据存储到数据库中,便于后续的结构化查询。
+
+## 整体结构
+
+Pipeline 由两部分组成:Processors 和 Transform,这两部分均为数组形式。一个 Pipeline 配置可以包含多个 Processor 和多个 Transform。Transform 所描述的数据类型会决定日志数据保存到数据库时的表结构。
+
+- Processor 用于对 log 数据进行预处理,例如解析时间字段,替换字段等。
+- Transform 用于对数据进行格式转换,例如将字符串类型转换为数字类型。
+
+一个包含 Processor 和 Transform 的简单配置示例如下:
+
+```yaml
+processors:
+ - urlencoding:
+ fields:
+ - string_field_a
+ - string_field_b
+ method: decode
+ ignore_missing: true
+transform:
+ - fields:
+ - string_field_a
+ - string_field_b
+ type: string
+ # 写入的数据必须包含 timestamp 字段
+ - fields:
+ - reqTimeSec, req_time_sec
+ # epoch 是特殊字段类型,必须指定精度
+ type: epoch, ms
+ index: timestamp
+```
+
+## Processor
+
+Processor 用于对 log 数据进行预处理,其配置位于 YAML 文件中的 `processors` 字段下。
+Pipeline 会按照多个 Processor 的顺序依次加工数据,每个 Processor 都依赖于上一个 Processor 处理的结果。
+Processor 由一个 name 和多个配置组成,不同类型的 Processor 配置有不同的字段。
+
+我们目前内置了以下几种 Processor:
+
+- `date`: 解析格式化的时间字符串字段,例如 `2024-07-12T16:18:53.048`。
+- `epoch`: 解析数字时间戳字段,例如 `1720772378893`。
+- `decolorize`: 移除日志数据中的 ANSI 颜色代码。
+- `dissect`: 对 log 数据字段进行拆分。
+- `gsub`: 对 log 数据字段进行替换。
+- `join`: 对 log 中的 array 类型字段进行合并。
+- `letter`: 对 log 数据字段进行字母转换。
+- `regex`: 对 log 数据字段进行正则匹配。
+- `urlencoding`: 对 log 数据字段进行 URL 编解码。
+- `csv`: 对 log 数据字段进行 CSV 解析。
+
+大多数 Processor 都有 `field` 或 `fields` 字段,用于指定需要被处理的字段。大部分 Processor 处理完成后会覆盖掉原先的 field。如果你不想影响到原数据中的对应字段,我们可以把结果输出到其他字段来避免覆盖。
+
+当字段名称包含 `,` 时,该字段将被重命名。例如,`reqTimeSec, req_time_sec` 表示将 `reqTimeSec` 字段重命名为 `req_time_sec`,处理完成后的数据将写入中间状态的 `req_time_sec` 字段中。原始的 `reqTimeSec` 字段不受影响。如果某些 Processor 不支持字段重命名,则重命名字段名称将被忽略,并将在文档中注明。
+
+例如:
+
+```yaml
+processors:
+ - letter:
+ fields:
+ - message, message_upper
+ method: upper
+ ignore_missing: true
+```
+
+`message` 字段将被转换为大写并存储在 `message_upper` 字段中。
+
+### `date`
+
+`date` Processor 用于解析时间字段。示例配置如下:
+
+```yaml
+processors:
+ - date:
+ fields:
+ - time
+ formats:
+ - '%Y-%m-%d %H:%M:%S%.3f'
+ ignore_missing: true
+ timezone: 'Asia/Shanghai'
+```
+
+如上所示,`date` Processor 的配置包含以下字段:
+
+- `fields`: 需要解析的时间字段名列表。
+- `formats`: 时间格式化字符串,支持多个时间格式化字符串。按照提供的顺序尝试解析,直到解析成功。你可以在[这里](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)找到格式化的语法说明。
+- `ignore_missing`: 忽略字段不存在的情况。默认为 `false`。如果字段不存在,并且此配置为 false,则会抛出异常。
+- `timezone`: 时区。使用[tz_database](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) 中的时区标识符来指定时区。默认为 `UTC`。
+
+### `epoch`
+
+`epoch` Processor 用于解析时间戳字段,示例配置如下:
+
+```yaml
+processors:
+ - epoch:
+ fields:
+ - reqTimeSec
+ resolution: millisecond
+ ignore_missing: true
+```
+
+如上所示,`epoch` Processor 的配置包含以下字段:
+
+- `fields`: 需要解析的时间戳字段名列表。
+- `resolution`: 时间戳精度,支持 `s`, `sec` , `second` , `ms`, `millisecond`, `milli`, `us`, `microsecond`, `micro`, `ns`, `nanosecond`, `nano`。默认为 `ms`。
+- `ignore_missing`: 忽略字段不存在的情况。默认为 `false`。如果字段不存在,并且此配置为 false,则会抛出异常。
+
+### `decolorize`
+
+`decolorize` Processor 用于移除日志数据中的 ANSI 颜色代码。示例配置如下:
+
+```yaml
+processors:
+ - decolorize:
+ fields:
+ - message
+```
+
+如上所示,`decolorize` Processor 的配置包含以下字段:
+
+- `fields`: 需要移除颜色代码的字段名列表。
+
+### `dissect`
+
+`dissect` Processor 用于对 log 数据字段进行拆分,示例配置如下:
+
+```yaml
+processors:
+ - dissect:
+ fields:
+ - message
+ patterns:
+ - '%{key1} %{key2}'
+ ignore_missing: true
+ append_separator: '-'
+```
+
+如上所示,`dissect` Processor 的配置包含以下字段:
+
+- `fields`: 需要拆分的字段名列表。不支持字段重命名。
+- `patterns`: 拆分的 dissect 模式。
+- `ignore_missing`: 忽略字段不存在的情况。默认为 `false`。如果字段不存在,并且此配置为 false,则会抛出异常。
+- `append_separator`: 对于多个追加到一起的字段,指定连接符。默认是一个空字符串。
+
+#### Dissect 模式
+
+和 Logstash 的 Dissect 模式类似,Dissect 模式由 `%{key}` 组成,其中 `%{key}` 为一个字段名。例如:
+
+```
+"%{key1} %{key2} %{+key3} %{+key4/2} %{key5->} %{?key6}"
+```
+
+#### Dissect 修饰符
+
+Dissect 模式支持以下修饰符:
+
+| 修饰符 | 说明 | 示例 |
+| ----------- | ---------------------------------------- | --------------------- |
+| `+` | 将两个或多个字段追加到一起 | `%{+key} %{+key}` |
+| `+` 和 `/n` | 按照指定的顺序将两个或多个字段追加到一起 | `%{+key/2} %{+key/1}` |
+| `->` | 忽略右侧的任何重复字符 | `%{key1->} %{key2->}` |
+| `?` | 忽略匹配的值 | `%{?key}` |
+
+#### `dissect` 示例
+
+例如,对于以下 log 数据:
+
+```
+"key1 key2 key3 key4 key5 key6"
+```
+
+使用以下 Dissect 模式:
+
+```
+"%{key1} %{key2} %{+key3} %{+key3/2} %{key5->} %{?key6}"
+```
+
+将得到以下结果:
+
+```
+{
+ "key1": "key1",
+ "key2": "key2",
+ "key3": "key3 key4",
+ "key5": "key5"
+}
+```
+
+### `gsub`
+
+`gsub` Processor 用于对 log 数据字段进行替换,示例配置如下:
+
+```yaml
+processors:
+ - gsub:
+ fields:
+ - message
+ pattern: 'old'
+ replacement: 'new'
+ ignore_missing: true
+```
+
+如上所示,`gsub` Processor 的配置包含以下字段:
+
+- `fields`: 需要替换的字段名列表。
+- `pattern`: 需要替换的字符串。支持正则表达式。
+- `replacement`: 替换后的字符串。
+- `ignore_missing`: 忽略字段不存在的情况。默认为 `false`。如果字段不存在,并且此配置为 false,则会抛出异常。
+
+### `join`
+
+`join` Processor 用于对 log 中的 Array 类型字段进行合并,示例配置如下:
+
+```yaml
+processors:
+ - join:
+ fields:
+ - message
+ separator: ','
+ ignore_missing: true
+```
+
+如上所示,`join` Processor 的配置包含以下字段:
+
+- `fields`: 需要合并的字段名列表。注意,这里每行字段的值需要是 Array 类型,每行字段会单独合并自己数组内的值,所有行的字段不会合并到一起。
+- `separator`: 合并后的分隔符。
+- `ignore_missing`: 忽略字段不存在的情况。默认为 `false`。如果字段不存在,并且此配置为 false,则会抛出异常。
+
+#### `join` 示例
+
+例如,对于以下 log 数据:
+
+```json
+{
+ "message": ["a", "b", "c"]
+}
+```
+
+使用以下配置:
+
+```yaml
+processors:
+ - join:
+ fields:
+ - message
+ separator: ','
+```
+
+将得到以下结果:
+
+```json
+{
+ "message": "a,b,c"
+}
+```
+
+### `letter`
+
+`letter` Processor 用于对 log 数据字段进行字母转换,示例配置如下:
+
+```yaml
+processors:
+ - letter:
+ fields:
+ - message
+ method: upper
+ ignore_missing: true
+```
+
+如上所示,`letter` Processor 的配置包含以下字段:
+
+- `fields`: 需要转换的字段名列表。
+- `method`: 转换方法,支持 `upper`, `lower` ,`capital`。默认为 `lower`。注意 `capital` 只会将第一个字母转换为大写。
+- `ignore_missing`: 忽略字段不存在的情况。默认为 `false`。如果字段不存在,并且此配置为 false,则会抛出异常。
+
+### `regex`
+
+`regex` Processor 用于对 log 数据字段进行正则匹配,示例配置如下:
+
+```yaml
+processors:
+ - regex:
+ fields:
+ - message
+ patterns:
+ - ':(?[0-9])'
+ ignore_missing: true
+```
+
+如上所示,`regex` Processor 的配置包含以下字段:
+
+- `fields`: 需要匹配的字段名列表。如果重命名了字段,重命名后的字段名将与 `pattern` 中的命名捕获组名进行拼接。
+- `pattern`: 要进行匹配的正则表达式,需要使用命名捕获组才可以从对应字段中取出对应数据。
+- `ignore_missing`: 忽略字段不存在的情况。默认为 `false`。如果字段不存在,并且此配置为 false,则会抛出异常。
+
+#### regex 命名捕获组的规则
+
+`regex` Processor 支持使用 `(?...)` 的语法来命名捕获组,最终将数据处理为这种形式:
+
+```json
+{
+ "_": ""
+}
+```
+
+例如 `regex` Processor 中 field 填写的字段名为 `message`,对应的内容为 `"[ERROR] error message"`,
+你可以将 pattern 设置为 `\[(?[A-Z]+)\] (?