monitor snmp graphs

Fuente: https://www.zabbix.com/documentation/2.0/manual/installation/install_from_packages#debian_ubuntu
Nos descargamos el paquete de configuración:

http://repo.zabbix.com/zabbix/2.0/debian/pool/main/z/zabbix-release/zabbix-release_2.0-1squeeze_all.deb

Y lo instalamos:

dpkg -i zabbix-release_2.0-1squeeze_all.deb 

Esto crea la siguiente entrada en los repositorios:

/etc/apt/sources.list.d/zabbix.list

deb http://repo.zabbix.com/zabbix/2.0/debian squeeze main
deb-src http://repo.zabbix.com/zabbix/2.0/debian squeeze main

NOTA ahora mismo el paquete 'zabbix-server-mysql' de los repositorios oficials de Debian se queda colgado

1. (monitor-1.dev.jj.com) Anyadir al sources list el repositorio de http://guruhub.com.uy:

sudo su
echo "deb http://repo.guruhub.com.uy/debian/ squeeze main" >/etc/apt/sources.list.d/guruhub-squeeze.list

2. Anyadir sus claves. A mi no me funciono, me sigue dando un warning:

wget -q -O - http://repo.guruhub.com.uy/guruhub.apt.gpg | sudo apt-key add -

3. Actualizar e instalar el paquete (probablemente dara un warning):

sudo aptitude update; sudo aptitude install zabbix-server-mysql

Indicar que se quiere instalar la base de datos en local, y asignarle un usuario y una contrasenya. Luego haremos unos cambios para apuntar a 'mysql-1.dev.jj.com'.

Quiza haya que reconfigurar el paquete:

sudo dpkg-reconfigure zabbix-server-mysql

4. Para el servidor zabbix:

sudo /etc/init.d/zabbix-server stop

5. Hacer un volcado de la base de datos (el nombre se especifica en el paso 3, asumo que es 'zabbix'):

sudo mysqldump --add-drop-table -e zabbix > /tmp/zabbix_dump.sql -u mi_usuario -p

Le anyadimos que use la base de datos zabbix:

sudo vim /tmp/zabbix_dump.sql

Teclear al inicio:

use zabbix;

6. Copiar el volcado a la base de datos (mysql-1.dev.jj.com en el ejemplo):

scp /tmp/zabbix_dump.sql mysql-1.dev.jj.com:/tmp/

7. Desinstalar mysql server y dependencias:

sudo aptitude remove mysql-server libhtml-template-perl mysql-server mysql-server-5.1 mysql-server-core-5.1

http://www.zabbix.com/documentation/2.0/manual/installation/install

1. Descargar

http://www.zabbix.com/download.php

2. Descomprimir

tar xvfz zabbix-2.0.2.tar.gz

3. (Opcional) Instalar dependencias

sudo aptitude update; sudo aptitude install build-essential libmysqlclient-dev libcurl4-openssl-dev libsnmp-dev snmp-mibs-downloader

4. Crear usuario y grupo:

sudo groupadd zabbix; sudo useradd -g zabbix zabbix

5. Configurar

cd /ruta/zabbix-2.0.2
./configure --enable-server --enable-agent --with-mysql --with-net-snmp --with-libcurl

6. Instalar

sudo make install

7. Crear el script de arranque:

sudo ln -s /ruta/zabbix-2.0.2/misc/init.d/debian/zabbix-server /etc/init.d/

8. Editar el archivo de configuracion (importante ajustar entre otros los valores de la conexion a la BD):

sudo vim /usr/local/etc/zabbix_server.conf

9. Arrancar

sudo /etc/init.d/zabbix-server restart

https://www.zabbix.com/documentation/2.0/manual/appendix/install/db_scripts

1. (mysql-1.dev.jj.com) Instalar mysql server:

sudo aptitude update; sudo aptitude install mysql-server

2. Crear la base de datos:

mysql -u root -p
create database zabbix;

3. Crear el usuario 'zabbix' que se conectara tanto desde el servidor Zabbix como desde el frontend web. En este caso le permito que se conecte desde maquinas cuyo nombre coincida con el patron '%.dev.jj.com':

grant usage on *.* to 'zabbix'@'%.dev.jj.com' identified by 'contrasenya';
grant all on zabbix.* to 'zabbix'@'%.dev.jj.com';
flush privileges;

4. Permito conectividad desde todas las maquinas (se puede hacer mas restrictivo si se quiere):

