This post is originally from www.jaredwolff.com

In this post, I’m going to show you how to get started with Grafana and InfluxDB. All of this running docker container on Digital Ocean.

That way you can have pretty graphs like these:

The cost?

$5 a month

Let’s get to it.

Steps

1. Login to Digital Ocean. If you don’t have Digital Ocean and would like to support this blog click here to create an account.
2. Go to Account Settings -> Security and make sure you have an SSH key setup.
3. Create a new droplet use their docker image
4. Make sure you select the $5 a month plan. For simple installs, this is more than enough!
5. SSH in once you’re done: ssh root@<yourserverip>

6. Set up InfluxDB

      docker run --rm -e INFLUXDB_HTTP_AUTH_ENABLED=true -e INFLUXDB_DB=particle -e INFLUXDB_ADMIN_ENABLED=true -e INFLUXDB_ADMIN_USER=admin -e INFLUXDB_USER=grafana -v influxdb:/var/lib/influxdb influxdb /init-influxdb.sh
   

   Watch the output of this command. It will generate passwords for both your admin and grafana user. Save these in a safe place!

7. Start influx

      docker run -d -p 8086:8086 \
            -v influxdb:/var/lib/influxdb \
            -e INFLUXDB_HTTP_AUTH_ENABLED=true \
            influxdb
   

8. Add firewall rule

      ufw allow 8086
   

   This allows the outside world to get to your InfluxDB instance.

