Skip to content
Permalink
Browse files
Ops guides updates for monitoring and disk space
Some additions to the User Guide "Operations" section, covering start,
monitoring and stopping the server, and a discussion of its disk space
usage.
  • Loading branch information
rdowner committed Jun 20, 2016
1 parent 4cfb123 commit 07101c40758f286a4a084ff6828c7e16a3dc999b
Show file tree
Hide file tree
Showing 3 changed files with 104 additions and 0 deletions.
@@ -3,6 +3,7 @@ title: Operations
started-pdf-exclude: true
layout: website-normal
children:
- starting-stopping-monitoring.md
- server-cli-reference.md
- cli/
- gui/
@@ -19,6 +19,43 @@ at least 8GB RAM and 100GB disk. The disk is just for logs, a small amount of pe
any binaries for custom blueprints/integrations.


### Disk Space

There are three main consumers of disk space:

* **Static files**: these are the Apache Brooklyn files themselves, plus
binaries for custom blueprints and integrations added to the `lib` directory.
* **Persisted state**: when using [Persistence](persistence/index.html) -- which
is a prerequisite for [High Availability](high-availability.html) -- Brooklyn
will save data to a store location. Items in the persisted state include
metadata about the Brooklyn servers, catalog items, and metadata about all
running applications and entities.
* **Log files**: Brooklyn writes detailed log files by default to its own
installation directory. This can be reconfigured to change the destination
files, and increase or decrease the detail of the logs. See the
[Logging](logging.html) page for more details.


The Apache Brooklyn distribution itself, when unpacked, consumes approximately
75MB of disk space. The space consumed by additional binaries for custom
blueprints and integrations is application-specific.

Persisted state, excluding catalog data, is relatively small, starting at
approximately 300KB for a clean, idle Brooklyn server. Deploying blueprints will
add to this - how much depends exactly on the entities involved and is therefore
application specific, but as a guideline, a 3-node Riak cluster adds
approximately 500KB to the persistence store.

Log data can be a large consumer of disk space. By default Brooklyn generates
two logfiles, one which logs notable information only, and another which logs at
a debug level. Each logfile rotates when it hits a size of 100MB; a maximum of
10 log files are retained for each type. The two logging streams combined,
therefore, can consume up to 2GB of disk space. In the default configuration
logs are saved to the Brooklyn installation directory. You will most likely want
to [reconfigure Brooklyn's logging](logging.html) to save logs to a location
elsewhere, and to rotate logs according to your organisation's policy.


## Supported Operating Systems

The recommended operating system is CentOS 6.x or RedHat 6.x.
@@ -0,0 +1,66 @@
---
title: Starting, Stopping and Monitoring
layout: website-normal
---

**NOTE:** This document is for information on starting an Apache Brooklyn
Server. For information on using the Brooklyn Client CLI to access an already
running Brooklyn Server, refer to [Client CLI Reference](cli/index.html).


## Starting

To launch Brooklyn, from the directory where Brooklyn is unpacked, run:

{% highlight bash %}
% bin/brooklyn launch > /dev/null 2>&1 & disown
{% endhighlight %}

With no configuration, this will launch the Brooklyn web console and REST API on [`http://localhost:8081/`](http://localhost:8081/).
No password is set, but the server is listening only on the loopback network interface for security.
Once [security is configured](brooklyn_properties.html), Brooklyn will listen on all network interfaces by default.

See the [Server CLI Reference](server-cli-reference.html) for more information
about the Brooklyn server process.

The Brooklyn startup script will create a file name `pid_java` at the root of
the Brooklyn directory, which contains the PID of the last Brooklyn process to
be started.


## Stopping

To stop Brooklyn, simply send a `TERM` signal to the Brooklyn process. The PID
of the most recently run Brooklyn process can be found in the `pid_java` file at
the root of the Brooklyn directory.

For example:

{% highlight bash %}
% kill $( cat pid_java )
{% endhighlight bash %}


## Monitoring

As already mentioned, the Brooklyn startup script will create a file name
`pid_java` at the root of the Brooklyn directory, which contains the PID of the
last Brooklyn process to be started. You can examine this file to discover the
PID, and then test that the process is still running.

This should lead to a fairly straightforward integration with many monitoring
tools - the monitoring tool can discover the expected PID, and can execute the
start or stop commands shown above as necessary.

For example, here is a fragment of a `monitrc` file as used by [Monit](http://https://mmonit.com/monit/):

{% highlight text %}
check process apachebrooklyn with pidfile /opt/apache-brooklyn/pid_java
start program = "/bin/bash -c '/opt/apache-brooklyn/bin/brooklyn launch & disown'" with timeout 10 seconds
stop program = "/bin/bash -c 'kill $( cat /opt/apache-brooklyn/pid_java )'"
{% endhighlight %}

In addition to monitoring the Brooklyn process itself, you will almost certainly
want to monitor resource usage of Brooklyn. In particular, please see the
[Requirements](requirements.html#disk-space) section for a discussion on Brooklyn's disk
space requirements.

0 comments on commit 07101c4

Please sign in to comment.