sudo cp /etc/mysql/my.cnf /etc/mysql/my.cnf.old
sudo vim /etc/mysql/my.cnf

Y anyado/edito la siguiente linea:

bind-address            = 0.0.0.0

5. Ingesta inicial del volcado de la base de datos del servidor Zabbix:

mysql -u root -p < /tmp/zabbix_dump.sql

5.1 Si lo hemos instalado de la versión oficial, ejecutamos el volcado de los ficheros de:

/usr/local/bin/zabbix-2.0.6/database/mysql

En el siguiente orden:

mysql zabbix -u zabbix -p < schema.sql
mysql zabbix -u zabbix -p < images.sql
mysql zabbix -u zabbix -p < data.sql

6. Reinicio la base de datos:

sudo /etc/init.d/mysql restart

7. (monitor-1.dev.jj.com) Ajusto la configuracion del servidor Zabbix para que apunte a la basae de datos:

sudo cp /etc/zabbix/zabbix_server.conf /etc/zabbix/zabbix_server.conf.old
sudo vim /etc/zabbix/zabbix_server.conf

Y anyado/edito las siguientes lineas:

DBHost=mysql-1.dev.jj.com
DBName=zabbix
DBUser=zabbix
DBPassword=contrasenya

8. Reinicio el servidor Zabbix y le echo un vistazo a los logs a ver si todo va bien:

sudo /etc/init.d/zabbix-agent restart
sudo tail -F /var/log/zabbix-server/zabbix_server.log

1. Repetir los pasos 1. y 2. del Servidor Zabbix (Compilar fuentes)

2. Crear un enlace simbólico del Document Root de Apache (asumimos '/var/www') al directorio 'frontends/php':

cd /srv/www; sudo ln -s cd /ruta/zabbix-2.0.5/frontends/php zabbix
sudo chown -R www-data:www-data *

3. Ajustar la configuración de la Base de Datos:

cd /srv/www/zabbix/conf; sudo cp zabbix.conf.php.example zabbix.conf.php
sudo vim zabbix.conf.php

Con el siguiente contenido:

$DB["SERVER"]    = "mysql-1.dev.jj.com";
$DB["DATABASE"]  = "zabbix";
$DB["USER"]      = "zabbix";
$DB["PASSWORD"]  = "contrasenya";
$ZBX_SERVER      = "monitor.dev.jj.com";

4. Deberiamos poder acceder (usuario 'Admin', contrasenya 'zabbix') al frontend web:

http://www-1.dev.jj.com/zabbix

1. Repetir los pasos 1. y 2. del Servidor Zabbix

2. Actualizar e instalar el paquete (probablemente dara un warning):

sudo aptitude update; sudo aptitude install zabbix-frontend-php

3. Editar el archivo de configuracion para indicar servidor Zabbix y de bases de datos:

sudo cp /etc/zabbix/dbconfig.php /etc/zabbix/dbconfig.php.old
sudo vim /etc/zabbix/dbconfig.php

Anyadir/editar las siguientes lineas:

$DB["SERVER"]    = "mysql-1.dev.jj.com";
$DB["DATABASE"]  = "zabbix";
$DB["USER"]      = "zabbix";
$DB["PASSWORD"]  = "contrasenya";
$ZBX_SERVER      = "monitor.dev.jj.com";

4. Deberiamos poder acceder (usuario 'Admin', contrasenya 'zabbix') al frontend web:

http://www-1.dev.jj.com/zabbix

Es similar a un agente SNMP. Para instalar

1. Repetir los pasos 1. y 2. del Servidor Zabbix

2. Actualizar e instalar el paquete (probablemente dara un warning):

sudo aptitude update; sudo aptitude install zabbix-agent

3. Para arrancar/para… el servicio:

/etc/init.d/zabbix_agentd {start|stop|restart|force-reload}

Esta receta es para Ubuntu server.

Resumen de maquinas:

1. Instalar

sudo aptitude install zabbix-proxy-mysql

Te pregunta usuario y contrasenya de MySQL etc…

2. Editar config:

sudo vim /etc/zabbix/zabbix_proxy.conf

Yo ajuste los siguientes valores:

IMPORTANTE Por defecto esta configurado en modo activo, es decir, proxy.dominio.com se conecta de vez en cuando a zabbix.dominio.com y le pregunta si hay alguna peticion que hacer. En caso de que la haya, proxy.dominio.com las hara y devolvera el resultado, a traves del puerto TCP 10051, a zabbix.dominio.com

