Learn how to use Raspberry Pi and a relay module to build a real-world alarm notification system for Elasticsearch.

Do you remember the last time when you saw a fire alarm or the police turning on a patrol car's flashing lights? That kind of warning light or loud sound simply notifies you that something is very important, or gives some some sense of danger, and that you must pay attention to it.

	Sometimes, you may also want to do a similar thing with your data, like when your server is down. That’s a big thing and you should call your admin as soon as possible to get it fixed. If your admin is nearby, you could even directly shout out to him/her.

	“Aha!” you might say, let’s use Elasticsearch to monitor our infrastructure and use the alerting feature to notify our admin via email or Slack. Wow, that’s great, but it can be better. Sometimes, the admin’s mobile phone maybe needs to be charged or it’s been left on the table, or the admin may be having a conversation and they may not pay attention to the message, so how can we bring it up?

	What if we used a real world warning light, like what we see during a fire alarm, and even add a loud sound that will be interesting and noticeable, so no one will miss it?

	In this post I will explain how to wire a Raspberry Pi with an alarm light and integrate it with the Elastic Stack to make this happen.
<h2 rel="line-height:1.38;margin-top:20pt;margin-bottom:6pt;">Intro to Raspberry Pi</h2>Raspberry Pi is a very small, but fully featured computer on a single board. You may plug in a monitor with an HDMI cable and attach a keyboard, mouse, camera, or even speakers via USB ports. It can also connect to your network through Wi-Fi or an ethernet port.
<img src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt482c0f7f2373731b/5c98d4df67b8321d593d7fa2/raspberry-pi.jpg" data-sys-asset-uid="blt482c0f7f2373731b" alt="" "="">
The first generation of Raspberry Pi was developed in 2012, with the intention of making computer learning easy for school students. It is cheap, with the newest model, the 3B+, costing you under USD$40. You can install a Linux OS on it, use your favourite language to do programming, and all with very low power consumption.

	The most important feature that Raspberry Pi has is the row of GPIO (General-Purpose Input/Output) pins along the top edge of the board.
<img src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/bltc9982e04982b119b/5c98d4dafc9053fa5ecd78e9/raspberry-pi-gpio.jpg" data-sys-asset-uid="bltc9982e04982b119b" alt="" "="">
The GPIO pins can be used with a variety of alternative functions, some are available on all pins, others on specific pins. This list below details the functions:
<ul>
	<li>PWM (pulse-width modulation)
	<ul>
		<li>Software PWM available on all pins</li>
		<li>Hardware PWM available on GPIO12, GPIO13, GPIO18, GPIO19</li>
	</ul></li>
	<li>SPI
	<ul>
		<li>SPI0: MOSI (GPIO10); MISO (GPIO9); SCLK (GPIO11); CE0 (GPIO8), CE1 (GPIO7)</li>
	</ul>
	<ul>
		<li>SPI1: MOSI (GPIO20); MISO (GPIO19); SCLK (GPIO21); CE0 (GPIO18); CE1 (GPIO17); CE2 (GPIO16)</li>
	</ul></li>
	<li>I2C
	<ul>
		<li>Data: (GPIO2); Clock (GPIO3)</li>
		<li>EEPROM Data: (GPIO0); EEPROM Clock (GPIO1)</li>
	</ul></li>
	<li>Serial
	<ul>
		<li>TX (GPIO14); RX (GPIO15)</li>
	</ul></li>
</ul>Basically, GPIO lets us connect to physical electronic device like alarm lights and also allows us to control these easily.
<h2>How it works</h2>So how it does this all work? The idea of this blog post is to use Raspberry Pi to control a relay module and light up a warning light. There are many alarm lights available to buy and they are very simple. You plug it in, it starts to flash, you unplug it, it stops flashing. More than simple enough for us to use. But wait! They usually are powered with higher voltages, like 12 V, 36 V, or even 220 V, and the Pi can only support 5 V or 3.3 V, which means we can’t control it directly with the Pi, but with a relay we can make it happen. A relay is an electrically operated switch. It uses a very low power electromagnet to mechanically operate a switch, and that switch can be the bridge to connect the high power power supply and our warning light.

	Then we will build a webhook service to send the command to the relay, tell the relay to switch on or off, and control the alarm light.

	And finally, we will use Elasticsearch’s alerting feature to trigger the webhook when we find some interesting events in Elasticsearch.

	Are you interested? If so, let’s get started!
