Hope This Helps

Da ich es einfacher finde für die Archivierung von Webcam Bildern Videos zu verwenden habe ich diese Script geschrieben. Die Webcam erstellt ein Bild wenn Sie Bewegung wahrnimmt. Diese werden von diesem Skript zu einen einzelnen Video vereint.
Ihr müsst nur die Variablen euren Gegebenheiten anpassen.
Variablen :

{FTP-USER} = der FTP Benutzer
{FTP-GROUP} = die FTP Gruppe
{QUELL-PFAD} = quelle der Snapshots
{ZIEL-PFAD} = wo soll das Video abgelegt werden ?

Script :

#!/bin/bash
#
# Konvertiert Einzelbilder zu Video mit ffmpeg
_src_folder={QUELL-PFAD}
_src_file_format=jpg
_tar_folder={ZIEL-PFAD}
_tar_file_format=mpg
_tar_file_name="video_$(date +%Y-%m-%d_%R)"
_temp_folder=$(mktemp -d)
_length=5
_cnt_files_in_src=$(ls -l ${_src_folder}/*.${_src_file_format} 2>/dev/null | wc -l)
_ftp_user={FTP-USER}
_ftp_group={FTP-GROUP}
_bin_ffmpeg=$(which ffmpeg)
_bin_chown=$(which chown)
_bin_rm=$(which rm)
_bin_find=$(which find)
# Bilder nach konvertieren löschen ?
DELFILESAFTERVIDEO=TRUE # TRUE OR FALSE
# setze symlinks in tempfolder
cnt=1
if [ ${_cnt_files_in_src} != "0" ]; then
        if [[ -d  "${_temp_folder}" && -d "${_src_folder}" ]]; then
                for i in ${_src_folder}/*.${_src_file_format};
                do
                        ln -s "${i}" "${_temp_folder}/$(printf %0${_length}d $cnt).jpg"
                        ((cnt++))
                done
                ${_bin_ffmpeg} -f image2 -i "${_temp_folder}/%0${_length}d.jpg" -r 25 -vcodec libx264 "${_tar_folder}/${_tar_file_name}.${_tar_file_format}" > /dev/null 2>&1
                ${_bin_rm} -rf "${_temp_folder}"
                ${_bin_chown} ${_ftp_user}:${_ftp_group} "${_tar_folder}/${_tar_file_name}.${_tar_file_format}"
                # löscht alle vorhanden bilder
                if [ ${DELFILESAFTERVIDEO} == "TRUE" ]; then
                ${_bin_find} ${_src_folder}/ -name "*.${_src_file_format}" -exec ${_bin_rm} {} \;
                fi
        else
                echo "ERROR : TEMP FOLDER OR SOURCE FOLDER DO NOT EXISTS"
                exit 99
        fi
else
                echo "found no files in source exit"
                exit 99
fi

Kleines lokales Plugin für check_mk um die HAProxy Backends zu monitoren.

das Skript muss unter /usr/lib/check_mk_agent/local angelegt werden.

touch /usr/lib/check_mk_agent/local/haproxy-local.sh

Dort dann den nachfolgenden Code reinkopieren und Konfiguration anpassen.

#!/bin/bash
#
# checks haproxy
#

_awk_bin=$(which awk)
_status_url="http://localhost:9090/haproxy/"
_server_name="ha-cap-"
a=0

# $(curl -s ${_status_url}\;csv | grep "^${_server_name}" | grep -vE "(FRONTEND|BACKEND)")

for line in $(curl -s ${_status_url}\;csv | grep "^${_server_name}" | grep -vE "(FRONTEND|BACKEND)"); do
        _name=$(echo $line | ${_awk_bin} -F',' '{ print $1; }' )
        _host=$(echo $line | ${_awk_bin} -F',' '{ print $2; }' )
        _stat=$(echo $line | ${_awk_bin} -F',' '{ print $18; }')
        STATUSTXT="${_name}  ${_host}  ${_stat}"
        if [ ${_stat} == "UP" ]; then
                _check_response="0"
        else
                _check_response="2"
        fi
        if [ ${a} -lt 10 ]; then
                echo "${_check_response} BEHIND-HAPROXY-0${a} - ${STATUSTXT}"
        else
                echo "${_check_response} BEHIND-HAPROXY-${a} - ${STATUSTXT}"
        fi
        a=$((a+1))
done

Ergebnis sieht dann so aus

Natürlich muss auch der haproxy so konfiguriert sein das er die Statusseite ausliefert. Hier Auszug aus der haproxy.cfg

listen status
    bind *:9090
    mode http
    stats enable
    stats uri /haproxy
    acl localhost  src  127.0.0.1
    acl stats      path_beg  /haproxy
    http-request allow if stats localhost
    http-request deny  if stats !localhost

Es kommt immer wieder vor das die Webserver unter Volllast geraten da jemand unsere API exzessiv anfragt. Da hier alle anderen Anfragen auch mit betroffen sind ist hier ein möglicher Weg einen Apache dagegen abzusichern. In meinem Fall handelt es sich um ein Debian 9 bei anderen Linux Derivaten sollte es ähnlich funktionieren.

Distributor ID:	Debian
Description:	Debian GNU/Linux 9.5 (stretch)
Release:	9.5
Codename:	stretch

Erstmal installieren wir die benötigten Packete

apt install libapache2-mod-qos fail2ban

Dann machen wir die Konfiguration für mod_qos

vi /etc/apache2/conf-available/mod_qos.conf

dort tragen wir erstmal eine Grundkonfiguration ein

## QoS Settings
<IfModule mod_qos.c>
    # Gleichzeitige Verbindungen von 100000 IP Adressen zulassen 
    QS_ClientEntries 100000
    # maximal 20 Verbindungen pro IP Adresse
    QS_SrvMaxConnPerIP 20
    # maximale Anzahl der aktiven TCP Verbindungen hier 256
    MaxClients              256
    # QS_SrvMaxConnClose <Nummer> [%] definiert die maximale Anzahl der gleichzeitigen TCP-Verbindungen,
    # bis der Server Keep-Alive für diesen Server deaktiviert (die Verbindung wird nach jeder Anforderung geschlossen. 
    # Sie können die Anzahl der Verbindungen als Prozentsatz von MaxClients angeben, wenn Sie das Suffix hinzufügen '%' auf den angegebenen Wert.
    QS_SrvMaxConnClose      70%
    # minimum request/response speed (https://de.wikipedia.org/wiki/Slowloris Schutz):
    QS_SrvMinDataRate       150 1200
    # QS_SrvMinDataRate <bytes pro seconds> [<max bytes pro second> [<connections>]], definiert den minimalen Upload / Download-Durchsatz
    # QS_SrvMaxConnExcludeIP <addr>
    # QS_SrvMaxConnExcludeIP 192.168.x.xxx
    #
    # Quelle : https://www.mankier.com/1/mod_qos
</IfModule>

Jetzt geben wir noch die Statusseite für qos frei damit wir auch sehen was hier so passiert.

<Location /qos>
   SetHandler qos-viewer
   Require ip [Eigene IP Adresse oder IP Range (CIDR)]
   # z.B. Require ip 127.0.0.1
</Location>

Jetzt aktivieren wir noch das Modul und die Konfiguration

a2enmod qos
a2enconf mod_qos

dann der obligatorische Neustart des Apaches

systemctl restart apache2

nun kann man den ersten Test durchführen, von einem anderen Rechner die IP Adresse des Servers über das Apache Benchmark Tool einfach mal anfragen mit diesen Werten

ab -n 1500 -c 100 http://[IP des Webservers]/index.html

im Errorlog des Apaches sollten jetzt solche Meldungen erscheinen

[xxx] [:error] [xxx] mod_qos(034): access denied, QS_SrvMinDataRate rule (in): min=354, this connection=26, c=192.168.x.xxx
[xxx] [:error] [xxx] mod_qos(031): access denied, QS_SrvMaxConnPerIP rule: max=50, concurrent connections=51, c=192.168.x.xxx

Dann machen wir mit fail2ban weiter

vi /etc/fail2ban/jail.d/http-requests.conf

dort fügen wir diesen Inhalt ein

[http-requests]
enabled = true
port = http,https
filter = http-requests
logpath = /var/log/apache2/access.log
# maxretry bedeutet wieviele GET / POST wir im Log finden bevor wir die IP sperren
maxretry = 30
# findtime ist die Zeitperiode in der wir GET/POST zählen (10 Sekunden)
findtime = 10
# Wielange wird die IP gebannt in Sekunden (600 Sekunden = 10 Minuten)
bantime = 600
action = iptables[name=HTTP, port=http, protocol=tcp]

den Filter dazu erstellen

vi /etc/fail2ban/filter.d/http-requests.conf

und dort diesen Inhalt rein

# Fail2Ban configuration file
# http-requests.conf
#
[Definition]
# failregex = es wird gegen GET/POST im Logfile gematched
failregex = ^<HOST> -.*"(GET|POST).*
# ignoreregex = 
ignoreregex =

ein neustart von fail2ban aktiviert die Config

systemctl restart fail2ban

Jetzt kann wieder mit dem Apache Benchmark Tool getestet werden, bevor wir allerdings das Benchmark Tool von einem anderen Rechner aus starten öffnen wir lokal das Logfile von fail2ban damit wir sehen was passiert.

tail -f /var/log/fail2ban.log

jetzt den Benchmark starten wie oben angegeben. Im Log sollten jetzt solche Meldungen erscheinen

2018-07-20 00:25:27,998 fail2ban.filter         [6203]: INFO    [http-requests] Found 192.168.x.xxx
2018-07-20 00:25:27,998 fail2ban.filter         [6203]: INFO    [http-requests] Found 192.168.x.xxx
2018-07-20 00:25:28,096 fail2ban.actions        [6203]: NOTICE  [http-requests] 192.168.x.xxx already banned
2018-07-20 00:25:29,098 fail2ban.actions        [6203]: NOTICE  [http-requests] 192.168.x.xxx already banned

In fail2ban kann man sich jetzt den Status anzeigen lassen

root@ddev-01: fail2ban-client status http-requests
Status for the jail: http-requests
|- Filter
|  |- Currently failed:	1
|  |- Total failed:	1629
|  `- File list:	/var/log/apache2/access.log
`- Actions
   |- Currently banned:	1
   |- Total banned:	2
   `- Banned IP list:	192.168.x.xxx

möchte man die IP wieder entsperren genügt ein

fail2ban-client set http-requests unbanip 192.168.x.xxx

wenn eine bestimmte IP oder eine IP Range freigegeben werden muss ist das in der jail.conf zu erledigen

vi /etc/fail2ban/jail.conf

dort nach ignoreip = suchen und die eigene IP hinzufügen

Quellen :
http://mod-qos.sourceforge.net/#variables
https://de.wikipedia.org/wiki/Slowloris
https://www.fail2ban.org/wiki/index.php/Main_Page
https://sourceforge.net/p/mod-qos/discussion/
http://mod-qos.sourceforge.net/#statusviewer
http://mod-qos.sourceforge.net/glossary.html
http://mod-qos.sourceforge.net/dos.html

Problem : In manchen Fällen bekommt man Dateien von Kunden geschickt die irgendein unbekanntes encoding enthalten. mit recode und iconv kam in meinem Fall auch nur Mist raus.

Lösung :
Die Datei mit vim öffnen und das encoding auf utf8 festnageln.

set fenc=utf8

dann können die unbekannten Zeichen ersetzt werden. Hier ein paar Beispiele.

:%s#\%x86#Ü#g
:%s#\%x9f#ü#g
:%s#\%x8a#ä#g
:%s#\%x9a#ö#g
:%s#§#ß#g

erstmal für alle die mosquitto nicht kennen das ist es : mosquitto.org

erstmal installieren wir alles was wir benötigen

sudo apt install mosquitto mosquitto-clients

nach der Installation aus den Debian Paketen liegt ein funktionierendes mosquitto auf der Platte nur ist es nicht sicher konfiguriert. Um es noch ein bisschen mehr abzusichern sollte man an den Configfiles etwas schrauben.

Hier ist meine mosquitto.conf diese liegt unter /etc/mosquitto/

pid_file /var/run/mosquitto.pid
persistence true
persistence_location /var/lib/mosquitto/
persistent_client_expiration 7d
connection_messages true
log_dest syslog
log_timestamp false
log_type error
log_type warning
log_type notice
log_type information
port 1883
max_connections -1
allow_anonymous false
use_identity_as_username false
password_file /etc/mosquitto/users
acl_file /etc/mosquitto/roles
include_dir /etc/mosquitto/conf.d

Als erstes legen wir einen Benutzer für mosquitto an.

touch /etc/mosquitto/users ; mosquitto_passwd /etc/mosquitto/users BENUTZERNAME

Jetzt brauchen wir die Rechte der User

touch /etc/mosquitto/roles ; vi /etc/mosquitto/roles

Hier ein Vorschlag für die roles, der Benutzer monitor hat alle rechte während der Benutzer clmon nur schreiben darf.

user monitor
topic write /mqtt/#
topic read /mqtt/#

user clmon
topic write /mqtt/#

Zum testen der konfig bieten sich die beiden tools mosquitto_sub und mosquitto_pub an.

Subscribe

mosquitto_sub -u USERNAME -P PASSWORD -t "/mqtt/#"

Publish

mosquitto_pub -h localhost -u USERNAME -P PASSWORD -t "/mqtt/test/" -m "TESTNACHRICHT"

Quelle : Mosquitto Dokumentation

erstmal was ist Influx db eigentlich : Influxdb

Um eine InfluxDB absichern zu können muss als erstes ein Benutzer mit Admin Rechten angelegt werden, BEVOR man Auth aktiviert.

Anlegen eines Admin Users :

CREATE USER admin WITH PASSWORD 'SECUREPASSWORD' WITH ALL PRIVILEGES

Überprüfen / Anzeigen der User geht mit dem Befehl :

SHOW USERS

bzw für die Rechte

SHOW GRANTS FOR admin

Jetzt muss die Authentifizierung aktiviert werden. Dazu muss die Konfiguration unter /etc/influx/influx.conf angepasst werden.
Hier mal der entscheidende Block (Ohne Kommentare)

[http]
   enabled = true
   bind-address = ":8086"
   auth-enabled = true
   access-log-path = "/var/log/influxdb/access.log"
   write-tracing = false
   pprof-enabled = false
   https-enabled = false
   https-certificate = "/etc/ssl/influxdb.pem"

Ab jetzt könnt ihr euch mit dem folgenden Befehl verbinden

influx -username admin -password SECUREPASSWORD -database DATABASENAME

was auch funktioniert ist mit dem Befehl

influx

die cli starten und dann mit dem Befehl

auth

die Authentifizierung einleiten.


Weitere Standardbefehle

InfluxDB Datenbanken anzeigen :

SHOW DATABASES

InfluxDB Datenbank anlegen :

CREATE DATABASE "DATABASENAME"

InfluxDB User anlegen :

CREATE USER dev WITH PASSWORD 'SECUREPASSWORD'

InfluxDB Rechte vergeben auf Datenbank :

GRANT (READ,WRITE,ALL) ON DATABASENAME TO dev

Quelle : InfluxDB 1.5 documentation