9. Set up curl from Particle

   Example equivalent call:

      curl -i -XPOST 'http://<DOCKER IP HERE>:8086/write?db=particle' --data-binary 'temperature,id=<ID HERE> value=22.1'
   

   The version of this to put in the custom request would be:

      temperature,id={{{PARTICLE_DEVICE_ID}}} value={{{temperature}}}
   

   

   Note: see under QUERY PARAMETERS that db is pointing to particle. This should point to whatever you set INFLUXDB_DB to in step 6

   Second Note: make sure that the username and password is the one you set up on step 6 as well. In this example the username is grafana

   

   Here’s a more complex version:

      temperature,id={{{PARTICLE_DEVICE_ID}}} value={{{temperature}}}
      humidity,id={{{PARTICLE_DEVICE_ID}}} value={{{humidity}}}
      tvoc,id={{{PARTICLE_DEVICE_ID}}} value={{{tvoc}}}
      c02,id={{{PARTICLE_DEVICE_ID}}} value={{{c02}}}
      {{#pm25}}pm25,id={{{PARTICLE_DEVICE_ID}}} value={{{pm25}}}{{/pm25}}
      {{#pm10}}pm10,id={{{PARTICLE_DEVICE_ID}}} value={{{pm10}}}{{/pm10}}
      {{#sgp30_tvoc}}sgp30_tvoc,id={{{PARTICLE_DEVICE_ID}}} value={{{sgp30_tvoc}}}{{/sgp30_tvoc}}
      {{#sgp30_c02}}sgp30_c02,id={{{PARTICLE_DEVICE_ID}}} value={{{sgp30_c02}}}{{/sgp30_c02}}
      {{#bme680_pres}}bme680_pres,id={{{PARTICLE_DEVICE_ID}}} value={{{bme680_pres}}}{{/bme680_pres}}
      {{#bme680_iaq}}bme680_iaq,id={{{PARTICLE_DEVICE_ID}}} value={{{bme680_iaq}}}{{/bme680_iaq}}
      {{#bme680_temp_calc}}bme680_temp_calc,id={{{PARTICLE_DEVICE_ID}}} value={{{bme680_temp_calc}}}{{/bme680_temp_calc}}
      {{#bme680_hum_calc}}bme680_hum_calc,id={{{PARTICLE_DEVICE_ID}}} value={{{bme680_hum_calc}}}{{/bme680_hum_calc}}
   

   For conditional data you can wrap the whole line in the variable that may or may not be there:

      {{#bme680_pres}}<insert stuff related to bme680_pres>{{/bme680_pres}}
   

10. Next! Install Grafana with persistent storage

      # create a persistent volume for your data in /var/lib/grafana (database and plugins)
      docker volume create grafana-storage
    
      # start grafana
      docker run \
        -d \
        -p 3000:3000 \
        --name=grafana \
        -v grafana-storage:/var/lib/grafana \
        grafana/grafana
    

11. Add firewall rule for graphana

        ufw allow 3000
        `
    

12. Login. This should be your Digital Ocean Droplet ip + :3000 appended. Example: 123.456.789.101:3000 (Default username and password is admin and admin)

13. Connect Grafana to Influx (should be one of the first options on a fresh Grafana install)

    

    

    Note under user, you’ll have to put the username grafana and the generated password from step 6. Also the name of the database has been set as particle in the same step.

14. Test your connection by clicking Save & Test It should come back quickly saying whether or not a connection has been successful.

15. Start up your device, if not already, and get it publishing to your InfluxDB database.

    (Need data? This project should get you some!)

16. Create graphs!

    Finally, the reason why you came to this page: pretty graphs

    Click the + icon on the left and create a new dashboard

    

17. Select Add Query

    

18. Go down and click select measurement If your device has been publishing to your database, you should see some options for values.

    

19. Under fill(null) change that to fill(none). That should give you a nice line between datapoints.

20. You should see the graph appear!
21. Click the back arrow button and then click the save button.
22. You now created a simple graph on the data directly from your device! I recommend you play around with the Grafana interface. It's fairly intuitive and takes only a few short minutes to get used to!

HTTPS/SSL

Installing HTTPS/SSL is fairly straight forward. Follow the steps below:

1. Stop the Grafana instance if you haven't already

2. Start a new container with nginx-proxy

   docker run --detach \
       --name nginx-proxy \
       --publish 80:80 \
       --publish 443:443 \
       --volume /etc/nginx/certs \
       --volume /etc/nginx/vhost.d \
       —volume /usr/share/nginx/html \
       —volume /var/run/docker.sock:/tmp/docker.sock:ro \
       jwilder/nginx-proxy
   

3. Run the letsencrypt-nginx-proxy-companion

   docker run —detach \
       —name nginx-proxy-letsencrypt \
       —volumes-from nginx-proxy \
       —volume /var/run/docker.sock:/var/run/docker.sock:ro \
       jrcs/letsencrypt-nginx-proxy-companion
   

4. Restart the Grafana container

   docker run \
     -d \
       --env "VIRTUAL_HOST=<YOUR SUBDOMAIN ADDRESS>" \
     --env "VIRTUAL_PORT=3000" \
     --env "LETSENCRYPT_HOST=<YOUR SUBDOMAIN ADDRESS>" \
     --env "LETSENCRYPT_EMAIL=<YOUR EMAIL ADDRESS>" \
     --name=grafana \
     -v grafana-storage:/var/lib/grafana \
     grafana/grafana
   

   Note: make sure you replace <YOUR SUBDOMAIN ADDRESS> and <YOUR EMAIL ADDRESS> above with your own info.

The proxy companion will generate an SSL certificate for the virtual host that you provided to the Grafana container. The proxy is used to forward all HTTP/HTTPS traffic to your Grafana container. It's clean, it's simple and it's secure!

Note InfluxDB is a bit more difficult. You either need to make a separate subdomain or configure HTTPS to share the certs between Grafana and Influx. This Docker Compose script does it all if you haven't already installed everything. You can follow the same steps above if you want to run it on a separate sub-domain.

Handy Links

Here are some handy links that I found useful getting started with Grafana + InfluxDB

• influxdb | Docker Documentation
• Getting Started | Grafana Documentation
• Installing using Docker | Grafana Documentation
• Let's Encrypt Nginx Proxy Companion
• Very Handy about Setting up HTTPS for both Grafana and Influx

Conclusion

You made it. Enjoy your new Grafana + InfluxDB install!

If you liked this tutorial, please share with your friends and your enemies. Also if you’re craving more, check out how to build your own air quality sensor using only a few parts.

My company’s Internet of Things (IoT) side project began when we couldn’t reset the door lock that we inherited from a previous tenant. It was one of those minor details we learned about after moving in to our new last-minute office.

Normally, people just pay for a new one. But our team was too cheap to replace the lock and no one ever wanted to get the door bell. Plus, we’re engineers and we wanted to fiddle with some hardware.

Our goal was to open the door with a phone or wearable technology. We had several options for how to approach the problem. In theory, we could use an app, an integration into another platform, or anything that could send a signal to trigger the door lock.

Chima Open Door on Pebble and iOS

So far in our door lock experiment, we’ve developed solutions for a Slack integration, native iOS and Android apps, the Apple Watch, and Pebble. I’ll focus on the architecture of the mobile apps. I admit the final product is a bit over-engineered, but we just love it!

iOS and Android architecture

Our IoT door lock project’s architecture

What exactly happens when you press the button in our iOS / Android app? An HTTP request is sent to the cloud server, which then triggers a message to the door lock daemon via the client server, which then tells a relay board to open the door lock.

Traditionally, the door lock is opened with a button beside the door. But with modern technology, the possibilities extend beyond a direct, physical button. In addition to the physical button that triggers the Doorlock Daemon in the diagram, we added two other triggers: a cloud-based trigger, and a Bluetooth Low Energy (BLE) trigger, thanks to our choice of hardware.

This article focuses on the cloud-based trigger, which is what our door lock app depends on.

Starting from pressing the button to a record saved on Skygear server.

When a user presses the open door button on the mobile app, the app accesses the cloud server.

Two things happen in the cloud server. The first is that a record is saved to our choice of server, Skygear Cloud Database, which allows you to synchronize your data to the cloud. The server will log when the door access is being requested.

Once a record is saved, it would trigger an after_save function provided by Skygear Cloud Functions, which runs our code in the cloud without bothering server deployment.

The after_save function is triggered after a record is saved. def after_open_door_save(record, original_record, db): is triggered asynchronously when a record of type 'OpenDoor' is saved. The function publishes a message to the channel 'xxx-channel'.

The Node Client and Clojure Server on Raspberry Pi

The next step is to create a listener for the request. This is where the Node client and a Clojure server on Raspberry Pi come in. The Node client listens to the message in the specified channel on the Skygear server. The Clojure server is the only one with the right to access the Raspberry Pi 3 circuit. Then the Node client issues a request to the Clojure server once it hears any message.

Here is the script for the Node client, which includes code related to our specific configuration for Skygear. The endpoint and the API Key are for accessing the main server on Skygear. skygear.on('xxx-channel', onReceiveOpenDoor) means to subscribe the function callback (onReceiveOpenDoor) on receiving a message on the 'xxx-channel' channel.

The Clojure server directly controls General Purpose Input/Output (GPIO) on a Raspberry Pi. GPIO are the pins on the Raspberry Pi 3. The GPIO connects to the external circuit that is connected with the door magnet.

Here is the Clojure code showing how the Raspberry Pi opens the door. Once the Clojure server receives the request from Node client, it will open the door and set it open for 3 seconds. However, if there is a new request coming in during that 3 seconds, the door will reset the timer to another 3 seconds. When the count down time is up, the door will lock again.

A random side note: Skygear is using AWS in America, while the door and the Raspberry Pi is in Hong Kong. Effectively, our ‘芝麻開門’ (Chima Open Door) request travels around the world before it reaches the door.

Why Raspberry Pi?

Now, you may be wondering why we specifically chose Raspberry Pi. We considered using Arduino boards because we had them in the office. The reason we couldn’t use our specific Arduino model was because we wanted to synchronize data via Skygear JS SDK and this specific Arduino can’t set up the Node server.

What’s more, Raspberry Pi is Bluetooth Low Energy ready (which means we could access the door lock using a third method, Bluetooth).

Linus-based Raspberry Pi is compatible with Oursky’s open-source serverless platform, Skygear

Additional integrations

Considering the app is internal-use only, we started a Slack customized command /chima-open-door to open the door since every Ourskyer has access to Slack.

Later some other Oursky colleagues got involved in this project and helped write the WatchOS app and Android app published on the internal platform. Apart from pressing the button inside the app, we also provide alternatives such as iOS 3D touch, Today extension, Android widget and even a Pebble integration because some of our developers use it.

That’s it! Before you dive in, there are two other main factors to consider: the reverse electricity flow (in this case for the Raspberry Pi) and the security of each of your integrations. For example, we also integrated Bluetooth app access with Bluetooth Low Energy (BLE), which has a self-implemented 2FA-like authentication. Other integrations you can include are notifications when the door is open (bell, LED).

If you want to learn about any of the above, feel free to get in touch!

Link to Repo / files
Doorlock: https://github.com/oursky/doorlock

I would like to credit my colleagues David Ng, Boris (akiroz), Brian (b壹貳參肆零零), and May Yeung for working on the Android application, the circuit implementation & Clojure, Pebble application, and this blog piece respectively. Here’s to teamwork!

At Oursky we’re all about helping brands and entrepreneurs make their ideas happen, as well as fellow developers — our latest project Skygear (https://skygear.io), an open source (https://github.com/skygeario) serverless platform for mobile, web & IoT apps — helps you build better apps faster. ?