3. Arrancar (si no lo estuviera ya):

sudo /etc/init.d/zabbix-proxy restart
sudo tail -F /var/log/zabbix-proxy/zabbix_proxy.log

Resumen de maquinas:

1. (Opcional) Permitir conexiones entre zabbix.dominio.com y proxy.dominio.com a traves del puerto TCP 10051. Ejemplo:

$IPTABLES -A INPUT -d $KVM_LAN_IP -s proxy.dominio.com -i $EXT_IF -p tcp --dport 10051 -j ACCEPT

http://linuxhacks.in/2013/08/zabbix-database-backup.html#.U1-ynt1yvg4

#!/bin/bash
#
# lh_zabbix_backup.sh
# v1.0 – 20130710
#
# Configuration Backup for Zabbix 2 w/MySQL
#
# Original Author: Ricardo Santos (rsantos at gmail.com) http://zabbixzone.com
#
#Modified by Suyash Jain ( me at suyashjain.com) http://linuxhacks.in

#The purpose of this script is to take the backup of zabbix server database.
#The concept behind writing this script is that #zabbix database grows up on day to day bases
#and it become very tedious to take the backup with mysqldump or other #available tools ,
#<strong>so we required an custom script which will take the backup of entire schema/structure and the
#important/configuration data only.</strong>

#Zabbix History/alerts and their are many other tables which grows rapidly.
#So we will not backup their data , only the #zabbix configrations.
#The script is based on zabbix 2.x database schema , or older schema you must check the table
#names and change them accordingly.

# mysql config
DBHOST="localhost"
DBNAME="database"
DBUSER="username"
DBPASS="password"

# some tools
MYSQLDUMP="`which mysqldump`"
GZIP="`which gzip`"
DATEBIN="`which date`"
MKDIRBIN="`which mkdir`"

# target path
MAINDIR="/opt/zabbix-backup/"
DUMPFILE="${MAINDIR}/`${DATEBIN} +%Y%m%d%H%M`"
${MKDIRBIN} -p ${MAINDIR}

# configuration tables
CONFTABLES=( actions applications autoreg_host conditions config dchecks dhosts drules dservices escalations expressions \
functions globalmacro globalvars graph_discovery graph_theme graphs graphs_items groups help_items \
host_inventory hostmacro hosts hosts_groups hosts_templates housekeeper httpstep httpstepitem \
httptest httptestitem icon_map icon_mapping ids images interface item_discovery items items_applications \
maintenances maintenances_groups maintenances_hosts maintenances_windows mappings media media_type \
node_cksum nodes opcommand opcommand_grp opcommand_hst opconditions operations opgroup opmessage \
opmessage_grp opmessage_usr optemplate profiles proxy_autoreg_host proxy_dhistory proxy_history \
regexps rights screens screens_items scripts service_alarms services services_links services_times \
sessions slides slideshows sysmap_element_url sysmap_url sysmaps sysmaps_elements sysmaps_link_triggers \
sysmaps_links timeperiods trigger_depends trigger_discovery triggers user_history users users_groups usrgrp valuemaps )

# tables with large data
DATATABLES=( acknowledges alerts auditlog_details auditlog events \
history history_log history_str history_str_sync history_sync history_text \
history_uint history_uint_sync trends trends_uint )

# CONFTABLES
for table in ${CONFTABLES[*]}; do
echo "Backuping table ${table}"
${MYSQLDUMP} -R –opt –extended-insert=FALSE \
-h ${DBHOST} -u ${DBUSER} -p${DBPASS} ${DBNAME} –tables ${table} >>${DUMPFILE}
done

# DATATABLES
for table in ${DATATABLES[*]}; do
echo "Backuping schema table ${table}"
${MYSQLDUMP} -R –opt –no-data \
-h ${DBHOST} -u ${DBUSER} -p${DBPASS} ${DBNAME} –tables ${table} >>${DUMPFILE}
done

echo
echo "Backup Completed – ${DUMPFILE}"

http://zabbixzone.com/zabbix/mysql-performance-tips-for-zabbix/

http://dev.mysql.com/doc/refman/5.5/en/innodb-multiple-tablespaces.html

https://www.zabbix.org/wiki/Docs/howto/mysql_partition

1. Habilitar file per table