<h2>Materials required</h2>So besides the Raspberry Pi, what materials are needed?, We also need some other electronics items, all of them are available at most electronic stores. Here is the list:
<table><colgroup><col width="235"><col width="192"><col width="192"></colgroup>
<tbody>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Name
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Unit
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Comments
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Raspberry Pi 3 model B+
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		You know, for Pi
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		16GB MicroSD card + reader
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Storage for Raspberry Pi
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		5V USB power supply + USB cable
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Power for Raspberry Pi
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Warning light with 12 V&nbsp;power
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		The light to do the alarm
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		5 V Relay module
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Control the lights
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Breadboard
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Connect&nbsp;all the wires
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		GPIO Breakout Expansion Board + Ribbon Cable
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Connect breadboard and Pi
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		3.3 V&nbsp;Active Piezo Buzzer Module
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		1
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Let’s make some noise
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Female – Female jumper cable
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		~5
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Wire stuff together
		
	</td>
</tr>
<tr style="height:0pt">
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Male – Female jumper cable
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		~5
		
	</td>
	<td style="border-width: 1pt; border-color: rgb(0, 0, 0); padding: 5pt;">
		Wire stuff together
		
	</td>
</tr>
</tbody>
</table><h2>Hardware setup</h2>Below is the diagram of how to connect them together. As you can see, we are using a ribbon cable to connect the Pi and the breadboard, also make sure the GPIO breakout aligns with the breadboard.
<img src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt6ec0deb9f113d3c6/5c98d4c7262c73954d53c60b/alarm-diagram.jpg" data-sys-asset-uid="blt6ec0deb9f113d3c6" alt="" "="">
The breadboard allow us to easily connect all the parts together, but you should be very careful. If you misconnect the VCC to GND, some bad things may happen (parts could get burned). The relay has two types of connection, one is for our warning light, the other side is connected to the breadboard, and there is an IO pin which should be connected to the breadboard labelled with P22. Remember that as we will be using it later.

	We also have put in a buzzer connected to the breadboard, the I/O pin is connected to P12, which has a PWM feature, and we will use it to control the sound buzzer later.

	After some wiring up, here is what it looks like:
<img src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt3c48dc7b8ae8ad42/5c98d4d355e02a1e5a5e9b00/alarm-hardware.jpg" data-sys-asset-uid="blt3c48dc7b8ae8ad42" alt="" "="">
<h2>Software setup</h2>Now the hardware is ready, let’s jump to the software part. The Raspberry Pi is based on the ARM CPU architecture and supports the Linux operating system. I will not teach you how to install a OS in Pi, because you can get very detailed instructions from <a href="https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up">Raspberry Pi’s official site</a>.
I have chosen RASPBIAN OS instead.
And now you should be able to use your favourite terminal tool to log into the Pi.
<h2>Controlling the Alarm with Python</h2>OK, let’s have some Python scripting fun by creating a script like this:
<pre class="prettyprint">#!/usr/bin/env python
import RPi.GPIO as GPIO
PIN_RELAY = 22
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(PIN_RELAY, GPIO.OUT)
GPIO.output(PIN_RELAY, GPIO.LOW)
</pre>At first, we imported a Python library RPi.GPIO, which is a neat Python package allowing you to operate the GPIO easily.

	Then, we set which GPIO pin we are going to operate. Our relay is connected on pin 22 so we set the variable PIN_RELAY to 22. We then setup the pin to GPIO.OUT mode, which means we are going to write out some data to this pin and we set a value GPIO.LOW to this pin. GPIO.LOW is the new state value of the pin, there is the other state GPIO.HIGH which we will use to control the relay, and relay will be switched on after you set the state to GPIO.LOW. If you set it back to GPIO.HIGH, the relay will be switched off. There is also a jumper on the relay to set the default state.

	Note that if you set it to GPIO.LOW before you set it to GPIO.HIGH, the relay will keep this state, which means that the alarm light keeps flashing. You can turn it off after a while, like this:
