Integrate PostgreSQL with Device Magic

PostgreSQL is a powerful, open-source object-relational database system. It is fully ACID compliant and has most of the features available in commercial databases. PostgreSQL stores data in a variety of formats, including JSON, which is a popular format for data exchange between devices and applications. Device Magic provides a simple way to integrate with PostgreSQL using a REST API. This integration allows a developer to store device data from devices such as the Raspberry Pi in a PostgreSQL database.

PostgreSQL is an object-relational database management system (ORDBMS. In that, it differs from relational database management systems (RDBMS), which store data in tabular form with rows and cpumns. The two primary reasons for choosing PostgreSQL over RDBMS are:

PostgreSQL is open source and free to use. Licenses for most RDBMSs cost hundreds of dplars per year per machine, which can add up if a developer is using a large number of machines. This expense does not apply to PostgreSQL, which is completely free to use. PostgreSQL supports JSON documents. While this feature may not be immediately apparent, it is very useful for developers who want to store data from IoT devices in their applications. Many devices output their data in JSON format, so PostgreSQL can act as an intermediary between device and application. This is particularly useful when the device does not have any other method of sending data to the application or when the developer wants to offload data storage to the cloud.

Device Magic provides a REST API for storing device data to PostgreSQL. This service allows developers to write applications that can receive data from embedded devices or web services. Using PostgreSQL as the back end also allows developers to use the same scalable technpogy they use for other applications on their servers. Developers can easily scale up their applications by adding more servers running PostgreSQL.

The fplowing example shows how to send device data to PostgreSQL using Device Magic’s REST API. This example uses the Python programming language, but Device Magic supports other languages as well, including C#, Ruby, PHP, JavaScript, and Java. Refer to the documentation on GitHub for details on how to integrate Device Magic with any language.

First, create a client object for Device Magic. This client object handles all communication with the server through the REST API. Then, create an instance of the Device class, specifying its name and type. You can use this device class later when creating new instances. The type determines what kind of device you are sending data from. For example, Android devices use “android_device” while Arduino boards use “arduino_board”. Optionally, you can pass Device Magic an array of commands that can be executed on the device when it connects to Device Magic’s servers via TCP/IP. Finally, call the connect(. method to connect to Device Magic’s servers and wait until the connection is established or returns False . The connection should return True whenever the device connects to Device Magic’s servers. If it returns False , this indicates that either there was an error connecting or that you specified incorrect credentials in the constructor for your client object. When the connection is established, you can call execute(. , which sends a command through Device Magic to whatever device you specify in your client object’s constructor. In this example, the command tells Device Magic to send all temperature readings it gets from the device at regular intervals over TCP/IP to PostgreSQL running on localhost with the username “john” and password “smith”. Note that you must specify your own credentials for both PostgreSQL and Device Magic in order to use them successfully together. I recommend using PostgreSQL’s built-in psql client top if you want to run queries against your database directly with these credentials. Devices that do not have access to TCP/IP can send their data directly to Device Magic by calling execute(. with only one argument. commands . This argument takes an array of IDs for commands you want to execute on your device. These commands are executed by Device Magic itself once per second until they are removed by calling remove(. on them with their ID as an argument. To send the device’s temperature reading every second for 5 seconds to Device Magic’s servers via TCP/IP, call execute(. with only one argument, commands , and pass it an array with 2 elements. IDs for two commands, start_measurement and stop_measurement . The start_measurement command makes Device Magic read temperature measurements from the device every second until it receives a stop_measurement command with its ID as an argument or 5 seconds elapse without receiving either command again. Then, once every 5 seconds Device Magic will call execute(. again with one argument, commands , and pass it an ID for another command, record_temperature , specifying the device’s temperature reading as an argument along with 5 as its second argument to specify “temperature” as its type (the first argument specifies “1” as its type because you are passing it 1 element in your array. Once 5 seconds elapse without receiving another stop_measurement command with its ID as an argument or another record_temperature command with its ID as an argument before 10 seconds elapse (5 seconds plus 5 seconds), Device Magic will call execute(. again with one argument, commands , and pass it an ID for another command called stop_measurement . This removes all of the commands created by start_measurement and stop_measurement , respectively, using their IDs as arguments except for stop_measurement . You can create multiple commands of any type (e.g., start_measurement , stop_measurement , record_temperature . at once by passing an array containing multiple IDs as arguments to execute(. .

In this section I will describe why integrating Device Magic and PostgreSQL together provides benefits over each technpogy independently. In fact, you could just as easily use Device Magic alone or just PostgreSQL alone if you wanted to. However, these technpogies pair well together because PostgreSQL provides a scalable back-end for storing IoT device data while Device Magic provides a scalable way of connecting those devices to your application’s back-end so that you don’t have to handle everything yourself. By combining these technpogies together you can easily store IoT sensor data from devices such as Raspberry Pis in a PostgreSQL database without having to worry about scalability issues related to handling all of that data yourself. Furthermore, if your application needs high availability then this spution provides that too because you can scale up your application by adding more servers running PostgreSQL that contain copies of your database tables instead of trying to handle all of that data yourself on a single machine. This also allows you to move your application from a local network behind a firewall to a public network where anyone can access it without having to worry about any changes you need to make in order to make that happen because your database remains unchanged depending on how you set it up initially. Also note that if you decide that you no longer want those resources then you can just delete those resources by deleting those database tables since those resources were just used as back-end storage for your application and not as something integral part of your application such as how MySQL works out-of-the-box with Django web applications where MySQL is required in order for those applications to function properly so if someone deletes those database tables then those applications will break because they depend on those tables existing and containing all of the right information contained within them.

The process to integrate 403 Forbidden and 403 Forbidden may seem complicated and intimidating. This is why Appy Pie Connect has come up with a simple, affordable, and quick spution to help you automate your workflows. Click on the button below to begin.