InfluxDB v2 on Kubernetes
Tags: monitoring, kubernetes
Published: 2021-03-28 22:26:10

Here is the thing, let's setup a InfluxDB v2 in Kubernetes. Fast and simple and just with 3 YAML files ;)

You will need a Kubernetes cluster. You could create a GKE, EKS or AKS, but if you're poor as I am; use Minikube :P

Install [Minikube](https://minikube.sigs.k8s.io) or [Kind](https://kind.sigs.k8s.io) and start it:

Minikube:
```bash
CMD> minikube start
```
Kind:
```bash
CMD> kind create cluster
```


Then create a namespace called "monitoring"
```bash
CMD> kubectl create namespace monitoring
```

Easy, dont you think? What now? Let's create a Service Account with a privileged permission scheme, this is mine:

```yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: cthulhu
  namespace: monitoring
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: cthulhu-clusterrole
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: cthulhu
  namespace: monitoring
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: cthulhu-role
  namespace: monitoring
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: cthulhu
  namespace: monitoring
```

Take note that this one is just for testing purposes, NEVER use this RBAC on a production environment, you will need to touch here and there for a production environment. Did I told you that this will be fast as a shark?

Let's deploy our InfluxDB v2 server. Here is the YAML:
```yaml
apiVersion: v1
kind: Service
metadata:
  name: influxdb
  namespace: monitoring 
spec:
  type: ClusterIP
  selector:
    app: influxdb
  ports:
  - name: api
    port: 9999
  - name: gui
    port: 8086
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: influxdb
  namespace: monitoring   
spec:
  serviceName: "influxdb"
  selector:
    matchLabels:
      app: influxdb
  template:
    metadata:
      labels:
        app: influxdb
    spec:
      serviceAccount: cthulhu    
      containers:
      - name: influxdb
        image: quay.io/influxdb/influxdb:v2.0.3
        resources:
          limits:
            memory: "128Mi"
            cpu: 1
        ports:
        - name: api
          containerPort: 9999
        - name: gui
          containerPort: 8086
        volumeMounts:
        - name: data
          mountPath: /root/.influxdbv2
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: 1Gi
        volumeMode: Filesystem
```
This is a Statefulset that will be enough to test new influxDB v2 features on your local environment, develop some alerting and dashboards with the new GUI and test some API things.

Now, we must configure the basic credentials. You could manage to create the admin user via GUI, but let's do it via YAML, because could be useful to create some pipelines with this monitoring monster.

So, here is the "config" YAML. Take note that I set up a simple token and password. Did I say that this is only for testing purposes?

```yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: influxdb-setup
  namespace: monitoring
spec:
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: create-credentials
          image: quay.io/influxdb/influxdb:v2.0.3
          command:
            - influx
          args:
            - setup
            - --host
            - http://influxdb.monitoring:8086
            - --bucket
            - kubernetes
            - --org
            - InfluxData
            - --password
            - yogsothoth
            - --username
            - admin
            - --token
            - secret-token
            - --force
```

So, so... what's next? I also have a Telegraf to send some data to that Influx, here it is:

```yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: telegraf
  namespace: monitoring  
spec:
  selector:
    matchLabels:
      app: telegraf
  template:
    metadata:
      labels:
        app: telegraf
    spec:
      serviceAccount: cthulhu
      volumes:
      - name: config
        configMap:
          name: telegraf
      containers:
      - name: telegraf
        image: telegraf:alpine
        imagePullPolicy: IfNotPresent
        volumeMounts:
        - name: config
          mountPath: /etc/telegraf/telegraf.conf
          subPath: telegraf.conf     
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: telegraf
  namespace: monitoring  
data:
  telegraf.conf: | 
    [global_tags]
      infra = "minikube"
    
    [agent]
    
      interval            = "10s"
      round_interval      = true
      metric_batch_size   = 1000
      metric_buffer_limit = 10000
      collection_jitter   = "0s"
      flush_interval      = "10s"
      flush_jitter        = "0s"
      precision           = ""
      debug               = false
      quiet               = false
      logfile             = ""
      hostname            = "telegraf"
      omit_hostname       = false

    [[outputs.influxdb_v2]]
      urls         = ["http://influxdb:8086"]

      organization = "InfluxData"
      bucket       = "kubernetes"
      token        = "secret-token"

    [[inputs.cpu]]  
      percpu           = true
      totalcpu         = true
      collect_cpu_time = false
      report_active    = false
    
    [[inputs.disk]]
       ignore_fs = ["rootfs","tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs"]
```

And then? Nothing more than port-forward InfluxDB GUI service and connect to http://localhost:8086

```bash
kubectl port-forward service/influxdb 8086:8086
```

Enjoy!