<pre class="prettyprint">time.sleep(2)
GPIO.output(PIN_RELAY, GPIO.HIGH)
</pre><div style="margin-left:0pt;">
</div>Now let’s see how to make a sound. It is pretty similar to the relay, the only difference is the pin code, since the sound buzzer is connected to pin 12. Let’s see the code below:
<pre class="prettyprint">PIN_AUDIO = 12 #gpio 12
GPIO.setup(PIN_AUDIO, GPIO.OUT)
GPIO.output(PIN_AUDIO, GPIO.LOW)
time.sleep(0.5)
GPIO.output(PIN_AUDIO, GPIO.HIGH)
</pre><h2>An alerting webhook service</h2>Building a webhook service is easy. We need to make sure that we call the webhook and it then calls the relay and buzzer. Let’s put it together using the code we built above, and a few extra sections:
<pre class="prettyprint">import os
import time
import RPi.GPIO as GPIO
from socket import *
PIN_AUDIO = 12 #gpio 12
PIN_RELAY = 22 #gpio 22
def setup():
 GPIO.setmode(GPIO.BCM) 
 GPIO.setwarnings(False)
 GPIO.setup(PIN_RELAY, GPIO.OUT)
 GPIO.setup(PIN_AUDIO, GPIO.OUT)
def alarm():
 GPIO.output(PIN_AUDIO, GPIO.LOW)
 GPIO.output(PIN_RELAY, GPIO.LOW)
 time.sleep(2)
 GPIO.output(PIN_RELAY, GPIO.HIGH)
 GPIO.output(PIN_AUDIO, GPIO.HIGH)
def createServer():
 serversocket = socket(AF_INET, SOCK_STREAM)
 serversocket.bind(('0.0.0.0',9000))
 serversocket.listen(3)
 while(1):
 (clientsocket, address) = serversocket.accept()
 alarm()
 clientsocket.send("HTTP/1.1 200 OK\n"
 +"Content-Type:application/json\n"
 +"\n" # Important!
 + '{"success":true}'
 +"\n")
 clientsocket.shutdown(SHUT_WR)
 clientsocket.close()
 serversocket.close()
def destroy():
 GPIO.output(PIN_RELAY, GPIO.HIGH)
 GPIO.output(PIN_RELAY, GPIO.HIGH)
 GPIO.cleanup() 
if __name__ == '__main__': 
 setup()
 try:
 createServer()
 except KeyboardInterrupt: 
 destroy()
</pre>Yay! We’ve just created a simple web server. You can start the webhook easily, just run: python web.py, it listens on port 9000, each time we access this port it will return a success message. Can’t be easier. But for our alerting usage this is enough.
<h2>Integrate with alerting</h2>We have a small Elasticsearch cluster running on Pi, but it can be on Elastic Cloud or on your own hardware. We also have Heartbeat to monitor several services, and we will create a Watch in Elasticsearch to watch the Heartbeat indices, and will be using our new webhook endpoint (192.168.1.200:9000) in the alerting action. Here is the full Watch:
<pre class="prettyprint">PUT _xpack/watcher/watch/server_is_down
{
 "trigger": {
 "schedule": {
 "interval": "1s"
 }
 },
 "input": {
 "search": {
 "request": {
 "search_type": "query_then_fetch",
 "indices": [
 "heartbeat-*"
 ],
 "types": [],
 "body": {
 "size": 0,
 "query": {
 "bool": {
 "must": [
 {
 "range": {
 "@timestamp": {
 "gte": "now-3s"
 }
 }
 },
 {
 "match": {
 "monitor.status": "down"
 }
 }
 ]
 }
 }
 }
 }
 }
 },
 "condition": {
 "compare": {
 "ctx.payload.hits.total": {
 "gte": 1
 }
 }
 },
 "actions": {
 "alarm_webhook": {
 "webhook": {
 "scheme": "http",
 "host": "192.168.1.200",
 "port": 9000,
 "method": "post",
 "params": {},
 "headers": {},
 "body": "SOS, server is down!"
 }
 }
 },
 "throttle_period_in_millis": 5000
}
</pre>As you can see the request above, the Watch will check the Heartbeat index every second.&nbsp;If it finds that at least one service is down in the most recent 3 seconds, the Watch will trigger a webhook action, and also we set the throttle period to 5 seconds to reduce repeat alerts.

	When the Watch is created, it will watch your cluster 24x7 without rest, and also you can view the execution history details from Watcher’s UI:
