.LNX-WORLD

Streiten sich drei Männer, welches wohl das beste Betriebssystem für Männer sei.
Sagt der Erste:
“Echte Männer arbeiten mit Windows und lassen die PS/2 den Kindern zum spielen!”
Darauf hin der Zweite:
“Echte Männer arbeiten mit Linux und lassen den Windows PC den Kindern zum spielen!”
“Alles Quatsch,” sagt der Dritte, “echte Männer spielen mit ihren KINDERN und lassen den MAC für sich arbeiten!!!”

Kommentar: Manchmal sprechen Witze die Wahrheit….

Wie man per Konsole einen neuen Benutzer in der MySQL anlegen kann, hatte ich schon beschrieben. Leider darf dieser User von sich aus so nichts. Ganz nebenbei fehlt ja auch die Datenbank in der beispielsweise das WordPress laufen soll…
Also legen wir nun eine Datenbank an und geben unserem Benutzer im gleichem Arbeitsgang volle Rechte auf diese Datenbank:

$ mysql -p -u root
CREATE DATABASE data-base;
USE data-base;
GRANT ALL ON data-base .* TO db-user@localhost IDENTIFIED BY 'PASSWORD_CHANGE_ME';
FLUSH PRIVILEGES;
exit;

Sieht einfach aus, ist es auch…

Zuerst der Login als Benutzer Root mit Kennwort (mysql -p -u root). Nach der Eingabe des Root Kennwortes (das für MySQL, nicht unbedingt das für die Konsole) folgt auch schon das MySQL Kommando zum erstellen der Datenbank, in diesem Fall “DATA-BASE” (CREATE DATABASE data-base;). Da die Rechte für diese Datenbank auch gleich angepasst werden sollen, wechselt man nun erstmal in diese Datenbank (USE data-base;) – nun werden die vollen Zugriffsrechte gesetzt (GRANT ALL ON data-base .* TO db-user@localhost IDENTIFIED BY ‘PASSWORD_CHANGE_ME’;) welcher das Kennwort “PASSWORD_CHANGE_ME” hat und sich nur von localhost aus anmelden darf (@localhost) wenn er Zugriff auf diese Datenbank haben möchte. Abschließend die Rechte noch “updaten” (FLUSH PRIVILEGES;) und die MySQL Konsole verlassen (exit;).

Wenn man einen Linux basierten Server auf einen anderen sichern möchte, kann man dies relativ leicht per rsync erledigen. Leider kam es bei mir in der letzten Zeit häufiger mal vor, das ich nicht die Sicherung des letzten Tages brauchte, sondern eine die ein paar Tage zurück lag – was ich bei meiner Sicherung nicht vorgesehen hatte…
Aber man lernt ja nie aus und so schrieb ich das nachfolgende Script, mit welchem vom Zielserver aus der Quellserver gesichert wird und diese Sicherung in “Tagesverzeichnisse” ablegt, also eine Sicherung je Tag in ein gesondertes Verzeichnis.
Ein kleines Feedback per Mail an mich durfte natürlich auch nicht fehlen!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#!/bin/bash
# set +x
# ACHTUNG!!! DAS SCRIPT MUSS ALS ROOT LAUFEN!!!
# ACHTUNG!!! AUTHORIZED KEYS SIND ERFORDERLICH!!!!
 
##############################
# Variablendefinitionen
##############################
RECIPIENTS="maik@lnx-world.de"
HOST=$1
MAIL=/tmp/rsyncmail_$HOST
TMPLOG=/tmp/rsynclog_$HOST
LOGFILE=/var/log/rsync.log
NOW=`/bin/date`
DOW=`/bin/date +"%A"`
BACKUPSERVER=$1
BACKUPDIR=/
TARGETDIR=/var/backup/$HOST/$DOW/
E1=/proc
E2=/tmp
E3=/lost+found
OPTIONS="-az -e ssh --force --stats --numeric-ids --ignore-errors --delete-after --delete-excluded --exclude=$E1 --exclude=$E2 --exclude=$E3"
 
##############################
# Funktionsdefinitionen
##############################
make_mail()
{
        printf "Subject: LNX-WORLD RSYNC REPORT for $HOST - $NOW\n" >> $MAIL
        printf "#########################################\n" >> $MAIL
        printf "# SCRIPTSTATUS: $SCRIPTSTATE\n" >> $MAIL
        printf "#########################################\n" >> $MAIL
        printf "\n\n" >> $MAIL
        printf "#########################################\n" >> $MAIL
        printf "# Script wurde mit folgenden Parametern gestartet:\n" >> $MAIL
        printf "#########################################\n" >> $MAIL
        printf "BACKUPSERVER   = $BACKUPSERVER \n" >> $MAIL
        printf "BACKUPDIR      = $BACKUPDIR \n" >> $MAIL
        printf "TARGETDIR      = $TARGETDIR \n" >> $MAIL
        printf "EXCLUDES       = $E1 $E2 $E3 \n" >> $MAIL
        printf "NOW            = $NOW \n" >> $MAIL
        printf "DOW            = $DOW \n" >> $MAIL
        printf "#########################################\n" >> $MAIL
        printf "# RSYNC Output:\n" >> $MAIL
        printf "#########################################\n" >> $MAIL
        /bin/cat $TMPLOG >> $MAIL
}
 
