使用 HTTP API 和客户端库写入数据

以下步骤使用InfluxDB 3 Go 客户端设置 Go 项目

1. 安装Go 1.13 或更高版本。

2. 为您的 Go 模块创建一个目录并更改到该目录——例如

   mkdir iot-starter-go && cd $_
   

3. 初始化 Go 模块——例如

   go mod init iot-starter
   

4. 安装influxdb3-go，它提供了 InfluxDB influxdb3 Go 客户端库模块。

   go get github.com/InfluxCommunity/influxdb3-go/v2
   

以下步骤使用InfluxDB 3 JavaScript 客户端设置 JavaScript 项目。

1. 安装Node.js。

2. 为您的 JavaScript 项目创建一个目录并更改到该目录——例如

   mkdir -p iot-starter-js && cd $_
   

3. 初始化一个项目——例如，使用 npm

   npm init
   

4. 安装 @influxdata/influxdb3-client InfluxDB 3 JavaScript 客户端库。

   npm install @influxdata/influxdb3-client
   

以下步骤使用InfluxDB 3 Python 客户端设置 Python 项目

1. 安装 Python

2. 在您的项目目录中，为您的 Python 模块创建一个目录并更改到该模块目录——例如

   mkdir -p iot-starter-py && cd $_
   

3. 可选，但推荐：使用 venv 或 conda 激活虚拟环境，以便安装和执行代码——例如，使用 venv 输入以下命令，为项目创建并激活虚拟环境

   python3 -m venv envs/iot-starter && source ./envs/iot-starter/bin/activate
   

4. 安装 influxdb3-python，它提供了 InfluxDB influxdb_client_3 Python 客户端库模块，并安装了 pyarrow 包，用于处理 Arrow 数据。

   pip install influxdb3-python
   

1. 为您的模块创建一个文件——例如：main.go。

2. 在 main.go 中，输入以下示例代码

   package main
   
   import (
    "context"
    "os"
    "fmt"
    "time"
    "github.com/InfluxCommunity/influxdb3-go/v2/influxdb3"
    "github.com/influxdata/line-protocol/v2/lineprotocol"
   )
   
   func Write() error {
     url := os.Getenv("INFLUX_HOST")
     token := os.Getenv("INFLUX_TOKEN")
     database := os.Getenv("INFLUX_DATABASE")
   
     // To instantiate a client, call New() with InfluxDB credentials.
     client, err := influxdb3.New(influxdb3.ClientConfig{
      Host: url,
      Token: token,
      Database: database,
     })
   
     /** Use a deferred function to ensure the client is closed when the
       * function returns.
      **/
     defer func (client *influxdb3.Client)  {
      err = client.Close()
      if err != nil {
        panic(err)
      }
     }(client)
   
     /** Use the NewPoint method to construct a point.
       * NewPoint(measurement, tags map, fields map, time)
      **/
     point := influxdb3.NewPoint("home",
        map[string]string{
          "room": "Living Room",
        },
        map[string]any{
          "temp": 24.5,
          "hum":  40.5,
          "co":   15i},
        time.Now(),
      )
   
     /** Use the NewPointWithMeasurement method to construct a point with
       * method chaining.
      **/
     point2 := influxdb3.NewPointWithMeasurement("home").
      SetTag("room", "Living Room").
      SetField("temp", 23.5).
      SetField("hum", 38.0).
      SetField("co",  16i).
      SetTimestamp(time.Now())
   
     fmt.Println("Writing points")
     points := []*influxdb3.Point{point, point2}
   
     /** Write points to InfluxDB.
       * You can specify WriteOptions, such as Gzip threshold,
       * default tags, and timestamp precision. Default precision is lineprotocol.Nanosecond
      **/
     err = client.WritePoints(context.Background(), points,
       influxdb3.WithPrecision(lineprotocol.Second))
     return nil
   }
   
   func main() {
     Write()
   }
   

3. 要运行模块并将数据写入您的 InfluxDB 3 Core 数据库，请在终端中输入以下命令

   go run main.go
   

1. 为您的模块创建一个文件——例如：write-points.js。