<img src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt8a3ad85fa58cb033/5c98d4cd166c55195f6cd4f6/alarm-dashboard.jpg" data-sys-asset-uid="blt8a3ad85fa58cb033" alt="" "="">
If you shutdown some service, you will get an alarm immediately.
Alerting with a webhook is really powerful.&nbsp;You may define your own webhook beyond just triggering a warning light, and you can also send the events to your own system, like Jira or GitHub, for further processing.
For more information about how to use Elasticsearch Alerting and how to define a Watch, please refer to this <a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.4/watcher-api-put-watch.html">doc</a>.
<h2>Show time</h2>Finally, it’s time to show our work. Check out this video below:
<div class="video embed-container" style="height: 319.725px;">
	<img style="width: 100%; margin: auto; display: block;" class="vidyard-player-embed" src="https://play.vidyard.com/GNeLehMybxzvYo4gEUc46Y.jpg" data-uuid="GNeLehMybxzvYo4gEUc46Y" data-v="4" data-type="inline">
</div><h2>Conclusion</h2>In this blog post, we used Raspberry Pi to connect the real world, and we also used the power of Elasticsearch to achieve real-time service monitoring. The most important thing is that getting a warning from real lights and a sound buzzer seems very cool. But when you get that kind of warning in your production&nbsp;environment, you should fix the issue right away.
All related scripts can be found in this <a href="https://github.com/medcl/pi-warning-light-for-elasticsearch">repo</a>.&nbsp;Have fun!

fire-truck-2000x415.jpg

fire-truck-720x420.jpg

Building a Real-World Alarm with Elasticsearch and Raspberry Pi