http://dev.mysql.com/doc/refman/5.5/en/innodb-multiple-tablespaces.html

2. Cambiar indices (puede ser lento y bloquear inserts):

mysql -u zabbix2014 -p
use zabbix2014;
Alter table history_text drop primary key, add index (id), drop index history_text_2, add index history_text_2 itemid, id);
Alter table history_log drop primary key, add index (id), drop index history_log_2, add index history_log_2 (itemid, id);

3. Crear procedures:

DELIMITER $$
CREATE PROCEDURE `partition_create`(SCHEMANAME VARCHAR(64), TABLENAME VARCHAR(64), PARTITIONNAME VARCHAR(64), CLOCK INT)
BEGIN
        /*
           SCHEMANAME = The DB schema in which to make changes
           TABLENAME = The table with partitions to potentially delete
           PARTITIONNAME = The name of the partition to create
        */
        /*
           Verify that the partition does not already exist
        */
 
        DECLARE RETROWS INT;
        SELECT COUNT(1) INTO RETROWS
        FROM information_schema.partitions
        WHERE table_schema = SCHEMANAME AND TABLE_NAME = TABLENAME AND partition_description >= CLOCK;
 
        IF RETROWS = 0 THEN
                /*
                   1. Print a message indicating that a partition was created.
                   2. Create the SQL to create the partition.
                   3. Execute the SQL from #2.
                */
                SELECT CONCAT( "partition_create(", SCHEMANAME, ",", TABLENAME, ",", PARTITIONNAME, ",", CLOCK, ")" ) AS msg;
                SET @SQL = CONCAT( 'ALTER TABLE ', SCHEMANAME, '.', TABLENAME, ' ADD PARTITION (PARTITION ', PARTITIONNAME, ' VALUES LESS THAN (', CLOCK, '));' );
                PREPARE STMT FROM @SQL;
                EXECUTE STMT;
                DEALLOCATE PREPARE STMT;
        END IF;
END$$
DELIMITER ;

DELIMITER $$
CREATE PROCEDURE `partition_drop`(SCHEMANAME VARCHAR(64), TABLENAME VARCHAR(64), DELETE_BELOW_PARTITION_DATE BIGINT)
BEGIN
        /*
           SCHEMANAME = The DB schema in which to make changes
           TABLENAME = The table with partitions to potentially delete
           DELETE_BELOW_PARTITION_DATE = Delete any partitions with names that are dates older than this one (yyyy-mm-dd)
        */
        DECLARE done INT DEFAULT FALSE;
        DECLARE drop_part_name VARCHAR(16);
 
        /*
           Get a list of all the partitions that are older than the date
           in DELETE_BELOW_PARTITION_DATE.  All partitions are prefixed with
           a "p", so use SUBSTRING TO get rid of that character.
        */
        DECLARE myCursor CURSOR FOR
                SELECT partition_name
                FROM information_schema.partitions
                WHERE table_schema = SCHEMANAME AND TABLE_NAME = TABLENAME AND CAST(SUBSTRING(partition_name FROM 2) AS UNSIGNED) < DELETE_BELOW_PARTITION_DATE;
        DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
 
        /*
           Create the basics for when we need to drop the partition.  Also, create
           @drop_partitions to hold a comma-delimited list of all partitions that
           should be deleted.
        */
        SET @alter_header = CONCAT("ALTER TABLE ", SCHEMANAME, ".", TABLENAME, " DROP PARTITION ");
        SET @drop_partitions = "";
 
        /*
           Start looping through all the partitions that are too old.
        */
        OPEN myCursor;
        read_loop: LOOP
                FETCH myCursor INTO drop_part_name;
                IF done THEN
                        LEAVE read_loop;
                END IF;
                SET @drop_partitions = IF(@drop_partitions = "", drop_part_name, CONCAT(@drop_partitions, ",", drop_part_name));
        END LOOP;
        IF @drop_partitions != "" THEN
                /*
                   1. Build the SQL to drop all the necessary partitions.
                   2. Run the SQL to drop the partitions.
                   3. Print out the table partitions that were deleted.
                */
                SET @full_sql = CONCAT(@alter_header, @drop_partitions, ";");
                PREPARE STMT FROM @full_sql;
                EXECUTE STMT;
                DEALLOCATE PREPARE STMT;
 
                SELECT CONCAT(SCHEMANAME, ".", TABLENAME) AS `table`, @drop_partitions AS `partitions_deleted`;
        ELSE
                /*
                   No partitions are being deleted, so print out "N/A" (Not applicable) to indicate
                   that no changes were made.
                */
                SELECT CONCAT(SCHEMANAME, ".", TABLENAME) AS `table`, "N/A" AS `partitions_deleted`;
        END IF;