2. 在 write-points.js 中，输入以下示例代码

   // write-points.js
   import { InfluxDBClient, Point } from '@influxdata/influxdb3-client';
   
   /**
    * Set InfluxDB credentials.
    */
   const host = process.env.INFLUX_HOST ?? '';
   const database = process.env.INFLUX_DATABASE;
   const token = process.env.INFLUX_TOKEN;
   
   /**
    * Write line protocol to InfluxDB using the JavaScript client library.
    */
   export async function writePoints() {
     /**
      * Instantiate an InfluxDBClient.
      * Provide the host URL and the database token.
      */
     const client = new InfluxDBClient({ host, token });
   
     /** Use the fluent interface with chained methods to construct Points. */
     const point = Point.measurement('home')
       .setTag('room', 'Living Room')
       .setFloatField('temp', 22.2)
       .setFloatField('hum', 35.5)
       .setIntegerField('co', 7)
       .setTimestamp(new Date().getTime() / 1000);
   
     const point2 = Point.measurement('home')
       .setTag('room', 'Kitchen')
       .setFloatField('temp', 21.0)
       .setFloatField('hum', 35.9)
       .setIntegerField('co', 0)
       .setTimestamp(new Date().getTime() / 1000);
   
     /** Write points to InfluxDB.
      * The write method accepts an array of points, the target database, and
      * an optional configuration object.
      * You can specify WriteOptions, such as Gzip threshold, default tags,
      * and timestamp precision. Default precision is lineprotocol.Nanosecond
      **/
   
     try {
       await client.write([point, point2], database, '', { precision: 's' });
       console.log('Data has been written successfully!');
     } catch (error) {
       console.error(`Error writing data to InfluxDB: ${error.body}`);
     }
   
     client.close();
   }
   
   writePoints();
   

3. 要运行模块并将数据写入您的 {{< product-name >}} 数据库，请在终端中输入以下命令

   node writePoints.js
   

1. 为您的模块创建一个文件——例如：write-points.py。

2. 在 write-points.py 中，输入以下示例代码以在批处理模式下写入数据

   import os
   from influxdb_client_3 import (
     InfluxDBClient3, InfluxDBError, Point, WritePrecision,
     WriteOptions, write_client_options)
   
   host = os.getenv('INFLUX_HOST')
   token = os.getenv('INFLUX_TOKEN')
   database = os.getenv('INFLUX_DATABASE')
   
   # Create an array of points with tags and fields.
   points = [Point("home")
               .tag("room", "Kitchen")
               .field("temp", 25.3)
               .field('hum', 20.2)
               .field('co', 9)]
   
   # With batching mode, define callbacks to execute after a successful or
   # failed write request.
   # Callback methods receive the configuration and data sent in the request.
   def success(self, data: str):
       print(f"Successfully wrote batch: data: {data}")
   
   def error(self, data: str, exception: InfluxDBError):
       print(f"Failed writing batch: config: {self}, data: {data} due: {exception}")
   
   def retry(self, data: str, exception: InfluxDBError):
       print(f"Failed retry writing batch: config: {self}, data: {data} retry: {exception}")
   
   # Configure options for batch writing.
   write_options = WriteOptions(batch_size=500,
                                       flush_interval=10_000,
                                       jitter_interval=2_000,
                                       retry_interval=5_000,
                                       max_retries=5,
                                       max_retry_delay=30_000,
                                       exponential_base=2)
   
   # Create an options dict that sets callbacks and WriteOptions.
   wco = write_client_options(success_callback=success,
                             error_callback=error,
                             retry_callback=retry,
                             write_options=write_options)
   
   # Instantiate a synchronous instance of the client with your
   # InfluxDB credentials and write options, such as Gzip threshold, default tags,
   # and timestamp precision. Default precision is nanosecond ('ns').
   with InfluxDBClient3(host=host,
                           token=token,
                           database=database,
                           write_client_options=wco) as client:
   
         client.write(points, write_precision='s')
   

3. 要运行模块并将数据写入您的 InfluxDB 3 Core 数据库，请在终端中输入以下命令

   python write-points.py