The Elastic Stack can be easily leveraged to monitor Go applications. It allows to do things like analyzing memory usage (memory leaks anyone?), performing long-term monitoring, tuning and capturing diagnostics. Beats in particular, the lightweight data shippers in the Stack, are designed to sit alongside the applications and are a natural fit for this kind of monitoring.Metricbeat is a Beat specialized in shipping service and/or server metrics, but also happens to be written in Go. It ships in a relatively small package (only about 10MB), and does not bring any additional dependencies with it. While its CPU overhead and memory footprint are also very light, it ships with modules for a variety of services such as:<ul><li>Apache</li><li>Couchbase</li><li>Docker</li><li>HAProxy</li><li>Kafka</li><li>MongoDB</li><li>MySQL</li><li>Nginx</li><li>PostgreSQL</li><li>Prometheus</li><li>Redis</li><li>System</li><li>ZooKeeper</li></ul>If the service you’re looking for is not listed, don’t worry: Metricbeat is extensible and <a href="https://www.elastic.co/guide/en/beats/metricbeat/current/creating-metricsets.html">you can easily implement a module</a> (and this post is proof of that!). We’d like to introduce you to the Golang Module for Metricbeat. It has merged into the master branch of <a href="https://github.com/elastic/beats/tree/master/metricbeat/module/golang">elastic/beats</a>, and is expected to be released in version 6.0.<h2>Sneak preview</h2>Here’s a Kibana Dashboard that captures the potential of the Golang Module for Metricbeat:<img asset_uid="blt4e97dc508fe57d70" src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt4e97dc508fe57d70/5bbf10620e6edaf014d240f0/kibana-dashboard-golang.jpg" alt="kibana-dashboard-golang.jpg" height="auto"/>The top panel shows a summary of the heap usage, which gives us a general idea of Go's memory usage and GC status:<ul><li>System Total Memory: the total number of bytes obtained from the system</li><li>Bytes allocated: overall bytes allocated, including memory that has since been freed</li><li>GC cycles: the number of garbage collections (GC) that occurred</li><li>GC limit: when heap memory allocation reaches this limit, the garbage collector is started. This can be different in each GC</li></ul>The middle panel has three charts in it with a breakdown of:<ul><li>heap memory</li><li>system memory</li><li>object statistics</li></ul>Heap Allocated represents both memory in use and not yet reclaimed, while Heap Inuse is obviously the size of objects that are active. Heap Idle accounts for objects that have been allocated but can be reclaimed as free memory.The two charts in the bottom panel are the GC time and GC count statistics. CPU Fraction represents the percentage of CPU time spent on GC. The greater the value, the more frequently GC occurs, in other words more time wasted on GC. The trend seems upward and pretty steep, but the range of values is between 0.41% and 0.52% so not too worrisome. Normally the GC ratio warns an optimization in the code when it goes into the single digits.<h3>Memory leaks</h3>With this information we will be able to know in much detail about Go's memory usage, distribution and GC implementation. For instance if we wanted to analyze whether there is a memory leak, we could check if the memory usage and heap memory allocation are somewhat stable. If for example GC Limit and Byte Allocation are clearly rising, it could be due to a memory leak.Historical information gives us great granularity in analyzing memory usage and GC patterns across different versions, or even commits!<h2>Great, now how do I get it?</h2><h3>expvar</h3>First things first, we need to enable Go's <a href="https://golang.org/pkg/expvar">expvar service</a>. expvar is a package in Go's standard library that exposes internal variables or statistics. Its usage is very simple, it's basically just a matter of importing the package in the application. It will automatically detect and register to an existing HTTP server:<pre class="prettyprint prettyprinted"></pre>If no HTTP server is available, the code below allows us to start one on port 6060:<pre class="prettyprint prettyprinted"></pre>The path registered by default is /debug/vars, we can access it at http://localhost:6060/debug/vars. It will expose data in JSON format, by default provides Go's <a href="https://golang.org/pkg/runtime/#MemStats">runtime.Memstats</a> but of course we can also register our own variables.<h3>Go Metricbeat!</h3>Now that we have an application with expvar, we can use Metricbeat to get this information into Elasticsearch. The installation of Metricbeat is very simple, it's just a matter of <a href="https://www.elastic.co/downloads/beats/metricbeat">downloading a package</a>. Before starting Metricbeat we just need modify the configuration file (metricbeat.yml) to enable the golang module:<pre class="prettyprint prettyprinted"></pre>The above configuration enables the Go monitoring module to poll for data every 10 seconds from heap.path. The other info that matters in the configuration file is the output:<pre class="prettyprint prettyprinted"></pre>Now assuming Elasticsearch is already running, we can finally start Metricbeat:<pre class="prettyprint prettyprinted"></pre>Now we are in business! Elasticsearch should have data, we can now start Kibana and customize the visualization for our needs. For this type of analysis <a href="https://www.elastic.co/guide/en/kibana/current/timelion.html">Timelion</a> is a particulary good fit, and to get started quickly we can leverage the existing sample <a href="https://www.elastic.co/guide/en/beats/metricbeat/current/metricbeat-sample-dashboards.html">Kibana Dashobards</a> for Metricbeat.<h3>More than memory</h3>In addition to monitoring the existing memory information, through expvar we can expose some additional internal information. For example we could do something like:<pre class="prettyprint prettyprinted"></pre>It's also possible to expose Metricbeat's internal stats, so it can basically can monitor itself. It can be done via the -httpprof option:<pre class="prettyprint prettyprinted"></pre>Now we can navigate to http://127.0.0.1:6060/debug/vars and see statistics about the Elasticsearch output such as output.elasticsearch.events.acked, which represents the message sent to Elasticsearch for which Metricbeat received an ACK:<pre class="prettyprint prettyprinted"></pre>We Metricbeat exposing its own metrics, we can modify its configuration to use both sets of metrics. We can do so by adding a new expvar type:<pre class="prettyprint prettyprinted"></pre>As you can see we also used the namespace parameter and set it to metricbeat. We can now restart Metricbeat and we should start seeing the new metric.<h4>Timelion</h4>We can take the output.elasticsearch.events.acked and output.elasticsearch.events.not_acked fields and use a simple Timelion expression to plot successes and failures in messages from Metricbeat to Elasticsearch:<pre class="prettyprint prettyprinted"></pre>Here's the result in Kibana:<img asset_uid="bltb97507142fea6f86" src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/bltb97507142fea6f86/5bbf106541d9d6bb1426368c/graph-golang.jpg" alt="graph-golang.jpg" height="auto"/>From the chart the channel between Metricbeat and Elasticsearch appears to be stable and no messages were lost.Finally, we can also compare the Metricbeat memory stats around the same time on the dashboard:<img asset_uid="bltbd45fb9460b34183" src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/bltbd45fb9460b34183/5bbf106a0e6edaf014d240f6/graph-golang2.jpg" alt="graph-golang2.jpg" height="auto"/><h2>Coming up in Beats 6</h2>This module will be released with Beats 6.0, but you can start using it right now by cloning (or forking ;) the <a href="https://github.com/elastic/beats">Beats repo</a> on GitHub and building the binary yourself.Banner image credit: <a href="https://golang.org/doc/gopher">golang.org</a>