do_rsync()
{
        /usr/bin/rsync $OPTIONS $HOST:$BACKUPDIR $TARGETDIR >> $TMPLOG
        RSYNCSTATE=$?
        if [ $RSYNCSTATE -eq 0 ]; then
                SCRIPTSTATE=OK
                echo "$NOW JOB: $HOST erfolgreich gesynct" >> $LOGFILE
        else
                SCRIPTSTATE=ERROR
                echo "$NOW JOB: $HOST NICHT erfolgreich gesynct" >> $LOGFILE
        fi
}
 
check_directorys()
{
        echo "$NOW JOB: $HOST Starte RSYNC Backup"  >> $LOGFILE
        if [ ! -d /var/backup ]
        then
           echo "$NOW JOB: $HOST ERROR - Backupdirectory nicht da! EXITING" >> $LOGFILE
           exit 1
        fi
 
        if [ ! -d /var/backup/$HOST ]
        then
                mkdir /var/backup/$HOST
                echo "$NOW JOB: $HOST /var/backup/$HOST/ angelegt" >> $LOGFILE
        else
                echo "$NOW JOB: $HOST /var/backup/$HOST/ ist schon da" >> $LOGFILE
        fi
 
        if [ ! -d /var/backup/$HOST/$DOW ]
        then
           mkdir /var/backup/$HOST/$DOW
           echo "$NOW JOB: $HOST /var/backup/$HOST/$DOW angelegt" >> $LOGFILE
        else
                echo "$NOW JOB: $HOST /var/backup/$HOST/$DOW ist schon da" >> $LOGFILE
        fi
}
 
# Zuerst einmal aufräumen!
/bin/rm $MAIL
/bin/rm $TMPLOG
check_directorys
do_rsync
make_mail
cat $MAIL | sendmail -r tagessicherung@lnx-world.de -t $RECIPIENTS

Die “Features” des Scriptes sind also:

• Sicherung von Server A in ein Backupverzeichnis auf Server B
• 7 Sicherungen liegen auf Vorrat
• Verzeichnisse werden bei Bedarf vom Script selbst angelegt
• Der Backupprozess wird in ein Logfile geschrieben und dort erfasst
• Es wird am Ende des Backuplaufes eine Reportmail an einen (oder mehrere) E-Mailempfänger versendet
• Die Sicherung erfolgt über eine mit SSH verschlüsselte Verbindung
• Es werden keine Sicherungsagenten auf dem Quellserver benötigt
• Das Script kostet nichts und ist absolut frei verfügbar

P.S.
Wer mein kleines Script bei sich einsetzt schreibe mir bitte ein kleines Feedback als Kommentar, danke!
Desweiteren kann die Liste der obigen Excludes frei ergänzt werden, gerade bei Datenbanken wäre es sinnvoll hier die Datenverzeichnisse der Datenbanken zu excluden und vor dem Scriptlauf per Dump ein sauberes Sicherungsfile zu erstellen! Wenn die Excludes erweitert werden, tragt bitte die zusätzlichen E-Nummern auch in den $OPTIONS nach, sonst werden die nicht übernommen!

Ziel
Um die Zugriffe auf die Festplatte/Flashkarte zu minimieren, soll das Log-Verzeichnis /var/log beim Starten in den RAM geschrieben werden.
Beim ausschalten und reboot muss mit der HD syncronisiert werden. Weiter muss es möglich sein in bestimmten Abständen und auch manuell bzw. per Script zu syncronisieren.

Mit tmpfs lässt sich das alles recht komfortabel umsetzen.

Vorbereitung

Kernel

Im Kernel muss FS Unterstützung im RAM aktiviert sein.

Symbol: TMPFS

Location:
-> File Systems
   -> Pseudo Filesystems

Sync-Verzeichnis

Man muss ein Verzeichnis anlegen, in dass syncronisiert wird und aus dem beim Systemstart die Dateien in den RAM geladen werden.

mkdir /var/log.hd

fstab

Diese Zeile hinzufügen:

tmpfs    /var/log    tmpfs    size=100M    0 0

Wir mounten damit /var/log in einen reservierten Bereich des Arbeitsspeichers.

init-Scipt

Folgendes Script unter /etc/init.d/varlogfs speichern:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/bin/sh
 
PATH=/bin:/usr/bin:/sbin:/usr/sbin
TMPFS_DIR="/var/log/"
HDD_DIR="/var/log.hd/"
 
