Time Series Database:From collection to analysis: Generate value from your data with TSDB for InfluxDB®

Collect metrics with Telegraf

Telegraf is an agent written in Go that collects system and service metrics and writes them to TSDB for InfluxDB® over HTTP. The Telegraf configuration file requires at least one input plugin (where metrics come from) and one output plugin (where metrics go).

Step 1: Install Telegraf

Follow the Telegraf installation guide for your operating system.

Step 2: Configure the output plugin

In your Telegraf configuration file, set up the [[outputs.influxdb]] section to write to TSDB for InfluxDB®:

[[outputs.influxdb]]
  urls = ["https://xxx.influxdata.rds.aliyuncs.com:3242"]
  database = "test"
  retention_policy = ""   # Leave blank to use the default retention policy
  username = "test"
  password = "test"

Replace xxx.influxdata.rds.aliyuncs.com with your VPC or public endpoint from the instance details page. Set username and password to an account that has write permissions on the database.

Step 3: Start Telegraf

Run the command for your operating system:

• Ubuntu, Debian, RedHat, or CentOS:

  sudo service telegraf start

• Ubuntu 15.04+, Debian 8+, CentOS 7+, or RHEL 7+:

  sudo systemctl start telegraf

Write data with the Go SDK

Download the Go SDK from GitHub. For Go installation instructions, see the Go documentation.

Connect over HTTPS using the instance endpoint and credentials, then write data in batches. Write 100–1,000 points per batch based on your data size to maximize throughput.

package main

import (
    "fmt"
    "log"
    "math/rand"
    "net/url"
    "time"

    client "github.com/influxdata/influxdb1-client"
)

func main() {
    // Connect to the instance endpoint over HTTPS
    host, err := url.Parse(fmt.Sprintf("https://%s:%d", "xxx.influxdata.rds.aliyuncs.com", 3242))
    if err != nil {
        log.Fatal(err)
    }
    config := client.Config{
        URL:      *host,
        Username: "test",
        Password: "test",
    }
    con, err := client.NewClient(config)
    if err != nil {
        log.Fatal(err)
    }

    _, _, err = con.Ping()
    if err != nil {
        log.Fatal(err)
    }

    // Build a batch of 1,000 points
    var (
        shapes     = []string{"circle", "rectangle", "square", "triangle"}
        colors     = []string{"red", "blue", "green"}
        sampleSize = 1000
        pts        = make([]client.Point, sampleSize)
    )

    rand.Seed(42)
    for i := 0; i < sampleSize; i++ {
        pts[i] = client.Point{
            Measurement: "shapes",
            Tags: map[string]string{
                "color": colors[rand.Intn(len(colors))],
                "shape": shapes[rand.Intn(len(shapes))],
            },
            Fields: map[string]interface{}{
                "value": rand.Intn(sampleSize),
            },
            Time: time.Now(),
        }
    }

    // Write the batch to the target database
    bps := client.BatchPoints{
        Points:          pts,
        Database:        "test",
        RetentionPolicy: "autogen",
    }
    _, err = con.Write(bps)
    if err != nil {
        log.Fatal(err)
    }
}

To compile and run:

go run main.go

Write data with the Java SDK

Download the Java SDK from GitHub.

package main;

import java.util.concurrent.TimeUnit;
import org.influxdb.InfluxDB;
import org.influxdb.BatchOptions;
import org.influxdb.InfluxDBFactory;
import org.influxdb.dto.Point;

public class StartMain {

    public static void main(String[] args) throws Exception {
        StartMain startMain = new StartMain();
        try {
            startMain.run();
        } catch (Exception e) {
            System.out.println(e);
        }
    }

    public void run() throws Exception {
        // Connect to the instance endpoint over HTTPS
        InfluxDB influxDB = InfluxDBFactory.connect(
            "https://xxx.influxdata.rds.aliyuncs.com:3242", "test", "test");

        String dbName = "test";
        influxDB.setDatabase(dbName);
        String rpName = "autogen";
        influxDB.setRetentionPolicy(rpName);
        influxDB.enableBatch(BatchOptions.DEFAULTS);

        // Write CPU metrics
        influxDB.write(Point.measurement("cpu")
            .time(System.currentTimeMillis(), TimeUnit.MILLISECONDS)
            .addField("idle", 90L)
            .addField("user", 9L)
            .addField("system", 1L)
            .build());

        // Write disk metrics
        influxDB.write(Point.measurement("disk")
            .time(System.currentTimeMillis(), TimeUnit.MILLISECONDS)
            .addField("used", 80L)
            .addField("free", 1L)
            .build());

        influxDB.close();
    }
}

To handle write errors, pass a custom exception handler to enableBatch():

influxDB.enableBatch(BatchOptions.DEFAULTS.exceptionHandler(
    (failedPoints, throwable) -> { /* custom error handling here */ })
);

Write data with the Influx CLI

Connect using the -ssl flag along with your host, port, username, and password:

influx -ssl -host xxx.influxdata.rds.aliyuncs.com -port 3242 -username admin -password admin

You can follow the Line Protocol tutorial to write data to TSDB For InfluxDB® from a client:

Write a data point using Line Protocol:

> INSERT cpu,host=serverA,region=us_west value=0.64

Write data with the HTTP API

Use curl to post data in Line Protocol format directly to the write endpoint:

curl -i -XPOST -u test:test \
  'https://xxx.influxdata.rds.aliyuncs.com:3242/write?db=test' \
  --data-binary 'cpu_load_short,host=server01,region=us-west value=0.64 1434055562000000000'