banner-five-years-animals-pig-brain-machine.jpg

thumb-five-years-animals-pig-brain-machine.jpg

Tuning Go Apps with Metricbeat

Start free trial

Blog Footer CTA

Sign up for Elastic Cloud free trial

Medcl Zeng

By submitting you acknowledge that you've read and agree to our <a href="/legal/elastic-cloud-account-terms" target="_self">Terms of Service</a>, and you agree to receive the <a href="/legal/privacy-statement#how-we-use-the-information" target="_self">selected communications</a> at the contact details you provided above. See <a href="/legal/privacy-statement/" target="_self">Elastic’s Privacy Statement</a> for more details or to opt-out at any time.

Communication Preferences - ONLY for /communication-preferences

제출하면 귀하가 <a href="/kr/legal/elastic-cloud-account-terms" target="_self">Elastic 서비스 약관</a>을 읽고 이에 동의하며, 위에 제공된 연락처로 <a href="/kr/legal/privacy-statement#how-we-use-the-information" target="_self">선택한 커뮤니케이션</a>을 수신하는 데 동의한 것으로 간주됩니다. 언제든지 수신을 거부할 수 있으며 자세한 내용은 <a href="/kr/legal/privacy-statement/" target="_self">Elastic 개인정보 취급방침</a>을 참조하시기 바랍니다.

By submitting you acknowledge that you've read and agree to our <a href="/legal/serverless-preview-terms" target="_blank">Terms of Service</a>, and that Elastic may <a href="/legal/privacy-statement#how-we-use-the-information" target="_blank">contact you</a> about our related products and services, using the details you provide above. See <a href="/legal/privacy-statement/" target="_blank">Elastic’s Privacy Statement</a> for more details or to opt-out at any time.

Serverless GDPR Text