case $1 in
        start)
                echo "sync hdd to tmpfs.."
                /bin/cp -Rpv $HDD_DIR* $TMPFS_DIR
                echo "done."
                ;;
        sync)
                echo "sync tmpfs to hdd.."
                /bin/cp -Rpv $TMPFS_DIR* $HDD_DIR
                echo "done."
                ;;
        stop)
                echo "sync tmpfs to hdd.."
                /bin/cp -Rpv $TMPFS_DIR* $HDD_DIR
                echo "done."
                ;;
        *)
                echo $"usage: $0 {start|sync|stop}"
                exit 1
                ;;
esac
 
exit 0

Das init-Script sollte logischerweise vor allen Diensten gestartet werden, die nach /var/log schreiben. Außerdem muss es beim Herunterfahren am Schluss ausgeführt werden, um das das Dateisystem zu syncronisieren.

ln -s /etc/init.d/varlogfs /etc/rc2.d/S9varlogfs
ln -s /etc/init.d/varlogfs /etc/rc3.d/S9varlogfs
ln -s /etc/init.d/varlogfs /etc/rc5.d/S9varlogfs
ln -s /etc/init.d/varlogfs /etc/rc0.d/K99varlogfs
ln -s /etc/init.d/varlogfs /etc/rc1.d/K99varlogfs
ln -s /etc/init.d/varlogfs /etc/rc6.d/K99varlogfs

Unter Debian geht auch:

update-rc.d varlogfs defaults 9 99

Beim nächsten Neustart ist das Log-Verzeichnis im Arbeitsspeicher.

Manuell syncronisieren kann man mit:

/etc/init.d/varlogfs sync

Seit neuestem ersparen ich mir den täglichen Login auf meine Linuxserver um nach Updates zu schauen. Ich lasse mich direkt von den Servern per Mail über anstehende Updates informieren!

Welche der drei von mir hier vorgestellten Möglichkeiten ich selbst benutze, hängt allein davon ab, wer informiert werden soll (ich selbst will natürlich immer alles wissen ;) )

Möglichkeit EINS:

Im leider geschlossenem Sysop Forum fand ich folgende Lösung, Welche eine schöne Mail verfasst, wenn denn Updates anliegen. In der Mail wird man noch informiert, welche Packageversionen aktuell installiert sind und welche Version in den eingetragenen Repositorys gefunden wurde.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/bin/bash
#
# (c)opyright 2005-2007 Thomas Lavis
#
clear
 
#
# Empfänger hier eingeben
#
 
eMailEmpfaenger="name@deinedomain.tld"
 
# Ausgabe für Script auf international setzen
 
TMPLANG=`echo $LANG`
LANG=C
 
if [[ `apt-get update 2>&1 | grep Get` ]] ;  then
  Updates=`apt-get -s dist-upgrade 2>&1 | grep Inst | wc -l`
    if [ $Updates -ne 0 ] ; then
        LANG=$TMPLANG
        echo "Für die folgenden Pakete gibt es ein Update:" > aptnachricht
        echo "" >> aptnachricht
        echo "" >> aptnachricht
        apt-get -s dist-upgrade | grep Inst | cut -c 6- >> aptnachricht
        mutt -s "Ergebnis von aptcheck auf Server: `hostname`" $eMailEmpfaenger < aptnachricht
        rm aptnachricht
    fi
fi

Möglichkeit ZWEI:

Ich weiß nicht mehr genau wo, aber folgende Lösung sendet einfach nur eine Mail wenn es Updates gibt, welche einen über die generelle Verfügbarkeit von Updates informiert, also keine weiteren Details zu den Packages enthält, welche zu updaten sind :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/bin/bash
EMAIL="root"
SUBJECT="[`hostname`] Update Hinweis"
MESSAGE="SYSTEMMELDUNG:\nAuf `hostname` sind neue Updates vorhanden"    
 
# Dieses Script versendet eine eMail, sobald Online-Updates fuer das System
# verfuegbar sind. Das Script ist Public Domain, der Autor uebernimmt keine
# Haftung fuer das Script.    
 
# Debian
apt-get update &>/dev/null
COUNT=`apt-get -s upgrade | grep -c "Inst"`    
 
if [ $COUNT -gt 0 ]
  then
  echo -e "$MESSAGE" | mail -s "$SUBJECT" "$EMAIL"
fi

Möglichkeit DREI:

Gefunden im Blog von Björn Böttcher - Einfach als Eintrag in die Crontab über nachfolgende Zeile via

crontab -e

und da:

1

@daily aptitude update; aptitude -d -y dist-upgrade) | mail -s “Debian OS Updates -> `hostname`” deinname@deinedomain.tld

Die einfachste Möglichkeit die ich bisher gefunden habe! Reicht in den meisten Fällen schon völlig aus und stellt auch die Puristen unter uns zufrieden!

Use the force - root

--- Updated on 12.12.2008 ---