END$$
DELIMITER ;

DELIMITER $$
CREATE PROCEDURE `partition_maintenance`(SCHEMA_NAME VARCHAR(32), TABLE_NAME VARCHAR(32), KEEP_DATA_DAYS INT, HOURLY_INTERVAL INT, CREATE_NEXT_INTERVALS INT)
BEGIN
        DECLARE OLDER_THAN_PARTITION_DATE VARCHAR(16);
        DECLARE PARTITION_NAME VARCHAR(16);
        DECLARE LESS_THAN_TIMESTAMP INT;
        DECLARE CUR_TIME INT;
 
        CALL partition_verify(SCHEMA_NAME, TABLE_NAME, HOURLY_INTERVAL);
        SET CUR_TIME = UNIX_TIMESTAMP(DATE_FORMAT(NOW(), '%Y-%m-%d 00:00:00'));
 
        SET @__interval = 1;
        create_loop: LOOP
                IF @__interval > CREATE_NEXT_INTERVALS THEN
                        LEAVE create_loop;
                END IF;
 
                SET LESS_THAN_TIMESTAMP = CUR_TIME + (HOURLY_INTERVAL * @__interval * 3600);
                SET PARTITION_NAME = FROM_UNIXTIME(CUR_TIME + HOURLY_INTERVAL * (@__interval - 1) * 3600, 'p%Y%m%d%H00');
                CALL partition_create(SCHEMA_NAME, TABLE_NAME, PARTITION_NAME, LESS_THAN_TIMESTAMP);
                SET @__interval=@__interval+1;
        END LOOP;
 
        SET OLDER_THAN_PARTITION_DATE=DATE_FORMAT(DATE_SUB(NOW(), INTERVAL KEEP_DATA_DAYS DAY), '%Y%m%d0000');
        CALL partition_drop(SCHEMA_NAME, TABLE_NAME, OLDER_THAN_PARTITION_DATE);
 
END$$
DELIMITER ;

DELIMITER $$
CREATE PROCEDURE `partition_verify`(SCHEMANAME VARCHAR(64), TABLENAME VARCHAR(64), HOURLYINTERVAL INT(11))
BEGIN
        DECLARE PARTITION_NAME VARCHAR(16);
        DECLARE RETROWS INT(11);
        DECLARE FUTURE_TIMESTAMP TIMESTAMP;
 
        /*
         * Check if any partitions exist for the given SCHEMANAME.TABLENAME.
         */
        SELECT COUNT(1) INTO RETROWS
        FROM information_schema.partitions
        WHERE table_schema = SCHEMANAME AND TABLE_NAME = TABLENAME AND partition_name IS NULL;
 
        /*
         * If partitions do not exist, go ahead and partition the table
         */
        IF RETROWS = 1 THEN
                /*
                 * Take the current date at 00:00:00 and add HOURLYINTERVAL to it.  This is the timestamp below which we will store values.
                 * We begin partitioning based on the beginning of a day.  This is because we don't want to generate a random partition
                 * that won't necessarily fall in line with the desired partition naming (ie: if the hour interval is 24 hours, we could
                 * end up creating a partition now named "p201403270600" when all other partitions will be like "p201403280000").
                 */
                SET FUTURE_TIMESTAMP = TIMESTAMPADD(HOUR, HOURLYINTERVAL, CONCAT(CURDATE(), " ", '00:00:00'));
                SET PARTITION_NAME = DATE_FORMAT(CURDATE(), 'p%Y%m%d%H00');
 
                -- Create the partitioning query
                SET @__PARTITION_SQL = CONCAT("ALTER TABLE ", SCHEMANAME, ".", TABLENAME, " PARTITION BY RANGE(`clock`)");
                SET @__PARTITION_SQL = CONCAT(@__PARTITION_SQL, "(PARTITION ", PARTITION_NAME, " VALUES LESS THAN (", UNIX_TIMESTAMP(FUTURE_TIMESTAMP), "));");
 
                -- Run the partitioning query
                PREPARE STMT FROM @__PARTITION_SQL;
                EXECUTE STMT;
                DEALLOCATE PREPARE STMT;
        END IF;
