El siguiente artículo es una colaboración entre Franco Díaz Hurtado (AKA @Franco_Sparrow) y mia Alexander Rivas Alpizar (AKA@alexminator). También es un update del articulo que escribiera Franco hace un tiempo sobre NetData. En el mismo les mostraremos como implementar un sistema de monitoreo en tiempo real con muchísima información basado en Netdata y la forma de hacer que esas métricas se guarden por periodos de tiempos más largos. Bueno, manos a la obra.
ÍNDICE
Netdata.
Implementación y configuración de Netdata.
Prerrequisitos de instalación de Netdata sin internet.
Configuración de Netdata-master.
Proxy inverso para autenticación de Netdata.
HTTPS con certificado SSL auto-firmado para Nginx.
Configurando Nginx para usar SSL.
Creando un Fragmento de Configuración Apuntando a la Llave y Certificado SSL.
Creando una Porción de Configuración con Fuertes Opciones de Encriptación.
Ajustando la Configuración de Nginx para usar SSL.
Script anticrash para Netdata.
Prometheus.
Implementación y configuración de Prometheus.
Comprobando resultados en servidor Prometheus.
Grafana.
Implementación y configuración de Grafana.
Integrando Prometheus con Grafana.
Datos
Sistema Operativo de los servidores: Debian 10 (Buster)
Servidor Netdata: 192.168.120.203 (netdata.empresa.midominio.cu)
Servidor Prometheus: 192.168.120.205 (prometheus.empresa.midominio.cu)
Servidor Grafana: 192.168.120.207 (grafana.empresa.midominio.cu)
Versión de Netdata: v1.26.0
Versión de Prometheus: v2.23.0 (aunque también es compatible el procedimiento con la versión v2.21.0)
Versión de Grafana: v7.3.5
Puertos a tener en cuenta para su Firewall:
(19999) por el protocolo (TCP), para Netdata
(9090) por el protocolo (TCP), para Prometheus
(9100) por el protocolo (TCP), para Prometheus Node Exporter
(3000) por el protocolo (TCP), para Grafana
¿Qué es lo que se quiere?
Se desea una solución que permita la monitorización de las métricas de los host Linux y que esta monitorización sea en tiempo real, pero que además brinde la posibilidad de históricos. Para resolver esta problemática se escogieron como soluciones: Netdata, Prometheus y Grafana. Estos servicios distribuidos en servidores independientes, propiciarán una solución conjunta que nos aportará los resultados esperados para métricas en tiempo real e históricos.
La siguiente arquitectura es una propuesta hecha en la documentación oficial de Netdata:
Todos los servidores deben estar sincronizados en tiempo con el PDC y usando la misma zona horaria, para que no haya inconsistencias en la representación gráfica en el tiempo de las métricas de Netdata.
NOTA: El procedimiento descrito en este tutorial ha de seguirse respetando las versiones de los softwares que serán utilizados en el mismo.
¿Qué es Netdata?
Netdata es una herramienta para visualizar y monitorear métricas en tiempo real, optimizada para acumular todo tipo de datos, como uso de CPU, actividad de disco, consultas SQL, visitas a un sitio web, entre otros. La herramienta está diseñada para visualizar el ahora en el mayor detalle posible, permitiendo al usuario obtener una visión de lo que está sucediendo y lo que acaba de suceder en su sistema o aplicación, siendo una opción ideal para solucionar problemas de desempeño en tiempo real. Su objetivo es brindar métricas en tiempo real.
Consiste en un demonio que, al ejecutarse, se encarga de obtener información en tiempo real, por segundo, y presentarla en un sitio web para su visualización y análisis. La presentación es interactiva y en tiempo real. Se trata de una herramienta ligera, en su mayor parte escrita en C, la cual presenta bajos niveles de consumo durante su ejecución: alrededor de 2% de uso para un CPU de un único hilo y unos pocos megabytes de RAM. Puede ejecutarse en cualquier kernel GNU/Linux para monitorear cualquier sistema o aplicación, siendo posible correrla en PCs, servidores o dispositivos embebidos Linux.
Implementación y configuración de Netdata.
Como mínimo, Netdata requiere las siguientes bibliotecas y herramientas para compilarse y ejecutarse correctamente:
libuuid
libuv version 1.0 o superior
zlib
GNU autoconf
GNU automake
GCC o Xcode (Clang se sabe que tiene problemas en ciertas configuraciones, consulte uso de Clang)
Una versión de make compatible con GNU automake
Git (usamos git en el sistema de compilación para generar información de la versión, no necesitamos una instalación completa, solo un comando git show que funcione)
Además, las siguientes características de tiempo de compilación requieren dependencias adicionales:
Soporte TLS para la GUI web:
OpenSSL 1.0.2 o más reciente o LibreSSL 3.0.0 o más reciente.
almacenamiento métrico dbengine:
liblz4 r129 o más reciente
OpenSSL 1.0 o más reciente (LibreSSL amy funciona, pero en gran parte no está probado).
libJudy
Soporte de Netdata Cloud:
Una conexión a Internet en funcionamiento
Una versión reciente de CMake
OpenSSL 1.0.2 o más reciente o LibreSSL 3.0.0 o más reciente.
JSON-C (puede ser proporcionado por el usuario como se muestra a continuación, o por el sistema)
En todos los hosts Linux, que van a implementar Netdata instalar los siguientes Pre-requisitos:
apt install autoconf autoconf-archive autogen automake cmake curl gcc git libelf-dev libjson-c-dev libjudy-dev liblz4-dev libmnl-dev libssl-dev libtool libuv1-dev lm-sensors make nodejs pkg-config python-mysqldb python-psycopg2 python-pymongo uuid-dev zlib1g-dev wget python uuid-runtime bash iproute2 python-yaml python-beanstalkc python-dnspython python-ipaddress libmnl0 libmnl-dev netcat libuv1 liblz4-1 openssl
En dependencia del servidor que se instale puede que les advierta que ya muchos de esos paquetes ya estan instalados y actuales.
Prerrequisitos de instalación de Netdata sin internet
Para nuestro articulo usaremos la version 1.26.0 de NetData que es la actual en el momento que se realizó este tutorial. Las siguientes configuraciones son necesarias si se quiere instalar Netdata en un servidor que no cuente con acceso a internet. Se deberá preparar el escenario, mediante la modificación del script de instalación y se debe descargar el software necesario desde un host que sí cuente con acceso a internet. Desde un host con acceso a internet, descargamos el software de Netdata y algunas dependencias necesarias:
https://github.com/netdata/netdata/archive/v1.26.0.zip
https://github.com/netdata/mosquitto/archive/v.1.6.8_Netdata-5.tar.gz
https://github.com/warmcat/libwebsockets/archive/v3.2.2.tar.gz
https://github.com/json-c/json-c/archive/json-c-0.15.tar.gz
https://github.com/netdata/libbpf/archive/v0.0.9_netdata-1.tar.gz
https://github.com/netdata/dashboard/releases/download/v2.10.1/dashboard.tar.gz
https://github.com/netdata/kernel-collector/releases/download/v0.4.9/netdata-kernel-collector-glibc-v0.4.9.tar.xz
Los paquetes descargados anteriormente, se los subimos al servidor a su directorio “/tmp” y le cambiamos el nombre a algunos de ellos. Esto será necesario para que funcione el script de instalación que se modificará más adelante:
cd /tmp mv mosquitto-v.1.6.8_Netdata-4.tar.gz v.1.6.8_Netdata-5.tar.gz mv libwebsockets-3.2.2.tar.gz 3.2.2.tar.gz mv libbpf-0.0.9_netdata-1.tar.gz 0.0.9_netdata-1.tar.gz
Creamos los siguientes directorios y les damos los permisos adecuados:
mkdir netdata-mosquitto/ \
netdata-libwebsockets/ \
netdata-jsonc/ \
netdata-libbpf/ \
netdata-dashboard/ \
netdata-ebpf/
chmod 700 netdata-*
Movemos los paquetes a sus respectivos directorios:
mv v.1.6.8_Netdata-5.tar.gz netdata-mosquitto mv 3.2.2.tar.gz netdata-libwebsockets mv json-c-0.15.tar.gz netdata-jsonc mv 0.0.9_netdata-1.tar.gz netdata-libbpf mv dashboard.tar.gz netdata-dashboard mv netdata-kernel-collector-glibc-v0.4.9.tar.xz netdata-ebpf
Copiamos el software de Netdata al directorio “/opt” y lo descompactamos:
cd /opt unzip netdata-1.26.0.zip cd netdata-1.26.0/
Dentro del contenido de la carpeta netdata encontraremos el script de instalación lo editaremos, adaptándolo a un sistema offline (sin salida a internet):
nano netdata-installer.sh
Comentamos la siguiente línea y la dejamos como sigue:
# MOSQUITTO_PACKAGE_VERSION="$(cat packaging/mosquitto.version)" MOSQUITTO_PACKAGE_VERSION="v.1.6.8_Netdata-5"
Comentamos la siguiente línea y la dejamos como sigue:
# tmp="$(mktemp -d -t netdata-mosquitto-XXXXXX)" tmp="/tmp/netdata-mosquitto"
Comentamos las siguientes líneas y dejamos las demás como se muestran:
# if fetch_and_verify "mosquitto" \
# "https://github.com/netdata/mosquitto/archive/${MOSQUITTO_PACKAGE_BASENAME}" \
# "${MOSQUITTO_PACKAGE_BASENAME}" \
# "${tmp}" \
# "${NETDATA_LOCAL_TARBALL_OVERRIDE_MOSQUITTO}"; then
if run tar -xf "${tmp}/${MOSQUITTO_PACKAGE_BASENAME}" -C "${tmp}" &&
build_libmosquitto "${tmp}/mosquitto-${MOSQUITTO_PACKAGE_VERSION}" &&
copy_libmosquitto "${tmp}/mosquitto-${MOSQUITTO_PACKAGE_VERSION}" &&
rm -rf "${tmp}"; then
run_ok "libmosquitto built and prepared."
else
run_failed "Failed to build libmosquitto."
if [ -n "${NETDATA_REQUIRE_CLOUD}" ]; then
exit 1
else
defer_error_highlighted "Unable to fetch sources for libmosquitto. You will not be able to connect this node to Netdata Cloud."
fi
fi
# else
# run_failed "Unable to fetch sources for libmosquitto."
# if [ -n "${NETDATA_REQUIRE_CLOUD}" ]; then
# exit 1
# else
# defer_error_highlighted "Unable to fetch sources for libmosquitto. You will not be able to connect this node to Netdata Cloud."
# fi
# fi
}
Comentamos la siguiente línea y la dejamos como sigue:
# LIBWEBSOCKETS_PACKAGE_VERSION="$(cat packaging/libwebsockets.version)" LIBWEBSOCKETS_PACKAGE_VERSION="3.2.2"
Comentamos la siguiente línea y la dejamos como sigue:
# tmp="$(mktemp -d -t netdata-libwebsockets-XXXXXX)" tmp="/tmp/netdata-libwebsockets"
Comentamos la siguiente línea y la dejamos como sigue:
# LIBWEBSOCKETS_PACKAGE_BASENAME="v${LIBWEBSOCKETS_PACKAGE_VERSION}.tar.gz"
LIBWEBSOCKETS_PACKAGE_BASENAME="${LIBWEBSOCKETS_PACKAGE_VERSION}.tar.gz"
Comentamos las siguientes líneas y dejamos las demás como se muestran:
# if fetch_and_verify "libwebsockets" \
# "https://github.com/warmcat/libwebsockets/archive/${LIBWEBSOCKETS_PACKAGE_BASENAME}" \
# "${LIBWEBSOCKETS_PACKAGE_BASENAME}" \
# "${tmp}" \
# "${NETDATA_LOCAL_TARBALL_OVERRIDE_LIBWEBSOCKETS}"; then
if run tar -xf "${tmp}/${LIBWEBSOCKETS_PACKAGE_BASENAME}" -C "${tmp}" &&
build_libwebsockets "${tmp}/libwebsockets-${LIBWEBSOCKETS_PACKAGE_VERSION}" &&
copy_libwebsockets "${tmp}/libwebsockets-${LIBWEBSOCKETS_PACKAGE_VERSION}" &&
rm -rf "${tmp}"; then
run_ok "libwebsockets built and prepared."
else
run_failed "Failed to build libwebsockets."
if [ -n "${NETDATA_REQUIRE_CLOUD}" ]; then
exit 1
else
defer_error_highlighted "Failed to build libwebsockets. You may not be able to connect this node to Netdata Cloud."
fi
fi
# else
# run_failed "Unable to fetch sources for libwebsockets."
# if [ -n "${NETDATA_REQUIRE_CLOUD}" ]; then
# exit 1
# else
# defer_error_highlighted "Unable to fetch sources for libwebsockets. You may not be able to connect this node to Netdata Cloud."
# fi
# fi
}
Comentamos la siguiente línea y la dejamos como sigue:
# JSONC_PACKAGE_VERSION="$(cat packaging/jsonc.version)" JSONC_PACKAGE_VERSION="0.15"
Comentamos la siguiente línea y la dejamos como sigue:
# tmp="$(mktemp -d -t netdata-jsonc-XXXXXX)" tmp="/tmp/netdata-jsonc"
Comentamos las siguientes líneas y dejamos las demás como se muestran:
# if fetch_and_verify "jsonc" \
# "https://github.com/json-c/json-c/archive/${JSONC_PACKAGE_BASENAME}" \
# "${JSONC_PACKAGE_BASENAME}" \
# "${tmp}" \
# "${NETDATA_LOCAL_TARBALL_OVERRIDE_JSONC}"; then
if run tar -xf "${tmp}/${JSONC_PACKAGE_BASENAME}" -C "${tmp}" &&
build_jsonc "${tmp}/json-c-json-c-${JSONC_PACKAGE_VERSION}" &&
copy_jsonc "${tmp}/json-c-json-c-${JSONC_PACKAGE_VERSION}" &&
rm -rf "${tmp}"; then
run_ok "JSON-C built and prepared."
else
run_failed "Failed to build JSON-C."
if [ -n "${NETDATA_REQUIRE_CLOUD}" ]; then
exit 1
else
defer_error_highlighted "Failed to build JSON-C. Netdata Cloud support will be disabled."
fi
fi
# else
# run_failed "Unable to fetch sources for JSON-C."
# if [ -n "${NETDATA_REQUIRE_CLOUD}" ]; then
# exit 1
# else
# defer_error_highlighted "Unable to fetch sources for JSON-C. Netdata Cloud support will be disabled."
# fi
# fi
}
Comentamos la siguiente línea y la dejamos como sigue:
# LIBBPF_PACKAGE_VERSION="$(cat packaging/libbpf.version)" LIBBPF_PACKAGE_VERSION="0.0.9_netdata-1"
Comentamos la siguiente línea y la dejamos como sigue:
# tmp="$(mktemp -d -t netdata-libbpf-XXXXXX)" tmp="/tmp/netdata-libbpf"
Comentamos la siguiente línea y la dejamos como sigue:
# LIBBPF_PACKAGE_BASENAME="v${LIBBPF_PACKAGE_VERSION}.tar.gz"
LIBBPF_PACKAGE_BASENAME="${LIBBPF_PACKAGE_VERSION}.tar.gz"
Comentamos las siguientes líneas y dejamos las demás como se muestran:
# if fetch_and_verify "libbpf" \
# "https://github.com/netdata/libbpf/archive/${LIBBPF_PACKAGE_BASENAME}" \
# "${LIBBPF_PACKAGE_BASENAME}" \
# "${tmp}" \
# "${NETDATA_LOCAL_TARBALL_OVERRIDE_LIBBPF}"; then
if run tar -xf "${tmp}/${LIBBPF_PACKAGE_BASENAME}" -C "${tmp}" &&
build_libbpf "${tmp}/libbpf-${LIBBPF_PACKAGE_VERSION}" &&
copy_libbpf "${tmp}/libbpf-${LIBBPF_PACKAGE_VERSION}" &&
rm -rf "${tmp}"; then
run_ok "libbpf built and prepared."
else
run_failed "Failed to build libbpf."
if [ -n "${NETDATA_DISABLE_EBPF}" ] && [ ${NETDATA_DISABLE_EBPF} = 0 ]; then
exit 1
else
defer_error_highlighted "Failed to build libbpf. You may not be able to use eBPF plugin."
fi
fi
# else
# run_failed "Unable to fetch sources for libbpf."
# if [ -n "${NETDATA_DISABLE_EBPF}" ] && [ ${NETDATA_DISABLE_EBPF} = 0 ]; then
# exit 1
# else
# defer_error_highlighted "Unable to fetch sources for libbpf. You may not be able to use eBPF plugin."
# fi
# fi
}
Comentamos la siguiente línea y la dejamos como sigue:
# DASHBOARD_PACKAGE_VERSION="$(cat packaging/dashboard.version)" DASHBOARD_PACKAGE_VERSION="v2.10.1"
Comentamos la siguiente línea y la dejamos como sigue:
# tmp="$(mktemp -d -t netdata-dashboard-XXXXXX)" tmp="/tmp/netdata-dashboard"
Comentamos las siguientes líneas y dejamos las demás como se muestran:
# if fetch_and_verify "dashboard" \
# "https://github.com/netdata/dashboard/releases/download/${DASHBOARD_PACKAGE_VERSION}/${DASHBOARD_PACKAGE_BASENAME}" \
# "${DASHBOARD_PACKAGE_BASENAME}" \
# "${tmp}" \
# "${NETDATA_LOCAL_TARBALL_OVERRIDE_DASHBOARD}"; then
if run tar -xf "${tmp}/${DASHBOARD_PACKAGE_BASENAME}" -C "${tmp}" &&
copy_react_dashboard "${tmp}/build" &&
rm -rf "${tmp}"; then
run_ok "React dashboard installed."
else
run_failed "Failed to install React dashboard. The install process will continue, but you will not be able to use the new dashboard."
fi
# else
# run_failed "Unable to fetch React dashboard. The install process will continue, but you will not be able to use the new dashboard."
# fi
}
Comentamos la siguiente línea y la dejamos como sigue:
# EBPF_VERSION="$(cat packaging/ebpf.version)" EBPF_VERSION="v0.4.9"
Comentamos la siguiente línea y la dejamos como sigue:
# tmp="$(mktemp -d -t netdata-ebpf-XXXXXX)" tmp="/tmp/netdata-ebpf"
Comentamos las siguientes líneas:
# if ! fetch_and_verify "ebpf" \
# "https://github.com/netdata/kernel-collector/releases/download/${EBPF_VERSION}/${EBPF_TARBALL}" \
# "${EBPF_TARBALL}" \
# "${tmp}" \
# "${NETDATA_LOCAL_TARBALL_OVERRIDE_EBPF}"; then
# run_failed "Failed to download eBPF collector package"
# echo 2>&" Removing temporary directory ${tmp} ..."
# rm -rf "${tmp}"
# return 1
# fi
Instalación de Netdata.
Si el servidor en el cual se va a instalar Netdata, cuenta con acceso a internet, no es necesario hacer ninguna de las modificaciones anteriores y se hace uso del script original. En mi caso particular que estoy detrás de un proxy padre tuve dificultades para correr el script. Investigando la razón me di cuenta que los repositorios de netdata usan certificados ssl (https) y el comando curl al parecer no se lleva muy bien con los certificados. Por lo que me di a la tarea de modificar los scripts para usar wget que es mucho más noble en ese sentido. A continuación les dejo los cambios que realice en los ficheros involucrados con la instalación automática de netdata.
Nota: Si usted no está detrás de un proxy padre y cuenta con conexión a internet no necesitara modificar nada. También si desea probar suerte con el comando curl que es el que por defecto usa el script podrá hacerlo.
Comenzaremos editando el fichero functions.sh donde se declaran todas las funciones que usara el script.
nano /opt/netdata-1.26.0/packaging/installer/functions.sh
Dentro buscaremos la funcion get y editamos lo siguiente:
buscar:
get() {
url="${1}"
if command -v curl > /dev/null 2>&1; then
curl -q -o - -sSL --connect-timeout 10 --retry 3 "${url}"
elif command -v wget > /dev/null 2>&1; then
wget -T 15 -O - "${url}"
else
editar:
get() {
url="${1}"
if command -v wget > /dev/null 2>&1; then
wget -T 15 -O - "${url}"
elseDentro buscaremos la funcion download_file y editamos lo siguiente:
buscar:
download_file() {
url="${1}"
dest="${2}"
name="${3}"
opt="${4}"
if command -v curl > /dev/null 2>&1; then
run curl -q -sSL --connect-timeout 10 --retry 3 --output "${dest}" "${url}"
elif command -v wget > /dev/null 2>&1; then
run wget -T 15 -O "${dest}" "${url}"
else
editar:
download_file() {
url="${1}"
dest="${2}"
name="${3}"
opt="${4}"
if command -v wget > /dev/null 2>&1; then
run wget -T 15 -O "${dest}" "${url}"
elseAhora editaremos todos los ficheros que instalan las dependencias necesarias. Todos a aparecen bajo la etiqueta de bundle-dependencia
/opt/netdata-1.26.0/packaging/bundle-dashboard.sh
buscar:
curl -sSL --connect-timeout 10 --retry 3 "https://github.com/netdata/dashboard/releases/download/${DASHBOARD_VERSION}/${DASHBOARD_TARBALL}" > "${DASHBOARD_TARBALL}" || exit 1
editar:
wget -O- "https://github.com/netdata/dashboard/releases/download/${DASHBOARD_VERSION}/${DASHBOARD_TARBALL}" > "${DASHBOARD_TARBALL}" || exit 1/opt/netdata-1.26.0/packaging/bundle-ebpf.sh
buscar:
curl -sSL --connect-timeout 10 --retry 3 "https://github.com/netdata/kernel-collector/releases/download/${EBPF_VERSION}/${EBPF_TARBALL}" > "${EBPF_TARBALL}" || exit 1
editar:
wget -O- "https://github.com/netdata/kernel-collector/releases/download/${EBPF_VERSION}/${EBPF_TARBALL}" > "${EBPF_TARBALL}" || exit 1/opt/netdata-1.26.0/packaging/bundle-judy.sh
buscar:
curl -sSL --connect-timeout 10 --retry 3 "https://github.com/netdata/libjudy/archive/${JUDY_TARBALL}" > "${JUDY_TARBALL}" || exit 1
editar:
wget -O- "https://github.com/netdata/libjudy/archive/${JUDY_TARBALL}" > "${JUDY_TARBALL}" || exit 1/opt/netdata-1.26.0/packaging/bundle-libbpf.sh
buscar:
curl -sSL --connect-timeout 10 --retry 3 "https://github.com/netdata/libbpf/archive/${LIBBPF_TARBALL}" > "${LIBBPF_TARBALL}" || exit 1
editar:
wget -O- "https://github.com/netdata/libbpf/archive/${LIBBPF_TARBALL}" > "${LIBBPF_TARBALL}" || exit 1
/opt/netdata-1.26.0/packaging/bundle-lws.sh
buscar:
curl -sSL --connect-timeout 10 --retry 3 "https://github.com/warmcat/libwebsockets/archive/${LWS_TARBALL}" > "${LWS_TARBALL}" || exit 1
editar:
wget -O- "https://github.com/warmcat/libwebsockets/archive/${LWS_TARBALL}" > "${LWS_TARBALL}" || exit 1/opt/netdata-1.26.0/packaging/bundle-mosquitto.sh
buscar:
curl -sSL --connect-timeout 10 --retry 3 "https://github.com/netdata/mosquitto/archive/${MOSQUITTO_TARBALL}" > "${MOSQUITTO_TARBALL}" || exit 1
editar:
wget -O- "https://github.com/netdata/mosquitto/archive/${MOSQUITTO_TARBALL}" > "${MOSQUITTO_TARBALL}" || exit 1Una vez ya preparado todo ya sea sin modificar el script instalador y usando internet, modificándolo para que use wget con internet o modificándola para su uso offline procederemos a instalarlo.
Nota: El siguiente procedimiento se usará para todos los hosts (master o slaves) en los que se vaya a instalar Netdata.
Ejecutamos el script de instalación. La opción especificada “–disable-go” evitará que se intente descargar e instalar de internet el paquete «go.d.plugin», mientras que la opción “–disable-telemetry” evitará que se envíen estadísticas a Google.
./netdata-installer.sh --disable-go --disable-telemetry
Debe devolver algo como esto:
^ |.-. .-. .-. .-. . netdata | '-' '-' '-' '-' real-time performance monitoring, done right! +----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+---> You are about to build and install netdata to your system. The build process will use /tmp for any temporary files. You can override this by setting $TMPDIR to a writable directory where you can execute files. It will be installed at these locations: - the daemon at /usr/sbin/netdata - config files in /etc/netdata - web files in /usr/share/netdata - plugins in /usr/libexec/netdata - cache files in /var/cache/netdata - db files in /var/lib/netdata - log files in /var/log/netdata - pid file at /var/run/netdata.pid - logrotate file at /etc/logrotate.d/netdata This installer allows you to change the installation path. Press Control-C and run the same command with --help for help.
Presionamos ENTER para continuar con la instalación. Al finalizar debe devolver algo como esto:
Presionamos ENTER para continuar con la instalación. Al finalizar debe devolver algo como esto: --- We are done! --- ^ |.-. .-. .-. .-. .-. . netdata .-. .- | '-' '-' '-' '-' '-' is installed and running now! -' '-' +----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+---> enjoy real-time performance and health monitoring...
Si se desea desinstalar Netdata, para actualizarlo a una versión superior, solo debe ejecutar la siguiente línea y seguir las instrucciones:
/usr/libexec/netdata/netdata-uninstaller.sh --yes
Si durante el proceso de corrida del script ven algún error fíjense bien cual es para luego arreglarlo y volver a correr el script. Casi siempre es errores de descarga en el caso de hacerlo online o errores de nombre en el caso de hacerlo offline. Tenga siempre en cuenta que cuando corre el script usando la variante offline se borran algunas de las carpetas y ficheros que copiamos en tmp, por lo q si desean correrlo de nuevo tendrá que crearlas y mover los ficheros otra vez.
Hay que destacar que el servicio de netdata al menos en esta versión y usando el script de instalación siempre nos dará error. Puede verlo al final de la corrida del script como se intenta levantarlo sin lograrlo. Por lo que, si reiniciamos el sistema, netdata no iniciara bien. Así luce el servicio:
root@netdata:~# service netdata status * netdata.service - Real time performance monitoring Loaded: loaded (/lib/systemd/system/netdata.service; enabled; vendor preset: enabled) Active: activating (auto-restart) (Result: exit-code) since Sun 2020-12-13 14:29:05 CST; 12s ag Process: 19931 ExecStartPre=/bin/mkdir -p /var/cache/netdata (code=exited, status=226/NAMESPACE) Process: 19932 ExecStopPost=/usr/libexec/netdata/plugins.d/reset_netdata_trace.sh (code=exited, Dec 13 14:29:05 netdata systemd[1]: netdata.service: Control process exited, code=exited, status=2 Dec 13 14:29:05 netdata systemd[1]: netdata.service: Failed with result 'exit-code'. Dec 13 14:29:05 netdata systemd[1]: Failed to start Real time performance monitoring. lines 1-9/9 (END)
Por lo que para poder iniciarlo usaremos siempre su binario que se encuentra en /usr/sbin/
Para ello usaremos cron:
NOTA: El script de instalación ofrece una opción para automatizar el servicio con la ejecución del mismo al iniciar el sistema; pero en este caso lo haremos nosotros mismos.
crontab -e
Agregar lo siguiente:
########### # LEYENDA # ########### # "m": minutos (0-59) # "h": horas (0-23) # "dow": dia de la semana (0-6) # "dom": dia del mes (1-28/1-30/1-31) # "mon": mes (1-12) # "*": cualquiera # ",": separa valores dentro de la misma variable (0,5,10) # "-": define rangos dentro de la misma variable (0-5) # <m> <h> <dom> <mon> <dow> <directorio del script> ########### # NETDATA # ########### @reboot /usr/sbin/netdata
Reiniciamos el cron:
systemctl restart cron.service
Si accedemos al siguiente enlace, podremos comprobar que ya se encuentra funcionando en su configuración por defecto:
http://netdata.empresa.midominio.cu:19999
http://IPnetdata:19999
Hasta aquí, usted cuenta con un servicio de Netdata para visualizar en los “dashboard” de la web, las métricas del servidor local, sin embargo, a continuación, se explica cómo configurar una estructura master-slave. En la arquitectura master-slave, el Netdata de los servidores clientes, enviarán sus métricas al servidor de Netdata master.
Como extra les mostrare como configurar las notificaciones de alarma. Si poseen una infraestructura mala que siempre lleva al límite a sus servidores pues su correo será invadido con miles de alarmas enviadas desde sus netdatas slaves. Debido a que cuando instala sus proxmox usted define el correo del usuario root muchas veces con su propio correo pues recibirá por parte de netdata las notificaciones de alarma. Por defecto netdata envía las notificaciones a root. En /usr/lib/netdata/conf.d encontraremos todas las configuraciones por defecto de netdata. Y ya conocemos que para configurarlo usamos edit-config el cual usa el editor interno del sistema y luego mueve el fichero a /etc/netdata una vez terminado de editar
La configuración que usaremos para el tema de las notificaciones será health_alarm_notify.conf
cd /etc/netdata ./edit-config health_alarm_notify.conf
Buscamos las siguientes líneas:
# if a role recipient is not configured, an email will be sent to: DEFAULT_RECIPIENT_EMAIL="root" # to receive only critical alarms, set it to "root|critical"
Cambie el valor de DEFAULT_RECIPIENT_EMAIL a la dirección de correo electrónico en la que le gustaría recibir notificaciones.
# if a role recipient is not configured, an email will be sent to: DEFAULT_RECIPIENT_EMAIL="[email protected]" # to receive only critical alarms, set it to "root|critical"
Ahora si queremos deshabilitar por completo el envío de estas alarmas debemos modificar lo siguiente:
# enable/disable sending emails SEND_EMAIL="NO"
Esta opción esta justo encima de DEFAULT_RECIPIENT_EMAIL. También puede configurar por separado cada fichero de configuración de salud. Por ejemplo:
cd /etc/netdata ./edit-config health.d/cpu.conf
Cada archivo de configuración de salud contiene una o más entidades de salud, que siempre comienzan con alarm: o template:. Por ejemplo, aquí está la primera entidad de salud en health.d/cpu.conf:
template: 10min_cpu_usage
on: system.cpu
os: linux
hosts: *
lookup: average -10m unaligned of user,system,softirq,irq,guest
units: %
every: 1m
warn: $this > (($status >= $WARNING) ? (75) : (85))
crit: $this > (($status == $CRITICAL) ? (85) : (95))
delay: down 15m multiplier 1.5 max 1h
info: average cpu utilization for the last 10 minutes (excluding iowait, nice and steal)
to: sysadminPara ajustar esta alarma para que active las alarmas de advertencia y críticas con un uso de CPU más bajo, cambie las líneas de advertencia y crítica a los valores que elija. Por ejemplo:
warn: $this > (($status >= $WARNING) ? (60) : (75))
crit: $this > (($status == $CRITICAL) ? (75) : (85))Guarde el archivo y vuelva a cargar la configuración de salud de Netdata para que sus cambios estén activos.
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Estoy tratando de utilizar esta documentacion para instalar NETDATA en OL7. Hasta ahora he ido pasando obstaculos e incluso se ha desplegado el servicio pero sin acceso al CLOUD. por este error:
CMake Error at tests/CMakeLists.txt:42 (target_sources):
Unknown CMake command «target_sources».