제출하면 귀하가 Elastic <a href="/kr/legal/serverless-preview-terms" target="_self">서비스 약관</a>을 읽고 이에 동의하며, 위에 제공된 세부 정보를 사용하여 Elastic이 관련 제품 및 서비스에 대해 귀하에게 <a href="/kr/legal/privacy-statement#how-we-use-the-information" target="_self">연락할 수 있음</a>을 이해한 것으로 간주됩니다. 언제든지 수신을 거부할 수 있으며 자세한 내용은 <a href="/kr/legal/privacy-statement/" target="_self">Elastic 개인정보 취급방침</a>을 참조하시기 바랍니다.

By submitting you agree to <a href="/agreements/global/cloud-services-monthly" rel="nofollow">Elastic Cloud Terms of Service</a>. Your personal data will be processed in accordance with <a href="/legal/privacy-statement">Elastic's Privacy Statement</a>.

Cloud Trial GDPR Text

제출하면 <a href="/kr/agreements/global/cloud-services-monthly" rel="nofollow">Elastic Cloud 서비스 약관</a>에 동의하시게 됩니다. 개인 데이터는 <a href="/kr/legal/privacy-statement">Elastic의 개인정보 취급방침</a>에 따라 처리됩니다.

By submitting you acknowledge that you've read and agree to our <a href="/legal/terms-of-use" target="_blank">Terms of Service</a>, and that Elastic may <a href="/legal/privacy-statement#how-we-use-the-information" target="_blank">contact you</a> about our related products and services, using the details you provide above. See <a href="/legal/privacy-statement/" target="_blank">Elastic’s Privacy Statement</a> for more details or to opt-out at any time.

Newsletter GDPR Text

제출하면 귀하가 Elastic <a href="/kr/legal/terms-of-use" target="_self">서비스 약관</a>을 읽고 이에 동의하며, 위에 제공된 세부 정보를 사용하여 Elastic이 관련 제품 및 서비스에 대해 귀하에게 <a href="/kr/legal/privacy-statement#how-we-use-the-information" target="_self">연락할 수 있음</a>을 이해한 것으로 간주됩니다. 언제든지 수신을 거부할 수 있으며 자세한 내용은 <a href="/kr/legal/privacy-statement/" target="_self">Elastic 개인정보 취급방침</a>을 참조하시기 바랍니다.

Explore similar demos

Overview

Speakers

Close

See more insights

The content on this page is not available in the selected language. As Elastic grows globally, we continue to support content in multiple languages.

The content on this page is not available in the selected language.

이 페이지의 콘텐츠는 선택하신 언어로 제공되지 않습니다. Elastic은 다양한 언어로 콘텐츠를 제공하기 위해 최선을 다하고 있습니다.조금만 더 기다려주세요!

Author

Articles by

Learn more

Watch now (no PT)

Watch now

See all top stories

All (no PT translation)

Contact information

Press Release

Share on Reddit

Share this story

Share by Email

Thank you for your interest!

Contact Info

Follow us on Youtube

Load More

Share on LinkedIn

Follow us on LinkedIn

Search Integrations

All Solutions

Video for

Follow us on Twitter

See when this webinar starts in my time zone

내 표준 시간대로 웨비나 시작 시간 확인하기

Register to Watch

Register now

See All Posts

Can't make it? Register and we'll send you the recording. You'll also receive an email with related content

참여가 어려우신가요? 등록하시면 녹화 자료를 보내드리겠습니다. 이메일로 관련 콘텐츠도 받아보실 수 있습니다.

Small image for

On-demand webinar

Featured webinar

Register to Attend

Share on Facebook

Reset all

Upcoming webinar

View more posts

Print

Hosted by

Sign In to Attend

View next

Follow us on Facebook

Share

Highlights

Read less

You'll also receive an email with related content

이메일을 통해 관련 내용을 보내드리겠습니다.

Thank you for registering. We will send you a confirmation email soon.

등록해 주셔서 감사합니다. 곧 확인 이메일을 보내드리겠습니다.

Author

Articles by Medcl Zeng

Building a Real-World Alarm with Elasticsearch and Raspberry Pi

Tuning Go Apps with Metricbeat

Sign up for Elastic Cloud free trial