END$$
DELIMITER ;

Este ultimo los gobierna todos, por tanto hay que seleccionar los valores que se adapte a nuestras necesidades:

DELIMITER $$
CREATE PROCEDURE `partition_maintenance_all`(SCHEMA_NAME VARCHAR(32))
BEGIN
                CALL partition_maintenance(SCHEMA_NAME, 'history', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_log', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_str', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_text', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_uint', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'trends', 730, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'trends_uint', 730, 24, 14);
END$$
DELIMITER ;

4. Dar permisos de ejecucion al ultimo procedimiento. Vamos a dar al mismo usuario que puede leer la base de datos de zabbix:

GRANT EXECUTE ON PROCEDURE zabbix2014.partition_maintenance_all TO 'zabbix2014'@'localhost';
flush privileges;
exit;

5. Creamos archivo para poder iniciar sesion mysql sin contrasenya:

vim ~/.my.cnf

Con el siguiente contenido:

[client]
user=zabbix2014
password=zabbix2014

Ajustamos permisos:

chmod 0600 ~/.my.cnf

6. Creamos un script para ser llamado desde cron:

sudo vim /opt/partition_maintenance_all.sh

Con el siguiente contenido (ajustar variables):

#!/bin/bash

LOG="/var/log/"`basename $0`".log"
STRING_START="START of the script:"
STRING_END="END of the script:"
MYSQL_USER="zabbix2014"
MYSQL_DB=$MYSQL_USER
MYSQL_PROCEDURE="partition_maintenance_all"

[[ ! $LOG ]]; touch $LOG
DATE="$(date +%d/%m/%Y) $(date +%H:%M:%S)"

echo -e "\n################### $STRING_START $DATE ##################"  >> $LOG

#mysql -u $MYSQL_USER -e "CALL partition_maintenance_all('zabbix2014')\G" zabbix2014 >> $LOG 2>&1
#mysql -u $MYSQL_USER -e "CALL partition_maintenance_all('"$MYSQL_DB"')\G" $MYSQL_DB >> $LOG 2>&1
mysql -u $MYSQL_USER -e "CALL "$MYSQL_PROCEDURE"('"$MYSQL_DB"')\G" $MYSQL_DB >> $LOG 2>&1

DATE="$(date +%d/%m/%Y) $(date +%H:%M:%S)"

echo -e "\n################### $STRING_END $DATE ##################"  >> $LOG

Ajustamos permisos y logs:

sudo chown usuario:usuario /opt/partition_maintenance_all.sh
chmod +x /opt/partition_maintenance_all.sh
sudo touch /var/log/partition_maintenance_all.sh.log
sudo chown root:usuario /var/log/partition_maintenance_all.sh.log
chmod 660 /var/log/partition_maintenance_all.sh.log

Y anyadimos la entrada a cron, para ser ejecutada, por ejemplo, cada dia:

13 4 * * * /opt/partition_maintenance_all.sh >> /var/log/partition_maintenance_all.sh.log 2>&1

Recargar la cache (util para recargar la configuracion sin reiniciar el demonio):

sudo zabbix_server -R config_cache_reload

Obtener un valor de una maquina con el cliente zabbix instalado:

zabbix_get -s www-1.dev -k system.cpu.load

http://www.zabbix.com/forum/showthread.php?t=26503

http://code.google.com/p/mysql-cacti-templates/source/browse/trunk/scripts/ss_get_mysql_stats.php?r=543

http://87.110.183.172/forum/showthread.php?t=20211 http://www.zabbix.com/forum/showthread.php?t=25551

Requisitos:

En este ejemplo:

Cliente

1. Editar:

/etc/zabbix/zabbix_agentd.conf

Y anyadir/editar las lineas:

EnableRemoteCommands=1
Hostname=test-5.dev.jj.com.dev.jj.com
ListenPort=10050
ServerActive=monitor.dev.jj.com

2. Reiniciar el servicio:

sudo /etc/init.d/zabbix-agent restart

Item

En este caso lo he creado a pelo sobre el 'Host', pero lo suyo es crear un 'Template'

Trigger

Buscamos la cadena 'ERROR':

Action

En este caso generica, pero se puede personalizar:

• Trigger que se ejecuta solo en un determinado lapso de tiempo (solo de 05:00:00 a 05:01:10):

https://www.zabbix.com/documentation/2.0/manual/config/notifications/media/script

1. Crear un script:

sudo vim /opt/zabbix_email.sh

Con el siguiente contenido:

#!/bin/bash
 
to=$1
subject=$2
body=$3
 
cat <<EOF | mail -s "$subject" "$to"
$body
EOF

2. Dar permisos:

sudo chgrp zabbix /opt/zabbix_email.sh
sudo chmod 0775 /opt/zabbix_email.sh

3. Editar el archivo de configuracion:

sudo cp /etc/zabbix/zabbix_server.conf /etc/zabbix/zabbix_server.conf.bak
sudo vim /etc/zabbix/zabbix_server.conf

Y escribir la siguiente linea:

AlertScriptsPath=/opt

4. Recargar la cache de configuracion:

sudo service zabbix-server force-reload 

5. (Interfaz web) Iniciar sesion con un usuario con permisos de administracion

6. Ir a “Administration / Media types”

7. Pulsar sobre el boton “Create media type”

8. Dejar los valores asi:

Pulsar el boton “Save”.

9. Comprobar que todo ha ido bien:

9.1. Ir a “Administration / Users”

9.2. Seleccionar un usuario cualquiera

9.3. Pulsar en la solapa “Media”

9.4. Pulsar en el enlace “Add”

9.5.Dejar los valores asi:

Pulsar el boton “Add”

1. Cuando activo/desactivo alguna 'Discovery rule' tengo que recargar la cache de la configuracion en el servidor

ssh monitor.dev.jj.com
sudo zabbix_server -R config_cache_reload

Usar este en lugar del que provee zabbix:

/etc/init.d/zabbix_agentd

#!/bin/sh

#
# Zabbix agent start/stop script.
#
# Copyright (C) 2000-2012 Zabbix SIA
# Added status) parameter by Jamgo S.C.C.L.

NAME=zabbix_agentd
DAEMON=/usr/sbin/${NAME}
DESC="Zabbix agent daemon"
PID=/var/run/zabbix/$NAME.pid
LOG=/var/log/zabbix/$NAME.log

# Include LSB funcions
. /lib/lsb/init-functions

test -f $DAEMON || exit 0

case "$1" in
  start)
        echo "Starting $DESC: $NAME"
        start-stop-daemon --start --oknodo --pidfile $PID --exec $DAEMON
        ;;
  stop)
        echo "Stopping $DESC: $NAME"
        start-stop-daemon --stop --quiet --pidfile $PID --retry=TERM/10/KILL/5 && return 0
        start-stop-daemon --stop --oknodo --exec $DAEMON --name $NAME --retry=TERM/10/KILL/5
        ;;
  restart|force-reload)
        $0 stop
        $0 start
        ;;
  status)
        status_of_proc -p $PID "$DAEMON" $NAME
        ;;
  *)
        N=/etc/init.d/$NAME
        echo "Usage: $N {start|stop|restart|force-reload}" >&2
        exit 1
        ;;
esac

exit 0

IMPORTANTE Hay que crear cuentas primero con el mismo 'uid' que el usuario en LDAP.

Ver:

ZBXNEXT-276

ZBXNEXT-1138

ZBXNEXT-1390

1. Hacer login con el superusuario 'admin'

2. Crear otro superusuario con el mismo usuario y contrasenya que un usuario LDAP ya existente

2.1. Ir a 'Administration/Users'

2.2. En el desplegable seleccionar 'Users' y pulsar sobre el boton “Create user”

2.3. Rellenar los campos “Alias” (sera el nombre de usuario) y el de “Password” con el mismo usuario y contrasenya que un usuario LDAP ya existente

2.4. En la pestanya “Permissions” nos aseguramos que este seleccionado “Zabbix Super Admin”

2.5. Pulsamos el boton “Save”

3. Hacemos un logout

4. Hacemos un login con las nuevas credenciales recien creadas en el paso 2.

5. Vamos a “Administration/Authentication”, y pulsamos sobre el boton “LDAP”

6. Ejemplo de config con LDAPS:

STRING:

ldaps://ldap.example.com

El campo “Login” esta en gris, y es el valor del usuario con el que hemos hecho login

7. Pulsar sobre el boton “Save”. Si ha ido bien, podemos revertir la autenticacion a local, hacer login como superusuario “admin”, quitarle los permisos de superusuario al usuario creado en el paso 2, y repetir de nuevo todo el proceso. (No lo he probado)